//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
//
// Ice version 3.7.10
//
// <auto-generated>
//
// Generated from file `Exception.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//

#include <IceGrid/Exception.h>
#include <IceUtil/PushDisableWarnings.h>
#include <Ice/InputStream.h>
#include <Ice/OutputStream.h>
#include <Ice/LocalException.h>
#include <IceUtil/PopDisableWarnings.h>

#if defined(_MSC_VER)
#   pragma warning(disable:4458) // declaration of ... hides class member
#elif defined(__clang__)
#   pragma clang diagnostic ignored "-Wshadow"
#elif defined(__GNUC__)
#   pragma GCC diagnostic ignored "-Wshadow"
#endif

#ifndef ICE_IGNORE_VERSION
#   if ICE_INT_VERSION / 100 != 307
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 >= 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 10
#       error Ice patch level mismatch!
#   endif
#endif

#ifdef ICE_CPP11_MAPPING // C++11 mapping

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::ApplicationNotExistException> iceC_IceGrid_ApplicationNotExistException_init("::IceGrid::ApplicationNotExistException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::ServerNotExistException> iceC_IceGrid_ServerNotExistException_init("::IceGrid::ServerNotExistException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::ServerStartException> iceC_IceGrid_ServerStartException_init("::IceGrid::ServerStartException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::ServerStopException> iceC_IceGrid_ServerStopException_init("::IceGrid::ServerStopException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::AdapterNotExistException> iceC_IceGrid_AdapterNotExistException_init("::IceGrid::AdapterNotExistException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::ObjectExistsException> iceC_IceGrid_ObjectExistsException_init("::IceGrid::ObjectExistsException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::ObjectNotRegisteredException> iceC_IceGrid_ObjectNotRegisteredException_init("::IceGrid::ObjectNotRegisteredException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::NodeNotExistException> iceC_IceGrid_NodeNotExistException_init("::IceGrid::NodeNotExistException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::RegistryNotExistException> iceC_IceGrid_RegistryNotExistException_init("::IceGrid::RegistryNotExistException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::DeploymentException> iceC_IceGrid_DeploymentException_init("::IceGrid::DeploymentException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::NodeUnreachableException> iceC_IceGrid_NodeUnreachableException_init("::IceGrid::NodeUnreachableException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::ServerUnreachableException> iceC_IceGrid_ServerUnreachableException_init("::IceGrid::ServerUnreachableException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::RegistryUnreachableException> iceC_IceGrid_RegistryUnreachableException_init("::IceGrid::RegistryUnreachableException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::BadSignalException> iceC_IceGrid_BadSignalException_init("::IceGrid::BadSignalException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::PatchException> iceC_IceGrid_PatchException_init("::IceGrid::PatchException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::AccessDeniedException> iceC_IceGrid_AccessDeniedException_init("::IceGrid::AccessDeniedException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::AllocationException> iceC_IceGrid_AllocationException_init("::IceGrid::AllocationException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::AllocationTimeoutException> iceC_IceGrid_AllocationTimeoutException_init("::IceGrid::AllocationTimeoutException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::PermissionDeniedException> iceC_IceGrid_PermissionDeniedException_init("::IceGrid::PermissionDeniedException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::ObserverAlreadyRegisteredException> iceC_IceGrid_ObserverAlreadyRegisteredException_init("::IceGrid::ObserverAlreadyRegisteredException");

const ::IceInternal::DefaultUserExceptionFactoryInit<::IceGrid::FileNotAvailableException> iceC_IceGrid_FileNotAvailableException_init("::IceGrid::FileNotAvailableException");

}

IceGrid::ApplicationNotExistException::~ApplicationNotExistException()
{
}

const ::std::string&
IceGrid::ApplicationNotExistException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::ApplicationNotExistException";
    return typeId;
}

IceGrid::ServerNotExistException::~ServerNotExistException()
{
}

const ::std::string&
IceGrid::ServerNotExistException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::ServerNotExistException";
    return typeId;
}

IceGrid::ServerStartException::~ServerStartException()
{
}

const ::std::string&
IceGrid::ServerStartException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::ServerStartException";
    return typeId;
}

IceGrid::ServerStopException::~ServerStopException()
{
}

const ::std::string&
IceGrid::ServerStopException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::ServerStopException";
    return typeId;
}

IceGrid::AdapterNotExistException::~AdapterNotExistException()
{
}

const ::std::string&
IceGrid::AdapterNotExistException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::AdapterNotExistException";
    return typeId;
}

IceGrid::ObjectExistsException::~ObjectExistsException()
{
}

const ::std::string&
IceGrid::ObjectExistsException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::ObjectExistsException";
    return typeId;
}

IceGrid::ObjectNotRegisteredException::~ObjectNotRegisteredException()
{
}

const ::std::string&
IceGrid::ObjectNotRegisteredException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::ObjectNotRegisteredException";
    return typeId;
}

IceGrid::NodeNotExistException::~NodeNotExistException()
{
}

const ::std::string&
IceGrid::NodeNotExistException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::NodeNotExistException";
    return typeId;
}

IceGrid::RegistryNotExistException::~RegistryNotExistException()
{
}

const ::std::string&
IceGrid::RegistryNotExistException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::RegistryNotExistException";
    return typeId;
}

