qr.hpp

#pragma once
 
#include "_detail/reader_2d_with_quietzone_config_base.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Barcode
  {
    using namespace Internal;
 
 
 
    class Qr : public Reader2DWithQuietzoneConfigBase
    {
public:
 
 
      void SetMaxVersionMiniQr(int maxVersionMiniQR)
      {
        if(maxVersionMiniQR < minVersionMiniQR_ ||
          maxVersionMiniQR > MaxVersionMiniQRHighest_)
          throw std::runtime_error("MaxVersionMiniQR out of range");
        maxVersionMiniQR_ = static_cast<short>(maxVersionMiniQR);
        SetDirty();
      }
 
 
      int MaxVersionMiniQr() const
      {
        return maxVersionMiniQR_;
      };
 
 
      void SetMaxVersionStandardQr(int maxVersionStandardQR)
      {
        if(maxVersionStandardQR < minVersionStandardQR_ ||
          maxVersionStandardQR > MaxVersionStandardQRHighest_)
          throw std::runtime_error("MaxVersionStandardQR out of range");
        maxVersionStandardQR_ = static_cast<short>(maxVersionStandardQR);
        SetDirty();
      }
 
 
      int MaxVersionStandardQr() const
      {
        return maxVersionStandardQR_;
      };
 
 
 
      void SetMinVersionMiniQr(int minVersionMiniQR)
      {
        if(minVersionMiniQR > maxVersionMiniQR_ ||
          minVersionMiniQR < MinVersionMiniQRLowest_)
          throw std::runtime_error("MinVersionMiniQR out of range");
        minVersionMiniQR_ = static_cast<short>(minVersionMiniQR);
        SetDirty();
      }
 
 
      int MinVersionMiniQr() const
      {
        return minVersionMiniQR_;
      };
 
 
 
      void SetMinVersionStandardQr(int minVersionStandardQR)
      {
        if(minVersionStandardQR > maxVersionStandardQR_ ||
          minVersionStandardQR < MinVersionStandardQRLowest_)
          throw std::runtime_error("MinVersionStandardQR out of range");
        minVersionStandardQR_ = static_cast<short>(minVersionStandardQR);
        SetDirty();
      }
 
 
      int MinVersionStandardQr() const
      {
        return minVersionStandardQR_;
      };
 
 
 
      void SetSubTypes(QrSubType subTypes)
      {
        if (subTypes_ != subTypes)
          SetDirty();
        subTypes_ = subTypes;
      };
 
 
      QrSubType SubTypes() const
      {
        return subTypes_;
      };
 
    protected:
      short maxVersionMiniQR_;
      short maxVersionStandardQR_;
      short minVersionMiniQR_;
      short minVersionStandardQR_;
      QrSubType subTypes_;
 
      const short MinVersionMiniQRLowest_ = 1;
 
      const short MaxVersionMiniQRHighest_ = 4;
 
      const short MinVersionStandardQRLowest_ = 1;
 
      const short MaxVersionStandardQRHighest_ = 40;
 
    public:
      virtual Symbology Type() const override { return Symbology::Qr; };
 
 
      static std::unique_ptr<Qr> FromHandle(const HandleGuard<ReaderConfig>& guard, bool& isActiveOut)
      {
        auto pConfig = std::unique_ptr<Qr>(new Qr());
        isActiveOut = pConfig->ReadFromHandle(guard);
        return pConfig;
      }
 
    protected:
      virtual bool ReadFromHandle_(const HandleGuard<ReaderConfig>& guard) override
      {
        CExports::cvbbool_t active;
        SmartBool activeMiniQr;
        SmartBool activeStandardQr;
        CVB_CALL_CAPI(CvcBcGetQRCode(
          reinterpret_cast<std::intptr_t>(guard.Handle()),
          &active,
          mirrored_.Ptr(),
          inverse_.Ptr(),
          checkQuietzone_.Ptr(),
          activeMiniQr.Ptr(),
          &minVersionMiniQR_,
          &maxVersionMiniQR_,
          activeStandardQr.Ptr(),
          &minVersionStandardQR_,
          &maxVersionStandardQR_
        ));
        // convert to QrSubType
        if (!activeMiniQr && !activeStandardQr)
          throw std::runtime_error("MiniQR and StandardQR both deactivated");
        else if (activeMiniQr && activeStandardQr)
          subTypes_ = QrSubType::Both;
        else if (activeMiniQr)
          subTypes_ = QrSubType::Mini;
        else if (activeStandardQr)
          subTypes_ = QrSubType::Standard;
 
        return SmartBool(active);
      }
 
      virtual void WriteToHandle_(bool active, HandleGuard<ReaderConfig>& guard) override
      {
        SmartBool activeMiniQr;
        SmartBool activeStandardQr;
        Internal::DoResCall([&]()
        {
          return CVB_CALL_CAPI(CvcBcSetQRCode(reinterpret_cast<std::intptr_t>(guard.Handle()),
            SmartBool(active),
            mirrored_,
            inverse_,
            checkQuietzone_,
            SmartBool(subTypes_ != QrSubType::Standard),
            minVersionMiniQR_,
            maxVersionMiniQR_,
            SmartBool(subTypes_ != QrSubType::Mini),
            minVersionStandardQR_,
            maxVersionStandardQR_));
        });
      }
    protected:
      Qr()
        : Reader2DWithQuietzoneConfigBase()
      {
      }
 
    };
 
    using QrPtr = std::shared_ptr<Qr>;
  }
 
  CVB_END_INLINE_NS
}