four_state_royal_mail.hpp

#pragma once
 
#include "reader_four_state_config_base.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Barcode
  {
    using namespace Internal;
 
 
 
    class FourStateRoyalMail : public ReaderFourStateConfigBase
    {
public:
 
 
      void SetEvaluateCheckDigit(bool evalCheckDigit)
      {
        SetDirty();
        evalCheckDigit_ = evalCheckDigit;
      }
 
 
      bool EvaluateCheckDigit() const
      {
        return evalCheckDigit_;
      };
 
 
 
      void SetTransmitCheckDigit(bool transmitCheckDigit)
      {
        SetDirty();
        transmitCheckDigit_ = transmitCheckDigit;
      };
 
 
      bool TransmitCheckDigit() const
      {
        return transmitCheckDigit_;
      };
 
 
      void SetTransmitStartStop(bool transmitStartStop)
      {
        SetDirty();
        transmitStartStop_ = transmitStartStop;
      };
 
 
      bool TransmitStartStop() const
      {
        return transmitStartStop_;
      };
 
 
 
      void SetMinDigits(int minDigits)
      {
        if(minDigits < minDigitsLimit_ ||
          minDigits > maxDigits_)
          throw std::runtime_error("MinDigits out of range");
        if(minDigits_ != minDigits)
          SetDirty();
        minDigits_ = static_cast<short>(minDigits);
      }
 
 
      int MinDigits() const
      {
        return static_cast<int>(minDigits_);
      };
 
 
 
      void SetMaxDigits(int maxDigits)
      {
        if(maxDigits < minDigits_ ||
          maxDigits > maxDigitsLimit_)
          throw std::runtime_error("MaxDigits out of range");
        if(maxDigits_ != maxDigits)
          SetDirty();
        maxDigits_ = static_cast<short>(maxDigits);
      }
 
 
      int MaxDigits() const
      {
        return static_cast<int>(maxDigits_);
      };
 
 
      void SetOrientation(CodeOrientation orientation)
      {
        if(orientation_ != orientation)
          SetDirty();
        orientation_ = orientation;
      }
 
 
      CodeOrientation Orientation() const
      {
        return orientation_;
      };
 
 
 
    protected:
      SmartBool evalCheckDigit_;
      SmartBool transmitCheckDigit_;
      SmartBool transmitStartStop_;
      short minDigits_;
      short maxDigits_;
      CodeOrientation orientation_;
 
 
 
 
      const short minDigitsLimit_ = 7;
      const short maxDigitsLimit_ = 13;
 
 
    public:
      virtual Symbology Type() const override { return Symbology::FourStateRoyalMail; };
 
 
      static std::unique_ptr<FourStateRoyalMail> FromHandle(const HandleGuard<ReaderConfig>& guard, bool& isActiveOut)
      {
        auto pConfig = std::unique_ptr<FourStateRoyalMail>(new FourStateRoyalMail());
        isActiveOut = pConfig->ReadFromHandle(guard);
        return pConfig;
      }
 
    protected:
      virtual bool ReadFromHandle_(const HandleGuard<ReaderConfig>& guard) override
      {
        CExports::cvbbool_t active;
        short tmpOrientation;
        CVB_CALL_CAPI(CvcBcGetFourStateRoyalMail(reinterpret_cast<std::intptr_t>(guard.Handle()),
          &active,
          &minDigits_,
          &maxDigits_,
          &tmpOrientation,
          &threshold_,
          inverse_.Ptr(),
          mirrored_.Ptr(),
          &quietzoneWidth_,
          evalCheckDigit_.Ptr(),
          transmitCheckDigit_.Ptr(),
          transmitStartStop_.Ptr()
          ));
          orientation_ =  static_cast<CodeOrientation>(tmpOrientation);
        return SmartBool(active);
      }
 
      virtual void WriteToHandle_(bool active, HandleGuard<ReaderConfig>& guard) override
      {
        Internal::DoResCall([&]()
        {
         return CVB_CALL_CAPI(CvcBcSetFourStateRoyalMail(reinterpret_cast<std::intptr_t>(guard.Handle()),
          active,
          minDigits_,
          maxDigits_,
          static_cast<short>(orientation_),
          threshold_,
          inverse_,
          mirrored_,
          quietzoneWidth_,
          evalCheckDigit_,
          transmitCheckDigit_,
          transmitStartStop_
          ));
        });
      }
    protected:
      FourStateRoyalMail()
        : ReaderFourStateConfigBase()
      {
      }
 
    };
 
    using FourStateRoyalMailPtr = std::shared_ptr<FourStateRoyalMail>;
  }
 
  CVB_END_INLINE_NS
}