error.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later OR BSD-3-Clause
/***************************************************************************
 *   Copyright (C) 2007,2008,2009,2010 by Rick L. Vinyard, Jr.             *
 *   rvinyard@cs.nmsu.edu                                                  *
 *                                                                         *
 *   This file is part of the dbus-cxx library.                            *
 ***************************************************************************/
#include <exception>
#include <string>
#include <dbus-cxx/dbus-error.h>
 
#ifndef DBUSCXX_ERROR_H
#define DBUSCXX_ERROR_H
 
namespace DBus {
 
class Message;
 
class Error : public std::exception {
public:
    Error();
 
    Error( const char* name, const char* message = nullptr );
 
    Error( const char* name, std::string message );
 
    Error( std::string name, std::string message );
 
    ~Error() noexcept;
 
    const char* what() const noexcept;
 
    std::string name() const;
 
    std::string message() const;
 
protected:
    std::string m_name;
    std::string m_message;
 
};
 
#define DBUSCXX_ERROR( CPPTYPE, DBUS_ERROR_CODE )            \
    class CPPTYPE : public Error {                             \
    public:                                                  \
        CPPTYPE( const char* message = nullptr )                 \
            : Error( DBUS_ERROR_CODE, message ) {}               \
        CPPTYPE( std::string message )                           \
            : Error( DBUS_ERROR_CODE, message ) {}               \
    }
 
DBUSCXX_ERROR( ErrorFailed, DBUSCXX_ERROR_FAILED );
 
DBUSCXX_ERROR( ErrorNoMemory, DBUSCXX_ERROR_NO_MEMORY );
 
DBUSCXX_ERROR( ErrorServiceUnknown, DBUSCXX_ERROR_SERVICE_UNKNOWN );
 
DBUSCXX_ERROR( ErrorNameHasNoOwner, DBUSCXX_ERROR_NAME_HAS_NO_OWNER );
 
DBUSCXX_ERROR( ErrorNoReply, DBUSCXX_ERROR_NO_REPLY );
 
DBUSCXX_ERROR( ErrorIOError, DBUSCXX_ERROR_IO_ERROR );
 
DBUSCXX_ERROR( ErrorBadAddress, DBUSCXX_ERROR_BAD_ADDRESS );
 
DBUSCXX_ERROR( ErrorNotSupported, DBUSCXX_ERROR_NOT_SUPPORTED );
 
DBUSCXX_ERROR( ErrorLimitsExceeded, DBUSCXX_ERROR_LIMITS_EXCEEDED );
 
DBUSCXX_ERROR( ErrorAccessDenied, DBUSCXX_ERROR_ACCESS_DENIED );
 
DBUSCXX_ERROR( ErrorAuthFailed, DBUSCXX_ERROR_AUTH_FAILED );
 
DBUSCXX_ERROR( ErrorNoServer, DBUSCXX_ERROR_NO_SERVER );
 
DBUSCXX_ERROR( ErrorTimeout, DBUSCXX_ERROR_TIMEOUT );
 
DBUSCXX_ERROR( ErrorNoNetwork, DBUSCXX_ERROR_NO_NETWORK );
 
DBUSCXX_ERROR( ErrorAddressInUse, DBUSCXX_ERROR_ADDRESS_IN_USE );
 
DBUSCXX_ERROR( ErrorDisconnected, DBUSCXX_ERROR_DISCONNECTED );
 
DBUSCXX_ERROR( ErrorInvalidArgs, DBUSCXX_ERROR_INVALID_ARGS );
 
DBUSCXX_ERROR( ErrorFileNotFound, DBUSCXX_ERROR_FILE_NOT_FOUND );
 
DBUSCXX_ERROR( ErrorFileExists, DBUSCXX_ERROR_FILE_EXISTS );
 
DBUSCXX_ERROR( ErrorUnknownMethod, DBUSCXX_ERROR_UNKNOWN_METHOD );
 
DBUSCXX_ERROR( ErrorUnknownObject, DBUSCXX_ERROR_UNKNOWN_OBJECT );
 
DBUSCXX_ERROR( ErrorUnknownInterface, DBUSCXX_ERROR_UNKNOWN_INTERFACE );
 
DBUSCXX_ERROR( ErrorUnknownProperty, DBUSCXX_ERROR_UNKNOWN_PROPERTY );
 
DBUSCXX_ERROR( ErrorPropertyReadOnly, DBUSCXX_ERROR_PROPERTY_READ_ONLY );
 
DBUSCXX_ERROR( ErrorTimedOut, DBUSCXX_ERROR_TIMED_OUT );
 
DBUSCXX_ERROR( ErrorMatchRuleNotFound, DBUSCXX_ERROR_MATCH_RULE_NOT_FOUND );
 
DBUSCXX_ERROR( ErrorMatchRuleInvalid, DBUSCXX_ERROR_MATCH_RULE_INVALID );
 
DBUSCXX_ERROR( ErrorSpawnExecFailed, DBUSCXX_ERROR_SPAWN_EXEC_FAILED );
 
DBUSCXX_ERROR( ErrorSpawnForkFailed, DBUSCXX_ERROR_SPAWN_FORK_FAILED );
 
DBUSCXX_ERROR( ErrorSpawnChildExited, DBUSCXX_ERROR_SPAWN_CHILD_EXITED );
 
DBUSCXX_ERROR( ErrorSpawnChildSignaled, DBUSCXX_ERROR_SPAWN_CHILD_SIGNALED );
 
DBUSCXX_ERROR( ErrorSpawnFailed, DBUSCXX_ERROR_SPAWN_FAILED );
 
DBUSCXX_ERROR( ErrorUnixProcessIdUnknown, DBUSCXX_ERROR_UNIX_PROCESS_ID_UNKNOWN );
 
DBUSCXX_ERROR( ErrorInvalidSignature, DBUSCXX_ERROR_INVALID_SIGNATURE );
 
DBUSCXX_ERROR( ErrorInvalidFileContent, DBUSCXX_ERROR_INVALID_FILE_CONTENT );
 
DBUSCXX_ERROR( ErrorSELinuxSecurityContextUnknown, DBUSCXX_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN );
 
DBUSCXX_ERROR( ErrorInvalidCObject, "Invalid C Object" );
 
DBUSCXX_ERROR( ErrorInvalidTypecast, "Invalid Typecast" );
 
DBUSCXX_ERROR( ErrorInvalidConnection, "DBus connection is invalid" );
 
DBUSCXX_ERROR( ErrorInvalidMessageType, "DBus message type does not match the C++ Message object type" );
 
DBUSCXX_ERROR( ErrorNoConnection, "No connection specified and operation requires a DBus connection" );
 
DBUSCXX_ERROR( ErrorDeadlock, "Locking a mutex a dbus-cxx thread already owns" );
 
DBUSCXX_ERROR( ErrorNotOwner, "Unlocking a mutex a dbus-cxx thread doesn't own" );
 
DBUSCXX_ERROR( ErrorNotInitialized, "DBus::init(bool threadsafe=true) not called" );
 
DBUSCXX_ERROR( ErrorInvalidAdaptee, "DBus adapter method called, but adaptee is invalid" );
 
DBUSCXX_ERROR( ErrorDispatcherInitFailed, "DBus::Dispatcher initialization failed" );
 
DBUSCXX_ERROR( ErrorInvalidSharedPtr, "shared_ptr was invalid" );
 
DBUSCXX_ERROR( ErrorPollFailed, "poll() syscall failed" );
 
DBUSCXX_ERROR( ErrorInvalidReturn, "dbuscxx.Error.InvalidReturnValue" );
 
DBUSCXX_ERROR( ErrorUnexpectedResponse, "dbuscxx.Error.UnexpectedResponse" );
 
class ErrorIncorrectDispatchThread : public Error {
public:
    ErrorIncorrectDispatchThread( const char* message = nullptr )
        : Error( nullptr, message ) {}
};
 
class ErrorRemoteException : public Error {
public:
    ErrorRemoteException( const char* message = nullptr )
        : Error( nullptr, message ) {}
};
 
class ErrorUnknown : public Error {
public:
    ErrorUnknown( const char* message = nullptr )
        : Error( nullptr, message ) {}
};
 
class ErrorBadVariantCast : public Error {
public:
    ErrorBadVariantCast( const char* message = nullptr )
        : Error( nullptr, message ) {}
};
 
class ErrorUnableToParse : public Error {
public:
    ErrorUnableToParse( const char* message = nullptr )
        : Error( nullptr, message ) {}
};
 
class ErrorInvalidMessage : public Error {
public:
    ErrorInvalidMessage( const char* message = nullptr )
        : Error( nullptr, message ) {}
};
 
class ErrorMessageNestedTooDeep : public Error {
public:
    ErrorMessageNestedTooDeep( const char* message = nullptr )
        : Error( nullptr, message ) {}
};
 
}
 
#endif