// **********************************************************************
//
// Copyright (c) 2003-2015 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
//
// Ice version 3.6.0
//
// <auto-generated>
//
// Generated from file `LocalException.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//

#ifndef ICE_API_EXPORTS
#   define ICE_API_EXPORTS
#endif
#include <Ice/LocalException.h>
#include <IceUtil/PushDisableWarnings.h>
#include <Ice/BasicStream.h>
#include <IceUtil/Iterator.h>
#include <IceUtil/PopDisableWarnings.h>

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

Ice::InitializationException::InitializationException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::InitializationException::InitializationException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::LocalException(__file, __line),
    reason(__ice_reason)
{
}

Ice::InitializationException::~InitializationException() throw()
{
}

::std::string
Ice::InitializationException::ice_name() const
{
    return "Ice::InitializationException";
}

Ice::InitializationException*
Ice::InitializationException::ice_clone() const
{
    return new InitializationException(*this);
}

void
Ice::InitializationException::ice_throw() const
{
    throw *this;
}

Ice::PluginInitializationException::PluginInitializationException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::PluginInitializationException::PluginInitializationException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::LocalException(__file, __line),
    reason(__ice_reason)
{
}

Ice::PluginInitializationException::~PluginInitializationException() throw()
{
}

::std::string
Ice::PluginInitializationException::ice_name() const
{
    return "Ice::PluginInitializationException";
}

Ice::PluginInitializationException*
Ice::PluginInitializationException::ice_clone() const
{
    return new PluginInitializationException(*this);
}

void
Ice::PluginInitializationException::ice_throw() const
{
    throw *this;
}

Ice::CollocationOptimizationException::CollocationOptimizationException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::CollocationOptimizationException::~CollocationOptimizationException() throw()
{
}

::std::string
Ice::CollocationOptimizationException::ice_name() const
{
    return "Ice::CollocationOptimizationException";
}

Ice::CollocationOptimizationException*
Ice::CollocationOptimizationException::ice_clone() const
{
    return new CollocationOptimizationException(*this);
}

void
Ice::CollocationOptimizationException::ice_throw() const
{
    throw *this;
}

Ice::AlreadyRegisteredException::AlreadyRegisteredException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::AlreadyRegisteredException::AlreadyRegisteredException(const char* __file, int __line, const ::std::string& __ice_kindOfObject, const ::std::string& __ice_id) :
    ::Ice::LocalException(__file, __line),
    kindOfObject(__ice_kindOfObject),
    id(__ice_id)
{
}

Ice::AlreadyRegisteredException::~AlreadyRegisteredException() throw()
{
}

::std::string
Ice::AlreadyRegisteredException::ice_name() const
{
    return "Ice::AlreadyRegisteredException";
}

Ice::AlreadyRegisteredException*
Ice::AlreadyRegisteredException::ice_clone() const
{
    return new AlreadyRegisteredException(*this);
}

void
Ice::AlreadyRegisteredException::ice_throw() const
{
    throw *this;
}

Ice::NotRegisteredException::NotRegisteredException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::NotRegisteredException::NotRegisteredException(const char* __file, int __line, const ::std::string& __ice_kindOfObject, const ::std::string& __ice_id) :
    ::Ice::LocalException(__file, __line),
    kindOfObject(__ice_kindOfObject),
    id(__ice_id)
{
}

Ice::NotRegisteredException::~NotRegisteredException() throw()
{
}

::std::string
Ice::NotRegisteredException::ice_name() const
{
    return "Ice::NotRegisteredException";
}

Ice::NotRegisteredException*
Ice::NotRegisteredException::ice_clone() const
{
    return new NotRegisteredException(*this);
}

void
Ice::NotRegisteredException::ice_throw() const
{
    throw *this;
}

Ice::TwowayOnlyException::TwowayOnlyException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::TwowayOnlyException::TwowayOnlyException(const char* __file, int __line, const ::std::string& __ice_operation) :
    ::Ice::LocalException(__file, __line),
    operation(__ice_operation)
{
}

Ice::TwowayOnlyException::~TwowayOnlyException() throw()
{
}

::std::string
Ice::TwowayOnlyException::ice_name() const
{
    return "Ice::TwowayOnlyException";
}

Ice::TwowayOnlyException*
Ice::TwowayOnlyException::ice_clone() const
{
    return new TwowayOnlyException(*this);
}

void
Ice::TwowayOnlyException::ice_throw() const
{
    throw *this;
}

Ice::CloneNotImplementedException::CloneNotImplementedException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::CloneNotImplementedException::~CloneNotImplementedException() throw()
{
}

::std::string
Ice::CloneNotImplementedException::ice_name() const
{
    return "Ice::CloneNotImplementedException";
}

Ice::CloneNotImplementedException*
Ice::CloneNotImplementedException::ice_clone() const
{
    return new CloneNotImplementedException(*this);
}

void
Ice::CloneNotImplementedException::ice_throw() const
{
    throw *this;
}

Ice::UnknownException::UnknownException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::UnknownException::UnknownException(const char* __file, int __line, const ::std::string& __ice_unknown) :
    ::Ice::LocalException(__file, __line),
    unknown(__ice_unknown)
{
}

Ice::UnknownException::~UnknownException() throw()
{
}

::std::string
Ice::UnknownException::ice_name() const
{
    return "Ice::UnknownException";
}

Ice::UnknownException*
Ice::UnknownException::ice_clone() const
{
    return new UnknownException(*this);
}

void
Ice::UnknownException::ice_throw() const
{
    throw *this;
}

Ice::UnknownLocalException::UnknownLocalException(const char* __file, int __line) :
    ::Ice::UnknownException(__file, __line)
{
}

