exception.hpp

#pragma once
 
#include <exception>
#include <new>
#include <stdexcept>
 
#include "_cexports/c_error.h"
 
#include "global.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS

  namespace ErrorCodes
  {

    const int CVB_OK = CExports::CVC_E_OK;
    const int CVB_ERROR = static_cast<int>(CExports::CVC_E_ERROR | 0x80000000);
    const int CVB_PARAMETER = static_cast<int>(CExports::CVC_E_PARAMETER | 0x80000000);
    const int CVB_FILEIO = static_cast<int>(CExports::CVC_E_FILEIO | 0x80000000);
    const int CVB_TIMEOUT = static_cast<int>(CExports::CVC_E_TIMEOUT | 0x80000000);
    const int CVB_MEMORY = static_cast<int>(CExports::CVC_E_MEMORY | 0x80000000);
    const int CVB_INVALIDPLANE = static_cast<int>(CExports::CVC_E_INVALIDPLANE | 0x80000000);
    const int CVB_UNSUPPORTEDDATATYPE = static_cast<int>(CExports::CVC_E_UNSUPPORTEDDATATYPE | 0x80000000);
    const int CVB_INVALIDCAMERAPORT = static_cast<int>(CExports::CVC_E_INVALIDCAMERAPORT | 0x80000000);
    const int CVB_BOARDSELECT = static_cast<int>(CExports::CVC_E_BOARDSELECT | 0x80000000);
    const int CVB_INVALIDTRIGGERMODE = static_cast<int>(CExports::CVC_E_INVALIDTRIGGERMODE | 0x80000000);
    const int CVB_PROPERTYREAD = static_cast<int>(CExports::CVC_E_PROPERTYREAD | 0x80000000);
    const int CVB_PROPERTYWRITE = static_cast<int>(CExports::CVC_E_PROPERTYWRITE | 0x80000000);
    const int CVB_INVALIDPORT = static_cast<int>(CExports::CVC_E_INVALIDPORT | 0x80000000);
    const int CVB_PORTREAD = static_cast<int>(CExports::CVC_E_PORTREAD | 0x80000000);
    const int CVB_PORTWRITE = static_cast<int>(CExports::CVC_E_PORTWRITE | 0x80000000);
    const int CVB_NOIMAGE = static_cast<int>(CExports::CVC_E_NOIMAGE | 0x80000000);
    const int CVB_NOINTERFACE = static_cast<int>(CExports::CVC_E_NOINTERFACE | 0x80000000);
    const int CVB_BUSY = static_cast<int>(CExports::CVC_E_BUSY | 0x80000000);
    const int CVB_NOTSUPPORTED = static_cast<int>(CExports::CVC_E_NOTSUPPORTED | 0x80000000);
    const int CVB_GRABABORTED = static_cast<int>(CExports::CVC_E_GRABABORTED | 0x80000000);
    const int CVB_NOPIXELLIST = static_cast<int>(CExports::CVC_E_NOPIXELLIST | 0x80000000);
    const int CVB_NOTENOUGHDATA = static_cast<int>(CExports::CVC_E_NOTENOUGHDATA | 0x80000000);
    const int CVB_NOTRANSFORMATION = static_cast<int>(CExports::CVC_E_NOTRANSFORMATION | 0x80000000);
    const int CVB_LINEAR_ONLY = static_cast<int>(CExports::CVC_E_LINEAR_ONLY | 0x80000000);
    const int CVB_DIVISIONBYZERO = static_cast<int>(CExports::CVC_E_DIVISIONBYZERO | 0x80000000);
    const int CVB_INVALIDDIMENSION = static_cast<int>(CExports::CVC_E_INVALIDDIMENSION | 0x80000000);
    const int CVB_INVALIDCOLORMODEL = static_cast<int>(CExports::CVC_E_INVALIDCOLORMODEL | 0x80000000);
    const int CVB_INVALIDDATATYPE = static_cast<int>(CExports::CVC_E_INVALIDDATATYPE | 0x80000000);
    const int CVB_WRONGOBJECT = static_cast<int>(CExports::CVC_E_WRONGOBJECT | 0x80000000);
    const int CVB_NOTREADY = static_cast<int>(CExports::CVC_E_NOTREADY | 0x80000000);
    const int CVB_NOANGLE = static_cast<int>(CExports::CVC_E_NOANGLE | 0x80000000);
    const int CVB_NOVECTOR2D = static_cast<int>(CExports::CVC_E_NOVECTOR2D | 0x80000000);
    const int CVB_NOLINE2D = static_cast<int>(CExports::CVC_E_NOLINE2D | 0x80000000);
    const int CVB_VECTOR2D_ZERO_LENGTH = static_cast<int>(CExports::CVC_E_VECTOR2D_ZERO_LENGTH | 0x80000000);
    const int CVB_VECTORS_IDENTICAL = static_cast<int>(CExports::CVC_E_VECTORS_IDENTICAL | 0x80000000);
    const int CVB_LINE2D_VERTICAL = static_cast<int>(CExports::CVC_E_LINE2D_VERTICAL | 0x80000000);
    const int CVB_LINE2D_HORIZONTAL = static_cast<int>(CExports::CVC_E_LINE2D_HORIZONTAL | 0x80000000);
    const int CVB_NOARGUMENT = static_cast<int>(CExports::CVC_E_NOARGUMENT | 0x80000000);
    const int CVB_LINE2D_UNDEFINED = static_cast<int>(CExports::CVC_E_LINE2D_UNDEFINED | 0x80000000);
    const int CVB_NOINTERSECTION = static_cast<int>(CExports::CVC_E_NOINTERSECTION | 0x80000000);
    const int CVB_NOCLIPPING = static_cast<int>(CExports::CVC_E_NOCLIPPING | 0x80000000);
    const int CVB_NOTENOUGHLINES = static_cast<int>(CExports::CVC_E_NOTENOUGHLINES | 0x80000000);
    const int CVB_OVERFLOW = static_cast<int>(CExports::CVC_E_OVERFLOW | 0x80000000);  // OVERFLOW clash with math.h
    const int CVB_NOCIRCLE = static_cast<int>(CExports::CVC_E_NOCIRCLE | 0x80000000);
    const int CVB_ACCESS = static_cast<int>(CExports::CVC_E_ACCESS | 0x80000000);
    const int CVB_NOTPRESENT = static_cast<int>(CExports::CVC_E_NOTPRESENT | 0x80000000);
    const int CVB_UNSUPPORTEDFEATURE = static_cast<int>(CExports::CVC_E_UNSUPPORTEDFEATURE | 0x80000000);
    const int CVB_INVALIDINDEX = static_cast<int>(CExports::CVC_E_INVALIDINDEX | 0x80000000);
    const int CVB_NOOVERLAY = static_cast<int>(CExports::CVC_E_NOOVERLAY | 0x80000000);
    const int CVB_INVALIDSTATE = static_cast<int>(CExports::CVC_E_INVALIDSTATE | 0x80000000);
    const int CVB_EMPTYRESULT = static_cast<int>(CExports::CVC_E_EMPTYRESULT | 0x80000000);
 
    inline int FromRes(CExports::cvbres_t hr) noexcept
    {
      return static_cast<int>((hr) & 0x7FFFFFFF);
    }
 
  };  // namespace ErrorCodes
  namespace ErrorCodes {…}


  class CvbException : public std::runtime_error
  {
  public:
    static std::exception_ptr FromCvbResult(int errorCode, const std::string &message) noexcept
    {
      switch (errorCode)
      {
        case ErrorCodes::CVB_PARAMETER:
        case ErrorCodes::CVB_NOARGUMENT:
        case ErrorCodes::CVB_NOINTERSECTION:
        case ErrorCodes::CVB_NOCLIPPING:
        case ErrorCodes::CVB_VECTOR2D_ZERO_LENGTH:
        case ErrorCodes::CVB_VECTORS_IDENTICAL:
        case ErrorCodes::CVB_LINE2D_VERTICAL:
        case ErrorCodes::CVB_LINE2D_HORIZONTAL:
          return std::make_exception_ptr(std::invalid_argument(message));
 
        case ErrorCodes::CVB_INVALIDCAMERAPORT:
        case ErrorCodes::CVB_INVALIDPORT:
        case ErrorCodes::CVB_INVALIDPLANE:
        case ErrorCodes::CVB_BOARDSELECT:
        case ErrorCodes::CVB_INVALIDINDEX:
        case ErrorCodes::CVB_INVALIDTRIGGERMODE:
          return std::make_exception_ptr(std::out_of_range(message));
 
        case ErrorCodes::CVB_DIVISIONBYZERO:
        case ErrorCodes::CVB_LINEAR_ONLY:
        case ErrorCodes::CVB_UNSUPPORTEDDATATYPE:
        case ErrorCodes::CVB_INVALIDDIMENSION:
        case ErrorCodes::CVB_INVALIDCOLORMODEL:
        case ErrorCodes::CVB_INVALIDDATATYPE:
        case ErrorCodes::CVB_NOOVERLAY:
        case ErrorCodes::CVB_LINE2D_UNDEFINED:
        case ErrorCodes::CVB_NOTENOUGHDATA:
        case ErrorCodes::CVB_NOTENOUGHLINES:
        case ErrorCodes::CVB_UNSUPPORTEDFEATURE:
        case ErrorCodes::CVB_BUSY:
        case ErrorCodes::CVB_NOTREADY:
        case ErrorCodes::CVB_NOTSUPPORTED:
          return std::make_exception_ptr(std::domain_error(message));
 
        case ErrorCodes::CVB_MEMORY:
          return std::make_exception_ptr(std::bad_alloc());
 
        case ErrorCodes::CVB_OVERFLOW:
          return std::make_exception_ptr(std::overflow_error(message));
 
        default:
          return std::make_exception_ptr(CvbException(message, errorCode));
      }
    }


    int ErrorCode() const noexcept
    {
      return errorCode_;
    }
    int ErrorCode() const noexcept {…}
 
  private:
    CvbException(const std::string &message, int errorCode) noexcept
        : std::runtime_error(message)
        , errorCode_(errorCode)
    {
    }
 
    int errorCode_ = 0;
  };
  class CvbException : public std::runtime_error {…};
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb