dpyError.h

/*
 * dpyError.h
 */
#pragma once

#ifndef DPY_ERROR
#define DPY_ERROR

#include <boost/system/error_code.hpp>
#include <boost/version.hpp>


#ifdef TESTING
#include "gtest/gtest.h"
#endif

#define XSTR(x) STR(x)
#define STR(x) #x

#if BOOST_VERSION < 107000
#define BOOST_IO_CONTEXT boost::asio::io_context
#define BOOST_GET_CONTEXT(x) x->get_executor().context()
#define BOOST_GET_EXECUTOR(x) boost::ref(x)
#else 
#define BOOST_IO_CONTEXT const boost::asio::any_io_executor
#define BOOST_GET_CONTEXT(x) x->get_executor()
#define BOOST_GET_EXECUTOR(x) x.get_executor()
#endif


enum dpy_errors
{
    DPY_OK = 0, 
    DPY_NOT_FOUND = 1, 
    DPY_FORMAT_ERROR = 2, 
    DPY_OVERFLOW = 3, 
    DPY_UNAVAILABLE = 4, 
    DPY_TERMINATED = 5, 
    DPY_IO_ERROR = 6, 
    DPY_COMM_ERROR = 7, 
    DPY_TIMEOUT = 8, 
    DPY_OUT_OF_RANGE = 9, 
    DPY_NO_MEMORY = 10, 
    DPY_NOT_PERMITTED = 11, 
    DPY_DUPLICATE = 12, 
    DPY_BAD_PARAMETER = 13, 
    DPY_CLOSED = 14, 
    DPY_BUSY = 15, 
    DPY_UNSUPPORTED = 16, 
    DPY_NOT_IMPLEMENTED = 17, 
    DPY_NO_EFFECT = 18, 
    DPY_COULD_NOT_OBTAIN_VALUE = 19, 
    DPY_EMPTY_MESSAGE = 20, 
    DPY_PARSE_ERROR = 21, 
    DPY_COMMAND_ERROR = 22, 
    DPY_INVALID_VALUE = 23, 
    DPY_INCOMPLETE = 24, 
    DPY_CONFIG_ERROR = 25, 
    DPY_NOT_READY = 26, 
    DPY_INVALID_CHECKSUM = 27, 
    DPY_REQUEST_PROCESSED = 28, 
    DPY_REQUEST_DEFERRED = 29, 

    DPY_FILE_COULD_NOT_BE_OPENED = 30, 
    DPY_FILE_DOES_NOT_EXIST = 31, 
    DPY_FILE_CORRUPTED = 32, 
    DPY_FILE_JSON_PARSE_ERROR = 33, 

    DPY_PORT_OPEN_ERROR = 40, 
    DPY_PORT_CLOSE_ERROR = 41, 
    DPY_PORT_OPEN_LOCK_ERROR = 42, 


    DPY_EXCEPTION = 45, 

};

#define ERROR_PARSE {ec=DPY_FILE_JSON_PARSE_ERROR;return false;}

class dpyError: public boost::system::error_category
{
public:

virtual ~dpyError() = default;
    virtual const char *name() const noexcept
    {
        return "DPY_ERRORS";
    }
    virtual std::string message(int e) const
    {
        switch (e) {
            case DPY_OK:
                return "Successful operation.";
            case DPY_NOT_FOUND:
                return "Referenced item does not exist or could not be found.";
            case DPY_FORMAT_ERROR:
                return "Format obtained does not meet the expected requirements";
            case DPY_OVERFLOW:
                return "An overflow occurred or would have occurred.";
            case DPY_UNAVAILABLE:
                return "A transient or temporary loss of a service or resource.";
            case DPY_TERMINATED:
                return "The process, operation, data stream, session, etc. has stopped.";
            case DPY_IO_ERROR:
                return "An IO operation failed.";
            case DPY_COMM_ERROR:
                return "Communications error.";
            case DPY_TIMEOUT:
                return "A time-out occurred.";
            case DPY_OUT_OF_RANGE:
                return "An index or other value is out of range.";
            case DPY_NO_MEMORY:
                return "Insufficient memory is available.";
            case DPY_NOT_PERMITTED:
                return "Requested action not permitted.";
            case DPY_DUPLICATE:
                return "Duplicate entry found or operation already performed.";
            case DPY_BAD_PARAMETER:
                return "Invalid parameter (out of range or invalid type).";
            case DPY_CLOSED:
                return "The resource is closed.";
            case DPY_BUSY:
                return "The resource is busy.";
            case DPY_UNSUPPORTED:
                return "The underlying resource does not support this operation.";
            case DPY_NOT_IMPLEMENTED:
                return "Unimplemented functionality.";
            case DPY_NO_EFFECT:
                return "Call has no effect.";
            case DPY_COULD_NOT_OBTAIN_VALUE:
                return "The value could not be obtained";
            case DPY_EMPTY_MESSAGE:
                return "The message is empty";
            case DPY_PARSE_ERROR:
                return "There was an error during parsing";
            case DPY_COMMAND_ERROR:
                return "Expected command response could not be received";
            case DPY_INVALID_VALUE:
                return "The value requested is not valid";
            case DPY_INCOMPLETE:
                return "The operation requested is missing one or more parameters";
            case DPY_CONFIG_ERROR:
                return "Configuration error occurred";
            case DPY_NOT_READY:
                return "The requested service is not ready yet";
            case DPY_INVALID_CHECKSUM:
                return "Checksum calculation has thrown an error";
            case DPY_REQUEST_PROCESSED:
                return "The request was processed but the result of the operation can't be known";
            case DPY_REQUEST_DEFERRED:
                return "The request was received and will be processed as soon as possible ";
            case DPY_FILE_COULD_NOT_BE_OPENED:
                return "File could not be opened.";
            case DPY_FILE_DOES_NOT_EXIST:
                return "File does not exist";
            case DPY_FILE_CORRUPTED:
                return "File is corrupted";
            case DPY_FILE_JSON_PARSE_ERROR:
                return "The json file could not be parsed";
            case DPY_PORT_OPEN_ERROR:
                return "Could not open the port";
            case DPY_PORT_CLOSE_ERROR:
                return "Could not close the port";
            case DPY_PORT_OPEN_LOCK_ERROR:
                return "Could not open the port, it is locked by another application";
            case DPY_EXCEPTION:
                return "Exception occurred while performing operation";
            default:
                return "unknown custom::category error";
        }
        return "unknown custom::category error";
    }
};

inline const boost::system::error_category& get_dpy_error_category();
static const boost::system::error_category& dpy_error_category = get_dpy_error_category();

const boost::system::error_category& get_dpy_error_category()
{
    static dpyError dpy_cat;
    return dpy_cat;
}


inline boost::system::error_code make_error_code(dpy_errors e)
{
    return boost::system::error_code(static_cast<int>(e), dpy_error_category);
}

namespace boost
{
namespace system
{
template<>
struct is_error_code_enum<dpy_errors>
{
    BOOST_STATIC_CONSTANT(bool, value = true);
};
}
} // namespaces

#endif