1 files changed, 103 insertions, 54 deletions

diff --git a/cpp/include/Ice/Object.h b/cpp/include/Ice/Object.h
index 801fb9c3d92..6aa5c18ade6 100644
--- a/cpp/include/Ice/Object.h
+++ b/cpp/include/Ice/Object.h
@@ -16,14 +16,20 @@
 #include <Ice/ProxyF.h>
 #include <Ice/IncomingAsyncF.h>
 #include <Ice/Current.h>
-#include <Ice/StreamF.h>
 #include <Ice/Format.h>
 
+namespace Ice
+{
+
+class OutputStream;
+class InpputStream;
+
+}
+
 namespace IceInternal
 {
 
 class Incoming;
-class BasicStream;
 class Direct;
 class GCVisitor;
 
@@ -32,89 +38,123 @@ class GCVisitor;
 namespace Ice
 {
 
-enum DispatchStatus
-{
-    DispatchOK,
-    DispatchUserException,
-    DispatchAsync
-};
-
+ICE_API extern const Current noExplicitCurrent;
 
+#ifndef ICE_CPP11_MAPPING
 class ICE_API DispatchInterceptorAsyncCallback : public virtual IceUtil::Shared
 {
 public:
-    
-    virtual bool response(bool) = 0;
+
+    virtual ~DispatchInterceptorAsyncCallback();
+
+    virtual bool response() = 0;
     virtual bool exception(const std::exception&) = 0;
     virtual bool exception() = 0;
 };
-typedef IceUtil::Handle<DispatchInterceptorAsyncCallback> DispatchInterceptorAsyncCallbackPtr;
+ICE_DEFINE_PTR(DispatchInterceptorAsyncCallbackPtr, DispatchInterceptorAsyncCallback);
+#endif
 
-class ICE_API Request 
+class ICE_API Request
 {
 public:
 
-    virtual ~Request() {}
+    virtual ~Request();
     virtual const Current& getCurrent() = 0;
 };
 
-class ICE_API Object : virtual public IceUtil::Shared
+#ifdef ICE_CPP11_MAPPING
+class ICE_API Object
+{
+public:
+
+    virtual ~Object() = default;
+
+    virtual bool ice_isA(std::string, const Current& = Ice::noExplicitCurrent) const;
+    bool _iceD_ice_isA(IceInternal::Incoming&, const Current&);
+
+    virtual void ice_ping(const Current&  = Ice::noExplicitCurrent) const;
+    bool _iceD_ice_ping(IceInternal::Incoming&, const Current&);
+
+    virtual std::vector< std::string> ice_ids(const Current& = Ice::noExplicitCurrent) const;
+    bool _iceD_ice_ids(IceInternal::Incoming&, const Current&);
+
+    virtual std::string ice_id(const Current& = Ice::noExplicitCurrent) const;
+    bool _iceD_ice_id(IceInternal::Incoming&, const Current&);
+
+    static const std::string& ice_staticId();
+
+#ifndef ICE_CPP11_MAPPING
+    virtual bool ice_dispatch(Ice::Request&, const DispatchInterceptorAsyncCallbackPtr& = 0);
+#else
+    virtual bool ice_dispatch(Ice::Request&,
+                              std::function<bool()> = nullptr,
+                              std::function<bool(std::exception_ptr)> = nullptr);
+#endif
+    virtual bool _iceDispatch(IceInternal::Incoming&, const Current&);
+
+    struct Ice_invokeResult
+    {
+        bool returnValue;
+        std::vector<::Ice::Byte> outParams;
+    };
+
+protected:
+
+    static void _iceCheckMode(OperationMode, OperationMode);
+};
+#else
+class ICE_API Object  : public virtual IceUtil::Shared
 {
 public:
 
     virtual bool operator==(const Object&) const;
     virtual bool operator<(const Object&) const;
 
-    virtual bool ice_isA(const std::string&, const Current& = Current()) const;
-    DispatchStatus ___ice_isA(IceInternal::Incoming&, const Current&);
+    virtual bool ice_isA(const std::string&, const Current& = Ice::noExplicitCurrent) const;
+    bool _iceD_ice_isA(IceInternal::Incoming&, const Current&);
 
-    virtual void ice_ping(const Current&  = Current()) const;
-    DispatchStatus ___ice_ping(IceInternal::Incoming&, const Current&);
+    virtual void ice_ping(const Current&  = Ice::noExplicitCurrent) const;
+    bool _iceD_ice_ping(IceInternal::Incoming&, const Current&);
 
-    virtual std::vector< std::string> ice_ids(const Current& = Current()) const;
-    DispatchStatus ___ice_ids(IceInternal::Incoming&, const Current&);
+    virtual std::vector< std::string> ice_ids(const Current& = Ice::noExplicitCurrent) const;
+    bool _iceD_ice_ids(IceInternal::Incoming&, const Current&);
 
-    virtual const std::string& ice_id(const Current& = Current()) const;
-    DispatchStatus ___ice_id(IceInternal::Incoming&, const Current&);
+    virtual const std::string& ice_id(const Current& = Ice::noExplicitCurrent) const;
+    bool _iceD_ice_id(IceInternal::Incoming&, const Current&);
 
     virtual Int ice_operationAttributes(const std::string&) const;
 
-    static const std::string& ice_staticId();
+    virtual void _iceWrite(Ice::OutputStream*) const;
+    virtual void _iceRead(Ice::InputStream*);
 
-    virtual ObjectPtr ice_clone() const;
+    virtual bool _iceGcVisit(IceInternal::GCVisitor&) { return false; }
+    virtual void ice_collectable(bool) { }
 
     virtual void ice_preMarshal();
     virtual void ice_postUnmarshal();
 
-    static std::string __all[];
-
-    virtual DispatchStatus ice_dispatch(Ice::Request&, const DispatchInterceptorAsyncCallbackPtr& = 0);
-    virtual DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
-
-    virtual void __write(IceInternal::BasicStream*) const;
-    virtual void __read(IceInternal::BasicStream*);
+    static const std::string& ice_staticId();
 
-    virtual void __write(const OutputStreamPtr&) const;
-    virtual void __read(const InputStreamPtr&);
+    virtual ObjectPtr ice_clone() const;
 
-    virtual bool __gcVisit(IceInternal::GCVisitor&) { return false; };
-    virtual void ice_collectable(bool) { };
+    virtual bool ice_dispatch(Ice::Request&, const DispatchInterceptorAsyncCallbackPtr& = 0);
+    virtual bool _iceDispatch(IceInternal::Incoming&, const Current&);
 
 protected:
 
     Object() {} // This class is abstract.
     virtual ~Object() {}
 
-    virtual void __writeImpl(IceInternal::BasicStream*) const {}
-    virtual void __readImpl(IceInternal::BasicStream*) {}
+protected:
 
-    virtual void __writeImpl(const OutputStreamPtr&) const;
-    virtual void __readImpl(const InputStreamPtr&);
+    virtual void _iceWriteImpl(Ice::OutputStream*) const {}
+    virtual void _iceReadImpl(Ice::InputStream*) {}
 
-    static void __checkMode(OperationMode, OperationMode);
+    static void _iceCheckMode(OperationMode, OperationMode);
 };
+#endif
 
-class ICE_API Blobject : virtual public Object
+class ICE_API Blobject : public virtual Object
 {
 public:
 
@@ -123,10 +163,10 @@ public:
     //
     virtual bool ice_invoke(const std::vector<Byte>&, std::vector<Byte>&, const Current&) = 0;
 
-    virtual DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
+    virtual bool _iceDispatch(IceInternal::Incoming&, const Current&);
 };
 
-class ICE_API BlobjectArray : virtual public Object
+class ICE_API BlobjectArray : public virtual Object
 {
 public:
 
@@ -135,31 +175,40 @@ public:
     //
     virtual bool ice_invoke(const std::pair<const Byte*, const Byte*>&, std::vector<Byte>&, const Current&) = 0;
 
-    virtual DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
+    virtual bool _iceDispatch(IceInternal::Incoming&, const Current&);
 };
 
-class ICE_API BlobjectAsync : virtual public Object
+class ICE_API BlobjectAsync : public virtual Object
 {
 public:
 
+#ifdef ICE_CPP11_MAPPING
+    virtual void ice_invokeAsync(std::vector<Byte>,
+                                 std::function<void(bool, std::vector<Byte>)>,
+                                 std::function<void(std::exception_ptr)>,
+                                 const Current&) = 0;
+#else
     virtual void ice_invoke_async(const AMD_Object_ice_invokePtr&, const std::vector<Byte>&, const Current&) = 0;
-
-    virtual DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
+#endif
+    virtual bool _iceDispatch(IceInternal::Incoming&, const Current&);
 };
 
-class ICE_API BlobjectArrayAsync : virtual public Object
+class ICE_API BlobjectArrayAsync : public virtual Object
 {
 public:
 
+#ifdef ICE_CPP11_MAPPING
+    virtual void ice_invokeAsync(std::pair<const Byte*, const Byte*>,
+                                 std::function<void(bool, std::pair<const Byte*, const Byte*>)>,
+                                 std::function<void(std::exception_ptr)>,
+                                 const Current&) = 0;
+#else
     virtual void ice_invoke_async(const AMD_Object_ice_invokePtr&, const std::pair<const Byte*, const Byte*>&,
                                   const Current&) = 0;
-
-    virtual DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
+#endif
+    virtual bool _iceDispatch(IceInternal::Incoming&, const Current&);
 };
 
-ICE_API void ice_writeObject(const OutputStreamPtr&, const ObjectPtr&);
-ICE_API void ice_readObject(const InputStreamPtr&, ObjectPtr&);
-
 }
 
 #endif