four_state_australian.hpp

#pragma once

#include "reader_four_state_config_base.hpp"

namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  namespace Barcode
  {
    using namespace Internal;


    class FourStateAustralian : public ReaderFourStateConfigBase
    {
public:


      void SetLevels(FourStateAustralianLevels levels)
      {
       if(levels_ != levels)
         SetDirty();
       levels_ = levels;
      }


      FourStateAustralianLevels Levels() const
      {
        return levels_;
      };


      void SetOrientation(CodeOrientation orientation)
      {
       if(orientation_ != orientation)
         SetDirty();
       orientation_ = orientation;
      }


      CodeOrientation Orientation() const
      {
        return orientation_;
      };



    protected:
      FourStateAustralianLevels levels_;
      CodeOrientation orientation_;


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


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

    protected:
      virtual bool ReadFromHandle_(const HandleGuard<ReaderConfig>& guard) override
      {
        CExports::cvbbool_t active;
        unsigned short tmpLevels;
        short tmpOrientation;
        CVB_CALL_CAPI(CvcBcGetFourStateAustralian(reinterpret_cast<std::intptr_t>(guard.Handle()),
          &active,
          &tmpLevels,
          &tmpOrientation,
          &threshold_,
          inverse_.Ptr(),
          mirrored_.Ptr(),
          &quietzoneWidth_
          ));
        levels_ = static_cast<FourStateAustralianLevels>(tmpLevels);
        orientation_ = static_cast<CodeOrientation>(tmpOrientation);
        return SmartBool(active);
      }

      virtual void WriteToHandle_(bool active, HandleGuard<ReaderConfig>& guard) override
      {
        Internal::DoResCall([&]()
        {
         return CVB_CALL_CAPI(CvcBcSetFourStateAustralian(reinterpret_cast<std::intptr_t>(guard.Handle()),
          SmartBool(active),
          static_cast<unsigned short>(levels_),
          static_cast<short>(orientation_),
          threshold_,
          inverse_,
          mirrored_,
          quietzoneWidth_
          ));
        });
      }
    protected:
      FourStateAustralian()
        : ReaderFourStateConfigBase()
      {
      }

    };

    using FourStateAustralianPtr = std::shared_ptr<FourStateAustralian>;
  }

  CVB_END_INLINE_NS
}