LocalException.h

Go to the documentation of this file.

//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
//
// Ice version 3.7.10
//
// <auto-generated>
//
// Generated from file `LocalException.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//
 
#ifndef __Ice_LocalException_h__
#define __Ice_LocalException_h__
 
#include <IceUtil/PushDisableWarnings.h>
#include <Ice/ProxyF.h>
#include <Ice/ObjectF.h>
#include <Ice/ValueF.h>
#include <Ice/Exception.h>
#include <Ice/LocalObject.h>
#include <Ice/StreamHelpers.h>
#include <Ice/Comparable.h>
#include <IceUtil/ScopedArray.h>
#include <Ice/Optional.h>
#include <Ice/ExceptionHelpers.h>
#include <Ice/Identity.h>
#include <Ice/Version.h>
#include <Ice/BuiltinSequences.h>
#include <IceUtil/UndefSysMacros.h>
 
#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
 
#ifndef ICE_API
#   if defined(ICE_STATIC_LIBS)
#       define ICE_API 
#   elif defined(ICE_API_EXPORTS)
#       define ICE_API ICE_DECLSPEC_EXPORT
#   else
#       define ICE_API ICE_DECLSPEC_IMPORT
#   endif
#endif
 
#ifdef ICE_CPP11_MAPPING // C++11 mapping
 
namespace Ice
{
 
class ICE_CLASS(ICE_API) InitializationException : public LocalExceptionHelper<InitializationException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~InitializationException();
 
    InitializationException(const InitializationException&) = default;
 
    InitializationException(const char* file, int line) : LocalExceptionHelper<InitializationException, LocalException>(file, line)
    {
    }
 
    InitializationException(const char* file, int line, const ::std::string& reason) : LocalExceptionHelper<InitializationException, LocalException>(file, line),
        reason(reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string reason;
};
 
class ICE_CLASS(ICE_API) PluginInitializationException : public LocalExceptionHelper<PluginInitializationException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~PluginInitializationException();
 
    PluginInitializationException(const PluginInitializationException&) = default;
 
    PluginInitializationException(const char* file, int line) : LocalExceptionHelper<PluginInitializationException, LocalException>(file, line)
    {
    }
 
    PluginInitializationException(const char* file, int line, const ::std::string& reason) : LocalExceptionHelper<PluginInitializationException, LocalException>(file, line),
        reason(reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string reason;
};
 
class ICE_CLASS(ICE_API) CollocationOptimizationException : public LocalExceptionHelper<CollocationOptimizationException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~CollocationOptimizationException();
 
    CollocationOptimizationException(const CollocationOptimizationException&) = default;
 
    CollocationOptimizationException(const char* file, int line) : LocalExceptionHelper<CollocationOptimizationException, LocalException>(file, line)
    {
    }
 
    std::tuple<> ice_tuple() const
    {
        return std::tie();
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) AlreadyRegisteredException : public LocalExceptionHelper<AlreadyRegisteredException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~AlreadyRegisteredException();
 
    AlreadyRegisteredException(const AlreadyRegisteredException&) = default;
 
    AlreadyRegisteredException(const char* file, int line) : LocalExceptionHelper<AlreadyRegisteredException, LocalException>(file, line)
    {
    }
 
    AlreadyRegisteredException(const char* file, int line, const ::std::string& kindOfObject, const ::std::string& id) : LocalExceptionHelper<AlreadyRegisteredException, LocalException>(file, line),
        kindOfObject(kindOfObject),
        id(id)
    {
    }
 
    std::tuple<const ::std::string&, const ::std::string&> ice_tuple() const
    {
        return std::tie(kindOfObject, id);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string kindOfObject;
    ::std::string id;
};
 
class ICE_CLASS(ICE_API) NotRegisteredException : public LocalExceptionHelper<NotRegisteredException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~NotRegisteredException();
 
    NotRegisteredException(const NotRegisteredException&) = default;
 
    NotRegisteredException(const char* file, int line) : LocalExceptionHelper<NotRegisteredException, LocalException>(file, line)
    {
    }
 
    NotRegisteredException(const char* file, int line, const ::std::string& kindOfObject, const ::std::string& id) : LocalExceptionHelper<NotRegisteredException, LocalException>(file, line),
        kindOfObject(kindOfObject),
        id(id)
    {
    }
 
    std::tuple<const ::std::string&, const ::std::string&> ice_tuple() const
    {
        return std::tie(kindOfObject, id);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string kindOfObject;
    ::std::string id;
};
 
class ICE_CLASS(ICE_API) TwowayOnlyException : public LocalExceptionHelper<TwowayOnlyException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~TwowayOnlyException();
 
    TwowayOnlyException(const TwowayOnlyException&) = default;
 
    TwowayOnlyException(const char* file, int line) : LocalExceptionHelper<TwowayOnlyException, LocalException>(file, line)
    {
    }
 
    TwowayOnlyException(const char* file, int line, const ::std::string& operation) : LocalExceptionHelper<TwowayOnlyException, LocalException>(file, line),
        operation(operation)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(operation);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string operation;
};
 
class ICE_CLASS(ICE_API) CloneNotImplementedException : public LocalExceptionHelper<CloneNotImplementedException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~CloneNotImplementedException();
 
    CloneNotImplementedException(const CloneNotImplementedException&) = default;
 
    CloneNotImplementedException(const char* file, int line) : LocalExceptionHelper<CloneNotImplementedException, LocalException>(file, line)
    {
    }
 
    std::tuple<> ice_tuple() const
    {
        return std::tie();
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) UnknownException : public LocalExceptionHelper<UnknownException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~UnknownException();
 
    UnknownException(const UnknownException&) = default;
 
    UnknownException(const char* file, int line) : LocalExceptionHelper<UnknownException, LocalException>(file, line)
    {
    }
 
    UnknownException(const char* file, int line, const ::std::string& unknown) : LocalExceptionHelper<UnknownException, LocalException>(file, line),
        unknown(unknown)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(unknown);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string unknown;
};
 
class ICE_CLASS(ICE_API) UnknownLocalException : public LocalExceptionHelper<UnknownLocalException, UnknownException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~UnknownLocalException();
 
    UnknownLocalException(const UnknownLocalException&) = default;
 
    UnknownLocalException(const char* file, int line) : LocalExceptionHelper<UnknownLocalException, UnknownException>(file, line)
    {
    }
 
    UnknownLocalException(const char* file, int line, const ::std::string& unknown) :
        LocalExceptionHelper<UnknownLocalException, UnknownException>(file, line, unknown)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(unknown);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) UnknownUserException : public LocalExceptionHelper<UnknownUserException, UnknownException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~UnknownUserException();
 
    UnknownUserException(const UnknownUserException&) = default;
 
    UnknownUserException(const char* file, int line) : LocalExceptionHelper<UnknownUserException, UnknownException>(file, line)
    {
    }
 
    UnknownUserException(const char* file, int line, const ::std::string& unknown) :
        LocalExceptionHelper<UnknownUserException, UnknownException>(file, line, unknown)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(unknown);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) VersionMismatchException : public LocalExceptionHelper<VersionMismatchException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~VersionMismatchException();
 
    VersionMismatchException(const VersionMismatchException&) = default;
 
    VersionMismatchException(const char* file, int line) : LocalExceptionHelper<VersionMismatchException, LocalException>(file, line)
    {
    }
 
    std::tuple<> ice_tuple() const
    {
        return std::tie();
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) CommunicatorDestroyedException : public LocalExceptionHelper<CommunicatorDestroyedException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~CommunicatorDestroyedException();
 
    CommunicatorDestroyedException(const CommunicatorDestroyedException&) = default;
 
    CommunicatorDestroyedException(const char* file, int line) : LocalExceptionHelper<CommunicatorDestroyedException, LocalException>(file, line)
    {
    }
 
    std::tuple<> ice_tuple() const
    {
        return std::tie();
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) ObjectAdapterDeactivatedException : public LocalExceptionHelper<ObjectAdapterDeactivatedException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ObjectAdapterDeactivatedException();
 
    ObjectAdapterDeactivatedException(const ObjectAdapterDeactivatedException&) = default;
 
    ObjectAdapterDeactivatedException(const char* file, int line) : LocalExceptionHelper<ObjectAdapterDeactivatedException, LocalException>(file, line)
    {
    }
 
    ObjectAdapterDeactivatedException(const char* file, int line, const ::std::string& name) : LocalExceptionHelper<ObjectAdapterDeactivatedException, LocalException>(file, line),
        name(name)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(name);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string name;
};
 
