reader_config.hpp

#pragma once
 
#include "../_cexports/c_barcode.h"
#include "barcode.hpp"
 
 
#include "_detail/config_base.hpp"
#include "_detail/barcode_grading.hpp"
#include "_detail/data_matrix_grading.hpp"
#include "_detail/qr_grading.hpp"
#include "_detail/qr.hpp"
 
#include "_detail/codabar.hpp"
#include "_detail/code11.hpp"
#include "_detail/code32.hpp"
#include "_detail/discrete_2_of_5.hpp"
#include "_detail/ean8.hpp"
#include "_detail/ean13.hpp"
#include "_detail/four_state_australian.hpp"
#include "_detail/four_state_kix.hpp"
#include "_detail/four_state_royal_mail.hpp"
#include "_detail/four_state_usps.hpp"
#include "_detail/interleaved_2_of_5.hpp"
#include "_detail/micro_pdf417.hpp"
#include "_detail/msi_plessey.hpp"
#include "_detail/pharma_code.hpp"
#include "_detail/planet.hpp"
#include "_detail/postnet.hpp"
#include "_detail/rss.hpp"
#include "_detail/upc_a.hpp"
#include "_detail/upc_e.hpp"
#include "_detail/pdf417.hpp"
#include "_detail/data_matrix.hpp"
#include "_detail/qr.hpp"
#include "_detail/sony_code.hpp"
#include "_detail/code128.hpp"
#include "_detail/code39.hpp"
#include "_detail/code93.hpp"
 
 
#include <map>
#include <typeinfo>
#include <typeindex>
 
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
    template <>
  inline HandleGuard<Barcode::ReaderConfig>::HandleGuard(void * handle) noexcept
    : HandleGuard<Barcode::ReaderConfig>(handle, [](void* handle) { CVB_CALL_CAPI(CvcBcDeleteConfiguration(reinterpret_cast<intptr_t>(handle))); })
  {
  }
 
  namespace Barcode
  {
 
    class ReaderConfig
    {
    public:
      static std::unique_ptr<ReaderConfig> Create(ReaderInitialization initMode)
      {
        return Internal::DoResCallObjectOut<ReaderConfig>([&](void* & configOut)
        {
          configOut = reinterpret_cast<void*>(CVB_CALL_CAPI(CvcBcCreateConfiguration(SmartBool(initMode == ReaderInitialization::ReadAll))));
          return CExports::CVC_E_OK;
        });
      }
 
 
 
      void* Handle() const noexcept
      {
        return handle_.Handle();
      }
 
 
 
      static std::unique_ptr<ReaderConfig> FromHandle(HandleGuard<ReaderConfig>&& guard)
      {
        if (!guard.Handle())
          throw std::runtime_error("handle must not be null");
        return std::unique_ptr<ReaderConfig>(new ReaderConfig(std::move(guard)));
      }
 
 
 
      static std::unique_ptr<ReaderConfig> Load(const Cvb::String &fileName)
      {
        auto pConfig = Create(ReaderInitialization::ReadAll);
        Internal::DoResCall([&]()
        {
          return CVB_CALL_CAPI(CvcBcLoadConfigurationTyped(reinterpret_cast<intptr_t>(pConfig->Handle()), fileName.c_str()));
        });
        pConfig->UpdateMap();
        return pConfig;
      }
 
 
 
      void Save(Cvb::String fileName)
      {
        Flush();
        Internal::DoResCall([&]()
        {
          return CVB_CALL_CAPI(CvcBcSaveConfigurationTyped(reinterpret_cast<intptr_t>(handle_.Handle()), fileName.c_str()));
        });
      }
 
 
 
      void Flush()
      {
        for (auto pair : configMap_)
          pair.second->WriteToHandle(true, handle_);
      }
 
 
 
      template<typename TConfig>
      std::shared_ptr<TConfig> Configuration()
      {
        static_assert(std::is_base_of<Config::ConfigBase, TConfig>::value, "CVB: ConfigBase must be a base of T");
        std::shared_ptr<TConfig> pConfig;
        if (TrySearchConfiguration<TConfig>(pConfig))
          return pConfig;
        return nullptr;
      }
 
 
 
      template<typename TConfig>
      std::shared_ptr<TConfig> CreateConfiguration()
      {
        if (auto config = Configuration<TConfig>())
          return config;
        else
        {
          auto& configId = typeid(TConfig);
          if (auto FromHandle = TypeIdCtorMapping.at(configId))
          {
            bool isCurrentlyActive = false;
            if (auto newConfig = FromHandle(handle_, isCurrentlyActive))
            {
              InsertConfiguration(configId, newConfig);
              return std::dynamic_pointer_cast<TConfig>(newConfig);
            }
            throw std::runtime_error("Failed to create configuration");
          }
          throw std::runtime_error("Unknown barcode id. No matching typeid found");
        }
      }
 
 
 
 
 
      template<typename TConfig>
      void RemoveConfiguration()
      {
        static_assert(std::is_base_of<Config::ConfigBase, TConfig>::value, "CVB: ConfigBase must be a base of T");
        RemoveConfiguration(typeid(TConfig));
      }
 
 
 
 
 
      void SetReadoutMode(Readout readoutMode)
      {
        readoutMode_ = readoutMode;
      }
 
 
      Readout ReadoutMode() const noexcept
      {
        return readoutMode_;
      }
 
 
 
      void SetReadoutStripeDistance(int range)
      {
        Internal::DoResCall([&]()
        {
          return CVB_CALL_CAPI(CvcBcSetReadout(reinterpret_cast<std::intptr_t>(handle_.Handle()),
            static_cast<short>(OmniDirectionalReadoutAngleCount()), 
            static_cast<short>(OmniDirectionalReadoutStripeCount()), 
            static_cast<short>(range)));
        });
      }
 
 
 
      int ReadoutStripeDistance() const noexcept
      {
        short numAngle = 0;
        short numStripes = 0;
        short range = 0;
        CVB_CALL_CAPI(CvcBcGetReadout(reinterpret_cast<std::intptr_t>(handle_.Handle()), &numAngle, &numStripes, &range));
        return static_cast<int>(range);
      }
 
 
 
      void SetOmniDirectionalReadoutAngleCount(int numAngle)
      {
        Internal::DoResCall([&]()
        {
          return CVB_CALL_CAPI(CvcBcSetReadout(reinterpret_cast<std::intptr_t>(handle_.Handle()),
            static_cast<short>(numAngle),
            static_cast<short>(OmniDirectionalReadoutStripeCount()),
            static_cast<short>(ReadoutStripeDistance())));
        });
      }
 
 
 
      int OmniDirectionalReadoutAngleCount() const noexcept
      {
        short numAngle = 0;
        short numStripes = 0;
        short range = 0;
        CVB_CALL_CAPI(CvcBcGetReadout(reinterpret_cast<std::intptr_t>(handle_.Handle()), &numAngle, &numStripes, &range));
        return static_cast<int>(numAngle);
      }
 
 
 
      void SetOmniDirectionalReadoutStripeCount(int numStripe)
      {
        Internal::DoResCall([&]()
        {
          return CVB_CALL_CAPI(CvcBcSetReadout(reinterpret_cast<std::intptr_t>(handle_.Handle()),
            static_cast<short>(OmniDirectionalReadoutAngleCount()),
            static_cast<short>(numStripe),
            static_cast<short>(ReadoutStripeDistance())));
        });
      }
 
 
 
      int OmniDirectionalReadoutStripeCount() const noexcept
      {
        short numAngle = 0;
        short numStripes = 0;
        short range = 0;
        CVB_CALL_CAPI(CvcBcGetReadout(reinterpret_cast<std::intptr_t>(handle_.Handle()), &numAngle, &numStripes, &range));
        return static_cast<int>(numStripes);
      }
 
 
 
      void SetCheckCodePosition(bool checkPosition)
      {
        Internal::DoResCall([&]()
        {
          return CVB_CALL_CAPI(CvcBcSetCodePositionCheck(reinterpret_cast<std::intptr_t>(handle_.Handle()), SmartBool(checkPosition)));
        });
      }
 
 
 
      bool CheckCodePosition() const noexcept
      {
        SmartBool checkPosition(false);
        CVB_CALL_CAPI(CvcBcGetCodePositionCheck(reinterpret_cast<std::intptr_t>(handle_.Handle()), checkPosition.Ptr()));
        return checkPosition;
      }
 
 
 
      void SetTimeLimit(int timeLimit)
      { 
        CVB_CALL_CAPI(CvcBcSetTimeLimit(reinterpret_cast<std::intptr_t>(handle_.Handle()), static_cast<short>(timeLimit)));
      }
 
 
 
      int TimeLimit() const noexcept
      {
        short timeLimit = 0;
        CVB_CALL_CAPI(CvcBcGetTimeLimit(reinterpret_cast<std::intptr_t>(handle_.Handle()), &timeLimit));
        return static_cast<int>(timeLimit);
      }
      
 
 
      bool ContainsSymbology(Symbology symbology) const
      {
        for (auto pair : TypeIdSymbologyMapping)
        {
          auto tmpSymbology = pair.second;
          auto& tmpId = pair.first;
          if (tmpSymbology == symbology)
            if (configMap_.count(tmpId) >= 1)
              return true;
            else
              return false;
        }
        return false;
      }
 
 
    private:
 
      ReaderConfig(ReaderInitialization initMode)
        : handle_(reinterpret_cast<void*>(CVB_CALL_CAPI(CvcBcCreateConfiguration(SmartBool(initMode == ReaderInitialization::ReadAll)))))
        , configMap_(ReaderConfig::InitConfigMap(handle_))
        , readoutMode_(Readout::Omnidirectional)
      {
      }
 
 
      ReaderConfig(HandleGuard<ReaderConfig>&& guard) noexcept
        : handle_(std::move(guard))
      {
        readoutMode_ = Readout::Omnidirectional;
        UpdateMap();
      }
 
      ReaderConfig(ReaderConfig && other) = default;
 
      ReaderConfig & operator=(ReaderConfig && other) = default;
 
 
      void UpdateMap()
      {
        configMap_ = InitConfigMap(handle_);
      }
 
 
      static std::map<std::type_index, ConfigBasePtr> InitConfigMap(HandleGuard<ReaderConfig>& guard)
      {
        std::map<std::type_index, ConfigBasePtr> tmpMap;
        for (auto pair : TypeIdCtorMapping)
        {
          auto& id = pair.first;
          auto FromHandle = pair.second;
          bool isActive = false;
          auto pConfig = FromHandle(guard, isActive);
          if (isActive)
            tmpMap.insert(std::pair<std::type_index, ConfigBasePtr>(id, pConfig));
        }
        return tmpMap;
      }
 
 
      template<typename TConfig>
      bool TrySearchConfiguration(std::shared_ptr<TConfig>& configOut)
      {
        try
        {
          for (auto const& pair : configMap_)
            if (auto tmpConfig = std::dynamic_pointer_cast<TConfig>(pair.second))
            {
              configOut = tmpConfig;
              return true;
            }
        }
        catch (...)
        {
          return false;
        }
        return false;
      }
 
 
      void InsertConfiguration(std::type_index configId, ConfigBasePtr configuration)
      {
        if (configuration)
          configMap_.insert(std::pair<std::type_index, ConfigBasePtr>(configId, configuration));
        else
          throw std::runtime_error("Failed to insert configuration - NULL pointer");
      }
 
 
      void RemoveConfiguration(std::type_index configId)
      {
        if (auto config = configMap_.at(configId))
        {
          config->WriteToHandle(false, handle_);
          configMap_.erase(configId);
        }
        else
          throw std::runtime_error("Failed to remove barcode symbology from configuration. Not available/active.");
      }
 
 
    private:
      HandleGuard<ReaderConfig> handle_;
      std::map<std::type_index, ConfigBasePtr> configMap_;
 
      Readout readoutMode_;
 
      static const std::map<std::type_index, std::function<ConfigBasePtr(const HandleGuard<ReaderConfig>&, bool&)> > TypeIdCtorMapping;
      static const std::map<std::type_index, Symbology> TypeIdSymbologyMapping;
    };
 
  }
  using Barcode::ReaderConfig;
 
  CVB_END_INLINE_NS
}
 
 
const std::map<std::type_index, std::function<Cvb::Barcode::ConfigBasePtr(const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>&, bool&)> > Cvb::Barcode::ReaderConfig::TypeIdCtorMapping =
{
  { typeid(Cvb::Barcode::Codabar)               , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::Codabar::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::Code11)                , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::Code11::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::Code32)                , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::Code32::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::Discrete2of5)          , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::Discrete2of5::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::Ean8)                  , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::Ean8::FromHandle(guard, isActiveOut); } } ,
  { typeid(Cvb::Barcode::Ean13)                 , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::Ean13::FromHandle(guard, isActiveOut); } } ,
  { typeid(Cvb::Barcode::FourStateAustralian)   , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::FourStateAustralian::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::FourStateKix)          , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::FourStateKix::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::FourStateRoyalMail)    , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::FourStateRoyalMail::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::FourStateUsps)         , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::FourStateUsps::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::Interleaved2of5)       , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::Interleaved2of5::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::MicroPdf417)           , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::MicroPdf417::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::MsiPlessey)            , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::MsiPlessey::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::PharmaCode)            , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::PharmaCode::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::Planet)                , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::Planet::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::Postnet)               , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::Postnet::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::Rss)                   , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::Rss::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::UpcA)                  , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::UpcA::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::UpcE)                  , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::UpcE::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::Pdf417)                , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::Pdf417::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::DataMatrix)            , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::DataMatrix::FromHandle(guard, isActiveOut);} } ,
  //  PharmaCode2D has the same config like DataMaMatrix
  { typeid(Cvb::Barcode::Qr)                    , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::Qr::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::SonyCode)              , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::SonyCode::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::Code128)               , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::Code128::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::Code39)                , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::Code39::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::Code93)                , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::Code93::FromHandle(guard, isActiveOut);} } ,
  { typeid(Cvb::Barcode::QrGrading)             , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::QrGrading::FromHandle(guard, isActiveOut); } } ,
  { typeid(Cvb::Barcode::DataMatrixGrading)     , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::DataMatrixGrading::FromHandle(guard, isActiveOut); } } ,
  { typeid(Cvb::Barcode::BarcodeGrading)        , [](const Cvb::HandleGuard<Cvb::Barcode::ReaderConfig>& guard, bool& isActiveOut) { return Cvb::Barcode::BarcodeGrading::FromHandle(guard, isActiveOut); } }
};
 