IceGrid::DeploymentException::~DeploymentException()
{
}

const ::std::string&
IceGrid::DeploymentException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::DeploymentException";
    return typeId;
}

IceGrid::NodeUnreachableException::~NodeUnreachableException()
{
}

const ::std::string&
IceGrid::NodeUnreachableException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::NodeUnreachableException";
    return typeId;
}

IceGrid::ServerUnreachableException::~ServerUnreachableException()
{
}

const ::std::string&
IceGrid::ServerUnreachableException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::ServerUnreachableException";
    return typeId;
}

IceGrid::RegistryUnreachableException::~RegistryUnreachableException()
{
}

const ::std::string&
IceGrid::RegistryUnreachableException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::RegistryUnreachableException";
    return typeId;
}

IceGrid::BadSignalException::~BadSignalException()
{
}

const ::std::string&
IceGrid::BadSignalException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::BadSignalException";
    return typeId;
}

IceGrid::PatchException::~PatchException()
{
}

const ::std::string&
IceGrid::PatchException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::PatchException";
    return typeId;
}

IceGrid::AccessDeniedException::~AccessDeniedException()
{
}

const ::std::string&
IceGrid::AccessDeniedException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::AccessDeniedException";
    return typeId;
}

IceGrid::AllocationException::~AllocationException()
{
}

const ::std::string&
IceGrid::AllocationException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::AllocationException";
    return typeId;
}

IceGrid::AllocationTimeoutException::~AllocationTimeoutException()
{
}

const ::std::string&
IceGrid::AllocationTimeoutException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::AllocationTimeoutException";
    return typeId;
}

IceGrid::PermissionDeniedException::~PermissionDeniedException()
{
}

const ::std::string&
IceGrid::PermissionDeniedException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::PermissionDeniedException";
    return typeId;
}

IceGrid::ObserverAlreadyRegisteredException::~ObserverAlreadyRegisteredException()
{
}

const ::std::string&
IceGrid::ObserverAlreadyRegisteredException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::ObserverAlreadyRegisteredException";
    return typeId;
}

IceGrid::FileNotAvailableException::~FileNotAvailableException()
{
}

const ::std::string&
IceGrid::FileNotAvailableException::ice_staticId()
{
    static const ::std::string typeId = "::IceGrid::FileNotAvailableException";
    return typeId;
}

#else // C++98 mapping

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::ApplicationNotExistException> iceC_IceGrid_ApplicationNotExistException_init("::IceGrid::ApplicationNotExistException");

}

IceGrid::ApplicationNotExistException::ApplicationNotExistException(const ::std::string& name) :
    ::Ice::UserException(),
    name(name)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::ApplicationNotExistException::~ApplicationNotExistException()
{
}
#else
IceGrid::ApplicationNotExistException::~ApplicationNotExistException() throw()
{
}
#endif

