rss.hpp

#pragma once
 
#include "reader_2d_config_base.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Barcode
  {
    using namespace Internal;
 
 
 
    class Rss : public Reader2DConfigBase
    {
public:
 
 
      void SetComposition(RssComposition composition)
      {
        if(composition_ != composition)
          SetDirty();
        composition_ = composition;
      }
 
 
      RssComposition Composition() const
      {
        return composition_;
      }
 
 
 
      void SetOrientation(CodeOrientation orientation)
      {
        if(orientation_ != orientation)
          SetDirty();
        orientation_ = orientation;
      }
 
 
      CodeOrientation Orientation() const
      {
        return orientation_;
      }
 
 
      void SetTypes(RssTypes types)
      {
        if(types_ != types)
          SetDirty();
        types_ = types;
      }
 
 
      RssTypes Types() const
      {
        return types_;
      };
 
 
    protected:
      RssComposition composition_;
      CodeOrientation orientation_;
      RssTypes types_;
 
 
    public:
      virtual Symbology Type() const override { return Symbology::RSS; };
 
 
      static std::unique_ptr<Rss> FromHandle(const HandleGuard<ReaderConfig>& guard, bool& isActiveOut)
      {
        auto pConfig = std::unique_ptr<Rss>(new Rss());
        isActiveOut = pConfig->ReadFromHandle(guard);
        return pConfig;
      }
 
    protected:
      virtual bool ReadFromHandle_(const HandleGuard<ReaderConfig>& guard) override
      {
        CExports::cvbbool_t active;
        short tmpTypes;
        short tmpComposite;
        short tmpDirection;
        CVB_CALL_CAPI(CvcBcGetRSS(reinterpret_cast<std::intptr_t>(guard.Handle()), &active,
          inverse_.Ptr(),
          mirrored_.Ptr(),
          &tmpTypes,
          &tmpComposite,
          &tmpDirection));
        types_ = static_cast<RssTypes>(tmpTypes);
        composition_ = static_cast<RssComposition>(tmpComposite);
        orientation_ = static_cast<CodeOrientation>(tmpDirection);
        return SmartBool(active);
      }
 
      virtual void WriteToHandle_(bool active, HandleGuard<ReaderConfig>& guard) override
      {
        Internal::DoResCall([&]()
        {
          return CVB_CALL_CAPI(CvcBcSetRSS(reinterpret_cast<std::intptr_t>(guard.Handle()),
            SmartBool(active),
            inverse_,
            mirrored_,
            static_cast<short>(types_),
            static_cast<short>(composition_),
            static_cast<short>(orientation_)));
        });
      }
    protected:
      Rss()
        : Reader2DConfigBase()
      {
      }
 
    };
 
    using RssPtr = std::shared_ptr<Rss>;
  }
 
  CVB_END_INLINE_NS
}