zeroc-ice 3.6.5 → 3.7.4

data/ext/ice/cpp/src/Ice/OSLogLoggerI.h

@@ -0,0 +1,40 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef ICE_OSLOG_LOGGER_I_H
+#define ICE_OSLOG_LOGGER_I_H
+
+#ifdef ICE_SWIFT
+
+#include <Ice/Logger.h>
+#include <Ice/UniqueRef.h>
+#include <os/log.h>
+
+namespace Ice
+{
+
+class OSLogLoggerI : public Logger
+{
+public:
+
+    OSLogLoggerI(const std::string&);
+
+    virtual void print(const std::string&);
+    virtual void trace(const std::string&, const std::string&);
+    virtual void warning(const std::string&);
+    virtual void error(const std::string&);
+    virtual std::string getPrefix();
+    virtual LoggerPtr cloneWithPrefix(const std::string&);
+
+private:
+
+    const std::string _prefix;
+    IceInternal::UniqueRef<os_log_t> _log;
+};
+
+}
+
+#endif
+
+#endif

data/ext/ice/cpp/src/Ice/Object.cpp

@@ -1,28 +1,28 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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.
-//
-// **********************************************************************
 
 #include <Ice/Object.h>
 #include <Ice/Incoming.h>
 #include <Ice/IncomingAsync.h>
 #include <Ice/IncomingRequest.h>
 #include <Ice/LocalException.h>
-#include <Ice/Stream.h>
 #include <Ice/SlicedData.h>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
+namespace Ice
+{
+const Current emptyCurrent = Current();
+}
+
+#ifndef ICE_CPP11_MAPPING
 Object* Ice::upCast(Object* p) { return p; }
 
-void 
-Ice::__patch(ObjectPtr& obj, const ObjectPtr& v)
+void
+Ice::_icePatchObjectPtr(ObjectPtr& obj, const ObjectPtr& v)
 {
     obj = v;
 }
@@ -38,22 +38,46 @@ Ice::Object::operator<(const Object& r) const
 {
     return this < &r;
 }
-
+#endif
 
 namespace
 {
 
-const string __Ice__Object_ids[] =
+const string object_ids[] =
 {
     "::Ice::Object"
 };
 
+const string object_all[] =
+{
+    "ice_id",
+    "ice_ids",
+    "ice_isA",
+    "ice_ping"
+};
+
+}
+
+#ifndef ICE_CPP11_MAPPING
+Ice::DispatchInterceptorAsyncCallback::~DispatchInterceptorAsyncCallback()
+{
+    // Out of line to avoid weak vtable
+}
+#endif
+
+Ice::Request::~Request()
+{
+    // Out of line to avoid weak vtable
 }
 
 bool
+#ifdef ICE_CPP11_MAPPING
+Ice::Object::ice_isA(string s, const Current&) const
+#else
 Ice::Object::ice_isA(const string& s, const Current&) const
+#endif
 {
-    return s == __Ice__Object_ids[0];
+    return s == object_ids[0];
 }
 
 void
@@ -65,213 +89,205 @@ Ice::Object::ice_ping(const Current&) const
 vector<string>
 Ice::Object::ice_ids(const Current&) const
 {
-    return vector<string>(&__Ice__Object_ids[0], &__Ice__Object_ids[1]);
+    return vector<string>(&object_ids[0], &object_ids[1]);
 }
 
+#ifdef ICE_CPP11_MAPPING
+string
+#else
 const string&
+#endif
 Ice::Object::ice_id(const Current&) const
 {
-    return __Ice__Object_ids[0];
+    return object_ids[0];
 }
 
 const ::std::string&
 Ice::Object::ice_staticId()
 {
-    return __Ice__Object_ids[0];
+    return object_ids[0];
 }
 
+#ifndef ICE_CPP11_MAPPING
 Ice::ObjectPtr
 Ice::Object::ice_clone() const
 {
     throw CloneNotImplementedException(__FILE__, __LINE__);
-    return 0; // avoid warning with some compilers
 }
 
-void
-Ice::Object::ice_preMarshal()
+Ice::SlicedDataPtr
+Ice::Object::ice_getSlicedData() const
 {
+    return 0;
 }
+#endif
 
-void
-Ice::Object::ice_postUnmarshal()
-{
-}
-
-DispatchStatus
-Ice::Object::___ice_isA(Incoming& __inS, const Current& __current)
-{
-    BasicStream* __is = __inS.startReadParams();
-    string __id;
-    __is->read(__id, false);
-    __inS.endReadParams();
-    bool __ret = ice_isA(__id, __current);
-    BasicStream* __os = __inS.__startWriteParams(DefaultFormat);
-    __os->write(__ret);
-    __inS.__endWriteParams(true);
-    return DispatchOK;
-}
-
-DispatchStatus
-Ice::Object::___ice_ping(Incoming& __inS, const Current& __current)
-{
-    __inS.readEmptyParams();
-    ice_ping(__current);
-    __inS.__writeEmptyParams();
-    return DispatchOK;
+bool
+Ice::Object::_iceD_ice_isA(Incoming& inS, const Current& current)
+{
+    InputStream* istr = inS.startReadParams();
+    string iceP_id;
+    istr->read(iceP_id, false);
+    inS.endReadParams();
+#ifdef ICE_CPP11_MAPPING
+    bool ret = ice_isA(move(iceP_id), current);
+#else
+    bool ret = ice_isA(iceP_id, current);
+#endif
+    OutputStream* ostr = inS.startWriteParams();
+    ostr->write(ret);
+    inS.endWriteParams();
+    return true;
 }
 
-DispatchStatus
-Ice::Object::___ice_ids(Incoming& __inS, const Current& __current)
+bool
+Ice::Object::_iceD_ice_ping(Incoming& inS, const Current& current)
 {
-    __inS.readEmptyParams();
-    vector<string> __ret = ice_ids(__current);
-    BasicStream* __os = __inS.__startWriteParams(DefaultFormat);
-    __os->write(&__ret[0], &__ret[0] + __ret.size(), false);
-    __inS.__endWriteParams(true);
-    return DispatchOK;
+    inS.readEmptyParams();
+    ice_ping(current);
+    inS.writeEmptyParams();
+    return true;
 }
 
-DispatchStatus
-Ice::Object::___ice_id(Incoming& __inS, const Current& __current)
+bool
+Ice::Object::_iceD_ice_ids(Incoming& inS, const Current& current)
 {
-    __inS.readEmptyParams();
-    string __ret = ice_id(__current);
-    BasicStream* __os = __inS.__startWriteParams(DefaultFormat);
-    __os->write(__ret, false);
-    __inS.__endWriteParams(true);
-    return DispatchOK;
+    inS.readEmptyParams();
+    vector<string> ret = ice_ids(current);
+    OutputStream* ostr = inS.startWriteParams();
+    if(ret.empty())
+    {
+        ostr->write(ret);
+    }
+    else
+    {
+        ostr->write(&ret[0], &ret[0] + ret.size(), false);
+    }
+    inS.endWriteParams();
+    return true;
 }
 
-Ice::Int
-Ice::Object::ice_operationAttributes(const string&) const
+bool
+Ice::Object::_iceD_ice_id(Incoming& inS, const Current& current)
 {
-    return 0;
+    inS.readEmptyParams();
+    string ret = ice_id(current);
+    OutputStream* ostr = inS.startWriteParams();
+    ostr->write(ret, false);
+    inS.endWriteParams();
+    return true;
 }
 
-
-string Ice::Object::__all[] =
-{
-    "ice_id",
-    "ice_ids",
-    "ice_isA",
-    "ice_ping"
-};
-
-
-DispatchStatus
+bool
+#ifdef ICE_CPP11_MAPPING
+Ice::Object::ice_dispatch(Request& request, std::function<bool()> r, std::function<bool(std::exception_ptr)> e)
+#else
 Ice::Object::ice_dispatch(Request& request, const DispatchInterceptorAsyncCallbackPtr& cb)
+#endif
 {
-    class PushCb
+    IceInternal::Incoming& in = dynamic_cast<IceInternal::IncomingRequest&>(request)._in;
+    in.startOver();
+#ifdef ICE_CPP11_MAPPING
+    if(r || e)
     {
-    public:
-        PushCb(IceInternal::Incoming& in, const DispatchInterceptorAsyncCallbackPtr& cb) :
-            _in(in),
-            _cb(cb)
+        in.push(r, e);
+#else
+    if(cb)
+    {
+        in.push(cb);
+#endif
+        try
         {
-            if(_cb != 0)
-            {
-                _in.push(_cb);
-            }
+            bool sync = _iceDispatch(in, in.getCurrent());
+            in.pop();
+            return sync;
         }
-
-        ~PushCb()
+        catch(...)
         {
-            if(_cb != 0)
-            {
-                _in.pop();
-            }
+            in.pop();
+            throw;
         }
-    private:
-        IceInternal::Incoming& _in;
-        const DispatchInterceptorAsyncCallbackPtr& _cb;
-    };
-
-
-    IceInternal::Incoming& in = dynamic_cast<IceInternal::IncomingRequest&>(request)._in;
-    
-    PushCb pusbCb(in, cb);
-    in.startOver(); // may raise ResponseSentException
-    return __dispatch(in, in.getCurrent());
+    }
+    else
+    {
+        return _iceDispatch(in, in.getCurrent());
+    }
 }
 
-DispatchStatus
-Ice::Object::__dispatch(Incoming& in, const Current& current)
+bool
+Ice::Object::_iceDispatch(Incoming& in, const Current& current)
 {
-    pair<string*, string*> r =
-        equal_range(__all, __all + sizeof(__all) / sizeof(string), current.operation);
+    pair<const string*, const string*> r = equal_range(object_all, object_all + sizeof(object_all) / sizeof(string), current.operation);
 
     if(r.first == r.second)
     {
         throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
-    }                                        
+    }
 
-    switch(r.first - __all)
+    switch(r.first - object_all)
     {
         case 0:
         {
-            return ___ice_id(in, current);
+            return _iceD_ice_id(in, current);
         }
         case 1:
         {
-            return ___ice_ids(in, current);
+            return _iceD_ice_ids(in, current);
         }
         case 2:
         {
-            return ___ice_isA(in, current);
+            return _iceD_ice_isA(in, current);
         }
         case 3:
         {
-            return ___ice_ping(in, current);
+            return _iceD_ice_ping(in, current);
+        }
+        default:
+        {
+            assert(false);
+            throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
         }
     }
-
-    assert(false);
-    throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
 }
 