::std::string
IceGrid::ApplicationNotExistException::ice_id() const
{
    return "::IceGrid::ApplicationNotExistException";
}

IceGrid::ApplicationNotExistException*
IceGrid::ApplicationNotExistException::ice_clone() const
{
    return new ApplicationNotExistException(*this);
}

void
IceGrid::ApplicationNotExistException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::ApplicationNotExistException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::ApplicationNotExistException", -1, true);
    ::Ice::StreamWriter< ApplicationNotExistException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::ApplicationNotExistException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< ApplicationNotExistException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::ServerNotExistException> iceC_IceGrid_ServerNotExistException_init("::IceGrid::ServerNotExistException");

}

IceGrid::ServerNotExistException::ServerNotExistException(const ::std::string& id) :
    ::Ice::UserException(),
    id(id)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::ServerNotExistException::~ServerNotExistException()
{
}
#else
IceGrid::ServerNotExistException::~ServerNotExistException() throw()
{
}
#endif

::std::string
IceGrid::ServerNotExistException::ice_id() const
{
    return "::IceGrid::ServerNotExistException";
}

IceGrid::ServerNotExistException*
IceGrid::ServerNotExistException::ice_clone() const
{
    return new ServerNotExistException(*this);
}

void
IceGrid::ServerNotExistException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::ServerNotExistException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::ServerNotExistException", -1, true);
    ::Ice::StreamWriter< ServerNotExistException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::ServerNotExistException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< ServerNotExistException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::ServerStartException> iceC_IceGrid_ServerStartException_init("::IceGrid::ServerStartException");

}

IceGrid::ServerStartException::ServerStartException(const ::std::string& id, const ::std::string& reason) :
    ::Ice::UserException(),
    id(id),
    reason(reason)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::ServerStartException::~ServerStartException()
{
}
#else
IceGrid::ServerStartException::~ServerStartException() throw()
{
}
#endif

::std::string
IceGrid::ServerStartException::ice_id() const
{
    return "::IceGrid::ServerStartException";
}

IceGrid::ServerStartException*
IceGrid::ServerStartException::ice_clone() const
{
    return new ServerStartException(*this);
}

void
IceGrid::ServerStartException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::ServerStartException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::ServerStartException", -1, true);
    ::Ice::StreamWriter< ServerStartException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::ServerStartException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< ServerStartException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::ServerStopException> iceC_IceGrid_ServerStopException_init("::IceGrid::ServerStopException");

}

IceGrid::ServerStopException::ServerStopException(const ::std::string& id, const ::std::string& reason) :
    ::Ice::UserException(),
    id(id),
    reason(reason)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::ServerStopException::~ServerStopException()
{
}
#else
IceGrid::ServerStopException::~ServerStopException() throw()
{
}
#endif

::std::string
IceGrid::ServerStopException::ice_id() const
{
    return "::IceGrid::ServerStopException";
}

IceGrid::ServerStopException*
IceGrid::ServerStopException::ice_clone() const
{
    return new ServerStopException(*this);
}

void
IceGrid::ServerStopException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::ServerStopException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::ServerStopException", -1, true);
    ::Ice::StreamWriter< ServerStopException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::ServerStopException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< ServerStopException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::AdapterNotExistException> iceC_IceGrid_AdapterNotExistException_init("::IceGrid::AdapterNotExistException");

}

IceGrid::AdapterNotExistException::AdapterNotExistException(const ::std::string& id) :
    ::Ice::UserException(),
    id(id)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::AdapterNotExistException::~AdapterNotExistException()
{
}
#else
IceGrid::AdapterNotExistException::~AdapterNotExistException() throw()
{
}
#endif

::std::string
IceGrid::AdapterNotExistException::ice_id() const
{
    return "::IceGrid::AdapterNotExistException";
}

IceGrid::AdapterNotExistException*
IceGrid::AdapterNotExistException::ice_clone() const
{
    return new AdapterNotExistException(*this);
}

