zeroc-ice 3.6.5 → 3.7.0

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -13,18 +13,22 @@
 #include <Ice/IncomingAsyncF.h>
 #include <Ice/Incoming.h>
 
+#ifndef ICE_CPP11_MAPPING
 namespace Ice
 {
 
-class ICE_API AMDCallback : virtual public Ice::LocalObject
+class ICE_API AMDCallback : public Ice::LocalObject
 {
 public:
 
+    virtual ~AMDCallback();
+
     virtual void ice_exception(const ::std::exception&) = 0;
     virtual void ice_exception() = 0;
 };
 
 }
+#endif
 
 namespace IceInternal
 {
@@ -33,52 +37,87 @@ namespace IceInternal
 // We need virtual inheritance from AMDCallback, because we use multiple
 // inheritance from Ice::AMDCallback for generated AMD code.
 //
-class ICE_API IncomingAsync : public IncomingBase, virtual public Ice::AMDCallback
+class ICE_API IncomingAsync : public IncomingBase,
+#ifdef ICE_CPP11_MAPPING
+    public ::std::enable_shared_from_this<IncomingAsync>
+#else
+    public virtual Ice::AMDCallback
+#endif
 {
 public:
 
-    IncomingAsync(Incoming&); // Adopts the argument. It must not be used afterwards.
-
-    void __deactivate(Incoming&);
+    IncomingAsync(Incoming&);
+
+#ifdef ICE_CPP11_MAPPING
+
+    static std::shared_ptr<IncomingAsync> create(Incoming&);
+
+    std::function<void()> response()
+    {
+        auto self = shared_from_this();
+        return [self]()
+        {
+            self->writeEmptyParams();
+            self->completed();
+        };
+    }
+
+    template<class T>
+    std::function<void(const T&)> response()
+    {
+        auto self = shared_from_this();
+        return [self](const T& marshaledResult)
+        {
+            self->setMarshaledResult(marshaledResult);
+            self->completed();
+        };
+    }
+
+    std::function<void(std::exception_ptr)> exception()
+    {
+        auto self = shared_from_this();
+        return [self](std::exception_ptr ex) { self->completed(ex); };
+    }
+
+#else
 
     virtual void ice_exception(const ::std::exception&);
     virtual void ice_exception();
 
-protected:
+#endif
+
+    void kill(Incoming&);
 
-    void __response();
-    void __exception(const std::exception&);
-    void __exception();
+    void completed();
 
-    bool __validateResponse(bool);
+#ifdef ICE_CPP11_MAPPING
+    void completed(std::exception_ptr);
+#endif
 
 private:
 
-    //
-    // We need a separate InstancePtr, because _is and _os only hold a
-    // Instance* for optimization.
-    //
-    const InstancePtr _instanceCopy;
+    void checkResponseSent();
+    bool _responseSent;
 
     //
     // We need a separate ConnectionIPtr, because IncomingBase only
     // holds a ConnectionI* for optimization.
     //
     const ResponseHandlerPtr _responseHandlerCopy;
-
-    const bool _retriable;
-    bool _active;
 };
 
 }
 
+#ifndef ICE_CPP11_MAPPING
 namespace Ice
 {
 
-class ICE_API AMD_Object_ice_invoke : virtual public Ice::AMDCallback
+class ICE_API AMD_Object_ice_invoke : public virtual Ice::AMDCallback
 {
 public:
-    
+
+    virtual ~AMD_Object_ice_invoke();
+
     virtual void ice_response(bool, const std::vector<Ice::Byte>&) = 0;
     virtual void ice_response(bool, const std::pair<const Ice::Byte*, const Ice::Byte*>&) = 0;
 };
@@ -94,9 +133,9 @@ namespace Ice
 class ICE_API AMD_Object_ice_invoke : public ::Ice::AMD_Object_ice_invoke, public IceInternal::IncomingAsync
 {
 public:
-    
+
     AMD_Object_ice_invoke(IceInternal::Incoming&);
-    
+
     virtual void ice_response(bool, const std::vector< ::Ice::Byte>&);
     virtual void ice_response(bool, const std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&);
 };
@@ -104,5 +143,6 @@ public:
 }
 
 }
