ISOCCTemplateAdapter.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Print/ANSITemplate.h"
#include "enrollment/Print/ExtractedPrint.h"
#include "enrollment/Print/ICSTemplate.h"
#include "enrollment/Print/ILOSIDTemplate.h"
#include "enrollment/Print/ISOCCTemplate.h"
#include "enrollment/Print/ISONCTemplate.h"
#include "enrollment/Print/ISOTemplate.h"
#include "enrollment/Print/ISOTemplateAdapter.h"
#include "enrollment/Print/PrintExecutor.h"
#include "enrollment/Print/PrintTemplate.h"
#include <climits>
#include <optional>
 
namespace inno
{
 
    class ISOCCTemplateAdapter
    {
    public:
        /// Defines sort order of minutiae points in ISO CC template
        enum class MinutiaSortOrder : uint8_t
        {
            NONE = 0,
            X_ASC = 1,
            X_DESC = 2,
            Y_ASC = 3,
            Y_DESC = 4
        };

         */
        [[nodiscard]] ISOCCTemplate Adapt(const ANSITemplate& tmpl) const
        {
            return ConvertFrom(PrintExecutor::INNO_ANSI_TEMPLATE, tmpl.data, tmpl);
        }
         */
        [[nodiscard]] ISOCCTemplate Adapt(const ILOSIDTemplate& tmpl) const
        {
            return ConvertFrom(PrintExecutor::INNO_ILO_SID_TEMPLATE, tmpl.GetData(), tmpl);
        }
         */
        [[nodiscard]] ISOCCTemplate Adapt(const ISONCTemplate& tmpl) const
        {
            return ConvertFrom(PrintExecutor::INNO_ISO_NC_TEMPLATE, tmpl.GetData(), tmpl);
        }
         */
        [[nodiscard]] ISOCCTemplate Adapt(const ISOCCTemplate& tmpl) const
        {
            if (!maxMinutiaeCount.has_value())
            {
                return tmpl;
            }
            return ConvertFrom(PrintExecutor::INNO_ISO_CC_TEMPLATE, tmpl.GetData(), tmpl);
        }
         */
        [[nodiscard]] ISOCCTemplate Adapt(const ISOTemplate& tmpl) const
        {
            return ConvertFrom(PrintExecutor::INNO_ISO_TEMPLATE, tmpl.data, tmpl);
        }
         */
        [[nodiscard]] ISOCCTemplate Adapt(const ICSTemplate& tmpl) const
        {
            return ConvertFrom(PrintExecutor::INNO_TT_UNKNOWN_TYPE, tmpl.icsTemplateData, tmpl);
        }
         */
        [[nodiscard]] ISOCCTemplate Adapt(const ExtractedPrint& tmpl) const
        {
            return ConvertFrom(PrintExecutor::INNO_TT_UNKNOWN_TYPE, tmpl.icsTemplateData, tmpl);
        }
         */
        [[nodiscard]] ISOCCTemplate Adapt(const PrintTemplate& tmpl) const
        {
            return ConvertFrom(PrintExecutor::INNO_TT_UNKNOWN_TYPE, tmpl.GetICSRepresentation()->icsTemplateData, tmpl);
        }

         */
        ISOCCTemplateAdapter()
          : exec(GlobalPrintExecutor::Get())
        {
        }
         */
        ISOCCTemplateAdapter(int maximumMinutiaeCount,
                             MinutiaSortOrder primarySortOrder,
                             MinutiaSortOrder secondarySortOrder)
          : exec(GlobalPrintExecutor::Get())
          , primaryOrder(primarySortOrder)
          , secondaryOrder(secondarySortOrder)
          , maxMinutiaeCount(maximumMinutiaeCount)
        {
        }
         */
        explicit ISOCCTemplateAdapter(std::shared_ptr<PrintExecutor> executor)
          : exec(std::move(executor))
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("Print executor cannot be null in ISOCCTemplateAdapter");
            }
        }

         */
        ISOCCTemplateAdapter(std::shared_ptr<PrintExecutor> executor,
                             int maximumMinutiaeCount,
                             MinutiaSortOrder primarySortOrder,
                             MinutiaSortOrder secondarySortOrder)
          : exec(std::move(executor))
          , primaryOrder(primarySortOrder)
          , secondaryOrder(secondarySortOrder)
          , maxMinutiaeCount(maximumMinutiaeCount)
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("Print executor cannot be null in ISOCCTemplateAdapter");
            }
        }
 
    private:
        std::shared_ptr<PrintExecutor> exec;
        std::optional<MinutiaSortOrder> primaryOrder;
        std::optional<MinutiaSortOrder> secondaryOrder;
        std::optional<int> maxMinutiaeCount;
 
        template<typename TemplateType>
        [[nodiscard]] ISOCCTemplate ConvertFrom(uint8_t templateType,
                                                const std::vector<uint8_t>& input,
                                                const TemplateType& tmpl) const
        {
            if (maxMinutiaeCount.has_value())
            {
                const ISOTemplateAdapter isoAdapter(ISOTemplateAdapter::Version::VERSION_2);
                auto iso = isoAdapter.Adapt(tmpl);
                auto limitedIsoccData = LimitIsoTemplate(iso.data);
                return ISOCCTemplate(std::move(limitedIsoccData));
            }
 
            return ISOCCTemplate(ConvertData(templateType, input));
        }
 
        [[nodiscard]] std::vector<uint8_t> ConvertData(uint8_t templateType, const std::vector<uint8_t>& input) const
        {
            std::vector<uint8_t> data;
            auto tmplAllocator = +[](void* container, size_t length) -> uint8_t*
            {
                // It is "safe" cast because we forward pointer to vector created in "user cpp space"
                // (the space where this header is compiled) and the "own cpp space" (out compiled shared library)
                // wil provide it back for us to the same "user cpp space". We have all spaces under control.
                // It is used to do not have unecessary copy data from "own cpp space" into "user cpp space".
                std::vector<uint8_t>& vec = *static_cast<std::vector<uint8_t>*>(container);
                vec.resize(length);
                return vec.data();
            };
            exec->ConvertTemplates(templateType,
                                   input.data(),
                                   input.size(),
                                   PrintExecutor::INNO_ISO_CC_TEMPLATE,
                                   tmplAllocator,
                                   &data,
                                   ThrowOnError{});
 
            return data;
        }
 
        [[nodiscard]] std::vector<uint8_t> LimitIsoTemplate(const std::vector<uint8_t>& input) const
        {
            std::vector<uint8_t> data;
            auto tmplAllocator = +[](void* container, size_t length) -> uint8_t*
            {
                // It is "safe" cast because we forward pointer to vector created in "user cpp space"
                // (the space where this header is compiled) and the "own cpp space" (out compiled shared library)
                // wil provide it back for us to the same "user cpp space". We have all spaces under control.
                // It is used to do not have unecessary copy data from "own cpp space" into "user cpp space".
                std::vector<uint8_t>& vec = *static_cast<std::vector<uint8_t>*>(container);
                vec.resize(length);
                return vec.data();
            };
 
            exec->ConvertIsoToIsoCCTemplate(
              input.data(),
              input.size(),
              maxMinutiaeCount.value_or(INT_MAX),
              static_cast<uint8_t>(primaryOrder.value_or(ISOCCTemplateAdapter::MinutiaSortOrder::NONE)),
              static_cast<uint8_t>(secondaryOrder.value_or(ISOCCTemplateAdapter::MinutiaSortOrder::NONE)),
              tmplAllocator,
              &data,
              ThrowOnError{});
 
            return data;
        }
    };
} // namespace inno