decl_config_2d_codes.hpp

#pragma once
 
#include "../../_cexports/c_code_reader.h"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace CodeReader
  {
    class Decoder;
 
    namespace Config
    {
#pragma region DataMatrix

      class DataMatrix final : public ConfigBase<DataMatrix>
      {
        friend class Cvb::CodeReader::Decoder;
 
      public:

        DataMatrix &SetPolarity(Polarity value);


        Config::Polarity Polarity() const;


        DataMatrix &SetMirroringEnabled(bool value);


        bool IsMirroringEnabled() const;


        DataMatrix &SetRectangularDecoding(RectangularDecoding value);


        Config::RectangularDecoding RectangularDecoding() const;


        DataMatrix &SetMinimumSize(int size);


        int MinimumSize() const;


        DataMatrix &SetMaximumSize(int size);


        int MaximumSize() const;


        DataMatrix &SetMinNumberModules(int value);


        int MinNumberModules() const;


        DataMatrix &SetMaxNumberModules(int value);


        int MaxNumberModules() const;


        DataMatrix &SetMaxModuleSize(int size);


        int MaxModuleSize() const;


        DataMatrix &SetMaxLineFilterSize(int size);


        int MaxLineFilterSize() const;


        DataMatrix &SetFastDataMatrixSearchEnabled(bool value);


        bool IsFastDataMatrixSearchEnabled() const;
 
      private:
        using ConfigBase<DataMatrix>::ConfigBase;
 
        enum class Properties
        {
          Rect                 = CExports::CVCRSymbologyPropertiesDataMatrix::CVCRSPDM_Rect,
          RectExtended         = CExports::CVCRSymbologyPropertiesDataMatrix::CVCRSPDM_RectExtended,
          Polarity             = CExports::CVCRSymbologyPropertiesDataMatrix::CVCRSPDM_Polarity,
          Mirror               = CExports::CVCRSymbologyPropertiesDataMatrix::CVCRSPDM_Mirror,
          MinSize              = CExports::CVCRSymbologyPropertiesDataMatrix::CVCRSPDM_MinimumSize,
          MaxSize              = CExports::CVCRSymbologyPropertiesDataMatrix::CVCRSPDM_MaximumSize,
          MinNumModules        = CExports::CVCRSymbologyPropertiesDataMatrix::CVCRSPDM_MinNumModule,
          MaxNumModules        = CExports::CVCRSymbologyPropertiesDataMatrix::CVCRSPDM_MaxNumModule,
          MaxModuleSize        = CExports::CVCRSymbologyPropertiesDataMatrix::CVCRSPDM_MaxModuleSize,
          MaxLineFilterSize    = CExports::CVCRSymbologyPropertiesDataMatrix::CVCRSPDM_MaxLineFilterSize,
          FastDataMatrixSearch = CExports::CVCRSymbologyPropertiesDataMatrix::CVCRSPDM_FastDataMatrixSearch
        };
      };
 
      template <>
      struct Mapper<Symbology::DataMatrix>
      {
        using Type = Config::DataMatrix;
      };
 
      template <>
      struct ReverseMapper<Config::DataMatrix>
      {
        static constexpr Symbology type = Symbology::DataMatrix;
      };
#pragma endregion
 
#pragma region QR and MicroQR

      class QR : public ConfigBase<QR>
      {
        friend class Cvb::CodeReader::Decoder;
 
      public:

        QR &SetPolarity(Polarity value);


        Config::Polarity Polarity() const;


        QR &SetMirroringEnabled(bool value);


        bool IsMirroringEnabled() const;


        QR &SetPreciseCornersEnabled(bool value);


        bool IsPreciseCornersEnabled() const;
 
      protected:
        QR(Decoder &decoder) noexcept
            : ConfigBase<QR>(decoder)
        {
        }
 
        enum class Properties
        {
          Polarity      = CExports::CVCRSymbologyPropertiesQR::CVCRSPQR_Polarity,
          Mirror        = CExports::CVCRSymbologyPropertiesQR::CVCRSPQR_Mirror,
          PreciseCorner = CExports::CVCRSymbologyPropertiesQR::CVCRSPQR_PreciseCornerQR
        };
      };
 
      template <>
      struct Mapper<Symbology::QR>
      {
        using Type = Config::QR;
      };
 
      template <>
      struct ReverseMapper<Config::QR>
      {
        static constexpr Symbology type = Symbology::QR;
      };


      class MicroQR final : public QR
      {
        friend class Cvb::CodeReader::Decoder;
 
      private:
        MicroQR(Decoder &decoder) noexcept
            : QR(decoder)
        {
        }
 
      public:

        bool Enabled() const;


        MicroQR &Enable();


        MicroQR &Disable();
      };
 
      template <>
      struct Mapper<Symbology::MicroQR>
      {
        using Type = Config::MicroQR;
      };
 
      template <>
      struct ReverseMapper<Config::MicroQR>
      {
        static constexpr Symbology type = Symbology::MicroQR;
      };
#pragma endregion
 
#pragma region Pdf417 and MicroPdf417

      class Pdf417 final : public ConfigBase<Pdf417>
      {
        friend class Cvb::CodeReader::Decoder;
 
      private:
        Pdf417(Decoder &decoder) noexcept
            : ConfigBase<Pdf417>(decoder)
        {
        }
      };
 
      template <>
      struct Mapper<Symbology::Pdf417>
      {
        using Type = Config::Pdf417;
      };
 
      template <>
      struct ReverseMapper<Config::Pdf417>
      {
        static constexpr Symbology type = Symbology::Pdf417;
      };


      class MicroPdf417 final : public ConfigBase<MicroPdf417>
      {
        friend class Cvb::CodeReader::Decoder;
 
      private:
        MicroPdf417(Decoder &decoder) noexcept
            : ConfigBase<MicroPdf417>(decoder)
        {
        }
      };
 
      template <>
      struct Mapper<Symbology::MicroPdf417>
      {
        using Type = Config::MicroPdf417;
      };
 
      template <>
      struct ReverseMapper<Config::MicroPdf417>
      {
        static constexpr Symbology type = Symbology::MicroPdf417;
      };
#pragma endregion
 
    }  // namespace Config
  }  // namespace CodeReader
 
  CVB_END_INLINE_NS
}  // namespace Cvb