zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,57 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_DEFAULT_VALUE_FACTORY_H
-#define ICE_DEFAULT_VALUE_FACTORY_H
-
-#include <Ice/Config.h>
-#include <Ice/ValueFactory.h>
-
-namespace IceInternal
-{
-
-#ifdef ICE_CPP11_MAPPING
-
-template<class V>
-::std::shared_ptr<::Ice::Value>
-#ifdef NDEBUG
-defaultValueFactory(const std::string&)
-#else
-defaultValueFactory(const std::string& typeId)
-#endif
-{
-    assert(typeId == V::ice_staticId());
-    return std::make_shared<V>();
-}
-
-#else
-
-template<class V>
-class DefaultValueFactory : public Ice::ValueFactory
-{
-public:
-
-    DefaultValueFactory(const ::std::string& typeId) :
-        _typeId(typeId)
-    {
-    }
-
-#ifndef NDEBUG
-    virtual ::Ice::ObjectPtr create(const ::std::string& typeId)
-#else
-    virtual ::Ice::ObjectPtr create(const ::std::string&)
-#endif
-    {
-        assert(typeId == _typeId);
-        return new V;
-    }
-
-private:
-    const ::std::string _typeId;
-};
-
-#endif
-
-}
-#endif

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

@@ -1,41 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_DISPATCH_INTERCEPTOR_H
-#define ICE_DISPATCH_INTERCEPTOR_H
-
-#include <Ice/Object.h>
-
-namespace Ice
-{
-
-/**
- * Base class for a dispatch interceptor, which is a servant that dispatches requests
- * to another servant. A subclass must implement the dispatch method. A dispatch interceptor
- * can be registered with an object adapter just like any other servant.
- * \headerfile Ice/Ice.h
- */
-class ICE_API DispatchInterceptor : public virtual Object
-{
-public:
-
-    /**
-     * Called by the Ice run time when a new request needs to be dispatched. The implementation
-     * must eventually call ice_dispatch on the delegate servant and pass the given request object.
-     * @param req An opaque object representing the request to be dispatched.
-     * @return True if the request was dispatched synchronously, or false if the request was
-     * dispatched asynchronously.
-     */
-    virtual bool dispatch(Request& req) = 0;
-
-    /// \cond INTERNAL
-    virtual bool _iceDispatch(IceInternal::Incoming&, const Current&);
-    /// \endcond
-};
-
-ICE_DEFINE_PTR(DispatchInterceptorPtr, DispatchInterceptor);
-
-}
-
-#endif

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

@@ -1,67 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_DISPATCHER_H
-#define ICE_DISPATCHER_H
-
-#if !defined(ICE_CPP11_MAPPING) || defined(ICE_BUILDING_SRC)
-//
-// Part of the C++98 mapping, and "internal" definitions when building Ice
-// with the C++11 mapping
-//
-
-#include <Ice/Config.h>
-#include <IceUtil/Shared.h>
-#include <IceUtil/Handle.h>
-#include <Ice/ConnectionF.h>
-
-namespace Ice
-{
-
-/**
- * Encapsulates all the details of a request dispatch or AMI callback.
- * The application must eventually invoke run to dispatch the call.
- * \headerfile Ice/Ice.h
- */
-class ICE_API DispatcherCall : public virtual IceUtil::Shared
-{
-public:
-
-    virtual ~DispatcherCall();
-
-    /**
-     * Dispatches the call.
-     */
-    virtual void run() = 0;
-};
-
-typedef IceUtil::Handle<DispatcherCall> DispatcherCallPtr;
-
-/**
- * Base class for a dispatcher. A subclass must define the dispatch method.
- * The dispatcher can be installed via InitializationData.
- * \headerfile Ice/Ice.h
- */
-class ICE_API Dispatcher : public virtual IceUtil::Shared
-{
-public:
-
-    virtual ~Dispatcher();
-
-    /**
-     * Called by the Ice run time when an incoming request or an AMI callback needs to
-     * be dispatched. The implementation must eventually invoke run on the call object.
-     * @param call An object representing the call that must be dispatched.
-     * @param connection The connection object associated with the call, or nil if no
-     * connection is associated with the call.
-     */
-    virtual void dispatch(const DispatcherCallPtr& call, const ConnectionPtr& connection) = 0;
-};
-
-typedef IceUtil::Handle<Dispatcher> DispatcherPtr;
-
-}
-
-#endif
-#endif

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

@@ -1,102 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_DYNAMIC_LIBRARY_H
-#define ICE_DYNAMIC_LIBRARY_H
-
-#include <Ice/DynamicLibraryF.h>
-#include <IceUtil/Shared.h>
-
-namespace IceInternal
-{
-
-class ICE_API DynamicLibrary : public ::IceUtil::Shared
-{
-public:
-
-    DynamicLibrary();
-    virtual ~DynamicLibrary();
-
-#ifdef _WIN32
-    typedef FARPROC symbol_type;
-#else
-    typedef void* symbol_type;
-#endif
-
-    //
-    // Load an entry point. This is really a convenience function
-    // which combines calls to load() and getSymbol(). However, it
-    // does add some value.
-    //
-    // An entry point has the following format:
-    //
-    // name[,version]:function
-    //
-    // The name of the library is constructed from the given
-    // information. If no version is supplied and the boolean
-    // argument is true, the Ice version (10 * major + minor) is
-    // used instead.
-    //
-    // For example, consider the following entry point:
-    //
-    // foo:create
-    //
-    // This would result in libfoo.so.11 (Unix) and foo11.dll
-    // (Windows), where the Ice version is 1.1.x.
-    //
-    // Now consider this entry point:
-    //
-    // foo,12:create
-    //
-    // The library names in this case are libfoo.so.12 (Unix) and
-    // foo12.dll (Windows).
-    //
-    // On Windows platforms, a 'd' is appended to the version for
-    // debug builds.
-    //
-    // Returns 0 if a failure occurred.
-    //
-    symbol_type loadEntryPoint(const std::string&, bool = true);
-
-    //
-    // Open a library with the given path.
-    //
-    bool load(const std::string&);
-
-    //
-    // Retrieve a symbol from the library. Returns 0 if no match is found.
-    //
-    symbol_type getSymbol(const std::string&);
-
-    //
-    // Get the error message for the last failure.
-    //
-    const std::string& getErrorMessage() const;
-
-private:
-
-#ifdef _WIN32
-    HINSTANCE _hnd;
-#else
-    void* _hnd;
-#endif
-    std::string _err;
-};
-
-class ICE_API DynamicLibraryList : public ::IceUtil::Shared
-{
-public:
-
-    virtual ~DynamicLibraryList();
-
-    void add(const DynamicLibraryPtr&);
-
-private:
-
-    std::vector<DynamicLibraryPtr> _libraries;
-};
-
-}
-
-#endif

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

@@ -1,24 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_DYNAMIC_LIBRARY_F_H
-#define ICE_DYNAMIC_LIBRARY_F_H
-
-#include <IceUtil/Shared.h>
-
-#include <Ice/Handle.h>
-
-namespace IceInternal
-{
-
-class DynamicLibrary;
-ICE_API IceUtil::Shared* upCast(DynamicLibrary*);
-typedef Handle<DynamicLibrary> DynamicLibraryPtr;
-
-class DynamicLibraryList;
-ICE_API IceUtil::Shared* upCast(DynamicLibraryList*);
-typedef Handle<DynamicLibraryList> DynamicLibraryListPtr;
-
-}
-#endif

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

