zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/include/Ice/OutgoingAsyncF.h

@@ -1,39 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_OUTGOING_ASYNC_F_H
-#define ICE_OUTGOING_ASYNC_F_H
-
-#include <IceUtil/Shared.h>
-#include <Ice/Handle.h>
-
-namespace IceInternal
-{
-
-class OutgoingAsyncBase;
-class OutgoingAsync;
-class ProxyOutgoingAsyncBase;
-class CommunicatorFlushBatchAsync;
-
-#ifdef ICE_CPP11_MAPPING
-using OutgoingAsyncBasePtr = ::std::shared_ptr<OutgoingAsyncBase>;
-using OutgoingAsyncPtr = ::std::shared_ptr<OutgoingAsync>;
-using ProxyOutgoingAsyncBasePtr = ::std::shared_ptr<ProxyOutgoingAsyncBase>;
-using CommunicatorFlushBatchAsyncPtr = ::std::shared_ptr<CommunicatorFlushBatchAsync>;
-#else
-ICE_API IceUtil::Shared* upCast(OutgoingAsyncBase*);
-typedef IceInternal::Handle<OutgoingAsyncBase> OutgoingAsyncBasePtr;
-
-ICE_API IceUtil::Shared* upCast(OutgoingAsync*);
-typedef IceInternal::Handle<OutgoingAsync> OutgoingAsyncPtr;
-
-ICE_API IceUtil::Shared* upCast(ProxyOutgoingAsyncBase*);
-typedef IceInternal::Handle<ProxyOutgoingAsyncBase> ProxyOutgoingAsyncBasePtr;
-
-ICE_API IceUtil::Shared* upCast(CommunicatorFlushBatchAsync*);
-typedef IceInternal::Handle<CommunicatorFlushBatchAsync> CommunicatorFlushBatchAsyncPtr;
-#endif
-}
-
-#endif

data/dist/ice/cpp/include/Ice/Protocol.h

