zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,83 +1,27 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/Object.h>
-#include <Ice/Incoming.h>
-#include <Ice/IncomingAsync.h>
-#include <Ice/IncomingRequest.h>
-#include <Ice/LocalException.h>
-#include <Ice/SlicedData.h>
+#include "Ice/Object.h"
+#include "Ice/AsyncResponseHandler.h"
+#include "Ice/InputStream.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/OutputStream.h"
+#include "Ice/SlicedData.h"
+
+#include <algorithm>
+#include <array>
+#include <sstream>
 
 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::_icePatchObjectPtr(ObjectPtr& obj, const ObjectPtr& v)
-{
-    obj = v;
-}
-
-bool
-Ice::Object::operator==(const Object& r) const
-{
-    return this == &r;
-}
-
-bool
-Ice::Object::operator<(const Object& r) const
-{
-    return this < &r;
-}
-#endif
-
-namespace
-{
-
-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
+Ice::Object::ice_isA(
+    string typeId, // NOLINT(performance-unnecessary-value-param)
+    const Current& current) const
 {
-    return s == object_ids[0];
+    vector<string> allTypeIds = ice_ids(current); // sorted type IDs
+    return std::binary_search(allTypeIds.begin(), allTypeIds.end(), typeId);
 }
 
 void
@@ -89,347 +33,217 @@ Ice::Object::ice_ping(const Current&) const
 vector<string>
 Ice::Object::ice_ids(const Current&) const
 {
-    return vector<string>(&object_ids[0], &object_ids[1]);
+    static const vector<string> allTypeIds = {"::Ice::Object"};
+    return allTypeIds;
 }
 
-#ifdef ICE_CPP11_MAPPING
 string
-#else
-const string&
-#endif
 Ice::Object::ice_id(const Current&) const
 {
-    return object_ids[0];
+    return string{ice_staticId()};
 }
 
-const ::std::string&
-Ice::Object::ice_staticId()
+const char*
+Ice::Object::ice_staticId() noexcept
 {
-    return object_ids[0];
+    return "::Ice::Object";
 }
 
-#ifndef ICE_CPP11_MAPPING
-Ice::ObjectPtr
-Ice::Object::ice_clone() const
-{
-    throw CloneNotImplementedException(__FILE__, __LINE__);
-}
-
-Ice::SlicedDataPtr
-Ice::Object::ice_getSlicedData() const
-{
-    return 0;
-}
-#endif
-
-bool
-Ice::Object::_iceD_ice_isA(Incoming& inS, const Current& current)
+void
+Ice::Object::_iceD_ice_isA(
+    IncomingRequest& request,
+    function<void(OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
 {
-    InputStream* istr = inS.startReadParams();
+    InputStream* istr = &request.inputStream();
+    istr->startEncapsulation();
     string iceP_id;
     istr->read(iceP_id, false);
-    inS.endReadParams();
-#ifdef ICE_CPP11_MAPPING
-    bool ret = ice_isA(std::move(iceP_id), current);
-#else
-    bool ret = ice_isA(iceP_id, current);
-#endif
-    OutputStream* ostr = inS.startWriteParams();
-    ostr->write(ret);
-    inS.endWriteParams();
-    return true;
-}
+    istr->endEncapsulation();
 
-bool
-Ice::Object::_iceD_ice_ping(Incoming& inS, const Current& current)
-{
-    inS.readEmptyParams();
-    ice_ping(current);
-    inS.writeEmptyParams();
-    return true;
+    bool ret = ice_isA(std::move(iceP_id), request.current());
+    sendResponse(makeOutgoingResponse([&](OutputStream* ostr) { ostr->write(ret); }, request.current()));
 }
 
-bool
-Ice::Object::_iceD_ice_ids(Incoming& inS, const Current& current)
+void
+Ice::Object::_iceD_ice_ping(
+    IncomingRequest& request,
+    function<void(OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
 {
-    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;
+    request.inputStream().skipEmptyEncapsulation();
+    ice_ping(request.current());
+    sendResponse(makeEmptyOutgoingResponse(request.current()));
 }
 
-bool
-Ice::Object::_iceD_ice_id(Incoming& inS, const Current& current)
+void
+Ice::Object::_iceD_ice_ids(
+    IncomingRequest& request,
+    function<void(OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
 {
-    inS.readEmptyParams();
-    string ret = ice_id(current);
-    OutputStream* ostr = inS.startWriteParams();
-    ostr->write(ret, false);
-    inS.endWriteParams();
-    return true;
+    request.inputStream().skipEmptyEncapsulation();
+    vector<string> ret = ice_ids(request.current());
+
+    sendResponse(makeOutgoingResponse(
+        [&](OutputStream* ostr)
+        {
+            if (ret.empty())
+            {
+                ostr->write(ret);
+            }
+            else
+            {
+                ostr->write(&ret[0], &ret[0] + ret.size(), false);
+            }
+        },
+        request.current()));
 }
 
-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
+void
+Ice::Object::_iceD_ice_id(
+    IncomingRequest& request,
+    function<void(OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
 {
-    IceInternal::Incoming& in = dynamic_cast<IceInternal::IncomingRequest&>(request)._in;
-    in.startOver();
-#ifdef ICE_CPP11_MAPPING
-    if(r || e)
-    {
-        in.push(r, e);
-#else
-    if(cb)
-    {
-        in.push(cb);
-#endif
-        try
-        {
-            bool sync = _iceDispatch(in, in.getCurrent());
-            in.pop();
-            return sync;
-        }
-        catch(...)
-        {
-            in.pop();
-            throw;
-        }
-    }
-    else
-    {
-        return _iceDispatch(in, in.getCurrent());
-    }
+    request.inputStream().skipEmptyEncapsulation();
+    string ret = ice_id(request.current());
+
+    sendResponse(makeOutgoingResponse([&](OutputStream* ostr) { ostr->write(ret, false); }, request.current()));
 }
 
-bool
-Ice::Object::_iceDispatch(Incoming& in, const Current& current)
+void
+Ice::Object::dispatch(IncomingRequest& request, std::function<void(OutgoingResponse)> sendResponse)
 {
-    pair<const string*, const string*> r = equal_range(object_all, object_all + sizeof(object_all) / sizeof(string), current.operation);
+    static constexpr std::array<string_view, 4> allOperations{"ice_id", "ice_ids", "ice_isA", "ice_ping"};
 
-    if(r.first == r.second)
+    const Current& current = request.current();
+    auto r = equal_range(allOperations.begin(), allOperations.end(), current.operation);
+
+    if (r.first == r.second)
     {
-        throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+        sendResponse(makeOutgoingResponse(make_exception_ptr(OperationNotExistException{__FILE__, __LINE__}), current));
+        return;
     }
 
-    switch(r.first - object_all)
+    switch (r.first - allOperations.begin())
     {
         case 0:
         {
-            return _iceD_ice_id(in, current);
+            _iceD_ice_id(request, std::move(sendResponse));
+            break;
         }
         case 1:
         {
-            return _iceD_ice_ids(in, current);
+            _iceD_ice_ids(request, std::move(sendResponse));
+            break;
         }
         case 2:
         {
-            return _iceD_ice_isA(in, current);
+            _iceD_ice_isA(request, std::move(sendResponse));
+            break;
         }
         case 3:
         {
-            return _iceD_ice_ping(in, current);
+            _iceD_ice_ping(request, std::move(sendResponse));
+            break;
         }
         default:
         {
             assert(false);
-            throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+            sendResponse(
+                makeOutgoingResponse(make_exception_ptr(OperationNotExistException{__FILE__, __LINE__}), current));
         }
     }
 }
 
-#ifndef ICE_CPP11_MAPPING
-void
-Ice::Object::ice_collectable(bool)
-{
-}
-
-void
-Ice::Object::ice_preMarshal()
-{
-}
-
 void
-Ice::Object::ice_postUnmarshal()
+Ice::Blobject::dispatch(IncomingRequest& request, std::function<void(OutgoingResponse)> sendResponse)
 {
-}
+    const Current& current = request.current();
+    const byte* inEncaps;
+    int32_t sz;
+    request.inputStream().readEncapsulation(inEncaps, sz);
+    vector<byte> outEncaps;
+    bool ok = ice_invoke(vector<byte>(inEncaps, inEncaps + sz), outEncaps, current);
 
-void
-Ice::Object::_iceWrite(Ice::OutputStream* os) const
-{
-    os->startValue(0);
-    _iceWriteImpl(os);
-    os->endValue();
+    if (outEncaps.empty())
+    {
+        sendResponse(makeOutgoingResponse(ok, {nullptr, nullptr}, current));
+    }
+    else
+    {
+        sendResponse(makeOutgoingResponse(ok, {outEncaps.data(), outEncaps.data() + outEncaps.size()}, current));
+    }
 }
 
 void
-Ice::Object::_iceRead(Ice::InputStream* is)
-{
-   is->startValue();
-   _iceReadImpl(is);
-   is->endValue(false);
-}
-
-Ice::Int
-Ice::Object::ice_operationAttributes(const string&) const
-{
-    return 0;
-}
-#endif
-
-namespace
+Ice::BlobjectArray::dispatch(IncomingRequest& request, std::function<void(OutgoingResponse)> sendResponse)
 {
+    const Current& current = request.current();
+    pair<const byte*, const byte*> inEncaps;
+    int32_t sz;
+    request.inputStream().readEncapsulation(inEncaps.first, sz);
+    inEncaps.second = inEncaps.first + sz;
+    vector<byte> outEncaps;
+    bool ok = ice_invoke(inEncaps, outEncaps, current);
 
-string
-operationModeToString(OperationMode mode)
-{
-    switch(mode)
+    if (outEncaps.empty())
     {
-    case ICE_ENUM(OperationMode, Normal):
-        return "::Ice::Normal";
-
-    case ICE_ENUM(OperationMode, Nonmutating):
-        return "::Ice::Nonmutating";
-
-    case ICE_ENUM(OperationMode, Idempotent):
-        return "::Ice::Idempotent";
+        sendResponse(makeOutgoingResponse(ok, {nullptr, nullptr}, current));
     }
-    //
-    // 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::_iceCheckMode(OperationMode expected, OperationMode received)
-{
-    if(expected != received)
+    else
     {
-        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
-            //
-        }
-        else
-        {
-            std::ostringstream reason;
-            reason << "unexpected operation mode. expected = "
-                   << operationModeToString(expected)
-                   << " received = "
-                   << operationModeToString(received);
-            throw Ice::MarshalException(__FILE__, __LINE__, reason.str());
-        }
+        sendResponse(makeOutgoingResponse(ok, {outEncaps.data(), outEncaps.data() + outEncaps.size()}, current));
     }
 }
 
-bool
-Ice::Blobject::_iceDispatch(Incoming& in, const Current& current)
+void
+Ice::BlobjectAsync::dispatch(IncomingRequest& request, std::function<void(OutgoingResponse)> sendResponse)
 {
-    const Byte* inEncaps;
-    Int sz;
-    in.readParamEncaps(inEncaps, sz);
-    vector<Byte> outEncaps;
-    bool ok = ice_invoke(vector<Byte>(inEncaps, inEncaps + sz), outEncaps, current);
-    if(outEncaps.empty())
+    const byte* inEncaps;
+    int32_t sz;
+    request.inputStream().readEncapsulation(inEncaps, sz);
+    auto responseHandler = make_shared<AsyncResponseHandler>(std::move(sendResponse), request.current());
+    try
     {
-        in.writeParamEncaps(0, 0, ok);
+        ice_invokeAsync(
+            vector<byte>{inEncaps, inEncaps + sz},
+            [responseHandler](bool ok, const vector<byte>& outEncaps)
+            {
+                if (outEncaps.empty())
+                {
+                    responseHandler->sendResponse(ok, {nullptr, nullptr});
+                }
+                else
+                {
+                    responseHandler->sendResponse(ok, {outEncaps.data(), outEncaps.data() + outEncaps.size()});
+                }
+            },
+            [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); },
+            responseHandler->current());
     }
-    else
+    catch (...)
     {
-        in.writeParamEncaps(&outEncaps[0], static_cast<Ice::Int>(outEncaps.size()), ok);
+        responseHandler->sendException(std::current_exception());
     }
-    return true;
 }
 
-bool
-Ice::BlobjectArray::_iceDispatch(Incoming& in, const Current& current)
+void
+Ice::BlobjectArrayAsync::dispatch(IncomingRequest& request, std::function<void(OutgoingResponse)> sendResponse)
 {
-    pair<const Byte*, const Byte*> inEncaps;
-    Int sz;
-    in.readParamEncaps(inEncaps.first, sz);
+    pair<const byte*, const byte*> inEncaps;
+    int32_t sz;
+    request.inputStream().readEncapsulation(inEncaps.first, sz);
     inEncaps.second = inEncaps.first + sz;
-    vector<Byte> outEncaps;
-    bool ok = ice_invoke(inEncaps, outEncaps, current);
-    if(outEncaps.empty())
+    auto responseHandler = make_shared<AsyncResponseHandler>(std::move(sendResponse), request.current());
+    try
     {
-        in.writeParamEncaps(0, 0, ok);
+        ice_invokeAsync(
+            inEncaps,
+            [responseHandler](bool ok, pair<const byte*, const byte*> outEncaps)
+            { responseHandler->sendResponse(ok, outEncaps); },
+            [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); },
+            responseHandler->current());
     }
-    else
+    catch (...)
     {
-        in.writeParamEncaps(&outEncaps[0], static_cast<Ice::Int>(outEncaps.size()), ok);
+        responseHandler->sendException(std::current_exception());
     }
-    return true;
-}
-
-bool
-Ice::BlobjectAsync::_iceDispatch(Incoming& in, const Current& current)
-{
-    const Byte* inEncaps;
-    Int sz;
-    in.readParamEncaps(inEncaps, sz);
-#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;
-}
-
-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;
-#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;
 }