ANSITemplateAdapter.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 ANSITemplateAdapter
    {
    public:
         */
        [[nodiscard]] ANSITemplate Adapt(const ISONCTemplate& tmpl) const
        {
            return ConvertFrom(PrintExecutor::INNO_ISO_NC_TEMPLATE, tmpl.GetData());
        }
         */
        [[nodiscard]] ANSITemplate Adapt(const ILOSIDTemplate& tmpl) const
        {
            return ConvertFrom(PrintExecutor::INNO_ILO_SID_TEMPLATE, tmpl.GetData());
        }
         */
        [[nodiscard]] ANSITemplate Adapt(const ISOCCTemplate& tmpl) const
        {
            return ConvertFrom(PrintExecutor::INNO_ISO_CC_TEMPLATE, tmpl.GetData());
        }
         */
        [[nodiscard]] ANSITemplate Adapt(const ISOTemplate& tmpl) const
        {
            return ConvertFrom(PrintExecutor::INNO_ISO_TEMPLATE, tmpl.data);
        }
         */
        [[nodiscard]] ANSITemplate Adapt(const ICSTemplate& tmpl) const
        {
            return ConvertFrom(PrintExecutor::INNO_TT_UNKNOWN_TYPE, tmpl.icsTemplateData);
        }
         */
        [[nodiscard]] ANSITemplate Adapt(const ExtractedPrint& tmpl) const
        {
            return ConvertFrom(PrintExecutor::INNO_TT_UNKNOWN_TYPE, tmpl.icsTemplateData);
        }
         */
        [[nodiscard]] ANSITemplate Adapt(const PrintTemplate& tmpl) const
        {
            return ConvertFrom(PrintExecutor::INNO_TT_UNKNOWN_TYPE, tmpl.GetICSRepresentation()->icsTemplateData);
        }

         */
        ANSITemplateAdapter()
          : exec(GlobalPrintExecutor::Get())
        {
        }
         */
        explicit ANSITemplateAdapter(std::shared_ptr<PrintExecutor> executor)
          : exec(std::move(executor))
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("Print executor cannot be null in ANSITemplateAdapter");
            }
        }
 
    private:
        std::shared_ptr<PrintExecutor> exec;
 
        [[nodiscard]] ANSITemplate 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(),
                                   PrintExecutor::INNO_ANSI_TEMPLATE,
                                   tmplAllocator,
                                   &data,
                                   ThrowOnError{});
 
            return ANSITemplate(std::move(data));
        }
    };
} // namespace inno