pdf417.hpp

#pragma once
 
#include "reader_2d_config_base.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Barcode
  {
    using namespace Internal;
 
 
    class Pdf417 : public Reader2DConfigBase
    {
public:
 
 
      void SetLevels(Pdf417Levels levels)
      {
        if(levels_ != levels)
          SetDirty();
        levels_ = levels;
      }
 
 
      Pdf417Levels Levels() const
      {
        return levels_;
      };
 
 
      void SetMinRows(int minRows)
      {
        if(minRows < MinRowsLimit_ ||
          minRows > maxRows_)
          throw std::runtime_error("MinRows out of range");
        if(minRows_ != minRows)
          SetDirty();
        minRows_ = static_cast<short>(minRows);
      }
 
 
      int MinRows() const
      {
        return static_cast<int>(minRows_);
      };
 
 
      void SetMaxRows(int maxRows)
      {
        if(maxRows < minRows_ ||
          maxRows > MaxRowsLimit_)
          throw std::runtime_error("MaxRows out of range");
        if(maxRows_ != maxRows)
          SetDirty();
        maxRows_ = static_cast<short>(maxRows);
      }
 
 
      int MaxRows() const
      {
        return static_cast<int>(maxRows_);
      };
 
 
 
      void SetMinColumns(int minColumns)
      {
        if(minColumns < MinColumnsLimit_ ||
          minColumns > maxColumns_)
          throw std::runtime_error("MinColumns out of range");
        if(minColumns_ != minColumns)
          SetDirty();
        minColumns_ = static_cast<short>(minColumns);
      }
 
 
      int MinColumns() const
      {
        return static_cast<int>(minColumns_);
      };
 
 
      void SetMaxColumns(int maxColumns)
      {
        if(maxColumns< minColumns_ ||
          maxColumns > MaxColumnsLimit_)
          throw std::runtime_error("MaxColumns out of range");
        if(maxColumns_ != maxColumns)
          SetDirty();
        maxColumns_ = static_cast<short>(maxColumns);
      }
 
 
      int MaxColumns() const
      {
        return static_cast<int>(maxColumns_);
      };
 
 
 
    protected:
      Pdf417Levels levels_;
      short minRows_;
      short maxRows_;
      short minColumns_;
      short maxColumns_;
 
      const short MinRowsLimit_ = 3;
      const short MaxRowsLimit_ = 90;
 
      const short MinColumnsLimit_ = 1;
      const short MaxColumnsLimit_ = 30;
 
 
    public:
      virtual Symbology Type() const override { return Symbology::Pdf417; };
 
 
      static std::unique_ptr<Pdf417> FromHandle(const HandleGuard<ReaderConfig>& guard, bool& isActiveOut)
      {
        auto pConfig = std::unique_ptr<Pdf417>(new Pdf417());
        isActiveOut = pConfig->ReadFromHandle(guard);
        return pConfig;
      }
 
    protected:
      virtual bool ReadFromHandle_(const HandleGuard<ReaderConfig>& guard) override
      {
        unsigned short tmpLevels;
        CVB_CALL_CAPI(CvcBcGetPDF417(reinterpret_cast<std::intptr_t>(guard.Handle()),
          &tmpLevels,
          &minRows_,
          &maxRows_,
          &minColumns_,
          &maxColumns_,
          mirrored_.Ptr(),
          inverse_.Ptr()));
        levels_ = static_cast<Pdf417Levels>(tmpLevels);
        return tmpLevels != 0;
      }
 
      virtual void WriteToHandle_(bool active, HandleGuard<ReaderConfig>& guard) override
      {
        if (!active)
          levels_ = static_cast<Pdf417Levels>(0);
        Internal::DoResCall([&]()
        {
          return CVB_CALL_CAPI(CvcBcSetPDF417(reinterpret_cast<std::intptr_t>(guard.Handle()),
            static_cast<unsigned short>(levels_),
            minRows_,
            maxRows_,
            minColumns_,
            maxColumns_,
            mirrored_,
            inverse_));
        });
      }
    protected:
      Pdf417()
        : Reader2DConfigBase()
      {
      }
 
    };
 
    using Pdf417Ptr = std::shared_ptr<Pdf417>;
  }
 
  CVB_END_INLINE_NS
}