InitializerConfig.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Exception/CallbackError.h"
#include "enrollment/Exception/EnrollmentException.h"
#include "enrollment/Export.h"
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
namespace inno
{
    namespace impl
    {
        extern "C"
        {
            INNO_ENROLLMENT_API void inno_InitializerConfig_GetLicenseContent(void* impl,
                                                                              uint8_t* (*allocator)(void*, size_t),
                                                                              void* container,
                                                                              ErrorCallbacks errorCallbacks);
            INNO_ENROLLMENT_API void inno_InitializerConfig_GetModelsPath(void* impl,
                                                                          char* (*allocator)(void*, size_t),
                                                                          void* container,
                                                                          ErrorCallbacks errorCallbacks);
            INNO_ENROLLMENT_API int inno_InitializerConfig_GetFaceIrisOpencvThreads(void* impl,
                                                                                    ErrorCallbacks errorCallbacks);
            INNO_ENROLLMENT_API int inno_InitializerConfig_GetFaceIrisOrtIntraThreads(void* impl,
                                                                                      ErrorCallbacks errorCallbacks);
            INNO_ENROLLMENT_API int inno_InitializerConfig_GetFaceIrisOrtInterThreads(void* impl,
                                                                                      ErrorCallbacks errorCallbacks);
        }
    } // namespace impl

     */
    struct InitializerConfig
    {
         */
        [[nodiscard]] std::vector<uint8_t> GetLicenseContent() const
        {
            std::vector<uint8_t> content;
            impl::inno_InitializerConfig_GetLicenseContent(
              impl.get(),
              +[](void* container, size_t size) -> uint8_t*
              {
                  auto* data = static_cast<std::vector<uint8_t>*>(container);
                  data->resize(size);
                  return data->data();
              },
              &content,
              ThrowOnError{});
            return content;
        }

         */
        [[nodiscard]] std::string GetModelsPath() const
        {
            std::string content;
            impl::inno_InitializerConfig_GetModelsPath(
              impl.get(),
              +[](void* container, size_t size) -> char*
              {
                  auto* data = static_cast<std::string*>(container);
                  data->resize(size);
                  return data->data();
              },
              &content,
              ThrowOnError{});
            return content;
        }

         */
        [[nodiscard]] int GetFaceIrisOpencvThreads() const
        {
            return impl::inno_InitializerConfig_GetFaceIrisOpencvThreads(impl.get(), ThrowOnError{});
        }

         */
        [[nodiscard]] int GetFaceIrisOrtIntraThreads() const
        {
            return impl::inno_InitializerConfig_GetFaceIrisOrtIntraThreads(impl.get(), ThrowOnError{});
        }

         */
        [[nodiscard]] int GetFaceIrisOrtInterThreads() const
        {
            return impl::inno_InitializerConfig_GetFaceIrisOrtInterThreads(impl.get(), ThrowOnError{});
        }
 
        InitializerConfig() = delete;
        InitializerConfig(const InitializerConfig&) = delete;
        InitializerConfig& operator=(const InitializerConfig&) = delete;
        InitializerConfig(InitializerConfig&&) noexcept = default;
        InitializerConfig& operator=(InitializerConfig&&) noexcept = default;
        ~InitializerConfig() = default;
 
    private:
        friend class InitializerConfigBuilder;
        friend void* GetInitializerConfigPimpl(const InitializerConfig& obj);
 
        InitializerConfig(void* p, void (*deleter)(void*))
          : impl(p, deleter)
        {
        }
        std::unique_ptr<void, void (*)(void*)> impl;
    };
 
    inline void* GetInitializerConfigPimpl(const InitializerConfig& obj)
    {
        return obj.impl.get();
    }
 