+#ifndef ICE_CPP11_MAPPING
 void
-Ice::Object::__write(IceInternal::BasicStream* os) const
+Ice::Object::ice_collectable(bool)
 {
-    os->startWriteObject(0);
-    __writeImpl(os);
-    os->endWriteObject();
 }
- 
-void 
-Ice::Object::__read(IceInternal::BasicStream* is)
+
+void
+Ice::Object::ice_preMarshal()
 {
-   is->startReadObject();
-   __readImpl(is);
-   is->endReadObject(false);
 }
-    
-void 
-Ice::Object::__write(const OutputStreamPtr& os) const
+
+void
+Ice::Object::ice_postUnmarshal()
 {
-    os->startObject(0);
-    __writeImpl(os);
-    os->endObject();
 }
- 
-void 
-Ice::Object::__read(const InputStreamPtr& is)
+
+void
+Ice::Object::_iceWrite(Ice::OutputStream* os) const
 {
-    is->startObject();
-   __readImpl(is);
-   is->endObject(false);
+    os->startValue(0);
+    _iceWriteImpl(os);
+    os->endValue();
 }
- 
-void 
-Ice::Object::__writeImpl(const OutputStreamPtr&) const
+
+void
+Ice::Object::_iceRead(Ice::InputStream* is)
 {
-    throw MarshalException(__FILE__, __LINE__, "class was not generated with stream support");
+   is->startValue();
+   _iceReadImpl(is);
+   is->endValue(false);
 }