void
IceGrid::AdapterNotExistException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::AdapterNotExistException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::AdapterNotExistException", -1, true);
    ::Ice::StreamWriter< AdapterNotExistException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::AdapterNotExistException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< AdapterNotExistException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::ObjectExistsException> iceC_IceGrid_ObjectExistsException_init("::IceGrid::ObjectExistsException");

}

IceGrid::ObjectExistsException::ObjectExistsException(const ::Ice::Identity& id) :
    ::Ice::UserException(),
    id(id)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::ObjectExistsException::~ObjectExistsException()
{
}
#else
IceGrid::ObjectExistsException::~ObjectExistsException() throw()
{
}
#endif

::std::string
IceGrid::ObjectExistsException::ice_id() const
{
    return "::IceGrid::ObjectExistsException";
}

IceGrid::ObjectExistsException*
IceGrid::ObjectExistsException::ice_clone() const
{
    return new ObjectExistsException(*this);
}

void
IceGrid::ObjectExistsException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::ObjectExistsException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::ObjectExistsException", -1, true);
    ::Ice::StreamWriter< ObjectExistsException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::ObjectExistsException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< ObjectExistsException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::ObjectNotRegisteredException> iceC_IceGrid_ObjectNotRegisteredException_init("::IceGrid::ObjectNotRegisteredException");

}

IceGrid::ObjectNotRegisteredException::ObjectNotRegisteredException(const ::Ice::Identity& id) :
    ::Ice::UserException(),
    id(id)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::ObjectNotRegisteredException::~ObjectNotRegisteredException()
{
}
#else
IceGrid::ObjectNotRegisteredException::~ObjectNotRegisteredException() throw()
{
}
#endif

::std::string
IceGrid::ObjectNotRegisteredException::ice_id() const
{
    return "::IceGrid::ObjectNotRegisteredException";
}

IceGrid::ObjectNotRegisteredException*
IceGrid::ObjectNotRegisteredException::ice_clone() const
{
    return new ObjectNotRegisteredException(*this);
}

void
IceGrid::ObjectNotRegisteredException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::ObjectNotRegisteredException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::ObjectNotRegisteredException", -1, true);
    ::Ice::StreamWriter< ObjectNotRegisteredException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::ObjectNotRegisteredException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< ObjectNotRegisteredException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::NodeNotExistException> iceC_IceGrid_NodeNotExistException_init("::IceGrid::NodeNotExistException");

}

IceGrid::NodeNotExistException::NodeNotExistException(const ::std::string& name) :
    ::Ice::UserException(),
    name(name)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::NodeNotExistException::~NodeNotExistException()
{
}
#else
IceGrid::NodeNotExistException::~NodeNotExistException() throw()
{
}
#endif

::std::string
IceGrid::NodeNotExistException::ice_id() const
{
    return "::IceGrid::NodeNotExistException";
}

IceGrid::NodeNotExistException*
IceGrid::NodeNotExistException::ice_clone() const
{
    return new NodeNotExistException(*this);
}

void
IceGrid::NodeNotExistException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::NodeNotExistException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::NodeNotExistException", -1, true);
    ::Ice::StreamWriter< NodeNotExistException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::NodeNotExistException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< NodeNotExistException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::RegistryNotExistException> iceC_IceGrid_RegistryNotExistException_init("::IceGrid::RegistryNotExistException");

}

IceGrid::RegistryNotExistException::RegistryNotExistException(const ::std::string& name) :
    ::Ice::UserException(),
    name(name)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::RegistryNotExistException::~RegistryNotExistException()
{
}
#else
IceGrid::RegistryNotExistException::~RegistryNotExistException() throw()
{
}
#endif

::std::string
IceGrid::RegistryNotExistException::ice_id() const
{
    return "::IceGrid::RegistryNotExistException";
}

IceGrid::RegistryNotExistException*
IceGrid::RegistryNotExistException::ice_clone() const
{
    return new RegistryNotExistException(*this);
}

void
IceGrid::RegistryNotExistException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::RegistryNotExistException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::RegistryNotExistException", -1, true);
    ::Ice::StreamWriter< RegistryNotExistException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::RegistryNotExistException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< RegistryNotExistException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::DeploymentException> iceC_IceGrid_DeploymentException_init("::IceGrid::DeploymentException");

}

