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
}