EmbeddingTemplate.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Export.h"
#include "enrollment/Print/EmbeddingMatcher.h"
#include "enrollment/Print/PrintAttributes/PrintPosition.h"
#include "enrollment/Print/PrintExecutor.h"
#include "enrollment/Serialization/Writer.h"
#include <vector>
 
// cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes: This is not a
// problem because we are using them only as read only.
// cppcoreguidelines-avoid-const-or-ref-data-members: We design te API with const member variables instead of
// implementing getter methods. This is nicely transformed in C# to properties. Usually our objects are immutable by
// intention to have no problem in multithreaded applications.
// NOLINTBEGIN(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes,cppcoreguidelines-avoid-const-or-ref-data-members)
namespace inno
{
     */
    class EmbeddingTemplate : public Serializable
    {
    public:
        const std::vector<uint8_t> embeddingTemplateData;

         */
        [[nodiscard]] PrintSimilarityScore SimilarWith(const EmbeddingTemplate& tmpl,
                                                       const EmbeddingMatcher& matcher) const
        {
            return matcher.Match(*this, tmpl);
        }

         */
        [[nodiscard]] bool IsEmbeddingTemplateBiometricPositionKnown() const
        {
            return pos.has_value();
        }

         */
        [[nodiscard]] PrintPosition GetEmbeddingTemplateBiometricPosition() const
        {
            if (!pos.has_value())
            {
                throw EnrollmentRuntimeException("EmbeddingTemplate has unknown biometric position");
            }
 
            return pos.value();
        }

         */
        [[nodiscard]] std::string GetVersion() const
        {
 
            uint32_t ifingerVersion = 0;
            uint32_t enrollmentVersion = 0;
            exec->IFingerGetTemplateVersion(&ifingerVersion,
                                            &enrollmentVersion,
                                            embeddingTemplateData.data(),
                                            static_cast<uint32_t>(embeddingTemplateData.size()),
                                            ThrowOnError{});
 
            return std::to_string(ifingerVersion) + "." + std::to_string(enrollmentVersion);
        }

         */
        explicit EmbeddingTemplate(std::vector<uint8_t>&& d)
          : embeddingTemplateData(std::move(d))
          , exec(GlobalPrintExecutor::Get())
        {
            if (embeddingTemplateData.empty())
            {
                throw InvalidTemplateException("Embedding template MUST have data");
            }
        }

         */
        explicit EmbeddingTemplate(const std::vector<uint8_t>& d)
          : embeddingTemplateData(d)
          , exec(GlobalPrintExecutor::Get())
        {
            if (embeddingTemplateData.empty())
            {
                throw InvalidTemplateException("Embedding template MUST have data");
            }
        }

         */
        EmbeddingTemplate(std::vector<uint8_t>&& d, std::shared_ptr<PrintExecutor> executor)
          : embeddingTemplateData(std::move(d))
          , exec(std::move(executor))
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
            if (embeddingTemplateData.empty())
            {
                throw InvalidTemplateException("Embedding template MUST have data");
            }
        }

         */
        EmbeddingTemplate(const std::vector<uint8_t>& d, std::shared_ptr<PrintExecutor> executor)
          : embeddingTemplateData(d)
          , exec(std::move(executor))
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
            if (embeddingTemplateData.empty())
            {
                throw InvalidTemplateException("Embedding template MUST have data");
            }
        }

         */
        explicit EmbeddingTemplate(std::vector<uint8_t>&& d, PrintPosition position)
          : embeddingTemplateData(std::move(d))
          , exec(GlobalPrintExecutor::Get())
          , pos(position)
        {
            if (embeddingTemplateData.empty())
            {
                throw InvalidTemplateException("Embedding template MUST have data");
            }
        }

         */
        explicit EmbeddingTemplate(const std::vector<uint8_t>& d, PrintPosition position)
          : embeddingTemplateData(d)
          , exec(GlobalPrintExecutor::Get())
          , pos(position)
        {
            if (embeddingTemplateData.empty())
            {
                throw InvalidTemplateException("Embedding template MUST have data");
            }
        }

         */
        EmbeddingTemplate(std::vector<uint8_t>&& d, PrintPosition position, std::shared_ptr<PrintExecutor> executor)
          : embeddingTemplateData(std::move(d))
          , exec(std::move(executor))
          , pos(position)
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
            if (embeddingTemplateData.empty())
            {
                throw InvalidTemplateException("Embedding template MUST have data");
            }
        }

         */
        EmbeddingTemplate(const std::vector<uint8_t>& d,
                          PrintPosition position,
                          std::shared_ptr<PrintExecutor> executor)
          : embeddingTemplateData(d)
          , exec(std::move(executor))
          , pos(position)
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
            if (embeddingTemplateData.empty())
            {
                throw InvalidTemplateException("Embedding template MUST have data");
            }
        }
 
        void WriteTo(Writer& w) const override
        {
            w.WriteArray("d", embeddingTemplateData);
        }
 
        EmbeddingTemplate(const EmbeddingTemplate&) = delete;
        EmbeddingTemplate(EmbeddingTemplate&&) = delete;
        EmbeddingTemplate& operator=(const EmbeddingTemplate&) = delete;
        EmbeddingTemplate& operator=(EmbeddingTemplate&&) = delete;
        EmbeddingTemplate() = delete;
        virtual ~EmbeddingTemplate() = default;
 
    private:
        std::shared_ptr<PrintExecutor> exec;
        std::optional<PrintPosition> pos;
    };
} // namespace inno
// NOLINTEND(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes,cppcoreguidelines-avoid-const-or-ref-data-members)