zeroc-ice 3.7.10 → 3.8.0

data/ext/ice/cpp/include/Ice/Buffer.h

@@ -1,154 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_BUFFER_H
-#define ICE_BUFFER_H
-
-#include <Ice/Config.h>
-
-namespace IceInternal
-{
-
-class ICE_API Buffer : private IceUtil::noncopyable
-{
-public:
-
-    Buffer() : i(b.begin()) { }
-    Buffer(const Ice::Byte* beg, const Ice::Byte* end) : b(beg, end), i(b.begin()) { }
-    Buffer(const std::vector<Ice::Byte>& v) : b(v), i(b.begin()) { }
-    Buffer(Buffer& o, bool adopt) : b(o.b, adopt), i(b.begin()) { }
-
-    void swapBuffer(Buffer&);
-
-    class ICE_API Container : private IceUtil::noncopyable
-    {
-    public:
-
-        //
-        // Standard vector-like operations.
-        //
-
-        typedef Ice::Byte value_type;
-        typedef Ice::Byte* iterator;
-        typedef const Ice::Byte* const_iterator;
-        typedef Ice::Byte& reference;
-        typedef const Ice::Byte& const_reference;
-        typedef Ice::Byte* pointer;
-        typedef size_t size_type;
-
-        Container();
-        Container(const_iterator, const_iterator);
-        Container(const std::vector<value_type>&);
-        Container(Container&, bool);
-
-        ~Container();
-
-        iterator begin()
-        {
-            return _buf;
-        }
-
-        const_iterator begin() const
-        {
-            return _buf;
-        }
-
-        iterator end()
-        {
-            return _buf + _size;
-        }
-
-        const_iterator end() const
-        {
-            return _buf + _size;
-        }
-
-        size_type size() const
-        {
-            return _size;
-        }
-
-        bool empty() const
-        {
-            return !_size;
-        }
-
-        void swap(Container&);
-
-        void clear();
-
-        void resize(size_type n) // Inlined for performance reasons.
-        {
-            if(n == 0)
-            {
-                clear();
-            }
-            else if(n > _capacity)
-            {
-                reserve(n);
-            }
-            _size = n;
-        }
-
-        void reset()
-        {
-            if(_size > 0 && _size * 2 < _capacity)
-            {
-                //
-                // If the current buffer size is smaller than the
-                // buffer capacity, we shrink the buffer memory to the
-                // current size. This is to avoid holding onto too much
-                // memory if it's not needed anymore.
-                //
-                if(++_shrinkCounter > 2)
-                {
-                    reserve(_size);
-                    _shrinkCounter = 0;
-                }
-            }
-            else
-            {
-                _shrinkCounter = 0;
-            }
-            _size = 0;
-        }
-
-        void push_back(value_type v)
-        {
-            resize(_size + 1);
-            _buf[_size - 1] = v;
-        }
-
-        reference operator[](size_type n)
-        {
-            assert(n < _size);
-            return _buf[n];
-        }
-
-        const_reference operator[](size_type n) const
-        {
-            assert(n < _size);
-            return _buf[n];
-        }
-
-    private:
-
-        Container(const Container&);
-        void operator=(const Container&);
-        void reserve(size_type);
-
-        pointer _buf;
-        size_type _size;
-        size_type _capacity;
-        int _shrinkCounter;
-        bool _owned;
-    };
-
-    Container b;
-    Container::iterator i;
-};
-
-}
-
-#endif

data/ext/ice/cpp/include/Ice/CommunicatorAsync.h

