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 CodeReader
  {
 
    enum class Symbology;

    enum class DecodeStatus
    {
      Failure = -1,
      Success = 100
    };


    enum class CompositeType
    {
      None = 0,
      CCA = CExports::CVCRValueSymbology::CVCRVS_CCA,
      CCB = CExports::CVCRValueSymbology::CVCRVS_CCB,
      CCC = CExports::CVCRValueSymbology::CVCRVS_CCC
    };


    class Result2D
    {
      friend class ResultHandle;
 
    private:
      Result2D(int quality, int rows, int columns, const Size2D<double> &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<double> Size() const noexcept
      {
        return size_;
      }


      int Quality() const noexcept
      {
        return quality_;
      }


      int ErrorCorrectionCodewords() const noexcept
      {
        return errorCorrectionCodewords_;
      }


      int ErrorCorrectionErasureCodewords() const noexcept
      {
        return errorCorrectionErasureCodewords_;
      }


      CodeReader::CompositeType CompositeType() const noexcept
      {
        return compositeType_;
      }
 
    private:
      int quality_                         = 0;  // 0-100
      int errorCorrectionCodewords_        = 0;
      int errorCorrectionErasureCodewords_ = 0;
      int rows_                            = 0;
      int columns_                         = 0;
      Size2D<double> size_;
 
      CodeReader::CompositeType compositeType_;
    };


    class Result final
    {
      friend class ResultHandle;
 
    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) {};
 
      Result(String &&data, const Point2D<int> &center, std::array<Point2D<int>, 4> &&corners, Symbology symbology,
             DecodeStatus decodeStatus, const Cvb::optional<class Result2D> &result2D = {})
          : data_(std::move(data))
          , center_(center)
          , corners_(std::move(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_;
      }


      CodeReader::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;
      CodeReader::DecodeStatus decodeStatus_ = CodeReader::DecodeStatus::Failure;
 
      Cvb::optional<class Result2D> result2D_;
    };
  }  // namespace CodeReader
 
  CVB_END_INLINE_NS
}  // namespace Cvb