IceGrid::DeploymentException::DeploymentException(const ::std::string& reason) :
    ::Ice::UserException(),
    reason(reason)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::DeploymentException::~DeploymentException()
{
}
#else
IceGrid::DeploymentException::~DeploymentException() throw()
{
}
#endif

::std::string
IceGrid::DeploymentException::ice_id() const
{
    return "::IceGrid::DeploymentException";
}

IceGrid::DeploymentException*
IceGrid::DeploymentException::ice_clone() const
{
    return new DeploymentException(*this);
}

void
IceGrid::DeploymentException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::DeploymentException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::DeploymentException", -1, true);
    ::Ice::StreamWriter< DeploymentException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::DeploymentException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< DeploymentException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::NodeUnreachableException> iceC_IceGrid_NodeUnreachableException_init("::IceGrid::NodeUnreachableException");

}

IceGrid::NodeUnreachableException::NodeUnreachableException(const ::std::string& name, const ::std::string& reason) :
    ::Ice::UserException(),
    name(name),
    reason(reason)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::NodeUnreachableException::~NodeUnreachableException()
{
}
#else
IceGrid::NodeUnreachableException::~NodeUnreachableException() throw()
{
}
#endif

::std::string
IceGrid::NodeUnreachableException::ice_id() const
{
    return "::IceGrid::NodeUnreachableException";
}

IceGrid::NodeUnreachableException*
IceGrid::NodeUnreachableException::ice_clone() const
{
    return new NodeUnreachableException(*this);
}

void
IceGrid::NodeUnreachableException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::NodeUnreachableException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::NodeUnreachableException", -1, true);
    ::Ice::StreamWriter< NodeUnreachableException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::NodeUnreachableException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< NodeUnreachableException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::ServerUnreachableException> iceC_IceGrid_ServerUnreachableException_init("::IceGrid::ServerUnreachableException");

}

IceGrid::ServerUnreachableException::ServerUnreachableException(const ::std::string& name, const ::std::string& reason) :
    ::Ice::UserException(),
    name(name),
    reason(reason)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::ServerUnreachableException::~ServerUnreachableException()
{
}
#else
IceGrid::ServerUnreachableException::~ServerUnreachableException() throw()
{
}
#endif

::std::string
IceGrid::ServerUnreachableException::ice_id() const
{
    return "::IceGrid::ServerUnreachableException";
}

IceGrid::ServerUnreachableException*
IceGrid::ServerUnreachableException::ice_clone() const
{
    return new ServerUnreachableException(*this);
}

void
IceGrid::ServerUnreachableException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::ServerUnreachableException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::ServerUnreachableException", -1, true);
    ::Ice::StreamWriter< ServerUnreachableException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::ServerUnreachableException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< ServerUnreachableException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::RegistryUnreachableException> iceC_IceGrid_RegistryUnreachableException_init("::IceGrid::RegistryUnreachableException");

}

IceGrid::RegistryUnreachableException::RegistryUnreachableException(const ::std::string& name, const ::std::string& reason) :
    ::Ice::UserException(),
    name(name),
    reason(reason)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::RegistryUnreachableException::~RegistryUnreachableException()
{
}
#else
IceGrid::RegistryUnreachableException::~RegistryUnreachableException() throw()
{
}
#endif

::std::string
IceGrid::RegistryUnreachableException::ice_id() const
{
    return "::IceGrid::RegistryUnreachableException";
}

IceGrid::RegistryUnreachableException*
IceGrid::RegistryUnreachableException::ice_clone() const
{
    return new RegistryUnreachableException(*this);
}

void
IceGrid::RegistryUnreachableException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::RegistryUnreachableException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::RegistryUnreachableException", -1, true);
    ::Ice::StreamWriter< RegistryUnreachableException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::RegistryUnreachableException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< RegistryUnreachableException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::BadSignalException> iceC_IceGrid_BadSignalException_init("::IceGrid::BadSignalException");

}