Ice::UnknownLocalException::UnknownLocalException(const char* __file, int __line, const ::std::string& __ice_unknown) :
    ::Ice::UnknownException(__file, __line, __ice_unknown)
{
}

Ice::UnknownLocalException::~UnknownLocalException() throw()
{
}

::std::string
Ice::UnknownLocalException::ice_name() const
{
    return "Ice::UnknownLocalException";
}

Ice::UnknownLocalException*
Ice::UnknownLocalException::ice_clone() const
{
    return new UnknownLocalException(*this);
}

void
Ice::UnknownLocalException::ice_throw() const
{
    throw *this;
}

Ice::UnknownUserException::UnknownUserException(const char* __file, int __line) :
    ::Ice::UnknownException(__file, __line)
{
}

Ice::UnknownUserException::UnknownUserException(const char* __file, int __line, const ::std::string& __ice_unknown) :
    ::Ice::UnknownException(__file, __line, __ice_unknown)
{
}

Ice::UnknownUserException::~UnknownUserException() throw()
{
}

::std::string
Ice::UnknownUserException::ice_name() const
{
    return "Ice::UnknownUserException";
}

Ice::UnknownUserException*
Ice::UnknownUserException::ice_clone() const
{
    return new UnknownUserException(*this);
}

void
Ice::UnknownUserException::ice_throw() const
{
    throw *this;
}

Ice::VersionMismatchException::VersionMismatchException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::VersionMismatchException::~VersionMismatchException() throw()
{
}

::std::string
Ice::VersionMismatchException::ice_name() const
{
    return "Ice::VersionMismatchException";
}

Ice::VersionMismatchException*
Ice::VersionMismatchException::ice_clone() const
{
    return new VersionMismatchException(*this);
}

void
Ice::VersionMismatchException::ice_throw() const
{
    throw *this;
}

Ice::CommunicatorDestroyedException::CommunicatorDestroyedException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::CommunicatorDestroyedException::~CommunicatorDestroyedException() throw()
{
}

::std::string
Ice::CommunicatorDestroyedException::ice_name() const
{
    return "Ice::CommunicatorDestroyedException";
}

Ice::CommunicatorDestroyedException*
Ice::CommunicatorDestroyedException::ice_clone() const
{
    return new CommunicatorDestroyedException(*this);
}

void
Ice::CommunicatorDestroyedException::ice_throw() const
{
    throw *this;
}

Ice::ObjectAdapterDeactivatedException::ObjectAdapterDeactivatedException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::ObjectAdapterDeactivatedException::ObjectAdapterDeactivatedException(const char* __file, int __line, const ::std::string& __ice_name) :
    ::Ice::LocalException(__file, __line),
    name(__ice_name)
{
}

Ice::ObjectAdapterDeactivatedException::~ObjectAdapterDeactivatedException() throw()
{
}

::std::string
Ice::ObjectAdapterDeactivatedException::ice_name() const
{
    return "Ice::ObjectAdapterDeactivatedException";
}

Ice::ObjectAdapterDeactivatedException*
Ice::ObjectAdapterDeactivatedException::ice_clone() const
{
    return new ObjectAdapterDeactivatedException(*this);
}

void
Ice::ObjectAdapterDeactivatedException::ice_throw() const
{
    throw *this;
}

Ice::ObjectAdapterIdInUseException::ObjectAdapterIdInUseException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::ObjectAdapterIdInUseException::ObjectAdapterIdInUseException(const char* __file, int __line, const ::std::string& __ice_id) :
    ::Ice::LocalException(__file, __line),
    id(__ice_id)
{
}

Ice::ObjectAdapterIdInUseException::~ObjectAdapterIdInUseException() throw()
{
}

::std::string
Ice::ObjectAdapterIdInUseException::ice_name() const
{
    return "Ice::ObjectAdapterIdInUseException";
}

Ice::ObjectAdapterIdInUseException*
Ice::ObjectAdapterIdInUseException::ice_clone() const
{
    return new ObjectAdapterIdInUseException(*this);
}

void
Ice::ObjectAdapterIdInUseException::ice_throw() const
{
    throw *this;
}

Ice::NoEndpointException::NoEndpointException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::NoEndpointException::NoEndpointException(const char* __file, int __line, const ::std::string& __ice_proxy) :
    ::Ice::LocalException(__file, __line),
    proxy(__ice_proxy)
{
}

Ice::NoEndpointException::~NoEndpointException() throw()
{
}

::std::string
Ice::NoEndpointException::ice_name() const
{
    return "Ice::NoEndpointException";
}

Ice::NoEndpointException*
Ice::NoEndpointException::ice_clone() const
{
    return new NoEndpointException(*this);
}

void
Ice::NoEndpointException::ice_throw() const
{
    throw *this;
}

Ice::EndpointParseException::EndpointParseException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::EndpointParseException::EndpointParseException(const char* __file, int __line, const ::std::string& __ice_str) :
    ::Ice::LocalException(__file, __line),
    str(__ice_str)
{
}

Ice::EndpointParseException::~EndpointParseException() throw()
{
}

::std::string
Ice::EndpointParseException::ice_name() const
{
    return "Ice::EndpointParseException";
}

Ice::EndpointParseException*
Ice::EndpointParseException::ice_clone() const
{
    return new EndpointParseException(*this);
}

void
Ice::EndpointParseException::ice_throw() const
{
    throw *this;
}

Ice::EndpointSelectionTypeParseException::EndpointSelectionTypeParseException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::EndpointSelectionTypeParseException::EndpointSelectionTypeParseException(const char* __file, int __line, const ::std::string& __ice_str) :
    ::Ice::LocalException(__file, __line),
    str(__ice_str)
{
}

