four_state_kix.hpp

#pragma once

#include "reader_four_state_config_base.hpp"

namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  namespace Barcode
  {
    using namespace Internal;


    class FourStateKix : public ReaderFourStateConfigBase
    {
public:


      void SetLsbPosition(FourStateLsb lsb)
      {
       if(lsb_ != lsb)
         SetDirty();
       lsb_ = lsb;
      }


      FourStateLsb LsbPosition() const
      {
        return lsb_;
      };



      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_);
      };


    protected:
      FourStateLsb lsb_;
      short minDigits_;
      short maxDigits_;

      const short minDigitsLimit_ = 6;
      const short maxDigitsLimit_ = 18;

    public:
      virtual Symbology Type() const override { return Symbology::FourStateKix; };


      static std::unique_ptr<FourStateKix> FromHandle(const HandleGuard<ReaderConfig>& guard, bool& isActiveOut)
      {
        auto pConfig = std::unique_ptr<FourStateKix>(new FourStateKix());
        isActiveOut = pConfig->ReadFromHandle(guard);
        return pConfig;
      }

    protected:
      virtual bool ReadFromHandle_(const HandleGuard<ReaderConfig>& guard) override
      {
        CExports::cvbbool_t active;
        short tmpLsb;
        CVB_CALL_CAPI(CvcBcGetFourStateKix(reinterpret_cast<std::intptr_t>(guard.Handle()),
          &active,
          &minDigits_,
          &maxDigits_,
          &tmpLsb,
          &threshold_,
          inverse_.Ptr(),
          mirrored_.Ptr(),
          &quietzoneWidth_
          ));
        lsb_ = static_cast<FourStateLsb>(tmpLsb);
        return SmartBool(active);
      }

      virtual void WriteToHandle_(bool active, HandleGuard<ReaderConfig>& guard) override
      {
        Internal::DoResCall([&]()
        {
         return CVB_CALL_CAPI(CvcBcSetFourStateKix(reinterpret_cast<std::intptr_t>(guard.Handle()),
          SmartBool(active),
          minDigits_,
          maxDigits_,
          static_cast<short>(lsb_),
          threshold_,
          inverse_,
          mirrored_,
          quietzoneWidth_
          ));
        });
      }
    protected:
      FourStateKix()
        : ReaderFourStateConfigBase()
      {
      }

    };

    using FourStateKixPtr = std::shared_ptr<FourStateKix>;
  }

  CVB_END_INLINE_NS
}