ISOTemplateAdapter.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/PrintExecutor.h"
#include "enrollment/Print/PrintTemplate.h"
 
namespace inno
{
 
    class ISOTemplateAdapter
    {
    public:
        /// ISO template version.
        enum class Version : uint8_t
        {
            VERSION_2 = 0,
            VERSION_3 = 1
        };

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

         */
        explicit ISOTemplateAdapter(Version version)
          : exec(GlobalPrintExecutor::Get())
          , ver(version)
        {
        }
         */
        explicit ISOTemplateAdapter(Version version, std::shared_ptr<PrintExecutor> executor)
          : exec(std::move(executor))
          , ver(version)
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("Print executor cannot be null in ISOTemplateAdapter");
            }
        }
 
    private:
        std::shared_ptr<PrintExecutor> exec;
        Version ver;
 
        [[nodiscard]] ISOTemplate ConvertFrom(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(),
                                   ver == Version::VERSION_2 ? PrintExecutor::INNO_ISO_TEMPLATE
                                                             : PrintExecutor::INNO_ISO_TEMPLATE_V30,
                                   tmplAllocator,
                                   &data,
                                   ThrowOnError{});
 
            return ISOTemplate(std::move(data));
        }
    };
} // namespace inno