four_state_usps.hpp

#pragma once
 
#include "reader_four_state_config_base.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Barcode
  {
    using namespace Internal;
 
 
    class FourStateUsps : public ReaderFourStateConfigBase
    {
public:
 
      void SetLsbPosition(FourStateLsb lsb)
      {
       if(lsb_ != lsb)
         SetDirty();
       lsb_ = lsb;
      }
 
 
      FourStateLsb LsbPosition() const
      {
        return lsb_;
      };
 
 
 
    protected:
      FourStateLsb lsb_;
 
 
    public:
      virtual Symbology Type() const override { return Symbology::FourStateUsps; };
 
 
      static std::unique_ptr<FourStateUsps> FromHandle(const HandleGuard<ReaderConfig>& guard, bool& isActiveOut)
      {
        auto pConfig = std::unique_ptr<FourStateUsps>(new FourStateUsps());
        isActiveOut = pConfig->ReadFromHandle(guard);
        return pConfig;
      }
 
    protected:
      virtual bool ReadFromHandle_(const HandleGuard<ReaderConfig>& guard) override
      {
        CExports::cvbbool_t active;
        short tmpLsb;
        CVB_CALL_CAPI(CvcBcGetFourStateUSPS(reinterpret_cast<std::intptr_t>(guard.Handle()),
          &active,
          &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(CvcBcSetFourStateUSPS(reinterpret_cast<std::intptr_t>(guard.Handle()),
          active,
          static_cast<short>(lsb_),
          threshold_,
          inverse_,
          mirrored_,
          quietzoneWidth_
          ));
        });
      }
    protected:
      FourStateUsps()
        : ReaderFourStateConfigBase()
      {
      }
 
    };
 
    using FourStateUspsPtr = std::shared_ptr<FourStateUsps>;
  }
 
  CVB_END_INLINE_NS
}