result.hpp

#pragma once
 
#include "../point_2d.hpp"
 
#include "../size_2d.hpp"
#include "../string.hpp"
#include "../shims/stdoptional.hpp"
 
#include "_decl/decl_config_base.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
 
  namespace Barcode
  {
    
    enum class Symbology;
 
    enum class DecodeStatus
    {
      Failure = -1,
      Success = 100
    };
 
 
    class Result2D
    {
      friend class Decoder;
    
    public:
 
      enum class CompositeType
      {
        None = 0,
        CCA  = CExports::CVBCValueSymbology::CVBCVS_CCA,
        CCB  = CExports::CVBCValueSymbology::CVBCVS_CCB,
        CCC  = CExports::CVBCValueSymbology::CVBCVS_CCC
      };
 
    private:
      Result2D(int quality, int rows, int columns, const Size2D<float> &size, int errorCorrectionErasureCodewords,
               int errorCorrectionCodewords, const CompositeType compositeType = CompositeType::None)
          : quality_(quality)
          , rows_(rows)
          , columns_(columns)
          , size_(size)
          , errorCorrectionCodewords_(errorCorrectionCodewords)
          , errorCorrectionErasureCodewords_(errorCorrectionErasureCodewords)
          , compositeType_(compositeType)
      {
      }
 
    public:
 
      int Rows() const noexcept
      {
        return rows_;
      }
 
 
      int Columns() const noexcept
      {
        return columns_;
      }
 
 
      Size2D<float> Size() const noexcept
      {
        return size_;
      }
 
 
      int Quality() const noexcept
      {
        return quality_;
      }
      
 
      int ErrorCorrectionCodewords() 
      {
        return errorCorrectionCodewords_;
      }
      
 
      int ErrorCorrectionErasureCodewords() 
      {
        return errorCorrectionErasureCodewords_;
      }
 
 
      CompositeType CompositeType()
      {
        return compositeType_;
      }
 
    private:
      int quality_ = 0;  // 0-100
      int errorCorrectionCodewords_ = 0;
      int errorCorrectionErasureCodewords_ = 0;
      int rows_    = 0;
      int columns_ = 0;
      Size2D<float> size_;
 
      enum class CompositeType compositeType_;
    };
 
 
    class Result final
    {
      friend class Decoder;
 
    private:
      Result(const String &data, const Point2D<int> &center, const std::array<Point2D<int>, 4> &corners,
             Symbology symbology, DecodeStatus decodeStatus, const Cvb::optional<class Result2D> &result2D = {})
          : data_(data)
          , center_(center)
          , corners_(corners)
          , symbology_(symbology)
          , decodeStatus_(decodeStatus)
          , result2D_(result2D){};
 
    public:
      Result() = default;
 
 
      String Data() const
      {
        return data_;
      }
 
 
      Point2D<int> Center() const noexcept
      {
        return center_;
      }
 
 
      std::array<Point2D<int>, 4> Corners() const noexcept
      {
        return corners_;
      }
 
 
      Symbology SymbologyType() const noexcept
      {
        return symbology_;
      }
 
 
      DecodeStatus DecodeStatus() const noexcept
      {
        return decodeStatus_;
      }
 
 
      Cvb::optional<class Result2D> Result2D() const noexcept
      {
        return result2D_;
      }
 
    private:
      String data_;
      Point2D<int> center_;
      std::array<Point2D<int>, 4> corners_;
      Symbology symbology_ = Symbology::Unknown;
      enum class DecodeStatus decodeStatus_ = DecodeStatus::Failure;
 
      Cvb::optional<class Result2D> result2D_;
    };
 
  }  // namespace Barcode
 
  CVB_END_INLINE_NS
}  // namespace Cvb