@@ -1,74 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_EXCEPTION_HELPERS_H
-#define ICE_EXCEPTION_HELPERS_H
-
-#ifdef ICE_CPP11_MAPPING // C++11 mapping
-
-#include <Ice/InputStream.h>
-#include <Ice/OutputStream.h>
-
-namespace Ice
-{
-
-class LocalException;
-
-/**
- * Helper template for the implementation of Ice::LocalException. It implements ice_id.
- * \headerfile Ice/Ice.h
- */
-template<typename T, typename B> class LocalExceptionHelper : public IceUtil::ExceptionHelper<T, B>
-{
-public:
-
-    using IceUtil::ExceptionHelper<T, B>::ExceptionHelper;
-
-    virtual std::string ice_id() const override
-    {
-        return T::ice_staticId();
-    }
-};
-
-/**
- * Helper template for the implementation of Ice::UserException. It implements ice_id.
- * \headerfile Ice/Ice.h
- */
-template<typename T, typename B> class UserExceptionHelper : public IceUtil::ExceptionHelper<T, B>
-{
-public:
-
-    using IceUtil::ExceptionHelper<T, B>::ExceptionHelper;
-
-    virtual std::string ice_id() const override
-    {
-        return T::ice_staticId();
-    }
-
-protected:
-
-    /// \cond STREAM
-    virtual void _writeImpl(Ice::OutputStream* os) const override
-    {
-        os->startSlice(T::ice_staticId(), -1, std::is_same<B, Ice::UserException>::value ? true : false);
-        Ice::StreamWriter<T, Ice::OutputStream>::write(os, static_cast<const T&>(*this));
-        os->endSlice();
-        B::_writeImpl(os);
-    }
-
-    virtual void _readImpl(Ice::InputStream* is) override
-    {
-        is->startSlice();
-        Ice::StreamReader<T, ::Ice::InputStream>::read(is, static_cast<T&>(*this));
-        is->endSlice();
-        B::_readImpl(is);
-    }
-    /// \endcond
-};
-
-}
-
-#endif // C++11 mapping end
-
-#endif

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

@@ -1,73 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_FACTORYTABLE_H
-#define ICE_FACTORYTABLE_H
-
-#include <IceUtil/Mutex.h>
-#include <Ice/UserExceptionFactory.h>
-#include <Ice/ValueFactory.h>
-
-namespace Ice
-{
-
-/**
- * The base class for a compact ID resolver. Subclasses must implement resolve.
- * The resolver can be installed via InitializationData.
- * \headerfile Ice/Ice.h
- */
-class ICE_API CompactIdResolver : public IceUtil::Shared
-{
-public:
-
-    /**
-     * Called by the Ice run time when a compact ID must be translated into a type ID.
-     * @param id The compact ID.
-     * @return The fully-scoped Slice type ID, or an empty string if the compact ID is unknown.
-     */
-    virtual ::std::string resolve(Ice::Int id) const = 0;
-};
-typedef IceUtil::Handle<CompactIdResolver> CompactIdResolverPtr;
-
-}
-
-namespace IceInternal
-{
-
-class ICE_API FactoryTable : private IceUtil::noncopyable
-{
-public:
-
-    void addExceptionFactory(const ::std::string&, ICE_IN(ICE_DELEGATE(::Ice::UserExceptionFactory)));
-    ICE_DELEGATE(::Ice::UserExceptionFactory) getExceptionFactory(const ::std::string&) const;
-    void removeExceptionFactory(const ::std::string&);
-
-    void addValueFactory(const ::std::string&, ICE_IN(ICE_DELEGATE(::Ice::ValueFactory)));
-    ICE_DELEGATE(::Ice::ValueFactory) getValueFactory(const ::std::string&) const;
-    void removeValueFactory(const ::std::string&);
-
-    void addTypeId(int, const ::std::string&);
-    std::string getTypeId(int) const;
-    void removeTypeId(int);
-
-private:
-
-    IceUtil::Mutex _m;
-
-    typedef ::std::pair< ICE_DELEGATE(::Ice::UserExceptionFactory), int> EFPair;
-    typedef ::std::map< ::std::string, EFPair> EFTable;
-    EFTable _eft;
-
-    typedef ::std::pair< ICE_DELEGATE(::Ice::ValueFactory), int> VFPair;
-    typedef ::std::map< ::std::string, VFPair> VFTable;
-    VFTable _vft;
-
-    typedef ::std::pair< ::std::string, int> TypeIdPair;
-    typedef ::std::map<int, TypeIdPair> TypeIdTable;
-    TypeIdTable _typeIdTable;
-};
-
-}
-
-#endif

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