- 
-void 
-Ice::Object::__readImpl(const InputStreamPtr&)
+
+Ice::Int
+Ice::Object::ice_operationAttributes(const string&) const
 {
-    throw MarshalException(__FILE__, __LINE__, "class was not generated with stream support");
+    return 0;
 }
+#endif
 
 namespace
 {
@@ -281,56 +297,56 @@ operationModeToString(OperationMode mode)
 {
     switch(mode)
     {
-    case Normal:
+    case ICE_ENUM(OperationMode, Normal):
         return "::Ice::Normal";
 
-    case Nonmutating:
+    case ICE_ENUM(OperationMode, Nonmutating):
         return "::Ice::Nonmutating";
 
-    case Idempotent:
+    case ICE_ENUM(OperationMode, Idempotent):
         return "::Ice::Idempotent";
     }
-
+    //
+    // This could not happen with C++11 strong type enums
+    //
+#ifdef ICE_CPP11_MAPPING
+    assert(false);
+    return "";
+#else
     ostringstream os;
     os << "unknown value (" << mode << ")";
     return os.str();
+#endif
 }
 
 }
 
 void
-Ice::Object::__checkMode(OperationMode expected, OperationMode received)
+Ice::Object::_iceCheckMode(OperationMode expected, OperationMode received)
 {
     if(expected != received)
     {
-        if(expected == Idempotent && received == Nonmutating)
+        assert(expected != ICE_ENUM(OperationMode, Nonmutating)); // We never expect Nonmutating
+        if(expected == ICE_ENUM(OperationMode, Idempotent) && received == ICE_ENUM(OperationMode, Nonmutating))
         {
-            // 
-            // Fine: typically an old client still using the deprecated nonmutating keyword
-            //
-            
             //
-            // Note that expected == Nonmutating and received == Idempotent is not ok:
-            // the server may still use the deprecated nonmutating keyword to detect updates
-            // and the client should not break this (deprecated) feature.
+            // Fine: typically an old client still using the deprecated nonmutating keyword
             //
         }
         else
         {
-            Ice::MarshalException ex(__FILE__, __LINE__);
-            std::ostringstream __reason;
-            __reason << "unexpected operation mode. expected = "
-                     << operationModeToString(expected)
-                     << " received = "
-                     << operationModeToString(received);
-            ex.reason = __reason.str();
-            throw ex;
+            std::ostringstream reason;
+            reason << "unexpected operation mode. expected = "
+                   << operationModeToString(expected)
+                   << " received = "
+                   << operationModeToString(received);
+            throw Ice::MarshalException(__FILE__, __LINE__, reason.str());
         }
     }
 }
 
-DispatchStatus
-Ice::Blobject::__dispatch(Incoming& in, const Current& current)
+bool
+Ice::Blobject::_iceDispatch(Incoming& in, const Current& current)
 {
     const Byte* inEncaps;
     Int sz;
@@ -339,24 +355,17 @@ Ice::Blobject::__dispatch(Incoming& in, const Current& current)
     bool ok = ice_invoke(vector<Byte>(inEncaps, inEncaps + sz), outEncaps, current);
     if(outEncaps.empty())
     {
-        in.__writeParamEncaps(0, 0, ok);
+        in.writeParamEncaps(0, 0, ok);
     }
     else
     {
-        in.__writeParamEncaps(&outEncaps[0], static_cast<Ice::Int>(outEncaps.size()), ok);
-    }
-    if(ok)
-    {
-        return DispatchOK;
-    }
-    else
-    {
-        return DispatchUserException;
+        in.writeParamEncaps(&outEncaps[0], static_cast<Ice::Int>(outEncaps.size()), ok);
     }
+    return true;
 }
 
