diff options
Diffstat (limited to 'cpp/src/Ice/LocalException.cpp')
| -rw-r--r-- | cpp/src/Ice/LocalException.cpp | 1219 |
1 files changed, 1219 insertions, 0 deletions
diff --git a/cpp/src/Ice/LocalException.cpp b/cpp/src/Ice/LocalException.cpp new file mode 100644 index 00000000000..2a63fa5f75a --- /dev/null +++ b/cpp/src/Ice/LocalException.cpp @@ -0,0 +1,1219 @@ +// ********************************************************************** +// +// Copyright (c) 2001 +// MutableRealms, Inc. +// Huntsville, AL, USA +// +// All Rights Reserved +// +// ********************************************************************** + +#include <Ice/LocalException.h> +#include <Ice/Network.h> +#include <sstream> + +using namespace std; +using namespace Ice; +using namespace IceInternal; + +Ice::LocalException::LocalException(const char* file, int line) : + _file(file), + _line(line) +{ +} + +Ice::LocalException::~LocalException() +{ +} + +Ice::LocalException::LocalException(const LocalException& ex) +{ + _line = ex._line; + _file = ex._file; +} + +LocalException& +Ice::LocalException::operator=(const LocalException& ex) +{ + if (this != &ex) + { + _line = ex._line; + _file = ex._file; + } + + return *this; +} + +string +Ice::LocalException::toString() const +{ + return debugInfo() + "unknown local exception"; +} + +LocalException* +Ice::LocalException::clone() const +{ + return new LocalException(*this); +} + +void +Ice::LocalException::raise() const +{ + throw *this; +} + +std::string +Ice::LocalException::debugInfo() const +{ + ostringstream s; + s << _file << ':' << _line << ": "; + return s.str(); +} + +ostream& +Ice::operator<<(ostream& out, const LocalException& ex) +{ + string s = ex.toString(); + return out << s; +} + +Ice::UnknownUserException::UnknownUserException(const char* file, int line) : + LocalException(file, line) +{ +} + +Ice::UnknownUserException::UnknownUserException(const UnknownUserException& ex) : + LocalException(ex) +{ +} + +UnknownUserException& +Ice::UnknownUserException::operator=(const UnknownUserException& ex) +{ + LocalException::operator=(ex); + return *this; +} + +string +Ice::UnknownUserException::toString() const +{ + string s = debugInfo() + "unknown user exception"; + return s; +} + +LocalException* +Ice::UnknownUserException::clone() const +{ + return new UnknownUserException(*this); +} + +void +Ice::UnknownUserException::raise() const +{ + throw *this; +} + +Ice::VersionMismatchException::VersionMismatchException(const char* file, int line) : + LocalException(file, line) +{ +} + +Ice::VersionMismatchException::VersionMismatchException(const VersionMismatchException& ex) : + LocalException(ex) +{ +} + +VersionMismatchException& +Ice::VersionMismatchException::operator=(const VersionMismatchException& ex) +{ + LocalException::operator=(ex); + return *this; +} + +string +Ice::VersionMismatchException::toString() const +{ + string s = debugInfo() + "Ice library version mismatch"; + return s; +} + +LocalException* +Ice::VersionMismatchException::clone() const +{ + return new VersionMismatchException(*this); +} + +void +Ice::VersionMismatchException::raise() const +{ + throw *this; +} + +Ice::CommunicatorDestroyedException::CommunicatorDestroyedException(const char* file, int line) : + LocalException(file, line) +{ +} + +Ice::CommunicatorDestroyedException::CommunicatorDestroyedException(const CommunicatorDestroyedException& ex) : + LocalException(ex) +{ +} + +CommunicatorDestroyedException& +Ice::CommunicatorDestroyedException::operator=(const CommunicatorDestroyedException& ex) +{ + LocalException::operator=(ex); + return *this; +} + +string +Ice::CommunicatorDestroyedException::toString() const +{ + string s = debugInfo() + "communicator object destroyed"; + return s; +} + +LocalException* +Ice::CommunicatorDestroyedException::clone() const +{ + return new CommunicatorDestroyedException(*this); +} + +void +Ice::CommunicatorDestroyedException::raise() const +{ + throw *this; +} + +Ice::ObjectAdapterDeactivatedException::ObjectAdapterDeactivatedException(const char* file, int line) : + LocalException(file, line) +{ +} + +Ice::ObjectAdapterDeactivatedException::ObjectAdapterDeactivatedException(const ObjectAdapterDeactivatedException& ex) : + LocalException(ex) +{ +} + +ObjectAdapterDeactivatedException& +Ice::ObjectAdapterDeactivatedException::operator=(const ObjectAdapterDeactivatedException& ex) +{ + LocalException::operator=(ex); + return *this; +} + +string +Ice::ObjectAdapterDeactivatedException::toString() const +{ + string s = debugInfo() + "object adapter deactivated"; + return s; +} + +LocalException* +Ice::ObjectAdapterDeactivatedException::clone() const +{ + return new ObjectAdapterDeactivatedException(*this); +} + +void +Ice::ObjectAdapterDeactivatedException::raise() const +{ + throw *this; +} + +Ice::WrongObjectAdapterException::WrongObjectAdapterException(const char* file, int line) : + LocalException(file, line) +{ +} + +Ice::WrongObjectAdapterException::WrongObjectAdapterException(const WrongObjectAdapterException& ex) : + LocalException(ex) +{ +} + +WrongObjectAdapterException& +Ice::WrongObjectAdapterException::operator=(const WrongObjectAdapterException& ex) +{ + LocalException::operator=(ex); + return *this; +} + +string +Ice::WrongObjectAdapterException::toString() const +{ + string s = debugInfo() + "no suitable endpoint information available"; + return s; +} + +LocalException* +Ice::WrongObjectAdapterException::clone() const +{ + return new WrongObjectAdapterException(*this); +} + +void +Ice::WrongObjectAdapterException::raise() const +{ + throw *this; +} + +Ice::NoEndpointException::NoEndpointException(const char* file, int line) : + LocalException(file, line) +{ +} + +Ice::NoEndpointException::NoEndpointException(const NoEndpointException& ex) : + LocalException(ex) +{ +} + +NoEndpointException& +Ice::NoEndpointException::operator=(const NoEndpointException& ex) +{ + LocalException::operator=(ex); + return *this; +} + +string +Ice::NoEndpointException::toString() const +{ + string s = debugInfo() + "no suitable endpoint information available"; + return s; +} + +LocalException* +Ice::NoEndpointException::clone() const +{ + return new NoEndpointException(*this); +} + +void +Ice::NoEndpointException::raise() const +{ + throw *this; +} + +Ice::EndpointParseException::EndpointParseException(const char* file, int line) : + LocalException(file, line) +{ +} + +Ice::EndpointParseException::EndpointParseException(const EndpointParseException& ex) : + LocalException(ex) +{ +} + +EndpointParseException& +Ice::EndpointParseException::operator=(const EndpointParseException& ex) +{ + LocalException::operator=(ex); + return *this; +} + +string +Ice::EndpointParseException::toString() const +{ + string s = debugInfo() + "error while parsing endpoint"; + return s; +} + +LocalException* +Ice::EndpointParseException::clone() const +{ + return new EndpointParseException(*this); +} + +void +Ice::EndpointParseException::raise() const +{ + throw *this; +} + +Ice::ReferenceParseException::ReferenceParseException(const char* file, int line) : + LocalException(file, line) +{ +} + +Ice::ReferenceParseException::ReferenceParseException(const ReferenceParseException& ex) : + LocalException(ex) +{ +} + +ReferenceParseException& +Ice::ReferenceParseException::operator=(const ReferenceParseException& ex) +{ + LocalException::operator=(ex); + return *this; +} + +string +Ice::ReferenceParseException::toString() const +{ + string s = debugInfo() + "error while parsing reference"; + return s; +} + +LocalException* +Ice::ReferenceParseException::clone() const +{ + return new ReferenceParseException(*this); +} + +void +Ice::ReferenceParseException::raise() const +{ + throw *this; +} + +Ice::ReferenceIdentityException::ReferenceIdentityException(const char* file, int line) : + LocalException(file, line) +{ +} + +Ice::ReferenceIdentityException::ReferenceIdentityException(const ReferenceIdentityException& ex) : + LocalException(ex) +{ +} + +ReferenceIdentityException& +Ice::ReferenceIdentityException::operator=(const ReferenceIdentityException& ex) +{ + LocalException::operator=(ex); + return *this; +} + +string +Ice::ReferenceIdentityException::toString() const +{ + string s = debugInfo() + "reference identity mismatch in location forward"; + return s; +} + +LocalException* +Ice::ReferenceIdentityException::clone() const +{ + return new ReferenceIdentityException(*this); +} + +void +Ice::ReferenceIdentityException::raise() const +{ + throw *this; +} + +Ice::ObjectNotExistException::ObjectNotExistException(const char* file, int line) : + LocalException(file, line) +{ +} + +Ice::ObjectNotExistException::ObjectNotExistException(const ObjectNotExistException& ex) : + LocalException(ex) +{ +} + +ObjectNotExistException& +Ice::ObjectNotExistException::operator=(const ObjectNotExistException& ex) +{ + LocalException::operator=(ex); + return *this; +} + +string +Ice::ObjectNotExistException::toString() const +{ + string s = debugInfo() + "object does not exist"; + return s; +} + +LocalException* +Ice::ObjectNotExistException::clone() const +{ + return new ObjectNotExistException(*this); +} + +void +Ice::ObjectNotExistException::raise() const +{ + throw *this; +} + +Ice::OperationNotExistException::OperationNotExistException(const char* file, int line) : + LocalException(file, line) +{ +} + +Ice::OperationNotExistException::OperationNotExistException(const OperationNotExistException& ex) : + LocalException(ex) +{ +} + +OperationNotExistException& +Ice::OperationNotExistException::operator=(const OperationNotExistException& ex) +{ + LocalException::operator=(ex); + return *this; +} + +string +Ice::OperationNotExistException::toString() const +{ + string s = debugInfo() + "operation does not exist"; + return s; +} + +LocalException* +Ice::OperationNotExistException::clone() const +{ + return new OperationNotExistException(*this); +} + +void +Ice::OperationNotExistException::raise() const +{ + throw *this; +} + +Ice::NoFactoryException::NoFactoryException(const char* file, int line) : + LocalException(file, line) +{ +} + +Ice::NoFactoryException::NoFactoryException(const NoFactoryException& ex) : + LocalException(ex) +{ +} + +NoFactoryException& +Ice::NoFactoryException::operator=(const NoFactoryException& ex) +{ + LocalException::operator=(ex); + return *this; +} + +string +Ice::NoFactoryException::toString() const +{ + string s = debugInfo() + "no factory installed for class with operations"; + return s; +} + +LocalException* +Ice::NoFactoryException::clone() const +{ + return new NoFactoryException(*this); +} + +void +Ice::NoFactoryException::raise() const +{ + throw *this; +} + +Ice::SystemException::SystemException(const char* file, int line) : + LocalException(file, line) +{ +#ifdef WIN32 + _error = WSAGetLastError(); +#else + _error = errno; +#endif +} + +Ice::SystemException::SystemException(const SystemException& ex) : + LocalException(ex) +{ + _error = ex._error; +} + +SystemException& +Ice::SystemException::operator=(const SystemException& ex) +{ + LocalException::operator=(ex); + + if (this != &ex) + _error = ex._error; + + return *this; +} + +string +Ice::SystemException::toString() const +{ + string s = debugInfo() + "system exception: "; + s += errorToString(_error); + return s; +} + +LocalException* +Ice::SystemException::clone() const +{ + return new SystemException(*this); +} + +void +Ice::SystemException::raise() const +{ + throw *this; +} + +Ice::SocketException::SocketException(const char* file, int line) : + SystemException(file, line) +{ +} + +Ice::SocketException::SocketException(const SocketException& ex) : + SystemException(ex) +{ +} + +SocketException& +Ice::SocketException::operator=(const SocketException& ex) +{ + SystemException::operator=(ex); + return *this; +} + +string +Ice::SocketException::toString() const +{ + string s = debugInfo() + "socket exception: "; + s += errorToString(_error); + return s; +} + +LocalException* +Ice::SocketException::clone() const +{ + return new SocketException(*this); +} + +void +Ice::SocketException::raise() const +{ + throw *this; +} + +Ice::TimeoutException::TimeoutException(const char* file, int line) : + SocketException(file, line) +{ +} + +Ice::TimeoutException::TimeoutException(const TimeoutException& ex) : + SocketException(ex) +{ +} + +TimeoutException& +Ice::TimeoutException::operator=(const TimeoutException& ex) +{ + SocketException::operator=(ex); + return *this; +} + +string +Ice::TimeoutException::toString() const +{ + return debugInfo() + "timeout while sending or receiving data"; +} + +LocalException* +Ice::TimeoutException::clone() const +{ + return new TimeoutException(*this); +} + +void +Ice::TimeoutException::raise() const +{ + throw *this; +} + +Ice::ConnectTimeoutException::ConnectTimeoutException(const char* file, int line) : + TimeoutException(file, line) +{ +} + +Ice::ConnectTimeoutException::ConnectTimeoutException(const ConnectTimeoutException& ex) : + TimeoutException(ex) +{ +} + +ConnectTimeoutException& +Ice::ConnectTimeoutException::operator=(const ConnectTimeoutException& ex) +{ + TimeoutException::operator=(ex); + return *this; +} + +string +Ice::ConnectTimeoutException::toString() const +{ + return debugInfo() + "timeout while establishing a connection"; +} + +LocalException* +Ice::ConnectTimeoutException::clone() const +{ + return new ConnectTimeoutException(*this); +} + +void +Ice::ConnectTimeoutException::raise() const +{ + throw *this; +} + +Ice::ConnectFailedException::ConnectFailedException(const char* file, int line) : + SocketException(file, line) +{ +} + +Ice::ConnectFailedException::ConnectFailedException(const ConnectFailedException& ex) : + SocketException(ex) +{ +} + +ConnectFailedException& +Ice::ConnectFailedException::operator=(const ConnectFailedException& ex) +{ + SocketException::operator=(ex); + return *this; +} + +string +Ice::ConnectFailedException::toString() const +{ + string s = debugInfo() + "connect failed: "; + s += errorToString(_error); + return s; +} + +LocalException* +Ice::ConnectFailedException::clone() const +{ + return new ConnectFailedException(*this); +} + +void +Ice::ConnectFailedException::raise() const +{ + throw *this; +} + +Ice::ConnectionLostException::ConnectionLostException(const char* file, int line) : + SocketException(file, line) +{ +} + +Ice::ConnectionLostException::ConnectionLostException(const ConnectionLostException& ex) : + SocketException(ex) +{ +} + +ConnectionLostException& +Ice::ConnectionLostException::operator=(const ConnectionLostException& ex) +{ + SocketException::operator=(ex); + return *this; +} + +string +Ice::ConnectionLostException::toString() const +{ + string s = debugInfo() + "connection lost: "; + if (_error == 0) + s += "recv() returned zero"; + else + s += errorToString(_error); + return s; +} + +LocalException* +Ice::ConnectionLostException::clone() const +{ + return new ConnectionLostException(*this); +} + +void +Ice::ConnectionLostException::raise() const +{ + throw *this; +} + +Ice::DNSException::DNSException(const char* file, int line) : + SystemException(file, line) +{ +#ifndef WIN32 + _error = h_errno; +#endif +} + +Ice::DNSException::DNSException(const DNSException& ex) : + SystemException(ex) +{ +} + +DNSException& +Ice::DNSException::operator=(const DNSException& ex) +{ + SystemException::operator=(ex); + return *this; +} + +string +Ice::DNSException::toString() const +{ + string s = debugInfo() + "DNS error: "; + s += errorToStringDNS(_error); + return s; +} + +LocalException* +Ice::DNSException::clone() const +{ + return new DNSException(*this); +} + +void +Ice::DNSException::raise() const +{ + throw *this; +} + +Ice::ProtocolException::ProtocolException(const char* file, int line) : + LocalException(file, line) +{ +} + +Ice::ProtocolException::ProtocolException(const ProtocolException& ex) : + LocalException(ex) +{ +} + +ProtocolException& +Ice::ProtocolException::operator=(const ProtocolException& ex) +{ + LocalException::operator=(ex); + return *this; +} + +Ice::UnmarshalOutOfBoundsException::UnmarshalOutOfBoundsException(const char* file, int line) : + ProtocolException(file, line) +{ +} + +Ice::UnmarshalOutOfBoundsException::UnmarshalOutOfBoundsException(const UnmarshalOutOfBoundsException& ex) : + ProtocolException(ex) +{ +} + +UnmarshalOutOfBoundsException& +Ice::UnmarshalOutOfBoundsException::operator=(const UnmarshalOutOfBoundsException& ex) +{ + ProtocolException::operator=(ex); + return *this; +} + +string +Ice::UnmarshalOutOfBoundsException::toString() const +{ + return debugInfo() + "protocol error: out of bounds during unmarshaling"; +} + +LocalException* +Ice::UnmarshalOutOfBoundsException::clone() const +{ + return new UnmarshalOutOfBoundsException(*this); +} + +void +Ice::UnmarshalOutOfBoundsException::raise() const +{ + throw *this; +} + +Ice::ValueUnmarshalException::ValueUnmarshalException(const char* file, int line) : + ProtocolException(file, line) +{ +} + +Ice::ValueUnmarshalException::ValueUnmarshalException(const ValueUnmarshalException& ex) : + ProtocolException(ex) +{ +} + +ValueUnmarshalException& +Ice::ValueUnmarshalException::operator=(const ValueUnmarshalException& ex) +{ + ProtocolException::operator=(ex); + return *this; +} + +string +Ice::ValueUnmarshalException::toString() const +{ + return debugInfo() + "protocol error: value type does not match signature"; +} + +LocalException* +Ice::ValueUnmarshalException::clone() const +{ + return new ValueUnmarshalException(*this); +} + +void +Ice::ValueUnmarshalException::raise() const +{ + throw *this; +} + +Ice::StringEncodingException::StringEncodingException(const char* file, int line) : + ProtocolException(file, line) +{ +} + +Ice::StringEncodingException::StringEncodingException(const StringEncodingException& ex) : + ProtocolException(ex) +{ +} + +StringEncodingException& +Ice::StringEncodingException::operator=(const StringEncodingException& ex) +{ + ProtocolException::operator=(ex); + return *this; +} + +string +Ice::StringEncodingException::toString() const +{ + return debugInfo() + "protocol error: string encoding error"; +} + +LocalException* +Ice::StringEncodingException::clone() const +{ + return new StringEncodingException(*this); +} + +void +Ice::StringEncodingException::raise() const +{ + throw *this; +} + +Ice::MemoryLimitException::MemoryLimitException(const char* file, int line) : + ProtocolException(file, line) +{ +} + +Ice::MemoryLimitException::MemoryLimitException(const MemoryLimitException& ex) : + ProtocolException(ex) +{ +} + +MemoryLimitException& +Ice::MemoryLimitException::operator=(const MemoryLimitException& ex) +{ + ProtocolException::operator=(ex); + return *this; +} + +string +Ice::MemoryLimitException::toString() const +{ + return debugInfo() + "protocol error: memory limit exceeded"; +} + +LocalException* +Ice::MemoryLimitException::clone() const +{ + return new MemoryLimitException(*this); +} + +void +Ice::MemoryLimitException::raise() const +{ + throw *this; +} + +Ice::EncapsulationException::EncapsulationException(const char* file, int line) : + ProtocolException(file, line) +{ +} + +Ice::EncapsulationException::EncapsulationException(const EncapsulationException& ex) : + ProtocolException(ex) +{ +} + +EncapsulationException& +Ice::EncapsulationException::operator=(const EncapsulationException& ex) +{ + ProtocolException::operator=(ex); + return *this; +} + +string +Ice::EncapsulationException::toString() const +{ + return debugInfo() + "protocol error: illegal encapsulation"; +} + +LocalException* +Ice::EncapsulationException::clone() const +{ + return new EncapsulationException(*this); +} + +void +Ice::EncapsulationException::raise() const +{ + throw *this; +} + +Ice::UnsupportedProtocolException::UnsupportedProtocolException(const char* file, int line) : + ProtocolException(file, line) +{ +} + +Ice::UnsupportedProtocolException::UnsupportedProtocolException(const UnsupportedProtocolException& ex) : + ProtocolException(ex) +{ +} + +UnsupportedProtocolException& +Ice::UnsupportedProtocolException::operator=(const UnsupportedProtocolException& ex) +{ + ProtocolException::operator=(ex); + return *this; +} + +string +Ice::UnsupportedProtocolException::toString() const +{ + return debugInfo() + "protocol error: unsupported protocol version"; +} + +LocalException* +Ice::UnsupportedProtocolException::clone() const +{ + return new UnsupportedProtocolException(*this); +} + +void +Ice::UnsupportedProtocolException::raise() const +{ + throw *this; +} + +Ice::UnsupportedEncodingException::UnsupportedEncodingException(const char* file, int line) : + ProtocolException(file, line) +{ +} + +Ice::UnsupportedEncodingException::UnsupportedEncodingException(const UnsupportedEncodingException& ex) : + ProtocolException(ex) +{ +} + +UnsupportedEncodingException& +Ice::UnsupportedEncodingException::operator=(const UnsupportedEncodingException& ex) +{ + ProtocolException::operator=(ex); + return *this; +} + +string +Ice::UnsupportedEncodingException::toString() const +{ + return debugInfo() + "protocol error: unsupported encoding version"; +} + +LocalException* +Ice::UnsupportedEncodingException::clone() const +{ + return new UnsupportedEncodingException(*this); +} + +void +Ice::UnsupportedEncodingException::raise() const +{ + throw *this; +} + +Ice::InvalidMessageException::InvalidMessageException(const char* file, int line) : + ProtocolException(file, line) +{ +} + +Ice::InvalidMessageException::InvalidMessageException(const InvalidMessageException& ex) : + ProtocolException(ex) +{ +} + +InvalidMessageException& +Ice::InvalidMessageException::operator=(const InvalidMessageException& ex) +{ + ProtocolException::operator=(ex); + return *this; +} + +string +Ice::InvalidMessageException::toString() const +{ + return debugInfo() + "protocol error: invalid message type"; +} + +LocalException* +Ice::InvalidMessageException::clone() const +{ + return new InvalidMessageException(*this); +} + +void +Ice::InvalidMessageException::raise() const +{ + throw *this; +} + +Ice::UnknownMessageException::UnknownMessageException(const char* file, int line) : + ProtocolException(file, line) +{ +} + +Ice::UnknownMessageException::UnknownMessageException(const UnknownMessageException& ex) : + ProtocolException(ex) +{ +} + +UnknownMessageException& +Ice::UnknownMessageException::operator=(const UnknownMessageException& ex) +{ + ProtocolException::operator=(ex); + return *this; +} + +string +Ice::UnknownMessageException::toString() const +{ + return debugInfo() + "protocol error: unknown message type"; +} + +LocalException* +Ice::UnknownMessageException::clone() const +{ + return new UnknownMessageException(*this); +} + +void +Ice::UnknownMessageException::raise() const +{ + throw *this; +} + +Ice::UnknownRequestIdException::UnknownRequestIdException(const char* file, int line) : + ProtocolException(file, line) +{ +} + +Ice::UnknownRequestIdException::UnknownRequestIdException(const UnknownRequestIdException& ex) : + ProtocolException(ex) +{ +} + +UnknownRequestIdException& +Ice::UnknownRequestIdException::operator=(const UnknownRequestIdException& ex) +{ + ProtocolException::operator=(ex); + return *this; +} + +string +Ice::UnknownRequestIdException::toString() const +{ + return debugInfo() + "protocol error: unknown request id"; +} + +LocalException* +Ice::UnknownRequestIdException::clone() const +{ + return new UnknownRequestIdException(*this); +} + +void +Ice::UnknownRequestIdException::raise() const +{ + throw *this; +} + +Ice::UnknownReplyStatusException::UnknownReplyStatusException(const char* file, int line) : + ProtocolException(file, line) +{ +} + +Ice::UnknownReplyStatusException::UnknownReplyStatusException(const UnknownReplyStatusException& ex) : + ProtocolException(ex) +{ +} + +UnknownReplyStatusException& +Ice::UnknownReplyStatusException::operator=(const UnknownReplyStatusException& ex) +{ + ProtocolException::operator=(ex); + return *this; +} + +string +Ice::UnknownReplyStatusException::toString() const +{ + return debugInfo() + "protocol error: unknown reply status"; +} + +LocalException* +Ice::UnknownReplyStatusException::clone() const +{ + return new UnknownReplyStatusException(*this); +} + +void +Ice::UnknownReplyStatusException::raise() const +{ + throw *this; +} + +Ice::CloseConnectionException::CloseConnectionException(const char* file, int line) : + ProtocolException(file, line) +{ +} + +Ice::CloseConnectionException::CloseConnectionException(const CloseConnectionException& ex) : + ProtocolException(ex) +{ +} + +CloseConnectionException& +Ice::CloseConnectionException::operator=(const CloseConnectionException& ex) +{ + ProtocolException::operator=(ex); + return *this; +} + +string +Ice::CloseConnectionException::toString() const +{ + return debugInfo() + "protocol error: connection closed by server"; +} + +LocalException* +Ice::CloseConnectionException::clone() const +{ + return new CloseConnectionException(*this); +} + +void +Ice::CloseConnectionException::raise() const +{ + throw *this; +} + |