class ICE_CLASS(ICE_API) ObjectAdapterIdInUseException : public LocalExceptionHelper<ObjectAdapterIdInUseException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ObjectAdapterIdInUseException();
 
    ObjectAdapterIdInUseException(const ObjectAdapterIdInUseException&) = default;
 
    ObjectAdapterIdInUseException(const char* file, int line) : LocalExceptionHelper<ObjectAdapterIdInUseException, LocalException>(file, line)
    {
    }
 
    ObjectAdapterIdInUseException(const char* file, int line, const ::std::string& id) : LocalExceptionHelper<ObjectAdapterIdInUseException, LocalException>(file, line),
        id(id)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(id);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string id;
};
 
class ICE_CLASS(ICE_API) NoEndpointException : public LocalExceptionHelper<NoEndpointException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~NoEndpointException();
 
    NoEndpointException(const NoEndpointException&) = default;
 
    NoEndpointException(const char* file, int line) : LocalExceptionHelper<NoEndpointException, LocalException>(file, line)
    {
    }
 
    NoEndpointException(const char* file, int line, const ::std::string& proxy) : LocalExceptionHelper<NoEndpointException, LocalException>(file, line),
        proxy(proxy)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(proxy);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string proxy;
};
 
class ICE_CLASS(ICE_API) EndpointParseException : public LocalExceptionHelper<EndpointParseException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~EndpointParseException();
 
    EndpointParseException(const EndpointParseException&) = default;
 
    EndpointParseException(const char* file, int line) : LocalExceptionHelper<EndpointParseException, LocalException>(file, line)
    {
    }
 
    EndpointParseException(const char* file, int line, const ::std::string& str) : LocalExceptionHelper<EndpointParseException, LocalException>(file, line),
        str(str)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(str);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string str;
};
 
class ICE_CLASS(ICE_API) EndpointSelectionTypeParseException : public LocalExceptionHelper<EndpointSelectionTypeParseException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~EndpointSelectionTypeParseException();
 
    EndpointSelectionTypeParseException(const EndpointSelectionTypeParseException&) = default;
 
    EndpointSelectionTypeParseException(const char* file, int line) : LocalExceptionHelper<EndpointSelectionTypeParseException, LocalException>(file, line)
    {
    }
 
    EndpointSelectionTypeParseException(const char* file, int line, const ::std::string& str) : LocalExceptionHelper<EndpointSelectionTypeParseException, LocalException>(file, line),
        str(str)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(str);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string str;
};
 
class ICE_CLASS(ICE_API) VersionParseException : public LocalExceptionHelper<VersionParseException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~VersionParseException();
 
    VersionParseException(const VersionParseException&) = default;
 
    VersionParseException(const char* file, int line) : LocalExceptionHelper<VersionParseException, LocalException>(file, line)
    {
    }
 
    VersionParseException(const char* file, int line, const ::std::string& str) : LocalExceptionHelper<VersionParseException, LocalException>(file, line),
        str(str)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(str);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string str;
};
 
class ICE_CLASS(ICE_API) IdentityParseException : public LocalExceptionHelper<IdentityParseException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~IdentityParseException();
 
    IdentityParseException(const IdentityParseException&) = default;
 
    IdentityParseException(const char* file, int line) : LocalExceptionHelper<IdentityParseException, LocalException>(file, line)
    {
    }
 
    IdentityParseException(const char* file, int line, const ::std::string& str) : LocalExceptionHelper<IdentityParseException, LocalException>(file, line),
        str(str)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(str);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string str;
};
 
class ICE_CLASS(ICE_API) ProxyParseException : public LocalExceptionHelper<ProxyParseException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ProxyParseException();
 
    ProxyParseException(const ProxyParseException&) = default;
 
    ProxyParseException(const char* file, int line) : LocalExceptionHelper<ProxyParseException, LocalException>(file, line)
    {
    }
 
    ProxyParseException(const char* file, int line, const ::std::string& str) : LocalExceptionHelper<ProxyParseException, LocalException>(file, line),
        str(str)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(str);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string str;
};
 
class ICE_CLASS(ICE_API) IllegalIdentityException : public LocalExceptionHelper<IllegalIdentityException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~IllegalIdentityException();
 
    IllegalIdentityException(const IllegalIdentityException&) = default;
 
    IllegalIdentityException(const char* file, int line) : LocalExceptionHelper<IllegalIdentityException, LocalException>(file, line)
    {
    }
 
    IllegalIdentityException(const char* file, int line, const Identity& id) : LocalExceptionHelper<IllegalIdentityException, LocalException>(file, line),
        id(id)
    {
    }
 
    std::tuple<const ::Ice::Identity&> ice_tuple() const
    {
        return std::tie(id);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::Ice::Identity id;
};
 
class ICE_CLASS(ICE_API) IllegalServantException : public LocalExceptionHelper<IllegalServantException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~IllegalServantException();
 
    IllegalServantException(const IllegalServantException&) = default;
 
    IllegalServantException(const char* file, int line) : LocalExceptionHelper<IllegalServantException, LocalException>(file, line)
    {
    }
 
    IllegalServantException(const char* file, int line, const ::std::string& reason) : LocalExceptionHelper<IllegalServantException, LocalException>(file, line),
        reason(reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string reason;
};
 
class ICE_CLASS(ICE_API) RequestFailedException : public LocalExceptionHelper<RequestFailedException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~RequestFailedException();
 
    RequestFailedException(const RequestFailedException&) = default;
 
    RequestFailedException(const char* file, int line) : LocalExceptionHelper<RequestFailedException, LocalException>(file, line)
    {
    }
 
    RequestFailedException(const char* file, int line, const Identity& id, const ::std::string& facet, const ::std::string& operation) : LocalExceptionHelper<RequestFailedException, LocalException>(file, line),
        id(id),
        facet(facet),
        operation(operation)
    {
    }
 
    std::tuple<const ::Ice::Identity&, const ::std::string&, const ::std::string&> ice_tuple() const
    {
        return std::tie(id, facet, operation);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::Ice::Identity id;
    ::std::string facet;
    ::std::string operation;
};
 
class ICE_CLASS(ICE_API) ObjectNotExistException : public LocalExceptionHelper<ObjectNotExistException, RequestFailedException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ObjectNotExistException();
 
    ObjectNotExistException(const ObjectNotExistException&) = default;
 
    ObjectNotExistException(const char* file, int line) : LocalExceptionHelper<ObjectNotExistException, RequestFailedException>(file, line)
    {
    }
 
    ObjectNotExistException(const char* file, int line, const Identity& id, const ::std::string& facet, const ::std::string& operation) :
        LocalExceptionHelper<ObjectNotExistException, RequestFailedException>(file, line, id, facet, operation)
    {
    }
 
    std::tuple<const ::Ice::Identity&, const ::std::string&, const ::std::string&> ice_tuple() const
    {
        return std::tie(id, facet, operation);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) FacetNotExistException : public LocalExceptionHelper<FacetNotExistException, RequestFailedException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~FacetNotExistException();
 
    FacetNotExistException(const FacetNotExistException&) = default;
 
    FacetNotExistException(const char* file, int line) : LocalExceptionHelper<FacetNotExistException, RequestFailedException>(file, line)
    {
    }
 
    FacetNotExistException(const char* file, int line, const Identity& id, const ::std::string& facet, const ::std::string& operation) :
        LocalExceptionHelper<FacetNotExistException, RequestFailedException>(file, line, id, facet, operation)
    {
    }
 
    std::tuple<const ::Ice::Identity&, const ::std::string&, const ::std::string&> ice_tuple() const
    {
        return std::tie(id, facet, operation);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) OperationNotExistException : public LocalExceptionHelper<OperationNotExistException, RequestFailedException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~OperationNotExistException();
 
    OperationNotExistException(const OperationNotExistException&) = default;
 
    OperationNotExistException(const char* file, int line) : LocalExceptionHelper<OperationNotExistException, RequestFailedException>(file, line)
    {
    }
 
    OperationNotExistException(const char* file, int line, const Identity& id, const ::std::string& facet, const ::std::string& operation) :
        LocalExceptionHelper<OperationNotExistException, RequestFailedException>(file, line, id, facet, operation)
    {
    }
 
    std::tuple<const ::Ice::Identity&, const ::std::string&, const ::std::string&> ice_tuple() const
    {
        return std::tie(id, facet, operation);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) SyscallException : public LocalExceptionHelper<SyscallException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~SyscallException();
 
    SyscallException(const SyscallException&) = default;
 
    SyscallException(const char* file, int line) : LocalExceptionHelper<SyscallException, LocalException>(file, line)
    {
    }
 
    SyscallException(const char* file, int line, int error) : LocalExceptionHelper<SyscallException, LocalException>(file, line),
        error(error)
    {
    }
 
    std::tuple<const int&> ice_tuple() const
    {
        return std::tie(error);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    int error = 0;
};
 