@@ -1,154 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_COMMUNICATOR_ASYNC_H
-#define ICE_COMMUNICATOR_ASYNC_H
-
-#ifndef ICE_CPP11_MAPPING
-
-#include <Ice/Communicator.h>
-
-namespace Ice
-{
-
-/**
- * Type-safe asynchronous callback wrapper class used for calls to
- * Ice::Communicator::begin_flushBatchRequests.
- * Create a wrapper instance by calling ::Ice::newCallback_Communicator_flushBatchRequests.
- * \headerfile Ice/Ice.h
- */
-template<class T>
-class CallbackNC_Communicator_flushBatchRequests : public Callback_Communicator_flushBatchRequests_Base,
-                                                   public ::IceInternal::OnewayCallbackNC<T>
-{
-public:
-
-    typedef IceUtil::Handle<T> TPtr;
-
-    typedef void (T::*Exception)(const ::Ice::Exception&);
-    typedef void (T::*Sent)(bool);
-
-    CallbackNC_Communicator_flushBatchRequests(const TPtr& obj, Exception excb, Sent sentcb)
-        : ::IceInternal::OnewayCallbackNC<T>(obj, 0, excb, sentcb)
-    {
-    }
-
-    /// \cond INTERNAL
-    virtual void completed(const ::Ice::AsyncResultPtr& result) const
-    {
-        ::Ice::CommunicatorPtr communicator = result->getCommunicator();
-        assert(communicator);
-        try
-        {
-            communicator->end_flushBatchRequests(result);
-            assert(false);
-        }
-        catch(const ::Ice::Exception& ex)
-        {
-            ::IceInternal::CallbackNC<T>::exception(result, ex);
-        }
-    }
-    /// \endcond
-};
-
-/**
- * Creates a callback wrapper instance that delegates to your object.
- * @param instance The callback object.
- * @param excb The exception method of the callback object.
- * @param sentcb The sent method of the callback object.
- * @return An object that can be passed to an asynchronous invocation of
- * Ice::Communicator::begin_flushBatchRequests.
- */
-template<class T> Callback_Communicator_flushBatchRequestsPtr
-newCallback_Communicator_flushBatchRequests(const IceUtil::Handle<T>& instance,
-                                            void (T::*excb)(const ::Ice::Exception&),
-                                            void (T::*sentcb)(bool) = 0)
-{
-    return new CallbackNC_Communicator_flushBatchRequests<T>(instance, excb, sentcb);
-}
-
-/**
- * Creates a callback wrapper instance that delegates to your object.
- * @param instance The callback object.
- * @param excb The exception method of the callback object.
- * @param sentcb The sent method of the callback object.
- * @return An object that can be passed to an asynchronous invocation of
- * Ice::Communicator::begin_flushBatchRequests.
- */
-template<class T> Callback_Communicator_flushBatchRequestsPtr
-newCallback_Communicator_flushBatchRequests(T* instance, void (T::*excb)(const ::Ice::Exception&),
-                                            void (T::*sentcb)(bool) = 0)
-{
-    return new CallbackNC_Communicator_flushBatchRequests<T>(instance, excb, sentcb);
-}
-
-/**
- * Type-safe asynchronous callback wrapper class used for calls to
- * Ice::Communicator::begin_flushBatchRequests.
- * Create a wrapper instance by calling ::Ice::newCallback_Communicator_flushBatchRequests.
- * \headerfile Ice/Ice.h
- */
-template<class T, typename CT>
-class Callback_Communicator_flushBatchRequests : public Callback_Communicator_flushBatchRequests_Base,
-                                                 public ::IceInternal::OnewayCallback<T, CT>
-{
-public:
-
-    typedef IceUtil::Handle<T> TPtr;
-
-    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
-    typedef void (T::*Sent)(bool , const CT&);
-
-    Callback_Communicator_flushBatchRequests(const TPtr& obj, Exception excb, Sent sentcb)
-        : ::IceInternal::OnewayCallback<T, CT>(obj, 0, excb, sentcb)
-    {
-    }
-
-    /// \cond INTERNAL
-    virtual void completed(const ::Ice::AsyncResultPtr& result) const
-    {
-        ::Ice::CommunicatorPtr communicator = result->getCommunicator();
-        assert(communicator);
-        try
-        {
-            communicator->end_flushBatchRequests(result);
-            assert(false);
-        }
-        catch(const ::Ice::Exception& ex)
-        {
-            ::IceInternal::Callback<T, CT>::exception(result, ex);
-        }
-    }
-    /// \endcond
-};
-
-/**
- * Type-safe asynchronous callback wrapper class used for calls to
- * Ice::Communicator::begin_flushBatchRequests.
- * Create a wrapper instance by calling ::Ice::newCallback_Communicator_flushBatchRequests.
- */
-template<class T, typename CT> Callback_Communicator_flushBatchRequestsPtr
-newCallback_Communicator_flushBatchRequests(const IceUtil::Handle<T>& instance,
-                                            void (T::*excb)(const ::Ice::Exception&, const CT&),
-                                            void (T::*sentcb)(bool, const CT&) = 0)
-{
-    return new Callback_Communicator_flushBatchRequests<T, CT>(instance, excb, sentcb);
-}
-
-/**
- * Type-safe asynchronous callback wrapper class used for calls to
- * Ice::Communicator::begin_flushBatchRequests.
- * Create a wrapper instance by calling ::Ice::newCallback_Communicator_flushBatchRequests.
- */
-template<class T, typename CT> Callback_Communicator_flushBatchRequestsPtr
-newCallback_Communicator_flushBatchRequests(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&),
-                                            void (T::*sentcb)(bool, const CT&) = 0)
-{
-    return new Callback_Communicator_flushBatchRequests<T, CT>(instance, excb, sentcb);
-}
-
-}
-#endif
-
-#endif

