Removed Current's default value in the C++11 mapping

Renamed Ice::noExplicitCurrent to Ice::emptyCurrent

26 files changed, 86 insertions, 87 deletions

diff --git a/cpp/include/Ice/Object.h b/cpp/include/Ice/Object.h
index 6aa5c18ade6..5dc57b8a92b 100644
--- a/cpp/include/Ice/Object.h
+++ b/cpp/include/Ice/Object.h
@@ -38,7 +38,7 @@ class GCVisitor;
 namespace Ice
 {
 
-ICE_API extern const Current noExplicitCurrent;
+ICE_API extern const Current emptyCurrent;
 
 #ifndef ICE_CPP11_MAPPING
 class ICE_API DispatchInterceptorAsyncCallback : public virtual IceUtil::Shared
@@ -69,16 +69,16 @@ public:
 
     virtual ~Object() = default;
 
-    virtual bool ice_isA(std::string, const Current& = Ice::noExplicitCurrent) const;
+    virtual bool ice_isA(std::string, const Current&) const;
     bool _iceD_ice_isA(IceInternal::Incoming&, const Current&);
 
-    virtual void ice_ping(const Current&  = Ice::noExplicitCurrent) const;
+    virtual void ice_ping(const Current&) const;
     bool _iceD_ice_ping(IceInternal::Incoming&, const Current&);
 
-    virtual std::vector< std::string> ice_ids(const Current& = Ice::noExplicitCurrent) const;
+    virtual std::vector< std::string> ice_ids(const Current&) const;
     bool _iceD_ice_ids(IceInternal::Incoming&, const Current&);
 
-    virtual std::string ice_id(const Current& = Ice::noExplicitCurrent) const;
+    virtual std::string ice_id(const Current&) const;
     bool _iceD_ice_id(IceInternal::Incoming&, const Current&);
 
     static const std::string& ice_staticId();
@@ -110,16 +110,16 @@ public:
     virtual bool operator==(const Object&) const;
     virtual bool operator<(const Object&) const;
 
-    virtual bool ice_isA(const std::string&, const Current& = Ice::noExplicitCurrent) const;
+    virtual bool ice_isA(const std::string&, const Current& = Ice::emptyCurrent) const;
     bool _iceD_ice_isA(IceInternal::Incoming&, const Current&);
 
-    virtual void ice_ping(const Current&  = Ice::noExplicitCurrent) const;
+    virtual void ice_ping(const Current&  = Ice::emptyCurrent) const;
     bool _iceD_ice_ping(IceInternal::Incoming&, const Current&);
 
-    virtual std::vector< std::string> ice_ids(const Current& = Ice::noExplicitCurrent) const;
+    virtual std::vector< std::string> ice_ids(const Current& = Ice::emptyCurrent) const;
     bool _iceD_ice_ids(IceInternal::Incoming&, const Current&);
 
-    virtual const std::string& ice_id(const Current& = Ice::noExplicitCurrent) const;
+    virtual const std::string& ice_id(const Current& = Ice::emptyCurrent) const;
     bool _iceD_ice_id(IceInternal::Incoming&, const Current&);
 
     virtual Int ice_operationAttributes(const std::string&) const;
diff --git a/cpp/src/Glacier2/RouterI.h b/cpp/src/Glacier2/RouterI.h
index cb17f1e7ad9..55f976ff014 100644
--- a/cpp/src/Glacier2/RouterI.h
+++ b/cpp/src/Glacier2/RouterI.h
@@ -38,8 +38,8 @@ public:
 
     void destroy(const Callback_Session_destroyPtr&);
 
-    virtual Ice::ObjectPrx getClientProxy(IceUtil::Optional<bool>&, const Ice::Current& = Ice::noExplicitCurrent) const;
-    virtual Ice::ObjectPrx getServerProxy(const Ice::Current& = Ice::noExplicitCurrent) const;
+    virtual Ice::ObjectPrx getClientProxy(IceUtil::Optional<bool>&, const Ice::Current&) const;
+    virtual Ice::ObjectPrx getServerProxy(const Ice::Current&) const;
     virtual Ice::ObjectProxySeq addProxies(const Ice::ObjectProxySeq&, const Ice::Current&);
     virtual std::string getCategoryForClient(const Ice::Current&) const;
     virtual void createSession_async(const AMD_Router_createSessionPtr&, const std::string&, const std::string&,
diff --git a/cpp/src/Glacier2/SessionRouterI.cpp b/cpp/src/Glacier2/SessionRouterI.cpp
index 563b58cf8f7..19ca27d2d8a 100644
--- a/cpp/src/Glacier2/SessionRouterI.cpp
+++ b/cpp/src/Glacier2/SessionRouterI.cpp
@@ -1256,7 +1256,7 @@ SessionRouterI::finishCreateSession(const ConnectionPtr& connection, const Route
 
     if(_instance->serverObjectAdapter())
     {
-        string category = router->getServerProxy()->ice_getIdentity().category;
+        string category = router->getServerProxy(Ice::emptyCurrent)->ice_getIdentity().category;
         assert(!category.empty());
         pair<map<string, RouterIPtr>::iterator, bool> rc =
             _routersByCategory.insert(pair<const string, RouterIPtr>(category, router));
diff --git a/cpp/src/Ice/Network.cpp b/cpp/src/Ice/Network.cpp
index b98ea329429..572df1b4cfc 100755
--- a/cpp/src/Ice/Network.cpp
+++ b/cpp/src/Ice/Network.cpp
@@ -3069,4 +3069,4 @@ IceInternal::isIpAddress(const string& name)
 
     return inet_pton(AF_INET, name.c_str(), &addr) > 0 || inet_pton(AF_INET6, name.c_str(), &addr6) > 0;
 #endif
-}
\ No newline at end of file
+}
diff --git a/cpp/src/Ice/Object.cpp b/cpp/src/Ice/Object.cpp
index db4b01cf72e..aa053d59d1d 100644
--- a/cpp/src/Ice/Object.cpp
+++ b/cpp/src/Ice/Object.cpp
@@ -20,7 +20,7 @@ using namespace IceInternal;
 
 namespace Ice
 {
-const Current noExplicitCurrent = Current();
+const Current emptyCurrent = Current();
 }
 
 #ifndef ICE_CPP11_MAPPING
diff --git a/cpp/src/IceGrid/Activator.cpp b/cpp/src/IceGrid/Activator.cpp
index 6dea80ccc53..eac4e13761a 100644
--- a/cpp/src/IceGrid/Activator.cpp
+++ b/cpp/src/IceGrid/Activator.cpp
@@ -1095,7 +1095,7 @@ Activator::destroy()
         //
         try
         {
-            p->second.server->stop_async(0);
+            p->second.server->stop_async(0, Ice::emptyCurrent);
         }
         catch(const ServerStopException&)
         {
diff --git a/cpp/src/IceGrid/AdminSessionI.cpp b/cpp/src/IceGrid/AdminSessionI.cpp
index cba61e004ef..03e8fdde2cd 100644
--- a/cpp/src/IceGrid/AdminSessionI.cpp
+++ b/cpp/src/IceGrid/AdminSessionI.cpp
@@ -499,7 +499,7 @@ AdminSessionFactory::AdminSessionFactory(const SessionServantManagerPtr& servant
                                          const RegistryIPtr& registry) :
     _servantManager(servantManager),
     _database(database),
-    _timeout(registry->getSessionTimeout()),
+    _timeout(registry->getSessionTimeout(Ice::emptyCurrent)),
     _reaper(reaper),
     _registry(registry),
     _filters(false)
diff --git a/cpp/src/IceGrid/AdminSessionI.h b/cpp/src/IceGrid/AdminSessionI.h
index b1928218aea..5d7866b1f90 100644
--- a/cpp/src/IceGrid/AdminSessionI.h
+++ b/cpp/src/IceGrid/AdminSessionI.h
@@ -35,7 +35,7 @@ public:
 
     virtual void keepAlive(const Ice::Current& current) { BaseSessionI::keepAlive(current); }
 
-    virtual AdminPrx getAdmin(const Ice::Current& = Ice::noExplicitCurrent) const;
+    virtual AdminPrx getAdmin(const Ice::Current&) const;
     virtual Ice::ObjectPrx getAdminCallbackTemplate(const Ice::Current&) const;
 
     virtual void setObservers(const RegistryObserverPrx&, const NodeObserverPrx&, const ApplicationObserverPrx&,
diff --git a/cpp/src/IceGrid/LocatorI.h b/cpp/src/IceGrid/LocatorI.h
index 16bbead38bc..d4d0eb59d74 100644
--- a/cpp/src/IceGrid/LocatorI.h
+++ b/cpp/src/IceGrid/LocatorI.h
@@ -55,7 +55,7 @@ public:
                                       const Ice::Current&) const;
 
     virtual void findAdapterById_async(const Ice::AMD_Locator_findAdapterByIdPtr&, const ::std::string&, 
-                                       const Ice::Current& = Ice::noExplicitCurrent) const;
+                                       const Ice::Current&) const;
 
     virtual Ice::LocatorRegistryPrx getRegistry(const Ice::Current&) const;
     virtual RegistryPrx getLocalRegistry(const Ice::Current&) const;
diff --git a/cpp/src/IceGrid/NodeCache.cpp b/cpp/src/IceGrid/NodeCache.cpp
index ce57c685ce5..6acb54222d7 100644
--- a/cpp/src/IceGrid/NodeCache.cpp
+++ b/cpp/src/IceGrid/NodeCache.cpp
@@ -402,7 +402,7 @@ NodeEntry::setSession(const NodeSessionIPtr& session)
                 {
                     try
                     {
-                        session->destroy();
+                        session->destroy(Ice::emptyCurrent);
                     }
                     catch(const Ice::ObjectNotExistException&)
                     {
@@ -569,7 +569,7 @@ NodeEntry::loadServer(const ServerEntryPtr& entry, const ServerInfo& server, con
             Lock sync(*this);
             checkSession();
             node = _session->getNode();
-            sessionTimeout = _session->getTimeout();
+            sessionTimeout = _session->getTimeout(Ice::emptyCurrent);
 
             //
             // Check if we should use a specific timeout (the load
diff --git a/cpp/src/IceGrid/NodeI.cpp b/cpp/src/IceGrid/NodeI.cpp
index 661c4f38993..e6a8f772a9b 100644
--- a/cpp/src/IceGrid/NodeI.cpp
+++ b/cpp/src/IceGrid/NodeI.cpp
@@ -231,7 +231,7 @@ public:
     {
         try
         {
-            _observer->begin_updateServer(_node->getName(),
+            _observer->begin_updateServer(_node->getName(Ice::emptyCurrent),
                                           _info,
                                           newCallback(static_cast<NodeI::Update*>(this), &NodeI::Update::completed));
         }
@@ -261,7 +261,7 @@ public:
     {
         try
         {
-            _observer->begin_updateAdapter(_node->getName(),
+            _observer->begin_updateAdapter(_node->getName(Ice::emptyCurrent),
                                            _info,
                                            newCallback(static_cast<NodeI::Update*>(this), &NodeI::Update::completed));
         }
diff --git a/cpp/src/IceGrid/NodeI.h b/cpp/src/IceGrid/NodeI.h
index 6e8706f8f7f..e9d46449433 100644
--- a/cpp/src/IceGrid/NodeI.h
+++ b/cpp/src/IceGrid/NodeI.h
@@ -99,9 +99,9 @@ public:
     virtual void replicaAdded(const InternalRegistryPrx&, const Ice::Current&);
     virtual void replicaRemoved(const InternalRegistryPrx&, const Ice::Current&);
 
-    virtual std::string getName(const Ice::Current& = Ice::noExplicitCurrent) const;
-    virtual std::string getHostname(const Ice::Current& = Ice::noExplicitCurrent) const;
-    virtual LoadInfo getLoad(const Ice::Current& = Ice::noExplicitCurrent) const;
+    virtual std::string getName(const Ice::Current&) const;
+    virtual std::string getHostname(const Ice::Current&) const;
+    virtual LoadInfo getLoad(const Ice::Current&) const;
     virtual int getProcessorSocketCount(const Ice::Current&) const;
     virtual void shutdown(const Ice::Current&) const;
 
diff --git a/cpp/src/IceGrid/NodeSessionI.h b/cpp/src/IceGrid/NodeSessionI.h
index a180b09abf1..d3f2a4e59c0 100644
--- a/cpp/src/IceGrid/NodeSessionI.h
+++ b/cpp/src/IceGrid/NodeSessionI.h
@@ -60,13 +60,13 @@ public:
 
     virtual void keepAlive(const LoadInfo&, const Ice::Current&);
     virtual void setReplicaObserver(const ReplicaObserverPrx&, const Ice::Current&);
-    virtual int getTimeout(const Ice::Current& = Ice::noExplicitCurrent) const;
+    virtual int getTimeout(const Ice::Current&) const;
     virtual NodeObserverPrx getObserver(const Ice::Current&) const;
     virtual void loadServers_async(const AMD_NodeSession_loadServersPtr&, const Ice::Current&) const;
     virtual Ice::StringSeq getServers(const Ice::Current&) const;
     virtual void waitForApplicationUpdate_async(const AMD_NodeSession_waitForApplicationUpdatePtr&,
                                                 const std::string&, int, const Ice::Current&) const;
-    virtual void destroy(const Ice::Current& = Ice::noExplicitCurrent);
+    virtual void destroy(const Ice::Current&);
     
     virtual IceUtil::Time timestamp() const;
     virtual void shutdown();
diff --git a/cpp/src/IceGrid/RegistryI.h b/cpp/src/IceGrid/RegistryI.h
index e4e8d436893..6707a6c4839 100644
--- a/cpp/src/IceGrid/RegistryI.h
+++ b/cpp/src/IceGrid/RegistryI.h
@@ -63,8 +63,8 @@ public:
     virtual SessionPrx createSessionFromSecureConnection(const Ice::Current&);
     virtual AdminSessionPrx createAdminSessionFromSecureConnection(const Ice::Current&);
 
-    virtual int getSessionTimeout(const Ice::Current& = Ice::noExplicitCurrent) const;
-    virtual int getACMTimeout(const Ice::Current& = Ice::noExplicitCurrent) const;
+    virtual int getSessionTimeout(const Ice::Current&) const;
+    virtual int getACMTimeout(const Ice::Current&) const;
     
     std::string getName() const;
     RegistryInfo getInfo() const;
diff --git a/cpp/src/IceGrid/ReplicaCache.cpp b/cpp/src/IceGrid/ReplicaCache.cpp
index d7e183da212..6166daf1b45 100644
--- a/cpp/src/IceGrid/ReplicaCache.cpp
+++ b/cpp/src/IceGrid/ReplicaCache.cpp
@@ -63,7 +63,7 @@ ReplicaCache::add(const string& name, const ReplicaSessionIPtr& session)
             {
                 try
                 {
-                    session->destroy();
+                    session->destroy(Ice::emptyCurrent);
                 }
                 catch(const Ice::LocalException&)
                 {
diff --git a/cpp/src/IceGrid/ReplicaSessionI.h b/cpp/src/IceGrid/ReplicaSessionI.h
index 579a30d29d3..1ef0877d6c4 100644
--- a/cpp/src/IceGrid/ReplicaSessionI.h
+++ b/cpp/src/IceGrid/ReplicaSessionI.h
@@ -41,7 +41,7 @@ public:
     virtual void setAdapterDirectProxy(const std::string&, const std::string&, const Ice::ObjectPrx&, 
                                        const Ice::Current&);
     virtual void receivedUpdate(TopicName, int, const std::string&, const Ice::Current&);
-    virtual void destroy(const Ice::Current& = Ice::noExplicitCurrent);
+    virtual void destroy(const Ice::Current&);
     
     virtual IceUtil::Time timestamp() const;
     virtual void shutdown();
diff --git a/cpp/src/IceGrid/ServerAdapterI.cpp b/cpp/src/IceGrid/ServerAdapterI.cpp
index d01a824c80d..879ffc6c2b8 100644
--- a/cpp/src/IceGrid/ServerAdapterI.cpp
+++ b/cpp/src/IceGrid/ServerAdapterI.cpp
@@ -17,10 +17,10 @@ using namespace std;
 using namespace IceGrid;
 
 ServerAdapterI::ServerAdapterI(const NodeIPtr& node,
-                               ServerI* server, 
+                               ServerI* server,
                                const string& serverName,
                                const AdapterPrx& proxy,
-                               const string& id, 
+                               const string& id,
                                bool enabled) :
     _node(node),
     _this(proxy),
@@ -52,7 +52,7 @@ ServerAdapterI::activate_async(const AMD_Adapter_activatePtr& cb, const Ice::Cur
         else if(_activateCB.empty())
         {
             //
-            // Nothing else waits for this adapter so we must make sure that this 
+            // Nothing else waits for this adapter so we must make sure that this
             // adapter if still activatable.
             //
             if(!_enabled || !_server->isAdapterActivatable(_id))
@@ -73,7 +73,8 @@ ServerAdapterI::activate_async(const AMD_Adapter_activatePtr& cb, const Ice::Cur
         {
             return;
         }
-        _activateAfterDeactivating = _server->getState() >= Deactivating && _server->getState() < Destroying;
+        _activateAfterDeactivating = _server->getState(Ice::emptyCurrent) >= Deactivating &&
+            _server->getState(Ice::emptyCurrent) < Destroying;
     }
 
     //
@@ -93,7 +94,7 @@ ServerAdapterI::activate_async(const AMD_Adapter_activatePtr& cb, const Ice::Cur
     catch(const Ice::ObjectNotExistException&)
     {
         //
-        // The server associated to this adapter doesn't exist anymore. Somehow the database is 
+        // The server associated to this adapter doesn't exist anymore. Somehow the database is
         // inconsistent if this happens. The best thing to do is to destroy the adapter.
         //
         destroy();
@@ -140,7 +141,7 @@ ServerAdapterI::setDirectProxy(const Ice::ObjectPrx& prx, const Ice::Current&)
     {
         if(prx && _proxy)
         {
-            if(_server->getState() == Active)
+            if(_server->getState(Ice::emptyCurrent) == Active)
             {
                 throw AdapterActiveException();
             }
@@ -156,7 +157,8 @@ ServerAdapterI::setDirectProxy(const Ice::ObjectPrx& prx, const Ice::Current&)
     // now. The server is going to be activated again and the adapter
     // activated.
     //
-    if(_server->getState() < Deactivating || _server->getState() >= Destroying || !_activateAfterDeactivating)
+    if(_server->getState(Ice::emptyCurrent) < Deactivating ||
+       _server->getState(Ice::emptyCurrent) >= Destroying || !_activateAfterDeactivating)
     {
         for(vector<AMD_Adapter_activatePtr>::const_iterator p = _activateCB.begin(); p != _activateCB.end(); ++p)
         {
@@ -211,7 +213,7 @@ void
 ServerAdapterI::updateEnabled()
 {
     Lock sync(*this);
-    _enabled = _server->isEnabled();
+    _enabled = _server->isEnabled(Ice::emptyCurrent);
 }
 
 void
@@ -222,7 +224,7 @@ ServerAdapterI::clear()
     _activateAfterDeactivating = false;
 }
 
-void 
+void
 ServerAdapterI::activationFailed(const std::string& reason)
 {
 
@@ -243,7 +245,7 @@ ServerAdapterI::activationFailed(const std::string& reason)
     _activateCB.clear();
 }
 
-void 
+void
 ServerAdapterI::activationCompleted()
 {
     Lock sync(*this);
@@ -258,7 +260,7 @@ ServerAdapterI::activationCompleted()
             out << "server `" + _serverId + "' adapter `" << _id << "' activation failed: server activation completed";
         }
     }
-    
+
     for(vector<AMD_Adapter_activatePtr>::const_iterator p = _activateCB.begin(); p != _activateCB.end(); ++p)
     {
         (*p)->ice_response(_proxy);
diff --git a/cpp/src/IceGrid/ServerAdapterI.h b/cpp/src/IceGrid/ServerAdapterI.h
index aaa39078a0a..f7c6e6dcb0c 100644
--- a/cpp/src/IceGrid/ServerAdapterI.h
+++ b/cpp/src/IceGrid/ServerAdapterI.h
@@ -29,8 +29,8 @@ public:
     virtual ~ServerAdapterI();
 
     virtual void activate_async(const AMD_Adapter_activatePtr& cb, const Ice::Current&);
-    virtual Ice::ObjectPrx getDirectProxy(const Ice::Current& = Ice::noExplicitCurrent) const;
-    virtual void setDirectProxy(const ::Ice::ObjectPrx&, const ::Ice::Current& = Ice::noExplicitCurrent);
+    virtual Ice::ObjectPrx getDirectProxy(const Ice::Current&) const;
+    virtual void setDirectProxy(const ::Ice::ObjectPrx&, const ::Ice::Current&);
     void destroy();
     void updateEnabled();
     void clear();
diff --git a/cpp/src/IceGrid/ServerI.cpp b/cpp/src/IceGrid/ServerI.cpp
index c74f85af73b..9e652cebd4e 100644
--- a/cpp/src/IceGrid/ServerI.cpp
+++ b/cpp/src/IceGrid/ServerI.cpp
@@ -1975,7 +1975,7 @@ ServerI::terminated(const string& msg, int status)
     {
         try
         {
-            p->second->setDirectProxy(0);
+            p->second->setDirectProxy(0, Ice::emptyCurrent);
         }
         catch(const Ice::ObjectNotExistException&)
         {
diff --git a/cpp/src/IceGrid/ServerI.h b/cpp/src/IceGrid/ServerI.h
index 7dcde8608c8..ce68d8be651 100644
--- a/cpp/src/IceGrid/ServerI.h
+++ b/cpp/src/IceGrid/ServerI.h
@@ -73,16 +73,16 @@ public:
 
     void waitForApplicationUpdateCompleted(const Ice::AsyncResultPtr&);
 
-    virtual void start_async(const AMD_Server_startPtr&, const ::Ice::Current& = Ice::noExplicitCurrent);
-    virtual void stop_async(const AMD_Server_stopPtr&, const ::Ice::Current& = Ice::noExplicitCurrent);
+    virtual void start_async(const AMD_Server_startPtr&, const ::Ice::Current&);
+    virtual void stop_async(const AMD_Server_stopPtr&, const ::Ice::Current&);
     virtual void sendSignal(const std::string&, const ::Ice::Current&);
     virtual void writeMessage(const std::string&, Ice::Int, const ::Ice::Current&);
 
-    virtual ServerState getState(const ::Ice::Current& = Ice::noExplicitCurrent) const;
-    virtual Ice::Int getPid(const ::Ice::Current& = Ice::noExplicitCurrent) const;
+    virtual ServerState getState(const ::Ice::Current&) const;
+    virtual Ice::Int getPid(const ::Ice::Current&) const;
 
     virtual void setEnabled(bool, const ::Ice::Current&);
-    virtual bool isEnabled(const ::Ice::Current& = Ice::noExplicitCurrent) const;
+    virtual bool isEnabled(const ::Ice::Current&) const;
     virtual void setProcess_async(const AMD_Server_setProcessPtr&, const ::Ice::ProcessPrx&, const ::Ice::Current&);
 
     virtual Ice::Long getOffsetFromEnd(const std::string&, int, const Ice::Current&) const;
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index de9d75e0f90..930e188c6f2 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -2463,11 +2463,9 @@ Slice::Gen::ObjectVisitor::visitClassDefStart(const ClassDefPtr& p)
         StringList::difference_type scopedPos = IceUtilInternal::distance(firstIter, scopedIter);
 
         H << sp;
-        H << nl << "virtual bool ice_isA"
-          << "(const ::std::string&, const ::Ice::Current& = ::Ice::noExplicitCurrent) const;";
-        H << nl << "virtual ::std::vector< ::std::string> ice_ids"
-          << "(const ::Ice::Current& = ::Ice::noExplicitCurrent) const;";
-        H << nl << "virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::noExplicitCurrent) const;";
+        H << nl << "virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::emptyCurrent) const;";
+        H << nl << "virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::emptyCurrent) const;";
+        H << nl << "virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::emptyCurrent) const;";
         H << sp << nl << "static const ::std::string& ice_staticId();";
 
         string flatName = "iceC" + p->flattenedScope() + p->name() + "_ids";
@@ -2995,7 +2993,7 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
             args += ", ";
         }
 
-        params += "const ::Ice::Current& = ::Ice::noExplicitCurrent)";
+        params += "const ::Ice::Current& = ::Ice::emptyCurrent)";
         paramsDecl += "const ::Ice::Current& current)";
         args += "current)";
     }
@@ -3006,7 +3004,7 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
         args += ')';
     }
 
-    paramsAMD += "const ::Ice::Current& = ::Ice::noExplicitCurrent)";
+    paramsAMD += "const ::Ice::Current& = ::Ice::emptyCurrent)";
     argsAMD += "current)";
 
     string isConst = ((p->mode() == Operation::Nonmutating) || p->hasMetaData("cpp:const")) ? " const" : "";
@@ -6803,10 +6801,10 @@ Slice::Gen::Cpp11InterfaceVisitor::visitClassDefStart(const ClassDefPtr& p)
     assert(scopedIter != ids.end());
 
     H << sp;
-    H << nl << "virtual bool ice_isA(::std::string, const ::Ice::Current& = ::Ice::noExplicitCurrent) const override;";
+    H << nl << "virtual bool ice_isA(::std::string, const ::Ice::Current&) const override;";
     H << nl
-      << "virtual ::std::vector<::std::string> ice_ids(const ::Ice::Current& = ::Ice::noExplicitCurrent) const override;";
-    H << nl << "virtual ::std::string ice_id(const ::Ice::Current& = ::Ice::noExplicitCurrent) const override;";
+      << "virtual ::std::vector<::std::string> ice_ids(const ::Ice::Current&) const override;";
+    H << nl << "virtual ::std::string ice_id(const ::Ice::Current&) const override;";
     H << sp << nl << "static const ::std::string& ice_staticId();";
 
     string flatName = "iceC" + p->flattenedScope() + p->name() + "_ids";
@@ -7010,7 +7008,7 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
         params.push_back("::std::function<void(::std::exception_ptr)>");
         args.push_back("inA->exception()");
     }
-    params.push_back("const ::Ice::Current& = ::Ice::noExplicitCurrent");
+    params.push_back("const ::Ice::Current&");
     args.push_back("current");
 
     if(cl->isInterface())
diff --git a/cpp/test/Ice/admin/TestI.cpp b/cpp/test/Ice/admin/TestI.cpp
index 59e18c6ec57..9740d4a2d91 100644
--- a/cpp/test/Ice/admin/TestI.cpp
+++ b/cpp/test/Ice/admin/TestI.cpp
@@ -220,7 +220,7 @@ RemoteCommunicatorFactoryI::createCommunicator(ICE_IN(Ice::PropertyDict) props,
     // Set the callback on the admin facet.
     //
     RemoteCommunicatorIPtr servant = ICE_MAKE_SHARED(RemoteCommunicatorI, communicator);
-    servant->addUpdateCallback(Ice::noExplicitCurrent);
+    servant->addUpdateCallback(Ice::emptyCurrent);
 
     Ice::ObjectPrxPtr proxy = current.adapter->addWithUUID(servant);
     return ICE_UNCHECKED_CAST(Test::RemoteCommunicatorPrx, proxy);
diff --git a/cpp/test/Ice/library/AllTests.cpp b/cpp/test/Ice/library/AllTests.cpp
index ccc9ca63803..c8ce74fed81 100644
--- a/cpp/test/Ice/library/AllTests.cpp
+++ b/cpp/test/Ice/library/AllTests.cpp
@@ -22,8 +22,7 @@ class TestI : public Test::MyInterface
 {
 public:
 
-    void op(bool, const Ice::Current& = Ice::noExplicitCurrent);
-
+    void op(bool, const Ice::Current&);
 };
 
 void
diff --git a/cpp/test/Ice/library/Consumer.cpp b/cpp/test/Ice/library/Consumer.cpp
index bd2af77ff90..b198a784c75 100644
--- a/cpp/test/Ice/library/Consumer.cpp
+++ b/cpp/test/Ice/library/Consumer.cpp
@@ -38,7 +38,7 @@ consume(const Ice::ObjectPtr& o, const Ice::ObjectPrxPtr& p)
     test(proxy);
 
     proxy->op(false);
-    servant->op(false, Ice::noExplicitCurrent);
+    servant->op(false, Ice::emptyCurrent);
 
     cout << "ok" << endl;
 
@@ -59,7 +59,7 @@ consume(const Ice::ObjectPtr& o, const Ice::ObjectPrxPtr& p)
 
     try
     {
-        servant->op(true);
+        servant->op(true, Ice::emptyCurrent);
     }
     catch(const Test::UserError&)
     {
diff --git a/cpp/test/Ice/optional/TestI.h b/cpp/test/Ice/optional/TestI.h
index 5a0d4b187f0..1755093f756 100644
--- a/cpp/test/Ice/optional/TestI.h
+++ b/cpp/test/Ice/optional/TestI.h
@@ -106,102 +106,102 @@ public:
     virtual IceUtil::Optional< ::Test::ByteSeq> opByteSeq(
         ICE_IN(IceUtil::Optional< ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> >),
         IceUtil::Optional< ::Test::ByteSeq>&,
-        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        const ::Ice::Current&);
 
     virtual IceUtil::Optional< ::Test::BoolSeq> opBoolSeq(
         ICE_IN(IceUtil::Optional< ::std::pair<const bool*, const bool*> >),
         IceUtil::Optional< ::Test::BoolSeq>&,
-        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        const ::Ice::Current&);
 
     virtual IceUtil::Optional< ::Test::ShortSeq> opShortSeq(
         ICE_IN(IceUtil::Optional< ::std::pair<const ::Ice::Short*, const ::Ice::Short*> >),
         IceUtil::Optional< ::Test::ShortSeq>&,
-        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        const ::Ice::Current&);
 
     virtual IceUtil::Optional< ::Test::IntSeq> opIntSeq(
         ICE_IN(IceUtil::Optional< ::std::pair<const ::Ice::Int*, const ::Ice::Int*> >),
         IceUtil::Optional< ::Test::IntSeq>&,
-        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        const ::Ice::Current&);
 
     virtual IceUtil::Optional< ::Test::LongSeq> opLongSeq(
         ICE_IN(IceUtil::Optional< ::std::pair<const ::Ice::Long*, const ::Ice::Long*> >),
         IceUtil::Optional< ::Test::LongSeq>&,
-        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        const ::Ice::Current&);
 
     virtual IceUtil::Optional< ::Test::FloatSeq> opFloatSeq(
         ICE_IN(IceUtil::Optional< ::std::pair<const ::Ice::Float*, const ::Ice::Float*> >),
         IceUtil::Optional< ::Test::FloatSeq>&,
-        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        const ::Ice::Current&);
 
     virtual IceUtil::Optional< ::Test::DoubleSeq> opDoubleSeq(
         ICE_IN(IceUtil::Optional< ::std::pair<const ::Ice::Double*, const ::Ice::Double*> >),
         IceUtil::Optional< ::Test::DoubleSeq>&,
-        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        const ::Ice::Current&);
 
 #ifdef ICE_CPP11_MAPPING
      virtual Ice::optional<::Test::StringSeq> opStringSeq(
          Ice::optional<::Test::StringSeq>,
-         Ice::optional<::Test::StringSeq>&, const ::Ice::Current& = ::Ice::noExplicitCurrent) ;
+         Ice::optional<::Test::StringSeq>&, const ::Ice::Current&) ;
 #else
     virtual IceUtil::Optional< ::Test::StringSeq> opStringSeq(
         const IceUtil::Optional< ::std::pair< ::Test::StringSeq::const_iterator,
                                               ::Test::StringSeq::const_iterator> >&,
         IceUtil::Optional< ::Test::StringSeq>&,
-        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        const ::Ice::Current&);
 #endif
 
     virtual IceUtil::Optional< ::Test::SmallStructSeq> opSmallStructSeq(
         ICE_IN(IceUtil::Optional< ::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*> >),
-        IceUtil::Optional< ::Test::SmallStructSeq>&, const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        IceUtil::Optional< ::Test::SmallStructSeq>&, const ::Ice::Current&);
 
     virtual IceUtil::Optional< ::Test::SmallStructList> opSmallStructList(
         ICE_IN(IceUtil::Optional< ::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*> >),
-        IceUtil::Optional< ::Test::SmallStructList>&, const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        IceUtil::Optional< ::Test::SmallStructList>&, const ::Ice::Current&);
 
     virtual IceUtil::Optional< ::Test::FixedStructSeq> opFixedStructSeq(
         ICE_IN(IceUtil::Optional< ::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*> >),
-        IceUtil::Optional< ::Test::FixedStructSeq>&, const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        IceUtil::Optional< ::Test::FixedStructSeq>&, const ::Ice::Current&);
 
     virtual IceUtil::Optional< ::Test::FixedStructList> opFixedStructList(
         ICE_IN(IceUtil::Optional< ::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*> >),
-        IceUtil::Optional< ::Test::FixedStructList>&, const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        IceUtil::Optional< ::Test::FixedStructList>&, const ::Ice::Current&);
 
 #ifdef ICE_CPP11_MAPPING
     virtual Ice::optional<::Test::VarStructSeq> opVarStructSeq(
         Ice::optional<::Test::VarStructSeq>, Ice::optional<::Test::VarStructSeq>&,
-        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        const ::Ice::Current&);
 #else
     virtual IceUtil::Optional< ::Test::VarStructSeq> opVarStructSeq(
         const IceUtil::Optional< ::std::pair< ::Test::VarStructSeq::const_iterator,
                                               ::Test::VarStructSeq::const_iterator> >&,
         IceUtil::Optional< ::Test::VarStructSeq>&,
-        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        const ::Ice::Current&);
 #endif
 
     virtual IceUtil::Optional< ::Test::Serializable> opSerializable(
         ICE_IN(IceUtil::Optional< ::Test::Serializable>),
         IceUtil::Optional< ::Test::Serializable>&,
-        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        const ::Ice::Current&);
 
     virtual IceUtil::Optional< ::Test::IntIntDict> opIntIntDict(
         ICE_IN(IceUtil::Optional< ::Test::IntIntDict>),
         IceUtil::Optional< ::Test::IntIntDict>&,
-        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        const ::Ice::Current&);
 
     virtual IceUtil::Optional< ::Test::StringIntDict> opStringIntDict(
         ICE_IN(IceUtil::Optional< ::Test::StringIntDict>),
         IceUtil::Optional< ::Test::StringIntDict>&,
-        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        const ::Ice::Current&);
 
     virtual IceUtil::Optional< ::Test::IntOneOptionalDict> opIntOneOptionalDict(
         ICE_IN(IceUtil::Optional< ::Test::IntOneOptionalDict>),
         IceUtil::Optional< ::Test::IntOneOptionalDict>&,
-        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        const ::Ice::Current&);
 
     virtual IceUtil::Optional< ::Test::IntStringDict> opCustomIntStringDict(
         ICE_IN(IceUtil::Optional<std::map<int, Util::string_view> >),
         IceUtil::Optional< ::Test::IntStringDict>&,
-        const ::Ice::Current& = ::Ice::noExplicitCurrent);
+        const ::Ice::Current&);
 
     virtual void opClassAndUnknownOptional(ICE_IN(Test::APtr), const Ice::Current&);
 
diff --git a/cpp/test/Ice/slicing/objects/AllTests.cpp b/cpp/test/Ice/slicing/objects/AllTests.cpp
index b048c8129d4..e35337d2de2 100644
--- a/cpp/test/Ice/slicing/objects/AllTests.cpp
+++ b/cpp/test/Ice/slicing/objects/AllTests.cpp
@@ -63,7 +63,7 @@ public:
     response_SBaseAsObject(const ::Ice::ObjectPtr& o)
     {
         test(o);
-        test(o->ice_id() == "::Test::SBase");
+        test(o->ice_id(Ice::emptyCurrent) == "::Test::SBase");
         SBasePtr sb = ICE_DYNAMIC_CAST(SBase, o);
         test(sb);
         test(sb->sb == "SBase.sb");