class ICE_CLASS(ICE_API) SocketException : public LocalExceptionHelper<SocketException, SyscallException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~SocketException();
 
    SocketException(const SocketException&) = default;
 
    SocketException(const char* file, int line) : LocalExceptionHelper<SocketException, SyscallException>(file, line)
    {
    }
 
    SocketException(const char* file, int line, int error) :
        LocalExceptionHelper<SocketException, SyscallException>(file, line, error)
    {
    }
 
    std::tuple<const int&> ice_tuple() const
    {
        return std::tie(error);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) CFNetworkException : public LocalExceptionHelper<CFNetworkException, SocketException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~CFNetworkException();
 
    CFNetworkException(const CFNetworkException&) = default;
 
    CFNetworkException(const char* file, int line) : LocalExceptionHelper<CFNetworkException, SocketException>(file, line)
    {
    }
 
    CFNetworkException(const char* file, int line, int error, const ::std::string& domain) :
        LocalExceptionHelper<CFNetworkException, SocketException>(file, line, error),
        domain(domain)
    {
    }
 
    std::tuple<const int&, const ::std::string&> ice_tuple() const
    {
        return std::tie(error, domain);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string domain;
};
 
class ICE_CLASS(ICE_API) FileException : public LocalExceptionHelper<FileException, SyscallException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~FileException();
 
    FileException(const FileException&) = default;
 
    FileException(const char* file, int line) : LocalExceptionHelper<FileException, SyscallException>(file, line)
    {
    }
 
    FileException(const char* file, int line, int error, const ::std::string& path) :
        LocalExceptionHelper<FileException, SyscallException>(file, line, error),
        path(path)
    {
    }
 
    std::tuple<const int&, const ::std::string&> ice_tuple() const
    {
        return std::tie(error, path);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string path;
};
 
class ICE_CLASS(ICE_API) ConnectFailedException : public LocalExceptionHelper<ConnectFailedException, SocketException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ConnectFailedException();
 
    ConnectFailedException(const ConnectFailedException&) = default;
 
    ConnectFailedException(const char* file, int line) : LocalExceptionHelper<ConnectFailedException, SocketException>(file, line)
    {
    }
 
    ConnectFailedException(const char* file, int line, int error) :
        LocalExceptionHelper<ConnectFailedException, SocketException>(file, line, error)
    {
    }
 
    std::tuple<const int&> ice_tuple() const
    {
        return std::tie(error);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) ConnectionRefusedException : public LocalExceptionHelper<ConnectionRefusedException, ConnectFailedException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ConnectionRefusedException();
 
    ConnectionRefusedException(const ConnectionRefusedException&) = default;
 
    ConnectionRefusedException(const char* file, int line) : LocalExceptionHelper<ConnectionRefusedException, ConnectFailedException>(file, line)
    {
    }
 
    ConnectionRefusedException(const char* file, int line, int error) :
        LocalExceptionHelper<ConnectionRefusedException, ConnectFailedException>(file, line, error)
    {
    }
 
    std::tuple<const int&> ice_tuple() const
    {
        return std::tie(error);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) ConnectionLostException : public LocalExceptionHelper<ConnectionLostException, SocketException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ConnectionLostException();
 
    ConnectionLostException(const ConnectionLostException&) = default;
 
    ConnectionLostException(const char* file, int line) : LocalExceptionHelper<ConnectionLostException, SocketException>(file, line)
    {
    }
 
    ConnectionLostException(const char* file, int line, int error) :
        LocalExceptionHelper<ConnectionLostException, SocketException>(file, line, error)
    {
    }
 
    std::tuple<const int&> ice_tuple() const
    {
        return std::tie(error);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) DNSException : public LocalExceptionHelper<DNSException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~DNSException();
 
    DNSException(const DNSException&) = default;
 
    DNSException(const char* file, int line) : LocalExceptionHelper<DNSException, LocalException>(file, line)
    {
    }
 
    DNSException(const char* file, int line, int error, const ::std::string& host) : LocalExceptionHelper<DNSException, LocalException>(file, line),
        error(error),
        host(host)
    {
    }
 
    std::tuple<const int&, const ::std::string&> ice_tuple() const
    {
        return std::tie(error, host);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    int error = 0;
    ::std::string host;
};
 
class ICE_CLASS(ICE_API) OperationInterruptedException : public LocalExceptionHelper<OperationInterruptedException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~OperationInterruptedException();
 
    OperationInterruptedException(const OperationInterruptedException&) = default;
 
    OperationInterruptedException(const char* file, int line) : LocalExceptionHelper<OperationInterruptedException, LocalException>(file, line)
    {
    }
 
    std::tuple<> ice_tuple() const
    {
        return std::tie();
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) TimeoutException : public LocalExceptionHelper<TimeoutException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~TimeoutException();
 
    TimeoutException(const TimeoutException&) = default;
 
    TimeoutException(const char* file, int line) : LocalExceptionHelper<TimeoutException, LocalException>(file, line)
    {
    }
 
    std::tuple<> ice_tuple() const
    {
        return std::tie();
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) ConnectTimeoutException : public LocalExceptionHelper<ConnectTimeoutException, TimeoutException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ConnectTimeoutException();
 
    ConnectTimeoutException(const ConnectTimeoutException&) = default;
 
    ConnectTimeoutException(const char* file, int line) : LocalExceptionHelper<ConnectTimeoutException, TimeoutException>(file, line)
    {
    }
 
    std::tuple<> ice_tuple() const
    {
        return std::tie();
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) CloseTimeoutException : public LocalExceptionHelper<CloseTimeoutException, TimeoutException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~CloseTimeoutException();
 
    CloseTimeoutException(const CloseTimeoutException&) = default;
 
    CloseTimeoutException(const char* file, int line) : LocalExceptionHelper<CloseTimeoutException, TimeoutException>(file, line)
    {
    }
 
    std::tuple<> ice_tuple() const
    {
        return std::tie();
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) ConnectionTimeoutException : public LocalExceptionHelper<ConnectionTimeoutException, TimeoutException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ConnectionTimeoutException();
 
    ConnectionTimeoutException(const ConnectionTimeoutException&) = default;
 
    ConnectionTimeoutException(const char* file, int line) : LocalExceptionHelper<ConnectionTimeoutException, TimeoutException>(file, line)
    {
    }
 
    std::tuple<> ice_tuple() const
    {
        return std::tie();
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) InvocationTimeoutException : public LocalExceptionHelper<InvocationTimeoutException, TimeoutException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~InvocationTimeoutException();
 
    InvocationTimeoutException(const InvocationTimeoutException&) = default;
 
    InvocationTimeoutException(const char* file, int line) : LocalExceptionHelper<InvocationTimeoutException, TimeoutException>(file, line)
    {
    }
 
    std::tuple<> ice_tuple() const
    {
        return std::tie();
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) InvocationCanceledException : public LocalExceptionHelper<InvocationCanceledException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~InvocationCanceledException();
 
    InvocationCanceledException(const InvocationCanceledException&) = default;
 
    InvocationCanceledException(const char* file, int line) : LocalExceptionHelper<InvocationCanceledException, LocalException>(file, line)
    {
    }
 
    std::tuple<> ice_tuple() const
    {
        return std::tie();
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) ProtocolException : public LocalExceptionHelper<ProtocolException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ProtocolException();
 
    ProtocolException(const ProtocolException&) = default;
 
    ProtocolException(const char* file, int line) : LocalExceptionHelper<ProtocolException, LocalException>(file, line)
    {
    }
 
    ProtocolException(const char* file, int line, const ::std::string& reason) : LocalExceptionHelper<ProtocolException, LocalException>(file, line),
        reason(reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string reason;
};
 
class ICE_CLASS(ICE_API) BadMagicException : public LocalExceptionHelper<BadMagicException, ProtocolException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~BadMagicException();
 
    BadMagicException(const BadMagicException&) = default;
 
    BadMagicException(const char* file, int line) : LocalExceptionHelper<BadMagicException, ProtocolException>(file, line)
    {
    }
 
    BadMagicException(const char* file, int line, const ::std::string& reason, const ByteSeq& badMagic) :
        LocalExceptionHelper<BadMagicException, ProtocolException>(file, line, reason),
        badMagic(badMagic)
    {
    }
 
    std::tuple<const ::std::string&, const ::Ice::ByteSeq&> ice_tuple() const
    {
        return std::tie(reason, badMagic);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::Ice::ByteSeq badMagic;
};
 
class ICE_CLASS(ICE_API) UnsupportedProtocolException : public LocalExceptionHelper<UnsupportedProtocolException, ProtocolException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~UnsupportedProtocolException();
 
    UnsupportedProtocolException(const UnsupportedProtocolException&) = default;
 
    UnsupportedProtocolException(const char* file, int line) : LocalExceptionHelper<UnsupportedProtocolException, ProtocolException>(file, line)
    {
    }
 
    UnsupportedProtocolException(const char* file, int line, const ::std::string& reason, const ProtocolVersion& bad, const ProtocolVersion& supported) :
        LocalExceptionHelper<UnsupportedProtocolException, ProtocolException>(file, line, reason),
        bad(bad),
        supported(supported)
    {
    }
 
    std::tuple<const ::std::string&, const ::Ice::ProtocolVersion&, const ::Ice::ProtocolVersion&> ice_tuple() const
    {
        return std::tie(reason, bad, supported);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::Ice::ProtocolVersion bad;
    ::Ice::ProtocolVersion supported;
};
 
class ICE_CLASS(ICE_API) UnsupportedEncodingException : public LocalExceptionHelper<UnsupportedEncodingException, ProtocolException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~UnsupportedEncodingException();
 
    UnsupportedEncodingException(const UnsupportedEncodingException&) = default;
 
    UnsupportedEncodingException(const char* file, int line) : LocalExceptionHelper<UnsupportedEncodingException, ProtocolException>(file, line)
    {
    }
 
    UnsupportedEncodingException(const char* file, int line, const ::std::string& reason, const EncodingVersion& bad, const EncodingVersion& supported) :
        LocalExceptionHelper<UnsupportedEncodingException, ProtocolException>(file, line, reason),
        bad(bad),
        supported(supported)
    {
    }
 
    std::tuple<const ::std::string&, const ::Ice::EncodingVersion&, const ::Ice::EncodingVersion&> ice_tuple() const
    {
        return std::tie(reason, bad, supported);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::Ice::EncodingVersion bad;
    ::Ice::EncodingVersion supported;
};
 
class ICE_CLASS(ICE_API) UnknownMessageException : public LocalExceptionHelper<UnknownMessageException, ProtocolException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~UnknownMessageException();
 
    UnknownMessageException(const UnknownMessageException&) = default;
 
    UnknownMessageException(const char* file, int line) : LocalExceptionHelper<UnknownMessageException, ProtocolException>(file, line)
    {
    }
 
    UnknownMessageException(const char* file, int line, const ::std::string& reason) :
        LocalExceptionHelper<UnknownMessageException, ProtocolException>(file, line, reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) ConnectionNotValidatedException : public LocalExceptionHelper<ConnectionNotValidatedException, ProtocolException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ConnectionNotValidatedException();
 
    ConnectionNotValidatedException(const ConnectionNotValidatedException&) = default;
 
    ConnectionNotValidatedException(const char* file, int line) : LocalExceptionHelper<ConnectionNotValidatedException, ProtocolException>(file, line)
    {
    }
 
    ConnectionNotValidatedException(const char* file, int line, const ::std::string& reason) :
        LocalExceptionHelper<ConnectionNotValidatedException, ProtocolException>(file, line, reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) UnknownRequestIdException : public LocalExceptionHelper<UnknownRequestIdException, ProtocolException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~UnknownRequestIdException();
 
    UnknownRequestIdException(const UnknownRequestIdException&) = default;
 
    UnknownRequestIdException(const char* file, int line) : LocalExceptionHelper<UnknownRequestIdException, ProtocolException>(file, line)
    {
    }
 
    UnknownRequestIdException(const char* file, int line, const ::std::string& reason) :
        LocalExceptionHelper<UnknownRequestIdException, ProtocolException>(file, line, reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) UnknownReplyStatusException : public LocalExceptionHelper<UnknownReplyStatusException, ProtocolException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~UnknownReplyStatusException();
 
    UnknownReplyStatusException(const UnknownReplyStatusException&) = default;
 
    UnknownReplyStatusException(const char* file, int line) : LocalExceptionHelper<UnknownReplyStatusException, ProtocolException>(file, line)
    {
    }
 
    UnknownReplyStatusException(const char* file, int line, const ::std::string& reason) :
        LocalExceptionHelper<UnknownReplyStatusException, ProtocolException>(file, line, reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) CloseConnectionException : public LocalExceptionHelper<CloseConnectionException, ProtocolException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~CloseConnectionException();
 
    CloseConnectionException(const CloseConnectionException&) = default;
 
    CloseConnectionException(const char* file, int line) : LocalExceptionHelper<CloseConnectionException, ProtocolException>(file, line)
    {
    }
 
    CloseConnectionException(const char* file, int line, const ::std::string& reason) :
        LocalExceptionHelper<CloseConnectionException, ProtocolException>(file, line, reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) ConnectionManuallyClosedException : public LocalExceptionHelper<ConnectionManuallyClosedException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ConnectionManuallyClosedException();
 
    ConnectionManuallyClosedException(const ConnectionManuallyClosedException&) = default;
 
    ConnectionManuallyClosedException(const char* file, int line) : LocalExceptionHelper<ConnectionManuallyClosedException, LocalException>(file, line)
    {
    }
 
    ConnectionManuallyClosedException(const char* file, int line, bool graceful) : LocalExceptionHelper<ConnectionManuallyClosedException, LocalException>(file, line),
        graceful(graceful)
    {
    }
 
    std::tuple<const bool&> ice_tuple() const
    {
        return std::tie(graceful);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    bool graceful;
};
 
class ICE_CLASS(ICE_API) IllegalMessageSizeException : public LocalExceptionHelper<IllegalMessageSizeException, ProtocolException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~IllegalMessageSizeException();
 
    IllegalMessageSizeException(const IllegalMessageSizeException&) = default;
 
    IllegalMessageSizeException(const char* file, int line) : LocalExceptionHelper<IllegalMessageSizeException, ProtocolException>(file, line)
    {
    }
 
    IllegalMessageSizeException(const char* file, int line, const ::std::string& reason) :
        LocalExceptionHelper<IllegalMessageSizeException, ProtocolException>(file, line, reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) CompressionException : public LocalExceptionHelper<CompressionException, ProtocolException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~CompressionException();
 
    CompressionException(const CompressionException&) = default;
 
    CompressionException(const char* file, int line) : LocalExceptionHelper<CompressionException, ProtocolException>(file, line)
    {
    }
 
    CompressionException(const char* file, int line, const ::std::string& reason) :
        LocalExceptionHelper<CompressionException, ProtocolException>(file, line, reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) DatagramLimitException : public LocalExceptionHelper<DatagramLimitException, ProtocolException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~DatagramLimitException();
 
    DatagramLimitException(const DatagramLimitException&) = default;
 
    DatagramLimitException(const char* file, int line) : LocalExceptionHelper<DatagramLimitException, ProtocolException>(file, line)
    {
    }
 
    DatagramLimitException(const char* file, int line, const ::std::string& reason) :
        LocalExceptionHelper<DatagramLimitException, ProtocolException>(file, line, reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) MarshalException : public LocalExceptionHelper<MarshalException, ProtocolException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~MarshalException();
 
    MarshalException(const MarshalException&) = default;
 
    MarshalException(const char* file, int line) : LocalExceptionHelper<MarshalException, ProtocolException>(file, line)
    {
    }
 
    MarshalException(const char* file, int line, const ::std::string& reason) :
        LocalExceptionHelper<MarshalException, ProtocolException>(file, line, reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) ProxyUnmarshalException : public LocalExceptionHelper<ProxyUnmarshalException, MarshalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ProxyUnmarshalException();
 
    ProxyUnmarshalException(const ProxyUnmarshalException&) = default;
 
    ProxyUnmarshalException(const char* file, int line) : LocalExceptionHelper<ProxyUnmarshalException, MarshalException>(file, line)
    {
    }
 
    ProxyUnmarshalException(const char* file, int line, const ::std::string& reason) :
        LocalExceptionHelper<ProxyUnmarshalException, MarshalException>(file, line, reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) UnmarshalOutOfBoundsException : public LocalExceptionHelper<UnmarshalOutOfBoundsException, MarshalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~UnmarshalOutOfBoundsException();
 
    UnmarshalOutOfBoundsException(const UnmarshalOutOfBoundsException&) = default;
 
    UnmarshalOutOfBoundsException(const char* file, int line) : LocalExceptionHelper<UnmarshalOutOfBoundsException, MarshalException>(file, line)
    {
    }
 
    UnmarshalOutOfBoundsException(const char* file, int line, const ::std::string& reason) :
        LocalExceptionHelper<UnmarshalOutOfBoundsException, MarshalException>(file, line, reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) NoValueFactoryException : public LocalExceptionHelper<NoValueFactoryException, MarshalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~NoValueFactoryException();
 
    NoValueFactoryException(const NoValueFactoryException&) = default;
 
    NoValueFactoryException(const char* file, int line) : LocalExceptionHelper<NoValueFactoryException, MarshalException>(file, line)
    {
    }
 
    NoValueFactoryException(const char* file, int line, const ::std::string& reason, const ::std::string& type) :
        LocalExceptionHelper<NoValueFactoryException, MarshalException>(file, line, reason),
        type(type)
    {
    }
 
    std::tuple<const ::std::string&, const ::std::string&> ice_tuple() const
    {
        return std::tie(reason, type);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string type;
};
 
class ICE_CLASS(ICE_API) UnexpectedObjectException : public LocalExceptionHelper<UnexpectedObjectException, MarshalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~UnexpectedObjectException();
 
    UnexpectedObjectException(const UnexpectedObjectException&) = default;
 
    UnexpectedObjectException(const char* file, int line) : LocalExceptionHelper<UnexpectedObjectException, MarshalException>(file, line)
    {
    }
 
    UnexpectedObjectException(const char* file, int line, const ::std::string& reason, const ::std::string& type, const ::std::string& expectedType) :
        LocalExceptionHelper<UnexpectedObjectException, MarshalException>(file, line, reason),
        type(type),
        expectedType(expectedType)
    {
    }
 
    std::tuple<const ::std::string&, const ::std::string&, const ::std::string&> ice_tuple() const
    {
        return std::tie(reason, type, expectedType);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string type;
    ::std::string expectedType;
};
 
class ICE_CLASS(ICE_API) MemoryLimitException : public LocalExceptionHelper<MemoryLimitException, MarshalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~MemoryLimitException();
 
    MemoryLimitException(const MemoryLimitException&) = default;
 
    MemoryLimitException(const char* file, int line) : LocalExceptionHelper<MemoryLimitException, MarshalException>(file, line)
    {
    }
 
    MemoryLimitException(const char* file, int line, const ::std::string& reason) :
        LocalExceptionHelper<MemoryLimitException, MarshalException>(file, line, reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) StringConversionException : public LocalExceptionHelper<StringConversionException, MarshalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~StringConversionException();
 
    StringConversionException(const StringConversionException&) = default;
 
    StringConversionException(const char* file, int line) : LocalExceptionHelper<StringConversionException, MarshalException>(file, line)
    {
    }
 
    StringConversionException(const char* file, int line, const ::std::string& reason) :
        LocalExceptionHelper<StringConversionException, MarshalException>(file, line, reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) EncapsulationException : public LocalExceptionHelper<EncapsulationException, MarshalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~EncapsulationException();
 
    EncapsulationException(const EncapsulationException&) = default;
 
    EncapsulationException(const char* file, int line) : LocalExceptionHelper<EncapsulationException, MarshalException>(file, line)
    {
    }
 
    EncapsulationException(const char* file, int line, const ::std::string& reason) :
        LocalExceptionHelper<EncapsulationException, MarshalException>(file, line, reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) FeatureNotSupportedException : public LocalExceptionHelper<FeatureNotSupportedException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~FeatureNotSupportedException();
 
    FeatureNotSupportedException(const FeatureNotSupportedException&) = default;
 
    FeatureNotSupportedException(const char* file, int line) : LocalExceptionHelper<FeatureNotSupportedException, LocalException>(file, line)
    {
    }
 
    FeatureNotSupportedException(const char* file, int line, const ::std::string& unsupportedFeature) : LocalExceptionHelper<FeatureNotSupportedException, LocalException>(file, line),
        unsupportedFeature(unsupportedFeature)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(unsupportedFeature);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string unsupportedFeature;
};
 
class ICE_CLASS(ICE_API) SecurityException : public LocalExceptionHelper<SecurityException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~SecurityException();
 
    SecurityException(const SecurityException&) = default;
 
    SecurityException(const char* file, int line) : LocalExceptionHelper<SecurityException, LocalException>(file, line)
    {
    }
 
    SecurityException(const char* file, int line, const ::std::string& reason) : LocalExceptionHelper<SecurityException, LocalException>(file, line),
        reason(reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
 
    ::std::string reason;
};
 
class ICE_CLASS(ICE_API) FixedProxyException : public LocalExceptionHelper<FixedProxyException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~FixedProxyException();
 
    FixedProxyException(const FixedProxyException&) = default;
 
    FixedProxyException(const char* file, int line) : LocalExceptionHelper<FixedProxyException, LocalException>(file, line)
    {
    }
 
    std::tuple<> ice_tuple() const
    {
        return std::tie();
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
class ICE_CLASS(ICE_API) ResponseSentException : public LocalExceptionHelper<ResponseSentException, LocalException>
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ResponseSentException();
 
    ResponseSentException(const ResponseSentException&) = default;
 
    ResponseSentException(const char* file, int line) : LocalExceptionHelper<ResponseSentException, LocalException>(file, line)
    {
    }
 
    std::tuple<> ice_tuple() const
    {
        return std::tie();
    }
 
    ICE_MEMBER(ICE_API) static const ::std::string& ice_staticId();
    ICE_MEMBER(ICE_API) virtual void ice_print(::std::ostream& stream) const override;
};
 
}
 
namespace Ice
{
 
}
 
#else // C++98 mapping
 
namespace Ice
{
 
class ICE_API InitializationException : public LocalException
{
public:
 
    InitializationException(const char* file, int line);
    InitializationException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    InitializationException(const InitializationException&) = default;
    virtual ~InitializationException();
#else
    virtual ~InitializationException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual InitializationException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string reason;
};
 
class ICE_API PluginInitializationException : public LocalException
{
public:
 
    PluginInitializationException(const char* file, int line);
    PluginInitializationException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    PluginInitializationException(const PluginInitializationException&) = default;
    virtual ~PluginInitializationException();
#else
    virtual ~PluginInitializationException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual PluginInitializationException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string reason;
};
 
class ICE_API CollocationOptimizationException : public LocalException
{
public:
 
    CollocationOptimizationException(const char* file, int line);
 
#ifdef ICE_CPP11_COMPILER
    CollocationOptimizationException(const CollocationOptimizationException&) = default;
    virtual ~CollocationOptimizationException();
#else
    virtual ~CollocationOptimizationException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual CollocationOptimizationException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API AlreadyRegisteredException : public LocalException
{
public:
 
    AlreadyRegisteredException(const char* file, int line);
    AlreadyRegisteredException(const char* file, int line, const ::std::string& kindOfObject, const ::std::string& id);
 
#ifdef ICE_CPP11_COMPILER
    AlreadyRegisteredException(const AlreadyRegisteredException&) = default;
    virtual ~AlreadyRegisteredException();
#else
    virtual ~AlreadyRegisteredException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual AlreadyRegisteredException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string kindOfObject;
    ::std::string id;
};
 
class ICE_API NotRegisteredException : public LocalException
{
public:
 