@@ -1,274 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_PROTOCOL_H
-#define ICE_PROTOCOL_H
-
-#include <Ice/Config.h>
-#include <Ice/Version.h>
-
-namespace IceInternal
-{
-
-//
-// Size of the Ice protocol header
-//
-// Magic number (4 Bytes)
-// Protocol version major (Byte)
-// Protocol version minor (Byte)
-// Encoding version major (Byte)
-// Encoding version minor (Byte)
-// Message type (Byte)
-// Compression status (Byte)
-// Message size (Int)
-//
-const ::Ice::Int headerSize = 14;
-
-//
-// The magic number at the front of each message
-//
-extern const ::Ice::Byte magic[4];
-
-//
-// The current Ice protocol, protocol encoding and encoding version
-//
-const ::Ice::Byte protocolMajor = 1;
-const ::Ice::Byte protocolMinor = 0;
-const ::Ice::Byte protocolEncodingMajor = 1;
-const ::Ice::Byte protocolEncodingMinor = 0;
-
-const ::Ice::Byte encodingMajor = 1;
-const ::Ice::Byte encodingMinor = 1;
-
-//
-// The Ice protocol message types
-//
-const ::Ice::Byte requestMsg = 0;
-const ::Ice::Byte requestBatchMsg = 1;
-const ::Ice::Byte replyMsg = 2;
-const ::Ice::Byte validateConnectionMsg = 3;
-const ::Ice::Byte closeConnectionMsg = 4;
-
-//
-// The request header, batch request header and reply header.
-//
-extern const ::Ice::Byte requestHdr[headerSize + sizeof(Ice::Int)];
-extern const ::Ice::Byte requestBatchHdr[headerSize + sizeof(Ice::Int)];
-extern const ::Ice::Byte replyHdr[headerSize];
-
-//
-// IPv4/IPv6 support enumeration.
-//
-enum ProtocolSupport
-{
-    EnableIPv4,
-    EnableIPv6,
-    EnableBoth
-};
-
-ICE_API void stringToMajorMinor(const ::std::string&, Ice::Byte&, Ice::Byte&);
-
-template<typename T> std::string
-versionToString(const T& v)
-{
-    std::ostringstream os;
-    os << v;
-    return os.str();
-}
-
-template<typename T> T
-stringToVersion(const ::std::string& str)
-{
-    T v;
-    stringToMajorMinor(str, v.major, v.minor);
-    return v;
-}
-
-template<typename T> bool
-isSupported(const T& version, const T& supported)
-{
-    return version.major == supported.major && version.minor <= supported.minor;
-}
-
-ICE_API void throwUnsupportedProtocolException(const char*, int, const Ice::ProtocolVersion&,
-                                               const Ice::ProtocolVersion&);
-ICE_API void throwUnsupportedEncodingException(const char*, int, const Ice::EncodingVersion&,
-                                               const Ice::EncodingVersion&);
-
-const ::Ice::Byte OPTIONAL_END_MARKER        = 0xFF;
-
-const ::Ice::Byte FLAG_HAS_TYPE_ID_STRING    = (1<<0);
-const ::Ice::Byte FLAG_HAS_TYPE_ID_INDEX     = (1<<1);
-const ::Ice::Byte FLAG_HAS_TYPE_ID_COMPACT   = (1<<0) | (1<<1);
-const ::Ice::Byte FLAG_HAS_OPTIONAL_MEMBERS  = (1<<2);
-const ::Ice::Byte FLAG_HAS_INDIRECTION_TABLE = (1<<3);
-const ::Ice::Byte FLAG_HAS_SLICE_SIZE        = (1<<4);
-const ::Ice::Byte FLAG_IS_LAST_SLICE         = (1<<5);
-
-}
-
-namespace Ice
-{
-
-/** Identifies protocol version 1.0. */
-ICE_API extern const ProtocolVersion Protocol_1_0;
-
-/** Identifies encoding version 1.0. */
-ICE_API extern const EncodingVersion Encoding_1_0;
-
-/** Identifies encoding version 1.1. */
-ICE_API extern const EncodingVersion Encoding_1_1;
-
-/** Identifies the latest protocol version. */
-ICE_API extern const ProtocolVersion currentProtocol;
-
-/** Identifies the latest protocol encoding version. */
-ICE_API extern const EncodingVersion currentProtocolEncoding;
-
-/** Identifies the latest encoding version. */
-ICE_API extern const EncodingVersion currentEncoding;
-
-/**
- * Converts a protocol version into a string.
- * @param v The protocol version.
- * @return A string representing the protocol version.
- */
-inline ::std::string
-protocolVersionToString(const Ice::ProtocolVersion& v)
-{
-    return IceInternal::versionToString<ProtocolVersion>(v);
-}
-
-/**
- * Converts a string into a protocol version.
- * @param v The string containing a stringified protocol version.
- * @return The protocol version.
- * @throws VersionParseException If the given string is not in the X.Y format.
- */
-inline ::Ice::ProtocolVersion
-stringToProtocolVersion(const ::std::string& v)
-{
-    return IceInternal::stringToVersion<ProtocolVersion>(v);
-}
-
-/**
- * Converts an encoding version into a string.
- * @param v The encoding version.
- * @return A string representing the encoding version.
- */
-inline ::std::string
-encodingVersionToString(const Ice::EncodingVersion& v)
-{
-    return IceInternal::versionToString<EncodingVersion>(v);
-}
-
-/**
- * Converts a string into an encoding version.
- * @param v The string containing a stringified encoding version.
- * @return The encoding version.
- * @throws VersionParseException If the given string is not in the X.Y format.
- */
-inline ::Ice::EncodingVersion
-stringToEncodingVersion(const ::std::string& v)
-{
-    return IceInternal::stringToVersion<EncodingVersion>(v);
-}
-
-inline std::ostream&
-operator<<(std::ostream& out, const ProtocolVersion& version)
-{
-    return out << static_cast<int>(version.major) << "." << static_cast<int>(version.minor);
-}
-
-inline std::ostream&
-operator<<(std::ostream& out, const EncodingVersion& version)
-{
-    return out << static_cast<int>(version.major) << "." << static_cast<int>(version.minor);
-}
-
-}
-
-namespace IceInternal
-{
-
-inline void
-checkSupportedProtocol(const Ice::ProtocolVersion& v)
-{
-    if(!isSupported(v, Ice::currentProtocol))
-    {
-        throwUnsupportedProtocolException(__FILE__, __LINE__, v, Ice::currentProtocol);
-    }
-}
-
-inline void
-checkSupportedProtocolEncoding(const Ice::EncodingVersion& v)
-{
-    if(!isSupported(v, Ice::currentProtocolEncoding))
-    {
-        throwUnsupportedEncodingException(__FILE__, __LINE__, v, Ice::currentProtocolEncoding);
-    }
-}
-
-inline void
-checkSupportedEncoding(const Ice::EncodingVersion& v)
-{
-    if(!isSupported(v, Ice::currentEncoding))
-    {
-        throwUnsupportedEncodingException(__FILE__, __LINE__, v, Ice::currentEncoding);
-    }
-}
-
-//
-// Either return the given protocol if not compatible, or the greatest
-// supported protocol otherwise.
-//
-inline const Ice::ProtocolVersion
-getCompatibleProtocol(const Ice::ProtocolVersion& v)
-{
-    if(v.major != Ice::currentProtocol.major)
-    {
-        return v; // Unsupported protocol, return as is.
-    }
-    else if(v.minor < Ice::currentProtocol.minor)
-    {
-        return v; // Supported protocol.
-    }
-    else
-    {
-        //
-        // Unsupported but compatible, use the currently supported
-        // protocol, that's the best we can do.
-        //
-        return Ice::currentProtocol;
-    }
-}
-
-//
-// Either return the given encoding if not compatible, or the greatest
-// supported encoding otherwise.
-//
-inline const Ice::EncodingVersion&
-getCompatibleEncoding(const Ice::EncodingVersion& v)
-{
-    if(v.major != Ice::currentEncoding.major)
-    {
-        return v; // Unsupported encoding, return as is.
-    }
-    else if(v.minor < Ice::currentEncoding.minor)
-    {
-        return v; // Supported encoding.
-    }
-    else
-    {
-        //
-        // Unsupported but compatible, use the currently supported
-        // encoding, that's the best we can do.
-        //
-        return Ice::currentEncoding;
-    }
-}
-
-}
-
-#endif

