Error.h

Go to the documentation of this file.

 
//#include "RobotRaconteur/DataTypes.h"
#include "RobotRaconteur/RobotRaconteurConstants.h"
#include "RobotRaconteur/RobotRaconteurConfig.h"
#include <stdexcept>
#include <string>
#pragma once
 
namespace RobotRaconteur
{
 
class ROBOTRACONTEUR_CORE_API RRValue;
 
class ROBOTRACONTEUR_CORE_API RobotRaconteurException : public std::runtime_error
{
 
  public:
    RobotRaconteurException();
 
    RobotRaconteurException(MessageErrorType ErrorCode, const std::string& error, const std::string& message,
                            const std::string& sub_name, const RR_INTRUSIVE_PTR<RRValue>& param);
 
    RobotRaconteurException(const std::string& message, std::exception& innerexception);
 
    MessageErrorType ErrorCode;
 
    std::string Error;
 
    std::string Message;
 
    std::string ErrorSubName;
 
    RR_INTRUSIVE_PTR<RRValue> ErrorParam;
 
    virtual std::string ToString();
 
    RR_OVIRTUAL const char* what() const throw() RR_OVERRIDE;
 
    RR_OVIRTUAL ~RobotRaconteurException() throw() RR_OVERRIDE {}
 
  private:
    std::string what_string;
};
 
// clang-format off
#define RR_EXCEPTION_TYPES_INIT(M,M2) \
        M(ConnectionException, MessageErrorType_ConnectionError, "RobotRaconteur.ConnectionError") \
        M(ProtocolException, MessageErrorType_ProtocolError, "RobotRaconteur.ProtocolError") \
        M(ServiceNotFoundException, MessageErrorType_ServiceNotFound, "RobotRaconteur.ServiceNotFound") \
        M(ObjectNotFoundException, MessageErrorType_ObjectNotFound, "RobotRaconteur.ObjectNotFound") \
        M(InvalidEndpointException, MessageErrorType_InvalidEndpoint, "RobotRaconteur.InvalidEndpoint") \
        M(EndpointCommunicationFatalException, MessageErrorType_EndpointCommunicationFatalError, "RobotRaconteur.EndpointCommunicationFatalError") \
        M(NodeNotFoundException, MessageErrorType_NodeNotFound, "RobotRaconteur.NodeNotFound") \
        M(ServiceException, MessageErrorType_ServiceError,  "RobotRaconteur.ServiceError") \
        M(MemberNotFoundException, MessageErrorType_MemberNotFound, "RobotRaconteur.MemberNotFound") \
        M(MemberFormatMismatchException, MessageErrorType_MemberFormatMismatch, "RobotRaconteur.MemberFormatMismatch") \
        M(DataTypeMismatchException, MessageErrorType_DataTypeMismatch, "RobotRaconteur.DataTypeMismatch") \
        M(DataTypeException, MessageErrorType_DataTypeError, "RobotRaconteur.DataTypeError") \
        M(DataSerializationException, MessageErrorType_DataSerializationError, "RobotRaconteur.DataSerializationError") \
        M(MessageEntryNotFoundException, MessageErrorType_MessageEntryNotFound, "RobotRaconteur.MessageEntryNotFound") \
        M(MessageElementNotFoundException, MessageErrorType_MessageElementNotFound, "RobotRaconteur.MessageElementNotFound") \
        M2(UnknownException, MessageErrorType_UnknownError) \
        M(InvalidOperationException, MessageErrorType_InvalidOperation, "RobotRaconteur.InvalidOperation") \
        M(InvalidArgumentException, MessageErrorType_InvalidArgument, "RobotRaconteur.InvalidArgument") \
        M(OperationFailedException, MessageErrorType_OperationFailed, "RobotRaconteur.OperationFailed") \
        M(NullValueException, MessageErrorType_NullValue, "RobotRaconteur.NullValue") \
        M(InternalErrorException, MessageErrorType_InternalError, "RobotRaconteur.InternalError") \
        M(SystemResourcePermissionDeniedException, MessageErrorType_SystemResourcePermissionDenied, "RobotRaconteur.SystemResourcePermissionDenied") \
        M(OutOfSystemResourceException, MessageErrorType_OutOfSystemResource,  "RobotRaconteur.OutOfSystemResource") \
        M(SystemResourceException, MessageErrorType_SystemResourceError, "RobotRaconteur.SystemResourceError") \
        M(ResourceNotFoundException, MessageErrorType_ResourceNotFound, "RobotRaconteur.ResourceNotFound") \
        M(IOException, MessageErrorType_IOError, "RobotRaconteur.IOError") \
        M(BufferLimitViolationException, MessageErrorType_BufferLimitViolation, "RobotRaconteur.BufferLimitViolation") \
        M(ServiceDefinitionException, MessageErrorType_ServiceDefinitionError, "RobotRaconteur.ServiceDefinitionError") \
        M(OutOfRangeException, MessageErrorType_OutOfRange, "RobotRaconteur.OutOfRange") \
        M(KeyNotFoundException, MessageErrorType_KeyNotFound, "RobotRaconteur.KeyNotFound") \
        M(InvalidConfigurationException, MessageErrorType_InvalidConfiguration, "RobotRaconteur.InvalidConfiguration") \
        M(InvalidStateException, MessageErrorType_InvalidState, "RobotRaconteur.InvalidState") \
        M2(RobotRaconteurRemoteException, MessageErrorType_RemoteError) \
        M(RequestTimeoutException, MessageErrorType_RequestTimeout, "RobotRaconteur.RequestTimeout") \
        M(ReadOnlyMemberException, MessageErrorType_ReadOnlyMember, "RobotRaconteur.ReadOnlyMember") \
        M(WriteOnlyMemberException, MessageErrorType_WriteOnlyMember, "RobotRaconteur.WriteOnlyMember") \
        M(NotImplementedException, MessageErrorType_NotImplementedError, "RobotRaconteur.NotImplementedError") \
        M(MemberBusyException, MessageErrorType_MemberBusy, "RobotRaconteur.MemberBusy") \
        M(ValueNotSetException, MessageErrorType_ValueNotSet, "RobotRaconteur.ValueNotSet") \
        M(AuthenticationException, MessageErrorType_AuthenticationError, "RobotRaconteur.AuthenticationError") \
        M(ObjectLockedException, MessageErrorType_ObjectLockedError, "RobotRaconteur.ObjectLockedError") \
        M(PermissionDeniedException, MessageErrorType_PermissionDenied, "RobotRaconteur.PermissionDenied") \
        M(AbortOperationException, MessageErrorType_AbortOperation, "RobotRaconteur.AbortOperation") \
        M(OperationAbortedException, MessageErrorType_OperationAborted, "RobotRaconteur.OperationAborted") \
        M(StopIterationException, MessageErrorType_StopIteration, "RobotRaconteur.StopIteration") \
        M(OperationTimeoutException, MessageErrorType_OperationTimeout, "RobotRaconteur.OperationTimeout") \
        M(OperationCancelledException, MessageErrorType_OperationCancelled, "RobotRaconteur.OperationCancelled")
// clang-format on
 
#define RR_EXCEPTION_DECL_1(exp_cpp_type, exp_code, exp_type_str)                                                      \
    class ROBOTRACONTEUR_CORE_API exp_cpp_type : public RobotRaconteurException                                        \
    {                                                                                                                  \
      public:                                                                                                          \
        exp_cpp_type(const std::string& message, const std::string& sub_name = "",                                     \
                     const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());                           \
    };
 
#define RR_EXCEPTION_DECL_2(exp_cpp_type, exp_code)                                                                    \
    class ROBOTRACONTEUR_CORE_API exp_cpp_type : public RobotRaconteurException                                        \
    {                                                                                                                  \
      public:                                                                                                          \
        exp_cpp_type(const std::string& error, const std::string& message, const std::string& sub_name = "",           \
                     const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());                           \
        exp_cpp_type(std::exception& innerexception);                                                                  \
    };
 
RR_EXCEPTION_TYPES_INIT(RR_EXCEPTION_DECL_1, RR_EXCEPTION_DECL_2)
 
#undef RR_EXCEPTION_DECL_1
#undef RR_EXCEPTION_DECL_2
 
#ifdef GENERATING_DOCUMENTATION
 
class ConnectionException : public RobotRaconteurException
{
  public:
    ConnectionException(const std::string& message, std::string sub_name = "",
                        const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class ProtocolException : public RobotRaconteurException
{
  public:
    ProtocolException(const std::string& message, std::string sub_name = "",
                      const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class ServiceNotFoundException : public RobotRaconteurException
{
  public:
    ServiceNotFoundException(const std::string& message, std::string sub_name = "",
                             const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class ObjectNotFoundException : public RobotRaconteurException
{
  public:
    ObjectNotFoundException(const std::string& message, std::string sub_name = "",
                            const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class InvalidEndpointException : public RobotRaconteurException
{
 
  public:
    InvalidEndpointException(const std::string& message, std::string sub_name = "",
                             const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class EndpointCommunicationFatalException : public RobotRaconteurException
{
  public:
    EndpointCommunicationFatalException(const std::string& message, std::string sub_name = "",
                                        const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class NodeNotFoundException : public RobotRaconteurException
{
  public:
    NodeNotFoundException(const std::string& message, std::string sub_name = "",
                          const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class ServiceException : public RobotRaconteurException
{
  public:
    ServiceException(const std::string& message, std::string sub_name = "",
                     const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class MemberNotFoundException : public RobotRaconteurException
{
  public:
    MemberNotFoundException(const std::string& message, std::string sub_name = "",
                            const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class MemberFormatMismatchException : public RobotRaconteurException
{
 
  public:
    MemberFormatMismatchException(const std::string& message, std::string sub_name = "",
                                  const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class DataTypeMismatchException : public RobotRaconteurException
{
  public:
    DataTypeMismatchException(const std::string& message, std::string sub_name = "",
                              const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class DataTypeException : public RobotRaconteurException
{
  public:
    DataTypeException(const std::string& message, std::string sub_name = "",
                      const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class DataSerializationException : public RobotRaconteurException
{
  public:
    DataSerializationException(const std::string& message, std::string sub_name = "",
                               const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class MessageEntryNotFoundException : public RobotRaconteurException
{
  public:
    MessageEntryNotFoundException(const std::string& message, std::string sub_name = "",
                                  const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class MessageElementNotFoundException : public RobotRaconteurException
{
  public:
    MessageElementNotFoundException(const std::string& message, std::string sub_name = "",
                                    const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class UnknownException : public RobotRaconteurException
{
  public:
    UnknownException(const std::string& error, const std::string& message, std::string sub_name = "",
                     const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class InvalidOperationException : public RobotRaconteurException
{
  public:
    InvalidOperationException(const std::string& message, std::string sub_name = "",
                              const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class InvalidArgumentException : public RobotRaconteurException
{
  public:
    InvalidArgumentException(const std::string& message, std::string sub_name = "",
                             const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class OperationFailedException : public RobotRaconteurException
{
  public:
    OperationFailedException(const std::string& message, std::string sub_name = "",
                             const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class NullValueException : public RobotRaconteurException
{
  public:
    NullValueException(const std::string& message, std::string sub_name = "",
                       const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class InternalErrorException : public RobotRaconteurException
{
  public:
    InternalErrorException(const std::string& message, std::string sub_name = "",
                           const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class PermissionDeniedException : public RobotRaconteurException
{
  public:
    PermissionDeniedException(const std::string& message, std::string sub_name = "",
                              const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class SystemResourcePermissionDeniedException : public RobotRaconteurException
{
  public:
    SystemResourcePermissionDeniedException(const std::string& message, std::string sub_name = "",
                                            const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class OutOfSystemResourceException : public RobotRaconteurException
{
  public:
    OutOfSystemResourceException(const std::string& message, std::string sub_name = "",
                                 const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class SystemResourceException : public RobotRaconteurException
{
  public:
    SystemResourceException(const std::string& message, std::string sub_name = "",
                            const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class ResourceNotFoundException : public RobotRaconteurException
{
  public:
    ResourceNotFoundException(const std::string& message, std::string sub_name = "",
                              const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class IOException : public RobotRaconteurException
{
  public:
    IOException(const std::string& message, std::string sub_name = "",
                const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class BufferLimitViolationException : public RobotRaconteurException
{
  public:
    BufferLimitViolationException(const std::string& message, std::string sub_name = "",
                                  const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class ServiceDefinitionException : public RobotRaconteurException
{
  public:
    ServiceDefinitionException(const std::string& message, std::string sub_name = "",
                               const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class OutOfRangeException : public RobotRaconteurException
{
  public:
    OutOfRangeException(const std::string& message, std::string sub_name = "",
                        const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class KeyNotFoundException : public RobotRaconteurException
{
  public:
    KeyNotFoundException(const std::string& message, std::string sub_name = "",
                         const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class InvalidConfigurationException : public RobotRaconteurException
{
  public:
    InvalidConfigurationException(const std::string& message, std::string sub_name = "",
                                  const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class InvalidStateException : public RobotRaconteurException
{
  public:
    InvalidStateException(const std::string& message, std::string sub_name = "",
                          const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class RobotRaconteurRemoteException : public RobotRaconteurException
{
  public:
    RobotRaconteurRemoteException(const std::string& error, const std::string& message, std::string sub_name = "",
                                  const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
 
    RobotRaconteurRemoteException(std::exception& innerexception);
};
 
class RequestTimeoutException : public RobotRaconteurException
{
  public:
    RequestTimeoutException(const std::string& message, std::string sub_name = "",
                            const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class ReadOnlyMemberException : public RobotRaconteurException
{
  public:
    ReadOnlyMemberException(const std::string& message, std::string sub_name = "",
                            const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class WriteOnlyMemberException : public RobotRaconteurException
{
  public:
    WriteOnlyMemberException(const std::string& message, std::string sub_name = "",
                             const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class NotImplementedException : public RobotRaconteurException
{
  public:
    NotImplementedException(const std::string& message, std::string sub_name = "",
                            const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class MemberBusyException : public RobotRaconteurException
{
  public:
    MemberBusyException(const std::string& message, std::string sub_name = "",
                        const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class ValueNotSetException : public RobotRaconteurException
{
  public:
    ValueNotSetException(const std::string& message, std::string sub_name = "",
                         const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class AuthenticationException : public RobotRaconteurException
{
  public:
    AuthenticationException(const std::string& message, std::string sub_name = "",
                            const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class ObjectLockedException : public RobotRaconteurException
{
  public:
    ObjectLockedException(const std::string& message, std::string sub_name = "",
                          const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class AbortOperationException : public RobotRaconteurException
{
  public:
    AbortOperationException(const std::string& message, std::string sub_name = "",
                            const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class OperationAbortedException : public RobotRaconteurException
{
  public:
    OperationAbortedException(const std::string& message, std::string sub_name = "",
                              const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class StopIterationException : public RobotRaconteurException
{
  public:
    StopIterationException(const std::string& message, std::string sub_name = "",
                           const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class OperationTimeoutException : public RobotRaconteurException
{
  public:
    OperationTimeoutException(const std::string& message, std::string sub_name = "",
                              const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
class OperationCancelledException : public RobotRaconteurException
{
  public:
    OperationCancelledException(const std::string& message, std::string sub_name = "",
                                const RR_INTRUSIVE_PTR<RRValue>& param_ = RR_INTRUSIVE_PTR<RRValue>());
};
 
#ifndef ROBOTRACONTEUR_NO_CXX11_TEMPLATE_ALIASES
using ConnectionExceptionPtr = RR_SHARED_PTR<ConnectionException>();
using ConnectionExceptionConstPtr = RR_SHARED_PTR<const ConnectionException>();
using ProtocolExceptionPtr = RR_SHARED_PTR<ProtocolException>();
using ProtocolExceptionConstPtr = RR_SHARED_PTR<const ProtocolException>();
using ServiceNotFoundExceptionPtr = RR_SHARED_PTR<ServiceNotFoundException>();
using ServiceNotFoundExceptionConstPtr = RR_SHARED_PTR<const ServiceNotFoundException>();
using ObjectNotFoundExceptionPtr = RR_SHARED_PTR<ObjectNotFoundException>();
using ObjectNotFoundExceptionConstPtr = RR_SHARED_PTR<const ObjectNotFoundException>();
using InvalidEndpointExceptionPtr = RR_SHARED_PTR<InvalidEndpointException>();
using InvalidEndpointExceptionConstPtr = RR_SHARED_PTR<const InvalidEndpointException>();
using EndpointCommunicationFatalExceptionPtr = RR_SHARED_PTR<EndpointCommunicationFatalException>();
using EndpointCommunicationFatalExceptionConstPtr = RR_SHARED_PTR<const EndpointCommunicationFatalException>();
using NodeNotFoundExceptionPtr = RR_SHARED_PTR<NodeNotFoundException>();
using NodeNotFoundExceptionConstPtr = RR_SHARED_PTR<const NodeNotFoundException>();
using ServiceExceptionPtr = RR_SHARED_PTR<ServiceException>();
using ServiceExceptionConstPtr = RR_SHARED_PTR<const ServiceException>();
using MemberNotFoundExceptionPtr = RR_SHARED_PTR<MemberNotFoundException>();
using MemberNotFoundExceptionConstPtr = RR_SHARED_PTR<const MemberNotFoundException>();
using MemberFormatMismatchExceptionPtr = RR_SHARED_PTR<MemberFormatMismatchException>();
using MemberFormatMismatchExceptionConstPtr = RR_SHARED_PTR<const MemberFormatMismatchException>();
using DataTypeMismatchExceptionPtr = RR_SHARED_PTR<DataTypeMismatchException>();
using DataTypeMismatchExceptionConstPtr = RR_SHARED_PTR<const DataTypeMismatchException>();
using DataTypeExceptionPtr = RR_SHARED_PTR<DataTypeException>();
using DataTypeExceptionConstPtr = RR_SHARED_PTR<const DataTypeException>();
using DataSerializationExceptionPtr = RR_SHARED_PTR<DataSerializationException>();
using DataSerializationExceptionConstPtr = RR_SHARED_PTR<const DataSerializationException>();
using MessageEntryNotFoundExceptionPtr = RR_SHARED_PTR<MessageEntryNotFoundException>();
using MessageEntryNotFoundExceptionConstPtr = RR_SHARED_PTR<const MessageEntryNotFoundException>();
using MessageElementNotFoundExceptionPtr = RR_SHARED_PTR<MessageElementNotFoundException>();
using MessageElementNotFoundExceptionConstPtr = RR_SHARED_PTR<const MessageElementNotFoundException>();
using UnknownExceptionPtr = RR_SHARED_PTR<UnknownException>();
using UnknownExceptionConstPtr = RR_SHARED_PTR<const UnknownException>();
using InvalidOperationExceptionPtr = RR_SHARED_PTR<InvalidOperationException>();
using InvalidOperationExceptionConstPtr = RR_SHARED_PTR<const InvalidOperationException>();
using InvalidArgumentExceptionPtr = RR_SHARED_PTR<InvalidArgumentException>();
using InvalidArgumentExceptionConstPtr = RR_SHARED_PTR<const InvalidArgumentException>();
using OperationFailedExceptionPtr = RR_SHARED_PTR<OperationFailedException>();
using OperationFailedExceptionConstPtr = RR_SHARED_PTR<const OperationFailedException>();
using NullValueExceptionPtr = RR_SHARED_PTR<NullValueException>();
using NullValueExceptionConstPtr = RR_SHARED_PTR<const NullValueException>();
using InternalErrorExceptionPtr = RR_SHARED_PTR<InternalErrorException>();
using InternalErrorExceptionConstPtr = RR_SHARED_PTR<const InternalErrorException>();
using SystemResourcePermissionDeniedExceptionPtr = RR_SHARED_PTR<SystemResourcePermissionDeniedException>();
using SystemResourcePermissionDeniedExceptionConstPtr = RR_SHARED_PTR<const SystemResourcePermissionDeniedException>();
using OutOfSystemResourceExceptionPtr = RR_SHARED_PTR<OutOfSystemResourceException>();
using OutOfSystemResourceExceptionConstPtr = RR_SHARED_PTR<const OutOfSystemResourceException>();
using SystemResourceExceptionPtr = RR_SHARED_PTR<SystemResourceException>();
using SystemResourceExceptionConstPtr = RR_SHARED_PTR<const SystemResourceException>();
using ResourceNotFoundExceptionPtr = RR_SHARED_PTR<ResourceNotFoundException>();
using ResourceNotFoundExceptionConstPtr = RR_SHARED_PTR<const ResourceNotFoundException>();
using IOExceptionPtr = RR_SHARED_PTR<IOException>();
using IOExceptionConstPtr = RR_SHARED_PTR<const IOException>();
using BufferLimitViolationExceptionPtr = RR_SHARED_PTR<BufferLimitViolationException>();
using BufferLimitViolationExceptionConstPtr = RR_SHARED_PTR<const BufferLimitViolationException>();
using ServiceDefinitionExceptionPtr = RR_SHARED_PTR<ServiceDefinitionException>();
using ServiceDefinitionExceptionConstPtr = RR_SHARED_PTR<const ServiceDefinitionException>();
using OutOfRangeExceptionPtr = RR_SHARED_PTR<OutOfRangeException>();
using OutOfRangeExceptionConstPtr = RR_SHARED_PTR<const OutOfRangeException>();
using KeyNotFoundExceptionPtr = RR_SHARED_PTR<KeyNotFoundException>();
using KeyNotFoundExceptionConstPtr = RR_SHARED_PTR<const KeyNotFoundException>();
using InvalidConfigurationExceptionPtr = RR_SHARED_PTR<InvalidConfigurationException>();
using InvalidConfigurationExceptionConstPtr = RR_SHARED_PTR<const InvalidConfigurationException>();
using InvalidStateExceptionPtr = RR_SHARED_PTR<InvalidStateException>();
using InvalidStateExceptionConstPtr = RR_SHARED_PTR<const InvalidStateException>();
using RobotRaconteurRemoteExceptionPtr = RR_SHARED_PTR<RobotRaconteurRemoteException>();
using RobotRaconteurRemoteExceptionConstPtr = RR_SHARED_PTR<const RobotRaconteurRemoteException>();
using RequestTimeoutExceptionPtr = RR_SHARED_PTR<RequestTimeoutException>();
using RequestTimeoutExceptionConstPtr = RR_SHARED_PTR<const RequestTimeoutException>();
using ReadOnlyMemberExceptionPtr = RR_SHARED_PTR<ReadOnlyMemberException>();
using ReadOnlyMemberExceptionConstPtr = RR_SHARED_PTR<const ReadOnlyMemberException>();
using WriteOnlyMemberExceptionPtr = RR_SHARED_PTR<WriteOnlyMemberException>();
using WriteOnlyMemberExceptionConstPtr = RR_SHARED_PTR<const WriteOnlyMemberException>();
using NotImplementedExceptionPtr = RR_SHARED_PTR<NotImplementedException>();
using NotImplementedExceptionConstPtr = RR_SHARED_PTR<const NotImplementedException>();
using MemberBusyExceptionPtr = RR_SHARED_PTR<MemberBusyException>();
using MemberBusyExceptionConstPtr = RR_SHARED_PTR<const MemberBusyException>();
using ValueNotSetExceptionPtr = RR_SHARED_PTR<ValueNotSetException>();
using ValueNotSetExceptionConstPtr = RR_SHARED_PTR<const ValueNotSetException>();
using AuthenticationExceptionPtr = RR_SHARED_PTR<AuthenticationException>();
using AuthenticationExceptionConstPtr = RR_SHARED_PTR<const AuthenticationException>();
using ObjectLockedExceptionPtr = RR_SHARED_PTR<ObjectLockedException>();
using ObjectLockedExceptionConstPtr = RR_SHARED_PTR<const ObjectLockedException>();
using PermissionDeniedExceptionPtr = RR_SHARED_PTR<PermissionDeniedException>();
using PermissionDeniedExceptionConstPtr = RR_SHARED_PTR<const PermissionDeniedException>();
using AbortOperationExceptionPtr = RR_SHARED_PTR<AbortOperationException>();
using AbortOperationExceptionConstPtr = RR_SHARED_PTR<const AbortOperationException>();
using OperationAbortedExceptionPtr = RR_SHARED_PTR<OperationAbortedException>();
using OperationAbortedExceptionConstPtr = RR_SHARED_PTR<const OperationAbortedException>();
using StopIterationExceptionPtr = RR_SHARED_PTR<StopIterationException>();
using StopIterationExceptionConstPtr = RR_SHARED_PTR<const StopIterationException>();
using OperationTimeoutExceptionPtr = RR_SHARED_PTR<OperationTimeoutException>();
using OperationTimeoutExceptionConstPtr = RR_SHARED_PTR<const OperationTimeoutException>();
using OperationCancelledExceptionPtr = RR_SHARED_PTR<OperationCancelledException>();
using OperationCancelledExceptionConstPtr = RR_SHARED_PTR<const OperationCacnelledException>();
#endif
 
#endif // GENERATING_DOCUMENTATION
 
#ifndef ROBOTRACONTEUR_NO_CXX11_TEMPLATE_ALIASES
using RobotRaconteurExceptionPtr = RR_SHARED_PTR<RobotRaconteurException>;
using RobotRaconteurExceptionConstPtr = RR_SHARED_PTR<const RobotRaconteurException>;
 
#define RR_EXCEPTION_DECL_1_PTR(exp_cpp_type, exp_code, exp_type_str)                                                  \
    using exp_cpp_type##Ptr = RR_SHARED_PTR<exp_cpp_type>;                                                             \
    using exp_cpp_type##ConstPtr = RR_SHARED_PTR<const exp_cpp_type>;
 
#define RR_EXCEPTION_DECL_2_PTR(exp_cpp_type, exp_code)                                                                \
    using exp_cpp_type##Ptr = RR_SHARED_PTR<exp_cpp_type>;                                                             \
    using exp_cpp_type##ConstPtr = RR_SHARED_PTR<const exp_cpp_type>;
 
RR_EXCEPTION_TYPES_INIT(RR_EXCEPTION_DECL_1_PTR, RR_EXCEPTION_DECL_2_PTR)
 
#undef RR_EXCEPTION_DECL_1_PTR
#undef RR_EXCEPTION_DECL_2_PTR
#endif
 
} // namespace RobotRaconteur