    NotRegisteredException(const char* file, int line);
    NotRegisteredException(const char* file, int line, const ::std::string& kindOfObject, const ::std::string& id);
 
#ifdef ICE_CPP11_COMPILER
    NotRegisteredException(const NotRegisteredException&) = default;
    virtual ~NotRegisteredException();
#else
    virtual ~NotRegisteredException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual NotRegisteredException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string kindOfObject;
    ::std::string id;
};
 
class ICE_API TwowayOnlyException : public LocalException
{
public:
 
    TwowayOnlyException(const char* file, int line);
    TwowayOnlyException(const char* file, int line, const ::std::string& operation);
 
#ifdef ICE_CPP11_COMPILER
    TwowayOnlyException(const TwowayOnlyException&) = default;
    virtual ~TwowayOnlyException();
#else
    virtual ~TwowayOnlyException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual TwowayOnlyException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string operation;
};
 
class ICE_API CloneNotImplementedException : public LocalException
{
public:
 
    CloneNotImplementedException(const char* file, int line);
 
#ifdef ICE_CPP11_COMPILER
    CloneNotImplementedException(const CloneNotImplementedException&) = default;
    virtual ~CloneNotImplementedException();
#else
    virtual ~CloneNotImplementedException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual CloneNotImplementedException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API UnknownException : public LocalException
{
public:
 
    UnknownException(const char* file, int line);
    UnknownException(const char* file, int line, const ::std::string& unknown);
 
#ifdef ICE_CPP11_COMPILER
    UnknownException(const UnknownException&) = default;
    virtual ~UnknownException();
#else
    virtual ~UnknownException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual UnknownException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string unknown;
};
 
class ICE_API UnknownLocalException : public UnknownException
{
public:
 