data/dist/ice/cpp/include/Ice/ProxyFactoryF.h

@@ -1,21 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_PROXY_FACTORY_F_H
-#define ICE_PROXY_FACTORY_F_H
-
-#include <IceUtil/Shared.h>
-
-#include <Ice/Handle.h>
-
-namespace IceInternal
-{
-
-class ProxyFactory;
-IceUtil::Shared* upCast(ProxyFactory*);
-typedef IceInternal::Handle<ProxyFactory> ProxyFactoryPtr;
-
-}
-
-#endif

data/dist/ice/cpp/include/Ice/ProxyHandle.h

@@ -1,318 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_PROXY_HANDLE_H
-#define ICE_PROXY_HANDLE_H
-
-#ifndef ICE_CPP11_MAPPING // C++98 mapping
-
-#include <IceUtil/Handle.h>
-#include <Ice/Config.h>
-
-#include <iosfwd>
-
-namespace IceInternal
-{
-
-template<typename T> class ProxyHandle;
-template<typename T> class Handle;
-
-}
-
-namespace IceProxy
-{
-namespace Ice
-{
-
-class Object;
-
-}
-}
-
-namespace Ice
-{
-
-/** Smart pointer for an object proxy. */
-typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::Object> ObjectPrx;
-
-class ObjectAdapter;
-typedef ::IceInternal::Handle< ::Ice::ObjectAdapter> ObjectAdapterPtr;
-
-/**
- * A request context. Context is used to transmit metadata about a
- * request from the server to the client, such as Quality-of-Service
- * (QoS) parameters. Each remote operation on a proxy optionally
- * accepts a Context parameter.
- **/
-typedef ::std::map< ::std::string, ::std::string> Context;
-
-/** Sentinel value indicating that no explicit context argument was passed to a remote invocation. */
-ICE_API extern const Context noExplicitContext;
-
-}
-
-namespace IceInternal
-{
-
-template<typename P> P
-checkedCastImpl(const ::Ice::ObjectPrx&, const ::Ice::Context&);
-
-template<typename P> P
-checkedCastImpl(const ::Ice::ObjectPrx&, const std::string&, const ::Ice::Context&);
-
-template<typename P> P
-uncheckedCastImpl(const ::Ice::ObjectPrx&);
-
-template<typename P> P
-uncheckedCastImpl(const ::Ice::ObjectPrx&, const std::string&);
-
-//
-// Upcast
-//
-template<typename T, typename Y> inline ProxyHandle<T>
-checkedCastHelper(const ::IceInternal::ProxyHandle<Y>& b, T*, const ::Ice::Context&)
-{
-    return b;
-}
-
-template<typename T, typename Y> inline ProxyHandle<T>
-uncheckedCastHelper(const ::IceInternal::ProxyHandle<Y>& b, T*)
-{
-    return b;
-}
-
-//
-// Downcast
-//
-template<typename T, typename Y> inline ProxyHandle<T>
-checkedCastHelper(const ::IceInternal::ProxyHandle<Y>& b, void*, const ::Ice::Context& ctx)
-{
-#ifdef __SUNPRO_CC
-    //
-    // Sun CC bug introduced in version 5.10
-    //
-    const ::Ice::ObjectPrx& o = b;
-    return checkedCastImpl<ProxyHandle<T> >(o, ctx);
-#else
-    return checkedCastImpl<ProxyHandle<T> >(b, ctx);
-#endif
-}
-
-template<typename T, typename Y> inline ProxyHandle<T>
-uncheckedCastHelper(const ::IceInternal::ProxyHandle<Y>& b, void*)
-{
-#ifdef __SUNPRO_CC
-    //
-    // Sun CC bug introduced in version 5.10
-    //
-    const ::Ice::ObjectPrx& o = b;
-    return uncheckedCastImpl<ProxyHandle<T> >(o);
-#else
-    return uncheckedCastImpl<ProxyHandle<T> >(b);
-#endif
-}
-
-//
-// Like IceInternal::Handle, but specifically for proxies, with
-// support for checkedCast() and uncheckedCast() instead of
-// dynamicCast().
-//
-template<typename T>
-class ProxyHandle : public ::IceUtil::HandleBase<T>
-{
-public:
-
-    ProxyHandle(T* p = 0)
-    {
-        this->_ptr = p;
-
-        if(this->_ptr)
-        {
-            upCast(this->_ptr)->__incRef();
-        }
-    }
-
-    template<typename Y>
-    ProxyHandle(const ProxyHandle<Y>& r)
-    {
-        this->_ptr = r._ptr;
-
-        if(this->_ptr)
-        {
-            upCast(this->_ptr)->__incRef();
-        }
-    }
-
-    template<typename Y>
-    ProxyHandle(const ::IceUtil::Handle<Y>& r)
-    {
-        this->_ptr = r._ptr;
-
-        if(this->_ptr)
-        {
-            upCast(this->_ptr)->__incRef();
-        }
-    }
-
-    ProxyHandle(const ProxyHandle& r)
-    {
-        this->_ptr = r._ptr;
-
-        if(this->_ptr)
-        {
-            upCast(this->_ptr)->__incRef();
-        }
-    }
-
-    ~ProxyHandle()
-    {
-        if(this->_ptr)
-        {
-            upCast(this->_ptr)->__decRef();
-        }
-    }
-
-    ProxyHandle& operator=(T* p)
-    {
-        if(this->_ptr != p)
-        {
-            if(p)
-            {
-                upCast(p)->__incRef();
-            }
-
-            if(this->_ptr)
-            {
-                upCast(this->_ptr)->__decRef();
-            }
-
-            this->_ptr = p;
-        }
-        return *this;
-    }
-
-    template<typename Y>
-    ProxyHandle& operator=(const ProxyHandle<Y>& r)
-    {
-        if(this->_ptr != r._ptr)
-        {
-            if(r._ptr)
-            {
-                upCast(r._ptr)->__incRef();
-            }
-
-            if(this->_ptr)
-            {
-                upCast(this->_ptr)->__decRef();
-            }
-
-            this->_ptr = r._ptr;
-        }
-        return *this;
-    }
-
-    template<typename Y>
-    ProxyHandle& operator=(const ::IceUtil::Handle<Y>& r)
-    {
-        if(this->_ptr != r._ptr)
-        {
-            if(r._ptr)
-            {
-                upCast(r._ptr)->__incRef();
-            }
-
-            if(this->_ptr)
-            {
-                upCast(this->_ptr)->__decRef();
-            }
-
-            this->_ptr = r._ptr;
-        }
-        return *this;
-    }
-
-    ProxyHandle& operator=(const ProxyHandle& r)
-    {
-        if(this->_ptr != r._ptr)
-        {
-            if(r._ptr)
-            {
-                upCast(r._ptr)->__incRef();
-            }
-
-            if(this->_ptr)
-            {
-                upCast(this->_ptr)->__decRef();
-            }
-
-            this->_ptr = r._ptr;
-        }
-        return *this;
-    }
-
-    ::IceProxy::Ice::Object* _upCast() const
-    {
-        return upCast(this->_ptr);
-    }
-
-    template<class Y>
-    static ProxyHandle checkedCast(const ProxyHandle<Y>& r, const ::Ice::Context& ctx = ::Ice::noExplicitContext)
-    {
-        Y* tag = 0;
-        return ::IceInternal::checkedCastHelper<T>(r, tag, ctx);
-    }
-
-    template<class Y>
-    static ProxyHandle checkedCast(const ProxyHandle<Y>& r, const std::string& f,
-                                   const ::Ice::Context& ctx = ::Ice::noExplicitContext)
-    {
-#ifdef __SUNPRO_CC
-        //
-        // Sun CC bug introduced in version 5.10
-        //
-        const ::Ice::ObjectPrx& o = r;
-        return ::IceInternal::checkedCastImpl<ProxyHandle>(o, f, ctx);
-#else
-        return ::IceInternal::checkedCastImpl<ProxyHandle>(r, f, ctx);
-#endif
-    }
-
-    template<class Y>
-    static ProxyHandle uncheckedCast(const ProxyHandle<Y>& r)
-    {
-        Y* tag = 0;
-        return::IceInternal::uncheckedCastHelper<T>(r, tag);
-    }
-
-    template<class Y>
-    static ProxyHandle uncheckedCast(const ProxyHandle<Y>& r, const std::string& f)
-    {
-#ifdef __SUNPRO_CC
-        //
-        // Sun CC bug introduced in version 5.10
-        //
-        const ::Ice::ObjectPrx& o = r;
-        return ::IceInternal::uncheckedCastImpl<ProxyHandle<T> >(o, f);
-#else
-        return ::IceInternal::uncheckedCastImpl<ProxyHandle>(r, f);
-#endif
-    }
-
-    static const std::string& ice_staticId()
-    {
-        return T::ice_staticId();
-    }
-};
-
-template<class Y>
-std::ostream& operator<<(std::ostream& os, ::IceInternal::ProxyHandle<Y> p)
-{
-    return os << (p ? p->ice_toString() : std::string(""));
-}
-
-}
-
-#endif
-
-#endif