PrintTemplate.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Export.h"
#include "enrollment/HashUtils.h"
#include "enrollment/Print/EmbeddingTemplate.h"
#include "enrollment/Print/ICSTemplate.h"
#include "enrollment/Serialization/Writer.h"
#include <algorithm>
#include <vector>
 
namespace inno
{
     */
    class PrintTemplate : public Serializable
    {
    public:
         */
        static std::vector<std::shared_ptr<ICSTemplate>> ToICSTemplates(
          const std::vector<std::shared_ptr<PrintTemplate>>& templates)
        {
            std::vector<std::shared_ptr<ICSTemplate>> icsTemplates(templates.size());
            std::transform(templates.begin(),
                           templates.end(),
                           icsTemplates.begin(),
                           [](const auto& pt) { return pt != nullptr ? pt->GetICSRepresentation() : nullptr; });
            return icsTemplates;
        }
         */
        static std::vector<std::shared_ptr<EmbeddingTemplate>> ToEmbeddingTemplates(
          const std::vector<std::shared_ptr<PrintTemplate>>& templates)
        {
            std::vector<std::shared_ptr<EmbeddingTemplate>> embeddings(templates.size());
            std::transform(templates.begin(),
                           templates.end(),
                           embeddings.begin(),
                           [](const auto& pt) { return pt != nullptr ? pt->GetEmbeddingRepresentation() : nullptr; });
            return embeddings;
        }
         */
        [[nodiscard]] std::shared_ptr<ICSTemplate> GetICSRepresentation() const
        {
            return t;
        }

         */
        [[nodiscard]] std::shared_ptr<EmbeddingTemplate> GetEmbeddingRepresentation() const
        {
            return e;
        }

         */
        [[nodiscard]] bool HasIcsRepresentation() const
        {
            return t != nullptr;
        }

         */
        [[nodiscard]] bool HasEmbeddingRepresentation() const
        {
            return e != nullptr;
        }

         */
        void WriteTo(Writer& writer) const final
        {
            writer.Write("ics", t);
            writer.Write("e", e);
        }

         */
        explicit PrintTemplate(std::shared_ptr<ICSTemplate> icsTemplate)
          : t(std::move(icsTemplate))
        {
            if (t == nullptr)
            {
                throw NullArgumentException("ICSTemplate cannot be null");
            }
        }

         */
        PrintTemplate(std::shared_ptr<ICSTemplate> icsTemplate, std::shared_ptr<EmbeddingTemplate> embedding)
          : t(std::move(icsTemplate))
          , e(std::move(embedding))
        {
            if (t == nullptr)
            {
                throw NullArgumentException("ICSTemplate cannot be null");
            }
            if (e == nullptr)
            {
                throw NullArgumentException("Embedding cannot be null");
            }
 
            if (!ArePositionsSame(t, e))
            {
                throw EnrollmentInvalidArgumentException("ICSTemplate and embedding have different position");
            }
        }

         */
        explicit PrintTemplate(std::shared_ptr<EmbeddingTemplate> embedding)
          : t(nullptr)
          , e(std::move(embedding))
        {
            if (e == nullptr)
            {
                throw NullArgumentException("Embedding cannot be null");
            }
        }
 
        [[nodiscard]] bool operator==(const PrintTemplate& other) const noexcept
        {
            auto icsEqual = (t == nullptr && other.t == nullptr) ||
                            (t != nullptr && other.t != nullptr && t->icsTemplateData == other.t->icsTemplateData);
            auto embEqual = (e == nullptr && other.e == nullptr) ||
                            (e != nullptr && other.e != nullptr &&
                             e->embeddingTemplateData == other.e->embeddingTemplateData);
            return icsEqual && embEqual;
        }
 
        [[nodiscard]] std::size_t Hash() const noexcept
        {
            std::size_t h = t != nullptr ? detail::HashBytes(t->icsTemplateData) : 0U;
            h = detail::HashCombine(h, e != nullptr ? detail::HashBytes(e->embeddingTemplateData) : 0U);
            return h;
        }
 
        PrintTemplate() = delete;
        virtual ~PrintTemplate() = default;
        PrintTemplate(const PrintTemplate& ap) = default;
        PrintTemplate(PrintTemplate&& ap) = default;
        PrintTemplate& operator=(const PrintTemplate& ap) = default;
        PrintTemplate& operator=(PrintTemplate&& ap) = default;
 
    private:
        std::shared_ptr<ICSTemplate> t;
        std::shared_ptr<EmbeddingTemplate> e;
 
        static bool ArePositionsSame(const std::shared_ptr<ICSTemplate>& i, const std::shared_ptr<EmbeddingTemplate>& e)
        {
            if (!i->IsICSTemplateBiometricPositionKnown() || !e->IsEmbeddingTemplateBiometricPositionKnown())
            {
                // one of position is unknown. When both have unknown position then they are same, otherwise they are
                // different.
                return i->IsICSTemplateBiometricPositionKnown() == e->IsEmbeddingTemplateBiometricPositionKnown();
            }
            // Both have known position.
            if (i->GetICSTemplateBiometricPosition() == e->GetEmbeddingTemplateBiometricPosition())
            {
                // both have same known position
                return true;
            }
 
            return false;
        }
    };
} // namespace inno