zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/Exception.cpp

@@ -1,818 +1,5 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/Exception.h>
-#include <Ice/LocalException.h>
-#include <Ice/Network.h>
-#include <Ice/Plugin.h>
-#include <Ice/SlicedData.h>
-#include <Ice/OutputStream.h>
-#include <Ice/InputStream.h>
-#include <Ice/Initialize.h>
-#include <IceUtil/StringUtil.h>
-#include <iomanip>
+#include "Ice/Exception.h"
 
-using namespace std;
-using namespace Ice;
-using namespace IceInternal;
-
-namespace
-{
-
-inline string
-socketErrorToString(int error)
-{
-    if(error == 0)
-    {
-        return "unknown error";
-    }
-    return IceUtilInternal::errorToString(error);
-}
-
-};
-
-namespace IceInternal
-{
-
-namespace Ex
-{
-
-void
-throwUOE(const string& expectedType, const ValuePtr& v)
-{
-    //
-    // If the object is an unknown sliced object, we didn't find an
-    // value factory, in this case raise a NoValueFactoryException
-    // instead.
-    //
-    UnknownSlicedValue* usv = dynamic_cast<UnknownSlicedValue*>(v.get());
-    if(usv)
-    {
-        throw NoValueFactoryException(__FILE__, __LINE__, "", usv->ice_id());
-    }
-
-    string type = v->ice_id();
-    throw Ice::UnexpectedObjectException(__FILE__, __LINE__,
-                                         "expected element of type `" + expectedType + "' but received `" +
-                                         type + "'", type, expectedType);
-}
-
-void
-throwMemoryLimitException(const char* file, int line, size_t requested, size_t maximum)
-{
-    ostringstream s;
-    s << "requested " << requested << " bytes, maximum allowed is " << maximum << " bytes (see Ice.MessageSizeMax)";
-    throw Ice::MemoryLimitException(file, line, s.str());
-}
-
-void
-throwMarshalException(const char* file, int line, const string& reason)
-{
-    throw Ice::MarshalException(file, line, reason);
-}
-
-}
-}
-
-namespace
-{
-
-const string userException_ids[] =
-{
-    "::Ice::UserException"
-};
-
-}
-
-const std::string&
-Ice::UserException::ice_staticId()
-{
-    return userException_ids[0];
-}
-
-#ifdef ICE_CPP11_MAPPING
-unique_ptr<Ice::UserException>
-Ice::UserException::ice_clone() const
-{
-    return unique_ptr<UserException>(static_cast<UserException*>(ice_cloneImpl()));
-}
-#endif
-
-Ice::SlicedDataPtr
-Ice::UserException::ice_getSlicedData() const
-{
-    return ICE_NULLPTR;
-}
-
-void
-Ice::UserException::_write(::Ice::OutputStream* os) const
-{
-    os->startException(0);
-    _writeImpl(os);
-    os->endException();
-}
-
-void
-Ice::UserException::_read(::Ice::InputStream* is)
-{
-    is->startException();
-    _readImpl(is);
-    is->endException(false);
-}
-
-bool
-Ice::UserException::_usesClasses() const
-{
-    return false;
-}
-
-Ice::LocalException::LocalException(const char* file, int line) :
-    Exception(file, line)
-{
-}
-
-Ice::LocalException::~LocalException()
-#ifndef ICE_CPP11_COMPILER
-    throw()
-#endif
-{
-   // Out of line to avoid weak vtable
-}
-
-#ifdef ICE_CPP11_MAPPING
-unique_ptr<Ice::LocalException>
-Ice::LocalException::ice_clone() const
-{
-    return unique_ptr<LocalException>(static_cast<LocalException*>(ice_cloneImpl()));
-}
-#endif
-
-namespace
-{
-
-const string localException_ids[] =
-{
-    "::Ice::LocalException"
-};
-
-}
-
-const std::string&
-Ice::LocalException::ice_staticId()
-{
-    return localException_ids[0];
-}
-
-Ice::SystemException::SystemException(const char* file, int line) :
-    Exception(file, line)
-{
-}
-
-Ice::SystemException::~SystemException()
-#ifndef ICE_CPP11_COMPILER
-    throw()
-#endif
-{
-}
-
-#ifdef ICE_CPP11_MAPPING
-unique_ptr<Ice::SystemException>
-Ice::SystemException::ice_clone() const
-{
-    return unique_ptr<SystemException>(static_cast<SystemException*>(ice_cloneImpl()));
-}
-#endif
-
-namespace
-{
-
-const string systemException_ids[] =
-{
-    "::Ice::SystemException"
-};
-
-}
-
-const std::string&
-Ice::SystemException::ice_staticId()
-{
-    return systemException_ids[0];
-}
-
-void
-Ice::InitializationException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\ninitialization exception";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::UnknownException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nunknown exception";
-    if(!unknown.empty())
-    {
-        out << ":\n" << unknown;
-    }
-}
-
-void
-Ice::UnknownLocalException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nunknown local exception";
-    if(!unknown.empty())
-    {
-        out << ":\n" << unknown;
-    }
-}
-
-void
-Ice::UnknownUserException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nunknown user exception";
-    if(!unknown.empty())
-    {
-        out << ":\n" << unknown;
-    }
-}
-
-void
-Ice::VersionMismatchException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nIce library version mismatch";
-}
-
-void
-Ice::CommunicatorDestroyedException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\ncommunicator object destroyed";
-}
-
-void
-Ice::ObjectAdapterDeactivatedException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nobject adapter `" << name << "' deactivated";
-}
-
-void
-Ice::ObjectAdapterIdInUseException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nobject adapter with id `" << id << "' is already in use";
-}
-
-void
-Ice::NoEndpointException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nno suitable endpoint available for proxy `" << proxy << "'";
-}
-
-void
-Ice::EndpointParseException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nerror while parsing endpoint `" << str << "'";
-}
-
-void
-Ice::EndpointSelectionTypeParseException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nerror while parsing endpoint selection type `" << str << "'";
-}
-
-void
-Ice::VersionParseException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nerror while parsing version `" << str << "'";
-}
-
-void
-Ice::IdentityParseException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nerror while parsing identity `" << str << "'";
-}
-
-void
-Ice::ProxyParseException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nerror while parsing proxy `" << str << "'";
-}
-
-void
-Ice::IllegalIdentityException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nillegal identity: `" << identityToString(id, ICE_ENUM(ToStringMode, Unicode)) << "'";
-}
-
-void
-Ice::IllegalServantException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nillegal servant: `" << reason << "'";
-}
-
-static void
-printFailedRequestData(ostream& out, const RequestFailedException& ex)
-{
-    out << ":\nidentity: `" << identityToString(ex.id, ICE_ENUM(ToStringMode, Unicode)) << "'";
-    out << "\nfacet: " << ex.facet;
-    out << "\noperation: " << ex.operation;
-}
-
-void
-Ice::RequestFailedException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nrequest failed";
-    printFailedRequestData(out, *this);
-}
-
-void
-Ice::ObjectNotExistException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nobject does not exist";
-    printFailedRequestData(out, *this);
-}
-
-void
-Ice::FacetNotExistException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nfacet does not exist";
-    printFailedRequestData(out, *this);
-}
-
-void
-Ice::OperationNotExistException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\noperation does not exist";
-    printFailedRequestData(out, *this);
-}
-
-void
-Ice::SyscallException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    if(error != 0)
-    {
-        out << ":\nsyscall exception: " << IceUtilInternal::errorToString(error);
-    }
-}
-
-void
-Ice::SocketException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nsocket exception: " << socketErrorToString(error);
-}
-
-void
-Ice::FileException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nfile exception: ";
-    if(error == 0)
-    {
-        out << "couldn't open file";
-    }
-    else
-    {
-        out << IceUtilInternal::errorToString(error);
-    }
-    if(!path.empty())
-    {
-        out << "\npath: " << path;
-    }
-}
-
-void
-Ice::ConnectFailedException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nconnect failed: " << socketErrorToString(error);
-}
-
-void
-Ice::ConnectionRefusedException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nconnection refused: " << socketErrorToString(error);
-}
-
-void
-Ice::ConnectionLostException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nconnection lost: ";
-    if(error == 0)
-    {
-        out << "recv() returned zero";
-    }
-    else
-    {
-        out << socketErrorToString(error);
-    }
-}
-
-void
-Ice::DNSException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nDNS error: ";
-    out << errorToStringDNS(error);
-    out << "\nhost: " << host;
-}
-
-void
-Ice::OperationInterruptedException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\noperation interrupted";
-}
-
-void
-Ice::TimeoutException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\ntimeout while sending or receiving data";
-}
-
-void
-Ice::ConnectTimeoutException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\ntimeout while establishing a connection";
-}
-
-void
-Ice::CloseTimeoutException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\ntimeout while closing a connection";
-}
-
-void
-Ice::ConnectionTimeoutException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nconnection has timed out";
-}
-
-void
-Ice::InvocationTimeoutException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\ninvocation has timed out";
-}
-
-void
-Ice::InvocationCanceledException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\ninvocation canceled";
-}
-
-void
-Ice::ProtocolException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol exception";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::BadMagicException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nunknown magic number: ";
-
-    ios_base::fmtflags originalFlags = out.flags();     // Save stream state
-    ostream::char_type originalFill = out.fill();
-
-    out.flags(ios_base::hex);                           // Change to hex
-    out.fill('0');                                      // Fill with leading zeros
-
-    out << "0x" << setw(2) << static_cast<unsigned int>(static_cast<unsigned char>(badMagic[0])) << ", ";
-    out << "0x" << setw(2) << static_cast<unsigned int>(static_cast<unsigned char>(badMagic[1])) << ", ";
-    out << "0x" << setw(2) << static_cast<unsigned int>(static_cast<unsigned char>(badMagic[2])) << ", ";
-    out << "0x" << setw(2) << static_cast<unsigned int>(static_cast<unsigned char>(badMagic[3]));
-
-    out.fill(originalFill);                             // Restore stream state
-    out.flags(originalFlags);
-
-    if(!reason.empty())
-    {
-        out << "\n" << reason;
-    }
-}
-
-void
-Ice::UnsupportedProtocolException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: unsupported protocol version: " << bad;
-    out << "\n(can only support protocols compatible with version " << supported << ")";
-}
-
-void
-Ice::UnsupportedEncodingException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nencoding error: unsupported encoding version: " << bad;
-    out << "\n(can only support encodings compatible with version " << supported << ")";
-    if(!reason.empty())
-    {
-        out << "\n" << reason;
-    }
-}
-
-void
-Ice::UnknownMessageException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: unknown message type";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::ConnectionNotValidatedException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: received message over unvalidated connection";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::UnknownRequestIdException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: unknown request id";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::UnknownReplyStatusException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: unknown reply status";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::CloseConnectionException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: connection closed";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::ConnectionManuallyClosedException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: connection manually closed (" << (graceful ? "gracefully" : "forcefully") << ")";
-}
-
-void
-Ice::IllegalMessageSizeException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: illegal message size";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::CompressionException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: failed to compress or uncompress data";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::DatagramLimitException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: maximum datagram payload size exceeded";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::MarshalException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: error during marshaling or unmarshaling";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::ProxyUnmarshalException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: inconsistent proxy data during unmarshaling";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::UnmarshalOutOfBoundsException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: out of bounds during unmarshaling";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::NoValueFactoryException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: no suitable value factory found for `" << type << "'";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::UnexpectedObjectException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nunexpected class instance of type `" << type <<
-        "'; expected instance of type `" << expectedType << "'";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::MemoryLimitException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: memory limit exceeded";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::StringConversionException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: string conversion failed";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::EncapsulationException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nprotocol error: illegal encapsulation";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::PluginInitializationException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nplug-in initialization failed";
-    if(!reason.empty())
-    {
-        out << ": " << reason;
-    }
-}
-
-void
-Ice::CollocationOptimizationException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nrequested feature not available with collocation optimization";
-}
-
-void
-Ice::AlreadyRegisteredException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\n" << kindOfObject << " with id `" << id << "' is already registered";
-}
-
-void
-Ice::NotRegisteredException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nno " << kindOfObject << " with id `" << id << "' is registered";
-}
-
-void
-Ice::TwowayOnlyException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\noperation `" << operation << "' can only be invoked as a twoway request";
-}
-
-void
-Ice::CloneNotImplementedException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nice_clone() must be implemented in classes derived from abstract base classes";
-}
-
-void
-Ice::FeatureNotSupportedException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nfeature `" << unsupportedFeature << "' is not supported";
-}
-
-void
-Ice::SecurityException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nsecurity exception";
-    if(!reason.empty())
-    {
-        out << ":\n" << reason;
-    }
-}
-
-void
-Ice::FixedProxyException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nfixed proxy exception";
-}
-
-void
-Ice::ResponseSentException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nresponse sent exception";
-}
-
-void
-Ice::CFNetworkException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    out << ":\nnetwork exception: domain: " << domain << " error: " << error;
-}
+Ice::Exception::~Exception() = default; // avoid weak vtable