    UnknownLocalException(const char* file, int line);
    UnknownLocalException(const char* file, int line, const ::std::string& unknown);
 
#ifdef ICE_CPP11_COMPILER
    UnknownLocalException(const UnknownLocalException&) = default;
    virtual ~UnknownLocalException();
#else
    virtual ~UnknownLocalException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual UnknownLocalException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API UnknownUserException : public UnknownException
{
public:
 
    UnknownUserException(const char* file, int line);
    UnknownUserException(const char* file, int line, const ::std::string& unknown);
 
#ifdef ICE_CPP11_COMPILER
    UnknownUserException(const UnknownUserException&) = default;
    virtual ~UnknownUserException();
#else
    virtual ~UnknownUserException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual UnknownUserException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API VersionMismatchException : public LocalException
{
public:
 
    VersionMismatchException(const char* file, int line);
 
#ifdef ICE_CPP11_COMPILER
    VersionMismatchException(const VersionMismatchException&) = default;
    virtual ~VersionMismatchException();
#else
    virtual ~VersionMismatchException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual VersionMismatchException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API CommunicatorDestroyedException : public LocalException
{
public:
 
    CommunicatorDestroyedException(const char* file, int line);
 
#ifdef ICE_CPP11_COMPILER
    CommunicatorDestroyedException(const CommunicatorDestroyedException&) = default;
    virtual ~CommunicatorDestroyedException();
#else
    virtual ~CommunicatorDestroyedException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual CommunicatorDestroyedException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API ObjectAdapterDeactivatedException : public LocalException
{
public:
 
    ObjectAdapterDeactivatedException(const char* file, int line);
    ObjectAdapterDeactivatedException(const char* file, int line, const ::std::string& name);
 
#ifdef ICE_CPP11_COMPILER
    ObjectAdapterDeactivatedException(const ObjectAdapterDeactivatedException&) = default;
    virtual ~ObjectAdapterDeactivatedException();
#else
    virtual ~ObjectAdapterDeactivatedException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual ObjectAdapterDeactivatedException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string name;
};
 
class ICE_API ObjectAdapterIdInUseException : public LocalException
{
public:
 
    ObjectAdapterIdInUseException(const char* file, int line);
    ObjectAdapterIdInUseException(const char* file, int line, const ::std::string& id);
 
#ifdef ICE_CPP11_COMPILER
    ObjectAdapterIdInUseException(const ObjectAdapterIdInUseException&) = default;
    virtual ~ObjectAdapterIdInUseException();
#else
    virtual ~ObjectAdapterIdInUseException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual ObjectAdapterIdInUseException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string id;
};
 
class ICE_API NoEndpointException : public LocalException
{
public:
 
    NoEndpointException(const char* file, int line);
    NoEndpointException(const char* file, int line, const ::std::string& proxy);
 
#ifdef ICE_CPP11_COMPILER
    NoEndpointException(const NoEndpointException&) = default;
    virtual ~NoEndpointException();
#else
    virtual ~NoEndpointException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual NoEndpointException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string proxy;
};
 
class ICE_API EndpointParseException : public LocalException
{
public:
 
    EndpointParseException(const char* file, int line);
    EndpointParseException(const char* file, int line, const ::std::string& str);
 
#ifdef ICE_CPP11_COMPILER
    EndpointParseException(const EndpointParseException&) = default;
    virtual ~EndpointParseException();
#else
    virtual ~EndpointParseException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual EndpointParseException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string str;
};
 
class ICE_API EndpointSelectionTypeParseException : public LocalException
{
public:
 
    EndpointSelectionTypeParseException(const char* file, int line);
    EndpointSelectionTypeParseException(const char* file, int line, const ::std::string& str);
 
#ifdef ICE_CPP11_COMPILER
    EndpointSelectionTypeParseException(const EndpointSelectionTypeParseException&) = default;
    virtual ~EndpointSelectionTypeParseException();
#else
    virtual ~EndpointSelectionTypeParseException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual EndpointSelectionTypeParseException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string str;
};
 
class ICE_API VersionParseException : public LocalException
{
public:
 
    VersionParseException(const char* file, int line);
    VersionParseException(const char* file, int line, const ::std::string& str);
 
#ifdef ICE_CPP11_COMPILER
    VersionParseException(const VersionParseException&) = default;
    virtual ~VersionParseException();
#else
    virtual ~VersionParseException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual VersionParseException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string str;
};
 
class ICE_API IdentityParseException : public LocalException
{
public:
 
    IdentityParseException(const char* file, int line);
    IdentityParseException(const char* file, int line, const ::std::string& str);
 
#ifdef ICE_CPP11_COMPILER
    IdentityParseException(const IdentityParseException&) = default;
    virtual ~IdentityParseException();
#else
    virtual ~IdentityParseException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual IdentityParseException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string str;
};
 
class ICE_API ProxyParseException : public LocalException
{
public:
 
    ProxyParseException(const char* file, int line);
    ProxyParseException(const char* file, int line, const ::std::string& str);
 
#ifdef ICE_CPP11_COMPILER
    ProxyParseException(const ProxyParseException&) = default;
    virtual ~ProxyParseException();
#else
    virtual ~ProxyParseException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual ProxyParseException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string str;
};
 
class ICE_API IllegalIdentityException : public LocalException
{
public:
 
    IllegalIdentityException(const char* file, int line);
    IllegalIdentityException(const char* file, int line, const Identity& id);
 
#ifdef ICE_CPP11_COMPILER
    IllegalIdentityException(const IllegalIdentityException&) = default;
    virtual ~IllegalIdentityException();
#else
    virtual ~IllegalIdentityException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual IllegalIdentityException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::Ice::Identity id;
};
 
class ICE_API IllegalServantException : public LocalException
{
public:
 
    IllegalServantException(const char* file, int line);
    IllegalServantException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    IllegalServantException(const IllegalServantException&) = default;
    virtual ~IllegalServantException();
#else
    virtual ~IllegalServantException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual IllegalServantException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string reason;
};
 
class ICE_API RequestFailedException : public LocalException
{
public:
 
    RequestFailedException(const char* file, int line);
    RequestFailedException(const char* file, int line, const Identity& id, const ::std::string& facet, const ::std::string& operation);
 
#ifdef ICE_CPP11_COMPILER
    RequestFailedException(const RequestFailedException&) = default;
    virtual ~RequestFailedException();
#else
    virtual ~RequestFailedException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual RequestFailedException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::Ice::Identity id;
    ::std::string facet;
    ::std::string operation;
};
 
class ICE_API ObjectNotExistException : public RequestFailedException
{
public:
 
    ObjectNotExistException(const char* file, int line);
    ObjectNotExistException(const char* file, int line, const Identity& id, const ::std::string& facet, const ::std::string& operation);
 
#ifdef ICE_CPP11_COMPILER
    ObjectNotExistException(const ObjectNotExistException&) = default;
    virtual ~ObjectNotExistException();
#else
    virtual ~ObjectNotExistException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual ObjectNotExistException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API FacetNotExistException : public RequestFailedException
{
public:
 
    FacetNotExistException(const char* file, int line);
    FacetNotExistException(const char* file, int line, const Identity& id, const ::std::string& facet, const ::std::string& operation);
 
#ifdef ICE_CPP11_COMPILER
    FacetNotExistException(const FacetNotExistException&) = default;
    virtual ~FacetNotExistException();
#else
    virtual ~FacetNotExistException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual FacetNotExistException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API OperationNotExistException : public RequestFailedException
{
public:
 
    OperationNotExistException(const char* file, int line);
    OperationNotExistException(const char* file, int line, const Identity& id, const ::std::string& facet, const ::std::string& operation);
 
#ifdef ICE_CPP11_COMPILER
    OperationNotExistException(const OperationNotExistException&) = default;
    virtual ~OperationNotExistException();
#else
    virtual ~OperationNotExistException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual OperationNotExistException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API SyscallException : public LocalException
{
public:
 
    SyscallException(const char* file, int line);
    SyscallException(const char* file, int line, Int error);
 
#ifdef ICE_CPP11_COMPILER
    SyscallException(const SyscallException&) = default;
    virtual ~SyscallException();
#else
    virtual ~SyscallException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual SyscallException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::Ice::Int error;
};
 
class ICE_API SocketException : public SyscallException
{
public:
 
    SocketException(const char* file, int line);
    SocketException(const char* file, int line, Int error);
 
#ifdef ICE_CPP11_COMPILER
    SocketException(const SocketException&) = default;
    virtual ~SocketException();
#else
    virtual ~SocketException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual SocketException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API CFNetworkException : public SocketException
{
public:
 
    CFNetworkException(const char* file, int line);
    CFNetworkException(const char* file, int line, Int error, const ::std::string& domain);
 
#ifdef ICE_CPP11_COMPILER
    CFNetworkException(const CFNetworkException&) = default;
    virtual ~CFNetworkException();
#else
    virtual ~CFNetworkException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual CFNetworkException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string domain;
};
 
class ICE_API FileException : public SyscallException
{
public:
 
    FileException(const char* file, int line);
    FileException(const char* file, int line, Int error, const ::std::string& path);
 
#ifdef ICE_CPP11_COMPILER
    FileException(const FileException&) = default;
    virtual ~FileException();
#else
    virtual ~FileException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual FileException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string path;
};
 
class ICE_API ConnectFailedException : public SocketException
{
public:
 
    ConnectFailedException(const char* file, int line);
    ConnectFailedException(const char* file, int line, Int error);
 
#ifdef ICE_CPP11_COMPILER
    ConnectFailedException(const ConnectFailedException&) = default;
    virtual ~ConnectFailedException();
#else
    virtual ~ConnectFailedException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual ConnectFailedException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API ConnectionRefusedException : public ConnectFailedException
{
public:
 
    ConnectionRefusedException(const char* file, int line);
    ConnectionRefusedException(const char* file, int line, Int error);
 
#ifdef ICE_CPP11_COMPILER
    ConnectionRefusedException(const ConnectionRefusedException&) = default;
    virtual ~ConnectionRefusedException();
#else
    virtual ~ConnectionRefusedException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual ConnectionRefusedException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API ConnectionLostException : public SocketException
{
public:
 
    ConnectionLostException(const char* file, int line);
    ConnectionLostException(const char* file, int line, Int error);
 
#ifdef ICE_CPP11_COMPILER
    ConnectionLostException(const ConnectionLostException&) = default;
    virtual ~ConnectionLostException();
#else
    virtual ~ConnectionLostException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual ConnectionLostException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API DNSException : public LocalException
{
public:
 
    DNSException(const char* file, int line);
    DNSException(const char* file, int line, Int error, const ::std::string& host);
 
#ifdef ICE_CPP11_COMPILER
    DNSException(const DNSException&) = default;
    virtual ~DNSException();
#else
    virtual ~DNSException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual DNSException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::Ice::Int error;
    ::std::string host;
};
 
class ICE_API OperationInterruptedException : public LocalException
{
public:
 
    OperationInterruptedException(const char* file, int line);
 
#ifdef ICE_CPP11_COMPILER
    OperationInterruptedException(const OperationInterruptedException&) = default;
    virtual ~OperationInterruptedException();
#else
    virtual ~OperationInterruptedException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual OperationInterruptedException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API TimeoutException : public LocalException
{
public:
 
    TimeoutException(const char* file, int line);
 
#ifdef ICE_CPP11_COMPILER
    TimeoutException(const TimeoutException&) = default;
    virtual ~TimeoutException();
#else
    virtual ~TimeoutException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual TimeoutException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API ConnectTimeoutException : public TimeoutException
{
public:
 
    ConnectTimeoutException(const char* file, int line);
 
#ifdef ICE_CPP11_COMPILER
    ConnectTimeoutException(const ConnectTimeoutException&) = default;
    virtual ~ConnectTimeoutException();
#else
    virtual ~ConnectTimeoutException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual ConnectTimeoutException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API CloseTimeoutException : public TimeoutException
{
public:
 
    CloseTimeoutException(const char* file, int line);
 
#ifdef ICE_CPP11_COMPILER
    CloseTimeoutException(const CloseTimeoutException&) = default;
    virtual ~CloseTimeoutException();
#else
    virtual ~CloseTimeoutException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual CloseTimeoutException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API ConnectionTimeoutException : public TimeoutException
{
public:
 
    ConnectionTimeoutException(const char* file, int line);
 
#ifdef ICE_CPP11_COMPILER
    ConnectionTimeoutException(const ConnectionTimeoutException&) = default;
    virtual ~ConnectionTimeoutException();
#else
    virtual ~ConnectionTimeoutException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual ConnectionTimeoutException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API InvocationTimeoutException : public TimeoutException
{
public:
 
    InvocationTimeoutException(const char* file, int line);
 
#ifdef ICE_CPP11_COMPILER
    InvocationTimeoutException(const InvocationTimeoutException&) = default;
    virtual ~InvocationTimeoutException();
#else
    virtual ~InvocationTimeoutException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual InvocationTimeoutException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API InvocationCanceledException : public LocalException
{
public:
 
    InvocationCanceledException(const char* file, int line);
 
#ifdef ICE_CPP11_COMPILER
    InvocationCanceledException(const InvocationCanceledException&) = default;
    virtual ~InvocationCanceledException();
#else
    virtual ~InvocationCanceledException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual InvocationCanceledException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API ProtocolException : public LocalException
{
public:
 
    ProtocolException(const char* file, int line);
    ProtocolException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    ProtocolException(const ProtocolException&) = default;
    virtual ~ProtocolException();
#else
    virtual ~ProtocolException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual ProtocolException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string reason;
};
 
class ICE_API BadMagicException : public ProtocolException
{
public:
 
    BadMagicException(const char* file, int line);
    BadMagicException(const char* file, int line, const ::std::string& reason, const ByteSeq& badMagic);
 
#ifdef ICE_CPP11_COMPILER
    BadMagicException(const BadMagicException&) = default;
    virtual ~BadMagicException();
#else
    virtual ~BadMagicException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual BadMagicException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::Ice::ByteSeq badMagic;
};
 
class ICE_API UnsupportedProtocolException : public ProtocolException
{
public:
 
    UnsupportedProtocolException(const char* file, int line);
    UnsupportedProtocolException(const char* file, int line, const ::std::string& reason, const ProtocolVersion& bad, const ProtocolVersion& supported);
 
#ifdef ICE_CPP11_COMPILER
    UnsupportedProtocolException(const UnsupportedProtocolException&) = default;
    virtual ~UnsupportedProtocolException();
#else
    virtual ~UnsupportedProtocolException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual UnsupportedProtocolException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::Ice::ProtocolVersion bad;
    ::Ice::ProtocolVersion supported;
};
 
class ICE_API UnsupportedEncodingException : public ProtocolException
{
public:
 
    UnsupportedEncodingException(const char* file, int line);
    UnsupportedEncodingException(const char* file, int line, const ::std::string& reason, const EncodingVersion& bad, const EncodingVersion& supported);
 
#ifdef ICE_CPP11_COMPILER
    UnsupportedEncodingException(const UnsupportedEncodingException&) = default;
    virtual ~UnsupportedEncodingException();
#else
    virtual ~UnsupportedEncodingException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual UnsupportedEncodingException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::Ice::EncodingVersion bad;
    ::Ice::EncodingVersion supported;
};
 
class ICE_API UnknownMessageException : public ProtocolException
{
public:
 
    UnknownMessageException(const char* file, int line);
    UnknownMessageException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    UnknownMessageException(const UnknownMessageException&) = default;
    virtual ~UnknownMessageException();
#else
    virtual ~UnknownMessageException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual UnknownMessageException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API ConnectionNotValidatedException : public ProtocolException
{
public:
 
    ConnectionNotValidatedException(const char* file, int line);
    ConnectionNotValidatedException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    ConnectionNotValidatedException(const ConnectionNotValidatedException&) = default;
    virtual ~ConnectionNotValidatedException();
#else
    virtual ~ConnectionNotValidatedException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual ConnectionNotValidatedException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API UnknownRequestIdException : public ProtocolException
{
public:
 
    UnknownRequestIdException(const char* file, int line);
    UnknownRequestIdException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    UnknownRequestIdException(const UnknownRequestIdException&) = default;
    virtual ~UnknownRequestIdException();
#else
    virtual ~UnknownRequestIdException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual UnknownRequestIdException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API UnknownReplyStatusException : public ProtocolException
{
public:
 
    UnknownReplyStatusException(const char* file, int line);
    UnknownReplyStatusException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    UnknownReplyStatusException(const UnknownReplyStatusException&) = default;
    virtual ~UnknownReplyStatusException();
#else
    virtual ~UnknownReplyStatusException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual UnknownReplyStatusException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API CloseConnectionException : public ProtocolException
{
public:
 
    CloseConnectionException(const char* file, int line);
    CloseConnectionException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    CloseConnectionException(const CloseConnectionException&) = default;
    virtual ~CloseConnectionException();
#else
    virtual ~CloseConnectionException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual CloseConnectionException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API ConnectionManuallyClosedException : public LocalException
{
public:
 
    ConnectionManuallyClosedException(const char* file, int line);
    ConnectionManuallyClosedException(const char* file, int line, bool graceful);
 
#ifdef ICE_CPP11_COMPILER
    ConnectionManuallyClosedException(const ConnectionManuallyClosedException&) = default;
    virtual ~ConnectionManuallyClosedException();
#else
    virtual ~ConnectionManuallyClosedException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual ConnectionManuallyClosedException* ice_clone() const;
    virtual void ice_throw() const;
 
    bool graceful;
};
 
class ICE_API IllegalMessageSizeException : public ProtocolException
{
public:
 
    IllegalMessageSizeException(const char* file, int line);
    IllegalMessageSizeException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    IllegalMessageSizeException(const IllegalMessageSizeException&) = default;
    virtual ~IllegalMessageSizeException();
#else
    virtual ~IllegalMessageSizeException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual IllegalMessageSizeException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API CompressionException : public ProtocolException
{
public:
 
    CompressionException(const char* file, int line);
    CompressionException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    CompressionException(const CompressionException&) = default;
    virtual ~CompressionException();
#else
    virtual ~CompressionException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual CompressionException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API DatagramLimitException : public ProtocolException
{
public:
 
    DatagramLimitException(const char* file, int line);
    DatagramLimitException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    DatagramLimitException(const DatagramLimitException&) = default;
    virtual ~DatagramLimitException();
#else
    virtual ~DatagramLimitException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual DatagramLimitException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API MarshalException : public ProtocolException
{
public:
 
    MarshalException(const char* file, int line);
    MarshalException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    MarshalException(const MarshalException&) = default;
    virtual ~MarshalException();
#else
    virtual ~MarshalException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual MarshalException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API ProxyUnmarshalException : public MarshalException
{
public:
 
    ProxyUnmarshalException(const char* file, int line);
    ProxyUnmarshalException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    ProxyUnmarshalException(const ProxyUnmarshalException&) = default;
    virtual ~ProxyUnmarshalException();
#else
    virtual ~ProxyUnmarshalException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual ProxyUnmarshalException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API UnmarshalOutOfBoundsException : public MarshalException
{
public:
 
    UnmarshalOutOfBoundsException(const char* file, int line);
    UnmarshalOutOfBoundsException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    UnmarshalOutOfBoundsException(const UnmarshalOutOfBoundsException&) = default;
    virtual ~UnmarshalOutOfBoundsException();
#else
    virtual ~UnmarshalOutOfBoundsException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual UnmarshalOutOfBoundsException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API NoValueFactoryException : public MarshalException
{
public:
 
    NoValueFactoryException(const char* file, int line);
    NoValueFactoryException(const char* file, int line, const ::std::string& reason, const ::std::string& type);
 
#ifdef ICE_CPP11_COMPILER
    NoValueFactoryException(const NoValueFactoryException&) = default;
    virtual ~NoValueFactoryException();
#else
    virtual ~NoValueFactoryException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual NoValueFactoryException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string type;
};
 
class ICE_API UnexpectedObjectException : public MarshalException
{
public:
 
    UnexpectedObjectException(const char* file, int line);
    UnexpectedObjectException(const char* file, int line, const ::std::string& reason, const ::std::string& type, const ::std::string& expectedType);
 
#ifdef ICE_CPP11_COMPILER
    UnexpectedObjectException(const UnexpectedObjectException&) = default;
    virtual ~UnexpectedObjectException();
#else
    virtual ~UnexpectedObjectException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual UnexpectedObjectException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string type;
    ::std::string expectedType;
};
 
class ICE_API MemoryLimitException : public MarshalException
{
public:
 
    MemoryLimitException(const char* file, int line);
    MemoryLimitException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    MemoryLimitException(const MemoryLimitException&) = default;
    virtual ~MemoryLimitException();
#else
    virtual ~MemoryLimitException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual MemoryLimitException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API StringConversionException : public MarshalException
{
public:
 
    StringConversionException(const char* file, int line);
    StringConversionException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    StringConversionException(const StringConversionException&) = default;
    virtual ~StringConversionException();
#else
    virtual ~StringConversionException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual StringConversionException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API EncapsulationException : public MarshalException
{
public:
 
    EncapsulationException(const char* file, int line);
    EncapsulationException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    EncapsulationException(const EncapsulationException&) = default;
    virtual ~EncapsulationException();
#else
    virtual ~EncapsulationException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual EncapsulationException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API FeatureNotSupportedException : public LocalException
{
public:
 
    FeatureNotSupportedException(const char* file, int line);
    FeatureNotSupportedException(const char* file, int line, const ::std::string& unsupportedFeature);
 
#ifdef ICE_CPP11_COMPILER
    FeatureNotSupportedException(const FeatureNotSupportedException&) = default;
    virtual ~FeatureNotSupportedException();
#else
    virtual ~FeatureNotSupportedException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual FeatureNotSupportedException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string unsupportedFeature;
};
 
class ICE_API SecurityException : public LocalException
{
public:
 
    SecurityException(const char* file, int line);
    SecurityException(const char* file, int line, const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    SecurityException(const SecurityException&) = default;
    virtual ~SecurityException();
#else
    virtual ~SecurityException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual SecurityException* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string reason;
};
 
class ICE_API FixedProxyException : public LocalException
{
public:
 
    FixedProxyException(const char* file, int line);
 
#ifdef ICE_CPP11_COMPILER
    FixedProxyException(const FixedProxyException&) = default;
    virtual ~FixedProxyException();
#else
    virtual ~FixedProxyException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual FixedProxyException* ice_clone() const;
    virtual void ice_throw() const;
};
 
class ICE_API ResponseSentException : public LocalException
{
public:
 
    ResponseSentException(const char* file, int line);
 
#ifdef ICE_CPP11_COMPILER
    ResponseSentException(const ResponseSentException&) = default;
    virtual ~ResponseSentException();
#else
    virtual ~ResponseSentException() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual void ice_print(::std::ostream& stream) const;
    virtual ResponseSentException* ice_clone() const;
    virtual void ice_throw() const;
};
 
}
 
namespace Ice
{
 
}
 
#endif
 
#include <IceUtil/PopDisableWarnings.h>
#endif