+#endif
 
 #endif

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -18,11 +18,16 @@ namespace IceInternal
 {
 
 class IncomingAsync;
+#ifdef ICE_CPP11_MAPPING
+using IncomingAsyncPtr = ::std::shared_ptr<IncomingAsync>;
+#else
 ICE_API IceUtil::Shared* upCast(IncomingAsync*);
 typedef IceInternal::Handle<IncomingAsync> IncomingAsyncPtr;
+#endif
 
 }
 
+#ifndef ICE_CPP11_MAPPING
 namespace Ice
 {
 
@@ -31,5 +36,6 @@ ICE_API IceUtil::Shared* upCast(::Ice::AMD_Object_ice_invoke*);
 typedef IceInternal::Handle<AMD_Object_ice_invoke> AMD_Object_ice_invokePtr;
 
 }
+#endif
 
 #endif

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -11,11 +11,10 @@
 #define ICE_INITIALIZE_H
 
 #include <IceUtil/Timer.h>
-#include <Ice/CommunicatorF.h>
+#include <Ice/Communicator.h>
 #include <Ice/PropertiesF.h>
 #include <Ice/InstanceF.h>
 #include <Ice/LoggerF.h>
-#include <Ice/StreamF.h>
 #include <Ice/InstrumentationF.h>
 #include <Ice/Dispatcher.h>
 #include <Ice/FactoryTable.h>
@@ -24,15 +23,19 @@
 #include <Ice/Plugin.h>
 #include <Ice/BatchRequestInterceptor.h>
 