IceGrid::BadSignalException::BadSignalException(const ::std::string& reason) :
    ::Ice::UserException(),
    reason(reason)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::BadSignalException::~BadSignalException()
{
}
#else
IceGrid::BadSignalException::~BadSignalException() throw()
{
}
#endif

::std::string
IceGrid::BadSignalException::ice_id() const
{
    return "::IceGrid::BadSignalException";
}

IceGrid::BadSignalException*
IceGrid::BadSignalException::ice_clone() const
{
    return new BadSignalException(*this);
}

void
IceGrid::BadSignalException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::BadSignalException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::BadSignalException", -1, true);
    ::Ice::StreamWriter< BadSignalException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::BadSignalException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< BadSignalException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::PatchException> iceC_IceGrid_PatchException_init("::IceGrid::PatchException");

}

IceGrid::PatchException::PatchException(const ::Ice::StringSeq& reasons) :
    ::Ice::UserException(),
    reasons(reasons)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::PatchException::~PatchException()
{
}
#else
IceGrid::PatchException::~PatchException() throw()
{
}
#endif

::std::string
IceGrid::PatchException::ice_id() const
{
    return "::IceGrid::PatchException";
}

IceGrid::PatchException*
IceGrid::PatchException::ice_clone() const
{
    return new PatchException(*this);
}

void
IceGrid::PatchException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::PatchException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::PatchException", -1, true);
    ::Ice::StreamWriter< PatchException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::PatchException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< PatchException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::AccessDeniedException> iceC_IceGrid_AccessDeniedException_init("::IceGrid::AccessDeniedException");

}

IceGrid::AccessDeniedException::AccessDeniedException(const ::std::string& lockUserId) :
    ::Ice::UserException(),
    lockUserId(lockUserId)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::AccessDeniedException::~AccessDeniedException()
{
}
#else
IceGrid::AccessDeniedException::~AccessDeniedException() throw()
{
}
#endif

::std::string
IceGrid::AccessDeniedException::ice_id() const
{
    return "::IceGrid::AccessDeniedException";
}

IceGrid::AccessDeniedException*
IceGrid::AccessDeniedException::ice_clone() const
{
    return new AccessDeniedException(*this);
}

void
IceGrid::AccessDeniedException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::AccessDeniedException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::AccessDeniedException", -1, true);
    ::Ice::StreamWriter< AccessDeniedException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::AccessDeniedException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< AccessDeniedException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::AllocationException> iceC_IceGrid_AllocationException_init("::IceGrid::AllocationException");

}

IceGrid::AllocationException::AllocationException(const ::std::string& reason) :
    ::Ice::UserException(),
    reason(reason)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::AllocationException::~AllocationException()
{
}
#else
IceGrid::AllocationException::~AllocationException() throw()
{
}
#endif

::std::string
IceGrid::AllocationException::ice_id() const
{
    return "::IceGrid::AllocationException";
}

IceGrid::AllocationException*
IceGrid::AllocationException::ice_clone() const
{
    return new AllocationException(*this);
}

void
IceGrid::AllocationException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::AllocationException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::AllocationException", -1, true);
    ::Ice::StreamWriter< AllocationException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::AllocationException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< AllocationException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::AllocationTimeoutException> iceC_IceGrid_AllocationTimeoutException_init("::IceGrid::AllocationTimeoutException");

}

IceGrid::AllocationTimeoutException::AllocationTimeoutException(const ::std::string& reason) :
    AllocationException(reason)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::AllocationTimeoutException::~AllocationTimeoutException()
{
}
#else
IceGrid::AllocationTimeoutException::~AllocationTimeoutException() throw()
{
}
#endif

::std::string
IceGrid::AllocationTimeoutException::ice_id() const
{
    return "::IceGrid::AllocationTimeoutException";
}

IceGrid::AllocationTimeoutException*
IceGrid::AllocationTimeoutException::ice_clone() const
{
    return new AllocationTimeoutException(*this);
}

void
IceGrid::AllocationTimeoutException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::AllocationTimeoutException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::AllocationTimeoutException", -1, false);
    ::Ice::StreamWriter< AllocationTimeoutException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
    AllocationException::_writeImpl(ostr);
}