@@ -1,84 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_FACTORYTABLEINIT_H
-#define ICE_FACTORYTABLEINIT_H
-
-#include <Ice/FactoryTable.h>
-#include <Ice/DefaultValueFactory.h>
-
-namespace IceInternal
-{
-
-class ICE_API FactoryTableInit
-{
-public:
-
-    FactoryTableInit();
-    ~FactoryTableInit();
-};
-
-static FactoryTableInit factoryTableInitializer;    // Dummy variable to force initialization of factoryTable
-
-extern ICE_API FactoryTable* factoryTable ICE_GLOBAL_VAR_SUFFIX;
-
-class ICE_API CompactIdInit
-{
-public:
-
-    CompactIdInit(const char*, int);
-    ~CompactIdInit();
-
-private:
-
-    const int _compactId;
-};
-
-template<class E>
-class DefaultUserExceptionFactoryInit
-{
-public:
-
-    DefaultUserExceptionFactoryInit(const char* tId) : typeId(tId)
-    {
-#ifdef ICE_CPP11_MAPPING
-        factoryTable->addExceptionFactory(typeId, defaultUserExceptionFactory<E>);
-#else
-        factoryTable->addExceptionFactory(typeId, new DefaultUserExceptionFactory<E>(typeId));
-#endif
-    }
-
-    ~DefaultUserExceptionFactoryInit()
-    {
-        factoryTable->removeExceptionFactory(typeId);
-    }
-
-    const ::std::string typeId;
-};
-
-template<class O>
-class DefaultValueFactoryInit
-{
-public:
-
-    DefaultValueFactoryInit(const char* tId) : typeId(tId)
-    {
-#ifdef ICE_CPP11_MAPPING
-        factoryTable->addValueFactory(typeId, defaultValueFactory<O>);
-#else
-        factoryTable->addValueFactory(typeId, new DefaultValueFactory<O>(typeId));
-#endif
-    }
-
-    ~DefaultValueFactoryInit()
-    {
-        factoryTable->removeValueFactory(typeId);
-    }
-
-    const ::std::string typeId;
-};
-
-}
-
-#endif

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