+#ifdef ICE_CPP11_MAPPING
+#   define ICE_CONFIG_FILE_STRING const std::string&
+#else
+#   define ICE_CONFIG_FILE_STRING const char*
+#endif
+
 namespace Ice
 {
 
-ICE_API StringSeq argsToStringSeq(int, char*[]);
+ICE_API StringSeq argsToStringSeq(int, const char* const[]);
 
 #ifdef _WIN32
-
-ICE_API StringSeq argsToStringSeq(int, wchar_t*[]);
-
+ICE_API StringSeq argsToStringSeq(int, const wchar_t* const[]);
 #endif
 
 //
@@ -41,11 +44,35 @@ ICE_API StringSeq argsToStringSeq(int, wchar_t*[]);
 // the argument vector elements so that the vector matches the
 // contents of the sequence.
 //
-ICE_API void stringSeqToArgs(const StringSeq&, int&, char*[]);
+ICE_API void stringSeqToArgs(const StringSeq&, int&, const char*[]);
+inline void stringSeqToArgs(const StringSeq& seq, int& argc, char* argv[])
+{
+    return stringSeqToArgs(seq, argc, const_cast<const char**>(argv));
+}
+
+#ifdef _WIN32
+ICE_API void stringSeqToArgs(const StringSeq&, int&, const wchar_t*[]);
+inline void stringSeqToArgs(const StringSeq& seq, int& argc, wchar_t* argv[])
+{
+    return stringSeqToArgs(seq, argc, const_cast<const wchar_t**>(argv));
+}
+#endif
 
 ICE_API PropertiesPtr createProperties();
 ICE_API PropertiesPtr createProperties(StringSeq&, const PropertiesPtr& = 0);
-ICE_API PropertiesPtr createProperties(int&, char*[], const PropertiesPtr& = 0);
+ICE_API PropertiesPtr createProperties(int&, const char*[], const PropertiesPtr& = 0);
+inline PropertiesPtr createProperties(int& argc, char* argv[], const PropertiesPtr& props = 0)
+{
+    return createProperties(argc, const_cast<const char**>(argv), props);
+}
+
+#ifdef _WIN32
+ICE_API PropertiesPtr createProperties(int&, const wchar_t*[], const PropertiesPtr& = 0);
+inline PropertiesPtr createProperties(int& argc, wchar_t* argv[], const PropertiesPtr& props = 0)
+{
+    return createProperties(argc, const_cast<const wchar_t**>(argv), props);
+}
+#endif
 
 //
 // This class is used to notify user of when Ice threads are started
@@ -69,8 +96,11 @@ class ICE_API ThreadHookPlugin : public Ice::Plugin
 {
 public:
 
+#ifdef ICE_CPP11_MAPPING
+    ThreadHookPlugin(const CommunicatorPtr& communicator, std::function<void()>, std::function<void()>);
+#else
     ThreadHookPlugin(const CommunicatorPtr& communicator, const ThreadNotificationPtr&);
-
+#endif
     virtual void initialize();
 
     virtual void destroy();
@@ -84,49 +114,159 @@ struct InitializationData
     PropertiesPtr properties;
     LoggerPtr logger;
     Instrumentation::CommunicatorObserverPtr observer;
+#ifdef ICE_CPP11_MAPPING
+    std::function<void()> threadStart;
+    std::function<void()> threadStop;
+    std::function<void(std::function<void()>, const std::shared_ptr<Ice::Connection>&)> dispatcher;
+    std::function<std::string(int)> compactIdResolver;
+    std::function<void(const Ice::BatchRequest&, int, int)> batchRequestInterceptor;
+#else
     ThreadNotificationPtr threadHook;
     DispatcherPtr dispatcher;
     CompactIdResolverPtr compactIdResolver;
     BatchRequestInterceptorPtr batchRequestInterceptor;
+#endif
+    ValueFactoryManagerPtr valueFactoryManager;
 };
 
-ICE_API CommunicatorPtr initialize(int&, char*[], const InitializationData& = InitializationData(),
-                                   Int = ICE_INT_VERSION);
+ICE_API CommunicatorPtr initialize(int&, const char*[], const InitializationData& = InitializationData(),
+                                   int = ICE_INT_VERSION);
+inline CommunicatorPtr initialize(int& argc, char* argv[], const InitializationData& initData = InitializationData(),
+                                   int version = ICE_INT_VERSION)
+{
+    return initialize(argc, const_cast<const char**>(argv), initData, version);
+}
+
+ICE_API CommunicatorPtr initialize(int&, const char*[], ICE_CONFIG_FILE_STRING, int = ICE_INT_VERSION);
+inline CommunicatorPtr initialize(int& argc, char* argv[], ICE_CONFIG_FILE_STRING configFile,
+                                  int version = ICE_INT_VERSION)
+{
+    return initialize(argc, const_cast<const char**>(argv), configFile, version);
+}
+
+#ifdef _WIN32
+ICE_API CommunicatorPtr initialize(int&, const wchar_t*[], const InitializationData& = InitializationData(),
+                                   int = ICE_INT_VERSION);
+inline CommunicatorPtr initialize(int& argc, wchar_t* argv[], const InitializationData& initData = InitializationData(),
+                                   int version = ICE_INT_VERSION)
+{
+    return initialize(argc, const_cast<const wchar_t**>(argv), initData, version);
+}
+
+ICE_API CommunicatorPtr initialize(int&, const wchar_t*[], ICE_CONFIG_FILE_STRING, int = ICE_INT_VERSION);
+inline CommunicatorPtr initialize(int& argc, wchar_t* argv[], ICE_CONFIG_FILE_STRING configFile,
+                                  int version = ICE_INT_VERSION)
+{
+    return initialize(argc, const_cast<const wchar_t**>(argv), configFile, version);
+}
+#endif
+
+ICE_API CommunicatorPtr initialize(StringSeq&, const InitializationData& = InitializationData(),
+                                   int = ICE_INT_VERSION);
 
-ICE_API CommunicatorPtr initialize(Ice::StringSeq&, const InitializationData& = InitializationData(),
-                                   Int = ICE_INT_VERSION);
+ICE_API CommunicatorPtr initialize(StringSeq&, ICE_CONFIG_FILE_STRING, int = ICE_INT_VERSION);
 
 ICE_API CommunicatorPtr initialize(const InitializationData& = InitializationData(),
-                                   Int = ICE_INT_VERSION);
-
-
-ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&);
-ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&,
-                                         const EncodingVersion&);
-ICE_API InputStreamPtr wrapInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&);
-ICE_API InputStreamPtr wrapInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&, const EncodingVersion&);
-ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&,
-                                         const ::std::pair< const Ice::Byte*, const Ice::Byte*>&);
-ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&,
-                                         const ::std::pair< const Ice::Byte*, const Ice::Byte*>&,
-                                         const EncodingVersion&);
-ICE_API InputStreamPtr wrapInputStream(const CommunicatorPtr&,
-                                       const ::std::pair< const Ice::Byte*, const Ice::Byte*>&);
-ICE_API InputStreamPtr wrapInputStream(const CommunicatorPtr&,
-                                       const ::std::pair< const Ice::Byte*, const Ice::Byte*>&,
-                                       const EncodingVersion&);
-
-ICE_API OutputStreamPtr createOutputStream(const CommunicatorPtr&);
-ICE_API OutputStreamPtr createOutputStream(const CommunicatorPtr&, const EncodingVersion&);
+                                   int = ICE_INT_VERSION);
+
+ICE_API CommunicatorPtr initialize(ICE_CONFIG_FILE_STRING, int = ICE_INT_VERSION);
 
 ICE_API LoggerPtr getProcessLogger();
 ICE_API void setProcessLogger(const LoggerPtr&);
 
