1N Identification
==============================

In order to avoid loading the same collection into memory multiple times (which becomes an issue when the collection sizes become very large),
instances of the SDK created within the same process will share the same collection in memory (RAM). This means when you enroll a template into the collection
using one instance of the SDK, it will be available in all other instances of the SDK in the same process.
For this same reason, applications which have multiple instances of the SDK in a single process only need to call ``createDatabaseConnection`` and ``createLoadCollection``
on a single instance of the SDK and all other instances will automatically be connected to the same database and collection.

The PostgreSQL backend option also has built in synchronization across multiple processes.
Let's take an example where you have two processes on different machines, A and B, connected to the same PostgreSQL backend.
Each of these processes will initially connect to the same database and collection and therefore load all the templates from the database into memory (RAM).
If process A then enrolls a template into the collection, this will both add the template to the in-memory (RAM) collection of process A and will update the PostgreSQL database.
In doing so, it will also automatically push out a notification to all the subscribed processes which are connected to the same database and collection.
Any process connected to the same database and collection is automatically subscribed to updates, no additional action is required from the developer.
Process B will therefore receive a notification that an update was made and will therefore automatically enroll the same template into its in-memory (RAM) collection.
Process A and B therefore have synchronized collections in memory. Note, it can take up to 30 seconds for subscribed processes to receive the notification.

This sort of multi-process synchronization is not supported by the sqlite backend. With the sqlite backend, if process A makes a change to the database,
process B will not know of the changes. Process B must re-call ``createLoadCollection`` in order to register the changes that were made to the database from process A.
Note doing so will not perform an incremental update, but will instead discard then re-load all the data into memory, which can be slow if the collection size is large.
This is why it is advised to use the sqlite backend option only for use cases which involve only a single process connecting to the database.
If multiple processes need to connect to a database (and require synchronization), it is advised to use the PostgreSQL backend.


.. doxygenfunction:: Trueface::SDK::createDatabaseConnection

.. doxygenfunction:: Trueface::SDK::createLoadCollection

.. doxygenfunction:: Trueface::SDK::enrollTemplate

.. doxygenfunction:: Trueface::SDK::removeByUUID

.. doxygenfunction:: Trueface::SDK::removeByIdentity

.. doxygenfunction:: Trueface::SDK::identifyTopCandidate

.. doxygenfunction:: Trueface::SDK::batchIdentifyTopCandidate

.. doxygenfunction:: Trueface::SDK::identifyTopCandidates

.. doxygenstruct:: Trueface::Candidate
   :members: