zeroc-ice 3.6b1

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

@@ -0,0 +1,39 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_FORMAT_H
+#define ICE_FORMAT_H
+
+#include <Ice/Config.h>
+
+namespace Ice
+{
+
+//
+// This enumeration describes the possible formats for classes and exceptions.
+//
+enum FormatType
+{
+    //
+    // Indicates that no preference was specified.
+    //
+    DefaultFormat,
+    //
+    // A minimal format that eliminates the possibility for slicing unrecognized types.
+    //
+    CompactFormat,
+    //
+    // Allow slicing and preserve slices for unknown types.
+    //
+    SlicedFormat
+};
+
+}
+
+#endif

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

@@ -0,0 +1,138 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_FUNCTIONAL_H
+#define ICE_FUNCTIONAL_H
+
+#include <IceUtil/Functional.h>
+#include <Ice/Handle.h>
+
+// ----------------------------------------------------------------------
+// Inline functions that return function objects that work with
+// IceInternal::Handle
+// ----------------------------------------------------------------------
+
+namespace Ice
+{
+
+template<class R, class T>
+inline ::IceUtilInternal::MemFun<R, T, ::IceInternal::Handle<T> >
+memFun(R (T::*p)(void))
+{
+    return ::IceUtilInternal::MemFun<R, T, ::IceInternal::Handle<T> >(p);
+}
+
+template<class R, class T, class A>
+inline ::IceUtilInternal::MemFun1<R, T, ::IceInternal::Handle<T>, A>
+memFun1(R (T::*p)(A))
+{
+    return ::IceUtilInternal::MemFun1<R, T, ::IceInternal::Handle<T>, A>(p);
+}
+
+template<class T>
+inline ::IceUtilInternal::VoidMemFun<T, ::IceInternal::Handle<T> >
+voidMemFun(void (T::*p)(void))
+{
+    return ::IceUtilInternal::VoidMemFun<T, ::IceInternal::Handle<T> >(p);
+}
+
+template<class T, class A>
+inline ::IceUtilInternal::VoidMemFun1<T, ::IceInternal::Handle<T>, A>
+voidMemFun1(void (T::*p)(A))
+{
+    return ::IceUtilInternal::VoidMemFun1<T, ::IceInternal::Handle<T>, A>(p);
+}
+
+template<class R, class K, class T>
+inline ::IceUtilInternal::SecondMemFun<R, K, T, ::IceInternal::Handle<T> >
+secondMemFun(R (T::*p)(void))
+{
+    return ::IceUtilInternal::SecondMemFun<R, K, T, ::IceInternal::Handle<T> >(p);
+}
+
+template<class R, class K, class T, class A>
+inline ::IceUtilInternal::SecondMemFun1<R, K, T, ::IceInternal::Handle<T>, A>
+secondMemFun1(R (T::*p)(A))
+{
+    return ::IceUtilInternal::SecondMemFun1<R, K, T, ::IceInternal::Handle<T>, A>(p);
+}
+
+template<class K, class T>
+inline ::IceUtilInternal::SecondVoidMemFun<K, T, ::IceInternal::Handle<T> >
+secondVoidMemFun(void (T::*p)(void))
+{
+    return ::IceUtilInternal::SecondVoidMemFun<K, T, ::IceInternal::Handle<T> >(p);
+}
+
+template<class K, class T, class A>
+inline ::IceUtilInternal::SecondVoidMemFun1<K, T, ::IceInternal::Handle<T>, A>
+secondVoidMemFun1(void (T::*p)(A))
+{
+    return ::IceUtilInternal::SecondVoidMemFun1<K, T, ::IceInternal::Handle<T>, A>(p);
+}
+
+template<class R, class T>
+inline ::IceUtilInternal::ConstMemFun<R, T, ::IceInternal::Handle<T> >
+constMemFun(R (T::*p)(void) const)
+{
+    return ::IceUtilInternal::ConstMemFun<R, T, ::IceInternal::Handle<T> >(p);
+}
+
+template<class R, class T, class A>
+inline ::IceUtilInternal::ConstMemFun1<R, T, ::IceInternal::Handle<T>, A>
+constMemFun1(R (T::*p)(A) const)
+{
+    return ::IceUtilInternal::ConstMemFun1<R, T, ::IceInternal::Handle<T>, A>(p);
+}
+
+template<class T>
+inline ::IceUtilInternal::ConstVoidMemFun<T, ::IceInternal::Handle<T> >
+constVoidMemFun(void (T::*p)(void) const)
+{
+    return ::IceUtilInternal::ConstVoidMemFun<T, ::IceInternal::Handle<T> >(p);
+}
+
+template<class T, class A>
+inline ::IceUtilInternal::ConstVoidMemFun1<T, ::IceInternal::Handle<T>, A>
+constVoidMemFun1(void (T::*p)(A) const)
+{
+    return ::IceUtilInternal::ConstVoidMemFun1<T, ::IceInternal::Handle<T>, A>(p);
+}
+
+template<class R, class K, class T>
+inline ::IceUtilInternal::SecondConstMemFun<R, K, T, ::IceInternal::Handle<T> >
+secondConstMemFun(R (T::*p)(void) const)
+{
+    return ::IceUtilInternal::SecondConstMemFun<R, K, T, ::IceInternal::Handle<T> >(p);
+}
+
+template<class R, class K, class T, class A>
+inline ::IceUtilInternal::SecondConstMemFun1<R, K, T, ::IceInternal::Handle<T>, A>
+secondConstMemFun1(R (T::*p)(A) const)
+{
+    return ::IceUtilInternal::SecondConstMemFun1<R, K, T, ::IceInternal::Handle<T>, A>(p);
+}
+
+template<class K, class T>
+inline ::IceUtilInternal::SecondConstVoidMemFun<K, T, ::IceInternal::Handle<T> >
+secondConstVoidMemFun(void (T::*p)(void) const)
+{
+    return ::IceUtilInternal::SecondConstVoidMemFun<K, T, ::IceInternal::Handle<T> >(p);
+}
+
+template<class K, class T, class A>
+inline ::IceUtilInternal::SecondConstVoidMemFun1<K, T, ::IceInternal::Handle<T>, A>
+secondConstVoidMemFun1(void (T::*p)(A) const)
+{
+    return ::IceUtilInternal::SecondConstVoidMemFun1<K, T, ::IceInternal::Handle<T>, A>(p);
+}
+
+}
+
+#endif

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

