ExtractedPrint.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Export.h"
#include "enrollment/Print/EmbeddingExtractor.h"
#include "enrollment/Print/ExtractedPrintEmbedding.h"
#include "enrollment/Print/ICSMatcher.h"
#include "enrollment/Print/ICSTemplate.h"
#include "enrollment/Print/ISOTemplate.h"
#include "enrollment/Print/Print.h"
#include "enrollment/Print/PrintExecutor.h"
#include "enrollment/Print/PrintTemplate.h"
#include "enrollment/Serialization/Writer.h"
#include <algorithm>
#include <mutex>
 
// 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 ExtractedPrint final : public ICSTemplate
    {
    public:
        const std::shared_ptr<Print> print;

         */
        static std::vector<std::shared_ptr<ICSTemplate>> ToICSTemplates(
          const std::vector<std::shared_ptr<ExtractedPrint>>& prints)
        {
            std::vector<std::shared_ptr<ICSTemplate>> templates(prints.size());
            std::transform(prints.begin(), prints.end(), templates.begin(), [](const auto& t) { return t; });
            return templates;
        }

         */
        static std::vector<std::shared_ptr<PrintTemplate>> ToTemplates(
          const std::vector<std::shared_ptr<ExtractedPrint>>& prints)
        {
            std::vector<std::shared_ptr<PrintTemplate>> templates(prints.size());
            std::transform(prints.begin(),
                           prints.end(),
                           templates.begin(),
                           [](const auto& t)
                           {
                               if (t->HasEmbeddingRepresentation())
                               {
                                   return std::make_shared<PrintTemplate>(t, t->e);
                               }
                               return std::make_shared<PrintTemplate>(t);
                           });
            return templates;
        }

         */
        void EnhanceWithEmbedding(std::shared_ptr<ExtractedPrintEmbedding> embedding)
        {
            if (embedding == nullptr)
            {
                throw NullArgumentException("Embedding can not be null");
            }
            if (print != embedding->print)
            {
                throw EnrollmentInvalidArgumentException(
                  "ExtractedPrint and embedding were not created from same print");
            }
            const std::scoped_lock lock(embeddingMutex);
            e = std::move(embedding);
        }

         */
        void EnhanceWithEmbedding(const EmbeddingExtractor& extractor)
        {
            const std::scoped_lock lock(embeddingMutex);
            e = extractor.Extract(print);
        }
         */
        std::shared_ptr<ExtractedPrintEmbedding> GetEmbeddingRepresentation() const
        {
            const std::scoped_lock lock(embeddingMutex);
            return e;
        }

         */
        bool HasEmbeddingRepresentation() const
        {
            const std::scoped_lock lock(embeddingMutex);
            return e != nullptr;
        }
         */
        ExtractedPrint(std::vector<uint8_t>&& d, std::shared_ptr<Print> fp)
          : ICSTemplate(std::move(d), GetSafePrintPosition(fp))
          , print(std::move(fp))
        {
        }

         */
        ExtractedPrint(std::vector<uint8_t>&& d, std::shared_ptr<Print> fp, std::shared_ptr<PrintExecutor> executor)
          : ICSTemplate(std::move(d), GetSafePrintPosition(fp), std::move(executor))
          , print(std::move(fp))
        {
        }

         */
        std::shared_ptr<ISOTemplate> ToISO() const
        {
            return ICSTemplate::ToISO(print);
        }

         */
        std::shared_ptr<ANSITemplate> ToANSI() const
        {
            return ICSTemplate::ToANSI(print);
        }
 
        void WriteTo(Writer& w) const final
        {
            w.Write("p", print);
            ICSTemplate::WriteTo(w);
            const std::scoped_lock lock(embeddingMutex);
            w.Write("e", e);
        }
 
        ExtractedPrint(const ExtractedPrint&) = delete;
        ExtractedPrint(ExtractedPrint&&) = delete;
        ExtractedPrint& operator=(const ExtractedPrint&) = delete;
        ExtractedPrint& operator=(ExtractedPrint&&) = delete;
        ExtractedPrint() = delete;
        virtual ~ExtractedPrint() = default;
 
    private:
        mutable std::mutex embeddingMutex;
        std::shared_ptr<ExtractedPrintEmbedding> e;
 
        static PrintPosition GetSafePrintPosition(const std::shared_ptr<Print>& p)
        {
            if (p == nullptr)
            {
                throw EnrollmentRuntimeException("Print cannot be null in ExtractedPrint");
            }
 
            return p->position;
        }
    };
 
} // namespace inno
// NOLINTEND(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes,cppcoreguidelines-avoid-const-or-ref-data-members)