data/ext/ice/cpp/include/Ice/Comparable.h

@@ -1,205 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_COMPARABLE_H
-#define ICE_COMPARABLE_H
-
-#include <functional>
-
-namespace Ice
-{
-
-/**
- * Compares the contents of two smart pointers.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the contents are equal, false otherwise.
- */
-template<typename T, typename U>
-inline bool targetEqualTo(const T& lhs, const U& rhs)
-{
-    if(lhs && rhs)
-    {
-        return *lhs == *rhs;
-    }
-    else
-    {
-        return !lhs && !rhs;
-    }
-}
-
-/**
- * Compares the contents of two smart pointers.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares less than the right-hand side, false otherwise.
- */
-template<typename T, typename U>
-inline bool targetLess(const T& lhs, const U& rhs)
-{
-    if(lhs && rhs)
-    {
-        return *lhs < *rhs;
-    }
-    else
-    {
-        return !lhs && rhs;
-    }
-}
-
-/**
- * Compares the contents of two smart pointers.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares greater than the right-hand side, false otherwise.
- */
-template<typename T, typename U>
-inline bool targetGreater(const T& lhs, const U& rhs)
-{
-    return targetLess(rhs, lhs);
-}
-
-/**
- * Compares the contents of two smart pointers.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares less than or equal to the right-hand side, false otherwise.
- */
-template<typename T, typename U>
-inline bool targetLessEqual(const T& lhs, const U& rhs)
-{
-    return !targetGreater(lhs, rhs);
-}
-
-/**
- * Compares the contents of two smart pointers.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares greater than or equal to the right-hand side, false otherwise.
- */
-template<typename T, typename U>
-inline bool targetGreaterEqual(const T& lhs, const U& rhs)
-{
-    return !targetLess(lhs, rhs);
-}
-
-/**
- * Compares the contents of two smart pointers.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the contents are not equal, false otherwise.
- */
-template<typename T, typename U>
-inline bool targetNotEqualTo(const T& lhs, const U& rhs)
-{
-    return !targetEqualTo(lhs, rhs);
-}
-
-#ifdef ICE_CPP11_MAPPING
-
-/**
- * Functor class that compares the contents of two smart pointers of the given type using the given comparator.
- * \headerfile Ice/Ice.h
- */
-template<typename T, template<typename> class Compare>
-struct TargetCompare
-{
-    /**
-     * Executes the functor to compare the contents of two smart pointers.
-     * @return True if the contents satisfy the given comparator, false otherwise.
-     */
-    bool operator()(const T& lhs, const T& rhs) const
-    {
-        if(lhs && rhs)
-        {
-            return Compare<typename T::element_type>()(*lhs, *rhs);
-        }
-        else
-        {
-            return Compare<bool>()(static_cast<const bool>(lhs), static_cast<const bool>(rhs));
-        }
-    }
-};
-
-//
-// Relational operators for generated structs and classes
-//
-
-/**
- * Relational operator for generated structs and classes.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares less than the right-hand side, false otherwise.
- */
-template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
-bool operator<(const C& lhs, const C& rhs)
-{
-   return lhs.ice_tuple() < rhs.ice_tuple();
-}
-
-/**
- * Relational operator for generated structs and classes.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares less than or equal to the right-hand side, false otherwise.
- */
-template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
-bool operator<=(const C& lhs, const C& rhs)
-{
-   return lhs.ice_tuple() <= rhs.ice_tuple();
-}
-
-/**
- * Relational operator for generated structs and classes.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares greater than the right-hand side, false otherwise.
- */
-template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
-bool operator>(const C& lhs, const C& rhs)
-{
-   return lhs.ice_tuple() > rhs.ice_tuple();
-}
-
-/**
- * Relational operator for generated structs and classes.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares greater than or equal to the right-hand side, false otherwise.
- */
-template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
-bool operator>=(const C& lhs, const C& rhs)
-{
-   return lhs.ice_tuple() >= rhs.ice_tuple();
-}
-
-/**
- * Relational operator for generated structs and classes.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares equal to the right-hand side, false otherwise.
- */
-template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
-bool operator==(const C& lhs, const C& rhs)
-{
-   return lhs.ice_tuple() == rhs.ice_tuple();
-}
-
-/**
- * Relational operator for generated structs and classes.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side is not equal to the right-hand side, false otherwise.
- */
-template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
-bool operator!=(const C& lhs, const C& rhs)
-{
-   return lhs.ice_tuple() != rhs.ice_tuple();
-}
-
-#endif
-
-}
-
-#endif