const std::map<std::type_index, Cvb::Barcode::Symbology> Cvb::Barcode::ReaderConfig::TypeIdSymbologyMapping =
{
  { typeid(Cvb::Barcode::Codabar)                  , Cvb::Barcode::Symbology::Codabar                  } ,
  { typeid(Cvb::Barcode::Code11)                   , Cvb::Barcode::Symbology::Code11                   } ,
  { typeid(Cvb::Barcode::Code32)                   , Cvb::Barcode::Symbology::Code32                   } ,
  { typeid(Cvb::Barcode::Discrete2of5)             , Cvb::Barcode::Symbology::Discrete2of5             } ,
  { typeid(Cvb::Barcode::Ean8)                     , Cvb::Barcode::Symbology::Ean8                     } ,
  { typeid(Cvb::Barcode::Ean13)                    , Cvb::Barcode::Symbology::Ean13                    } ,
  { typeid(Cvb::Barcode::FourStateAustralian)      , Cvb::Barcode::Symbology::FourStateAustralian      } ,
  { typeid(Cvb::Barcode::FourStateKix)             , Cvb::Barcode::Symbology::FourStateKix             } ,
  { typeid(Cvb::Barcode::FourStateRoyalMail)       , Cvb::Barcode::Symbology::FourStateRoyalMail       } ,
  { typeid(Cvb::Barcode::FourStateUsps)            , Cvb::Barcode::Symbology::FourStateUsps            } ,
  { typeid(Cvb::Barcode::Interleaved2of5)          , Cvb::Barcode::Symbology::Interleaved2of5          } ,
  { typeid(Cvb::Barcode::MicroPdf417)              , Cvb::Barcode::Symbology::MicroPdf417              } ,
  { typeid(Cvb::Barcode::MsiPlessey)               , Cvb::Barcode::Symbology::MsiPlessey               } ,
  { typeid(Cvb::Barcode::PharmaCode)               , Cvb::Barcode::Symbology::PharmaCode               } ,
  { typeid(Cvb::Barcode::Planet)                   , Cvb::Barcode::Symbology::Planet                   } ,
  { typeid(Cvb::Barcode::Postnet)                  , Cvb::Barcode::Symbology::Postnet                  } ,
  { typeid(Cvb::Barcode::Rss)                      , Cvb::Barcode::Symbology::RSS                      } ,
  { typeid(Cvb::Barcode::UpcA)                     , Cvb::Barcode::Symbology::UpcA                     } ,
  { typeid(Cvb::Barcode::UpcE)                     , Cvb::Barcode::Symbology::UpcE                     } ,
  { typeid(Cvb::Barcode::Pdf417)                   , Cvb::Barcode::Symbology::Pdf417                   } ,
  { typeid(Cvb::Barcode::DataMatrix)               , Cvb::Barcode::Symbology::DataMatrix               } ,
  // PharmaCode2D has the same config like DataMatrix
  { typeid(Cvb::Barcode::Qr)                       , Cvb::Barcode::Symbology::Qr } ,
  { typeid(Cvb::Barcode::SonyCode)                 , Cvb::Barcode::Symbology::SonyCode                 } ,
  { typeid(Cvb::Barcode::Code128)                  , Cvb::Barcode::Symbology::Code128                  } ,
  { typeid(Cvb::Barcode::Code39)                   , Cvb::Barcode::Symbology::Code39                   } ,
  { typeid(Cvb::Barcode::Code93)                   , Cvb::Barcode::Symbology::Code93                   } ,
  { typeid(Cvb::Barcode::BarcodeGrading)           , Cvb::Barcode::Symbology::BarcodeGrading           } ,
  { typeid(Cvb::Barcode::QrGrading)                , Cvb::Barcode::Symbology::QrGrading                } ,
  { typeid(Cvb::Barcode::DataMatrixGrading)        , Cvb::Barcode::Symbology::DataMatrixGrading        } 
};