Ice::EndpointSelectionTypeParseException::~EndpointSelectionTypeParseException() throw()
{
}

::std::string
Ice::EndpointSelectionTypeParseException::ice_name() const
{
    return "Ice::EndpointSelectionTypeParseException";
}

Ice::EndpointSelectionTypeParseException*
Ice::EndpointSelectionTypeParseException::ice_clone() const
{
    return new EndpointSelectionTypeParseException(*this);
}

void
Ice::EndpointSelectionTypeParseException::ice_throw() const
{
    throw *this;
}

Ice::VersionParseException::VersionParseException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::VersionParseException::VersionParseException(const char* __file, int __line, const ::std::string& __ice_str) :
    ::Ice::LocalException(__file, __line),
    str(__ice_str)
{
}

Ice::VersionParseException::~VersionParseException() throw()
{
}

::std::string
Ice::VersionParseException::ice_name() const
{
    return "Ice::VersionParseException";
}

Ice::VersionParseException*
Ice::VersionParseException::ice_clone() const
{
    return new VersionParseException(*this);
}

void
Ice::VersionParseException::ice_throw() const
{
    throw *this;
}

Ice::IdentityParseException::IdentityParseException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::IdentityParseException::IdentityParseException(const char* __file, int __line, const ::std::string& __ice_str) :
    ::Ice::LocalException(__file, __line),
    str(__ice_str)
{
}

Ice::IdentityParseException::~IdentityParseException() throw()
{
}

::std::string
Ice::IdentityParseException::ice_name() const
{
    return "Ice::IdentityParseException";
}

Ice::IdentityParseException*
Ice::IdentityParseException::ice_clone() const
{
    return new IdentityParseException(*this);
}

void
Ice::IdentityParseException::ice_throw() const
{
    throw *this;
}

Ice::ProxyParseException::ProxyParseException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::ProxyParseException::ProxyParseException(const char* __file, int __line, const ::std::string& __ice_str) :
    ::Ice::LocalException(__file, __line),
    str(__ice_str)
{
}

Ice::ProxyParseException::~ProxyParseException() throw()
{
}

::std::string
Ice::ProxyParseException::ice_name() const
{
    return "Ice::ProxyParseException";
}

Ice::ProxyParseException*
Ice::ProxyParseException::ice_clone() const
{
    return new ProxyParseException(*this);
}

void
Ice::ProxyParseException::ice_throw() const
{
    throw *this;
}

Ice::IllegalIdentityException::IllegalIdentityException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::IllegalIdentityException::IllegalIdentityException(const char* __file, int __line, const ::Ice::Identity& __ice_id) :
    ::Ice::LocalException(__file, __line),
    id(__ice_id)
{
}

Ice::IllegalIdentityException::~IllegalIdentityException() throw()
{
}

::std::string
Ice::IllegalIdentityException::ice_name() const
{
    return "Ice::IllegalIdentityException";
}

Ice::IllegalIdentityException*
Ice::IllegalIdentityException::ice_clone() const
{
    return new IllegalIdentityException(*this);
}

void
Ice::IllegalIdentityException::ice_throw() const
{
    throw *this;
}

Ice::IllegalServantException::IllegalServantException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::IllegalServantException::IllegalServantException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::LocalException(__file, __line),
    reason(__ice_reason)
{
}

Ice::IllegalServantException::~IllegalServantException() throw()
{
}

::std::string
Ice::IllegalServantException::ice_name() const
{
    return "Ice::IllegalServantException";
}

Ice::IllegalServantException*
Ice::IllegalServantException::ice_clone() const
{
    return new IllegalServantException(*this);
}

void
Ice::IllegalServantException::ice_throw() const
{
    throw *this;
}

Ice::RequestFailedException::RequestFailedException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::RequestFailedException::RequestFailedException(const char* __file, int __line, const ::Ice::Identity& __ice_id, const ::std::string& __ice_facet, const ::std::string& __ice_operation) :
    ::Ice::LocalException(__file, __line),
    id(__ice_id),
    facet(__ice_facet),
    operation(__ice_operation)
{
}

Ice::RequestFailedException::~RequestFailedException() throw()
{
}

::std::string
Ice::RequestFailedException::ice_name() const
{
    return "Ice::RequestFailedException";
}

Ice::RequestFailedException*
Ice::RequestFailedException::ice_clone() const
{
    return new RequestFailedException(*this);
}

void
Ice::RequestFailedException::ice_throw() const
{
    throw *this;
}

Ice::ObjectNotExistException::ObjectNotExistException(const char* __file, int __line) :
    ::Ice::RequestFailedException(__file, __line)
{
}

Ice::ObjectNotExistException::ObjectNotExistException(const char* __file, int __line, const ::Ice::Identity& __ice_id, const ::std::string& __ice_facet, const ::std::string& __ice_operation) :
    ::Ice::RequestFailedException(__file, __line, __ice_id, __ice_facet, __ice_operation)
{
}

Ice::ObjectNotExistException::~ObjectNotExistException() throw()
{
}

::std::string
Ice::ObjectNotExistException::ice_name() const
{
    return "Ice::ObjectNotExistException";
}

Ice::ObjectNotExistException*
Ice::ObjectNotExistException::ice_clone() const
{
    return new ObjectNotExistException(*this);
}

void
Ice::ObjectNotExistException::ice_throw() const
{
    throw *this;
}

Ice::FacetNotExistException::FacetNotExistException(const char* __file, int __line) :
    ::Ice::RequestFailedException(__file, __line)
{
}

Ice::FacetNotExistException::FacetNotExistException(const char* __file, int __line, const ::Ice::Identity& __ice_id, const ::std::string& __ice_facet, const ::std::string& __ice_operation) :
    ::Ice::RequestFailedException(__file, __line, __ice_id, __ice_facet, __ice_operation)
{
}