-typedef Ice::Plugin* (*PLUGIN_FACTORY)(const ::Ice::CommunicatorPtr&, const std::string&, const ::Ice::StringSeq&);
-ICE_API void registerPluginFactory(const std::string&, PLUGIN_FACTORY, bool);
+typedef Ice::Plugin* (*PluginFactory)(const ::Ice::CommunicatorPtr&, const std::string&, const ::Ice::StringSeq&);
+ICE_API void registerPluginFactory(const std::string&, PluginFactory, bool);
+
+//
+// RAII helper class
+//
+class ICE_API CommunicatorHolder
+{
+public:
+
+    //
+    // Empty holder
+    //
+    CommunicatorHolder();
+
+#ifdef ICE_CPP11_MAPPING
+
+    //
+    // Call initialize to create communicator with the provided args
+    // (all except default ctor above)
+    //
+    //
+    template<class... T>
+    explicit CommunicatorHolder(T&&... args) :
+        _communicator(std::move(initialize(std::forward<T>(args)...)))
+    {
+    }
+
+    //
+    // Adopt communicator
+    //
+    explicit CommunicatorHolder(std::shared_ptr<Communicator>);
+    CommunicatorHolder& operator=(std::shared_ptr<Communicator>);
+
+    CommunicatorHolder(const CommunicatorHolder&) = delete;
+
+    CommunicatorHolder(CommunicatorHolder&&) = default;
+    CommunicatorHolder& operator=(CommunicatorHolder&&);
+
+    explicit operator bool() const;
+
+#else // C++98 mapping
+
+    //
+    // Call initialize to create communicator with the provided args
+    //
+    CommunicatorHolder(int&, const char*[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
+    CommunicatorHolder(int&, char*[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
+    CommunicatorHolder(int&, const char*[], const char*, int = ICE_INT_VERSION);
+    CommunicatorHolder(int&, char*[], const char*, int = ICE_INT_VERSION);
+
+#   ifdef _WIN32
+    CommunicatorHolder(int&, const wchar_t*[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
+    CommunicatorHolder(int&, wchar_t*[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
+    CommunicatorHolder(int&, const wchar_t*[], const char*, int = ICE_INT_VERSION);
+    CommunicatorHolder(int&, wchar_t*[], const char*, int = ICE_INT_VERSION);
+#   endif
+
+    explicit CommunicatorHolder(StringSeq&, const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
+    CommunicatorHolder(StringSeq&, const char*, int = ICE_INT_VERSION);
+
+    explicit CommunicatorHolder(const InitializationData&, int = ICE_INT_VERSION);
+    explicit CommunicatorHolder(const char*, int = ICE_INT_VERSION);
+
+    //
+    // Adopt communicator
+    //
+    explicit CommunicatorHolder(const CommunicatorPtr&);
+    CommunicatorHolder& operator=(const CommunicatorPtr&);
+
+    operator bool() const;
+
+    //
+    // Required for successful copy-initialization, but not
+    // defined as it should always be elided by compiler
+    CommunicatorHolder(const CommunicatorHolder&);
+
+#endif
+
+    ~CommunicatorHolder();
+
+    const CommunicatorPtr& communicator() const;
+    const CommunicatorPtr& operator->() const;
+    CommunicatorPtr release();
+
+private:
+
+    CommunicatorPtr  _communicator;
+};
 
 ICE_API Identity stringToIdentity(const std::string&);
-ICE_API std::string identityToString(const Identity&);
+ICE_API std::string identityToString(const Identity&, ToStringMode = ICE_ENUM(ToStringMode, Unicode));
+
 }
 
 namespace IceInternal