    namespace impl
    {
        extern "C"
        {
            INNO_ENROLLMENT_API void inno_InitializerConfigBuilder_UseAllAvailableCores(void* impl,
                                                                                        ErrorCallbacks errorCallbacks);
            INNO_ENROLLMENT_API void inno_InitializerConfigBuilder_UseSingleCore(void* impl,
                                                                                 ErrorCallbacks errorCallbacks);
            INNO_ENROLLMENT_API void inno_InitializerConfigBuilder_SetLicenseContent(void* impl,
                                                                                     const uint8_t* data,
                                                                                     size_t size,
                                                                                     ErrorCallbacks errorCallbacks);
            INNO_ENROLLMENT_API void inno_InitializerConfigBuilder_SetLicensePath(void* impl,
                                                                                  const char* data,
                                                                                  size_t size,
                                                                                  ErrorCallbacks errorCallbacks);
            INNO_ENROLLMENT_API void inno_InitializerConfigBuilder_SetModelsPath(void* impl,
                                                                                 const char* data,
                                                                                 size_t size,
                                                                                 ErrorCallbacks errorCallbacks);
            INNO_ENROLLMENT_API void inno_InitializerConfigBuilder_SetFaceIrisOpencvThreads(
              void* impl,
              int count,
              ErrorCallbacks errorCallbacks);
            INNO_ENROLLMENT_API void inno_InitializerConfigBuilder_SetFaceIrisOrtIntraThreads(
              void* impl,
              int count,
              ErrorCallbacks errorCallbacks);
            INNO_ENROLLMENT_API void inno_InitializerConfigBuilder_SetFaceIrisOrtInterThreads(
              void* impl,
              int count,
              ErrorCallbacks errorCallbacks);
            INNO_ENROLLMENT_API void* inno_InitializerConfigBuilder_Build(void* impl,
                                                                          void (**deleter)(void*),
                                                                          ErrorCallbacks errorCallbacks);
            INNO_ENROLLMENT_API void* inno_InitializerConfigBuilder_Create(void (**deleter)(void*),
                                                                           ErrorCallbacks errorCallbacks);
        }
    } // namespace impl

     */
    class InitializerConfigBuilder
    {
    public:
         */
        InitializerConfigBuilder& UseAllAvailableCores()
        {
            impl::inno_InitializerConfigBuilder_UseAllAvailableCores(impl.get(), ThrowOnError{});
            return *this;
        }

         */
        InitializerConfigBuilder& UseSingleCore()
        {
            impl::inno_InitializerConfigBuilder_UseSingleCore(impl.get(), ThrowOnError{});
            return *this;
        }

         */
        InitializerConfigBuilder& SetLicenseContent(std::vector<uint8_t> content)
        {
            impl::inno_InitializerConfigBuilder_SetLicenseContent(
              impl.get(), content.data(), content.size(), ThrowOnError{});
            return *this;
        }

         */
        InitializerConfigBuilder& SetLicensePath(const std::string& path)
        {
            impl::inno_InitializerConfigBuilder_SetLicensePath(impl.get(), path.data(), path.size(), ThrowOnError{});
            return *this;
        }

         */
        InitializerConfigBuilder& SetModelsPath(std::string path)
        {
            impl::inno_InitializerConfigBuilder_SetModelsPath(impl.get(), path.data(), path.size(), ThrowOnError{});
            return *this;
        }

         */
        InitializerConfigBuilder& SetFaceIrisOpencvThreads(int count)
        {
            impl::inno_InitializerConfigBuilder_SetFaceIrisOpencvThreads(impl.get(), count, ThrowOnError{});
            return *this;
        }

         */
        InitializerConfigBuilder& SetFaceIrisOrtIntraThreads(int count)
        {
            impl::inno_InitializerConfigBuilder_SetFaceIrisOrtIntraThreads(impl.get(), count, ThrowOnError{});
            return *this;
        }

         */
        InitializerConfigBuilder& SetFaceIrisOrtInterThreads(int count)
        {
            impl::inno_InitializerConfigBuilder_SetFaceIrisOrtInterThreads(impl.get(), count, ThrowOnError{});
            return *this;
        }

         */
        [[nodiscard]] InitializerConfig Build()
        {
            void (*deleter)(void*) = nullptr;
            auto* cfgImpl = impl::inno_InitializerConfigBuilder_Build(impl.get(), &deleter, ThrowOnError{});
 
            return { cfgImpl, deleter };
        }
 
        InitializerConfigBuilder()
          : impl(Create())
        {
        }
        InitializerConfigBuilder(const InitializerConfigBuilder&) = delete;
        InitializerConfigBuilder& operator=(const InitializerConfigBuilder&) = delete;
        InitializerConfigBuilder(InitializerConfigBuilder&&) noexcept = default;
        InitializerConfigBuilder& operator=(InitializerConfigBuilder&&) noexcept = default;
        ~InitializerConfigBuilder() = default;
 
    private:
        std::unique_ptr<void, void (*)(void*)> impl;
 
        static std::unique_ptr<void, void (*)(void*)> Create()
        {
            void (*deleter)(void*) = nullptr;
            auto* p = impl::inno_InitializerConfigBuilder_Create(&deleter, ThrowOnError{});
            return { p, deleter };
        }
    };
} // namespace inno