Ice::FacetNotExistException::~FacetNotExistException() throw()
{
}

::std::string
Ice::FacetNotExistException::ice_name() const
{
    return "Ice::FacetNotExistException";
}

Ice::FacetNotExistException*
Ice::FacetNotExistException::ice_clone() const
{
    return new FacetNotExistException(*this);
}

void
Ice::FacetNotExistException::ice_throw() const
{
    throw *this;
}

Ice::OperationNotExistException::OperationNotExistException(const char* __file, int __line) :
    ::Ice::RequestFailedException(__file, __line)
{
}

Ice::OperationNotExistException::OperationNotExistException(const char* __file, int __line, const ::Ice::Identity& __ice_id, const ::std::string& __ice_facet, const ::std::string& __ice_operation) :
    ::Ice::RequestFailedException(__file, __line, __ice_id, __ice_facet, __ice_operation)
{
}

Ice::OperationNotExistException::~OperationNotExistException() throw()
{
}

::std::string
Ice::OperationNotExistException::ice_name() const
{
    return "Ice::OperationNotExistException";
}

Ice::OperationNotExistException*
Ice::OperationNotExistException::ice_clone() const
{
    return new OperationNotExistException(*this);
}

void
Ice::OperationNotExistException::ice_throw() const
{
    throw *this;
}

Ice::SyscallException::SyscallException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line), 
    error(0)
{
}

Ice::SyscallException::SyscallException(const char* __file, int __line, ::Ice::Int __ice_error) :
    ::Ice::LocalException(__file, __line),
    error(__ice_error)
{
}

Ice::SyscallException::~SyscallException() throw()
{
}

::std::string
Ice::SyscallException::ice_name() const
{
    return "Ice::SyscallException";
}

Ice::SyscallException*
Ice::SyscallException::ice_clone() const
{
    return new SyscallException(*this);
}

void
Ice::SyscallException::ice_throw() const
{
    throw *this;
}

Ice::SocketException::SocketException(const char* __file, int __line) :
    ::Ice::SyscallException(__file, __line)
{
}

Ice::SocketException::SocketException(const char* __file, int __line, ::Ice::Int __ice_error) :
    ::Ice::SyscallException(__file, __line, __ice_error)
{
}

Ice::SocketException::~SocketException() throw()
{
}

::std::string
Ice::SocketException::ice_name() const
{
    return "Ice::SocketException";
}

Ice::SocketException*
Ice::SocketException::ice_clone() const
{
    return new SocketException(*this);
}

void
Ice::SocketException::ice_throw() const
{
    throw *this;
}

Ice::FileException::FileException(const char* __file, int __line) :
    ::Ice::SyscallException(__file, __line)
{
}

Ice::FileException::FileException(const char* __file, int __line, ::Ice::Int __ice_error, const ::std::string& __ice_path) :
    ::Ice::SyscallException(__file, __line, __ice_error),
    path(__ice_path)
{
}

Ice::FileException::~FileException() throw()
{
}

::std::string
Ice::FileException::ice_name() const
{
    return "Ice::FileException";
}

Ice::FileException*
Ice::FileException::ice_clone() const
{
    return new FileException(*this);
}

void
Ice::FileException::ice_throw() const
{
    throw *this;
}

Ice::ConnectFailedException::ConnectFailedException(const char* __file, int __line) :
    ::Ice::SocketException(__file, __line)
{
}

Ice::ConnectFailedException::ConnectFailedException(const char* __file, int __line, ::Ice::Int __ice_error) :
    ::Ice::SocketException(__file, __line, __ice_error)
{
}

Ice::ConnectFailedException::~ConnectFailedException() throw()
{
}

::std::string
Ice::ConnectFailedException::ice_name() const
{
    return "Ice::ConnectFailedException";
}

Ice::ConnectFailedException*
Ice::ConnectFailedException::ice_clone() const
{
    return new ConnectFailedException(*this);
}

void
Ice::ConnectFailedException::ice_throw() const
{
    throw *this;
}

Ice::ConnectionRefusedException::ConnectionRefusedException(const char* __file, int __line) :
    ::Ice::ConnectFailedException(__file, __line)
{
}

Ice::ConnectionRefusedException::ConnectionRefusedException(const char* __file, int __line, ::Ice::Int __ice_error) :
    ::Ice::ConnectFailedException(__file, __line, __ice_error)
{
}

Ice::ConnectionRefusedException::~ConnectionRefusedException() throw()
{
}

::std::string
Ice::ConnectionRefusedException::ice_name() const
{
    return "Ice::ConnectionRefusedException";
}

Ice::ConnectionRefusedException*
Ice::ConnectionRefusedException::ice_clone() const
{
    return new ConnectionRefusedException(*this);
}

void
Ice::ConnectionRefusedException::ice_throw() const
{
    throw *this;
}

Ice::ConnectionLostException::ConnectionLostException(const char* __file, int __line) :
    ::Ice::SocketException(__file, __line)
{
}

Ice::ConnectionLostException::ConnectionLostException(const char* __file, int __line, ::Ice::Int __ice_error) :
    ::Ice::SocketException(__file, __line, __ice_error)
{
}

Ice::ConnectionLostException::~ConnectionLostException() throw()
{
}

::std::string
Ice::ConnectionLostException::ice_name() const
{
    return "Ice::ConnectionLostException";
}

Ice::ConnectionLostException*
Ice::ConnectionLostException::ice_clone() const
{
    return new ConnectionLostException(*this);
}

void
Ice::ConnectionLostException::ice_throw() const
{
    throw *this;
}

Ice::DNSException::DNSException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line), 
    error(0)
{
}

Ice::DNSException::DNSException(const char* __file, int __line, ::Ice::Int __ice_error, const ::std::string& __ice_host) :
    ::Ice::LocalException(__file, __line),
    error(__ice_error),
    host(__ice_host)
{
}

Ice::DNSException::~DNSException() throw()
{
}

::std::string
Ice::DNSException::ice_name() const
{
    return "Ice::DNSException";
}

Ice::DNSException*
Ice::DNSException::ice_clone() const
{
    return new DNSException(*this);
}

void
Ice::DNSException::ice_throw() const
{
    throw *this;
}

Ice::OperationInterruptedException::OperationInterruptedException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::OperationInterruptedException::~OperationInterruptedException() throw()
{
}

::std::string
Ice::OperationInterruptedException::ice_name() const
{
    return "Ice::OperationInterruptedException";
}

Ice::OperationInterruptedException*
Ice::OperationInterruptedException::ice_clone() const
{
    return new OperationInterruptedException(*this);
}

void
Ice::OperationInterruptedException::ice_throw() const
{
    throw *this;
}

Ice::TimeoutException::TimeoutException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::TimeoutException::~TimeoutException() throw()
{
}

::std::string
Ice::TimeoutException::ice_name() const
{
    return "Ice::TimeoutException";
}

Ice::TimeoutException*
Ice::TimeoutException::ice_clone() const
{
    return new TimeoutException(*this);
}

void
Ice::TimeoutException::ice_throw() const
{
    throw *this;
}

Ice::ConnectTimeoutException::ConnectTimeoutException(const char* __file, int __line) :
    ::Ice::TimeoutException(__file, __line)
{
}

Ice::ConnectTimeoutException::~ConnectTimeoutException() throw()
{
}

::std::string
Ice::ConnectTimeoutException::ice_name() const
{
    return "Ice::ConnectTimeoutException";
}

Ice::ConnectTimeoutException*
Ice::ConnectTimeoutException::ice_clone() const
{
    return new ConnectTimeoutException(*this);
}

void
Ice::ConnectTimeoutException::ice_throw() const
{
    throw *this;
}

Ice::CloseTimeoutException::CloseTimeoutException(const char* __file, int __line) :
    ::Ice::TimeoutException(__file, __line)
{
}

Ice::CloseTimeoutException::~CloseTimeoutException() throw()
{
}

::std::string
Ice::CloseTimeoutException::ice_name() const
{
    return "Ice::CloseTimeoutException";
}

Ice::CloseTimeoutException*
Ice::CloseTimeoutException::ice_clone() const
{
    return new CloseTimeoutException(*this);
}

void
Ice::CloseTimeoutException::ice_throw() const
{
    throw *this;
}

Ice::ConnectionTimeoutException::ConnectionTimeoutException(const char* __file, int __line) :
    ::Ice::TimeoutException(__file, __line)
{
}

Ice::ConnectionTimeoutException::~ConnectionTimeoutException() throw()
{
}

::std::string
Ice::ConnectionTimeoutException::ice_name() const
{
    return "Ice::ConnectionTimeoutException";
}

Ice::ConnectionTimeoutException*
Ice::ConnectionTimeoutException::ice_clone() const
{
    return new ConnectionTimeoutException(*this);
}

void
Ice::ConnectionTimeoutException::ice_throw() const
{
    throw *this;
}

Ice::InvocationTimeoutException::InvocationTimeoutException(const char* __file, int __line) :
    ::Ice::TimeoutException(__file, __line)
{
}

Ice::InvocationTimeoutException::~InvocationTimeoutException() throw()
{
}

::std::string
Ice::InvocationTimeoutException::ice_name() const
{
    return "Ice::InvocationTimeoutException";
}

Ice::InvocationTimeoutException*
Ice::InvocationTimeoutException::ice_clone() const
{
    return new InvocationTimeoutException(*this);
}

void
Ice::InvocationTimeoutException::ice_throw() const
{
    throw *this;
}

Ice::InvocationCanceledException::InvocationCanceledException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::InvocationCanceledException::~InvocationCanceledException() throw()
{
}

::std::string
Ice::InvocationCanceledException::ice_name() const
{
    return "Ice::InvocationCanceledException";
}

Ice::InvocationCanceledException*
Ice::InvocationCanceledException::ice_clone() const
{
    return new InvocationCanceledException(*this);
}

void
Ice::InvocationCanceledException::ice_throw() const
{
    throw *this;
}

Ice::ProtocolException::ProtocolException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::ProtocolException::ProtocolException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::LocalException(__file, __line),
    reason(__ice_reason)
{
}

Ice::ProtocolException::~ProtocolException() throw()
{
}

::std::string
Ice::ProtocolException::ice_name() const
{
    return "Ice::ProtocolException";
}

Ice::ProtocolException*
Ice::ProtocolException::ice_clone() const
{
    return new ProtocolException(*this);
}

void
Ice::ProtocolException::ice_throw() const
{
    throw *this;
}

Ice::BadMagicException::BadMagicException(const char* __file, int __line) :
    ::Ice::ProtocolException(__file, __line)
{
}

Ice::BadMagicException::BadMagicException(const char* __file, int __line, const ::std::string& __ice_reason, const ::Ice::ByteSeq& __ice_badMagic) :
    ::Ice::ProtocolException(__file, __line, __ice_reason),
    badMagic(__ice_badMagic)
{
}

Ice::BadMagicException::~BadMagicException() throw()
{
}

::std::string
Ice::BadMagicException::ice_name() const
{
    return "Ice::BadMagicException";
}

Ice::BadMagicException*
Ice::BadMagicException::ice_clone() const
{
    return new BadMagicException(*this);
}

