error.hpp

Go to the documentation of this file.

/*------------------------------------------------------------------------------
    Copyright Butterfly Energy Systems 2014-2015, 2022.
    Distributed under the Boost Software License, Version 1.0.
    http://www.boost.org/LICENSE_1_0.txt
------------------------------------------------------------------------------*/
 
#ifndef CPPWAMP_ERROR_HPP
#define CPPWAMP_ERROR_HPP
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
#include <sstream>
#include <stdexcept>
#include <string>
#include <system_error>
#include "api.hpp"
#include "config.hpp"
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#define CPPWAMP_LOGIC_ERROR(msg) \
    error::Logic::raise(__FILE__, __LINE__, (msg));
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#define CPPWAMP_LOGIC_CHECK(cond, msg) \
    {error::Logic::check((cond), __FILE__, __LINE__, (msg));}
 
namespace wamp
{
 
//******************************************************************************
// Exception Types
//******************************************************************************
 
namespace error
{
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Failure : public std::system_error
{
public:
    static std::string makeMessage(std::error_code ec);
 
    static std::string makeMessage(std::error_code ec, const std::string& info);
 
    explicit Failure(std::error_code ec);
 
    Failure(std::error_code ec, const std::string& info);
};
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
struct CPPWAMP_API Logic : public std::logic_error
{
    using std::logic_error::logic_error;
 
    static void raise(const char* file, int line, const std::string& msg);
 
    static void check(bool condition, const char* file, int line,
                      const std::string& msg);
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
struct CPPWAMP_API BadType : public std::runtime_error
{
    explicit BadType(const std::string& what);
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
struct CPPWAMP_API Access : public BadType
{
    explicit Access(const std::string& what);
    Access(const std::string& from, const std::string& to);
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
struct CPPWAMP_API Conversion : public BadType
{
    explicit Conversion(const std::string& what);
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
struct CPPWAMP_API Decode: public std::runtime_error
{
    explicit Decode(const std::string& what);
};
 
} // namespace error
 
 
//******************************************************************************
// Session Error Codes
//******************************************************************************
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
enum class SessionErrc
{
    // Generic errors
    success = 0,            
    sessionEnded,           
    sessionEndedByPeer,     
    allTransportsFailed,    
    joinError,              
    publishError,           
    subscribeError,         
    unsubscribeError,       
    registerError,          
    unregisterError,        
    callError,              
    invalidState,           
 