void
IceGrid::AllocationTimeoutException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< AllocationTimeoutException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
    AllocationException::_readImpl(istr);
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::PermissionDeniedException> iceC_IceGrid_PermissionDeniedException_init("::IceGrid::PermissionDeniedException");

}

IceGrid::PermissionDeniedException::PermissionDeniedException(const ::std::string& reason) :
    ::Ice::UserException(),
    reason(reason)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::PermissionDeniedException::~PermissionDeniedException()
{
}
#else
IceGrid::PermissionDeniedException::~PermissionDeniedException() throw()
{
}
#endif

::std::string
IceGrid::PermissionDeniedException::ice_id() const
{
    return "::IceGrid::PermissionDeniedException";
}

IceGrid::PermissionDeniedException*
IceGrid::PermissionDeniedException::ice_clone() const
{
    return new PermissionDeniedException(*this);
}

void
IceGrid::PermissionDeniedException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::PermissionDeniedException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::PermissionDeniedException", -1, true);
    ::Ice::StreamWriter< PermissionDeniedException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::PermissionDeniedException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< PermissionDeniedException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::ObserverAlreadyRegisteredException> iceC_IceGrid_ObserverAlreadyRegisteredException_init("::IceGrid::ObserverAlreadyRegisteredException");

}

IceGrid::ObserverAlreadyRegisteredException::ObserverAlreadyRegisteredException(const ::Ice::Identity& id) :
    ::Ice::UserException(),
    id(id)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::ObserverAlreadyRegisteredException::~ObserverAlreadyRegisteredException()
{
}
#else
IceGrid::ObserverAlreadyRegisteredException::~ObserverAlreadyRegisteredException() throw()
{
}
#endif

::std::string
IceGrid::ObserverAlreadyRegisteredException::ice_id() const
{
    return "::IceGrid::ObserverAlreadyRegisteredException";
}

IceGrid::ObserverAlreadyRegisteredException*
IceGrid::ObserverAlreadyRegisteredException::ice_clone() const
{
    return new ObserverAlreadyRegisteredException(*this);
}

void
IceGrid::ObserverAlreadyRegisteredException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::ObserverAlreadyRegisteredException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::ObserverAlreadyRegisteredException", -1, true);
    ::Ice::StreamWriter< ObserverAlreadyRegisteredException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::ObserverAlreadyRegisteredException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< ObserverAlreadyRegisteredException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace
{

const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceGrid::FileNotAvailableException> iceC_IceGrid_FileNotAvailableException_init("::IceGrid::FileNotAvailableException");

}

IceGrid::FileNotAvailableException::FileNotAvailableException(const ::std::string& reason) :
    ::Ice::UserException(),
    reason(reason)
{
}

#ifdef ICE_CPP11_COMPILER
IceGrid::FileNotAvailableException::~FileNotAvailableException()
{
}
#else
IceGrid::FileNotAvailableException::~FileNotAvailableException() throw()
{
}
#endif

::std::string
IceGrid::FileNotAvailableException::ice_id() const
{
    return "::IceGrid::FileNotAvailableException";
}

IceGrid::FileNotAvailableException*
IceGrid::FileNotAvailableException::ice_clone() const
{
    return new FileNotAvailableException(*this);
}

void
IceGrid::FileNotAvailableException::ice_throw() const
{
    throw *this;
}

/// \cond STREAM
void
IceGrid::FileNotAvailableException::_writeImpl(::Ice::OutputStream* ostr) const
{
    ostr->startSlice("::IceGrid::FileNotAvailableException", -1, true);
    ::Ice::StreamWriter< FileNotAvailableException, ::Ice::OutputStream>::write(ostr, *this);
    ostr->endSlice();
}

void
IceGrid::FileNotAvailableException::_readImpl(::Ice::InputStream* istr)
{
    istr->startSlice();
    ::Ice::StreamReader< FileNotAvailableException, ::Ice::InputStream>::read(istr, *this);
    istr->endSlice();
}
/// \endcond

namespace Ice
{
}

#endif