void
Ice::BadMagicException::ice_throw() const
{
    throw *this;
}

Ice::UnsupportedProtocolException::UnsupportedProtocolException(const char* __file, int __line) :
    ::Ice::ProtocolException(__file, __line)
{
}

Ice::UnsupportedProtocolException::UnsupportedProtocolException(const char* __file, int __line, const ::std::string& __ice_reason, const ::Ice::ProtocolVersion& __ice_bad, const ::Ice::ProtocolVersion& __ice_supported) :
    ::Ice::ProtocolException(__file, __line, __ice_reason),
    bad(__ice_bad),
    supported(__ice_supported)
{
}

Ice::UnsupportedProtocolException::~UnsupportedProtocolException() throw()
{
}

::std::string
Ice::UnsupportedProtocolException::ice_name() const
{
    return "Ice::UnsupportedProtocolException";
}

Ice::UnsupportedProtocolException*
Ice::UnsupportedProtocolException::ice_clone() const
{
    return new UnsupportedProtocolException(*this);
}

void
Ice::UnsupportedProtocolException::ice_throw() const
{
    throw *this;
}

Ice::UnsupportedEncodingException::UnsupportedEncodingException(const char* __file, int __line) :
    ::Ice::ProtocolException(__file, __line)
{
}

Ice::UnsupportedEncodingException::UnsupportedEncodingException(const char* __file, int __line, const ::std::string& __ice_reason, const ::Ice::EncodingVersion& __ice_bad, const ::Ice::EncodingVersion& __ice_supported) :
    ::Ice::ProtocolException(__file, __line, __ice_reason),
    bad(__ice_bad),
    supported(__ice_supported)
{
}

Ice::UnsupportedEncodingException::~UnsupportedEncodingException() throw()
{
}

::std::string
Ice::UnsupportedEncodingException::ice_name() const
{
    return "Ice::UnsupportedEncodingException";
}

Ice::UnsupportedEncodingException*
Ice::UnsupportedEncodingException::ice_clone() const
{
    return new UnsupportedEncodingException(*this);
}

void
Ice::UnsupportedEncodingException::ice_throw() const
{
    throw *this;
}

Ice::UnknownMessageException::UnknownMessageException(const char* __file, int __line) :
    ::Ice::ProtocolException(__file, __line)
{
}

Ice::UnknownMessageException::UnknownMessageException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::ProtocolException(__file, __line, __ice_reason)
{
}

Ice::UnknownMessageException::~UnknownMessageException() throw()
{
}

::std::string
Ice::UnknownMessageException::ice_name() const
{
    return "Ice::UnknownMessageException";
}

Ice::UnknownMessageException*
Ice::UnknownMessageException::ice_clone() const
{
    return new UnknownMessageException(*this);
}

void
Ice::UnknownMessageException::ice_throw() const
{
    throw *this;
}

Ice::ConnectionNotValidatedException::ConnectionNotValidatedException(const char* __file, int __line) :
    ::Ice::ProtocolException(__file, __line)
{
}

Ice::ConnectionNotValidatedException::ConnectionNotValidatedException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::ProtocolException(__file, __line, __ice_reason)
{
}

Ice::ConnectionNotValidatedException::~ConnectionNotValidatedException() throw()
{
}

::std::string
Ice::ConnectionNotValidatedException::ice_name() const
{
    return "Ice::ConnectionNotValidatedException";
}

Ice::ConnectionNotValidatedException*
Ice::ConnectionNotValidatedException::ice_clone() const
{
    return new ConnectionNotValidatedException(*this);
}

void
Ice::ConnectionNotValidatedException::ice_throw() const
{
    throw *this;
}

Ice::UnknownRequestIdException::UnknownRequestIdException(const char* __file, int __line) :
    ::Ice::ProtocolException(__file, __line)
{
}

Ice::UnknownRequestIdException::UnknownRequestIdException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::ProtocolException(__file, __line, __ice_reason)
{
}

Ice::UnknownRequestIdException::~UnknownRequestIdException() throw()
{
}

::std::string
Ice::UnknownRequestIdException::ice_name() const
{
    return "Ice::UnknownRequestIdException";
}

Ice::UnknownRequestIdException*
Ice::UnknownRequestIdException::ice_clone() const
{
    return new UnknownRequestIdException(*this);
}

void
Ice::UnknownRequestIdException::ice_throw() const
{
    throw *this;
}

Ice::UnknownReplyStatusException::UnknownReplyStatusException(const char* __file, int __line) :
    ::Ice::ProtocolException(__file, __line)
{
}

Ice::UnknownReplyStatusException::UnknownReplyStatusException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::ProtocolException(__file, __line, __ice_reason)
{
}

Ice::UnknownReplyStatusException::~UnknownReplyStatusException() throw()
{
}

::std::string
Ice::UnknownReplyStatusException::ice_name() const
{
    return "Ice::UnknownReplyStatusException";
}

Ice::UnknownReplyStatusException*
Ice::UnknownReplyStatusException::ice_clone() const
{
    return new UnknownReplyStatusException(*this);
}

void
Ice::UnknownReplyStatusException::ice_throw() const
{
    throw *this;
}

Ice::CloseConnectionException::CloseConnectionException(const char* __file, int __line) :
    ::Ice::ProtocolException(__file, __line)
{
}

Ice::CloseConnectionException::CloseConnectionException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::ProtocolException(__file, __line, __ice_reason)
{
}

Ice::CloseConnectionException::~CloseConnectionException() throw()
{
}

::std::string
Ice::CloseConnectionException::ice_name() const
{
    return "Ice::CloseConnectionException";
}

Ice::CloseConnectionException*
Ice::CloseConnectionException::ice_clone() const
{
    return new CloseConnectionException(*this);
}