    // Errors mapped to predefined URIs
    invalidUri,             
    noSuchProcedure,        
    procedureAlreadyExists, 
    noSuchRegistration,     
    noSuchSubscription,     
    invalidArgument,        
    systemShutdown,         
    closeRealm,             
    goodbyeAndOut,          
    notAuthorized,          
    authorizationFailed,    
    noSuchRealm,            
    noSuchRole,             
    cancelled,              
    optionNotAllowed,       
    noEligibleCallee,       
    discloseMeDisallowed,   
    networkFailure          
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API SessionCategory : public std::error_category
{
public:
    virtual const char* name() const noexcept override;
 
    virtual std::string message(int ev) const override;
 
    virtual bool equivalent(const std::error_code& code,
                            int condition) const noexcept override;
 
private:
    CPPWAMP_HIDDEN SessionCategory();
 
    friend SessionCategory& wampCategory();
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
CPPWAMP_API SessionCategory& wampCategory();
 
//------------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CPPWAMP_API std::error_code make_error_code(SessionErrc errc);
 
//------------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CPPWAMP_API std::error_condition make_error_condition(SessionErrc errc);
 
//------------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CPPWAMP_API bool lookupWampErrorUri(const std::string& uri,
                                    SessionErrc fallback, SessionErrc& result);
 
 
//******************************************************************************
// Codec decoding Error Codes
//******************************************************************************
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
enum class DecodingErrc
{
    success           = 0, 
    failure           = 1, 
    emptyInput        = 2, 
    expectedStringKey = 3, 
    badBase64Length   = 4, 
    badBase64Padding  = 5, 
    badBase64Char     = 6  
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API DecodingCategory : public std::error_category
{
public:
    virtual const char* name() const noexcept override;
 
    virtual std::string message(int ev) const override;
 
    virtual bool equivalent(const std::error_code& code,
                            int condition) const noexcept override;
 
private:
    CPPWAMP_HIDDEN DecodingCategory();
 
    friend DecodingCategory& decodingCategory();
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
CPPWAMP_API DecodingCategory& decodingCategory();
 
//------------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CPPWAMP_API std::error_code make_error_code(DecodingErrc errc);
 
//------------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CPPWAMP_API std::error_condition make_error_condition(DecodingErrc errc);
 
 
//******************************************************************************
// Protocol Error Codes
//******************************************************************************
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
enum class ProtocolErrc
{
    success = 0,    
    badDecode,      
    badSchema,      
    unsupportedMsg, 
    unexpectedMsg   
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API ProtocolCategory : public std::error_category
{
public:
    virtual const char* name() const noexcept override;
 
    virtual std::string message(int ev) const override;
 
    virtual bool equivalent(const std::error_code& code,
                            int condition) const noexcept override;
 
private:
    CPPWAMP_HIDDEN ProtocolCategory();
 
    friend ProtocolCategory& protocolCategory();
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
CPPWAMP_API ProtocolCategory& protocolCategory();
 
//------------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CPPWAMP_API std::error_code make_error_code(ProtocolErrc errc);
 
//------------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CPPWAMP_API std::error_condition make_error_condition(ProtocolErrc errc);
 
 
//******************************************************************************
// Transport Error Codes
//******************************************************************************
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
enum class TransportErrc
{
    success     = 0, 
    aborted     = 1, 
    failed      = 2, 
    badTxLength = 3, 
    badRxLength = 4  
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API TransportCategory : public std::error_category
{
public:
    virtual const char* name() const noexcept override;
 
    virtual std::string message(int ev) const override;
 
    virtual bool equivalent(const std::error_code& code,
                            int condition) const noexcept override;
 
private:
    CPPWAMP_HIDDEN TransportCategory();
 
    friend TransportCategory& transportCategory();
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
CPPWAMP_API TransportCategory& transportCategory();
 
//------------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CPPWAMP_API std::error_code make_error_code(TransportErrc errc);
 
//------------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CPPWAMP_API std::error_condition make_error_condition(TransportErrc errc);
 
 
//******************************************************************************
// Raw Socket Error Codes
//******************************************************************************
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
enum class RawsockErrc
{
    success                 = 0, 
    badSerializer           = 1, 
    badMaxLength            = 2, 
    reservedBitsUsed        = 3, 
    maxConnectionsReached   = 4, 
    // 5-15 reserved for future WAMP raw socket error responses
 
    badHandshake            = 16, 
    badMessageType          = 17  
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API RawsockCategory : public std::error_category
{
public:
    virtual const char* name() const noexcept override;
 
    virtual std::string message(int ev) const override;
 
    virtual bool equivalent(const std::error_code& code,
                            int condition) const noexcept override;
 
private:
    CPPWAMP_HIDDEN RawsockCategory();
 
    friend RawsockCategory& rawsockCategory();
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
CPPWAMP_API RawsockCategory& rawsockCategory();
 
//------------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CPPWAMP_API std::error_code make_error_code(RawsockErrc errc);
 
//------------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CPPWAMP_API std::error_condition make_error_condition(RawsockErrc errc);
 
} // namespace wamp
 
 
//------------------------------------------------------------------------------
#if !defined CPPWAMP_FOR_DOXYGEN
namespace std
{
 
template <>
struct CPPWAMP_API is_error_condition_enum<wamp::SessionErrc>
    : public true_type
{};
 
template <>
struct CPPWAMP_API is_error_condition_enum<wamp::DecodingErrc>
    : public true_type
{};
 
template <>
struct CPPWAMP_API is_error_condition_enum<wamp::ProtocolErrc>
    : public true_type
{};
 
template <>
struct CPPWAMP_API is_error_condition_enum<wamp::TransportErrc>
    : public true_type
{};
 
template <>
struct CPPWAMP_API is_error_condition_enum<wamp::RawsockErrc>
    : public true_type
{};
 
} // namespace std
#endif // !defined CPPWAMP_FOR_DOXYGEN
 
 
#ifndef CPPWAMP_COMPILED_LIB
#include "internal/error.ipp"
#endif
 
#endif // CPPWAMP_ERROR_HPP