@@ -0,0 +1,73 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_GC_OBJECT_H
+#define ICE_GC_OBJECT_H
+
+#include <Ice/Object.h>
+
+#include <IceUtil/MutexPtrLock.h>
+#include <IceUtil/Mutex.h>
+
+namespace IceInternal
+{
+
+class GCObject;
+
+class GCVisitor
+{
+public:
+
+    virtual bool visit(GCObject*) = 0;
+};
+
+class ICE_API GCObject : virtual public Ice::Object
+{
+public:
+
+    //
+    // Flags constant used for collection of graphs
+    //
+    static const unsigned char Collectable;
+    static const unsigned char CycleMember;
+    static const unsigned char Visiting;
+
+    //
+    // Override IceUtil::Shared methods
+    //
+    virtual void __incRef();
+    virtual void __decRef();
+    virtual int __getRef() const;
+    virtual void __setNoDelete(bool);
+
+    //
+    // Override Object methods
+    //
+    virtual bool __gcVisit(GCVisitor&);
+    virtual void ice_collectable(bool);
+
+    //
+    // This method is implemented by Slice classes to visit class
+    // members.
+    //
+    virtual void __gcVisitMembers(IceInternal::GCVisitor&) = 0;
+
+    int __getRefUnsafe()
+    {
+        return _ref;
+    }
+
+private:
+
+    bool collect(IceUtilInternal::MutexPtrLock<IceUtil::Mutex>&);
+};
+
+}
+
+#endif

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