void
Ice::CloseConnectionException::ice_throw() const
{
    throw *this;
}

Ice::ForcedCloseConnectionException::ForcedCloseConnectionException(const char* __file, int __line) :
    ::Ice::ProtocolException(__file, __line)
{
}

Ice::ForcedCloseConnectionException::ForcedCloseConnectionException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::ProtocolException(__file, __line, __ice_reason)
{
}

Ice::ForcedCloseConnectionException::~ForcedCloseConnectionException() throw()
{
}

::std::string
Ice::ForcedCloseConnectionException::ice_name() const
{
    return "Ice::ForcedCloseConnectionException";
}

Ice::ForcedCloseConnectionException*
Ice::ForcedCloseConnectionException::ice_clone() const
{
    return new ForcedCloseConnectionException(*this);
}

void
Ice::ForcedCloseConnectionException::ice_throw() const
{
    throw *this;
}

Ice::IllegalMessageSizeException::IllegalMessageSizeException(const char* __file, int __line) :
    ::Ice::ProtocolException(__file, __line)
{
}

Ice::IllegalMessageSizeException::IllegalMessageSizeException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::ProtocolException(__file, __line, __ice_reason)
{
}

Ice::IllegalMessageSizeException::~IllegalMessageSizeException() throw()
{
}

::std::string
Ice::IllegalMessageSizeException::ice_name() const
{
    return "Ice::IllegalMessageSizeException";
}

Ice::IllegalMessageSizeException*
Ice::IllegalMessageSizeException::ice_clone() const
{
    return new IllegalMessageSizeException(*this);
}

void
Ice::IllegalMessageSizeException::ice_throw() const
{
    throw *this;
}

Ice::CompressionException::CompressionException(const char* __file, int __line) :
    ::Ice::ProtocolException(__file, __line)
{
}

Ice::CompressionException::CompressionException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::ProtocolException(__file, __line, __ice_reason)
{
}

Ice::CompressionException::~CompressionException() throw()
{
}

::std::string
Ice::CompressionException::ice_name() const
{
    return "Ice::CompressionException";
}

Ice::CompressionException*
Ice::CompressionException::ice_clone() const
{
    return new CompressionException(*this);
}

void
Ice::CompressionException::ice_throw() const
{
    throw *this;
}

Ice::DatagramLimitException::DatagramLimitException(const char* __file, int __line) :
    ::Ice::ProtocolException(__file, __line)
{
}

Ice::DatagramLimitException::DatagramLimitException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::ProtocolException(__file, __line, __ice_reason)
{
}

Ice::DatagramLimitException::~DatagramLimitException() throw()
{
}

::std::string
Ice::DatagramLimitException::ice_name() const
{
    return "Ice::DatagramLimitException";
}

Ice::DatagramLimitException*
Ice::DatagramLimitException::ice_clone() const
{
    return new DatagramLimitException(*this);
}

void
Ice::DatagramLimitException::ice_throw() const
{
    throw *this;
}

Ice::MarshalException::MarshalException(const char* __file, int __line) :
    ::Ice::ProtocolException(__file, __line)
{
}

Ice::MarshalException::MarshalException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::ProtocolException(__file, __line, __ice_reason)
{
}

Ice::MarshalException::~MarshalException() throw()
{
}

::std::string
Ice::MarshalException::ice_name() const
{
    return "Ice::MarshalException";
}

Ice::MarshalException*
Ice::MarshalException::ice_clone() const
{
    return new MarshalException(*this);
}

void
Ice::MarshalException::ice_throw() const
{
    throw *this;
}

Ice::ProxyUnmarshalException::ProxyUnmarshalException(const char* __file, int __line) :
    ::Ice::MarshalException(__file, __line)
{
}

Ice::ProxyUnmarshalException::ProxyUnmarshalException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::MarshalException(__file, __line, __ice_reason)
{
}

Ice::ProxyUnmarshalException::~ProxyUnmarshalException() throw()
{
}

::std::string
Ice::ProxyUnmarshalException::ice_name() const
{
    return "Ice::ProxyUnmarshalException";
}

Ice::ProxyUnmarshalException*
Ice::ProxyUnmarshalException::ice_clone() const
{
    return new ProxyUnmarshalException(*this);
}

void
Ice::ProxyUnmarshalException::ice_throw() const
{
    throw *this;
}

Ice::UnmarshalOutOfBoundsException::UnmarshalOutOfBoundsException(const char* __file, int __line) :
    ::Ice::MarshalException(__file, __line)
{
}

Ice::UnmarshalOutOfBoundsException::UnmarshalOutOfBoundsException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::MarshalException(__file, __line, __ice_reason)
{
}

Ice::UnmarshalOutOfBoundsException::~UnmarshalOutOfBoundsException() throw()
{
}

::std::string
Ice::UnmarshalOutOfBoundsException::ice_name() const
{
    return "Ice::UnmarshalOutOfBoundsException";
}

Ice::UnmarshalOutOfBoundsException*
Ice::UnmarshalOutOfBoundsException::ice_clone() const
{
    return new UnmarshalOutOfBoundsException(*this);
}

void
Ice::UnmarshalOutOfBoundsException::ice_throw() const
{
    throw *this;
}

Ice::NoObjectFactoryException::NoObjectFactoryException(const char* __file, int __line) :
    ::Ice::MarshalException(__file, __line)
{
}

Ice::NoObjectFactoryException::NoObjectFactoryException(const char* __file, int __line, const ::std::string& __ice_reason, const ::std::string& __ice_type) :
    ::Ice::MarshalException(__file, __line, __ice_reason),
    type(__ice_type)
{
}

Ice::NoObjectFactoryException::~NoObjectFactoryException() throw()
{
}