@@ -1,140 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_FUNCTIONAL_H
-#define ICE_FUNCTIONAL_H
-
-#include <IceUtil/Config.h>
-
-#if !defined(ICE_CPP11_MAPPING) && (ICE_CPLUSPLUS < 201703L)
-
-#include <IceUtil/Functional.h>
-#include <Ice/Handle.h>
-
-// ----------------------------------------------------------------------
-// Inline functions that return function objects that work with
-// IceInternal::Handle
-// ----------------------------------------------------------------------
-
-namespace Ice
-{
-
-/// \cond INTERNAL
-template<class R, class T>
-inline ::IceUtilInternal::MemFun<R, T, ICE_INTERNAL_HANDLE<T> >
-memFun(R (T::*p)(void))
-{
-    return ::IceUtilInternal::MemFun<R, T, ICE_INTERNAL_HANDLE<T> >(p);
-}
-
-template<class R, class T, class A>
-inline ::IceUtilInternal::MemFun1<R, T, ICE_INTERNAL_HANDLE<T>, A>
-memFun1(R (T::*p)(A))
-{
-    return ::IceUtilInternal::MemFun1<R, T, ICE_INTERNAL_HANDLE<T>, A>(p);
-}
-
-template<class T>
-inline ::IceUtilInternal::VoidMemFun<T, ICE_INTERNAL_HANDLE<T> >
-voidMemFun(void (T::*p)(void))
-{
-    return ::IceUtilInternal::VoidMemFun<T, ICE_INTERNAL_HANDLE<T> >(p);
-}
-
-template<class T, class A>
-inline ::IceUtilInternal::VoidMemFun1<T, ICE_INTERNAL_HANDLE<T>, A>
-voidMemFun1(void (T::*p)(A))
-{
-    return ::IceUtilInternal::VoidMemFun1<T, ICE_INTERNAL_HANDLE<T>, A>(p);
-}
-
-template<class R, class K, class T>
-inline ::IceUtilInternal::SecondMemFun<R, K, T, ICE_INTERNAL_HANDLE<T> >
-secondMemFun(R (T::*p)(void))
-{
-    return ::IceUtilInternal::SecondMemFun<R, K, T, ICE_INTERNAL_HANDLE<T> >(p);
-}
-
-template<class R, class K, class T, class A>
-inline ::IceUtilInternal::SecondMemFun1<R, K, T, ICE_INTERNAL_HANDLE<T>, A>
-secondMemFun1(R (T::*p)(A))
-{
-    return ::IceUtilInternal::SecondMemFun1<R, K, T, ICE_INTERNAL_HANDLE<T>, A>(p);
-}
-
-template<class K, class T>
-inline ::IceUtilInternal::SecondVoidMemFun<K, T, ICE_INTERNAL_HANDLE<T> >
-secondVoidMemFun(void (T::*p)(void))
-{
-    return ::IceUtilInternal::SecondVoidMemFun<K, T, ICE_INTERNAL_HANDLE<T> >(p);
-}
-
-template<class K, class T, class A>
-inline ::IceUtilInternal::SecondVoidMemFun1<K, T, ICE_INTERNAL_HANDLE<T>, A>
-secondVoidMemFun1(void (T::*p)(A))
-{
-    return ::IceUtilInternal::SecondVoidMemFun1<K, T, ICE_INTERNAL_HANDLE<T>, A>(p);
-}
-
-template<class R, class T>
-inline ::IceUtilInternal::ConstMemFun<R, T, ICE_INTERNAL_HANDLE<T> >
-constMemFun(R (T::*p)(void) const)
-{
-    return ::IceUtilInternal::ConstMemFun<R, T, ICE_INTERNAL_HANDLE<T> >(p);
-}
-
-template<class R, class T, class A>
-inline ::IceUtilInternal::ConstMemFun1<R, T, ICE_INTERNAL_HANDLE<T>, A>
-constMemFun1(R (T::*p)(A) const)
-{
-    return ::IceUtilInternal::ConstMemFun1<R, T, ICE_INTERNAL_HANDLE<T>, A>(p);
-}
-
-template<class T>
-inline ::IceUtilInternal::ConstVoidMemFun<T, ICE_INTERNAL_HANDLE<T> >
-constVoidMemFun(void (T::*p)(void) const)
-{
-    return ::IceUtilInternal::ConstVoidMemFun<T, ICE_INTERNAL_HANDLE<T> >(p);
-}
-
-template<class T, class A>
-inline ::IceUtilInternal::ConstVoidMemFun1<T, ICE_INTERNAL_HANDLE<T>, A>
-constVoidMemFun1(void (T::*p)(A) const)
-{
-    return ::IceUtilInternal::ConstVoidMemFun1<T, ICE_INTERNAL_HANDLE<T>, A>(p);
-}
-
-template<class R, class K, class T>
-inline ::IceUtilInternal::SecondConstMemFun<R, K, T, ICE_INTERNAL_HANDLE<T> >
-secondConstMemFun(R (T::*p)(void) const)
-{
-    return ::IceUtilInternal::SecondConstMemFun<R, K, T, ICE_INTERNAL_HANDLE<T> >(p);
-}
-
-template<class R, class K, class T, class A>
-inline ::IceUtilInternal::SecondConstMemFun1<R, K, T, ICE_INTERNAL_HANDLE<T>, A>
-secondConstMemFun1(R (T::*p)(A) const)
-{
-    return ::IceUtilInternal::SecondConstMemFun1<R, K, T, ICE_INTERNAL_HANDLE<T>, A>(p);
-}
-
-template<class K, class T>
-inline ::IceUtilInternal::SecondConstVoidMemFun<K, T, ICE_INTERNAL_HANDLE<T> >
-secondConstVoidMemFun(void (T::*p)(void) const)
-{
-    return ::IceUtilInternal::SecondConstVoidMemFun<K, T, ICE_INTERNAL_HANDLE<T> >(p);
-}
-
-template<class K, class T, class A>
-inline ::IceUtilInternal::SecondConstVoidMemFun1<K, T, ICE_INTERNAL_HANDLE<T>, A>
-secondConstVoidMemFun1(void (T::*p)(A) const)
-{
-    return ::IceUtilInternal::SecondConstVoidMemFun1<K, T, ICE_INTERNAL_HANDLE<T>, A>(p);
-}
-/// \endcond
-
-}
-
-#   endif
-#endif