@@ -0,0 +1,192 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_HANDLE_H
+#define ICE_HANDLE_H
+
+#include <IceUtil/Handle.h>
+#include <Ice/Config.h>
+
+//
+// "Handle" or "smart pointer" template for classes derived from
+// IceInternal::GCShared, IceUtil::Shared, or IceUtil::SimpleShared.
+//
+// In constrast to IceUtil::Handle, IceInternal::Handle<T> can be used
+// for a type T that has been declared but not defined. The only
+// requirement is a declaration of the following function:
+//
+// namespace IceInternal
+// {
+//     X* upCast(T*);
+// }
+//
+// Where X is (or derives from) IceUtil::Shared or IceUtil::SimpleShared.
+//
+
+namespace IceInternal
+{
+
+template<typename T>
+class Handle : public ::IceUtil::HandleBase<T>
+{
+public:
+
+    Handle(T* p = 0)
+    {
+        this->_ptr = p;
+
+        if(this->_ptr)
+        {
+            upCast(this->_ptr)->__incRef();
+        }
+    }
+    
+    template<typename Y>
+    Handle(const Handle<Y>& r)
+    {
+        this->_ptr = r._ptr;
+
+        if(this->_ptr)
+        {
+            upCast(this->_ptr)->__incRef();
+        }
+    }
+
+    template<typename Y>
+    Handle(const ::IceUtil::Handle<Y>& r)
+    {
+        this->_ptr = r._ptr;
+
+        if(this->_ptr)
+        {
+            upCast(this->_ptr)->__incRef();
+        }
+    }
+
+    Handle(const Handle& r)
+    {
+        this->_ptr = r._ptr;
+
+        if(this->_ptr)
+        {
+            upCast(this->_ptr)->__incRef();
+        }
+    }
+    
+    ~Handle()
+    {
+        if(this->_ptr)
+        {
+            upCast(this->_ptr)->__decRef();
+        }
+    }
+    
+    Handle& operator=(T* p)
+    {
+        if(this->_ptr != p)
+        {
+            if(p)
+            {
+                upCast(p)->__incRef();
+            }
+
+            T* ptr = this->_ptr;
+            this->_ptr = p;
+
+            if(ptr)
+            {
+                upCast(ptr)->__decRef();
+            }
+        }
+        return *this;
+    }
+        
+    template<typename Y>
+    Handle& operator=(const Handle<Y>& r)
+    {
+        if(this->_ptr != r._ptr)
+        {
+            if(r._ptr)
+            {
+                upCast(r._ptr)->__incRef();
+            }
+
+            T* ptr = this->_ptr;
+            this->_ptr = r._ptr;
+
+            if(ptr)
+            {
+                upCast(ptr)->__decRef();
+            }
+        }
+        return *this;
+    }
+
+    template<typename Y>
+    Handle& operator=(const ::IceUtil::Handle<Y>& r)
+    {
+        if(this->_ptr != r._ptr)
+        {
+            if(r._ptr)
+            {
+                upCast(r._ptr)->__incRef();
+            }
+
+            T* ptr = this->_ptr;
+            this->_ptr = r._ptr;
+
+            if(ptr)
+            {
+                upCast(ptr)->__decRef();
+            }
+        }
+        return *this;
+    }
+
+    Handle& operator=(const Handle& r)
+    {
+        if(this->_ptr != r._ptr)
+        {
+            if(r._ptr)
+            {
+                upCast(r._ptr)->__incRef();
+            }
+
+            T* ptr = this->_ptr;
+            this->_ptr = r._ptr;
+
+            if(ptr)
+            {
+                upCast(ptr)->__decRef();
+            }
+        }
+        return *this;
+    }
+        
+    template<class Y>
+    static Handle dynamicCast(const ::IceUtil::HandleBase<Y>& r)
+    {
+        return Handle(dynamic_cast<T*>(r._ptr));
+    }
+
+    template<class Y>
+    static Handle dynamicCast(Y* p)
+    {
+        return Handle(dynamic_cast<T*>(p));
+    }
+
+    void __clearHandleUnsafe()
+    {
+        this->_ptr = 0;
+    }
+};
+
+}
+
+#endif

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

@@ -0,0 +1,54 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_ICE_H
+#define ICE_ICE_H
+
+#include <IceUtil/PushDisableWarnings.h>
+#include <Ice/Config.h>
+#include <Ice/DeprecatedStringConverter.h>
+#include <Ice/Initialize.h>
+#include <Ice/LocalException.h>
+#include <Ice/PropertiesAdmin.h>
+#include <Ice/Properties.h>
+#include <Ice/Logger.h>
+#include <Ice/LoggerUtil.h>
+#include <Ice/RemoteLogger.h>
+#include <Ice/Communicator.h>
+#include <Ice/CommunicatorAsync.h>
+#include <Ice/ObjectFactory.h>
+#include <Ice/ObjectAdapter.h>
+#include <Ice/ServantLocator.h>
+#include <Ice/Proxy.h>
+#include <Ice/Object.h>
+#include <Ice/SlicedData.h>
+#include <Ice/OutgoingAsync.h>
+#include <Ice/IncomingAsync.h>
+#include <Ice/Process.h>
+#ifndef ICE_OS_WINRT
+#   include <Ice/Application.h>
+#endif
+#include <Ice/Connection.h>
+#include <Ice/ConnectionAsync.h>
+#include <Ice/Functional.h>
+#include <Ice/Stream.h>
+#include <Ice/ImplicitContext.h>
+#include <Ice/Locator.h>
+#include <Ice/Router.h>
+#include <Ice/DispatchInterceptor.h>
+#include <Ice/Plugin.h>
+#include <Ice/NativePropertiesAdmin.h>
+#include <Ice/Instrumentation.h>
+#include <Ice/Metrics.h>
+#ifndef ICE_OS_WINRT
+#   include <Ice/Service.h>
+#endif
+#include <IceUtil/PopDisableWarnings.h>
+
+#endif