::std::string
Ice::NoObjectFactoryException::ice_name() const
{
    return "Ice::NoObjectFactoryException";
}

Ice::NoObjectFactoryException*
Ice::NoObjectFactoryException::ice_clone() const
{
    return new NoObjectFactoryException(*this);
}

void
Ice::NoObjectFactoryException::ice_throw() const
{
    throw *this;
}

Ice::UnexpectedObjectException::UnexpectedObjectException(const char* __file, int __line) :
    ::Ice::MarshalException(__file, __line)
{
}

Ice::UnexpectedObjectException::UnexpectedObjectException(const char* __file, int __line, const ::std::string& __ice_reason, const ::std::string& __ice_type, const ::std::string& __ice_expectedType) :
    ::Ice::MarshalException(__file, __line, __ice_reason),
    type(__ice_type),
    expectedType(__ice_expectedType)
{
}

Ice::UnexpectedObjectException::~UnexpectedObjectException() throw()
{
}

::std::string
Ice::UnexpectedObjectException::ice_name() const
{
    return "Ice::UnexpectedObjectException";
}

Ice::UnexpectedObjectException*
Ice::UnexpectedObjectException::ice_clone() const
{
    return new UnexpectedObjectException(*this);
}

void
Ice::UnexpectedObjectException::ice_throw() const
{
    throw *this;
}

Ice::MemoryLimitException::MemoryLimitException(const char* __file, int __line) :
    ::Ice::MarshalException(__file, __line)
{
}

Ice::MemoryLimitException::MemoryLimitException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::MarshalException(__file, __line, __ice_reason)
{
}

Ice::MemoryLimitException::~MemoryLimitException() throw()
{
}

::std::string
Ice::MemoryLimitException::ice_name() const
{
    return "Ice::MemoryLimitException";
}

Ice::MemoryLimitException*
Ice::MemoryLimitException::ice_clone() const
{
    return new MemoryLimitException(*this);
}

void
Ice::MemoryLimitException::ice_throw() const
{
    throw *this;
}

Ice::StringConversionException::StringConversionException(const char* __file, int __line) :
    ::Ice::MarshalException(__file, __line)
{
}

Ice::StringConversionException::StringConversionException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::MarshalException(__file, __line, __ice_reason)
{
}

Ice::StringConversionException::~StringConversionException() throw()
{
}

::std::string
Ice::StringConversionException::ice_name() const
{
    return "Ice::StringConversionException";
}

Ice::StringConversionException*
Ice::StringConversionException::ice_clone() const
{
    return new StringConversionException(*this);
}

void
Ice::StringConversionException::ice_throw() const
{
    throw *this;
}

Ice::EncapsulationException::EncapsulationException(const char* __file, int __line) :
    ::Ice::MarshalException(__file, __line)
{
}

Ice::EncapsulationException::EncapsulationException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::MarshalException(__file, __line, __ice_reason)
{
}

Ice::EncapsulationException::~EncapsulationException() throw()
{
}

::std::string
Ice::EncapsulationException::ice_name() const
{
    return "Ice::EncapsulationException";
}

Ice::EncapsulationException*
Ice::EncapsulationException::ice_clone() const
{
    return new EncapsulationException(*this);
}

void
Ice::EncapsulationException::ice_throw() const
{
    throw *this;
}

Ice::FeatureNotSupportedException::FeatureNotSupportedException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::FeatureNotSupportedException::FeatureNotSupportedException(const char* __file, int __line, const ::std::string& __ice_unsupportedFeature) :
    ::Ice::LocalException(__file, __line),
    unsupportedFeature(__ice_unsupportedFeature)
{
}

Ice::FeatureNotSupportedException::~FeatureNotSupportedException() throw()
{
}

::std::string
Ice::FeatureNotSupportedException::ice_name() const
{
    return "Ice::FeatureNotSupportedException";
}

Ice::FeatureNotSupportedException*
Ice::FeatureNotSupportedException::ice_clone() const
{
    return new FeatureNotSupportedException(*this);
}

void
Ice::FeatureNotSupportedException::ice_throw() const
{
    throw *this;
}

Ice::SecurityException::SecurityException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::SecurityException::SecurityException(const char* __file, int __line, const ::std::string& __ice_reason) :
    ::Ice::LocalException(__file, __line),
    reason(__ice_reason)
{
}

Ice::SecurityException::~SecurityException() throw()
{
}

::std::string
Ice::SecurityException::ice_name() const
{
    return "Ice::SecurityException";
}

Ice::SecurityException*
Ice::SecurityException::ice_clone() const
{
    return new SecurityException(*this);
}

void
Ice::SecurityException::ice_throw() const
{
    throw *this;
}

Ice::FixedProxyException::FixedProxyException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::FixedProxyException::~FixedProxyException() throw()
{
}

::std::string
Ice::FixedProxyException::ice_name() const
{
    return "Ice::FixedProxyException";
}

Ice::FixedProxyException*
Ice::FixedProxyException::ice_clone() const
{
    return new FixedProxyException(*this);
}

void
Ice::FixedProxyException::ice_throw() const
{
    throw *this;
}

Ice::ResponseSentException::ResponseSentException(const char* __file, int __line) :
    ::Ice::LocalException(__file, __line)
{
}

Ice::ResponseSentException::~ResponseSentException() throw()
{
}

::std::string
Ice::ResponseSentException::ice_name() const
{
    return "Ice::ResponseSentException";
}

Ice::ResponseSentException*
Ice::ResponseSentException::ice_clone() const
{
    return new ResponseSentException(*this);
}

void
Ice::ResponseSentException::ice_throw() const
{
    throw *this;
}

namespace Ice
{
}