data/ext/ice/cpp/include/Ice/Config.h

@@ -1,76 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_CONFIG_H
-#define ICE_CONFIG_H
-
-#include <IceUtil/Config.h>
-
-//
-// Some include files we need almost everywhere
-//
-#include <cerrno>
-#include <cstdio>
-#include <cstring>
-#include <string>
-#include <vector>
-#include <map>
-
-#if defined(_WIN32)
-#    include <process.h>
-#else
-#    include <sys/types.h>
-#    include <cstddef>
-#endif
-
-#ifdef ICE_SWIFT
-#   include <dispatch/dispatch.h>
-#endif
-
-//
-// Define the Ice and IceInternal namespace, so that we can use the following
-// everywhere in our code:
-//
-// using namespace Ice;
-// using namespace IceInternal;
-//
-namespace Ice
-{
-}
-
-namespace IceInternal
-{
-}
-
-namespace Ice
-{
-
-/** The mapping for the Slice byte type. */
-typedef unsigned char Byte;
-/** The mapping for the Slice short type. */
-typedef short Short;
-/** The mapping for the Slice int type. */
-typedef int Int;
-#ifdef ICE_CPP11_MAPPING
-/** The mapping for the Slice long type. */
-typedef long long int Long;
-#else
-/** The mapping for the Slice long type. */
-typedef IceUtil::Int64 Long;
-#endif
-/** The mapping for the Slice float type. */
-typedef float Float;
-/** The mapping for the Slice double type. */
-typedef double Double;
-
-}
-
-namespace IceInternal
-{
-
-ICE_API int getSystemErrno();
-
-}
-
-#endif