-DispatchStatus
-Ice::BlobjectArray::__dispatch(Incoming& in, const Current& current)
+bool
+Ice::BlobjectArray::_iceDispatch(Incoming& in, const Current& current)
 {
     pair<const Byte*, const Byte*> inEncaps;
     Int sz;
@@ -366,75 +375,61 @@ Ice::BlobjectArray::__dispatch(Incoming& in, const Current& current)
     bool ok = ice_invoke(inEncaps, outEncaps, current);
     if(outEncaps.empty())
     {
-        in.__writeParamEncaps(0, 0, ok);
-    }
-    else
-    {
-        in.__writeParamEncaps(&outEncaps[0], static_cast<Ice::Int>(outEncaps.size()), ok);
-    }
-    if(ok)
-    {
-        return DispatchOK;
+        in.writeParamEncaps(0, 0, ok);
     }
     else
     {
-        return DispatchUserException;
+        in.writeParamEncaps(&outEncaps[0], static_cast<Ice::Int>(outEncaps.size()), ok);
     }
+    return true;
 }
 
-DispatchStatus
-Ice::BlobjectAsync::__dispatch(Incoming& in, const Current& current)
+bool
+Ice::BlobjectAsync::_iceDispatch(Incoming& in, const Current& current)
 {
     const Byte* inEncaps;
     Int sz;
     in.readParamEncaps(inEncaps, sz);
-    AMD_Object_ice_invokePtr cb = new ::IceAsync::Ice::AMD_Object_ice_invoke(in);
-    try
-    {
-        ice_invoke_async(cb, vector<Byte>(inEncaps, inEncaps + sz), current);
-    }
-    catch(const ::std::exception& ex)
-    {
-        cb->ice_exception(ex);
-    }
-    catch(...)
-    {
-        cb->ice_exception();
-    }
-    return DispatchAsync;
+#ifdef ICE_CPP11_MAPPING
+    auto async = IncomingAsync::create(in);
+    ice_invokeAsync(vector<Byte>(inEncaps, inEncaps + sz),
+                    [async](bool ok, const vector<Byte>& outEncaps)
+                    {
+                        if(outEncaps.empty())
+                        {
+                            async->writeParamEncaps(0, 0, ok);
+                        }
+                        else
+                        {
+                            async->writeParamEncaps(&outEncaps[0], static_cast<Int>(outEncaps.size()), ok);
+                        }
+                        async->completed();
+                    },
+                    async->exception(), current);
+#else
+    ice_invoke_async(new ::IceAsync::Ice::AMD_Object_ice_invoke(in), vector<Byte>(inEncaps, inEncaps + sz), current);
+#endif
+    return false;
 }
 
-DispatchStatus
-Ice::BlobjectArrayAsync::__dispatch(Incoming& in, const Current& current)
+bool
+Ice::BlobjectArrayAsync::_iceDispatch(Incoming& in, const Current& current)
 {
     pair<const Byte*, const Byte*> inEncaps;
     Int sz;
     in.readParamEncaps(inEncaps.first, sz);
     inEncaps.second = inEncaps.first + sz;
-    AMD_Object_ice_invokePtr cb = new ::IceAsync::Ice::AMD_Object_ice_invoke(in);
-    try
-    {
-        ice_invoke_async(cb, inEncaps, current);
-    }
-    catch(const ::std::exception& ex)
-    {
-        cb->ice_exception(ex);
-    }
-    catch(...)
-    {
-        cb->ice_exception();
-    }
-    return DispatchAsync;
-}
-
-void
-Ice::ice_writeObject(const OutputStreamPtr& out, const ObjectPtr& p)
-{
-    out->write(p);
-}
-
-void
-Ice::ice_readObject(const InputStreamPtr& in, ObjectPtr& p)
-{
-    in->read(p);
+#ifdef ICE_CPP11_MAPPING
+    auto async = IncomingAsync::create(in);
+    ice_invokeAsync(inEncaps,
+                    [async](bool ok, const pair<const Byte*, const Byte*>& outE)
+                    {
+                        async->writeParamEncaps(outE.first, static_cast<Int>(outE.second - outE.first), ok);
+                        async->completed();
+                    },
+                    async->exception(), current);
+#else
+    ice_invoke_async(new ::IceAsync::Ice::AMD_Object_ice_invoke(in), inEncaps, current);
+#endif
+    return false;
 }