diff options
| author | Bernard Normier <bernard@zeroc.com> | 2016-11-02 17:56:08 -0400 |
|---|---|---|
| committer | Bernard Normier <bernard@zeroc.com> | 2016-11-02 17:56:08 -0400 |
| commit | 91fa99c34d1211d426b24bf68001fc27a87b3f00 (patch) | |
| tree | 15af995f00414098b678b4cff09a9f0c29830fa8 | |
| parent | Add C# code sign support (diff) | |
| download | ice-91fa99c34d1211d426b24bf68001fc27a87b3f00.tar.bz2 ice-91fa99c34d1211d426b24bf68001fc27a87b3f00.tar.xz ice-91fa99c34d1211d426b24bf68001fc27a87b3f00.zip | |
Replaced double and triple underscores in C++ by ice-prefixed names
92 files changed, 1344 insertions, 1337 deletions
diff --git a/cpp/include/Ice/AsyncResult.h b/cpp/include/Ice/AsyncResult.h index e8aea029007..5562448e7eb 100644 --- a/cpp/include/Ice/AsyncResult.h +++ b/cpp/include/Ice/AsyncResult.h @@ -51,20 +51,20 @@ public: virtual const std::string& getOperation() const = 0; - virtual bool __wait() = 0; - virtual Ice::InputStream* __startReadParams() = 0; - virtual void __endReadParams() = 0; - virtual void __readEmptyParams() = 0; - virtual void __readParamEncaps(const ::Ice::Byte*&, ::Ice::Int&) = 0; - virtual void __throwUserException() = 0; + virtual bool iceWait() = 0; + virtual Ice::InputStream* iceStartReadParams() = 0; + virtual void iceEndReadParams() = 0; + virtual void iceReadEmptyParams() = 0; + virtual void iceReadParamEncaps(const ::Ice::Byte*&, ::Ice::Int&) = 0; + virtual void iceThrowUserException() = 0; - static void __check(const AsyncResultPtr&, const ::IceProxy::Ice::Object*, const ::std::string&); - static void __check(const AsyncResultPtr&, const Connection*, const ::std::string&); - static void __check(const AsyncResultPtr&, const Communicator*, const ::std::string&); + static void iceCheck(const AsyncResultPtr&, const ::IceProxy::Ice::Object*, const ::std::string&); + static void iceCheck(const AsyncResultPtr&, const Connection*, const ::std::string&); + static void iceCheck(const AsyncResultPtr&, const Communicator*, const ::std::string&); protected: - static void __check(const AsyncResultPtr&, const ::std::string&); + static void iceCheck(const AsyncResultPtr&, const ::std::string&); }; } diff --git a/cpp/include/Ice/CommunicatorAsync.h b/cpp/include/Ice/CommunicatorAsync.h index 549542567dd..ea121dff6c5 100644 --- a/cpp/include/Ice/CommunicatorAsync.h +++ b/cpp/include/Ice/CommunicatorAsync.h @@ -33,18 +33,18 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const { - ::Ice::CommunicatorPtr __com = __result->getCommunicator(); - assert(__com); + ::Ice::CommunicatorPtr iceCom = iceResult->getCommunicator(); + assert(iceCom); try { - __com->end_flushBatchRequests(__result); + iceCom->end_flushBatchRequests(iceResult); assert(false); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(iceResult, ex); } } }; @@ -81,18 +81,18 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const { - ::Ice::CommunicatorPtr __com = __result->getCommunicator(); - assert(__com); + ::Ice::CommunicatorPtr iceCom = iceResult->getCommunicator(); + assert(iceCom); try { - __com->end_flushBatchRequests(__result); + iceCom->end_flushBatchRequests(iceResult); assert(false); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(iceResult, ex); } } }; diff --git a/cpp/include/Ice/ConnectionAsync.h b/cpp/include/Ice/ConnectionAsync.h index ce9fd85e7af..dfba4900e52 100644 --- a/cpp/include/Ice/ConnectionAsync.h +++ b/cpp/include/Ice/ConnectionAsync.h @@ -34,18 +34,18 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const { - ::Ice::ConnectionPtr __con = __result->getConnection(); - assert(__con); + ::Ice::ConnectionPtr iceCon = iceResult->getConnection(); + assert(iceCon); try { - __con->end_flushBatchRequests(__result); + iceCon->end_flushBatchRequests(iceResult); assert(false); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(iceResult, ex); } } }; @@ -81,18 +81,18 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const { - ::Ice::ConnectionPtr __con = __result->getConnection(); - assert(__con); + ::Ice::ConnectionPtr iceCon = iceResult->getConnection(); + assert(iceCon); try { - __con->end_flushBatchRequests(__result); + iceCon->end_flushBatchRequests(iceResult); assert(false); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(iceResult, ex); } } }; diff --git a/cpp/include/Ice/DispatchInterceptor.h b/cpp/include/Ice/DispatchInterceptor.h index 648e21412ca..12223a61abe 100644 --- a/cpp/include/Ice/DispatchInterceptor.h +++ b/cpp/include/Ice/DispatchInterceptor.h @@ -21,7 +21,7 @@ public: virtual bool dispatch(Request&) = 0; - virtual bool __dispatch(IceInternal::Incoming&, const Current&); + virtual bool iceDispatch(IceInternal::Incoming&, const Current&); }; ICE_DEFINE_PTR(DispatchInterceptorPtr, DispatchInterceptor); diff --git a/cpp/include/Ice/Exception.h b/cpp/include/Ice/Exception.h index b2b4720b8ea..b135e34c69b 100644 --- a/cpp/include/Ice/Exception.h +++ b/cpp/include/Ice/Exception.h @@ -57,10 +57,10 @@ class ICE_API UserException : public IceUtil::Exception { public: - virtual void __write(::Ice::OutputStream*) const; - virtual void __read(::Ice::InputStream*); + virtual void iceWrite(::Ice::OutputStream*) const; + virtual void iceRead(::Ice::InputStream*); - virtual bool __usesClasses() const; + virtual bool iceUsesClasses() const; #ifdef ICE_CPP11_MAPPING std::unique_ptr<UserException> ice_clone() const; @@ -72,8 +72,8 @@ public: protected: - virtual void __writeImpl(::Ice::OutputStream*) const {}; - virtual void __readImpl(::Ice::InputStream*) {}; + virtual void iceWriteImpl(::Ice::OutputStream*) const {}; + virtual void iceReadImpl(::Ice::InputStream*) {}; }; diff --git a/cpp/include/Ice/ExceptionHelpers.h b/cpp/include/Ice/ExceptionHelpers.h index 04c37669f07..320f5de9aaa 100644 --- a/cpp/include/Ice/ExceptionHelpers.h +++ b/cpp/include/Ice/ExceptionHelpers.h @@ -45,20 +45,20 @@ public: protected: - virtual void __writeImpl(Ice::OutputStream* os) const override + virtual void iceWriteImpl(Ice::OutputStream* os) const override { os->startSlice(T::ice_staticId(), -1, std::is_same<B, Ice::LocalException>::value ? true : false); Ice::StreamWriter<T, Ice::OutputStream>::write(os, static_cast<const T&>(*this)); os->endSlice(); - B::__writeImpl(os); + B::iceWriteImpl(os); } - virtual void __readImpl(Ice::InputStream* is) override + virtual void iceReadImpl(Ice::InputStream* is) override { is->startSlice(); Ice::StreamReader<T, ::Ice::InputStream>::read(is, static_cast<T&>(*this)); is->endSlice(); - B::__readImpl(is); + B::iceReadImpl(is); } }; diff --git a/cpp/include/Ice/GCObject.h b/cpp/include/Ice/GCObject.h index e115795be20..ad18de931ca 100644 --- a/cpp/include/Ice/GCObject.h +++ b/cpp/include/Ice/GCObject.h @@ -47,24 +47,24 @@ public: // // Override IceUtil::Shared methods // - virtual void __incRef(); - virtual void __decRef(); - virtual int __getRef() const; - virtual void __setNoDelete(bool); + virtual void iceIncRef(); + virtual void iceDecRef(); + virtual int iceGetRef() const; + virtual void iceSetNoDelete(bool); // // Override Object methods // - virtual bool __gcVisit(GCVisitor&); + virtual bool iceGcVisit(GCVisitor&); virtual void ice_collectable(bool); // // This method is implemented by Slice classes to visit class // members. // - virtual void __gcVisitMembers(IceInternal::GCVisitor&) = 0; + virtual void iceGcVisitMembers(IceInternal::GCVisitor&) = 0; - int __getRefUnsafe() + int iceGetRefUnsafe() { return _ref; } diff --git a/cpp/include/Ice/Handle.h b/cpp/include/Ice/Handle.h index 59283f07702..927ad362b13 100644 --- a/cpp/include/Ice/Handle.h +++ b/cpp/include/Ice/Handle.h @@ -43,7 +43,7 @@ public: if(this->_ptr) { - upCast(this->_ptr)->__incRef(); + upCast(this->_ptr)->iceIncRef(); } } @@ -54,7 +54,7 @@ public: if(this->_ptr) { - upCast(this->_ptr)->__incRef(); + upCast(this->_ptr)->iceIncRef(); } } @@ -65,7 +65,7 @@ public: if(this->_ptr) { - upCast(this->_ptr)->__incRef(); + upCast(this->_ptr)->iceIncRef(); } } @@ -75,7 +75,7 @@ public: if(this->_ptr) { - upCast(this->_ptr)->__incRef(); + upCast(this->_ptr)->iceIncRef(); } } @@ -83,7 +83,7 @@ public: { if(this->_ptr) { - upCast(this->_ptr)->__decRef(); + upCast(this->_ptr)->iceDecRef(); } } @@ -93,7 +93,7 @@ public: { if(p) { - upCast(p)->__incRef(); + upCast(p)->iceIncRef(); } T* ptr = this->_ptr; @@ -101,7 +101,7 @@ public: if(ptr) { - upCast(ptr)->__decRef(); + upCast(ptr)->iceDecRef(); } } return *this; @@ -114,7 +114,7 @@ public: { if(r._ptr) { - upCast(r._ptr)->__incRef(); + upCast(r._ptr)->iceIncRef(); } T* ptr = this->_ptr; @@ -122,7 +122,7 @@ public: if(ptr) { - upCast(ptr)->__decRef(); + upCast(ptr)->iceDecRef(); } } return *this; @@ -135,7 +135,7 @@ public: { if(r._ptr) { - upCast(r._ptr)->__incRef(); + upCast(r._ptr)->iceIncRef(); } T* ptr = this->_ptr; @@ -143,7 +143,7 @@ public: if(ptr) { - upCast(ptr)->__decRef(); + upCast(ptr)->iceDecRef(); } } return *this; @@ -155,7 +155,7 @@ public: { if(r._ptr) { - upCast(r._ptr)->__incRef(); + upCast(r._ptr)->iceIncRef(); } T* ptr = this->_ptr; @@ -163,7 +163,7 @@ public: if(ptr) { - upCast(ptr)->__decRef(); + upCast(ptr)->iceDecRef(); } } return *this; @@ -181,7 +181,7 @@ public: return Handle(dynamic_cast<T*>(p)); } - void __clearHandleUnsafe() + void iceClearHandleUnsafe() { this->_ptr = 0; } diff --git a/cpp/include/Ice/Incoming.h b/cpp/include/Ice/Incoming.h index f512d38ac8b..bdff5b49721 100644 --- a/cpp/include/Ice/Incoming.h +++ b/cpp/include/Ice/Incoming.h @@ -37,12 +37,12 @@ public: std::shared_ptr<OutputStream> getOutputStream() const { - return __os; + return _os; } protected: - std::shared_ptr<OutputStream> __os; + std::shared_ptr<OutputStream> _os; }; } diff --git a/cpp/include/Ice/InputStream.h b/cpp/include/Ice/InputStream.h index 81d5be4c950..c570d7cbe77 100644 --- a/cpp/include/Ice/InputStream.h +++ b/cpp/include/Ice/InputStream.h @@ -41,7 +41,7 @@ patchHandle(void* addr, const ValuePtr& v) } #else IceInternal::Handle<T>* p = static_cast<IceInternal::Handle<T>*>(addr); - __patch(*p, v); // Generated __patch method, necessary for forward declarations. + icePatch(*p, v); // Generated icePatch method, necessary for forward declarations. #endif } @@ -383,7 +383,7 @@ public: #ifdef ICE_CPP11_MAPPING v.emplace(); #else - v.__setIsSet(); + v.iceSetIsSet(); #endif StreamOptionalHelper<T, StreamableTraits<T>::helper, @@ -594,14 +594,14 @@ public: else { v = ::IceInternal::createProxy<T>(); - v->__copyFrom(proxy); + v->iceCopyFrom(proxy); } } #else void read(ObjectPrx&); template<typename T> void read(IceInternal::ProxyHandle<T>& v) { - __read(this, v); // Generated __read method, necessary for forward declarations. + iceRead(this, v); // Generated iceRead method, necessary for forward declarations. } #endif diff --git a/cpp/include/Ice/LoggerUtil.h b/cpp/include/Ice/LoggerUtil.h index ff890e9aedd..0be6d1e4359 100644 --- a/cpp/include/Ice/LoggerUtil.h +++ b/cpp/include/Ice/LoggerUtil.h @@ -24,7 +24,7 @@ public: std::string str() const; - std::ostringstream& __str(); // For internal use only. Don't use in your code. + std::ostringstream& iceStr(); // For internal use only. Don't use in your code. private: @@ -48,7 +48,7 @@ struct LoggerOutputInserter static inline LoggerOutputBase& insert(LoggerOutputBase& out, const T& val) { - out.__str() << val; + out.iceStr() << val; return out; } }; @@ -87,7 +87,7 @@ operator<<(LoggerOutputBase& os, const ::IceInternal::ProxyHandle<T>& p) inline LoggerOutputBase& operator<<(LoggerOutputBase& out, const ::std::exception& ex) { - out.__str() << ex.what(); + out.iceStr() << ex.what(); return out; } @@ -108,13 +108,13 @@ public: inline void flush() { - std::string s = __str().str(); + std::string s = iceStr().str(); if(!s.empty()) { L& ref = *_logger; (ref.*output)(s); } - __str().str(""); + iceStr().str(""); } private: diff --git a/cpp/include/Ice/Object.h b/cpp/include/Ice/Object.h index 6e472bd5fee..9e2eaf984b7 100644 --- a/cpp/include/Ice/Object.h +++ b/cpp/include/Ice/Object.h @@ -70,20 +70,20 @@ public: virtual ~Object() = default; virtual bool ice_isA(std::string, const Current& = Ice::noExplicitCurrent) const; - bool ___ice_isA(IceInternal::Incoming&, const Current&); + bool iceD_ice_isA(IceInternal::Incoming&, const Current&); virtual void ice_ping(const Current& = Ice::noExplicitCurrent) const; - bool ___ice_ping(IceInternal::Incoming&, const Current&); + bool iceD_ice_ping(IceInternal::Incoming&, const Current&); virtual std::vector< std::string> ice_ids(const Current& = Ice::noExplicitCurrent) const; - bool ___ice_ids(IceInternal::Incoming&, const Current&); + bool iceD_ice_ids(IceInternal::Incoming&, const Current&); virtual std::string ice_id(const Current& = Ice::noExplicitCurrent) const; - bool ___ice_id(IceInternal::Incoming&, const Current&); + bool iceD_ice_id(IceInternal::Incoming&, const Current&); static const std::string& ice_staticId(); - static std::string __all[]; + static std::string s_iceAll[]; #ifndef ICE_CPP11_MAPPING virtual bool ice_dispatch(Ice::Request&, const DispatchInterceptorAsyncCallbackPtr& = 0); @@ -92,7 +92,7 @@ public: std::function<bool()> = nullptr, std::function<bool(std::exception_ptr)> = nullptr); #endif - virtual bool __dispatch(IceInternal::Incoming&, const Current&); + virtual bool iceDispatch(IceInternal::Incoming&, const Current&); struct Ice_invokeResult { @@ -102,7 +102,7 @@ public: protected: - static void __checkMode(OperationMode, OperationMode); + static void iceCheckMode(OperationMode, OperationMode); }; #else class ICE_API Object : public virtual IceUtil::Shared @@ -113,23 +113,23 @@ public: virtual bool operator<(const Object&) const; virtual bool ice_isA(const std::string&, const Current& = Ice::noExplicitCurrent) const; - bool ___ice_isA(IceInternal::Incoming&, const Current&); + bool iceD_ice_isA(IceInternal::Incoming&, const Current&); virtual void ice_ping(const Current& = Ice::noExplicitCurrent) const; - bool ___ice_ping(IceInternal::Incoming&, const Current&); + bool iceD_ice_ping(IceInternal::Incoming&, const Current&); virtual std::vector< std::string> ice_ids(const Current& = Ice::noExplicitCurrent) const; - bool ___ice_ids(IceInternal::Incoming&, const Current&); + bool iceD_ice_ids(IceInternal::Incoming&, const Current&); virtual const std::string& ice_id(const Current& = Ice::noExplicitCurrent) const; - bool ___ice_id(IceInternal::Incoming&, const Current&); + bool iceD_ice_id(IceInternal::Incoming&, const Current&); virtual Int ice_operationAttributes(const std::string&) const; - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void iceWrite(Ice::OutputStream*) const; + virtual void iceRead(Ice::InputStream*); - virtual bool __gcVisit(IceInternal::GCVisitor&) { return false; }; + virtual bool iceGcVisit(IceInternal::GCVisitor&) { return false; }; virtual void ice_collectable(bool) { }; virtual void ice_preMarshal(); @@ -139,10 +139,10 @@ public: virtual ObjectPtr ice_clone() const; - static std::string __all[]; + static std::string s_iceAll[]; virtual bool ice_dispatch(Ice::Request&, const DispatchInterceptorAsyncCallbackPtr& = 0); - virtual bool __dispatch(IceInternal::Incoming&, const Current&); + virtual bool iceDispatch(IceInternal::Incoming&, const Current&); protected: @@ -151,10 +151,10 @@ protected: protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void iceWriteImpl(Ice::OutputStream*) const {} + virtual void iceReadImpl(Ice::InputStream*) {} - static void __checkMode(OperationMode, OperationMode); + static void iceCheckMode(OperationMode, OperationMode); }; #endif @@ -167,7 +167,7 @@ public: // virtual bool ice_invoke(const std::vector<Byte>&, std::vector<Byte>&, const Current&) = 0; - virtual bool __dispatch(IceInternal::Incoming&, const Current&); + virtual bool iceDispatch(IceInternal::Incoming&, const Current&); }; class ICE_API BlobjectArray : public virtual Object @@ -179,7 +179,7 @@ public: // virtual bool ice_invoke(const std::pair<const Byte*, const Byte*>&, std::vector<Byte>&, const Current&) = 0; - virtual bool __dispatch(IceInternal::Incoming&, const Current&); + virtual bool iceDispatch(IceInternal::Incoming&, const Current&); }; class ICE_API BlobjectAsync : public virtual Object @@ -194,7 +194,7 @@ public: #else virtual void ice_invoke_async(const AMD_Object_ice_invokePtr&, const std::vector<Byte>&, const Current&) = 0; #endif - virtual bool __dispatch(IceInternal::Incoming&, const Current&); + virtual bool iceDispatch(IceInternal::Incoming&, const Current&); }; class ICE_API BlobjectArrayAsync : public virtual Object @@ -210,7 +210,7 @@ public: virtual void ice_invoke_async(const AMD_Object_ice_invokePtr&, const std::pair<const Byte*, const Byte*>&, const Current&) = 0; #endif - virtual bool __dispatch(IceInternal::Incoming&, const Current&); + virtual bool iceDispatch(IceInternal::Incoming&, const Current&); }; } diff --git a/cpp/include/Ice/ObjectF.h b/cpp/include/Ice/ObjectF.h index eb157fac899..8f6ffd96580 100644 --- a/cpp/include/Ice/ObjectF.h +++ b/cpp/include/Ice/ObjectF.h @@ -23,7 +23,7 @@ using ObjectPtr = ::std::shared_ptr<Object>; ICE_API Object* upCast(Object*); typedef IceInternal::Handle<Object> ObjectPtr; typedef ObjectPtr ValuePtr; -ICE_API void __patch(ObjectPtr&, const ObjectPtr&); +ICE_API void icePatch(ObjectPtr&, const ObjectPtr&); #endif } diff --git a/cpp/include/Ice/OutgoingAsync.h b/cpp/include/Ice/OutgoingAsync.h index 8391c6c189d..23d2ef8a1e6 100644 --- a/cpp/include/Ice/OutgoingAsync.h +++ b/cpp/include/Ice/OutgoingAsync.h @@ -101,12 +101,12 @@ public: virtual void throwLocalException() const; - virtual bool __wait(); - virtual Ice::InputStream* __startReadParams(); - virtual void __endReadParams(); - virtual void __readEmptyParams(); - virtual void __readParamEncaps(const ::Ice::Byte*&, ::Ice::Int&); - virtual void __throwUserException(); + virtual bool iceWait(); + virtual Ice::InputStream* iceStartReadParams(); + virtual void iceEndReadParams(); + virtual void iceReadEmptyParams(); + virtual void iceReadParamEncaps(const ::Ice::Byte*&, ::Ice::Int&); + virtual void iceThrowUserException(); #endif void attachRemoteObserver(const Ice::ConnectionInfoPtr& c, const Ice::EndpointPtr& endpt, Ice::Int requestId) @@ -753,7 +753,7 @@ public: // // See comments in OutgoingAsync.cpp // -extern ICE_API CallbackBasePtr __dummyCallback; +extern ICE_API CallbackBasePtr dummyCallback; // // Generic callback template that requires the caller to down-cast the diff --git a/cpp/include/Ice/Proxy.h b/cpp/include/Ice/Proxy.h index 30315e7f33b..b0ddec97b23 100644 --- a/cpp/include/Ice/Proxy.h +++ b/cpp/include/Ice/Proxy.h @@ -254,7 +254,7 @@ public: bool ice_isA(const ::std::string& typeId, const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - return makePromiseOutgoing<bool>(true, this, &ObjectPrx::__ice_isA, typeId, ctx).get(); + return makePromiseOutgoing<bool>(true, this, &ObjectPrx::iceI_ice_isA, typeId, ctx).get(); } ::std::function<void()> @@ -264,23 +264,23 @@ public: ::std::function<void(bool)> sent = nullptr, const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - return makeLambdaOutgoing<bool>(response, ex, sent, this, &ObjectPrx::__ice_isA, typeId, ctx); + return makeLambdaOutgoing<bool>(response, ex, sent, this, &ObjectPrx::iceI_ice_isA, typeId, ctx); } template<template<typename> class P = std::promise> auto ice_isAAsync(const ::std::string& typeId, const ::Ice::Context& ctx = ::Ice::noExplicitContext) -> decltype(std::declval<P<bool>>().get_future()) { - return makePromiseOutgoing<bool, P>(false, this, &ObjectPrx::__ice_isA, typeId, ctx); + return makePromiseOutgoing<bool, P>(false, this, &ObjectPrx::iceI_ice_isA, typeId, ctx); } void - __ice_isA(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<bool>>&, const ::std::string&, const ::Ice::Context&); + iceI_ice_isA(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<bool>>&, const ::std::string&, const ::Ice::Context&); void ice_ping(const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - makePromiseOutgoing<void>(true, this, &ObjectPrx::__ice_ping, ctx).get(); + makePromiseOutgoing<void>(true, this, &ObjectPrx::iceI_ice_ping, ctx).get(); } ::std::function<void()> @@ -289,23 +289,23 @@ public: ::std::function<void(bool)> sent = nullptr, const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - return makeLambdaOutgoing<void>(response, ex, sent, this, &ObjectPrx::__ice_ping, ctx); + return makeLambdaOutgoing<void>(response, ex, sent, this, &ObjectPrx::iceI_ice_ping, ctx); } template<template<typename> class P = std::promise> auto ice_pingAsync(const ::Ice::Context& ctx = ::Ice::noExplicitContext) -> decltype(std::declval<P<void>>().get_future()) { - return makePromiseOutgoing<void, P>(false, this, &ObjectPrx::__ice_ping, ctx); + return makePromiseOutgoing<void, P>(false, this, &ObjectPrx::iceI_ice_ping, ctx); } void - __ice_ping(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::Ice::Context&); + iceI_ice_ping(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::Ice::Context&); ::std::vector<::std::string> ice_ids(const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - return makePromiseOutgoing<::std::vector<::std::string>>(true, this, &ObjectPrx::__ice_ids, ctx).get(); + return makePromiseOutgoing<::std::vector<::std::string>>(true, this, &ObjectPrx::iceI_ice_ids, ctx).get(); } ::std::function<void()> @@ -314,23 +314,23 @@ public: ::std::function<void(bool)> sent = nullptr, const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - return makeLambdaOutgoing<::std::vector<::std::string>>(response, ex, sent, this, &ObjectPrx::__ice_ids, ctx); + return makeLambdaOutgoing<::std::vector<::std::string>>(response, ex, sent, this, &ObjectPrx::iceI_ice_ids, ctx); } template<template<typename> class P = std::promise> auto ice_idsAsync(const ::Ice::Context& ctx = ::Ice::noExplicitContext) -> decltype(std::declval<P<::std::vector<::std::string>>>().get_future()) { - return makePromiseOutgoing<::std::vector<::std::string>, P>(false, this, &ObjectPrx::__ice_ids, ctx); + return makePromiseOutgoing<::std::vector<::std::string>, P>(false, this, &ObjectPrx::iceI_ice_ids, ctx); } void - __ice_ids(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::vector<::std::string>>>&, const ::Ice::Context&); + iceI_ice_ids(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::vector<::std::string>>>&, const ::Ice::Context&); ::std::string ice_id(const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - return makePromiseOutgoing<::std::string>(true, this, &ObjectPrx::__ice_id, ctx).get(); + return makePromiseOutgoing<::std::string>(true, this, &ObjectPrx::iceI_ice_id, ctx).get(); } ::std::function<void()> @@ -339,18 +339,18 @@ public: ::std::function<void(bool)> sent = nullptr, const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - return makeLambdaOutgoing<::std::string>(response, ex, sent, this, &ObjectPrx::__ice_id, ctx); + return makeLambdaOutgoing<::std::string>(response, ex, sent, this, &ObjectPrx::iceI_ice_id, ctx); } template<template<typename> class P = std::promise> auto ice_idAsync(const ::Ice::Context& ctx = ::Ice::noExplicitContext) -> decltype(std::declval<P<::std::string>>().get_future()) { - return makePromiseOutgoing<::std::string, P>(false, this, &ObjectPrx::__ice_id, ctx); + return makePromiseOutgoing<::std::string, P>(false, this, &ObjectPrx::iceI_ice_id, ctx); } void - __ice_id(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::string>>&, const ::Ice::Context&); + iceI_ice_id(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::string>>&, const ::Ice::Context&); static const ::std::string& ice_staticId() { @@ -541,7 +541,7 @@ public: { using LambdaOutgoing = ::IceInternal::ProxyGetConnectionLambda; auto outAsync = ::std::make_shared<LambdaOutgoing>(shared_from_this(), response, ex, sent); - __ice_getConnection(outAsync); + iceGetConnection(outAsync); return [outAsync]() { outAsync->cancel(); }; } @@ -550,11 +550,11 @@ public: { using PromiseOutgoing = ::IceInternal::ProxyGetConnectionPromise<P<::std::shared_ptr<::Ice::Connection>>>; auto outAsync = ::std::make_shared<PromiseOutgoing>(shared_from_this()); - __ice_getConnection(outAsync); + iceGetConnection(outAsync); return outAsync->getFuture(); } - void __ice_getConnection(const ::std::shared_ptr<::IceInternal::ProxyGetConnection>&); + void iceGetConnection(const ::std::shared_ptr<::IceInternal::ProxyGetConnection>&); ::std::shared_ptr<::Ice::Connection> ice_getCachedConnection() const; @@ -569,7 +569,7 @@ public: { using LambdaOutgoing = ::IceInternal::ProxyFlushBatchLambda; auto outAsync = ::std::make_shared<LambdaOutgoing>(shared_from_this(), ex, sent); - __ice_flushBatchRequests(outAsync); + iceI_ice_flushBatchRequests(outAsync); return [outAsync]() { outAsync->cancel(); }; } @@ -578,29 +578,29 @@ public: { using PromiseOutgoing = ::IceInternal::ProxyFlushBatchPromise<P<bool>>; auto outAsync = ::std::make_shared<PromiseOutgoing>(shared_from_this()); - __ice_flushBatchRequests(outAsync); + iceI_ice_flushBatchRequests(outAsync); return outAsync->getFuture(); } - void __ice_flushBatchRequests(const ::std::shared_ptr<::IceInternal::ProxyFlushBatchAsync>&); + void iceI_ice_flushBatchRequests(const ::std::shared_ptr<::IceInternal::ProxyFlushBatchAsync>&); - const ::IceInternal::ReferencePtr& __reference() const { return _reference; } + const ::IceInternal::ReferencePtr& iceReference() const { return _reference; } - void __copyFrom(const std::shared_ptr<::Ice::ObjectPrx>&); + void iceCopyFrom(const std::shared_ptr<::Ice::ObjectPrx>&); - int __handleException(const ::Ice::Exception&, const ::IceInternal::RequestHandlerPtr&, ::Ice::OperationMode, + int iceHandleException(const ::Ice::Exception&, const ::IceInternal::RequestHandlerPtr&, ::Ice::OperationMode, bool, int&); - void __checkTwowayOnly(const ::std::string&) const; + void iceCheckTwowayOnly(const ::std::string&) const; - ::IceInternal::RequestHandlerPtr __getRequestHandler(); - ::IceInternal::BatchRequestQueuePtr __getBatchRequestQueue(); - ::IceInternal::RequestHandlerPtr __setRequestHandler(const ::IceInternal::RequestHandlerPtr&); - void __updateRequestHandler(const ::IceInternal::RequestHandlerPtr&, const ::IceInternal::RequestHandlerPtr&); + ::IceInternal::RequestHandlerPtr iceGetRequestHandler(); + ::IceInternal::BatchRequestQueuePtr iceGetBatchRequestQueue(); + ::IceInternal::RequestHandlerPtr iceSetRequestHandler(const ::IceInternal::RequestHandlerPtr&); + void iceUpdateRequestHandler(const ::IceInternal::RequestHandlerPtr&, const ::IceInternal::RequestHandlerPtr&); - int __hash() const; + int iceHash() const; - void __write(OutputStream&) const; + void iceWrite(OutputStream&) const; protected: @@ -621,7 +621,7 @@ protected: return [outAsync]() { outAsync->cancel(); }; } - virtual ::std::shared_ptr<ObjectPrx> __newInstance() const; + virtual ::std::shared_ptr<ObjectPrx> iceNewInstance() const; ObjectPrx() = default; friend ::std::shared_ptr<ObjectPrx> IceInternal::createProxy<ObjectPrx>(); @@ -772,7 +772,7 @@ public: protected: - virtual ::std::shared_ptr<ObjectPrx> __newInstance() const = 0; + virtual ::std::shared_ptr<ObjectPrx> iceNewInstance() const = 0; }; ICE_API ::std::ostream& operator<<(::std::ostream&, const ::Ice::ObjectPrx&); @@ -828,7 +828,7 @@ uncheckedCast(const ::std::shared_ptr<T>& b) if(!r) { r = IceInternal::createProxy<P>(); - r->__copyFrom(b); + r->iceCopyFrom(b); } } return r; @@ -844,7 +844,7 @@ uncheckedCast(const ::std::shared_ptr<T>& b, const std::string& f) if(b) { r = IceInternal::createProxy<P>(); - r->__copyFrom(b->ice_facet(f)); + r->iceCopyFrom(b->ice_facet(f)); } return r; } @@ -861,7 +861,7 @@ checkedCast(const ::std::shared_ptr<T>& b, const ::Ice::Context& context = Ice:: if(b->ice_isA(P::ice_staticId(), context)) { r = IceInternal::createProxy<P>(); - r->__copyFrom(b); + r->iceCopyFrom(b); } } return r; @@ -882,7 +882,7 @@ checkedCast(const ::std::shared_ptr<T>& b, const std::string& f, const ::Ice::Co if(bb->ice_isA(P::ice_staticId(), context)) { r = IceInternal::createProxy<P>(); - r->__copyFrom(bb); + r->iceCopyFrom(bb); } } catch(const Ice::FacetNotExistException&) @@ -964,20 +964,20 @@ public: bool ice_isA(const ::std::string& typeId, const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - return end_ice_isA(__begin_ice_isA(typeId, ctx, ::IceInternal::__dummyCallback, 0, true)); + return end_ice_isA(iceI_begin_ice_isA(typeId, ctx, ::IceInternal::dummyCallback, 0, true)); } ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId, const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - return __begin_ice_isA(typeId, ctx, ::IceInternal::__dummyCallback, 0); + return iceI_begin_ice_isA(typeId, ctx, ::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_isA(typeId, ::Ice::noExplicitContext, del, cookie); + return iceI_begin_ice_isA(typeId, ::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId, @@ -985,14 +985,14 @@ public: const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_isA(typeId, ctx, del, cookie); + return iceI_begin_ice_isA(typeId, ctx, del, cookie); } ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId, const ::Ice::Callback_Object_ice_isAPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_isA(typeId, ::Ice::noExplicitContext, del, cookie); + return iceI_begin_ice_isA(typeId, ::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId, @@ -1000,119 +1000,119 @@ public: const ::Ice::Callback_Object_ice_isAPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_isA(typeId, ctx, del, cookie); + return iceI_begin_ice_isA(typeId, ctx, del, cookie); } bool end_ice_isA(const ::Ice::AsyncResultPtr&); void ice_ping(const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - end_ice_ping(__begin_ice_ping(ctx, ::IceInternal::__dummyCallback, 0, true)); + end_ice_ping(iceI_begin_ice_ping(ctx, ::IceInternal::dummyCallback, 0, true)); } ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - return __begin_ice_ping(ctx, ::IceInternal::__dummyCallback, 0); + return iceI_begin_ice_ping(ctx, ::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ping(::Ice::noExplicitContext, del, cookie); + return iceI_begin_ice_ping(::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& ctx, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ping(ctx, del, cookie); + return iceI_begin_ice_ping(ctx, del, cookie); } ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Callback_Object_ice_pingPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ping(::Ice::noExplicitContext, del, cookie); + return iceI_begin_ice_ping(::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& ctx, const ::Ice::Callback_Object_ice_pingPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ping(ctx, del, cookie); + return iceI_begin_ice_ping(ctx, del, cookie); } void end_ice_ping(const ::Ice::AsyncResultPtr&); ::std::vector< ::std::string> ice_ids(const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - return end_ice_ids(__begin_ice_ids(ctx, ::IceInternal::__dummyCallback, 0, true)); + return end_ice_ids(iceI_begin_ice_ids(ctx, ::IceInternal::dummyCallback, 0, true)); } ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - return __begin_ice_ids(ctx, ::IceInternal::__dummyCallback, 0); + return iceI_begin_ice_ids(ctx, ::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ids(::Ice::noExplicitContext, del, cookie); + return iceI_begin_ice_ids(::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& ctx, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ids(ctx, del, cookie); + return iceI_begin_ice_ids(ctx, del, cookie); } ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Callback_Object_ice_idsPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ids(::Ice::noExplicitContext, del, cookie); + return iceI_begin_ice_ids(::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& ctx, const ::Ice::Callback_Object_ice_idsPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ids(ctx, del, cookie); + return iceI_begin_ice_ids(ctx, del, cookie); } ::std::vector< ::std::string> end_ice_ids(const ::Ice::AsyncResultPtr&); ::std::string ice_id(const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - return end_ice_id(__begin_ice_id(ctx, ::IceInternal::__dummyCallback, 0, true)); + return end_ice_id(iceI_begin_ice_id(ctx, ::IceInternal::dummyCallback, 0, true)); } ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - return __begin_ice_id(ctx, ::IceInternal::__dummyCallback, 0); + return iceI_begin_ice_id(ctx, ::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_id(::Ice::noExplicitContext, del, cookie); + return iceI_begin_ice_id(::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& ctx, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_id(ctx, del, cookie); + return iceI_begin_ice_id(ctx, del, cookie); } ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Callback_Object_ice_idPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_id(::Ice::noExplicitContext, del, cookie); + return iceI_begin_ice_id(::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& ctx, const ::Ice::Callback_Object_ice_idPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_id(ctx, del, cookie); + return iceI_begin_ice_id(ctx, del, cookie); } ::std::string end_ice_id(const ::Ice::AsyncResultPtr&); @@ -1134,7 +1134,7 @@ public: ::Ice::OperationMode mode, const ::std::vector< ::Ice::Byte>& inParams) { - return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, ::IceInternal::__dummyCallback, 0); + return iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, ::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, @@ -1142,7 +1142,7 @@ public: const ::std::vector< ::Ice::Byte>& inParams, const ::Ice::Context& ctx) { - return __begin_ice_invoke(op, mode, inParams, ctx, ::IceInternal::__dummyCallback, 0); + return iceI_begin_ice_invoke(op, mode, inParams, ctx, ::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, @@ -1151,7 +1151,7 @@ public: const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); + return iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, @@ -1161,7 +1161,7 @@ public: const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ctx, del, cookie); + return iceI_begin_ice_invoke(op, mode, inParams, ctx, del, cookie); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, @@ -1170,7 +1170,7 @@ public: const ::Ice::Callback_Object_ice_invokePtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); + return iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, @@ -1180,7 +1180,7 @@ public: const ::Ice::Callback_Object_ice_invokePtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ctx, del, cookie); + return iceI_begin_ice_invoke(op, mode, inParams, ctx, del, cookie); } bool end_ice_invoke(::std::vector< ::Ice::Byte>&, const ::Ice::AsyncResultPtr&); @@ -1191,14 +1191,14 @@ public: ::std::vector< ::Ice::Byte>& outP, const ::Ice::Context& ctx = ::Ice::noExplicitContext) { - return end_ice_invoke(outP, __begin_ice_invoke(op, mode, inP, ctx, ::IceInternal::__dummyCallback, 0, true)); + return end_ice_invoke(outP, iceI_begin_ice_invoke(op, mode, inP, ctx, ::IceInternal::dummyCallback, 0, true)); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, ::Ice::OperationMode mode, const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams) { - return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, ::IceInternal::__dummyCallback, 0); + return iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, ::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, @@ -1207,7 +1207,7 @@ public: const ::Ice::Context& ctx, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ctx, ::IceInternal::__dummyCallback, cookie); + return iceI_begin_ice_invoke(op, mode, inParams, ctx, ::IceInternal::dummyCallback, cookie); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, @@ -1216,7 +1216,7 @@ public: const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); + return iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, @@ -1226,7 +1226,7 @@ public: const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ctx, del, cookie); + return iceI_begin_ice_invoke(op, mode, inParams, ctx, del, cookie); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, @@ -1235,7 +1235,7 @@ public: const ::Ice::Callback_Object_ice_invokePtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); + return iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, @@ -1245,10 +1245,10 @@ public: const ::Ice::Callback_Object_ice_invokePtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ctx, del, cookie); + return iceI_begin_ice_invoke(op, mode, inParams, ctx, del, cookie); } - bool ___end_ice_invoke(::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&, const ::Ice::AsyncResultPtr&); + bool iceI_end_ice_invoke(::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&, const ::Ice::AsyncResultPtr&); ::Ice::Identity ice_getIdentity() const; ::Ice::ObjectPrx ice_identity(const ::Ice::Identity&) const; @@ -1319,19 +1319,19 @@ public: ::Ice::AsyncResultPtr begin_ice_getConnection() { - return __begin_ice_getConnection(::IceInternal::__dummyCallback, 0); + return iceI_begin_ice_getConnection(::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_getConnection(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_getConnection(del, cookie); + return iceI_begin_ice_getConnection(del, cookie); } ::Ice::AsyncResultPtr begin_ice_getConnection(const ::Ice::Callback_Object_ice_getConnectionPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_getConnection(del, cookie); + return iceI_begin_ice_getConnection(del, cookie); } ::Ice::ConnectionPtr end_ice_getConnection(const ::Ice::AsyncResultPtr&); @@ -1345,71 +1345,71 @@ public: ::Ice::AsyncResultPtr begin_ice_flushBatchRequests() { - return __begin_ice_flushBatchRequests(::IceInternal::__dummyCallback, 0); + return iceI_begin_ice_flushBatchRequests(::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_flushBatchRequests(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_flushBatchRequests(del, cookie); + return iceI_begin_ice_flushBatchRequests(del, cookie); } ::Ice::AsyncResultPtr begin_ice_flushBatchRequests(const ::Ice::Callback_Object_ice_flushBatchRequestsPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_flushBatchRequests(del, cookie); + return iceI_begin_ice_flushBatchRequests(del, cookie); } void end_ice_flushBatchRequests(const ::Ice::AsyncResultPtr&); - const ::IceInternal::ReferencePtr& __reference() const { return _reference; } + const ::IceInternal::ReferencePtr& iceReference() const { return _reference; } - ::Ice::Int __hash() const; + ::Ice::Int iceHash() const; - void __copyFrom(const ::Ice::ObjectPrx&); + void iceCopyFrom(const ::Ice::ObjectPrx&); - int __handleException(const ::Ice::Exception&, const ::IceInternal::RequestHandlerPtr&, ::Ice::OperationMode, + int iceHandleException(const ::Ice::Exception&, const ::IceInternal::RequestHandlerPtr&, ::Ice::OperationMode, bool, int&); - void __checkTwowayOnly(const ::std::string&, bool) const; + void iceCheckTwowayOnly(const ::std::string&, bool) const; - void __end(const ::Ice::AsyncResultPtr&, const std::string&) const; + void iceEnd(const ::Ice::AsyncResultPtr&, const std::string&) const; - ::IceInternal::RequestHandlerPtr __getRequestHandler(); - ::IceInternal::BatchRequestQueuePtr __getBatchRequestQueue(); - ::IceInternal::RequestHandlerPtr __setRequestHandler(const ::IceInternal::RequestHandlerPtr&); - void __updateRequestHandler(const ::IceInternal::RequestHandlerPtr&, const ::IceInternal::RequestHandlerPtr&); + ::IceInternal::RequestHandlerPtr iceGetRequestHandler(); + ::IceInternal::BatchRequestQueuePtr iceGetBatchRequestQueue(); + ::IceInternal::RequestHandlerPtr iceSetRequestHandler(const ::IceInternal::RequestHandlerPtr&); + void iceUpdateRequestHandler(const ::IceInternal::RequestHandlerPtr&, const ::IceInternal::RequestHandlerPtr&); - void __write(::Ice::OutputStream&) const; + void iceWrite(::Ice::OutputStream&) const; protected: - virtual Object* __newInstance() const; + virtual Object* iceNewInstance() const; private: - ::Ice::AsyncResultPtr __begin_ice_isA(const ::std::string&, + ::Ice::AsyncResultPtr iceI_begin_ice_isA(const ::std::string&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr&, bool = false); - ::Ice::AsyncResultPtr __begin_ice_ping(const ::Ice::Context&, + ::Ice::AsyncResultPtr iceI_begin_ice_ping(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr&, bool = false); - ::Ice::AsyncResultPtr __begin_ice_ids(const ::Ice::Context&, + ::Ice::AsyncResultPtr iceI_begin_ice_ids(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr&, bool = false); - ::Ice::AsyncResultPtr __begin_ice_id(const ::Ice::Context&, + ::Ice::AsyncResultPtr iceI_begin_ice_id(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr&, bool = false); - ::Ice::AsyncResultPtr __begin_ice_invoke(const ::std::string&, + ::Ice::AsyncResultPtr iceI_begin_ice_invoke(const ::std::string&, ::Ice::OperationMode, const ::std::vector< ::Ice::Byte>&, const ::Ice::Context&, @@ -1417,7 +1417,7 @@ private: const ::Ice::LocalObjectPtr&, bool = false); - ::Ice::AsyncResultPtr __begin_ice_invoke(const ::std::string&, + ::Ice::AsyncResultPtr iceI_begin_ice_invoke(const ::std::string&, ::Ice::OperationMode, const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&, const ::Ice::Context&, @@ -1425,11 +1425,11 @@ private: const ::Ice::LocalObjectPtr&, bool = false); - ::Ice::AsyncResultPtr __begin_ice_getConnection(const ::IceInternal::CallbackBasePtr&, - const ::Ice::LocalObjectPtr&); + ::Ice::AsyncResultPtr iceI_begin_ice_getConnection(const ::IceInternal::CallbackBasePtr&, + const ::Ice::LocalObjectPtr&); - ::Ice::AsyncResultPtr __begin_ice_flushBatchRequests(const ::IceInternal::CallbackBasePtr&, - const ::Ice::LocalObjectPtr&); + ::Ice::AsyncResultPtr iceI_begin_ice_flushBatchRequests(const ::IceInternal::CallbackBasePtr&, + const ::Ice::LocalObjectPtr&); void setup(const ::IceInternal::ReferencePtr&); friend class ::IceInternal::ProxyFactory; @@ -1559,7 +1559,7 @@ public: protected: - virtual ::IceProxy::Ice::Object* __newInstance() const = 0; + virtual ::IceProxy::Ice::Object* iceNewInstance() const = 0; }; ICE_API bool proxyIdentityLess(const ObjectPrx&, const ObjectPrx&); @@ -1611,8 +1611,8 @@ namespace IceInternal template<typename T, typename U> inline bool operator==(const ProxyHandle<T>& lhs, const ProxyHandle<U>& rhs) { - ::IceProxy::Ice::Object* l = lhs.__upCast(); - ::IceProxy::Ice::Object* r = rhs.__upCast(); + ::IceProxy::Ice::Object* l = lhs.iceUpCast(); + ::IceProxy::Ice::Object* r = rhs.iceUpCast(); if(l && r) { return *l == *r; @@ -1632,8 +1632,8 @@ inline bool operator!=(const ProxyHandle<T>& lhs, const ProxyHandle<U>& rhs) template<typename T, typename U> inline bool operator<(const ProxyHandle<T>& lhs, const ProxyHandle<U>& rhs) { - ::IceProxy::Ice::Object* l = lhs.__upCast(); - ::IceProxy::Ice::Object* r = rhs.__upCast(); + ::IceProxy::Ice::Object* l = lhs.iceUpCast(); + ::IceProxy::Ice::Object* r = rhs.iceUpCast(); if(l && r) { return *l < *r; @@ -1677,7 +1677,7 @@ checkedCastImpl(const ::Ice::ObjectPrx& b, const ::Ice::Context& context) if(b->ice_isA(T::ice_staticId(), context)) { d = new T; - d->__copyFrom(b); + d->iceCopyFrom(b); } } return d; @@ -1695,7 +1695,7 @@ uncheckedCastImpl(const ::Ice::ObjectPrx& b) if(!d) { d = new T; - d->__copyFrom(b); + d->iceCopyFrom(b); } } return d; @@ -1744,7 +1744,7 @@ checkedCastImpl(const ::Ice::ObjectPrx& b, const std::string& f, const ::Ice::Co if(bb) { d = new T; - d->__copyFrom(bb); + d->iceCopyFrom(bb); } return d; } @@ -1759,7 +1759,7 @@ uncheckedCastImpl(const ::Ice::ObjectPrx& b, const std::string& f) ::Ice::ObjectPrx bb = b->ice_facet(f); d = new T; - d->__copyFrom(bb); + d->iceCopyFrom(bb); } return d; } @@ -1977,7 +1977,7 @@ public: { try { - result->getProxy()->__end(result, result->getOperation()); + result->getProxy()->iceEnd(result, result->getOperation()); } catch(const ::Ice::Exception& ex) { @@ -2016,7 +2016,7 @@ public: { try { - result->getProxy()->__end(result, result->getOperation()); + result->getProxy()->iceEnd(result, result->getOperation()); } catch(const ::Ice::Exception& ex) { @@ -2055,21 +2055,21 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const { - bool __ret; + bool iceRet; try { - __ret = __result->getProxy()->end_ice_isA(__result); + iceRet = iceResult->getProxy()->end_ice_isA(iceResult); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(iceResult, ex); return; } if(_response) { - (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret); + (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(iceRet); } } @@ -2094,22 +2094,22 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const { - bool __ret; + bool iceRet; try { - __ret = __result->getProxy()->end_ice_isA(__result); + iceRet = iceResult->getProxy()->end_ice_isA(iceResult); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(iceResult, ex); return; } if(_response) { - (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret, - CT::dynamicCast(__result->getCookie())); + (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(iceRet, + CT::dynamicCast(iceResult->getCookie())); } } @@ -2168,21 +2168,21 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const { - ::std::vector< ::std::string> __ret; + ::std::vector< ::std::string> iceRet; try { - __ret = __result->getProxy()->end_ice_ids(__result); + iceRet = iceResult->getProxy()->end_ice_ids(iceResult); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(iceResult, ex); return; } if(_response) { - (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret); + (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(iceRet); } } @@ -2207,22 +2207,22 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const { - ::std::vector< ::std::string> __ret; + ::std::vector< ::std::string> iceRet; try { - __ret = __result->getProxy()->end_ice_ids(__result); + iceRet = iceResult->getProxy()->end_ice_ids(iceResult); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(iceResult, ex); return; } if(_response) { - (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret, - CT::dynamicCast(__result->getCookie())); + (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(iceRet, + CT::dynamicCast(iceResult->getCookie())); } } @@ -2247,21 +2247,21 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const { - ::std::string __ret; + ::std::string iceRet; try { - __ret = __result->getProxy()->end_ice_id(__result); + iceRet = iceResult->getProxy()->end_ice_id(iceResult); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(iceResult, ex); return; } if(_response) { - (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret); + (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(iceRet); } } @@ -2286,22 +2286,22 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const { - ::std::string __ret; + ::std::string iceRet; try { - __ret = __result->getProxy()->end_ice_id(__result); + iceRet = iceResult->getProxy()->end_ice_id(iceResult); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(iceResult, ex); return; } if(_response) { - (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret, - CT::dynamicCast(__result->getCookie())); + (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(iceRet, + CT::dynamicCast(iceResult->getCookie())); } } @@ -2332,39 +2332,39 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const { if(_response) { - bool __ok; + bool iceOk; std::vector< ::Ice::Byte> outParams; try { - __ok = __result->getProxy()->end_ice_invoke(outParams, __result); + iceOk = iceResult->getProxy()->end_ice_invoke(outParams, iceResult); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(iceResult, ex); return; } - (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ok, outParams); + (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(iceOk, outParams); } else { - bool __ok; + bool iceOk; std::pair<const ::Ice::Byte*, const::Ice::Byte*> outParams; try { - __ok = __result->getProxy()->___end_ice_invoke(outParams, __result); + iceOk = iceResult->getProxy()->iceI_end_ice_invoke(outParams, iceResult); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(iceResult, ex); return; } if(_responseArray) { - (::IceInternal::CallbackNC<T>::_callback.get()->*_responseArray)(__ok, outParams); + (::IceInternal::CallbackNC<T>::_callback.get()->*_responseArray)(iceOk, outParams); } } } @@ -2397,44 +2397,44 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const { if(_response) { - bool __ok; + bool iceOk; std::vector< ::Ice::Byte> outParams; try { - __ok = __result->getProxy()->end_ice_invoke(outParams, __result); + iceOk = iceResult->getProxy()->end_ice_invoke(outParams, iceResult); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(iceResult, ex); return; } - (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ok, + (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(iceOk, outParams, - CT::dynamicCast(__result->getCookie())); + CT::dynamicCast(iceResult->getCookie())); } else { - bool __ok; + bool iceOk; std::pair<const ::Ice::Byte*, const::Ice::Byte*> outParams; try { - __ok = __result->getProxy()->___end_ice_invoke(outParams, __result); + iceOk = iceResult->getProxy()->iceI_end_ice_invoke(outParams, iceResult); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(iceResult, ex); return; } if(_responseArray) { - (::IceInternal::Callback<T, CT>::_callback.get()->*_responseArray)(__ok, + (::IceInternal::Callback<T, CT>::_callback.get()->*_responseArray)(iceOk, outParams, CT::dynamicCast( - __result->getCookie())); + iceResult->getCookie())); } } } @@ -2463,21 +2463,21 @@ public: } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const { - ::Ice::ConnectionPtr __ret; + ::Ice::ConnectionPtr iceRet; try { - __ret = __result->getProxy()->end_ice_getConnection(__result); + iceRet = iceResult->getProxy()->end_ice_getConnection(iceResult); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(iceResult, ex); return; } if(_response) { - (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret); + (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(iceRet); } } @@ -2503,22 +2503,22 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const { - ::Ice::ConnectionPtr __ret; + ::Ice::ConnectionPtr iceRet; try { - __ret = __result->getProxy()->end_ice_getConnection(__result); + iceRet = iceResult->getProxy()->end_ice_getConnection(iceResult); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(iceResult, ex); return; } if(_response) { - (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret, - CT::dynamicCast(__result->getCookie())); + (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(iceRet, + CT::dynamicCast(iceResult->getCookie())); } } diff --git a/cpp/include/Ice/ProxyHandle.h b/cpp/include/Ice/ProxyHandle.h index 628fb2b460b..0e39dfa9ef6 100644 --- a/cpp/include/Ice/ProxyHandle.h +++ b/cpp/include/Ice/ProxyHandle.h @@ -125,7 +125,7 @@ public: if(this->_ptr) { - upCast(this->_ptr)->__incRef(); + upCast(this->_ptr)->iceIncRef(); } } @@ -136,7 +136,7 @@ public: if(this->_ptr) { - upCast(this->_ptr)->__incRef(); + upCast(this->_ptr)->iceIncRef(); } } @@ -147,7 +147,7 @@ public: if(this->_ptr) { - upCast(this->_ptr)->__incRef(); + upCast(this->_ptr)->iceIncRef(); } } @@ -157,7 +157,7 @@ public: if(this->_ptr) { - upCast(this->_ptr)->__incRef(); + upCast(this->_ptr)->iceIncRef(); } } @@ -165,7 +165,7 @@ public: { if(this->_ptr) { - upCast(this->_ptr)->__decRef(); + upCast(this->_ptr)->iceDecRef(); } } @@ -175,12 +175,12 @@ public: { if(p) { - upCast(p)->__incRef(); + upCast(p)->iceIncRef(); } if(this->_ptr) { - upCast(this->_ptr)->__decRef(); + upCast(this->_ptr)->iceDecRef(); } this->_ptr = p; @@ -195,12 +195,12 @@ public: { if(r._ptr) { - upCast(r._ptr)->__incRef(); + upCast(r._ptr)->iceIncRef(); } if(this->_ptr) { - upCast(this->_ptr)->__decRef(); + upCast(this->_ptr)->iceDecRef(); } this->_ptr = r._ptr; @@ -215,12 +215,12 @@ public: { if(r._ptr) { - upCast(r._ptr)->__incRef(); + upCast(r._ptr)->iceIncRef(); } if(this->_ptr) { - upCast(this->_ptr)->__decRef(); + upCast(this->_ptr)->iceDecRef(); } this->_ptr = r._ptr; @@ -234,12 +234,12 @@ public: { if(r._ptr) { - upCast(r._ptr)->__incRef(); + upCast(r._ptr)->iceIncRef(); } if(this->_ptr) { - upCast(this->_ptr)->__decRef(); + upCast(this->_ptr)->iceDecRef(); } this->_ptr = r._ptr; @@ -247,7 +247,7 @@ public: return *this; } - ::IceProxy::Ice::Object* __upCast() const + ::IceProxy::Ice::Object* iceUpCast() const { return upCast(this->_ptr); } diff --git a/cpp/include/Ice/SlicedData.h b/cpp/include/Ice/SlicedData.h index dcd322b661b..beb09947d90 100644 --- a/cpp/include/Ice/SlicedData.h +++ b/cpp/include/Ice/SlicedData.h @@ -74,7 +74,7 @@ public: const SliceInfoSeq slices; #ifndef ICE_CPP11_MAPPING - void __gcVisitMembers(IceInternal::GCVisitor&); + void iceGcVisitMembers(IceInternal::GCVisitor&); #endif }; @@ -97,8 +97,8 @@ public: SlicedDataPtr getSlicedData() const; #ifdef ICE_CPP11_MAPPING - virtual void __write(::Ice::OutputStream*) const override; - virtual void __read(::Ice::InputStream*) override; + virtual void iceWrite(::Ice::OutputStream*) const override; + virtual void iceRead(::Ice::InputStream*) override; virtual std::string ice_id() const override; std::shared_ptr<UnknownSlicedValue> ice_clone() const; @@ -107,10 +107,10 @@ protected: virtual std::shared_ptr<Value> cloneImpl() const override; #else - virtual void __gcVisitMembers(IceInternal::GCVisitor&); + virtual void iceGcVisitMembers(IceInternal::GCVisitor&); - virtual void __write(::Ice::OutputStream*) const; - virtual void __read(::Ice::InputStream*); + virtual void iceWrite(::Ice::OutputStream*) const; + virtual void iceRead(::Ice::InputStream*); #endif private: diff --git a/cpp/include/Ice/Value.h b/cpp/include/Ice/Value.h index b2c4b4f2b57..5801c195913 100644 --- a/cpp/include/Ice/Value.h +++ b/cpp/include/Ice/Value.h @@ -29,8 +29,8 @@ public: virtual void ice_preMarshal(); virtual void ice_postUnmarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void iceWrite(Ice::OutputStream*) const; + virtual void iceRead(Ice::InputStream*); virtual std::string ice_id() const; static const std::string& ice_staticId(); @@ -41,8 +41,8 @@ protected: virtual std::shared_ptr<Value> cloneImpl() const = 0; - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void iceWriteImpl(Ice::OutputStream*) const {} + virtual void iceReadImpl(Ice::InputStream*) {} }; template<typename T, typename Base> class ValueHelper : public Base @@ -70,20 +70,20 @@ protected: return std::make_shared<T>(static_cast<const T&>(*this)); } - virtual void __writeImpl(Ice::OutputStream* os) const override + virtual void iceWriteImpl(Ice::OutputStream* os) const override { os->startSlice(T::ice_staticId(), -1, std::is_same<Base, Ice::Value>::value ? true : false); Ice::StreamWriter<T, Ice::OutputStream>::write(os, static_cast<const T&>(*this)); os->endSlice(); - Base::__writeImpl(os); + Base::iceWriteImpl(os); } - virtual void __readImpl(Ice::InputStream* is) override + virtual void iceReadImpl(Ice::InputStream* is) override { is->startSlice(); Ice::StreamReader<T, Ice::InputStream>::read(is, static_cast<T&>(*this)); is->endSlice(); - Base::__readImpl(is); + Base::iceReadImpl(is); } }; diff --git a/cpp/include/IceUtil/Handle.h b/cpp/include/IceUtil/Handle.h index 91a58be60f0..19991681cbc 100644 --- a/cpp/include/IceUtil/Handle.h +++ b/cpp/include/IceUtil/Handle.h @@ -154,7 +154,7 @@ public: if(this->_ptr) { - this->_ptr->__incRef(); + this->_ptr->iceIncRef(); } } @@ -165,7 +165,7 @@ public: if(this->_ptr) { - this->_ptr->__incRef(); + this->_ptr->iceIncRef(); } } @@ -175,7 +175,7 @@ public: if(this->_ptr) { - this->_ptr->__incRef(); + this->_ptr->iceIncRef(); } } @@ -183,7 +183,7 @@ public: { if(this->_ptr) { - this->_ptr->__decRef(); + this->_ptr->iceDecRef(); } } @@ -193,7 +193,7 @@ public: { if(p) { - p->__incRef(); + p->iceIncRef(); } T* ptr = this->_ptr; @@ -201,7 +201,7 @@ public: if(ptr) { - ptr->__decRef(); + ptr->iceDecRef(); } } return *this; @@ -214,7 +214,7 @@ public: { if(r._ptr) { - r._ptr->__incRef(); + r._ptr->iceIncRef(); } T* ptr = this->_ptr; @@ -222,7 +222,7 @@ public: if(ptr) { - ptr->__decRef(); + ptr->iceDecRef(); } } return *this; @@ -234,7 +234,7 @@ public: { if(r._ptr) { - r._ptr->__incRef(); + r._ptr->iceIncRef(); } T* ptr = this->_ptr; @@ -242,7 +242,7 @@ public: if(ptr) { - ptr->__decRef(); + ptr->iceDecRef(); } } return *this; diff --git a/cpp/include/IceUtil/Optional.h b/cpp/include/IceUtil/Optional.h index 60493e30fe3..c7edf344ee8 100644 --- a/cpp/include/IceUtil/Optional.h +++ b/cpp/include/IceUtil/Optional.h @@ -143,7 +143,7 @@ public: std::swap(_value, other._value); } - void __setIsSet() + void iceSetIsSet() { _isSet = true; } diff --git a/cpp/include/IceUtil/Shared.h b/cpp/include/IceUtil/Shared.h index 756b10e5f22..b9971c3d855 100644 --- a/cpp/include/IceUtil/Shared.h +++ b/cpp/include/IceUtil/Shared.h @@ -45,13 +45,13 @@ public: return *this; } - void __incRef() + void iceIncRef() { assert(_ref >= 0); ++_ref; } - void __decRef() + void iceDecRef() { assert(_ref > 0); if(--_ref == 0) @@ -63,12 +63,12 @@ public: } } - int __getRef() const + int iceGetRef() const { return _ref; } - void __setNoDelete(bool b) + void iceSetNoDelete(bool b) { _noDelete = b; } @@ -101,22 +101,22 @@ public: return *this; } - virtual void __incRef(); - virtual void __decRef(); - virtual int __getRef() const; - virtual void __setNoDelete(bool); + virtual void iceIncRef(); + virtual void iceDecRef(); + virtual int iceGetRef() const; + virtual void iceSetNoDelete(bool); - void __setFlag(unsigned char flag) + void iceSetFlag(unsigned char flag) { _flags |= flag; } - void __clearFlag(unsigned char flag) + void iceClearFlag(unsigned char flag) { _flags &= ~flag; } - bool __hasFlag(unsigned char flag) + bool iceHasFlag(unsigned char flag) { return (_flags & flag) > 0; } diff --git a/cpp/src/Glacier2/SessionRouterI.cpp b/cpp/src/Glacier2/SessionRouterI.cpp index 9f774b79a8e..e494f88839a 100644 --- a/cpp/src/Glacier2/SessionRouterI.cpp +++ b/cpp/src/Glacier2/SessionRouterI.cpp @@ -678,7 +678,7 @@ SessionRouterI::SessionRouterI(const InstancePtr& instance, { if(_sessionThread) { - __setNoDelete(true); + iceSetNoDelete(true); try { _sessionThread->start(); @@ -687,10 +687,10 @@ SessionRouterI::SessionRouterI(const InstancePtr& instance, { _sessionThread->destroy(); _sessionThread = 0; - __setNoDelete(false); + iceSetNoDelete(false); throw; } - __setNoDelete(false); + iceSetNoDelete(false); } try diff --git a/cpp/src/Ice/AsyncResult.cpp b/cpp/src/Ice/AsyncResult.cpp index 60e5ac65773..42e58e945f7 100644 --- a/cpp/src/Ice/AsyncResult.cpp +++ b/cpp/src/Ice/AsyncResult.cpp @@ -24,9 +24,9 @@ AsyncResult::~AsyncResult() } void -AsyncResult::__check(const AsyncResultPtr& r, const IceProxy::Ice::Object* prx, const string& operation) +AsyncResult::iceCheck(const AsyncResultPtr& r, const IceProxy::Ice::Object* prx, const string& operation) { - __check(r, operation); + iceCheck(r, operation); if(r->getProxy().get() != prx) { throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "Proxy for call to end_" + operation + @@ -36,9 +36,9 @@ AsyncResult::__check(const AsyncResultPtr& r, const IceProxy::Ice::Object* prx, } void -AsyncResult::__check(const AsyncResultPtr& r, const Ice::Communicator* com, const string& operation) +AsyncResult::iceCheck(const AsyncResultPtr& r, const Ice::Communicator* com, const string& operation) { - __check(r, operation); + iceCheck(r, operation); if(r->getCommunicator().get() != com) { throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "Communicator for call to end_" + operation + @@ -48,9 +48,9 @@ AsyncResult::__check(const AsyncResultPtr& r, const Ice::Communicator* com, cons } void -AsyncResult::__check(const AsyncResultPtr& r, const Ice::Connection* con, const string& operation) +AsyncResult::iceCheck(const AsyncResultPtr& r, const Ice::Connection* con, const string& operation) { - __check(r, operation); + iceCheck(r, operation); if(r->getConnection().get() != con) { throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "Connection for call to end_" + operation + @@ -60,7 +60,7 @@ AsyncResult::__check(const AsyncResultPtr& r, const Ice::Connection* con, const } void -AsyncResult::__check(const AsyncResultPtr& r, const string& operation) +AsyncResult::iceCheck(const AsyncResultPtr& r, const string& operation) { if(!r) { diff --git a/cpp/src/Ice/CommunicatorI.cpp b/cpp/src/Ice/CommunicatorI.cpp index 99c332f629e..3c69a86bbc2 100644 --- a/cpp/src/Ice/CommunicatorI.cpp +++ b/cpp/src/Ice/CommunicatorI.cpp @@ -204,7 +204,7 @@ Ice::CommunicatorI::getValueFactoryManager() const namespace { -const ::std::string __flushBatchRequests_name = "flushBatchRequests"; +const ::std::string iceC_flushBatchRequests_name = "flushBatchRequests"; } @@ -230,7 +230,7 @@ Ice::CommunicatorI::flushBatchRequestsAsync(function<void(exception_ptr)> ex, fu } }; auto outAsync = make_shared<CommunicatorFlushBatchLambda>(_instance, ex, sent); - outAsync->invoke(__flushBatchRequests_name); + outAsync->invoke(iceC_flushBatchRequests_name); return [outAsync]() { outAsync->cancel(); }; } @@ -245,24 +245,24 @@ Ice::CommunicatorI::flushBatchRequests() AsyncResultPtr Ice::CommunicatorI::begin_flushBatchRequests() { - return __begin_flushBatchRequests(::IceInternal::__dummyCallback, 0); + return iceI_begin_flushBatchRequests(::IceInternal::dummyCallback, 0); } AsyncResultPtr Ice::CommunicatorI::begin_flushBatchRequests(const CallbackPtr& cb, const LocalObjectPtr& cookie) { - return __begin_flushBatchRequests(cb, cookie); + return iceI_begin_flushBatchRequests(cb, cookie); } AsyncResultPtr Ice::CommunicatorI::begin_flushBatchRequests(const Callback_Communicator_flushBatchRequestsPtr& cb, const LocalObjectPtr& cookie) { - return __begin_flushBatchRequests(cb, cookie); + return iceI_begin_flushBatchRequests(cb, cookie); } AsyncResultPtr -Ice::CommunicatorI::__begin_flushBatchRequests(const IceInternal::CallbackBasePtr& cb, const LocalObjectPtr& cookie) +Ice::CommunicatorI::iceI_begin_flushBatchRequests(const IceInternal::CallbackBasePtr& cb, const LocalObjectPtr& cookie) { class CommunicatorFlushBatchAsyncWithCallback : public CommunicatorFlushBatchAsync, public CallbackCompletion { @@ -285,7 +285,7 @@ Ice::CommunicatorI::__begin_flushBatchRequests(const IceInternal::CallbackBasePt virtual const std::string& getOperation() const { - return __flushBatchRequests_name; + return iceC_flushBatchRequests_name; } private: @@ -294,15 +294,15 @@ Ice::CommunicatorI::__begin_flushBatchRequests(const IceInternal::CallbackBasePt }; CommunicatorFlushBatchAsyncPtr result = new CommunicatorFlushBatchAsyncWithCallback(this, _instance, cb, cookie); - result->invoke(__flushBatchRequests_name); + result->invoke(iceC_flushBatchRequests_name); return result; } void Ice::CommunicatorI::end_flushBatchRequests(const AsyncResultPtr& r) { - AsyncResult::__check(r, this, __flushBatchRequests_name); - r->__wait(); + AsyncResult::iceCheck(r, this, iceC_flushBatchRequests_name); + r->iceWait(); } #endif diff --git a/cpp/src/Ice/CommunicatorI.h b/cpp/src/Ice/CommunicatorI.h index e75037bf72b..7ba37267523 100644 --- a/cpp/src/Ice/CommunicatorI.h +++ b/cpp/src/Ice/CommunicatorI.h @@ -113,7 +113,7 @@ private: friend ICE_API ::IceUtil::TimerPtr IceInternal::getInstanceTimer(const ::Ice::CommunicatorPtr&); #ifndef ICE_CPP11_MAPPING - AsyncResultPtr __begin_flushBatchRequests(const IceInternal::CallbackBasePtr&, const LocalObjectPtr&); + AsyncResultPtr iceI_begin_flushBatchRequests(const IceInternal::CallbackBasePtr&, const LocalObjectPtr&); #endif const ::IceInternal::InstancePtr _instance; diff --git a/cpp/src/Ice/ConnectRequestHandler.cpp b/cpp/src/Ice/ConnectRequestHandler.cpp index f68ec2c0770..7bfd9aaf265 100644 --- a/cpp/src/Ice/ConnectRequestHandler.cpp +++ b/cpp/src/Ice/ConnectRequestHandler.cpp @@ -316,7 +316,7 @@ ConnectRequestHandler::flushRequests() _requestHandler = ICE_MAKE_SHARED(ConnectionRequestHandler, _reference, _connection, _compress); for(set<Ice::ObjectPrxPtr>::const_iterator p = _proxies.begin(); p != _proxies.end(); ++p) { - (*p)->__updateRequestHandler(ICE_SHARED_FROM_THIS, _requestHandler); + (*p)->iceUpdateRequestHandler(ICE_SHARED_FROM_THIS, _requestHandler); } } diff --git a/cpp/src/Ice/ConnectionI.cpp b/cpp/src/Ice/ConnectionI.cpp index ce042d87ba5..75d40c3609b 100644 --- a/cpp/src/Ice/ConnectionI.cpp +++ b/cpp/src/Ice/ConnectionI.cpp @@ -44,7 +44,7 @@ Ice::LocalObject* Ice::upCast(ConnectionI* p) { return p; } namespace { -const ::std::string __flushBatchRequests_name = "flushBatchRequests"; +const ::std::string iceC_flushBatchRequests_name = "flushBatchRequests"; class TimeoutCallback : public IceUtil::TimerTask { @@ -718,7 +718,7 @@ Ice::ConnectionI::flushBatchRequestsAsync(::std::function<void(::std::exception_ } }; auto outAsync = make_shared<ConnectionFlushBatchLambda>(ICE_SHARED_FROM_THIS, _instance, ex, sent); - outAsync->invoke(__flushBatchRequests_name); + outAsync->invoke(iceC_flushBatchRequests_name); return [outAsync]() { outAsync->cancel(); }; } #else @@ -731,24 +731,24 @@ Ice::ConnectionI::flushBatchRequests() AsyncResultPtr Ice::ConnectionI::begin_flushBatchRequests() { - return __begin_flushBatchRequests(__dummyCallback, 0); + return iceI_begin_flushBatchRequests(dummyCallback, 0); } AsyncResultPtr Ice::ConnectionI::begin_flushBatchRequests(const CallbackPtr& cb, const LocalObjectPtr& cookie) { - return __begin_flushBatchRequests(cb, cookie); + return iceI_begin_flushBatchRequests(cb, cookie); } AsyncResultPtr Ice::ConnectionI::begin_flushBatchRequests(const Callback_Connection_flushBatchRequestsPtr& cb, const LocalObjectPtr& cookie) { - return __begin_flushBatchRequests(cb, cookie); + return iceI_begin_flushBatchRequests(cb, cookie); } AsyncResultPtr -Ice::ConnectionI::__begin_flushBatchRequests(const CallbackBasePtr& cb, const LocalObjectPtr& cookie) +Ice::ConnectionI::iceI_begin_flushBatchRequests(const CallbackBasePtr& cb, const LocalObjectPtr& cookie) { class ConnectionFlushBatchAsyncWithCallback : public ConnectionFlushBatchAsync, public CallbackCompletion { @@ -780,7 +780,7 @@ Ice::ConnectionI::__begin_flushBatchRequests(const CallbackBasePtr& cb, const Lo virtual const std::string& getOperation() const { - return __flushBatchRequests_name; + return iceC_flushBatchRequests_name; } private: @@ -790,15 +790,15 @@ Ice::ConnectionI::__begin_flushBatchRequests(const CallbackBasePtr& cb, const Lo }; ConnectionFlushBatchAsyncPtr result = new ConnectionFlushBatchAsyncWithCallback(this, _communicator, _instance, cb, cookie); - result->invoke(__flushBatchRequests_name); + result->invoke(iceC_flushBatchRequests_name); return result; } void Ice::ConnectionI::end_flushBatchRequests(const AsyncResultPtr& r) { - AsyncResult::__check(r, this, __flushBatchRequests_name); - r->__wait(); + AsyncResult::iceCheck(r, this, iceC_flushBatchRequests_name); + r->iceWait(); } #endif diff --git a/cpp/src/Ice/ConnectionI.h b/cpp/src/Ice/ConnectionI.h index ef277ee7c9a..32314d57d0b 100644 --- a/cpp/src/Ice/ConnectionI.h +++ b/cpp/src/Ice/ConnectionI.h @@ -307,7 +307,7 @@ private: void reap(); #ifndef ICE_CPP11_MAPPING - AsyncResultPtr __begin_flushBatchRequests(const IceInternal::CallbackBasePtr&, const LocalObjectPtr&); + AsyncResultPtr iceI_begin_flushBatchRequests(const IceInternal::CallbackBasePtr&, const LocalObjectPtr&); #endif Ice::CommunicatorPtr _communicator; diff --git a/cpp/src/Ice/DispatchInterceptor.cpp b/cpp/src/Ice/DispatchInterceptor.cpp index b9d87096848..e662ee9cdc9 100644 --- a/cpp/src/Ice/DispatchInterceptor.cpp +++ b/cpp/src/Ice/DispatchInterceptor.cpp @@ -15,7 +15,7 @@ using namespace Ice; using namespace IceInternal; bool -Ice::DispatchInterceptor::__dispatch(IceInternal::Incoming& in, const Current& /*current*/) +Ice::DispatchInterceptor::iceDispatch(IceInternal::Incoming& in, const Current& /*current*/) { try { diff --git a/cpp/src/Ice/Exception.cpp b/cpp/src/Ice/Exception.cpp index 95136f5339a..64fbfeb95bf 100644 --- a/cpp/src/Ice/Exception.cpp +++ b/cpp/src/Ice/Exception.cpp @@ -106,7 +106,7 @@ throwMarshalException(const char* file, int line, const string& reason) namespace { -const string __Ice__UserException_ids[] = +const string iceC_Ice_UserException_ids[] = { "::Ice::UserException" }; @@ -116,7 +116,7 @@ const string __Ice__UserException_ids[] = const std::string& Ice::UserException::ice_staticId() { - return __Ice__UserException_ids[0]; + return iceC_Ice_UserException_ids[0]; } #ifdef ICE_CPP11_MAPPING @@ -128,23 +128,23 @@ Ice::UserException::ice_clone() const #endif void -Ice::UserException::__write(::Ice::OutputStream* os) const +Ice::UserException::iceWrite(::Ice::OutputStream* os) const { os->startException(0); - __writeImpl(os); + iceWriteImpl(os); os->endException(); } void -Ice::UserException::__read(::Ice::InputStream* is) +Ice::UserException::iceRead(::Ice::InputStream* is) { is->startException(); - __readImpl(is); + iceReadImpl(is); is->endException(false); } bool -Ice::UserException::__usesClasses() const +Ice::UserException::iceUsesClasses() const { return false; } @@ -173,7 +173,7 @@ Ice::LocalException::ice_clone() const namespace { -const string __Ice__LocalException_ids[] = +const string iceC_Ice_LocalException_ids[] = { "::Ice::LocalException" }; @@ -183,7 +183,7 @@ const string __Ice__LocalException_ids[] = const std::string& Ice::LocalException::ice_staticId() { - return __Ice__LocalException_ids[0]; + return iceC_Ice_LocalException_ids[0]; } Ice::SystemException::SystemException(const char* file, int line) : @@ -209,7 +209,7 @@ Ice::SystemException::ice_clone() const namespace { -const string __Ice__SystemException_ids[] = +const string iceC_Ice_SystemException_ids[] = { "::Ice::SystemException" }; @@ -219,7 +219,7 @@ const string __Ice__SystemException_ids[] = const std::string& Ice::SystemException::ice_staticId() { - return __Ice__SystemException_ids[0]; + return iceC_Ice_SystemException_ids[0]; } void diff --git a/cpp/src/Ice/GCObject.cpp b/cpp/src/Ice/GCObject.cpp index a78ebbc8f50..fb2cb3d3f7b 100644 --- a/cpp/src/Ice/GCObject.cpp +++ b/cpp/src/Ice/GCObject.cpp @@ -142,10 +142,10 @@ DecreaseRefCounts::visit(GCObject* obj) GCCountMap::iterator p = _counts.find(obj); if(p == _counts.end()) { - _counts.insert(make_pair(obj, obj->__getRefUnsafe() - 1)); - if(obj->__hasFlag(GCObject::Collectable)) + _counts.insert(make_pair(obj, obj->iceGetRefUnsafe() - 1)); + if(obj->iceHasFlag(GCObject::Collectable)) { - obj->__gcVisitMembers(*this); + obj->iceGcVisitMembers(*this); } } else @@ -179,7 +179,7 @@ RestoreRefCountsIfReachable::visit(GCObject* obj) // reachable children. // _counts.erase(p); - obj->__gcVisitMembers(*this); + obj->iceGcVisitMembers(*this); } else if(p->second == 0) { @@ -189,7 +189,7 @@ RestoreRefCountsIfReachable::visit(GCObject* obj) // being visited again. // p->second = -1; - obj->__gcVisitMembers(*this); + obj->iceGcVisitMembers(*this); } else if(p->second > 0) { @@ -201,7 +201,7 @@ RestoreRefCountsIfReachable::visit(GCObject* obj) _counts.erase(p); _reachable = true; - obj->__gcVisitMembers(*this); + obj->iceGcVisitMembers(*this); _reachable = false; } return false; @@ -224,17 +224,17 @@ MarkCollectable::visit(GCObject* obj) // strong components of the graph. // - if(obj->__hasFlag(GCObject::Collectable)) + if(obj->iceHasFlag(GCObject::Collectable)) { return false; } - obj->__setFlag(GCObject::Collectable); + obj->iceSetFlag(GCObject::Collectable); _numbers[obj] = ++_counter; _p.push(obj); _s.push(obj); - obj->__gcVisitMembers(_neighborsVisitor); + obj->iceGcVisitMembers(_neighborsVisitor); if(_p.top() == obj) { @@ -243,7 +243,7 @@ MarkCollectable::visit(GCObject* obj) { o = _s.top(); _s.pop(); - o->__setFlag(GCObject::CycleMember); + o->iceSetFlag(GCObject::CycleMember); } while(o != obj); _p.pop(); @@ -259,7 +259,7 @@ MarkCollectable::visitNeighbor(GCObject* obj) { visit(obj); } - else if(!obj->__hasFlag(GCObject::CycleMember)) + else if(!obj->iceHasFlag(GCObject::CycleMember)) { while(_numbers[_p.top()] > p->second) { @@ -287,10 +287,10 @@ ClearCollectable::visit(GCObject* obj) // // Clear the collectable flag on the object graph. // - if(obj->__hasFlag(GCObject::Collectable)) + if(obj->iceHasFlag(GCObject::Collectable)) { - obj->__clearFlag(GCObject::Collectable | GCObject::CycleMember); - obj->__gcVisitMembers(*this); + obj->iceClearFlag(GCObject::Collectable | GCObject::CycleMember); + obj->iceGcVisitMembers(*this); } return false; } @@ -306,14 +306,14 @@ const unsigned char GCObject::Visiting = 8; // GCObject // void -IceInternal::GCObject::__incRef() +IceInternal::GCObject::iceIncRef() { IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(gcMutex); ++_ref; } void -IceInternal::GCObject::__decRef() +IceInternal::GCObject::iceDecRef() { IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(gcMutex); bool doDelete = false; @@ -323,15 +323,15 @@ IceInternal::GCObject::__decRef() // Try to collect the object each time its reference count is // decremented and only if it's part of a cycle. // - if(_ref > 1 && __hasFlag(CycleMember) && collect(lock)) + if(_ref > 1 && iceHasFlag(CycleMember) && collect(lock)) { return; } if(--_ref == 0) { - doDelete = !__hasFlag(NoDelete); - __setFlag(NoDelete); + doDelete = !iceHasFlag(NoDelete); + iceSetFlag(NoDelete); } lock.release(); @@ -342,21 +342,21 @@ IceInternal::GCObject::__decRef() } int -IceInternal::GCObject::__getRef() const +IceInternal::GCObject::iceGetRef() const { IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(gcMutex); return _ref; } void -IceInternal::GCObject::__setNoDelete(bool b) +IceInternal::GCObject::iceSetNoDelete(bool b) { IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(gcMutex); - IceUtil::Shared::__setNoDelete(b); + IceUtil::Shared::iceSetNoDelete(b); } bool -GCObject::__gcVisit(GCVisitor& v) +GCObject::iceGcVisit(GCVisitor& v) { return v.visit(this); } @@ -431,12 +431,12 @@ GCObject::collect(IceUtilInternal::MutexPtrLock<IceUtil::Mutex>& lock) // for(GCCountMap::const_iterator p = counts.begin(); p != counts.end(); ++p) { - p->first->__setFlag(NoDelete); - p->first->__clearFlag(CycleMember); // Disable cycle collection. + p->first->iceSetFlag(NoDelete); + p->first->iceClearFlag(CycleMember); // Disable cycle collection. } for(GCCountMap::const_iterator p = counts.begin(); p != counts.end(); ++p) { - p->first->__gcVisitMembers(clearMembers); + p->first->iceGcVisitMembers(clearMembers); } for(GCCountMap::const_iterator p = counts.begin(); p != counts.end(); ++p) { diff --git a/cpp/src/Ice/IPEndpointI.cpp b/cpp/src/Ice/IPEndpointI.cpp index 10983ccc672..b5017cbf596 100644 --- a/cpp/src/Ice/IPEndpointI.cpp +++ b/cpp/src/Ice/IPEndpointI.cpp @@ -495,7 +495,7 @@ IceInternal::EndpointHostResolver::EndpointHostResolver(const InstancePtr& insta _preferIPv6(instance->preferIPv6()), _destroyed(false) { - __setNoDelete(true); + iceSetNoDelete(true); try { updateObserver(); @@ -518,7 +518,7 @@ IceInternal::EndpointHostResolver::EndpointHostResolver(const InstancePtr& insta } throw; } - __setNoDelete(false); + iceSetNoDelete(false); } void diff --git a/cpp/src/Ice/Incoming.cpp b/cpp/src/Ice/Incoming.cpp index da4bb25cbc6..6db84652796 100644 --- a/cpp/src/Ice/Incoming.cpp +++ b/cpp/src/Ice/Incoming.cpp @@ -39,11 +39,11 @@ extern bool printStackTraces; #ifdef ICE_CPP11_MAPPING Ice::MarshaledResult::MarshaledResult(const Ice::Current& current) : - __os(make_shared<Ice::OutputStream>(current.adapter->getCommunicator(), Ice::currentProtocolEncoding)) + _os(make_shared<Ice::OutputStream>(current.adapter->getCommunicator(), Ice::currentProtocolEncoding)) { - __os->writeBlob(replyHdr, sizeof(replyHdr)); - __os->write(current.requestId); - __os->write(replyOK); + _os->writeBlob(replyHdr, sizeof(replyHdr)); + _os->write(current.requestId); + _os->write(replyOK); } #endif @@ -732,7 +732,7 @@ IceInternal::Incoming::invoke(const ServantManagerPtr& servantManager, InputStre // // Dispatch in the incoming call // - _servant->__dispatch(*this, _current); + _servant->iceDispatch(*this, _current); // // If the request was not dispatched asynchronously, send the response. diff --git a/cpp/src/Ice/InputStream.cpp b/cpp/src/Ice/InputStream.cpp index 132012b07b2..562bde737fd 100644 --- a/cpp/src/Ice/InputStream.cpp +++ b/cpp/src/Ice/InputStream.cpp @@ -1899,7 +1899,7 @@ Ice::InputStream::EncapsDecoder::unmarshal(Int index, const Ice::ValuePtr& v) // // Read the object. // - v->__read(_stream); + v->iceRead(_stream); // // Patch all instances now that the object is unmarshaled. @@ -2034,7 +2034,7 @@ Ice::InputStream::EncapsDecoder10::throwException(ICE_IN(ICE_USER_EXCEPTION_FACT } catch(UserException& ex) { - ex.__read(_stream); + ex.iceRead(_stream); if(usesClasses) { readPendingValues(); @@ -2329,7 +2329,7 @@ Ice::InputStream::EncapsDecoder11::throwException(ICE_IN(ICE_USER_EXCEPTION_FACT } catch(UserException& ex) { - ex.__read(_stream); + ex.iceRead(_stream); throw; // Never reached. diff --git a/cpp/src/Ice/Instance.cpp b/cpp/src/Ice/Instance.cpp index 304036dec90..08987b7dace 100644 --- a/cpp/src/Ice/Instance.cpp +++ b/cpp/src/Ice/Instance.cpp @@ -956,7 +956,7 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi { try { - __setNoDelete(true); + iceSetNoDelete(true); { IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(staticMutex); instanceList->push_back(this); @@ -1264,7 +1264,7 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi _retryQueue = new RetryQueue(this); - __setNoDelete(false); + iceSetNoDelete(false); } catch(...) { @@ -1273,7 +1273,7 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi instanceList->remove(this); } destroy(); - __setNoDelete(false); + iceSetNoDelete(false); throw; } } diff --git a/cpp/src/Ice/LocatorInfo.cpp b/cpp/src/Ice/LocatorInfo.cpp index 74f65e2d808..c80f773799d 100644 --- a/cpp/src/Ice/LocatorInfo.cpp +++ b/cpp/src/Ice/LocatorInfo.cpp @@ -351,7 +351,7 @@ IceInternal::LocatorInfo::RequestCallback::response(const LocatorInfoPtr& locato vector<EndpointIPtr> endpoints; if(proxy) { - ReferencePtr r = proxy->__reference(); + ReferencePtr r = proxy->iceReference(); if(_ref->isWellKnown() && !isSupported(_ref->getEncoding(), r->getEncoding())) { // @@ -482,7 +482,7 @@ IceInternal::LocatorInfo::Request::getEndpoints(const ReferencePtr& ref, vector<EndpointIPtr> endpoints; if(_proxy) { - ReferencePtr r = _proxy->__reference(); + ReferencePtr r = _proxy->iceReference(); if(!r->isIndirect()) { endpoints = r->getEndpoints(); @@ -924,7 +924,7 @@ IceInternal::LocatorInfo::finishRequest(const ReferencePtr& ref, const Ice::ObjectPrxPtr& proxy, bool notRegistered) { - if(!proxy || proxy->__reference()->isIndirect()) + if(!proxy || proxy->iceReference()->isIndirect()) { // // Remove the cached references of well-known objects for which we tried @@ -938,9 +938,9 @@ IceInternal::LocatorInfo::finishRequest(const ReferencePtr& ref, if(!ref->isWellKnown()) { - if(proxy && !proxy->__reference()->isIndirect()) // Cache the adapter endpoints. + if(proxy && !proxy->iceReference()->isIndirect()) // Cache the adapter endpoints. { - _table->addAdapterEndpoints(ref->getAdapterId(), proxy->__reference()->getEndpoints()); + _table->addAdapterEndpoints(ref->getAdapterId(), proxy->iceReference()->getEndpoints()); } else if(notRegistered) // If the adapter isn't registered anymore, remove it from the cache. { @@ -953,9 +953,9 @@ IceInternal::LocatorInfo::finishRequest(const ReferencePtr& ref, } else { - if(proxy && !proxy->__reference()->isWellKnown()) // Cache the well-known object reference. + if(proxy && !proxy->iceReference()->isWellKnown()) // Cache the well-known object reference. { - _table->addObjectReference(ref->getIdentity(), proxy->__reference()); + _table->addObjectReference(ref->getIdentity(), proxy->iceReference()); } else if(notRegistered) // If the well-known object isn't registered anymore, remove it from the cache. { diff --git a/cpp/src/Ice/LoggerUtil.cpp b/cpp/src/Ice/LoggerUtil.cpp index 13dd1eae363..f58397d0fc9 100644 --- a/cpp/src/Ice/LoggerUtil.cpp +++ b/cpp/src/Ice/LoggerUtil.cpp @@ -30,7 +30,7 @@ Ice::LoggerOutputBase::str() const } ostringstream& -Ice::LoggerOutputBase::__str() +Ice::LoggerOutputBase::iceStr() { return _str; } @@ -38,7 +38,7 @@ Ice::LoggerOutputBase::__str() Ice::LoggerOutputBase& Ice::operator<<(Ice::LoggerOutputBase& out, ios_base& (*val)(ios_base&)) { - out.__str() << val; + out.iceStr() << val; return out; } @@ -47,11 +47,11 @@ Ice::loggerInsert(Ice::LoggerOutputBase& out, const IceUtil::Exception& ex) { if(IceUtilInternal::printStackTraces) { - out.__str() << ex.what() << '\n' << ex.ice_stackTrace(); + out.iceStr() << ex.what() << '\n' << ex.ice_stackTrace(); } else { - out.__str() << ex.what(); + out.iceStr() << ex.what(); } return out; } @@ -71,12 +71,12 @@ Ice::Trace::~Trace() void Ice::Trace::flush() { - string s = __str().str(); + string s = iceStr().str(); if(!s.empty()) { _logger->trace(_category, s); } - __str().str(""); + iceStr().str(""); } diff --git a/cpp/src/Ice/Object.cpp b/cpp/src/Ice/Object.cpp index 197c54e1918..2ffdc88901d 100644 --- a/cpp/src/Ice/Object.cpp +++ b/cpp/src/Ice/Object.cpp @@ -27,7 +27,7 @@ const Current noExplicitCurrent = Current(); Object* Ice::upCast(Object* p) { return p; } void -Ice::__patch(ObjectPtr& obj, const ObjectPtr& v) +Ice::icePatch(ObjectPtr& obj, const ObjectPtr& v) { obj = v; } @@ -48,7 +48,7 @@ Ice::Object::operator<(const Object& r) const namespace { -const string __Ice__Object_ids[] = +const string iceC_Ice_Object_ids[] = { "::Ice::Object" }; @@ -74,7 +74,7 @@ Ice::Object::ice_isA(string s, const Current&) const Ice::Object::ice_isA(const string& s, const Current&) const #endif { - return s == __Ice__Object_ids[0]; + return s == iceC_Ice_Object_ids[0]; } void @@ -86,7 +86,7 @@ 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>(&iceC_Ice_Object_ids[0], &iceC_Ice_Object_ids[1]); } #ifdef ICE_CPP11_MAPPING @@ -96,13 +96,13 @@ const string& #endif Ice::Object::ice_id(const Current&) const { - return __Ice__Object_ids[0]; + return iceC_Ice_Object_ids[0]; } const ::std::string& Ice::Object::ice_staticId() { - return __Ice__Object_ids[0]; + return iceC_Ice_Object_ids[0]; } #ifndef ICE_CPP11_MAPPING @@ -115,56 +115,56 @@ Ice::Object::ice_clone() const #endif bool -Ice::Object::___ice_isA(Incoming& __inS, const Current& __current) +Ice::Object::iceD_ice_isA(Incoming& iceInS, const Current& iceCurrent) { - InputStream* __is = __inS.startReadParams(); - string __id; - __is->read(__id, false); - __inS.endReadParams(); + InputStream* iceIs = iceInS.startReadParams(); + string iceId; + iceIs->read(iceId, false); + iceInS.endReadParams(); #ifdef ICE_CPP11_MAPPING - bool __ret = ice_isA(move(__id), __current); + bool iceRet = ice_isA(move(iceId), iceCurrent); #else - bool __ret = ice_isA(__id, __current); + bool iceRet = ice_isA(iceId, iceCurrent); #endif - OutputStream* __os = __inS.startWriteParams(); - __os->write(__ret); - __inS.endWriteParams(); + OutputStream* iceOs = iceInS.startWriteParams(); + iceOs->write(iceRet); + iceInS.endWriteParams(); return false; } bool -Ice::Object::___ice_ping(Incoming& __inS, const Current& __current) +Ice::Object::iceD_ice_ping(Incoming& iceInS, const Current& iceCurrent) { - __inS.readEmptyParams(); - ice_ping(__current); - __inS.writeEmptyParams(); + iceInS.readEmptyParams(); + ice_ping(iceCurrent); + iceInS.writeEmptyParams(); return false; } bool -Ice::Object::___ice_ids(Incoming& __inS, const Current& __current) +Ice::Object::iceD_ice_ids(Incoming& iceInS, const Current& iceCurrent) { - __inS.readEmptyParams(); - vector<string> __ret = ice_ids(__current); - OutputStream* __os = __inS.startWriteParams(); - __os->write(&__ret[0], &__ret[0] + __ret.size(), false); - __inS.endWriteParams(); + iceInS.readEmptyParams(); + vector<string> iceRet = ice_ids(iceCurrent); + OutputStream* iceOs = iceInS.startWriteParams(); + iceOs->write(&iceRet[0], &iceRet[0] + iceRet.size(), false); + iceInS.endWriteParams(); return false; } bool -Ice::Object::___ice_id(Incoming& __inS, const Current& __current) +Ice::Object::iceD_ice_id(Incoming& iceInS, const Current& iceCurrent) { - __inS.readEmptyParams(); - string __ret = ice_id(__current); - OutputStream* __os = __inS.startWriteParams(); - __os->write(__ret, false); - __inS.endWriteParams(); + iceInS.readEmptyParams(); + string iceRet = ice_id(iceCurrent); + OutputStream* iceOs = iceInS.startWriteParams(); + iceOs->write(iceRet, false); + iceInS.endWriteParams(); return false; } -string Ice::Object::__all[] = +string Ice::Object::s_iceAll[] = { "ice_id", "ice_ids", @@ -193,7 +193,7 @@ Ice::Object::ice_dispatch(Request& request, const DispatchInterceptorAsyncCallba #endif try { - return __dispatch(in, in.getCurrent()); + return iceDispatch(in, in.getCurrent()); in.pop(); } catch(...) @@ -204,37 +204,37 @@ Ice::Object::ice_dispatch(Request& request, const DispatchInterceptorAsyncCallba } else { - return __dispatch(in, in.getCurrent()); + return iceDispatch(in, in.getCurrent()); } } bool -Ice::Object::__dispatch(Incoming& in, const Current& current) +Ice::Object::iceDispatch(Incoming& in, const Current& current) { - pair<string*, string*> r = equal_range(__all, __all + sizeof(__all) / sizeof(string), current.operation); + pair<string*, string*> r = equal_range(s_iceAll, s_iceAll + sizeof(s_iceAll) / 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 - s_iceAll) { 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: { @@ -256,18 +256,18 @@ Ice::Object::ice_postUnmarshal() } void -Ice::Object::__write(Ice::OutputStream* os) const +Ice::Object::iceWrite(Ice::OutputStream* os) const { os->startValue(0); - __writeImpl(os); + iceWriteImpl(os); os->endValue(); } void -Ice::Object::__read(Ice::InputStream* is) +Ice::Object::iceRead(Ice::InputStream* is) { is->startValue(); - __readImpl(is); + iceReadImpl(is); is->endValue(false); } @@ -311,7 +311,7 @@ operationModeToString(OperationMode mode) } void -Ice::Object::__checkMode(OperationMode expected, OperationMode received) +Ice::Object::iceCheckMode(OperationMode expected, OperationMode received) { if(expected != received) { @@ -330,19 +330,19 @@ Ice::Object::__checkMode(OperationMode expected, OperationMode received) else { Ice::MarshalException ex(__FILE__, __LINE__); - std::ostringstream __reason; - __reason << "unexpected operation mode. expected = " + std::ostringstream iceReason; + iceReason << "unexpected operation mode. expected = " << operationModeToString(expected) << " received = " << operationModeToString(received); - ex.reason = __reason.str(); + ex.reason = iceReason.str(); throw ex; } } } bool -Ice::Blobject::__dispatch(Incoming& in, const Current& current) +Ice::Blobject::iceDispatch(Incoming& in, const Current& current) { const Byte* inEncaps; Int sz; @@ -361,7 +361,7 @@ Ice::Blobject::__dispatch(Incoming& in, const Current& current) } bool -Ice::BlobjectArray::__dispatch(Incoming& in, const Current& current) +Ice::BlobjectArray::iceDispatch(Incoming& in, const Current& current) { pair<const Byte*, const Byte*> inEncaps; Int sz; @@ -381,7 +381,7 @@ Ice::BlobjectArray::__dispatch(Incoming& in, const Current& current) } bool -Ice::BlobjectAsync::__dispatch(Incoming& in, const Current& current) +Ice::BlobjectAsync::iceDispatch(Incoming& in, const Current& current) { const Byte* inEncaps; Int sz; @@ -409,7 +409,7 @@ Ice::BlobjectAsync::__dispatch(Incoming& in, const Current& current) } bool -Ice::BlobjectArrayAsync::__dispatch(Incoming& in, const Current& current) +Ice::BlobjectArrayAsync::iceDispatch(Incoming& in, const Current& current) { pair<const Byte*, const Byte*> inEncaps; Int sz; diff --git a/cpp/src/Ice/ObjectAdapterI.cpp b/cpp/src/Ice/ObjectAdapterI.cpp index 0631186769d..810d46cf7fb 100644 --- a/cpp/src/Ice/ObjectAdapterI.cpp +++ b/cpp/src/Ice/ObjectAdapterI.cpp @@ -537,7 +537,7 @@ Ice::ObjectAdapterI::findByProxy(const ObjectPrxPtr& proxy) const checkForDeactivation(); - ReferencePtr ref = proxy->__reference(); + ReferencePtr ref = proxy->iceReference(); return findFacet(ref->getIdentity(), ref->getFacet()); } @@ -712,7 +712,7 @@ Ice::ObjectAdapterI::isLocal(const ObjectPrxPtr& proxy) const // it can be called for AMI invocations if the proxy has no delegate set yet. // - ReferencePtr ref = proxy->__reference(); + ReferencePtr ref = proxy->iceReference(); if(ref->isWellKnown()) { // diff --git a/cpp/src/Ice/ObserverHelper.cpp b/cpp/src/Ice/ObserverHelper.cpp index 6b88a0d68de..3cf5b1e3da5 100644 --- a/cpp/src/Ice/ObserverHelper.cpp +++ b/cpp/src/Ice/ObserverHelper.cpp @@ -18,7 +18,7 @@ using namespace Ice::Instrumentation; IceInternal::InvocationObserver::InvocationObserver(const Ice::ObjectPrxPtr& proxy, const string& op, const Context& ctx) { - const CommunicatorObserverPtr& obsv = proxy->__reference()->getInstance()->initializationData().observer; + const CommunicatorObserverPtr& obsv = proxy->iceReference()->getInstance()->initializationData().observer; if(!obsv) { return; @@ -40,7 +40,7 @@ IceInternal::InvocationObserver::InvocationObserver(IceInternal::Instance* insta void IceInternal::InvocationObserver::attach(const Ice::ObjectPrxPtr& proxy, const string& op, const Context& ctx) { - const CommunicatorObserverPtr& obsv = proxy->__reference()->getInstance()->initializationData().observer; + const CommunicatorObserverPtr& obsv = proxy->iceReference()->getInstance()->initializationData().observer; if(!obsv) { return; diff --git a/cpp/src/Ice/OutgoingAsync.cpp b/cpp/src/Ice/OutgoingAsync.cpp index d7ffc2f4d6d..9569e9b92a9 100644 --- a/cpp/src/Ice/OutgoingAsync.cpp +++ b/cpp/src/Ice/OutgoingAsync.cpp @@ -474,7 +474,7 @@ OutgoingAsyncBase::throwLocalException() const } bool -OutgoingAsyncBase::__wait() +OutgoingAsyncBase::iceWait() { Lock sync(_m); if(_state & EndCalled) @@ -495,32 +495,32 @@ OutgoingAsyncBase::__wait() } Ice::InputStream* -OutgoingAsyncBase::__startReadParams() +OutgoingAsyncBase::iceStartReadParams() { _is.startEncapsulation(); return &_is; } void -OutgoingAsyncBase::__endReadParams() +OutgoingAsyncBase::iceEndReadParams() { _is.endEncapsulation(); } void -OutgoingAsyncBase::__readEmptyParams() +OutgoingAsyncBase::iceReadEmptyParams() { _is.skipEmptyEncapsulation(); } void -OutgoingAsyncBase::__readParamEncaps(const ::Ice::Byte*& encaps, ::Ice::Int& sz) +OutgoingAsyncBase::iceReadParamEncaps(const ::Ice::Byte*& encaps, ::Ice::Int& sz) { _is.readEncapsulation(encaps, sz); } void -OutgoingAsyncBase::__throwUserException() +OutgoingAsyncBase::iceThrowUserException() { try { @@ -574,7 +574,7 @@ ProxyOutgoingAsyncBase::exception(const Exception& exc) } _cachedConnection = 0; - if(_proxy->__reference()->getInvocationTimeout() == -2) + if(_proxy->iceReference()->getInvocationTimeout() == -2) { _instance->timer()->cancel(ICE_SHARED_FROM_THIS); } @@ -590,7 +590,7 @@ ProxyOutgoingAsyncBase::exception(const Exception& exc) // the retry interval is 0. This method can be called with the // connection locked so we can't just retry here. // - _instance->retryQueue()->add(ICE_SHARED_FROM_THIS, _proxy->__handleException(exc, _handler, _mode, _sent, _cnt)); + _instance->retryQueue()->add(ICE_SHARED_FROM_THIS, _proxy->iceHandleException(exc, _handler, _mode, _sent, _cnt)); return false; } catch(const Exception& ex) @@ -602,7 +602,7 @@ ProxyOutgoingAsyncBase::exception(const Exception& exc) void ProxyOutgoingAsyncBase::cancelable(const CancellationHandlerPtr& handler) { - if(_proxy->__reference()->getInvocationTimeout() == -2 && _cachedConnection) + if(_proxy->iceReference()->getInvocationTimeout() == -2 && _cachedConnection) { const int timeout = _cachedConnection->timeout(); if(timeout > 0) @@ -624,7 +624,7 @@ ProxyOutgoingAsyncBase::retryException(const Exception& ex) // require could end up waiting for the flush of the // connection to be done. // - _proxy->__updateRequestHandler(_handler, 0); // Clear request handler and always retry. + _proxy->iceUpdateRequestHandler(_handler, 0); // Clear request handler and always retry. _instance->retryQueue()->add(ICE_SHARED_FROM_THIS, 0); } catch(const Ice::Exception& exc) @@ -677,7 +677,7 @@ ProxyOutgoingAsyncBase::getCommunicator() const #endif ProxyOutgoingAsyncBase::ProxyOutgoingAsyncBase(const ObjectPrxPtr& prx) : - OutgoingAsyncBase(prx->__reference()->getInstance()), + OutgoingAsyncBase(prx->iceReference()->getInstance()), _proxy(prx), _mode(ICE_ENUM(OperationMode, Normal)), _cnt(0), @@ -696,7 +696,7 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread) { if(userThread) { - int invocationTimeout = _proxy->__reference()->getInvocationTimeout(); + int invocationTimeout = _proxy->iceReference()->getInvocationTimeout(); if(invocationTimeout > 0) { _instance->timer()->schedule(ICE_SHARED_FROM_THIS, IceUtil::Time::milliSeconds(invocationTimeout)); @@ -712,7 +712,7 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread) try { _sent = false; - _handler = _proxy->__getRequestHandler(); + _handler = _proxy->iceGetRequestHandler(); AsyncStatus status = _handler->sendAsyncRequest(ICE_SHARED_FROM_THIS); if(status & AsyncStatusSent) { @@ -736,7 +736,7 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread) } catch(const RetryException&) { - _proxy->__updateRequestHandler(_handler, 0); // Clear request handler and always retry. + _proxy->iceUpdateRequestHandler(_handler, 0); // Clear request handler and always retry. } catch(const Exception& ex) { @@ -745,7 +745,7 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread) _childObserver.failed(ex.ice_id()); _childObserver.detach(); } - int interval = _proxy->__handleException(ex, _handler, _mode, _sent, _cnt); + int interval = _proxy->iceHandleException(ex, _handler, _mode, _sent, _cnt); if(interval > 0) { _instance->retryQueue()->add(ICE_SHARED_FROM_THIS, interval); @@ -781,7 +781,7 @@ ProxyOutgoingAsyncBase::sentImpl(bool done) _sent = true; if(done) { - if(_proxy->__reference()->getInvocationTimeout() != -1) + if(_proxy->iceReference()->getInvocationTimeout() != -1) { _instance->timer()->cancel(ICE_SHARED_FROM_THIS); } @@ -792,7 +792,7 @@ ProxyOutgoingAsyncBase::sentImpl(bool done) bool ProxyOutgoingAsyncBase::exceptionImpl(const Exception& ex) { - if(_proxy->__reference()->getInvocationTimeout() != -1) + if(_proxy->iceReference()->getInvocationTimeout() != -1) { _instance->timer()->cancel(ICE_SHARED_FROM_THIS); } @@ -802,7 +802,7 @@ ProxyOutgoingAsyncBase::exceptionImpl(const Exception& ex) bool ProxyOutgoingAsyncBase::responseImpl(bool ok) { - if(_proxy->__reference()->getInvocationTimeout() != -1) + if(_proxy->iceReference()->getInvocationTimeout() != -1) { _instance->timer()->cancel(ICE_SHARED_FROM_THIS); } @@ -812,7 +812,7 @@ ProxyOutgoingAsyncBase::responseImpl(bool ok) void ProxyOutgoingAsyncBase::runTimerTask() { - if(_proxy->__reference()->getInvocationTimeout() == -2) + if(_proxy->iceReference()->getInvocationTimeout() == -2) { cancel(ConnectionTimeoutException(__FILE__, __LINE__)); } @@ -824,7 +824,7 @@ ProxyOutgoingAsyncBase::runTimerTask() OutgoingAsync::OutgoingAsync(const ObjectPrxPtr& prx, bool synchronous) : ProxyOutgoingAsyncBase(prx), - _encoding(getCompatibleEncoding(prx->__reference()->getEncoding())), + _encoding(getCompatibleEncoding(prx->iceReference()->getEncoding())), _synchronous(synchronous) { } @@ -832,12 +832,12 @@ OutgoingAsync::OutgoingAsync(const ObjectPrxPtr& prx, bool synchronous) : void OutgoingAsync::prepare(const string& operation, OperationMode mode, const Context& context) { - checkSupportedProtocol(getCompatibleProtocol(_proxy->__reference()->getProtocol())); + checkSupportedProtocol(getCompatibleProtocol(_proxy->iceReference()->getProtocol())); _mode = mode; _observer.attach(_proxy, operation, context); - switch(_proxy->__reference()->getMode()) + switch(_proxy->iceReference()->getMode()) { case Reference::ModeTwoway: case Reference::ModeOneway: @@ -850,12 +850,12 @@ OutgoingAsync::prepare(const string& operation, OperationMode mode, const Contex case Reference::ModeBatchOneway: case Reference::ModeBatchDatagram: { - _proxy->__getBatchRequestQueue()->prepareBatchRequest(&_os); + _proxy->iceGetBatchRequestQueue()->prepareBatchRequest(&_os); break; } } - Reference* ref = _proxy->__reference().get(); + Reference* ref = _proxy->iceReference().get(); _os.write(ref->getIdentity()); @@ -1068,7 +1068,7 @@ OutgoingAsync::invokeCollocated(CollocatedRequestHandler* handler) void OutgoingAsync::abort(const Exception& ex) { - const Reference::Mode mode = _proxy->__reference()->getMode(); + const Reference::Mode mode = _proxy->iceReference()->getMode(); if(mode == Reference::ModeBatchOneway || mode == Reference::ModeBatchDatagram) { // @@ -1076,7 +1076,7 @@ OutgoingAsync::abort(const Exception& ex) // must notify the connection about that we give up ownership // of the batch stream. // - _proxy->__getBatchRequestQueue()->abortBatchRequest(&_os); + _proxy->iceGetBatchRequestQueue()->abortBatchRequest(&_os); } ProxyOutgoingAsyncBase::abort(ex); @@ -1085,11 +1085,11 @@ OutgoingAsync::abort(const Exception& ex) void OutgoingAsync::invoke(const string& operation) { - const Reference::Mode mode = _proxy->__reference()->getMode(); + const Reference::Mode mode = _proxy->iceReference()->getMode(); if(mode == Reference::ModeBatchOneway || mode == Reference::ModeBatchDatagram) { _sentSynchronously = true; - _proxy->__getBatchRequestQueue()->finishBatchRequest(&_os, _proxy, operation); + _proxy->iceGetBatchRequestQueue()->finishBatchRequest(&_os, _proxy, operation); responseImpl(true); return; // Don't call sent/completed callback for batch AMI requests } @@ -1194,9 +1194,9 @@ ProxyFlushBatchAsync::invokeCollocated(CollocatedRequestHandler* handler) void ProxyFlushBatchAsync::invoke(const string& operation) { - checkSupportedProtocol(getCompatibleProtocol(_proxy->__reference()->getProtocol())); + checkSupportedProtocol(getCompatibleProtocol(_proxy->iceReference()->getProtocol())); _observer.attach(_proxy, operation, ::Ice::noExplicitContext); - _batchRequestNum = _proxy->__getBatchRequestQueue()->swap(&_os); + _batchRequestNum = _proxy->iceGetBatchRequestQueue()->swap(&_os); invokeImpl(true); // userThread = true } @@ -1496,7 +1496,7 @@ namespace // // Dummy class derived from CallbackBase -// We use this class for the __dummyCallback extern pointer in OutgoingAsync. In turn, +// We use this class for the dummyCallback extern pointer in OutgoingAsync. In turn, // this allows us to test whether the user supplied a null delegate instance to the // generated begin_ method without having to generate a separate test to throw IllegalArgumentException // in the inlined versions of the begin_ method. In other words, this reduces the amount of generated @@ -1550,7 +1550,7 @@ public: // versus the generated inline version of the begin_ method having // passed a pointer to the dummy delegate. // -CallbackBasePtr IceInternal::__dummyCallback = new DummyCallback; +CallbackBasePtr IceInternal::dummyCallback = new DummyCallback; CallbackBase::~CallbackBase() { diff --git a/cpp/src/Ice/OutputStream.cpp b/cpp/src/Ice/OutputStream.cpp index 4850b0f5474..7c7a2347664 100644 --- a/cpp/src/Ice/OutputStream.cpp +++ b/cpp/src/Ice/OutputStream.cpp @@ -800,7 +800,7 @@ Ice::OutputStream::write(const ObjectPrx& v) { if(v) { - v->__write(*this); + v->iceWrite(*this); } else { @@ -963,9 +963,9 @@ Ice::OutputStream::EncapsEncoder10::write(const UserException& v) // This allows reading the pending instances even if some part of // the exception was sliced. // - bool usesClasses = v.__usesClasses(); + bool usesClasses = v.iceUsesClasses(); _stream->write(usesClasses); - v.__write(_stream); + v.iceWrite(_stream); if(usesClasses) { writePendingValues(); @@ -1076,7 +1076,7 @@ Ice::OutputStream::EncapsEncoder10::writePendingValues() out << "unknown exception raised by ice_preMarshal"; } - p->first->__write(_stream); + p->first->iceWrite(_stream); } } _stream->writeSize(0); // Zero marker indicates end of sequence of sequences of instances. @@ -1151,7 +1151,7 @@ Ice::OutputStream::EncapsEncoder11::write(const ValuePtr& v) void Ice::OutputStream::EncapsEncoder11::write(const UserException& v) { - v.__write(_stream); + v.iceWrite(_stream); } void @@ -1395,5 +1395,5 @@ Ice::OutputStream::EncapsEncoder11::writeInstance(const ValuePtr& v) } _stream->writeSize(1); // Object instance marker. - v->__write(_stream); + v->iceWrite(_stream); } diff --git a/cpp/src/Ice/Proxy.cpp b/cpp/src/Ice/Proxy.cpp index 5555d4214a1..70db48fe6c9 100644 --- a/cpp/src/Ice/Proxy.cpp +++ b/cpp/src/Ice/Proxy.cpp @@ -68,11 +68,11 @@ operator==(const ObjectPrx& lhs, const ObjectPrx& rhs) } void -Ice::ObjectPrx::__ice_isA(const shared_ptr<IceInternal::OutgoingAsyncT<bool>>& outAsync, +Ice::ObjectPrx::iceI_ice_isA(const shared_ptr<IceInternal::OutgoingAsyncT<bool>>& outAsync, const string& typeId, const Context& ctx) { - __checkTwowayOnly(ice_isA_name); + iceCheckTwowayOnly(ice_isA_name); outAsync->invoke(ice_isA_name, OperationMode::Nonmutating, DefaultFormat, ctx, [&](Ice::OutputStream* os) { @@ -82,15 +82,15 @@ Ice::ObjectPrx::__ice_isA(const shared_ptr<IceInternal::OutgoingAsyncT<bool>>& o } void -Ice::ObjectPrx::__ice_ping(const shared_ptr<IceInternal::OutgoingAsyncT<void>>& outAsync, const Context& ctx) +Ice::ObjectPrx::iceI_ice_ping(const shared_ptr<IceInternal::OutgoingAsyncT<void>>& outAsync, const Context& ctx) { outAsync->invoke(ice_ping_name, OperationMode::Nonmutating, DefaultFormat, ctx, nullptr, nullptr); } void -Ice::ObjectPrx::__ice_ids(const shared_ptr<IceInternal::OutgoingAsyncT<vector<string>>>& outAsync, const Context& ctx) +Ice::ObjectPrx::iceI_ice_ids(const shared_ptr<IceInternal::OutgoingAsyncT<vector<string>>>& outAsync, const Context& ctx) { - __checkTwowayOnly(ice_ids_name); + iceCheckTwowayOnly(ice_ids_name); outAsync->invoke(ice_ids_name, OperationMode::Nonmutating, DefaultFormat, ctx, nullptr, nullptr, [](Ice::InputStream* stream) { @@ -101,9 +101,9 @@ Ice::ObjectPrx::__ice_ids(const shared_ptr<IceInternal::OutgoingAsyncT<vector<st } void -Ice::ObjectPrx::__ice_id(const shared_ptr<IceInternal::OutgoingAsyncT<string>>& outAsync, const Context& ctx) +Ice::ObjectPrx::iceI_ice_id(const shared_ptr<IceInternal::OutgoingAsyncT<string>>& outAsync, const Context& ctx) { - __checkTwowayOnly(ice_id_name); + iceCheckTwowayOnly(ice_id_name); outAsync->invoke(ice_id_name, OperationMode::Nonmutating, DefaultFormat, ctx, nullptr, nullptr, [](Ice::InputStream* stream) { @@ -114,19 +114,19 @@ Ice::ObjectPrx::__ice_id(const shared_ptr<IceInternal::OutgoingAsyncT<string>>& } void -Ice::ObjectPrx::__ice_getConnection(const shared_ptr<IceInternal::ProxyGetConnection>& outAsync) +Ice::ObjectPrx::iceGetConnection(const shared_ptr<IceInternal::ProxyGetConnection>& outAsync) { outAsync->invoke(ice_getConnection_name); } void -Ice::ObjectPrx::__ice_flushBatchRequests(const shared_ptr<IceInternal::ProxyFlushBatchAsync>& outAsync) +Ice::ObjectPrx::iceI_ice_flushBatchRequests(const shared_ptr<IceInternal::ProxyFlushBatchAsync>& outAsync) { outAsync->invoke(ice_flushBatchRequests_name); } void -Ice::ObjectPrx::__checkTwowayOnly(const string& name) const +Ice::ObjectPrx::iceCheckTwowayOnly(const string& name) const { // // No mutex lock necessary, there is nothing mutable in this operation. @@ -141,7 +141,7 @@ Ice::ObjectPrx::__checkTwowayOnly(const string& name) const shared_ptr<ObjectPrx> -Ice::ObjectPrx::__newInstance() const +Ice::ObjectPrx::iceNewInstance() const { return createProxy<ObjectPrx>(); } @@ -193,164 +193,164 @@ IceProxy::Ice::Object::operator<(const Object& r) const } Ice::AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_isA(const string& typeId, +IceProxy::Ice::Object::iceI_begin_ice_isA(const string& typeId, const Context& ctx, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync) { - __checkTwowayOnly(ice_isA_name, sync); - OutgoingAsyncPtr __result = new CallbackOutgoing(this, ice_isA_name, del, cookie, sync); + iceCheckTwowayOnly(ice_isA_name, sync); + OutgoingAsyncPtr iceResult = new CallbackOutgoing(this, ice_isA_name, del, cookie, sync); try { - __result->prepare(ice_isA_name, Nonmutating, ctx); - ::Ice::OutputStream* __os = __result->startWriteParams(DefaultFormat); - __os->write(typeId, false); - __result->endWriteParams(); - __result->invoke(ice_isA_name); + iceResult->prepare(ice_isA_name, Nonmutating, ctx); + ::Ice::OutputStream* iceOs = iceResult->startWriteParams(DefaultFormat); + iceOs->write(typeId, false); + iceResult->endWriteParams(); + iceResult->invoke(ice_isA_name); } - catch(const Exception& __ex) + catch(const Exception& iceEx) { - __result->abort(__ex); + iceResult->abort(iceEx); } - return __result; + return iceResult; } bool -IceProxy::Ice::Object::end_ice_isA(const AsyncResultPtr& __result) +IceProxy::Ice::Object::end_ice_isA(const AsyncResultPtr& iceResult) { - AsyncResult::__check(__result, this, ice_isA_name); - bool __ok = __result->__wait(); - if(!__ok) + AsyncResult::iceCheck(iceResult, this, ice_isA_name); + bool iceOk = iceResult->iceWait(); + if(!iceOk) { try { - __result->__throwUserException(); + iceResult->iceThrowUserException(); } - catch(const UserException& __ex) + catch(const UserException& iceEx) { - throw UnknownUserException(__FILE__, __LINE__, __ex.ice_id()); + throw UnknownUserException(__FILE__, __LINE__, iceEx.ice_id()); } } - bool __ret; - ::Ice::InputStream* __is = __result->__startReadParams(); - __is->read(__ret); - __result->__endReadParams(); - return __ret; + bool iceRet; + ::Ice::InputStream* iceIs = iceResult->iceStartReadParams(); + iceIs->read(iceRet); + iceResult->iceEndReadParams(); + return iceRet; } AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_ping(const Context& ctx, +IceProxy::Ice::Object::iceI_begin_ice_ping(const Context& ctx, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync) { - OutgoingAsyncPtr __result = new CallbackOutgoing(this, ice_ping_name, del, cookie, sync); + OutgoingAsyncPtr iceResult = new CallbackOutgoing(this, ice_ping_name, del, cookie, sync); try { - __result->prepare(ice_ping_name, Nonmutating, ctx); - __result->writeEmptyParams(); - __result->invoke(ice_ping_name); + iceResult->prepare(ice_ping_name, Nonmutating, ctx); + iceResult->writeEmptyParams(); + iceResult->invoke(ice_ping_name); } - catch(const Exception& __ex) + catch(const Exception& iceEx) { - __result->abort(__ex); + iceResult->abort(iceEx); } - return __result; + return iceResult; } void -IceProxy::Ice::Object::end_ice_ping(const AsyncResultPtr& __result) +IceProxy::Ice::Object::end_ice_ping(const AsyncResultPtr& iceResult) { - __end(__result, ice_ping_name); + iceEnd(iceResult, ice_ping_name); } AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_ids(const Context& ctx, +IceProxy::Ice::Object::iceI_begin_ice_ids(const Context& ctx, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync) { - __checkTwowayOnly(ice_ids_name, sync); - OutgoingAsyncPtr __result = new CallbackOutgoing(this, ice_ids_name, del, cookie, sync); + iceCheckTwowayOnly(ice_ids_name, sync); + OutgoingAsyncPtr iceResult = new CallbackOutgoing(this, ice_ids_name, del, cookie, sync); try { - __result->prepare(ice_ids_name, Nonmutating, ctx); - __result->writeEmptyParams(); - __result->invoke(ice_ids_name); + iceResult->prepare(ice_ids_name, Nonmutating, ctx); + iceResult->writeEmptyParams(); + iceResult->invoke(ice_ids_name); } - catch(const Exception& __ex) + catch(const Exception& iceEx) { - __result->abort(__ex); + iceResult->abort(iceEx); } - return __result; + return iceResult; } vector<string> -IceProxy::Ice::Object::end_ice_ids(const AsyncResultPtr& __result) +IceProxy::Ice::Object::end_ice_ids(const AsyncResultPtr& iceResult) { - AsyncResult::__check(__result, this, ice_ids_name); - bool __ok = __result->__wait(); - if(!__ok) + AsyncResult::iceCheck(iceResult, this, ice_ids_name); + bool iceOk = iceResult->iceWait(); + if(!iceOk) { try { - __result->__throwUserException(); + iceResult->iceThrowUserException(); } - catch(const UserException& __ex) + catch(const UserException& iceEx) { - throw UnknownUserException(__FILE__, __LINE__, __ex.ice_id()); + throw UnknownUserException(__FILE__, __LINE__, iceEx.ice_id()); } } - vector<string> __ret; - ::Ice::InputStream* __is = __result->__startReadParams(); - __is->read(__ret, false); - __result->__endReadParams(); - return __ret; + vector<string> iceRet; + ::Ice::InputStream* iceIs = iceResult->iceStartReadParams(); + iceIs->read(iceRet, false); + iceResult->iceEndReadParams(); + return iceRet; } AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_id(const Context& ctx, +IceProxy::Ice::Object::iceI_begin_ice_id(const Context& ctx, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync) { - __checkTwowayOnly(ice_id_name, sync); - OutgoingAsyncPtr __result = new CallbackOutgoing(this, ice_id_name, del, cookie, sync); + iceCheckTwowayOnly(ice_id_name, sync); + OutgoingAsyncPtr iceResult = new CallbackOutgoing(this, ice_id_name, del, cookie, sync); try { - __result->prepare(ice_id_name, Nonmutating, ctx); - __result->writeEmptyParams(); - __result->invoke(ice_id_name); + iceResult->prepare(ice_id_name, Nonmutating, ctx); + iceResult->writeEmptyParams(); + iceResult->invoke(ice_id_name); } - catch(const Exception& __ex) + catch(const Exception& iceEx) { - __result->abort(__ex); + iceResult->abort(iceEx); } - return __result; + return iceResult; } string -IceProxy::Ice::Object::end_ice_id(const AsyncResultPtr& __result) +IceProxy::Ice::Object::end_ice_id(const AsyncResultPtr& iceResult) { - AsyncResult::__check(__result, this, ice_id_name); - bool __ok = __result->__wait(); - if(!__ok) + AsyncResult::iceCheck(iceResult, this, ice_id_name); + bool iceOk = iceResult->iceWait(); + if(!iceOk) { try { - __result->__throwUserException(); + iceResult->iceThrowUserException(); } - catch(const UserException& __ex) + catch(const UserException& iceEx) { - throw UnknownUserException(__FILE__, __LINE__, __ex.ice_id()); + throw UnknownUserException(__FILE__, __LINE__, iceEx.ice_id()); } } - string __ret; - ::Ice::InputStream* __is = __result->__startReadParams(); - __is->read(__ret, false); - __result->__endReadParams(); - return __ret; + string iceRet; + ::Ice::InputStream* iceIs = iceResult->iceStartReadParams(); + iceIs->read(iceRet, false); + iceResult->iceEndReadParams(); + return iceRet; } bool @@ -374,7 +374,7 @@ IceProxy::Ice::Object::ice_invoke(const string& operation, } AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_invoke(const string& operation, +IceProxy::Ice::Object::iceI_begin_ice_invoke(const string& operation, OperationMode mode, const vector<Byte>& inEncaps, const Context& ctx, @@ -392,26 +392,26 @@ IceProxy::Ice::Object::__begin_ice_invoke(const string& operation, inPair.first = &inEncaps[0]; inPair.second = inPair.first + inEncaps.size(); } - return __begin_ice_invoke(operation, mode, inPair, ctx, del, cookie); + return iceI_begin_ice_invoke(operation, mode, inPair, ctx, del, cookie); } bool -IceProxy::Ice::Object::end_ice_invoke(vector<Byte>& outEncaps, const AsyncResultPtr& __result) +IceProxy::Ice::Object::end_ice_invoke(vector<Byte>& outEncaps, const AsyncResultPtr& iceResult) { - AsyncResult::__check(__result, this, ice_invoke_name); - bool ok = __result->__wait(); + AsyncResult::iceCheck(iceResult, this, ice_invoke_name); + bool ok = iceResult->iceWait(); if(_reference->getMode() == Reference::ModeTwoway) { const Byte* v; Int sz; - __result->__readParamEncaps(v, sz); + iceResult->iceReadParamEncaps(v, sz); vector<Byte>(v, v + sz).swap(outEncaps); } return ok; } AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_invoke(const string& operation, +IceProxy::Ice::Object::iceI_begin_ice_invoke(const string& operation, OperationMode mode, const pair<const Byte*, const Byte*>& inEncaps, const Context& ctx, @@ -419,36 +419,36 @@ IceProxy::Ice::Object::__begin_ice_invoke(const string& operation, const ::Ice::LocalObjectPtr& cookie, bool sync) { - OutgoingAsyncPtr __result = new CallbackOutgoing(this, ice_invoke_name, del, cookie, sync); + OutgoingAsyncPtr iceResult = new CallbackOutgoing(this, ice_invoke_name, del, cookie, sync); try { - __result->prepare(operation, mode, ctx); - __result->writeParamEncaps(inEncaps.first, static_cast<Int>(inEncaps.second - inEncaps.first)); - __result->invoke(operation); + iceResult->prepare(operation, mode, ctx); + iceResult->writeParamEncaps(inEncaps.first, static_cast<Int>(inEncaps.second - inEncaps.first)); + iceResult->invoke(operation); } - catch(const Exception& __ex) + catch(const Exception& iceEx) { - __result->abort(__ex); + iceResult->abort(iceEx); } - return __result; + return iceResult; } bool -IceProxy::Ice::Object::___end_ice_invoke(pair<const Byte*, const Byte*>& outEncaps, const AsyncResultPtr& __result) +IceProxy::Ice::Object::iceI_end_ice_invoke(pair<const Byte*, const Byte*>& outEncaps, const AsyncResultPtr& iceResult) { - AsyncResult::__check(__result, this, ice_invoke_name); - bool ok = __result->__wait(); + AsyncResult::iceCheck(iceResult, this, ice_invoke_name); + bool ok = iceResult->iceWait(); if(_reference->getMode() == Reference::ModeTwoway) { Int sz; - __result->__readParamEncaps(outEncaps.first, sz); + iceResult->iceReadParamEncaps(outEncaps.first, sz); outEncaps.second = outEncaps.first + sz; } return ok; } ::Ice::AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_flushBatchRequests(const ::IceInternal::CallbackBasePtr& del, +IceProxy::Ice::Object::iceI_begin_ice_flushBatchRequests(const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie) { class ProxyFlushBatchAsyncWithCallback : public ProxyFlushBatchAsync, public CallbackCompletion @@ -485,29 +485,29 @@ IceProxy::Ice::Object::__begin_ice_flushBatchRequests(const ::IceInternal::Callb void IceProxy::Ice::Object::end_ice_flushBatchRequests(const AsyncResultPtr& result) { - AsyncResult::__check(result, this, ice_flushBatchRequests_name); - result->__wait(); + AsyncResult::iceCheck(result, this, ice_flushBatchRequests_name); + result->iceWait(); } void -IceProxy::Ice::Object::__end(const ::Ice::AsyncResultPtr& __result, const std::string& operation) const +IceProxy::Ice::Object::iceEnd(const ::Ice::AsyncResultPtr& iceResult, const std::string& operation) const { - AsyncResult::__check(__result, this, operation); - bool __ok = __result->__wait(); + AsyncResult::iceCheck(iceResult, this, operation); + bool iceOk = iceResult->iceWait(); if(_reference->getMode() == Reference::ModeTwoway) { - if(!__ok) + if(!iceOk) { try { - __result->__throwUserException(); + iceResult->iceThrowUserException(); } - catch(const UserException& __ex) + catch(const UserException& iceEx) { - throw UnknownUserException(__FILE__, __LINE__, __ex.ice_id()); + throw UnknownUserException(__FILE__, __LINE__, iceEx.ice_id()); } } - __result->__readEmptyParams(); + iceResult->iceReadEmptyParams(); } } @@ -528,13 +528,13 @@ operator<<(ostream& os, const ::IceProxy::Ice::Object& p) } IceProxy::Ice::Object* -IceProxy::Ice::Object::__newInstance() const +IceProxy::Ice::Object::iceNewInstance() const { return new Object; } AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_getConnection(const ::IceInternal::CallbackBasePtr& del, +IceProxy::Ice::Object::iceI_begin_ice_getConnection(const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie) { class ProxyGetConnectionWithCallback : public ProxyGetConnection, public CallbackCompletion @@ -569,15 +569,15 @@ IceProxy::Ice::Object::__begin_ice_getConnection(const ::IceInternal::CallbackBa } ConnectionPtr -IceProxy::Ice::Object::end_ice_getConnection(const AsyncResultPtr& __result) +IceProxy::Ice::Object::end_ice_getConnection(const AsyncResultPtr& iceResult) { - AsyncResult::__check(__result, this, ice_getConnection_name); - __result->__wait(); - return __result->getConnection(); + AsyncResult::iceCheck(iceResult, this, ice_getConnection_name); + iceResult->iceWait(); + return iceResult->getConnection(); } void -IceProxy::Ice::Object::__checkTwowayOnly(const string& name, bool sync) const +IceProxy::Ice::Object::iceCheckTwowayOnly(const string& name, bool sync) const { // // No mutex lock necessary, there is nothing mutable in this operation. @@ -649,7 +649,7 @@ ICE_OBJECT_PRX::ice_getContext() const ObjectPrxPtr ICE_OBJECT_PRX::ice_context(const Context& newContext) const { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changeContext(newContext)); return proxy; } @@ -694,7 +694,7 @@ ICE_OBJECT_PRX::ice_adapterId(const string& newAdapterId) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changeAdapterId(newAdapterId)); return proxy; } @@ -727,7 +727,7 @@ ICE_OBJECT_PRX::ice_endpoints(const EndpointSeq& newEndpoints) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changeEndpoints(endpoints)); return proxy; } @@ -754,7 +754,7 @@ ICE_OBJECT_PRX::ice_locatorCacheTimeout(Int newTimeout) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changeLocatorCacheTimeout(newTimeout)); return proxy; } @@ -775,7 +775,7 @@ ICE_OBJECT_PRX::ice_connectionCached(bool newCache) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changeCacheConnection(newCache)); return proxy; } @@ -796,7 +796,7 @@ ICE_OBJECT_PRX::ice_endpointSelection(EndpointSelectionType newType) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changeEndpointSelection(newType)); return proxy; } @@ -817,7 +817,7 @@ ICE_OBJECT_PRX::ice_secure(bool b) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changeSecure(b)); return proxy; } @@ -838,7 +838,7 @@ ICE_OBJECT_PRX::ice_encodingVersion(const ::Ice::EncodingVersion& encoding) cons } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changeEncoding(encoding)); return proxy; } @@ -859,7 +859,7 @@ ICE_OBJECT_PRX::ice_preferSecure(bool b) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changePreferSecure(b)); return proxy; } @@ -886,7 +886,7 @@ ICE_OBJECT_PRX::ice_router(const RouterPrxPtr& router) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(ref); return proxy; } @@ -913,7 +913,7 @@ ICE_OBJECT_PRX::ice_locator(const LocatorPrxPtr& locator) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(ref); return proxy; } @@ -934,7 +934,7 @@ ICE_OBJECT_PRX::ice_collocationOptimized(bool b) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changeCollocationOptimized(b)); return proxy; } @@ -961,7 +961,7 @@ ICE_OBJECT_PRX::ice_invocationTimeout(Int newTimeout) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changeInvocationTimeout(newTimeout)); return proxy; } @@ -976,7 +976,7 @@ ICE_OBJECT_PRX::ice_twoway() const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changeMode(Reference::ModeTwoway)); return proxy; } @@ -997,7 +997,7 @@ ICE_OBJECT_PRX::ice_oneway() const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changeMode(Reference::ModeOneway)); return proxy; } @@ -1018,7 +1018,7 @@ ICE_OBJECT_PRX::ice_batchOneway() const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changeMode(Reference::ModeBatchOneway)); return proxy; } @@ -1039,7 +1039,7 @@ ICE_OBJECT_PRX::ice_datagram() const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changeMode(Reference::ModeDatagram)); return proxy; } @@ -1060,7 +1060,7 @@ ICE_OBJECT_PRX::ice_batchDatagram() const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(_reference->changeMode(Reference::ModeBatchDatagram)); return proxy; } @@ -1082,7 +1082,7 @@ ICE_OBJECT_PRX::ice_compress(bool b) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(ref); return proxy; } @@ -1104,7 +1104,7 @@ ICE_OBJECT_PRX::ice_timeout(int t) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(ref); return proxy; } @@ -1120,7 +1120,7 @@ ICE_OBJECT_PRX::ice_connectionId(const string& id) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = iceNewInstance(); proxy->setup(ref); return proxy; } @@ -1135,17 +1135,17 @@ ICE_OBJECT_PRX::ice_getConnectionId() const ConnectionPtr ICE_OBJECT_PRX::ice_getCachedConnection() const { - RequestHandlerPtr __handler; + RequestHandlerPtr iceHandler; { IceUtil::Mutex::Lock sync(_mutex); - __handler = _requestHandler; + iceHandler = _requestHandler; } - if(__handler) + if(iceHandler) { try { - return __handler->getConnection(); + return iceHandler->getConnection(); } catch(const LocalException&) { @@ -1169,13 +1169,13 @@ ICE_OBJECT_PRX::setup(const ReferencePtr& ref) } int -ICE_OBJECT_PRX::__handleException(const Exception& ex, +ICE_OBJECT_PRX::iceHandleException(const Exception& ex, const RequestHandlerPtr& handler, OperationMode mode, bool sent, int& cnt) { - __updateRequestHandler(handler, 0); // Clear the request handler + iceUpdateRequestHandler(handler, 0); // Clear the request handler // // We only retry local exception, system exceptions aren't retried. @@ -1218,7 +1218,7 @@ ICE_OBJECT_PRX::__handleException(const Exception& ex, } ::IceInternal::RequestHandlerPtr -ICE_OBJECT_PRX::__getRequestHandler() +ICE_OBJECT_PRX::iceGetRequestHandler() { RequestHandlerPtr handler; if(_reference->getCacheConnection()) @@ -1233,7 +1233,7 @@ ICE_OBJECT_PRX::__getRequestHandler() } IceInternal::BatchRequestQueuePtr -ICE_OBJECT_PRX::__getBatchRequestQueue() +ICE_OBJECT_PRX::iceGetBatchRequestQueue() { IceUtil::Mutex::Lock sync(_mutex); if(!_batchRequestQueue) @@ -1244,7 +1244,7 @@ ICE_OBJECT_PRX::__getBatchRequestQueue() } ::IceInternal::RequestHandlerPtr -ICE_OBJECT_PRX::__setRequestHandler(const ::IceInternal::RequestHandlerPtr& handler) +ICE_OBJECT_PRX::iceSetRequestHandler(const ::IceInternal::RequestHandlerPtr& handler) { if(_reference->getCacheConnection()) { @@ -1259,7 +1259,7 @@ ICE_OBJECT_PRX::__setRequestHandler(const ::IceInternal::RequestHandlerPtr& hand } void -ICE_OBJECT_PRX::__updateRequestHandler(const ::IceInternal::RequestHandlerPtr& previous, +ICE_OBJECT_PRX::iceUpdateRequestHandler(const ::IceInternal::RequestHandlerPtr& previous, const ::IceInternal::RequestHandlerPtr& handler) { if(_reference->getCacheConnection() && previous) @@ -1280,7 +1280,7 @@ ICE_OBJECT_PRX::__updateRequestHandler(const ::IceInternal::RequestHandlerPtr& p } void -ICE_OBJECT_PRX::__copyFrom(const ObjectPrxPtr& from) +ICE_OBJECT_PRX::iceCopyFrom(const ObjectPrxPtr& from) { IceUtil::Mutex::Lock sync(from->_mutex); _reference = from->_reference; @@ -1305,16 +1305,16 @@ ICE_OBJECT_PRX::ice_toString() const } Int -ICE_OBJECT_PRX::__hash() const +ICE_OBJECT_PRX::iceHash() const { return _reference->hash(); } void -ICE_OBJECT_PRX::__write(OutputStream& os) const +ICE_OBJECT_PRX::iceWrite(OutputStream& os) const { - os.write(__reference()->getIdentity()); - __reference()->streamWrite(&os); + os.write(iceReference()->getIdentity()); + iceReference()->streamWrite(&os); } bool diff --git a/cpp/src/Ice/ProxyFactory.cpp b/cpp/src/Ice/ProxyFactory.cpp index b0037fa9ce5..cdda57d6ce1 100644 --- a/cpp/src/Ice/ProxyFactory.cpp +++ b/cpp/src/Ice/ProxyFactory.cpp @@ -41,7 +41,7 @@ IceInternal::ProxyFactory::proxyToString(const ObjectPrxPtr& proxy) const { if(proxy) { - return proxy->__reference()->toString(); + return proxy->iceReference()->toString(); } else { @@ -62,7 +62,7 @@ IceInternal::ProxyFactory::proxyToProperty(const ObjectPrxPtr& proxy, const stri { if(proxy) { - return proxy->__reference()->toProperty(prefix); + return proxy->iceReference()->toProperty(prefix); } else { diff --git a/cpp/src/Ice/Reference.cpp b/cpp/src/Ice/Reference.cpp index 12296b9f04f..e2c824002e1 100644 --- a/cpp/src/Ice/Reference.cpp +++ b/cpp/src/Ice/Reference.cpp @@ -815,7 +815,7 @@ IceInternal::FixedReference::getRequestHandler(const Ice::ObjectPrxPtr& proxy) c } ReferencePtr ref = const_cast<FixedReference*>(this); - return proxy->__setRequestHandler(ICE_MAKE_SHARED(ConnectionRequestHandler, ref, _fixedConnection, compress)); + return proxy->iceSetRequestHandler(ICE_MAKE_SHARED(ConnectionRequestHandler, ref, _fixedConnection, compress)); } BatchRequestQueuePtr @@ -1269,7 +1269,7 @@ IceInternal::RoutableReference::toProperty(const string& prefix) const } if(_routerInfo) { - PropertyDict routerProperties = _routerInfo->getRouter()->__reference()->toProperty(prefix + ".Router"); + PropertyDict routerProperties = _routerInfo->getRouter()->iceReference()->toProperty(prefix + ".Router"); for(PropertyDict::const_iterator p = routerProperties.begin(); p != routerProperties.end(); ++p) { properties[p->first] = p->second; @@ -1278,7 +1278,7 @@ IceInternal::RoutableReference::toProperty(const string& prefix) const if(_locatorInfo) { - PropertyDict locatorProperties = _locatorInfo->getLocator()->__reference()->toProperty(prefix + ".Locator"); + PropertyDict locatorProperties = _locatorInfo->getLocator()->iceReference()->toProperty(prefix + ".Locator"); for(PropertyDict::const_iterator p = locatorProperties.begin(); p != locatorProperties.end(); ++p) { properties[p->first] = p->second; diff --git a/cpp/src/Ice/RequestHandlerFactory.cpp b/cpp/src/Ice/RequestHandlerFactory.cpp index 414d1001220..6d5dc493e7a 100644 --- a/cpp/src/Ice/RequestHandlerFactory.cpp +++ b/cpp/src/Ice/RequestHandlerFactory.cpp @@ -30,7 +30,7 @@ IceInternal::RequestHandlerFactory::getRequestHandler(const RoutableReferencePtr Ice::ObjectAdapterPtr adapter = _instance->objectAdapterFactory()->findObjectAdapter(proxy); if(adapter) { - return proxy->__setRequestHandler(ICE_MAKE_SHARED(CollocatedRequestHandler, ref, adapter)); + return proxy->iceSetRequestHandler(ICE_MAKE_SHARED(CollocatedRequestHandler, ref, adapter)); } } @@ -64,7 +64,7 @@ IceInternal::RequestHandlerFactory::getRequestHandler(const RoutableReferencePtr ref->getConnection(handler.get()); #endif } - return proxy->__setRequestHandler(handler->connect(proxy)); + return proxy->iceSetRequestHandler(handler->connect(proxy)); } void diff --git a/cpp/src/Ice/RouterInfo.cpp b/cpp/src/Ice/RouterInfo.cpp index b205b057d7a..3817b58d919 100644 --- a/cpp/src/Ice/RouterInfo.cpp +++ b/cpp/src/Ice/RouterInfo.cpp @@ -335,7 +335,7 @@ IceInternal::RouterInfo::setClientEndpoints(const Ice::ObjectPrxPtr& proxy) // // If getClientProxy() return nil, use router endpoints. // - _clientEndpoints = _router->__reference()->getEndpoints(); + _clientEndpoints = _router->iceReference()->getEndpoints(); } else { @@ -351,7 +351,7 @@ IceInternal::RouterInfo::setClientEndpoints(const Ice::ObjectPrxPtr& proxy) clientProxy = clientProxy->ice_timeout(_router->ice_getConnection()->timeout()); } - _clientEndpoints = clientProxy->__reference()->getEndpoints(); + _clientEndpoints = clientProxy->iceReference()->getEndpoints(); } } return _clientEndpoints; @@ -372,7 +372,7 @@ IceInternal::RouterInfo::setServerEndpoints(const Ice::ObjectPrxPtr& /*serverPro serverProxy = serverProxy->ice_router(0); // The server proxy cannot be routed. - _serverEndpoints = serverProxy->__reference()->getEndpoints(); + _serverEndpoints = serverProxy->iceReference()->getEndpoints(); } return _serverEndpoints; } diff --git a/cpp/src/Ice/SlicedData.cpp b/cpp/src/Ice/SlicedData.cpp index 6a433ffbe4d..320763a1bda 100644 --- a/cpp/src/Ice/SlicedData.cpp +++ b/cpp/src/Ice/SlicedData.cpp @@ -33,7 +33,7 @@ Ice::SlicedData::SlicedData(const SliceInfoSeq& seq) : #ifndef ICE_CPP11_MAPPING void -Ice::SlicedData::__gcVisitMembers(IceInternal::GCVisitor& visitor) +Ice::SlicedData::iceGcVisitMembers(IceInternal::GCVisitor& visitor) { // // Iterate over the object references in each preserved slice. @@ -42,7 +42,7 @@ Ice::SlicedData::__gcVisitMembers(IceInternal::GCVisitor& visitor) { for(vector<ObjectPtr>::iterator q = (*p)->instances.begin(); q != (*p)->instances.end(); ++q) { - if(q->get()->__gcVisit(visitor)) + if(q->get()->iceGcVisit(visitor)) { *q = 0; } @@ -51,11 +51,11 @@ Ice::SlicedData::__gcVisitMembers(IceInternal::GCVisitor& visitor) } void -Ice::UnknownSlicedValue::__gcVisitMembers(IceInternal::GCVisitor& _v) +Ice::UnknownSlicedValue::iceGcVisitMembers(IceInternal::GCVisitor& _v) { if(_slicedData) { - _slicedData->__gcVisitMembers(_v); + _slicedData->iceGcVisitMembers(_v); } } @@ -78,17 +78,17 @@ Ice::UnknownSlicedValue::getSlicedData() const } void -Ice::UnknownSlicedValue::__write(Ice::OutputStream* __os) const +Ice::UnknownSlicedValue::iceWrite(Ice::OutputStream* iceOs) const { - __os->startValue(_slicedData); - __os->endValue(); + iceOs->startValue(_slicedData); + iceOs->endValue(); } void -Ice::UnknownSlicedValue::__read(Ice::InputStream* __is) +Ice::UnknownSlicedValue::iceRead(Ice::InputStream* iceIs) { - __is->startValue(); - _slicedData = __is->endValue(true); + iceIs->startValue(); + _slicedData = iceIs->endValue(true); } #ifdef ICE_CPP11_MAPPING diff --git a/cpp/src/Ice/Thread.cpp b/cpp/src/Ice/Thread.cpp index 7882a0a2948..8c3e03cfd46 100644 --- a/cpp/src/Ice/Thread.cpp +++ b/cpp/src/Ice/Thread.cpp @@ -162,7 +162,7 @@ WINAPI startHook(void* arg) // // See the comment in IceUtil::Thread::start() for details. // - rawThread->__decRef(); + rawThread->iceDecRef(); thread->run(); } catch(...) @@ -209,9 +209,9 @@ IceUtil::Thread::start(size_t, int) // object could be deleted before the thread object takes // ownership. It's also necessary to increment the reference count // prior to calling pthread_create since the thread itself calls - // __decRef(). + // iceDecRef(). // - __incRef(); + iceIncRef(); _thread.reset(new thread(startHook, this)); _started = true; @@ -397,7 +397,7 @@ WINAPI startHook(void* arg) // // See the comment in IceUtil::Thread::start() for details. // - rawThread->__decRef(); + rawThread->iceDecRef(); thread->run(); } catch(...) @@ -444,9 +444,9 @@ IceUtil::Thread::start(size_t stackSize, int priority) // object could be deleted before the thread object takes // ownership. It's also necessary to increment the reference count // prior to calling pthread_create since the thread itself calls - // __decRef(). + // iceDecRef(). // - __incRef(); + iceIncRef(); unsigned int id; _handle = @@ -460,7 +460,7 @@ IceUtil::Thread::start(size_t stackSize, int priority) assert(_handle != (HANDLE)-1L); if(_handle == 0) { - __decRef(); + iceDecRef(); throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); } if(SetThreadPriority(_handle, priority) == 0) @@ -469,7 +469,7 @@ IceUtil::Thread::start(size_t stackSize, int priority) } if(static_cast<int>(ResumeThread(_handle)) == -1) { - __decRef(); + iceDecRef(); throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); } @@ -643,7 +643,7 @@ startHook(void* arg) // // See the comment in IceUtil::Thread::start() for details. // - rawThread->__decRef(); + rawThread->iceDecRef(); thread->run(); } catch(...) @@ -695,15 +695,15 @@ IceUtil::Thread::start(size_t stackSize, bool realtimeScheduling, int priority) // object could be deleted before the thread object takes // ownership. It's also necessary to increment the reference count // prior to calling pthread_create since the thread itself calls - // __decRef(). + // iceDecRef(). // - __incRef(); + iceIncRef(); pthread_attr_t attr; int rc = pthread_attr_init(&attr); if(rc != 0) { - __decRef(); + iceDecRef(); pthread_attr_destroy(&attr); throw ThreadSyscallException(__FILE__, __LINE__, rc); } @@ -722,7 +722,7 @@ IceUtil::Thread::start(size_t stackSize, bool realtimeScheduling, int priority) rc = pthread_attr_setstacksize(&attr, stackSize); if(rc != 0) { - __decRef(); + iceDecRef(); pthread_attr_destroy(&attr); throw ThreadSyscallException(__FILE__, __LINE__, rc); } @@ -733,7 +733,7 @@ IceUtil::Thread::start(size_t stackSize, bool realtimeScheduling, int priority) rc = pthread_attr_setschedpolicy(&attr, SCHED_RR); if(rc != 0) { - __decRef(); + iceDecRef(); throw ThreadSyscallException(__FILE__, __LINE__, rc); } sched_param param; @@ -741,7 +741,7 @@ IceUtil::Thread::start(size_t stackSize, bool realtimeScheduling, int priority) rc = pthread_attr_setschedparam(&attr, ¶m); if(rc != 0) { - __decRef(); + iceDecRef(); pthread_attr_destroy(&attr); throw ThreadSyscallException(__FILE__, __LINE__, rc); } @@ -751,7 +751,7 @@ IceUtil::Thread::start(size_t stackSize, bool realtimeScheduling, int priority) pthread_attr_destroy(&attr); if(rc != 0) { - __decRef(); + iceDecRef(); throw ThreadSyscallException(__FILE__, __LINE__, rc); } diff --git a/cpp/src/Ice/ThreadPool.cpp b/cpp/src/Ice/ThreadPool.cpp index 3769458371b..5412db05acc 100644 --- a/cpp/src/Ice/ThreadPool.cpp +++ b/cpp/src/Ice/ThreadPool.cpp @@ -373,7 +373,7 @@ IceInternal::ThreadPool::ThreadPool(const InstancePtr& instance, const string& p << _sizeWarn; } - __setNoDelete(true); + iceSetNoDelete(true); try { for(int i = 0 ; i < _size ; ++i) @@ -399,15 +399,15 @@ IceInternal::ThreadPool::ThreadPool(const InstancePtr& instance, const string& p destroy(); joinWithAllThreads(); - __setNoDelete(false); + iceSetNoDelete(false); throw; } catch(...) { - __setNoDelete(false); + iceSetNoDelete(false); throw; } - __setNoDelete(false); + iceSetNoDelete(false); } IceInternal::ThreadPool::~ThreadPool() diff --git a/cpp/src/Ice/Timer.cpp b/cpp/src/Ice/Timer.cpp index c19ba12a92b..f85895456d0 100644 --- a/cpp/src/Ice/Timer.cpp +++ b/cpp/src/Ice/Timer.cpp @@ -22,18 +22,18 @@ Timer::Timer() : Thread("IceUtil timer thread"), _destroyed(false) { - __setNoDelete(true); + iceSetNoDelete(true); start(); - __setNoDelete(false); + iceSetNoDelete(false); } Timer::Timer(int priority) : Thread("IceUtil timer thread"), _destroyed(false) { - __setNoDelete(true); + iceSetNoDelete(true); start(0, priority); - __setNoDelete(false); + iceSetNoDelete(false); } void diff --git a/cpp/src/Ice/Value.cpp b/cpp/src/Ice/Value.cpp index f5a7f6b1bbf..1e596f62f56 100644 --- a/cpp/src/Ice/Value.cpp +++ b/cpp/src/Ice/Value.cpp @@ -29,25 +29,25 @@ Ice::Value::ice_postUnmarshal() } void -Ice::Value::__write(Ice::OutputStream* os) const +Ice::Value::iceWrite(Ice::OutputStream* os) const { os->startValue(0); - __writeImpl(os); + iceWriteImpl(os); os->endValue(); } void -Ice::Value::__read(Ice::InputStream* is) +Ice::Value::iceRead(Ice::InputStream* is) { is->startValue(); - __readImpl(is); + iceReadImpl(is); is->endValue(false); } namespace { -const string __Ice__Object_ids[] = +const string iceC_Ice_Object_ids[] = { "::Ice::Object" }; @@ -57,13 +57,13 @@ const string __Ice__Object_ids[] = string Ice::Value::ice_id() const { - return __Ice__Object_ids[0]; + return iceC_Ice_Object_ids[0]; } const string& Ice::Value::ice_staticId() { - return __Ice__Object_ids[0]; + return iceC_Ice_Object_ids[0]; } ValuePtr diff --git a/cpp/src/IceBT/DBus.cpp b/cpp/src/IceBT/DBus.cpp index 9101e88bb60..2b40398b39a 100644 --- a/cpp/src/IceBT/DBus.cpp +++ b/cpp/src/IceBT/DBus.cpp @@ -826,7 +826,7 @@ public: // Bump our refcount to ensure this object lives until the reply is received. // The pendingFree function will decrement the refcount. // - __incRef(); + iceIncRef(); if(!::dbus_pending_call_set_notify(_call, pendingCallCompletedCallback, this, pendingCallFree)) { @@ -971,7 +971,7 @@ pendingCallFree(void* userData) { AsyncResultI* r = static_cast<AsyncResultI*>(userData); assert(r); - r->__decRef(); + r->iceDecRef(); } static DBusHandlerResult filterCallback(DBusConnection*, DBusMessage*, void*); @@ -1117,7 +1117,7 @@ public: ::dbus_bus_add_match(_connection, "type='signal'", 0); //::dbus_bus_add_match(_connection, "type='method_call'", 0); - __incRef(); // __decRef called in freeConnection. + iceIncRef(); // iceDecRef called in freeConnection. _thread = new HelperThread(this); _thread->start(); @@ -1229,7 +1229,7 @@ static void freeConnection(void* p) { ConnectionI* c = static_cast<ConnectionI*>(p); assert(c); - c->__decRef(); + c->iceDecRef(); } } diff --git a/cpp/src/IceGrid/NodeCache.cpp b/cpp/src/IceGrid/NodeCache.cpp index 8757dc0fe2b..abac64ac90c 100644 --- a/cpp/src/IceGrid/NodeCache.cpp +++ b/cpp/src/IceGrid/NodeCache.cpp @@ -722,7 +722,7 @@ NodeEntry::getInternalServerDescriptor(const ServerInfo& server, const SessionIP } void -NodeEntry::__incRef() +NodeEntry::iceIncRef() { Lock sync(*this); assert(_ref >= 0); @@ -730,7 +730,7 @@ NodeEntry::__incRef() } void -NodeEntry::__decRef() +NodeEntry::iceDecRef() { // // The node entry implements its own reference counting. If the diff --git a/cpp/src/IceGrid/NodeCache.h b/cpp/src/IceGrid/NodeCache.h index 1346cdb3ee2..88b1bf88fa7 100644 --- a/cpp/src/IceGrid/NodeCache.h +++ b/cpp/src/IceGrid/NodeCache.h @@ -62,8 +62,8 @@ public: ServerInfo getServerInfo(const ServerInfo&, const SessionIPtr&); InternalServerDescriptorPtr getInternalServerDescriptor(const ServerInfo&, const SessionIPtr&); - void __incRef(); - void __decRef(); + void iceIncRef(); + void iceDecRef(); void checkSession() const; void setProxy(const NodePrx&); diff --git a/cpp/src/IceGrid/NodeSessionI.cpp b/cpp/src/IceGrid/NodeSessionI.cpp index 01bbb7679c0..9accf0eb7f3 100644 --- a/cpp/src/IceGrid/NodeSessionI.cpp +++ b/cpp/src/IceGrid/NodeSessionI.cpp @@ -145,7 +145,7 @@ NodeSessionI::NodeSessionI(const DatabasePtr& database, _load(load), _destroy(false) { - __setNoDelete(true); + iceSetNoDelete(true); try { _database->getNode(info->name, true)->setSession(this); @@ -159,7 +159,7 @@ NodeSessionI::NodeSessionI(const DatabasePtr& database, } catch(const NodeActiveException&) { - __setNoDelete(false); + iceSetNoDelete(false); throw; } catch(...) @@ -174,10 +174,10 @@ NodeSessionI::NodeSessionI(const DatabasePtr& database, _database->getNode(info->name)->setSession(0); - __setNoDelete(false); + iceSetNoDelete(false); throw; } - __setNoDelete(false); + iceSetNoDelete(false); } void diff --git a/cpp/src/IceGrid/ReplicaSessionI.cpp b/cpp/src/IceGrid/ReplicaSessionI.cpp index acb3f2e56d2..983ebd24430 100644 --- a/cpp/src/IceGrid/ReplicaSessionI.cpp +++ b/cpp/src/IceGrid/ReplicaSessionI.cpp @@ -42,7 +42,7 @@ ReplicaSessionI::ReplicaSessionI(const DatabasePtr& database, _timestamp(IceUtil::Time::now(IceUtil::Time::Monotonic)), _destroy(false) { - __setNoDelete(true); + iceSetNoDelete(true); try { _database->getReplicaCache().add(info->name, this); @@ -54,7 +54,7 @@ ReplicaSessionI::ReplicaSessionI(const DatabasePtr& database, } catch(const ReplicaActiveException&) { - __setNoDelete(false); + iceSetNoDelete(false); throw; } catch(...) @@ -64,10 +64,10 @@ ReplicaSessionI::ReplicaSessionI(const DatabasePtr& database, _database->getReplicaCache().remove(_info->name, false); - __setNoDelete(false); + iceSetNoDelete(false); throw; } - __setNoDelete(false); + iceSetNoDelete(false); } void diff --git a/cpp/src/IceGridLib/PluginFacadeI.cpp b/cpp/src/IceGridLib/PluginFacadeI.cpp index f84f33dff0b..5747f2e0b1d 100644 --- a/cpp/src/IceGridLib/PluginFacadeI.cpp +++ b/cpp/src/IceGridLib/PluginFacadeI.cpp @@ -46,12 +46,12 @@ IceGrid::setRegistryPluginFacade(const RegistryPluginFacadePtr& facade) #else if(pluginFacade) { - pluginFacade->__decRef(); + pluginFacade->iceDecRef(); } pluginFacade = facade.get(); if(pluginFacade) { - pluginFacade->__incRef(); + pluginFacade->iceIncRef(); } #endif } diff --git a/cpp/src/IceSSL/OpenSSLEngine.cpp b/cpp/src/IceSSL/OpenSSLEngine.cpp index 84238614220..76b4e562afa 100644 --- a/cpp/src/IceSSL/OpenSSLEngine.cpp +++ b/cpp/src/IceSSL/OpenSSLEngine.cpp @@ -195,7 +195,7 @@ OpenSSLEngine::OpenSSLEngine(const CommunicatorPtr& communicator) : _initialized(false), _ctx(0) { - __setNoDelete(true); + iceSetNoDelete(true); // // Initialize OpenSSL if necessary. @@ -325,7 +325,7 @@ OpenSSLEngine::OpenSSLEngine(const CommunicatorPtr& communicator) : # endif } } - __setNoDelete(false); + iceSetNoDelete(false); } OpenSSLEngine::~OpenSSLEngine() diff --git a/cpp/src/IceStorm/Instance.cpp b/cpp/src/IceStorm/Instance.cpp index 6d8334cab4d..7f92944c498 100644 --- a/cpp/src/IceStorm/Instance.cpp +++ b/cpp/src/IceStorm/Instance.cpp @@ -117,7 +117,7 @@ Instance::Instance( { try { - __setNoDelete(true); + iceSetNoDelete(true); Ice::PropertiesPtr properties = communicator->getProperties(); if(properties->getProperty(name + ".TopicManager.AdapterId").empty()) @@ -167,11 +167,11 @@ Instance::Instance( { shutdown(); destroy(); - __setNoDelete(false); + iceSetNoDelete(false); throw; } - __setNoDelete(false); + iceSetNoDelete(false); } Instance::~Instance() diff --git a/cpp/src/IceStorm/TopicI.cpp b/cpp/src/IceStorm/TopicI.cpp index acea59e5c15..c89e3146211 100644 --- a/cpp/src/IceStorm/TopicI.cpp +++ b/cpp/src/IceStorm/TopicI.cpp @@ -352,7 +352,7 @@ TopicImpl::TopicImpl( { try { - __setNoDelete(true); + iceSetNoDelete(true); // TODO: If we want to improve the performance of the // non-replicated case we could allocate a null-topic impl here. @@ -435,10 +435,10 @@ TopicImpl::TopicImpl( catch(...) { shutdown(); - __setNoDelete(false); + iceSetNoDelete(false); throw; } - __setNoDelete(false); + iceSetNoDelete(false); } TopicImpl::~TopicImpl() diff --git a/cpp/src/IceStorm/TopicManagerI.cpp b/cpp/src/IceStorm/TopicManagerI.cpp index 5c4ad1c6cbc..57f5b619a4b 100644 --- a/cpp/src/IceStorm/TopicManagerI.cpp +++ b/cpp/src/IceStorm/TopicManagerI.cpp @@ -255,7 +255,7 @@ TopicManagerImpl::TopicManagerImpl(const PersistentInstancePtr& instance) : { try { - __setNoDelete(true); + iceSetNoDelete(true); if(_instance->observer()) { @@ -319,10 +319,10 @@ TopicManagerImpl::TopicManagerImpl(const PersistentInstancePtr& instance) : catch(...) { shutdown(); - __setNoDelete(false); + iceSetNoDelete(false); throw; } - __setNoDelete(false); + iceSetNoDelete(false); } TopicManagerImpl::~TopicManagerImpl() diff --git a/cpp/src/IceUtil/Shared.cpp b/cpp/src/IceUtil/Shared.cpp index 75b43462398..c9c924fef27 100644 --- a/cpp/src/IceUtil/Shared.cpp +++ b/cpp/src/IceUtil/Shared.cpp @@ -47,14 +47,14 @@ IceUtil::Shared::Shared(const Shared&) : } void -IceUtil::Shared::__incRef() +IceUtil::Shared::iceIncRef() { assert(_ref >= 0); ++_ref; } void -IceUtil::Shared::__decRef() +IceUtil::Shared::iceDecRef() { assert(_ref > 0); if(--_ref == 0 && !(_flags & NoDelete)) @@ -64,13 +64,13 @@ IceUtil::Shared::__decRef() } int -IceUtil::Shared::__getRef() const +IceUtil::Shared::iceGetRef() const { return _ref; } void -IceUtil::Shared::__setNoDelete(bool b) +IceUtil::Shared::iceSetNoDelete(bool b) { _flags = b ? (_flags | NoDelete) : (_flags & ~NoDelete); } diff --git a/cpp/src/Slice/CPlusPlusUtil.cpp b/cpp/src/Slice/CPlusPlusUtil.cpp index 4ae02b9372f..bbdff8765af 100644 --- a/cpp/src/Slice/CPlusPlusUtil.cpp +++ b/cpp/src/Slice/CPlusPlusUtil.cpp @@ -217,7 +217,7 @@ writeParamAllocateCode(Output& out, const TypePtr& type, bool optional, const st { s = toOptional(s, typeCtx); } - out << nl << s << " ___" << fixedName << ";"; + out << nl << s << " iceP_" << fixedName << ";"; } } } @@ -228,7 +228,7 @@ writeParamEndCode(Output& out, const TypePtr& type, bool optional, const string& { string objPrefix = obj.empty() ? obj : obj + "."; string paramName = objPrefix + fixedName; - string escapedParamName = objPrefix + "___" + fixedName; + string escapedParamName = objPrefix + "iceP_" + fixedName; SequencePtr seq = SequencePtr::dynamicCast(type); if(seq) @@ -269,7 +269,7 @@ writeParamEndCode(Output& out, const TypePtr& type, bool optional, const string& { out << nl << "if(" << escapedParamName << ")"; out << sb; - out << nl << paramName << ".__setIsSet();"; + out << nl << paramName << ".iceSetIsSet();"; out << nl << "if(!" << escapedParamName << "->empty())"; out << sb; out << nl << paramName << "->first" << " = &(*" << escapedParamName << ")[0];"; @@ -301,7 +301,7 @@ writeParamEndCode(Output& out, const TypePtr& type, bool optional, const string& { out << nl << "if(" << escapedParamName << ")"; out << sb; - out << nl << paramName << ".__setIsSet();"; + out << nl << paramName << ".iceSetIsSet();"; out << nl << paramName << "->first = (*" << escapedParamName << ").begin();"; out << nl << paramName << "->second = (*" << escapedParamName << ").end();"; out << eb; @@ -317,10 +317,12 @@ writeParamEndCode(Output& out, const TypePtr& type, bool optional, const string& void writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const OperationPtr& op, bool marshal, - bool prepend, int typeCtx, const string& retP = "", const string& obj = "") + bool prepend, int typeCtx, const string& retP = "", const string& obj = "", + const string& stream = "") { string prefix = prepend ? paramPrefix : ""; - string returnValueS = retP.empty() ? string("__ret") : retP; + string returnValueS = retP.empty() ? string("iceRet") : retP; + string streamTarget = stream.empty() ? (marshal ? "iceOs" : "iceIs") : stream; string objPrefix = obj.empty() ? obj : obj + "."; @@ -351,11 +353,11 @@ writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const Oper out << nl; if(marshal) { - out << "__os->writeAll"; + out << streamTarget << "->writeAll"; } else { - out << "__is->readAll"; + out << streamTarget << "->readAll"; } out << spar; for(ParamDeclList::const_iterator p = requiredParams.begin(); p != requiredParams.end(); ++p) @@ -407,11 +409,11 @@ writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const Oper out << nl; if(marshal) { - out << "__os->writeAll"; + out << streamTarget << "->writeAll"; } else { - out << "__is->readAll"; + out << streamTarget << "->readAll"; } out << spar; @@ -494,7 +496,7 @@ writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const Oper } Slice::FeatureProfile Slice::featureProfile = Slice::Ice; -string Slice::paramPrefix = "__p_"; +string Slice::paramPrefix = "iceP_"; char Slice::ToIfdef::operator()(char c) @@ -1255,7 +1257,7 @@ Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, bool optional ostringstream os; if(str.empty()) { - os << (marshal ? "__os" : "__is"); + os << (marshal ? "iceOs" : "iceIs"); } else { @@ -1302,13 +1304,13 @@ Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, bool optional return; } - out << nl << func << objPrefix << "___" << param << ");"; + out << nl << func << objPrefix << "iceP_" << param << ");"; writeParamEndCode(out, seq, optional, param, metaData, obj); return; } else if(seqType.find("%range") == 0) { - out << nl << func << objPrefix << "___" << param << ");"; + out << nl << func << objPrefix << "iceP_" << param << ");"; writeParamEndCode(out, seq, optional, param, metaData, obj); return; } @@ -1319,9 +1321,10 @@ Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, bool optional } void -Slice::writeMarshalCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx) +Slice::writeMarshalCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx, + const string& streamTarget) { - writeMarshalUnmarshalParams(out, params, op, true, prepend, typeCtx); + writeMarshalUnmarshalParams(out, params, op, true, prepend, typeCtx, "", "", streamTarget); } void @@ -1335,7 +1338,7 @@ void Slice::writeAllocateCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx) { string prefix = prepend ? paramPrefix : ""; - string returnValueS = "__ret"; + string returnValueS = "iceRet"; for(ParamDeclList::const_iterator p = params.begin(); p != params.end(); ++p) { @@ -1373,11 +1376,11 @@ Slice::getEndArg(const TypePtr& type, const StringList& metaData, const string& builtin->kind() != Builtin::KindObject && builtin->kind() != Builtin::KindObjectProxy) { - endArg = "___" + endArg; + endArg = "iceP_" + endArg; } else if(!builtin || builtin->kind() != Builtin::KindByte) { - endArg = "___" + endArg; + endArg = "iceP_" + endArg; } } else if(seqType.find("%range") == 0) @@ -1387,7 +1390,7 @@ Slice::getEndArg(const TypePtr& type, const StringList& metaData, const string& { md.push_back("cpp:type:" + seqType.substr(strlen("%range:"))); } - endArg = "___" + endArg; + endArg = "iceP_" + endArg; } } return endArg; @@ -1403,7 +1406,7 @@ Slice::writeEndCode(Output& out, const ParamDeclList& params, const OperationPtr } if(op && op->returnType()) { - writeParamEndCode(out, op->returnType(), op->returnIsOptional(), "__ret", op->getMetaData()); + writeParamEndCode(out, op->returnType(), op->returnIsOptional(), "iceRet", op->getMetaData()); } } @@ -1429,7 +1432,7 @@ Slice::writeMarshalUnmarshalAllInHolder(IceUtilInternal::Output& out, return; } - string stream = marshal ? "__os" : "__is"; + string stream = marshal ? "iceOs" : "iceIs"; string streamOp = marshal ? "writeAll" : "readAll"; out << nl << stream << "->" << streamOp; @@ -1519,15 +1522,15 @@ Slice::writeStreamHelpers(Output& out, out << nl << "template<typename S>"; out << nl << "struct StreamWriter" << (cpp11 ? "<" : "< ") << fullName << ", S>"; out << sb; + if(requiredMembers.empty() && optionalMembers.empty()) { out << nl << "static void write(S*, const " << fullName << "&)"; } else { - out << nl << "static void write(S* __os, const " << fullName << "& v)"; + out << nl << "static void write(S* iceOs, const " << fullName << "& v)"; } - out << sb; if(cpp11) @@ -1558,13 +1561,14 @@ Slice::writeStreamHelpers(Output& out, out << nl << "template<typename S>"; out << nl << "struct StreamReader" << (cpp11 ? "<" : "< ") << fullName << ", S>"; out << sb; + if (requiredMembers.empty() && optionalMembers.empty()) { out << nl << "static void read(S*, " << fullName << "&)"; } else { - out << nl << "static void read(S* __is, " << fullName << "& v)"; + out << nl << "static void read(S* iceIs, " << fullName << "& v)"; } out << sb; diff --git a/cpp/src/Slice/CPlusPlusUtil.h b/cpp/src/Slice/CPlusPlusUtil.h index 0e359b9a1a7..3c6dcc652c2 100644 --- a/cpp/src/Slice/CPlusPlusUtil.h +++ b/cpp/src/Slice/CPlusPlusUtil.h @@ -52,7 +52,8 @@ void writeMarshalUnmarshalCode(::IceUtilInternal::Output&, const TypePtr&, bool, bool, const StringList& = StringList(), int = 0, const std::string& = "", bool = true, const std::string& = ""); -void writeMarshalCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool, int = 0); +void writeMarshalCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool, int = 0, + const std::string& = ""); void writeUnmarshalCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool, int = 0, const std::string& = "", const std::string& = ""); void writeAllocateCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool, int = 0); diff --git a/cpp/src/Slice/Parser.cpp b/cpp/src/Slice/Parser.cpp index e6e8fb768a6..77038503d92 100644 --- a/cpp/src/Slice/Parser.cpp +++ b/cpp/src/Slice/Parser.cpp @@ -425,12 +425,14 @@ string Slice::Contained::flattenedScope() const { string s = scope(); - string flattenedScope; - for(string::const_iterator r = s.begin(); r != s.end(); ++r) + const string doubleColon = "::"; + + size_t pos = 0; + while((pos = s.find(doubleColon, pos)) != string::npos) { - flattenedScope += ((*r) == ':') ? '_' : *r; + s.replace(pos++, doubleColon.length(), "_"); } - return flattenedScope; + return s; } string @@ -3805,13 +3807,13 @@ Slice::ClassDef::ClassDef(const ContainerPtr& container, const string& name, int bool Slice::Proxy::isLocal() const { - return __class->isLocal(); + return _classDM->isLocal(); } string Slice::Proxy::typeId() const { - return __class->scoped(); + return _classDM->scoped(); } bool @@ -3835,13 +3837,13 @@ Slice::Proxy::isVariableLength() const ClassDeclPtr Slice::Proxy::_class() const { - return __class; + return _classDM; } Slice::Proxy::Proxy(const ClassDeclPtr& cl) : SyntaxTreeBase(cl->unit()), Type(cl->unit()), - __class(cl) + _classDM(cl) { } diff --git a/cpp/src/Slice/Parser.h b/cpp/src/Slice/Parser.h index c26de803f13..cb009a76837 100644 --- a/cpp/src/Slice/Parser.h +++ b/cpp/src/Slice/Parser.h @@ -707,7 +707,7 @@ public: protected: - ClassDeclPtr __class; + ClassDeclPtr _classDM; }; // ---------------------------------------------------------------------- diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp index ad125388647..94a555d0e63 100644 --- a/cpp/src/slice2cpp/Gen.cpp +++ b/cpp/src/slice2cpp/Gen.cpp @@ -236,12 +236,12 @@ writeInParamsLambda(IceUtilInternal::Output& C, const OperationPtr& p, const Par } else { - C << "[&](::Ice::OutputStream* __os)"; + C << "[&](::Ice::OutputStream* iceOs)"; C << sb; writeMarshalCode(C, inParams, 0, true, TypeContextInParam | TypeContextCpp11); if(p->sendsClasses(false)) { - C << nl << "__os->writePendingValues();"; + C << nl << "iceOs->writePendingValues();"; } C << eb; } @@ -267,11 +267,11 @@ throwUserExceptionLambda(IceUtilInternal::Output& C, ExceptionList throws) // throws.sort(Slice::DerivedToBaseCompare()); - C << "[](const ::Ice::UserException& __ex)"; + C << "[](const ::Ice::UserException& iceEx)"; C << sb; C << nl << "try"; C << sb; - C << nl << "__ex.ice_throw();"; + C << nl << "iceEx.ice_throw();"; C << eb; // // Generate a catch block for each legal user exception. @@ -427,7 +427,7 @@ Slice::Gen::generateChecksumMap(const UnitPtr& p) { C << sp << nl << "namespace"; C << nl << "{"; - C << sp << nl << "const char* __sliceChecksums[] ="; + C << sp << nl << "const char* iceSliceChecksums[] ="; C << sb; for(ChecksumMap::const_iterator q = map.begin(); q != map.end(); ++q) { @@ -443,7 +443,7 @@ Slice::Gen::generateChecksumMap(const UnitPtr& p) } C << nl << "0"; C << eb << ';'; - C << nl << "const IceInternal::SliceChecksumInit __sliceChecksumInit(__sliceChecksums);"; + C << nl << "const IceInternal::SliceChecksumInit iceSliceChecksumInit(iceSliceChecksums);"; C << sp << nl << "}"; } } @@ -949,7 +949,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) { string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring); allTypes.push_back(typeName); - allParamDecls.push_back(typeName + " __ice_" + fixKwd((*q)->name())); + allParamDecls.push_back(typeName + " iceP_" + fixKwd((*q)->name())); } if(base) @@ -957,7 +957,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) DataMemberList baseDataMembers = base->allDataMembers(); for(DataMemberList::const_iterator q = baseDataMembers.begin(); q != baseDataMembers.end(); ++q) { - baseParams.push_back("__ice_" + fixKwd((*q)->name())); + baseParams.push_back("iceP_" + fixKwd((*q)->name())); } } @@ -1012,7 +1012,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) if(!p->isLocal()) { - string initName = p->flattenedScope() + p->name() + "_init"; + string initName = "iceC" + p->flattenedScope() + p->name() + "_init"; C << sp << nl << "namespace"; C << nl << "{"; @@ -1025,10 +1025,10 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) if(p->isLocal()) { - C << sp << nl << scoped.substr(2) << "::" << name << spar << "const char* __file" << "int __line" << epar + C << sp << nl << scoped.substr(2) << "::" << name << spar << "const char* iceFile" << "int iceLine" << epar << " :"; C.inc(); - emitUpcall(base, "(__file, __line)", true); + emitUpcall(base, "(iceFile, iceLine)", true); if(p->hasDefaultValues()) { C << ", "; @@ -1054,7 +1054,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) C << scoped.substr(2) << "::" << name << spar; if(p->isLocal()) { - C << "const char* __file" << "int __line"; + C << "const char* iceFile" << "int iceLine"; } C << allParamDecls << epar; if(p->isLocal() || !baseParams.empty() || !params.empty()) @@ -1067,7 +1067,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) upcall = "("; if(p->isLocal()) { - upcall += "__file, __line"; + upcall += "iceFile, iceLine"; } for(vector<string>::const_iterator pi = baseParams.begin(); pi != baseParams.end(); ++pi) { @@ -1091,7 +1091,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) { C << ","; } - C << nl << *pi << "(__ice_" << *pi << ')'; + C << nl << *pi << "(iceP_" << *pi << ')'; } if(p->isLocal() || !baseParams.empty() || !params.empty()) { @@ -1134,10 +1134,10 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) { if(!base || (base && !base->usesClasses(false))) { - H << sp << nl << "virtual bool __usesClasses() const;"; + H << sp << nl << "virtual bool iceUsesClasses() const;"; C << sp << nl << "bool"; - C << nl << scoped.substr(2) << "::__usesClasses() const"; + C << nl << scoped.substr(2) << "::iceUsesClasses() const"; C << sb; C << nl << "return true;"; C << eb; @@ -1167,62 +1167,62 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p) if(preserved && !basePreserved) { - H << sp << nl << "virtual void __write(::Ice::OutputStream*) const;"; - H << nl << "virtual void __read(::Ice::InputStream*);"; + H << sp << nl << "virtual void iceWrite(::Ice::OutputStream*) const;"; + H << nl << "virtual void iceRead(::Ice::InputStream*);"; string baseName = base ? fixKwd(base->scoped()) : string("::Ice::UserException"); - H << nl << "using " << baseName << "::__write;"; - H << nl << "using " << baseName << "::__read;"; + H << nl << "using " << baseName << "::iceWrite;"; + H << nl << "using " << baseName << "::iceRead;"; } H.dec(); H << sp << nl << "protected:"; H.inc(); - H << sp << nl << "virtual void __writeImpl(::Ice::OutputStream*) const;"; - H << nl << "virtual void __readImpl(::Ice::InputStream*);"; + H << sp << nl << "virtual void iceWriteImpl(::Ice::OutputStream*) const;"; + H << nl << "virtual void iceReadImpl(::Ice::InputStream*);"; string baseName = base ? fixKwd(base->scoped()) : string("::Ice::UserException"); if(preserved && !basePreserved) { - H << sp << nl << "::Ice::SlicedDataPtr __slicedData;"; + H << sp << nl << "::Ice::SlicedDataPtr _slicedData;"; - C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(::Ice::OutputStream* __os) const"; + C << sp << nl << "void" << nl << scoped.substr(2) << "::iceWrite(::Ice::OutputStream* iceOs) const"; C << sb; - C << nl << "__os->startException(__slicedData);"; - C << nl << "__writeImpl(__os);"; - C << nl << "__os->endException();"; + C << nl << "iceOs->startException(_slicedData);"; + C << nl << "iceWriteImpl(iceOs);"; + C << nl << "iceOs->endException();"; C << eb; - C << sp << nl << "void" << nl << scoped.substr(2) << "::__read(::Ice::InputStream* __is)"; + C << sp << nl << "void" << nl << scoped.substr(2) << "::iceRead(::Ice::InputStream* iceIs)"; C << sb; - C << nl << "__is->startException();"; - C << nl << "__readImpl(__is);"; - C << nl << "__slicedData = __is->endException(true);"; + C << nl << "iceIs->startException();"; + C << nl << "iceReadImpl(iceIs);"; + C << nl << "_slicedData = iceIs->endException(true);"; C << eb; } - C << sp << nl << "void" << nl << scoped.substr(2) << "::__writeImpl(::Ice::OutputStream* __os) const"; + C << sp << nl << "void" << nl << scoped.substr(2) << "::iceWriteImpl(::Ice::OutputStream* iceOs) const"; C << sb; - C << nl << "__os->startSlice(\"" << p->scoped() << "\", -1, " << (!base ? "true" : "false") << ");"; - C << nl << "Ice::StreamWriter< ::" << scoped.substr(2) << ", ::Ice::OutputStream>::write(__os, *this);"; - C << nl << "__os->endSlice();"; + C << nl << "iceOs->startSlice(\"" << p->scoped() << "\", -1, " << (!base ? "true" : "false") << ");"; + C << nl << "Ice::StreamWriter< ::" << scoped.substr(2) << ", ::Ice::OutputStream>::write(iceOs, *this);"; + C << nl << "iceOs->endSlice();"; if(base) { - emitUpcall(base, "::__writeImpl(__os);"); + emitUpcall(base, "::iceWriteImpl(iceOs);"); } C << eb; - C << sp << nl << "void" << nl << scoped.substr(2) << "::__readImpl(::Ice::InputStream* __is)"; + C << sp << nl << "void" << nl << scoped.substr(2) << "::iceReadImpl(::Ice::InputStream* iceIs)"; C << sb; - C << nl << "__is->startSlice();"; - C << nl << "Ice::StreamReader< ::" << scoped.substr(2) << ", ::Ice::InputStream>::read(__is, *this);"; - C << nl << "__is->endSlice();"; + C << nl << "iceIs->startSlice();"; + C << nl << "Ice::StreamReader< ::" << scoped.substr(2) << ", ::Ice::InputStream>::read(iceIs, *this);"; + C << nl << "iceIs->endSlice();"; if(base) { - emitUpcall(base, "::__readImpl(__is);"); + emitUpcall(base, "::iceReadImpl(iceIs);"); } C << eb; } @@ -1238,7 +1238,7 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p) if(!_doneStaticSymbol) { _doneStaticSymbol = true; - H << sp << nl << "static " << name << " __" << p->name() << "_init;"; + H << sp << nl << "static " << name << " iceS_" << p->name() << "_init;"; } } @@ -1304,7 +1304,7 @@ Slice::Gen::TypesVisitor::visitStructStart(const StructPtr& p) { string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring); types.push_back(typeName); - paramDecls.push_back(typeName + " __ice_" + (*q)->name()); + paramDecls.push_back(typeName + " iceP_" + (*q)->name()); } H << nl; @@ -1322,7 +1322,7 @@ Slice::Gen::TypesVisitor::visitStructStart(const StructPtr& p) H << ','; } string memberName = fixKwd((*q)->name()); - H << nl << memberName << '(' << "__ice_" << (*q)->name() << ')'; + H << nl << memberName << '(' << "iceP_" << (*q)->name() << ')'; } H.dec(); @@ -1356,34 +1356,34 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p) bool containsSequence = false; if((Dictionary::legalKeyType(p, containsSequence) && !containsSequence) || p->hasMetaData("cpp:comparable")) { - H << sp << nl << "bool operator==(const " << name << "& __rhs) const"; + H << sp << nl << "bool operator==(const " << name << "& iceRhs) const"; H << sb; - H << nl << "if(this == &__rhs)"; + H << nl << "if(this == &iceRhs)"; H << sb; H << nl << "return true;"; H << eb; for(vector<string>::const_iterator pi = params.begin(); pi != params.end(); ++pi) { - H << nl << "if(" << *pi << " != __rhs." << *pi << ')'; + H << nl << "if(" << *pi << " != iceRhs." << *pi << ')'; H << sb; H << nl << "return false;"; H << eb; } H << nl << "return true;"; H << eb; - H << sp << nl << "bool operator<(const " << name << "& __rhs) const"; + H << sp << nl << "bool operator<(const " << name << "& iceRhs) const"; H << sb; - H << nl << "if(this == &__rhs)"; + H << nl << "if(this == &iceRhs)"; H << sb; H << nl << "return false;"; H << eb; for(vector<string>::const_iterator pi = params.begin(); pi != params.end(); ++pi) { - H << nl << "if(" << *pi << " < __rhs." << *pi << ')'; + H << nl << "if(" << *pi << " < iceRhs." << *pi << ')'; H << sb; H << nl << "return true;"; H << eb; - H << nl << "else if(__rhs." << *pi << " < " << *pi << ')'; + H << nl << "else if(iceRhs." << *pi << " < " << *pi << ')'; H << sb; H << nl << "return false;"; H << eb; @@ -1391,21 +1391,21 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p) H << nl << "return false;"; H << eb; - H << sp << nl << "bool operator!=(const " << name << "& __rhs) const"; + H << sp << nl << "bool operator!=(const " << name << "& iceRhs) const"; H << sb; - H << nl << "return !operator==(__rhs);"; + H << nl << "return !operator==(iceRhs);"; H << eb; - H << nl << "bool operator<=(const " << name << "& __rhs) const"; + H << nl << "bool operator<=(const " << name << "& iceRhs) const"; H << sb; - H << nl << "return operator<(__rhs) || operator==(__rhs);"; + H << nl << "return operator<(iceRhs) || operator==(iceRhs);"; H << eb; - H << nl << "bool operator>(const " << name << "& __rhs) const"; + H << nl << "bool operator>(const " << name << "& iceRhs) const"; H << sb; - H << nl << "return !operator<(__rhs) && !operator==(__rhs);"; + H << nl << "return !operator<(iceRhs) && !operator==(iceRhs);"; H << eb; - H << nl << "bool operator>=(const " << name << "& __rhs) const"; + H << nl << "bool operator>=(const " << name << "& iceRhs) const"; H << sb; - H << nl << "return !operator<(__rhs);"; + H << nl << "return !operator<(iceRhs);"; H << eb; } H << eb << ';'; @@ -1586,7 +1586,7 @@ Slice::Gen::ProxyDeclVisitor::visitClassDecl(const ClassDeclPtr& p) string scoped = fixKwd(p->scoped()); H << sp << nl << "class " << name << ';'; - H << nl << _dllExport << "void __read(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy" + H << nl << _dllExport << "void iceRead(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy" << scoped << ">&);"; H << nl << _dllExport << "::IceProxy::Ice::Object* upCast(::IceProxy" << scoped << "*);"; } @@ -1693,7 +1693,7 @@ Slice::Gen::ProxyVisitor::visitClassDefStart(const ClassDefPtr& p) H << sp << nl << "protected:"; H.inc(); - H << sp << nl << "virtual Object* __newInstance() const = 0;"; + H << sp << nl << "virtual Object* iceNewInstance() const = 0;"; H << eb << ';'; } @@ -1723,11 +1723,11 @@ Slice::Gen::ProxyVisitor::visitClassDefStart(const ClassDefPtr& p) << "::IceProxy::Ice::Object* ::IceProxy" << scope << "upCast(::IceProxy" << scoped << "* p) { return p; }"; C << sp; - C << nl << "void" << nl << "::IceProxy" << scope << "__read(::Ice::InputStream* __is, " + C << nl << "void" << nl << "::IceProxy" << scope << "iceRead(::Ice::InputStream* iceIs, " << "::IceInternal::ProxyHandle< ::IceProxy" << scoped << ">& v)"; C << sb; C << nl << "::Ice::ObjectPrx proxy;"; - C << nl << "__is->read(proxy);"; + C << nl << "iceIs->read(proxy);"; C << nl << "if(!proxy)"; C << sb; C << nl << "v = 0;"; @@ -1735,7 +1735,7 @@ Slice::Gen::ProxyVisitor::visitClassDefStart(const ClassDefPtr& p) C << nl << "else"; C << sb; C << nl << "v = new ::IceProxy" << scoped << ';'; - C << nl << "v->__copyFrom(proxy);"; + C << nl << "v->iceCopyFrom(proxy);"; C << eb; C << eb; @@ -1754,12 +1754,12 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p) H.dec(); H << sp << nl << "protected: "; H.inc(); - H << sp << nl << _dllMemberExport << "virtual ::IceProxy::Ice::Object* __newInstance() const;"; + H << sp << nl << _dllMemberExport << "virtual ::IceProxy::Ice::Object* iceNewInstance() const;"; H << eb << ';'; C << sp; C << nl << "::IceProxy::Ice::Object*"; - C << nl << "IceProxy" << scoped << "::__newInstance() const"; + C << nl << "IceProxy" << scoped << "::iceNewInstance() const"; C << sb; C << nl << "return new " << name << ";"; C << eb; @@ -1809,7 +1809,7 @@ void Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p) { string name = p->name(); - string flatName = p->flattenedScope() + p->name() + "_name"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_name"; string scoped = fixKwd(p->scoped()); string scope = fixKwd(p->scope()); @@ -1889,12 +1889,12 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p) } // - // Check if we need to generate a private ___end_ method. This is the case if the + // Check if we need to generate a private iceI_end_ method. This is the case if the // when using certain mapping features such as cpp:array. While // the regular end_ method can't return pair<const TYPE*, const TYPE*> because the // pointers would be invalid once end_ returns, we still want to allow using this // alternate mapping with AMI response callbacks (to allow zero-copy for instance). - // For this purpose, we generate a special ___end method which is used by the + // For this purpose, we generate a special iceI_end method which is used by the // completed implementation of the generated Callback_Inft_opName operation // delegate. // @@ -1903,65 +1903,65 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p) { string typeStringEndAMI = outputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring | TypeContextAMIPrivateEnd); - outParamsDeclEndAMI.push_back(typeStringEndAMI + ' ' + "__ret"); + outParamsDeclEndAMI.push_back(typeStringEndAMI + ' ' + "iceRet"); } string thisPointer = fixKwd(scope.substr(0, scope.size() - 2)) + "*"; string deprecateSymbol = getDeprecateSymbol(p, cl); H << sp << nl << deprecateSymbol << _dllMemberExport << retS << ' ' << fixKwd(name) << spar << paramsDecl - << "const ::Ice::Context& __ctx = ::Ice::noExplicitContext" << epar; + << "const ::Ice::Context& iceCtx = ::Ice::noExplicitContext" << epar; H << sb << nl; if(ret) { H << "return "; } - H << "end_" << name << spar << outParamNamesAMI << "__begin_" + name << spar << argsAMI; - H << "__ctx" << "::IceInternal::__dummyCallback" << "0" << "true" << epar << epar << ';'; + H << "end_" << name << spar << outParamNamesAMI << "iceI_begin_" + name << spar << argsAMI; + H << "iceCtx" << "::IceInternal::dummyCallback" << "0" << "true" << epar << epar << ';'; H << eb; H << sp << nl << "::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI - << "const ::Ice::Context& __ctx = ::Ice::noExplicitContext" << epar; + << "const ::Ice::Context& iceCtx = ::Ice::noExplicitContext" << epar; H << sb; - H << nl << "return __begin_" << name << spar << argsAMI << "__ctx" << "::IceInternal::__dummyCallback" << "0" + H << nl << "return iceI_begin_" << name << spar << argsAMI << "iceCtx" << "::IceInternal::dummyCallback" << "0" << epar << ';'; H << eb; H << sp << nl << "::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI - << "const ::Ice::CallbackPtr& __del" - << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar; + << "const ::Ice::CallbackPtr& iceDel" + << "const ::Ice::LocalObjectPtr& iceCookie = 0" << epar; H << sb; - H << nl << "return __begin_" << name << spar << argsAMI << "::Ice::noExplicitContext" << "__del" << "__cookie" << epar << ';'; + H << nl << "return iceI_begin_" << name << spar << argsAMI << "::Ice::noExplicitContext" << "iceDel" << "iceCookie" << epar << ';'; H << eb; H << sp << nl << "::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI - << "const ::Ice::Context& __ctx" - << "const ::Ice::CallbackPtr& __del" - << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar; + << "const ::Ice::Context& iceCtx" + << "const ::Ice::CallbackPtr& iceDel" + << "const ::Ice::LocalObjectPtr& iceCookie = 0" << epar; H << sb; - H << nl << "return __begin_" << name << spar << argsAMI << "__ctx" << "__del" << "__cookie" << epar << ';'; + H << nl << "return iceI_begin_" << name << spar << argsAMI << "iceCtx" << "iceDel" << "iceCookie" << epar << ';'; H << eb; H << sp << nl << "::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI - << "const " + delNameScoped + "Ptr& __del" - << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar; + << "const " + delNameScoped + "Ptr& iceDel" + << "const ::Ice::LocalObjectPtr& iceCookie = 0" << epar; H << sb; - H << nl << "return __begin_" << name << spar << argsAMI << "::Ice::noExplicitContext" << "__del" << "__cookie" << epar << ';'; + H << nl << "return iceI_begin_" << name << spar << argsAMI << "::Ice::noExplicitContext" << "iceDel" << "iceCookie" << epar << ';'; H << eb; H << sp << nl << "::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI - << "const ::Ice::Context& __ctx" - << "const " + delNameScoped + "Ptr& __del" - << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar; + << "const ::Ice::Context& iceCtx" + << "const " + delNameScoped + "Ptr& iceDel" + << "const ::Ice::LocalObjectPtr& iceCookie = 0" << epar; H << sb; - H << nl << "return __begin_" << name << spar << argsAMI << "__ctx" << "__del" << "__cookie" << epar << ';'; + H << nl << "return iceI_begin_" << name << spar << argsAMI << "iceCtx" << "iceDel" << "iceCookie" << epar << ';'; H << eb; H << sp << nl << _dllMemberExport << retS << " end_" << name << spar << outParamsDeclAMI << "const ::Ice::AsyncResultPtr&" << epar << ';'; if(generatePrivateEnd) { - H << sp << nl << _dllMemberExport << "void ___end_" << name << spar << outParamsDeclEndAMI; + H << sp << nl << _dllMemberExport << "void iceI_end_" << name << spar << outParamsDeclEndAMI; H << "const ::Ice::AsyncResultPtr&" << epar << ';'; } @@ -1969,71 +1969,71 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p) H.dec(); H << nl << "private:"; H.inc(); - H << sp << nl << _dllMemberExport << "::Ice::AsyncResultPtr __begin_" << name << spar + H << sp << nl << _dllMemberExport << "::Ice::AsyncResultPtr iceI_begin_" << name << spar << paramsAMI << "const ::Ice::Context&" << "const ::IceInternal::CallbackBasePtr&" - << "const ::Ice::LocalObjectPtr& __cookie = 0" + << "const ::Ice::LocalObjectPtr& iceCookie = 0" << "bool sync = false" << epar << ';'; H << nl; H.dec(); H << nl << "public:"; H.inc(); - C << sp << nl << "::Ice::AsyncResultPtr" << nl << "IceProxy" << scope << "__begin_" << name << spar << paramsDeclAMI - << "const ::Ice::Context& __ctx" << "const ::IceInternal::CallbackBasePtr& __del" - << "const ::Ice::LocalObjectPtr& __cookie" << "bool sync" << epar; + C << sp << nl << "::Ice::AsyncResultPtr" << nl << "IceProxy" << scope << "iceI_begin_" << name << spar << paramsDeclAMI + << "const ::Ice::Context& iceCtx" << "const ::IceInternal::CallbackBasePtr& iceDel" + << "const ::Ice::LocalObjectPtr& iceCookie" << "bool sync" << epar; C << sb; if(p->returnsData()) { - C << nl << "__checkTwowayOnly(" << flatName << ", sync);"; + C << nl << "iceCheckTwowayOnly(" << flatName << ", sync);"; } - C << nl << "::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::CallbackOutgoing(this, " << flatName - << ", __del, __cookie, sync);"; + C << nl << "::IceInternal::OutgoingAsyncPtr iceResult = new ::IceInternal::CallbackOutgoing(this, " << flatName + << ", iceDel, iceCookie, sync);"; C << nl << "try"; C << sb; - C << nl << "__result->prepare(" << flatName << ", " << operationModeToString(p->sendMode()) << ", __ctx);"; + C << nl << "iceResult->prepare(" << flatName << ", " << operationModeToString(p->sendMode()) << ", iceCtx);"; if(inParams.empty()) { - C << nl << "__result->writeEmptyParams();"; + C << nl << "iceResult->writeEmptyParams();"; } else { - C << nl << "::Ice::OutputStream* __os = __result->startWriteParams(" << opFormatTypeToString(p) <<");"; + C << nl << "::Ice::OutputStream* iceOs = iceResult->startWriteParams(" << opFormatTypeToString(p) <<");"; writeMarshalCode(C, inParams, 0, true, TypeContextInParam); if(p->sendsClasses(false)) { - C << nl << "__os->writePendingValues();"; + C << nl << "iceOs->writePendingValues();"; } - C << nl << "__result->endWriteParams();"; + C << nl << "iceResult->endWriteParams();"; } - C << nl << "__result->invoke(" << flatName << ");"; + C << nl << "iceResult->invoke(" << flatName << ");"; C << eb; - C << nl << "catch(const ::Ice::Exception& __ex)"; + C << nl << "catch(const ::Ice::Exception& iceEx)"; C << sb; - C << nl << "__result->abort(__ex);"; + C << nl << "iceResult->abort(iceEx);"; C << eb; - C << nl << "return __result;"; + C << nl << "return iceResult;"; C << eb; C << sp << nl << retS << nl << "IceProxy" << scope << "end_" << name << spar << outParamsDeclAMI - << "const ::Ice::AsyncResultPtr& __result" << epar; + << "const ::Ice::AsyncResultPtr& iceResult" << epar; C << sb; if(p->returnsData()) { - C << nl << "::Ice::AsyncResult::__check(__result, this, " << flatName << ");"; + C << nl << "::Ice::AsyncResult::iceCheck(iceResult, this, " << flatName << ");"; // // COMPILERFIX: It's necessary to generate the allocate code here before - // this if(!__result->wait()). If generated after this if block, we get + // this if(!iceResult->wait()). If generated after this if block, we get // access violations errors with the test/Ice/slicing/objects test on VC9 // and Windows 64 bits when compiled with optimization (see bug 4400). // writeAllocateCode(C, ParamDeclList(), p, true, _useWstring | TypeContextAMIEnd); - C << nl << "if(!__result->__wait())"; + C << nl << "if(!iceResult->iceWait())"; C << sb; C << nl << "try"; C << sb; - C << nl << "__result->__throwUserException();"; + C << nl << "iceResult->iceThrowUserException();"; C << eb; // // Generate a catch block for each legal user exception. @@ -2054,33 +2054,33 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p) C << nl << "throw;"; C << eb; } - C << nl << "catch(const ::Ice::UserException& __ex)"; + C << nl << "catch(const ::Ice::UserException& iceEx)"; C << sb; - C << nl << "throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_id());"; + C << nl << "throw ::Ice::UnknownUserException(__FILE__, __LINE__, iceEx.ice_id());"; C << eb; C << eb; if(ret || !outParams.empty()) { - C << nl << "::Ice::InputStream* __is = __result->__startReadParams();"; + C << nl << "::Ice::InputStream* iceIs = iceResult->iceStartReadParams();"; writeUnmarshalCode(C, outParams, p, true, _useWstring | TypeContextAMIEnd); if(p->returnsClasses(false)) { - C << nl << "__is->readPendingValues();"; + C << nl << "iceIs->readPendingValues();"; } - C << nl << "__result->__endReadParams();"; + C << nl << "iceResult->iceEndReadParams();"; } else { - C << nl << "__result->__readEmptyParams();"; + C << nl << "iceResult->iceReadEmptyParams();"; } if(ret) { - C << nl << "return __ret;"; + C << nl << "return iceRet;"; } } else { - C << nl << "__end(__result, " << flatName << ");"; + C << nl << "iceEnd(iceResult, " << flatName << ");"; } C << eb; @@ -2088,15 +2088,15 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p) { assert(p->returnsData()); - C << sp << nl << "void IceProxy" << scope << "___end_" << name << spar << outParamsDeclEndAMI - << "const ::Ice::AsyncResultPtr& __result" << epar; + C << sp << nl << "void IceProxy" << scope << "iceI_end_" << name << spar << outParamsDeclEndAMI + << "const ::Ice::AsyncResultPtr& iceResult" << epar; C << sb; - C << nl << "::Ice::AsyncResult::__check(__result, this, " << flatName << ");"; - C << nl << "if(!__result->__wait())"; + C << nl << "::Ice::AsyncResult::iceCheck(iceResult, this, " << flatName << ");"; + C << nl << "if(!iceResult->iceWait())"; C << sb; C << nl << "try"; C << sb; - C << nl << "__result->__throwUserException();"; + C << nl << "iceResult->iceThrowUserException();"; C << eb; // // Generate a catch block for each legal user exception. @@ -2117,25 +2117,25 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p) C << nl << "throw;"; C << eb; } - C << nl << "catch(const ::Ice::UserException& __ex)"; + C << nl << "catch(const ::Ice::UserException& iceEx)"; C << sb; - C << nl << "throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_id());"; + C << nl << "throw ::Ice::UnknownUserException(__FILE__, __LINE__, iceEx.ice_id());"; C << eb; C << eb; if(ret || !outParams.empty()) { - C << nl << "::Ice::InputStream* __is = __result->__startReadParams();"; + C << nl << "::Ice::InputStream* iceIs = iceResult->iceStartReadParams();"; writeUnmarshalCode(C, outParams, p, true, _useWstring | TypeContextAMIPrivateEnd); if(p->returnsClasses(false)) { - C << nl << "__is->readPendingValues();"; + C << nl << "iceIs->readPendingValues();"; } - C << nl << "__result->__endReadParams();"; + C << nl << "iceResult->iceEndReadParams();"; } else { - C << nl << "__result->__readEmptyParams();"; + C << nl << "iceResult->iceReadEmptyParams();"; } C << eb; } @@ -2181,7 +2181,7 @@ Slice::Gen::ObjectDeclVisitor::visitClassDecl(const ClassDeclPtr& p) H << nl << "typedef ::IceInternal::Handle< " << scoped << "> " << p->name() << "Ptr;"; H << nl << "typedef ::IceInternal::ProxyHandle< ::IceProxy" << scoped << "> " << p->name() << "Prx;"; H << nl << "typedef " << p->name() << "Prx " << p->name() << "PrxPtr;"; - H << nl << _dllExport << "void __patch(" << p->name() << "Ptr&, const ::Ice::ObjectPtr&);"; + H << nl << _dllExport << "void icePatch(" << p->name() << "Ptr&, const ::Ice::ObjectPtr&);"; } else { @@ -2196,7 +2196,7 @@ Slice::Gen::ObjectDeclVisitor::visitOperation(const OperationPtr& p) ClassDefPtr cl = ClassDefPtr::dynamicCast(p->container()); if(cl && !cl->isLocal()) { - string flatName = p->flattenedScope() + p->name() + "_name"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_name"; C << sp << nl << "const ::std::string " << flatName << " = \"" << p->name() << "\";"; } } @@ -2329,7 +2329,7 @@ Slice::Gen::ObjectVisitor::visitClassDefStart(const ClassDefPtr& p) { string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring); allTypes.push_back(typeName); - allParamDecls.push_back(typeName + " __ice_" + (*q)->name()); + allParamDecls.push_back(typeName + " iceP_" + (*q)->name()); } if(!p->isInterface()) @@ -2382,8 +2382,8 @@ Slice::Gen::ObjectVisitor::visitClassDefStart(const ClassDefPtr& p) C << sb; if(!p->isAbstract()) { - C << nl << "::Ice::Object* __p = new " << name << "(*this);"; - C << nl << "return __p;"; + C << nl << "::Ice::Object* iceP = new " << name << "(*this);"; + C << nl << "return iceP;"; } else { @@ -2425,7 +2425,7 @@ Slice::Gen::ObjectVisitor::visitClassDefStart(const ClassDefPtr& p) H << nl << "virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::noExplicitCurrent) const;"; H << sp << nl << "static const ::std::string& ice_staticId();"; - string flatName = p->flattenedScope() + p->name() + "_ids"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_ids"; C << sp << nl << "namespace"; C << nl << "{"; @@ -2527,9 +2527,9 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) allOpNames.unique(); H << sp; - H << nl << "virtual bool __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);"; + H << nl << "virtual bool iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&);"; - string flatName = p->flattenedScope() + p->name() + "_all"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_all"; C << sp << nl << "namespace"; C << nl << "{"; C << nl << "const ::std::string " << flatName << "[] ="; @@ -2547,7 +2547,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) C << sp << nl << "}"; C << sp; C << nl << "bool"; - C << nl << scoped.substr(2) << "::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)"; + C << nl << scoped.substr(2) << "::iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)"; C << sb; C << nl << "::std::pair< const ::std::string*, const ::std::string*> r = " @@ -2566,7 +2566,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) { C << nl << "case " << i++ << ':'; C << sb; - C << nl << "return ___" << *q << "(in, current);"; + C << nl << "return iceD_" << *q << "(in, current);"; C << eb; } C << nl << "default:"; @@ -2597,7 +2597,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) H << nl << "virtual ::Ice::Int ice_operationAttributes(const ::std::string&) const;"; - string opAttrFlatName = p->flattenedScope() + p->name() + "_operationAttributes"; + string opAttrFlatName = "iceC" + p->flattenedScope() + p->name() + "_operationAttributes"; C << sp << nl << "namespace"; C << nl << "{"; @@ -2652,8 +2652,8 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) if(preserved && !basePreserved) { H << sp; - H << nl << "virtual void __write(::Ice::OutputStream*) const;"; - H << nl << "virtual void __read(::Ice::InputStream*);"; + H << nl << "virtual void iceWrite(::Ice::OutputStream*) const;"; + H << nl << "virtual void iceRead(::Ice::InputStream*);"; } H.dec(); @@ -2661,49 +2661,49 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) inProtected = true; H.inc(); - H << sp << nl << "virtual void __writeImpl(::Ice::OutputStream*) const;"; - H << nl << "virtual void __readImpl(::Ice::InputStream*);"; + H << sp << nl << "virtual void iceWriteImpl(::Ice::OutputStream*) const;"; + H << nl << "virtual void iceReadImpl(::Ice::InputStream*);"; if(preserved && !basePreserved) { C << sp; - C << nl << "void" << nl << scoped.substr(2) << "::__write(::Ice::OutputStream* __os) const"; + C << nl << "void" << nl << scoped.substr(2) << "::iceWrite(::Ice::OutputStream* iceOs) const"; C << sb; - C << nl << "__os->startValue(__slicedData);"; - C << nl << "__writeImpl(__os);"; - C << nl << "__os->endValue();"; + C << nl << "iceOs->startValue(_slicedData);"; + C << nl << "iceWriteImpl(iceOs);"; + C << nl << "iceOs->endValue();"; C << eb; C << sp; - C << nl << "void" << nl << scoped.substr(2) << "::__read(::Ice::InputStream* __is)"; + C << nl << "void" << nl << scoped.substr(2) << "::iceRead(::Ice::InputStream* iceIs)"; C << sb; - C << nl << "__is->startValue();"; - C << nl << "__readImpl(__is);"; - C << nl << "__slicedData = __is->endValue(true);"; + C << nl << "iceIs->startValue();"; + C << nl << "iceReadImpl(iceIs);"; + C << nl << "_slicedData = iceIs->endValue(true);"; C << eb; } C << sp; - C << nl << "void" << nl << scoped.substr(2) << "::__writeImpl(::Ice::OutputStream* __os) const"; + C << nl << "void" << nl << scoped.substr(2) << "::iceWriteImpl(::Ice::OutputStream* iceOs) const"; C << sb; - C << nl << "__os->startSlice(ice_staticId(), " << p->compactId() << (!base ? ", true" : ", false") << ");"; - C << nl << "Ice::StreamWriter< ::" << scoped.substr(2) << ", ::Ice::OutputStream>::write(__os, *this);"; - C << nl << "__os->endSlice();"; + C << nl << "iceOs->startSlice(ice_staticId(), " << p->compactId() << (!base ? ", true" : ", false") << ");"; + C << nl << "Ice::StreamWriter< ::" << scoped.substr(2) << ", ::Ice::OutputStream>::write(iceOs, *this);"; + C << nl << "iceOs->endSlice();"; if(base) { - emitUpcall(base, "::__writeImpl(__os);"); + emitUpcall(base, "::iceWriteImpl(iceOs);"); } C << eb; C << sp; - C << nl << "void" << nl << scoped.substr(2) << "::__readImpl(::Ice::InputStream* __is)"; + C << nl << "void" << nl << scoped.substr(2) << "::iceReadImpl(::Ice::InputStream* iceIs)"; C << sb; - C << nl << "__is->startSlice();"; - C << nl << "Ice::StreamReader< ::" << scoped.substr(2) << ", ::Ice::InputStream>::read(__is, *this);"; - C << nl << "__is->endSlice();"; + C << nl << "iceIs->startSlice();"; + C << nl << "Ice::StreamReader< ::" << scoped.substr(2) << ", ::Ice::InputStream>::read(iceIs, *this);"; + C << nl << "iceIs->endSlice();"; if(base) { - emitUpcall(base, "::__readImpl(__is);"); + emitUpcall(base, "::iceReadImpl(iceIs);"); } C << eb; @@ -2714,13 +2714,13 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) if(!p->isAbstract()) { - string initName = p->flattenedScope() + p->name() + "_init"; + string initName = "iceC" + p->flattenedScope() + p->name() + "_init"; C << nl << "const ::IceInternal::DefaultValueFactoryInit< " << scoped << "> " << initName << "(\"" << p->scoped() << "\");"; } if(p->compactId() >= 0) { - string initName = p->flattenedScope() + p->name() + "_compactIdInit"; + string initName = "iceC" + p->flattenedScope() + p->name() + "_compactIdInit"; C << nl << "const ::IceInternal::CompactIdInit " << initName << "(\"" << p->scoped() << "\", " << p->compactId() << ");"; } @@ -2787,7 +2787,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) H.inc(); inProtected = true; } - H << sp << nl << "::Ice::SlicedDataPtr __slicedData;"; + H << sp << nl << "::Ice::SlicedDataPtr _slicedData;"; } if(generateFriend) @@ -2835,7 +2835,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) else { C << sp << nl << "void " << _dllExport; - C << nl << scope.substr(2) << "__patch(" << p->name() << "Ptr& handle, const ::Ice::ObjectPtr& v)"; + C << nl << scope.substr(2) << "icePatch(" << p->name() << "Ptr& handle, const ::Ice::ObjectPtr& v)"; C << sb; C << nl << "handle = " << scope << p->name() << "Ptr::dynamicCast(v);"; C << nl << "if(v && !handle)"; @@ -2892,8 +2892,8 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p) string classScopedAMD = classScope + classNameAMD; string paramsAMD = "(const " + classScopedAMD + '_' + name + "Ptr&, "; - string paramsDeclAMD = "(const " + classScopedAMD + '_' + name + "Ptr& __cb, "; - string argsAMD = "(new IceAsync" + classScopedAMD + '_' + name + "(__inS), "; + string paramsDeclAMD = "(const " + classScopedAMD + '_' + name + "Ptr& iceCb, "; + string argsAMD = "(new IceAsync" + classScopedAMD + '_' + name + "(iceInS), "; ParamDeclList inParams; ParamDeclList outParams; @@ -2956,8 +2956,8 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p) } params += "const ::Ice::Current& = ::Ice::noExplicitCurrent)"; - paramsDecl += "const ::Ice::Current& __current)"; - args += "__current)"; + paramsDecl += "const ::Ice::Current& iceCurrent)"; + args += "iceCurrent)"; } else { @@ -2967,8 +2967,8 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p) } paramsAMD += "const ::Ice::Current& = ::Ice::noExplicitCurrent)"; - paramsDeclAMD += "const ::Ice::Current& __current)"; - argsAMD += "__current)"; + paramsDeclAMD += "const ::Ice::Current& iceCurrent)"; + argsAMD += "iceCurrent)"; string isConst = ((p->mode() == Operation::Nonmutating) || p->hasMetaData("cpp:const")) ? " const" : ""; bool amd = !cl->isLocal() && (cl->hasMetaData("amd") || p->hasMetaData("amd")); @@ -2987,32 +2987,32 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p) if(!cl->isLocal()) { - H << nl << "bool ___" << name << "(::IceInternal::Incoming&, const ::Ice::Current&)" << isConst << ';'; + H << nl << "bool iceD_" << name << "(::IceInternal::Incoming&, const ::Ice::Current&)" << isConst << ';'; C << sp; - C << nl << "bool" << nl << scope.substr(2) << "___" << name << "(::IceInternal::Incoming& __inS" - << ", const ::Ice::Current& __current)" << isConst; + C << nl << "bool" << nl << scope.substr(2) << "iceD_" << name << "(::IceInternal::Incoming& iceInS" + << ", const ::Ice::Current& iceCurrent)" << isConst; C << sb; - C << nl << "__checkMode(" << operationModeToString(p->mode()) << ", __current.mode);"; + C << nl << "iceCheckMode(" << operationModeToString(p->mode()) << ", iceCurrent.mode);"; if(!inParams.empty()) { - C << nl << "::Ice::InputStream* __is = __inS.startReadParams();"; + C << nl << "::Ice::InputStream* iceIs = iceInS.startReadParams();"; writeAllocateCode(C, inParams, 0, true, _useWstring | TypeContextInParam); writeUnmarshalCode(C, inParams, 0, true, TypeContextInParam); if(p->sendsClasses(false)) { - C << nl << "__is->readPendingValues();"; + C << nl << "iceIs->readPendingValues();"; } - C << nl << "__inS.endReadParams();"; + C << nl << "iceInS.endReadParams();"; } else { - C << nl << "__inS.readEmptyParams();"; + C << nl << "iceInS.readEmptyParams();"; } if(p->format() != DefaultFormat) { - C << nl << "__inS.setFormat(" << opFormatTypeToString(p) << ");"; + C << nl << "iceInS.setFormat(" << opFormatTypeToString(p) << ");"; } if(!amd) @@ -3020,22 +3020,22 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p) writeAllocateCode(C, outParams, 0, true, _useWstring); if(ret) { - C << retS << " __ret = "; + C << retS << " iceRet = "; } C << fixKwd(name) << args << ';'; if(ret || !outParams.empty()) { - C << nl << "::Ice::OutputStream* __os = __inS.startWriteParams();"; + C << nl << "::Ice::OutputStream* iceOs = iceInS.startWriteParams();"; writeMarshalCode(C, outParams, p, true); if(p->returnsClasses(false)) { - C << nl << "__os->writePendingValues();"; + C << nl << "iceOs->writePendingValues();"; } - C << nl << "__inS.endWriteParams();"; + C << nl << "iceInS.endWriteParams();"; } else { - C << nl << "__inS.writeEmptyParams();"; + C << nl << "iceInS.writeEmptyParams();"; } C << nl << "return false;"; } @@ -3082,16 +3082,16 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p) H << sp << nl << "virtual ::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI << epar << " = 0;"; H << sp << nl << "virtual ::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI - << "const ::Ice::CallbackPtr& __del" - << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar << " = 0;"; + << "const ::Ice::CallbackPtr& iceDel" + << "const ::Ice::LocalObjectPtr& iceCookie = 0" << epar << " = 0;"; string clScope = fixKwd(cl->scope()); string delName = "Callback_" + cl->name() + "_" + name; string delNameScoped = clScope + delName; H << sp << nl << "virtual ::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI - << "const " + delNameScoped + "Ptr& __del" - << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar << " = 0;"; + << "const " + delNameScoped + "Ptr& iceDel" + << "const ::Ice::LocalObjectPtr& iceCookie = 0" << epar << " = 0;"; H << sp << nl << "virtual " << retS << " end_" << name << spar << outParamsDeclAMI << "const ::Ice::AsyncResultPtr&" << epar << " = 0;"; @@ -3126,7 +3126,7 @@ Slice::Gen::ObjectVisitor::emitGCFunctions(const ClassDefPtr& p) bool preserved = basePreserved || p->hasMetaData("preserve-slice"); // - // __gcVisit() is overridden by the basemost class that can be + // iceGcVisit() is overridden by the basemost class that can be // cyclic, plus all classes derived from that class. // // We also override these methods for the initial preserved class in a @@ -3134,22 +3134,22 @@ Slice::Gen::ObjectVisitor::emitGCFunctions(const ClassDefPtr& p) // if(canBeCyclic || (preserved && !basePreserved)) { - H << nl << "virtual void __gcVisitMembers(::IceInternal::GCVisitor&);"; + H << nl << "virtual void iceGcVisitMembers(::IceInternal::GCVisitor&);"; - C << sp << nl << "void" << nl << scoped.substr(2) << "::__gcVisitMembers(::IceInternal::GCVisitor& _v)"; + C << sp << nl << "void" << nl << scoped.substr(2) << "::iceGcVisitMembers(::IceInternal::GCVisitor& _v)"; C << sb; bool hasCyclicBase = base && base->canBeCyclic(); if(hasCyclicBase || basePreserved) { - emitUpcall(bases.front(), "::__gcVisitMembers(_v);"); + emitUpcall(bases.front(), "::iceGcVisitMembers(_v);"); } if(preserved && !basePreserved) { - C << nl << "if(__slicedData)"; + C << nl << "if(_slicedData)"; C << sb; - C << nl << "__slicedData->__gcVisitMembers(_v);"; + C << nl << "_slicedData->iceGcVisitMembers(_v);"; C << eb; } @@ -3188,11 +3188,11 @@ Slice::Gen::ObjectVisitor::emitGCVisitCode(const TypePtr& p, const string& prefi if(decl) { string scope = fixKwd(decl->scope()); - C << nl << "if((" << scope << "upCast(" << prefix << name << ".get())->__gcVisit(_v)))"; + C << nl << "if((" << scope << "upCast(" << prefix << name << ".get())->iceGcVisit(_v)))"; } else { - C << nl << "if((" << prefix << name << ".get())->__gcVisit(_v))"; + C << nl << "if((" << prefix << name << ".get())->iceGcVisit(_v))"; } C << sb; C << nl << prefix << name << " = 0;"; @@ -3276,7 +3276,7 @@ Slice::Gen::ObjectVisitor::emitVirtualBaseInitializers(const ClassDefPtr& p, boo { upcall += ", "; } - upcall += "__ice_" + (*q)->name(); + upcall += "iceP_" + (*q)->name(); } upcall += ")"; @@ -3304,7 +3304,7 @@ Slice::Gen::ObjectVisitor::emitOneShotConstructor(const ClassDefPtr& p) string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring); bool dataMember = std::find(dataMembers.begin(), dataMembers.end(), (*q)) != dataMembers.end(); allParamDecls.push_back(typeName + ((dataMember || callBaseConstuctors) ? - (" __ice_" + (*q)->name()) : (" /*__ice_" + (*q)->name() + "*/"))); + (" iceP_" + (*q)->name()) : (" /*iceP_" + (*q)->name() + "*/"))); } H << sp << nl; @@ -3344,7 +3344,7 @@ Slice::Gen::ObjectVisitor::emitOneShotConstructor(const ClassDefPtr& p) H << ',' << nl; } string memberName = fixKwd((*q)->name()); - H << memberName << '(' << "__ice_" << (*q)->name() << ')'; + H << memberName << '(' << "iceP_" << (*q)->name() << ')'; } H.dec(); @@ -3491,7 +3491,7 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr& TypePtr ret = p->returnType(); string retS = inputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring); - string retEndArg = getEndArg(ret, p->getMetaData(), "__ret"); + string retEndArg = getEndArg(ret, p->getMetaData(), "iceRet"); ParamDeclList outParams; vector<string> outArgs; @@ -3592,10 +3592,10 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr& // // completed. // - H << sp << nl << "virtual void completed(const ::Ice::AsyncResultPtr& __result) const"; + H << sp << nl << "virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const"; H << sb; - H << nl << clScope << clName << "Prx __proxy = " << clScope << clName - << "Prx::uncheckedCast(__result->getProxy());"; + H << nl << clScope << clName << "Prx iceProxy = " << clScope << clName + << "Prx::uncheckedCast(iceResult->getProxy());"; writeAllocateCode(H, outParams, p, false, _useWstring | TypeContextInParam | TypeContextAMICallPrivateEnd); H << nl << "try"; H << sb; @@ -3606,23 +3606,23 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr& { H << retEndArg << " = "; } - H << "__proxy->end_" << p->name() << spar << outEndArgs << "__result" << epar << ';'; + H << "iceProxy->end_" << p->name() << spar << outEndArgs << "iceResult" << epar << ';'; } else { - H << "__proxy->___end_" << p->name() << spar << outEndArgs; + H << "iceProxy->iceI_end_" << p->name() << spar << outEndArgs; if(ret) { H << retEndArg; } - H << "__result" << epar << ';'; + H << "iceResult" << epar << ';'; } writeEndCode(H, outParams, p); H << eb; H << nl << "catch(const ::Ice::Exception& ex)"; H << sb; - H << nl << "" << baseD << "::exception(__result, ex);"; + H << nl << "" << baseD << "::exception(iceResult, ex);"; H << nl << "return;"; H << eb; H << nl << "if(_response)"; @@ -3630,12 +3630,12 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr& H << nl << "(" << baseD << "::_callback.get()->*_response)" << spar; if(ret) { - H << "__ret"; + H << "iceRet"; } H << outArgs; if(withCookie) { - H << "CT::dynamicCast(__result->getCookie())"; + H << "CT::dynamicCast(iceResult->getCookie())"; } H << epar << ';'; H << eb; @@ -4085,7 +4085,7 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p) vector<string> paramsDeclInvoke; paramsInvoke.push_back("const " + proxyName + "&"); - paramsDeclInvoke.push_back("const " + proxyName + "& __prx"); + paramsDeclInvoke.push_back("const " + proxyName + "& icePrx"); TypePtr ret = p->returnType(); string retS = inputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring); @@ -4094,8 +4094,8 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p) { params.push_back(retS); paramsAMD.push_back(inputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring)); - paramsDecl.push_back(retS + " __ret"); - args.push_back("__ret"); + paramsDecl.push_back(retS + " iceRet"); + args.push_back("iceRet"); } ParamDeclList inParams; @@ -4126,7 +4126,7 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p) } paramsInvoke.push_back("const ::Ice::Context&"); - paramsDeclInvoke.push_back("const ::Ice::Context& __ctx"); + paramsDeclInvoke.push_back("const ::Ice::Context& iceCtx"); if(cl->hasMetaData("amd") || p->hasMetaData("amd")) { @@ -4245,8 +4245,8 @@ Slice::Gen::AsyncImplVisitor::visitOperation(const OperationPtr& p) params += retS; paramsDecl += retS; paramsDecl += ' '; - paramsDecl += "__ret"; - args += "__ret"; + paramsDecl += "iceRet"; + args += "iceRet"; } ParamDeclList outParams; @@ -4303,11 +4303,11 @@ Slice::Gen::AsyncImplVisitor::visitOperation(const OperationPtr& p) C << sb; if(ret || !outParams.empty()) { - C << nl << "::Ice::OutputStream* __os = startWriteParams();"; + C << nl << "::Ice::OutputStream* iceOs = startWriteParams();"; writeMarshalCode(C, outParams, p, false, TypeContextInParam); if(p->returnsClasses(false)) { - C << nl << "__os->writePendingValues();"; + C << nl << "iceOs->writePendingValues();"; } C << nl << "endWriteParams();"; } @@ -5134,11 +5134,11 @@ Slice::Gen::Cpp11DeclVisitor::visitClassDefStart(const ClassDefPtr& p) C << sp; C << nl << "const ::IceInternal::DefaultValueFactoryInit<" << fixKwd(p->scoped()) << "> "; - C << p->flattenedScope() + p->name() + "_init" << "(\"" << p->scoped() << "\");"; + C << "iceC" + p->flattenedScope() + p->name() + "_init" << "(\"" << p->scoped() << "\");"; if(p->compactId() >= 0) { - string n = p->flattenedScope() + p->name() + "_compactIdInit "; + string n = "iceC" + p->flattenedScope() + p->name() + "_compactIdInit "; C << "const ::IceInternal::CompactIdInit " << n << "(\"" << p->scoped() << "\", " << p->compactId() << ");"; } } @@ -5158,7 +5158,7 @@ Slice::Gen::Cpp11DeclVisitor::visitClassDefStart(const ClassDefPtr& p) ids.merge(other); ids.unique(); - C << nl << "const ::std::string " << p->flattenedScope() << p->name() << "_ids[" << ids.size() << "] ="; + C << nl << "const ::std::string iceC" << p->flattenedScope() << p->name() << "_ids[" << ids.size() << "] ="; C << sb; for(StringList::const_iterator r = ids.begin(); r != ids.end();) { @@ -5179,7 +5179,7 @@ Slice::Gen::Cpp11DeclVisitor::visitClassDefStart(const ClassDefPtr& p) allOpNames.sort(); allOpNames.unique(); - C << nl << "const ::std::string " << p->flattenedScope() << p->name() << "_ops[] ="; + C << nl << "const ::std::string iceC" << p->flattenedScope() << p->name() << "_ops[] ="; C << sb; for(StringList::const_iterator q = allOpNames.begin(); q != allOpNames.end();) { @@ -5205,7 +5205,7 @@ Slice::Gen::Cpp11DeclVisitor::visitExceptionStart(const ExceptionPtr& p) C << sp; C << nl << "const ::IceInternal::DefaultUserExceptionFactoryInit<" << fixKwd(p->scoped()) << "> "; - C << p->flattenedScope() + p->name() + "_init" << "(\"" << p->scoped() << "\");"; + C << "iceC" + p->flattenedScope() + p->name() + "_init" << "(\"" << p->scoped() << "\");"; return false; } @@ -5215,7 +5215,7 @@ Slice::Gen::Cpp11DeclVisitor::visitOperation(const OperationPtr& p) ClassDefPtr cl = ClassDefPtr::dynamicCast(p->container()); if(cl && !cl->isLocal()) { - string flatName = p->flattenedScope() + p->name() + "_name"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_name"; C << nl << "const ::std::string " << flatName << " = \"" << p->name() << "\";"; } } @@ -5288,7 +5288,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring | TypeContextCpp11); allTypes.push_back(typeName); - allParamDecls.push_back(typeName + " " + fixKwd("__ice_" + (*q)->name())); + allParamDecls.push_back(typeName + " " + fixKwd("iceP_" + (*q)->name())); } if(base) @@ -5296,7 +5296,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) baseDataMembers = base->allDataMembers(); for(DataMemberList::const_iterator q = baseDataMembers.begin(); q != baseDataMembers.end(); ++q) { - baseParams.push_back(fixKwd("__ice_" + (*q)->name())); + baseParams.push_back(fixKwd("iceP_" + (*q)->name())); } } @@ -5321,9 +5321,9 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) if(p->isLocal()) { - H << sp << nl << name << "(const char* __ice_file, int __ice_line) : "; + H << sp << nl << name << "(const char* iceFile, int iceLine) : "; H << "::Ice::LocalExceptionHelper" << "<" << templateParameters << ">"; - H << "(__ice_file, __ice_line)"; + H << "(iceFile, iceLine)"; H << sb; H << eb; } @@ -5337,7 +5337,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) H << sp << nl << name << "("; if(p->isLocal()) { - H << "const char* __ice_file, int __ice_line"; + H << "const char* iceFile, int iceLine"; if(!allParamDecls.empty()) { H << ", "; @@ -5359,7 +5359,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) H << nl << "::" << helperClass << "<" << templateParameters << ">" << "("; if(p->isLocal()) { - H << "__ice_file, __ice_line"; + H << "iceFile, iceLine"; if(!baseDataMembers.empty()) { H << ", "; @@ -5374,11 +5374,11 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) } if(isMovable((*q)->type())) { - H << "::std::move(" << fixKwd("__ice_" + (*q)->name()) << ")"; + H << "::std::move(" << fixKwd("iceP_" + (*q)->name()) << ")"; } else { - H << fixKwd("__ice_" + (*q)->name()); + H << fixKwd("iceP_" + (*q)->name()); } } @@ -5391,7 +5391,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) else if(p->isLocal()) { H << " ::Ice::LocalExceptionHelper" << "<" << templateParameters << ">"; - H << "(__ice_file, __ice_line)"; + H << "(iceFile, iceLine)"; if(!dataMembers.empty()) { H << ","; @@ -5406,11 +5406,11 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) } if(isMovable((*q)->type())) { - H << nl << fixKwd((*q)->name()) << "(::std::move(" << fixKwd("__ice_" + (*q)->name()) << "))"; + H << nl << fixKwd((*q)->name()) << "(::std::move(" << fixKwd("iceP_" + (*q)->name()) << "))"; } else { - H << nl << fixKwd((*q)->name()) << "(" << fixKwd("__ice_" + (*q)->name()) << ")"; + H << nl << fixKwd((*q)->name()) << "(" << fixKwd("iceP_" + (*q)->name()) << ")"; } } @@ -5444,10 +5444,10 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) { if(!base || (base && !base->usesClasses(false))) { - H << sp << nl << _dllMemberExport << "virtual bool __usesClasses() const override;"; + H << sp << nl << _dllMemberExport << "virtual bool iceUsesClasses() const override;"; C << sp << nl << "bool"; - C << nl << scoped.substr(2) << "::__usesClasses() const"; + C << nl << scoped.substr(2) << "::iceUsesClasses() const"; C << sb; C << nl << "return true;"; C << eb; @@ -5477,23 +5477,23 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionEnd(const ExceptionPtr& p) if(preserved && !basePreserved) { - H << sp << nl << _dllMemberExport << "virtual void __write(::Ice::OutputStream*) const override;"; - H << nl << _dllMemberExport << "virtual void __read(::Ice::InputStream*) override;"; + H << sp << nl << _dllMemberExport << "virtual void iceWrite(::Ice::OutputStream*) const override;"; + H << nl << _dllMemberExport << "virtual void iceRead(::Ice::InputStream*) override;"; - H << sp << nl << "::std::shared_ptr<::Ice::SlicedData> __slicedData;"; + H << sp << nl << "::std::shared_ptr<::Ice::SlicedData> _slicedData;"; - C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(::Ice::OutputStream* __os) const"; + C << sp << nl << "void" << nl << scoped.substr(2) << "::iceWrite(::Ice::OutputStream* iceOs) const"; C << sb; - C << nl << "__os->startException(__slicedData);"; - C << nl << "__writeImpl(__os);"; - C << nl << "__os->endException();"; + C << nl << "iceOs->startException(_slicedData);"; + C << nl << "iceWriteImpl(iceOs);"; + C << nl << "iceOs->endException();"; C << eb; - C << sp << nl << "void" << nl << scoped.substr(2) << "::__read(::Ice::InputStream* __is)"; + C << sp << nl << "void" << nl << scoped.substr(2) << "::iceRead(::Ice::InputStream* iceIs)"; C << sb; - C << nl << "__is->startException();"; - C << nl << "__readImpl(__is);"; - C << nl << "__slicedData = __is->endException(true);"; + C << nl << "iceIs->startException();"; + C << nl << "iceReadImpl(iceIs);"; + C << nl << "_slicedData = iceIs->endException(true);"; C << eb; } } @@ -5509,7 +5509,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionEnd(const ExceptionPtr& p) if(!_doneStaticSymbol) { _doneStaticSymbol = true; - H << sp << nl << "static " << name << " __" << p->name() << "_init;"; + H << sp << nl << "static " << name << " iceS_" << p->name() << "_init;"; } } @@ -5715,7 +5715,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p) H << sp << nl << prx << "() = default;"; H << nl << "friend ::std::shared_ptr<" << prx << "> IceInternal::createProxy<" << prx << ">();"; H << sp; - H << nl << _dllMemberExport << "virtual ::std::shared_ptr<::Ice::ObjectPrx> __newInstance() const override;"; + H << nl << _dllMemberExport << "virtual ::std::shared_ptr<::Ice::ObjectPrx> iceNewInstance() const override;"; H << eb << ';'; string suffix = p->isInterface() ? "" : "Disp"; @@ -5723,7 +5723,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p) C << sp; C << nl << "::std::shared_ptr<::Ice::ObjectPrx>"; - C << nl << scoped.substr(2) << "::__newInstance() const"; + C << nl << scoped.substr(2) << "::iceNewInstance() const"; C << sb; C << nl << "return ::IceInternal::createProxy<" << prx << ">();"; C << eb; @@ -5740,7 +5740,7 @@ void Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) { string name = p->name(); - string flatName = p->flattenedScope() + p->name() + "_name"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_name"; TypePtr ret = p->returnType(); @@ -5839,7 +5839,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) // Synchronous operation // H << sp << nl << deprecateSymbol << retS << ' ' << fixKwd(name) << spar << paramsDecl; - H << "const ::Ice::Context& __ctx = Ice::noExplicitContext" << epar; + H << "const ::Ice::Context& iceCtx = Ice::noExplicitContext" << epar; H << sb; H << nl; if(futureOutParams.size() == 1) @@ -5855,27 +5855,27 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) } else if(futureOutParams.size() > 1) { - H << "auto __result = "; + H << "auto iceResult = "; } H << "makePromiseOutgoing<" << futureT << ">"; - H << spar << "true, this" << string("&" + scoped + "__" + name); + H << spar << "true, this" << string("&" + scoped + "iceI_" + name); for(ParamDeclList::const_iterator q = inParams.begin(); q != inParams.end(); ++q) { H << fixKwd(paramPrefix + (*q)->name()); } - H << "__ctx" << epar << ".get();"; + H << "iceCtx" << epar << ".get();"; if(futureOutParams.size() > 1) { for(ParamDeclList::const_iterator q = outParams.begin(); q != outParams.end(); ++q) { H << nl << paramPrefix << (*q)->name() << " = "; - H << condMove(isMovable((*q)->type()), "__result." + fixKwd((*q)->name())) + ";"; + H << condMove(isMovable((*q)->type()), "iceResult." + fixKwd((*q)->name())) + ";"; } if(ret) { - H << nl << "return " + condMove(isMovable(ret), "__result." + returnValueS) + ";"; + H << nl << "return " + condMove(isMovable(ret), "iceResult." + returnValueS) + ";"; } } H << eb; @@ -5886,7 +5886,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) H << sp; H << nl << "template<template<typename> class P = ::std::promise>"; H << nl << deprecateSymbol << "auto " << name << "Async" << spar << inParamsDecl; - H << "const ::Ice::Context& __ctx = Ice::noExplicitContext" << epar; + H << "const ::Ice::Context& iceCtx = Ice::noExplicitContext" << epar; H.inc(); H << nl << "-> decltype(::std::declval<P<" << futureT << ">>().get_future())"; H.dec(); @@ -5894,12 +5894,12 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) H << nl << "return makePromiseOutgoing<" << futureT << ", P>" << spar; - H << "false, this" << string("&" + scoped + "__" + name); + H << "false, this" << string("&" + scoped + "iceI_" + name); for(ParamDeclList::const_iterator q = inParams.begin(); q != inParams.end(); ++q) { H << fixKwd(paramPrefix + (*q)->name()); } - H << "__ctx" << epar << ";"; + H << "iceCtx" << epar << ";"; H << eb; @@ -5937,13 +5937,13 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) } H << "::std::function<void" << spar << lambdaOutParams << epar << ">" - + condString(!lambdaCustomOut, " __response") + ","; + + condString(!lambdaCustomOut, " iceResponse") + ","; H << nl << "::std::function<void(::std::exception_ptr)>" - + condString(!lambdaCustomOut, " __ex") + " = nullptr,"; + + condString(!lambdaCustomOut, " iceEx") + " = nullptr,"; H << nl << "::std::function<void(bool)>" - + condString(!lambdaCustomOut," __sent") + " = nullptr,"; + + condString(!lambdaCustomOut," iceSent") + " = nullptr,"; H << nl << "const ::Ice::Context&" - + condString(!lambdaCustomOut, "__ctx") + " = Ice::noExplicitContext)" + condString(lambdaCustomOut, ";"); + + condString(!lambdaCustomOut, "iceCtx") + " = Ice::noExplicitContext)" + condString(lambdaCustomOut, ";"); H.restoreIndent(); if(lambdaCustomOut) @@ -5964,36 +5964,36 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) } C << nl; } - C << "::std::function<void " << spar << lambdaOutParams << epar << "> __response,"; - C << nl << "::std::function<void(::std::exception_ptr)> __ex,"; - C << nl << "::std::function<void(bool)> __sent,"; - C << nl << "const ::Ice::Context& __ctx)"; + C << "::std::function<void " << spar << lambdaOutParams << epar << "> iceResponse,"; + C << nl << "::std::function<void(::std::exception_ptr)> iceEx,"; + C << nl << "::std::function<void(bool)> iceSent,"; + C << nl << "const ::Ice::Context& iceCtx)"; C.restoreIndent(); C << sb; if(p->returnsData()) { - C << nl << "__checkTwowayOnly(" << flatName << ");"; + C << nl << "iceCheckTwowayOnly(" << flatName << ");"; } - C << nl << "::std::function<void(::Ice::InputStream*)> __read;"; - C << nl << "if(__response)"; + C << nl << "::std::function<void(::Ice::InputStream*)> iceRead;"; + C << nl << "if(iceResponse)"; C << sb; - C << nl << "__read = [__response](::Ice::InputStream* __is)"; + C << nl << "iceRead = [iceResponse](::Ice::InputStream* iceIs)"; C << sb; - C << nl << "__is->startEncapsulation();"; + C << nl << "iceIs->startEncapsulation();"; writeAllocateCode(C, outParams, p, true, _useWstring | TypeContextInParam | TypeContextCpp11); writeUnmarshalCode(C, outParams, p, true, _useWstring | TypeContextInParam | TypeContextCpp11); if(p->returnsClasses(false)) { - C << nl << "__is->readPendingValues();"; + C << nl << "iceIs->readPendingValues();"; } - C << nl << "__is->endEncapsulation();"; + C << nl << "iceIs->endEncapsulation();"; C << nl << "try" << sb; - C << nl << "__response" << spar; + C << nl << "iceResponse" << spar; if(ret) { - C << "__ret"; + C << "iceRet"; } for(ParamDeclList::const_iterator q = outParams.begin(); q != outParams.end(); ++q) { @@ -6007,12 +6007,12 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) C << eb; C << eb << ";"; C << eb; - C << nl << "auto __outAsync = ::std::make_shared<::IceInternal::CustomLambdaOutgoing>("; - C << "shared_from_this(), __read, __ex, __sent);"; + C << nl << "auto iceOutAsync = ::std::make_shared<::IceInternal::CustomLambdaOutgoing>("; + C << "shared_from_this(), iceRead, iceEx, iceSent);"; C << sp; - C << nl << "__outAsync->invoke(" << flatName << ", "; - C << operationModeToString(p->sendMode(), true) << ", " << opFormatTypeToString(p) << ", __ctx, "; + C << nl << "iceOutAsync->invoke(" << flatName << ", "; + C << operationModeToString(p->sendMode(), true) << ", " << opFormatTypeToString(p) << ", iceCtx, "; C.inc(); C << nl; @@ -6022,7 +6022,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) C.dec(); C << ");"; - C << nl << "return [__outAsync]() { __outAsync->cancel(); };"; + C << nl << "return [iceOutAsync]() { iceOutAsync->cancel(); };"; C << eb; } else @@ -6034,9 +6034,9 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) H << sb; if(futureOutParams.size() > 1) { - H << nl << "auto __responseCb = [__response](" << futureT << "&& result)"; + H << nl << "auto iceResponseCb = [iceResponse](" << futureT << "&& result)"; H << sb; - H << nl << "__response" << spar; + H << nl << "iceResponse" << spar; if(ret) { @@ -6051,13 +6051,13 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) H << nl << "return makeLambdaOutgoing<" << futureT << ">" << spar; - H << (futureOutParams.size() > 1 ? "__responseCb" : "__response") << "__ex" << "__sent" << "this"; - H << string("&" + scoped + "__" + name); + H << (futureOutParams.size() > 1 ? "iceResponseCb" : "iceResponse") << "iceEx" << "iceSent" << "this"; + H << string("&" + scoped + "iceI_" + name); for(ParamDeclList::const_iterator q = inParams.begin(); q != inParams.end(); ++q) { H << fixKwd(paramPrefix + (*q)->name()); } - H << "__ctx" << epar << ";"; + H << "iceCtx" << epar << ";"; H << eb; } @@ -6066,24 +6066,24 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) // H << sp; - H << nl << _dllMemberExport << "void __" << name << spar; + H << nl << _dllMemberExport << "void iceI_" << name << spar; H << "const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<" + futureT + ">>&"; H << inParamsS; H << "const ::Ice::Context&"; H << epar << ";"; C << sp; - C << nl << "void" << nl << scoped << "__" << name << spar; - C << "const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<" + futureT + ">>& __outAsync"; - C << inParamsDecl << "const ::Ice::Context& __ctx"; + C << nl << "void" << nl << scoped << "iceI_" << name << spar; + C << "const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<" + futureT + ">>& iceOutAsync"; + C << inParamsDecl << "const ::Ice::Context& iceCtx"; C << epar; C << sb; if(p->returnsData()) { - C << nl << "__checkTwowayOnly(" << flatName << ");"; + C << nl << "iceCheckTwowayOnly(" << flatName << ");"; } - C << nl << "__outAsync->invoke(" << flatName << ", "; - C << operationModeToString(p->sendMode(), true) << ", " << opFormatTypeToString(p) << ", __ctx, "; + C << nl << "iceOutAsync->invoke(" << flatName << ", "; + C << operationModeToString(p->sendMode(), true) << ", " << opFormatTypeToString(p) << ", iceCtx, "; C.inc(); C << nl; @@ -6098,14 +6098,14 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) // only one, we rely on the default read method from LambdaOutgoing // except if the unique ret/out is optional or is an array/range. // - C << "," << nl << "[](::Ice::InputStream* __is)"; + C << "," << nl << "[](::Ice::InputStream* iceIs)"; C << sb; C << nl << futureT << " v;"; writeUnmarshalCode(C, outParams, p, false, _useWstring | TypeContextCpp11, returnValueS, "v"); if(p->returnsClasses(false)) { - C << nl << "__is->readPendingValues();"; + C << nl << "iceIs->readPendingValues();"; } C << nl << "return v;"; C << eb; @@ -6117,7 +6117,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) // a read method, we can't rely on the default read method which wouldn't // known which tag to use. // - C << "," << nl << "[](::Ice::InputStream* __is)"; + C << "," << nl << "[](::Ice::InputStream* iceIs)"; C << sb; writeAllocateCode(C, outParams, p, true, _useWstring | TypeContextCpp11); @@ -6125,12 +6125,12 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) if(p->returnsClasses(false)) { - C << nl << "__is->readPendingValues();"; + C << nl << "iceIs->readPendingValues();"; } if(ret) { - C << nl << "return __ret;"; + C << nl << "return iceRet;"; } else { @@ -6356,7 +6356,7 @@ Slice::Gen::Cpp11LocalObjectVisitor::visitClassDefStart(const ClassDefPtr& p) { string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring); allTypes.push_back(typeName); - allParamDecls.push_back(typeName + " __ice_" + (*q)->name()); + allParamDecls.push_back(typeName + " iceP_" + (*q)->name()); } if(!p->isInterface()) @@ -6569,7 +6569,7 @@ Slice::Gen::Cpp11LocalObjectVisitor::visitOperation(const OperationPtr& p) H.dec(); H << sb; H << nl << "using Promise = P<bool>;"; - H << nl << "auto __promise = ::std::make_shared<Promise>();"; + H << nl << "auto icePromise = ::std::make_shared<Promise>();"; H << nl << name << "Async("; H.useCurrentPosAsIndent(); @@ -6581,17 +6581,17 @@ Slice::Gen::Cpp11LocalObjectVisitor::visitOperation(const OperationPtr& p) { H << nl; } - H << "[__promise](::std::exception_ptr __ex)"; + H << "[icePromise](::std::exception_ptr iceEx)"; H << sb; - H << nl << "__promise->set_exception(::std::move(__ex));"; + H << nl << "icePromise->set_exception(::std::move(iceEx));"; H << eb << ","; - H << nl << "[__promise](bool __b)"; + H << nl << "[icePromise](bool iceB)"; H << sb; - H << nl << "__promise->set_value(__b);"; + H << nl << "icePromise->set_value(iceB);"; H << eb << ");"; H.restoreIndent(); - H << nl << "return __promise->get_future();"; + H << nl << "return icePromise->get_future();"; H << eb; } } @@ -6707,7 +6707,7 @@ Slice::Gen::Cpp11InterfaceVisitor::visitClassDefStart(const ClassDefPtr& p) H << nl << "virtual ::std::string ice_id(const ::Ice::Current& = ::Ice::noExplicitCurrent) const override;"; H << sp << nl << "static const ::std::string& ice_staticId();"; - string flatName = p->flattenedScope() + p->name() + "_ids"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_ids"; C << sp; C << nl << "bool" << nl << scoped.substr(2) << "::ice_isA(::std::string _s, const ::Ice::Current&) const"; @@ -6766,14 +6766,14 @@ Slice::Gen::Cpp11InterfaceVisitor::visitClassDefEnd(const ClassDefPtr& p) allOpNames.sort(); allOpNames.unique(); - string flatName = p->flattenedScope() + p->name() + "_ops"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_ops"; H << sp; - H << nl << "virtual bool __dispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;"; + H << nl << "virtual bool iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;"; C << sp; C << nl << "bool"; - C << nl << scoped.substr(2) << "::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& c)"; + C << nl << scoped.substr(2) << "::iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& c)"; C << sb; C << nl << "::std::pair< const ::std::string*, const ::std::string*> r = " @@ -6790,7 +6790,7 @@ Slice::Gen::Cpp11InterfaceVisitor::visitClassDefEnd(const ClassDefPtr& p) { C << nl << "case " << i++ << ':'; C << sb; - C << nl << "return ___" << *q << "(in, c);"; + C << nl << "return iceD_" << *q << "(in, c);"; C << eb; } C << nl << "default:"; @@ -6851,7 +6851,7 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p) { string typeS = inputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring | TypeContextCpp11); responseParams.push_back(typeS); - responseParamsDecl.push_back(typeS + " __ret"); + responseParamsDecl.push_back(typeS + " iceRet"); } string retS; @@ -6909,13 +6909,13 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p) else { params.push_back("::std::function<void(" + joinString(responseParams, ",") + ")>"); - args.push_back(ret || !outParams.empty() ? "__responseCB" : "inS->response()"); + args.push_back(ret || !outParams.empty() ? "iceResponseCB" : "inS->response()"); } params.push_back("::std::function<void(::std::exception_ptr)>"); args.push_back("inS->exception()"); } params.push_back("const ::Ice::Current& = ::Ice::noExplicitCurrent"); - args.push_back("__current"); + args.push_back("iceCurrent"); if(cl->isInterface()) { @@ -6935,18 +6935,18 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p) H << eb << ';'; C << sp << nl << scope.substr(2) << resultName << "::" << resultName; - C << spar << responseParamsDecl << "const ::Ice::Current& __current" << epar << ":"; + C << spar << responseParamsDecl << "const ::Ice::Current& iceCurrent" << epar << ":"; C.inc(); - C << nl << "MarshaledResult(__current)"; + C << nl << "MarshaledResult(iceCurrent)"; C.dec(); C << sb; - C << nl << "__os->startEncapsulation(__current.encoding, " << opFormatTypeToString(p) << ");"; - writeMarshalCode(C, outParams, p, true, TypeContextCpp11); + C << nl << "_os->startEncapsulation(iceCurrent.encoding, " << opFormatTypeToString(p) << ");"; + writeMarshalCode(C, outParams, p, true, TypeContextCpp11, "_os"); if(p->returnsClasses(false)) { - C << nl << "__os->writePendingValues();"; + C << nl << "_os->writePendingValues();"; } - C << nl << "__os->endEncapsulation();"; + C << nl << "_os->endEncapsulation();"; C << eb; } @@ -6957,33 +6957,33 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p) H << sp; H << nl << deprecateSymbol << "virtual " << retS << ' ' << opName << spar << params << epar << isConst << " = 0;"; - H << nl << "bool ___" << name << "(::IceInternal::Incoming&, const ::Ice::Current&)" << isConst << ';'; + H << nl << "bool iceD_" << name << "(::IceInternal::Incoming&, const ::Ice::Current&)" << isConst << ';'; C << sp; C << nl << "bool"; C << nl << scope.substr(2); - C << "___" << name << "(::IceInternal::Incoming& __inS" << ", const ::Ice::Current& __current)" << isConst; + C << "iceD_" << name << "(::IceInternal::Incoming& iceInS" << ", const ::Ice::Current& iceCurrent)" << isConst; C << sb; - C << nl << "__checkMode(" << operationModeToString(p->mode(), true) << ", __current.mode);"; + C << nl << "iceCheckMode(" << operationModeToString(p->mode(), true) << ", iceCurrent.mode);"; if(!inParams.empty()) { - C << nl << "auto __is = __inS.startReadParams();"; + C << nl << "auto iceIs = iceInS.startReadParams();"; writeAllocateCode(C, inParams, 0, true, _useWstring | TypeContextInParam | TypeContextCpp11); writeUnmarshalCode(C, inParams, 0, true, _useWstring | TypeContextInParam | TypeContextCpp11); if(p->sendsClasses(false)) { - C << nl << "__is->readPendingValues();"; + C << nl << "iceIs->readPendingValues();"; } - C << nl << "__inS.endReadParams();"; + C << nl << "iceInS.endReadParams();"; } else { - C << nl << "__inS.readEmptyParams();"; + C << nl << "iceInS.readEmptyParams();"; } if(p->format() != DefaultFormat) { - C << nl << "__inS.setFormat(" << opFormatTypeToString(p) << ");"; + C << nl << "iceInS.setFormat(" << opFormatTypeToString(p) << ");"; } if(!amd) @@ -6991,11 +6991,11 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p) writeAllocateCode(C, outParams, 0, true, _useWstring | TypeContextCpp11); if(p->hasMarshaledResult()) { - C << nl << "__inS.setMarshaledResult("; + C << nl << "iceInS.setMarshaledResult("; } else if(ret) { - C << nl << retS << " __ret = "; + C << nl << retS << " iceRet = "; } else { @@ -7012,33 +7012,33 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p) C << ";"; if(ret || !outParams.empty()) { - C << nl << "auto __os = __inS.startWriteParams();"; + C << nl << "auto iceOs = iceInS.startWriteParams();"; writeMarshalCode(C, outParams, p, true, TypeContextCpp11); if(p->returnsClasses(false)) { - C << nl << "__os->writePendingValues();"; + C << nl << "iceOs->writePendingValues();"; } - C << nl << "__inS.endWriteParams();"; + C << nl << "iceInS.endWriteParams();"; } else { - C << nl << "__inS.writeEmptyParams();"; + C << nl << "iceInS.writeEmptyParams();"; } } C << nl << "return false;"; } else { - C << nl << "auto inS = ::IceInternal::IncomingAsync::create(__inS);"; + C << nl << "auto inS = ::IceInternal::IncomingAsync::create(iceInS);"; if(!p->hasMarshaledResult() && (ret || !outParams.empty())) { - C << nl << "auto __responseCB = [inS]" << spar << responseParamsDecl << epar; + C << nl << "auto iceResponseCB = [inS]" << spar << responseParamsDecl << epar; C << sb; - C << nl << "auto __os = inS->startWriteParams();"; + C << nl << "auto iceOs = inS->startWriteParams();"; writeMarshalCode(C, outParams, p, true, TypeContextCpp11); if(p->returnsClasses(false)) { - C << nl << "__os->writePendingValues();"; + C << nl << "iceOs->writePendingValues();"; } C << nl << "inS->endWriteParams();"; C << nl << "inS->completed();"; @@ -7159,23 +7159,23 @@ Slice::Gen::Cpp11ValueVisitor::visitClassDefEnd(const ClassDefPtr& p) if(preserved && !basePreserved) { H << sp; - H << nl << "virtual void __write(::Ice::OutputStream*) const override;"; - H << nl << "virtual void __read(::Ice::InputStream*) override;"; + H << nl << "virtual void iceWrite(::Ice::OutputStream*) const override;"; + H << nl << "virtual void iceRead(::Ice::InputStream*) override;"; C << sp; - C << nl << "void" << nl << scoped.substr(2) << "::__write(::Ice::OutputStream* __os) const"; + C << nl << "void" << nl << scoped.substr(2) << "::iceWrite(::Ice::OutputStream* iceOs) const"; C << sb; - C << nl << "__os->startValue(__slicedData);"; - C << nl << "__writeImpl(__os);"; - C << nl << "__os->endValue();"; + C << nl << "iceOs->startValue(_slicedData);"; + C << nl << "iceWriteImpl(iceOs);"; + C << nl << "iceOs->endValue();"; C << eb; C << sp; - C << nl << "void" << nl << scoped.substr(2) << "::__read(::Ice::InputStream* __is)"; + C << nl << "void" << nl << scoped.substr(2) << "::iceRead(::Ice::InputStream* iceIs)"; C << sb; - C << nl << "__is->startValue();"; - C << nl << "__readImpl(__is);"; - C << nl << "__slicedData = __is->endValue(true);"; + C << nl << "iceIs->startValue();"; + C << nl << "iceReadImpl(iceIs);"; + C << nl << "_slicedData = iceIs->endValue(true);"; C << eb; } @@ -7242,7 +7242,7 @@ Slice::Gen::Cpp11ValueVisitor::visitClassDefEnd(const ClassDefPtr& p) H.inc(); inProtected = true; } - H << sp << nl << "::std::shared_ptr<::Ice::SlicedData> __slicedData;"; + H << sp << nl << "::std::shared_ptr<::Ice::SlicedData> _slicedData;"; } if(generateFriend) @@ -7314,11 +7314,11 @@ Slice::Gen::Cpp11ObjectVisitor::emitVirtualBaseInitializers(const ClassDefPtr& d } if(isMovable((*q)->type())) { - upcall += "::std::move(__ice_" + (*q)->name() + ")"; + upcall += "::std::move(iceP_" + (*q)->name() + ")"; } else { - upcall += "__ice_" + (*q)->name(); + upcall += "iceP_" + (*q)->name(); } } upcall += ")"; @@ -7349,7 +7349,7 @@ Slice::Gen::Cpp11ObjectVisitor::emitOneShotConstructor(const ClassDefPtr& p) { string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring | TypeContextCpp11); - allParamDecls.push_back(typeName + " __ice_" + (*q)->name()); + allParamDecls.push_back(typeName + " iceP_" + (*q)->name()); } H << sp << nl; @@ -7387,11 +7387,11 @@ Slice::Gen::Cpp11ObjectVisitor::emitOneShotConstructor(const ClassDefPtr& p) string memberName = fixKwd((*q)->name()); if(isMovable((*q)->type())) { - H << memberName << "(::std::move(" << "__ice_" << (*q)->name() << "))"; + H << memberName << "(::std::move(" << "iceP_" << (*q)->name() << "))"; } else { - H << memberName << '(' << "__ice_" << (*q)->name() << ')'; + H << memberName << '(' << "iceP_" << (*q)->name() << ')'; } } @@ -7756,7 +7756,7 @@ Slice::Gen::Cpp11ImplVisitor::visitClassDefStart(const ClassDefPtr& p) string typeS = inputTypeToString(ret, op->returnIsOptional(), op->getMetaData(), _useWstring | TypeContextCpp11); responseParams = typeS; - responseParamsDecl = typeS + " __ret"; + responseParamsDecl = typeS + " iceRet"; if(!outParams.empty()) { responseParams += ", "; diff --git a/cpp/test/Ice/dispatcher/Dispatcher.cpp b/cpp/test/Ice/dispatcher/Dispatcher.cpp index c725a9af4a1..93b72a313c7 100644 --- a/cpp/test/Ice/dispatcher/Dispatcher.cpp +++ b/cpp/test/Ice/dispatcher/Dispatcher.cpp @@ -18,9 +18,9 @@ Dispatcher::Dispatcher() { _instance = this; _terminated = false; - __setNoDelete(true); + iceSetNoDelete(true); start(); - __setNoDelete(false); + iceSetNoDelete(false); } void diff --git a/cpp/test/Ice/gc/Client.cpp b/cpp/test/Ice/gc/Client.cpp index 4298d102621..e6f6c9f188d 100644 --- a/cpp/test/Ice/gc/Client.cpp +++ b/cpp/test/Ice/gc/Client.cpp @@ -132,15 +132,15 @@ public: virtual bool visit(IceInternal::GCObject* obj) { - if(obj->__hasFlag(IceInternal::GCObject::Visiting)) + if(obj->iceHasFlag(IceInternal::GCObject::Visiting)) { return false; } - test(obj->__hasFlag(IceInternal::GCObject::CycleMember) && obj->__hasFlag(IceInternal::GCObject::Collectable)); + test(obj->iceHasFlag(IceInternal::GCObject::CycleMember) && obj->iceHasFlag(IceInternal::GCObject::Collectable)); - obj->__setFlag(IceInternal::GCObject::Visiting); - obj->__gcVisitMembers(*this); - obj->__clearFlag(IceInternal::GCObject::Visiting); + obj->iceSetFlag(IceInternal::GCObject::Visiting); + obj->iceGcVisitMembers(*this); + obj->iceClearFlag(IceInternal::GCObject::Visiting); return false; } }; diff --git a/cpp/test/Ice/hash/Client.cpp b/cpp/test/Ice/hash/Client.cpp index dd1cc6ee4d8..c6be6fbf8d2 100644 --- a/cpp/test/Ice/hash/Client.cpp +++ b/cpp/test/Ice/hash/Client.cpp @@ -53,11 +53,11 @@ int main(int argc, char** argv) Ice::ObjectPrxPtr obj = communicator->stringToProxy(os.str()); Ice::EndpointSeq endpoints = obj->ice_getEndpoints(); - if(!seenProxy.insert(make_pair(obj->__hash(), obj)).second) + if(!seenProxy.insert(make_pair(obj->iceHash(), obj)).second) { ++proxyCollisions; } - test(obj->__hash() == obj->__hash()); + test(obj->iceHash() == obj->iceHash()); } test(proxyCollisions < maxCollisions); @@ -76,27 +76,27 @@ int main(int argc, char** argv) Ice::ObjectPrxPtr prx10 = communicator->stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011 -t 10000"); map<string, int> proxyMap; - proxyMap["prx1"] = prx1->__hash(); - proxyMap["prx2"] = prx2->__hash(); - proxyMap["prx3"] = prx3->__hash(); - proxyMap["prx4"] = prx4->__hash(); - proxyMap["prx5"] = prx5->__hash(); - proxyMap["prx6"] = prx6->__hash(); - proxyMap["prx7"] = prx7->__hash(); - proxyMap["prx8"] = prx8->__hash(); - proxyMap["prx9"] = prx9->__hash(); - proxyMap["prx10"] = prx10->__hash(); + proxyMap["prx1"] = prx1->iceHash(); + proxyMap["prx2"] = prx2->iceHash(); + proxyMap["prx3"] = prx3->iceHash(); + proxyMap["prx4"] = prx4->iceHash(); + proxyMap["prx5"] = prx5->iceHash(); + proxyMap["prx6"] = prx6->iceHash(); + proxyMap["prx7"] = prx7->iceHash(); + proxyMap["prx8"] = prx8->iceHash(); + proxyMap["prx9"] = prx9->iceHash(); + proxyMap["prx10"] = prx10->iceHash(); - test( communicator->stringToProxy("Glacier2/router:tcp -p 10010")->__hash() == proxyMap["prx1"]); - test( communicator->stringToProxy("Glacier2/router:ssl -p 10011")->__hash() == proxyMap["prx2"]); - test( communicator->stringToProxy("Glacier2/router:udp -p 10012")->__hash() == proxyMap["prx3"]); - test( communicator->stringToProxy("Glacier2/router:tcp -h zeroc.com -p 10010")->__hash() == proxyMap["prx4"]); - test( communicator->stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011")->__hash() == proxyMap["prx5"]); - test( communicator->stringToProxy("Glacier2/router:udp -h zeroc.com -p 10012")->__hash() == proxyMap["prx6"]); - test( communicator->stringToProxy("Glacier2/router:tcp -p 10010 -t 10000")->__hash() == proxyMap["prx7"]); - test( communicator->stringToProxy("Glacier2/router:ssl -p 10011 -t 10000")->__hash() == proxyMap["prx8"]); - test( communicator->stringToProxy("Glacier2/router:tcp -h zeroc.com -p 10010 -t 10000")->__hash() == proxyMap["prx9"]); - test( communicator->stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011 -t 10000")->__hash() == proxyMap["prx10"]); + test( communicator->stringToProxy("Glacier2/router:tcp -p 10010")->iceHash() == proxyMap["prx1"]); + test( communicator->stringToProxy("Glacier2/router:ssl -p 10011")->iceHash() == proxyMap["prx2"]); + test( communicator->stringToProxy("Glacier2/router:udp -p 10012")->iceHash() == proxyMap["prx3"]); + test( communicator->stringToProxy("Glacier2/router:tcp -h zeroc.com -p 10010")->iceHash() == proxyMap["prx4"]); + test( communicator->stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011")->iceHash() == proxyMap["prx5"]); + test( communicator->stringToProxy("Glacier2/router:udp -h zeroc.com -p 10012")->iceHash() == proxyMap["prx6"]); + test( communicator->stringToProxy("Glacier2/router:tcp -p 10010 -t 10000")->iceHash() == proxyMap["prx7"]); + test( communicator->stringToProxy("Glacier2/router:ssl -p 10011 -t 10000")->iceHash() == proxyMap["prx8"]); + test( communicator->stringToProxy("Glacier2/router:tcp -h zeroc.com -p 10010 -t 10000")->iceHash() == proxyMap["prx9"]); + test( communicator->stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011 -t 10000")->iceHash() == proxyMap["prx10"]); cerr << "ok" << endl; diff --git a/cpp/test/Ice/optional/AllTests.cpp b/cpp/test/Ice/optional/AllTests.cpp index 6aa46b6d691..945337fd385 100644 --- a/cpp/test/Ice/optional/AllTests.cpp +++ b/cpp/test/Ice/optional/AllTests.cpp @@ -50,9 +50,9 @@ class TestObjectReader : public Ice::Object #endif { public: - virtual void __write(Ice::OutputStream*) const { } + virtual void iceWrite(Ice::OutputStream*) const { } - virtual void __read(Ice::InputStream* in) + virtual void iceRead(Ice::InputStream* in) { in->startValue(); in->startSlice(); @@ -80,9 +80,9 @@ class BObjectReader : public Ice::Object #endif { public: - virtual void __write(Ice::OutputStream*) const { } + virtual void iceWrite(Ice::OutputStream*) const { } - virtual void __read(Ice::InputStream* in) + virtual void iceRead(Ice::InputStream* in) { in->startValue(); // ::Test::B @@ -117,9 +117,9 @@ class CObjectReader : public Ice::Object #endif { public: - virtual void __write(Ice::OutputStream*) const { } + virtual void iceWrite(Ice::OutputStream*) const { } - virtual void __read(Ice::InputStream* in) + virtual void iceRead(Ice::InputStream* in) { in->startValue(); // ::Test::C @@ -158,7 +158,7 @@ class DObjectWriter : public Ice::Object { public: - virtual void __write(Ice::OutputStream* out) const + virtual void iceWrite(Ice::OutputStream* out) const { out->startValue(0); // ::Test::D @@ -188,7 +188,7 @@ public: out->endValue(); } - virtual void __read(Ice::InputStream*) { } + virtual void iceRead(Ice::InputStream*) { } #ifdef ICE_CPP11_MAPPING @@ -211,9 +211,9 @@ class DObjectReader : public Ice::Object #endif { public: - virtual void __write(Ice::OutputStream*) const { } + virtual void iceWrite(Ice::OutputStream*) const { } - virtual void __read(Ice::InputStream* in) + virtual void iceRead(Ice::InputStream* in) { in->startValue(); // ::Test::D @@ -268,9 +268,9 @@ class FObjectReader : public Ice::Object #endif { public: - virtual void __write(Ice::OutputStream*) const { } + virtual void iceWrite(Ice::OutputStream*) const { } - virtual void __read(Ice::InputStream* in) + virtual void iceRead(Ice::InputStream* in) { _f = ICE_MAKE_SHARED(F); in->startValue(); diff --git a/cpp/test/Ice/stream/Client.cpp b/cpp/test/Ice/stream/Client.cpp index 31ab757aa7f..bcff7f85e9a 100644 --- a/cpp/test/Ice/stream/Client.cpp +++ b/cpp/test/Ice/stream/Client.cpp @@ -32,13 +32,13 @@ public: called = false; } - virtual void __write(Ice::OutputStream* out) const + virtual void iceWrite(Ice::OutputStream* out) const { - obj->__write(out); + obj->iceWrite(out); const_cast<TestObjectWriter*>(this)->called = true; } - virtual void __read(Ice::InputStream*) + virtual void iceRead(Ice::InputStream*) { assert(false); } @@ -61,15 +61,15 @@ public: called = false; } - virtual void __write(Ice::OutputStream*) const + virtual void iceWrite(Ice::OutputStream*) const { assert(false); } - virtual void __read(Ice::InputStream* in) + virtual void iceRead(Ice::InputStream* in) { obj = ICE_MAKE_SHARED(MyClass); - obj->__read(in); + obj->iceRead(in); called = true; } @@ -78,29 +78,29 @@ public: }; ICE_DEFINE_PTR(TestObjectReaderPtr, TestObjectReader); -// Required for ValueHelper<>'s __readImpl and __writeIpml +// Required for ValueHelper<>'s iceReadImpl and iceWriteIpml #ifdef ICE_CPP11_MAPPING namespace Ice { template<class S> struct StreamWriter<TestObjectWriter, S> { - static void write(S* __os, const TestObjectWriter&) { assert(false); } + static void write(S* iceOs, const TestObjectWriter&) { assert(false); } }; template<class S> struct StreamReader<TestObjectWriter, S> { - static void read(S* __is, TestObjectWriter&) { assert(false); } + static void read(S* iceIs, TestObjectWriter&) { assert(false); } }; template<class S> struct StreamWriter<TestObjectReader, S> { - static void write(S* __os, const TestObjectReader&) { assert(false); } + static void write(S* iceOs, const TestObjectReader&) { assert(false); } }; template<class S> struct StreamReader<TestObjectReader, S> { - static void read(S* __is, TestObjectReader&) { assert(false); } + static void read(S* iceIs, TestObjectReader&) { assert(false); } }; } #endif diff --git a/objective-c/src/Ice/Dispatcher.mm b/objective-c/src/Ice/Dispatcher.mm index 33462e12fde..e71b84b38fb 100644 --- a/objective-c/src/Ice/Dispatcher.mm +++ b/objective-c/src/Ice/Dispatcher.mm @@ -85,12 +85,12 @@ typedef IceUtil::Handle<DispatcherI> DispatcherIPtr; } cxxCall_ = call; - cxxCall_->__incRef(); + cxxCall_->iceIncRef(); return self; } -(void) dealloc { - cxxCall_->__decRef(); + cxxCall_->iceDecRef(); cxxCall_ = 0; [super dealloc]; } diff --git a/objective-c/src/Ice/ImplicitContextI.mm b/objective-c/src/Ice/ImplicitContextI.mm index 92b12edcf96..9bce79d6917 100644 --- a/objective-c/src/Ice/ImplicitContextI.mm +++ b/objective-c/src/Ice/ImplicitContextI.mm @@ -18,7 +18,7 @@ if(self) { self->implicitContext__ = implicitContext; - self->implicitContext__->__incRef(); + self->implicitContext__->iceIncRef(); } return self; } @@ -37,7 +37,7 @@ -(void) dealloc { - self->implicitContext__->__decRef(); + self->implicitContext__->iceDecRef(); [super dealloc]; } diff --git a/objective-c/src/Ice/LocalObject.mm b/objective-c/src/Ice/LocalObject.mm index 70b7dc692fa..0ccf9bc7dbf 100644 --- a/objective-c/src/Ice/LocalObject.mm +++ b/objective-c/src/Ice/LocalObject.mm @@ -43,7 +43,7 @@ std::map<IceUtil::Shared*, ICELocalObject*> cachedObjects; return nil; } cxxObject_ = arg; - CXXOBJECT->__incRef(); + CXXOBJECT->iceIncRef(); // // No synchronization because initWithCxxObject is always called with the wrapper class object locked @@ -66,7 +66,7 @@ std::map<IceUtil::Shared*, ICELocalObject*> cachedObjects; // No synchronization because dealloc is always called with the wrapper class object locked // cachedObjects.erase(CXXOBJECT); - CXXOBJECT->__decRef(); + CXXOBJECT->iceDecRef(); cxxObject_ = 0; } diff --git a/objective-c/src/Ice/Object.mm b/objective-c/src/Ice/Object.mm index 48f4788a516..2093a2b8cdc 100644 --- a/objective-c/src/Ice/Object.mm +++ b/objective-c/src/Ice/Object.mm @@ -63,12 +63,12 @@ public: // We must explicitely CFRetain/CFRelease so that the garbage // collector does not trash the _object. - virtual void __incRef() + virtual void iceIncRef() { CFRetain(_object); } - virtual void __decRef() + virtual void iceDecRef() { CFRelease(_object); } @@ -95,12 +95,12 @@ public: // We must explicitely CFRetain/CFRelease so that the garbage // collector does not trash the _blobject. - virtual void __incRef() + virtual void iceIncRef() { CFRetain(_blobject); } - virtual void __decRef() + virtual void iceDecRef() { CFRelease(_blobject); } @@ -562,7 +562,7 @@ static NSString* ICEObject_all__[4] = { // // NOTE: IceObjC::ObjectI implements it own reference counting and there's no need - // to call __incRef/__decRef here. The C++ object and Objective-C object are sharing + // to call iceIncRef/iceDecRef here. The C++ object and Objective-C object are sharing // the same reference count (the one of the Objective-C object). This is necessary // to properly release both objects when there's either no more C++ handle/ObjC // reference to the object (without this, servants added to the object adapter @@ -584,7 +584,7 @@ static NSString* ICEObject_all__[4] = { // // NOTE: IceObjC::ObjectI implements it own reference counting and there's no need - // to call __incRef/__decRef here. The C++ object and Objective-C object are sharing + // to call iceIncRef/iceDecRef here. The C++ object and Objective-C object are sharing // the same reference count (the one of the Objective-C object). This is necessary // to properly release both objects when there's either no more C++ handle/ObjC // reference to the object (without this, servants added to the object adapter @@ -607,7 +607,7 @@ static NSString* ICEObject_all__[4] = } object__ = arg; - object__->__incRef(); + object__->iceIncRef(); assert(cachedObjects.find(object__) == cachedObjects.end()); cachedObjects.insert(std::make_pair(object__, self)); return self; @@ -615,7 +615,7 @@ static NSString* ICEObject_all__[4] = -(void) dealloc { cachedObjects.erase(object__); - object__->__decRef(); + object__->iceDecRef(); [super dealloc]; } +(id) servantWrapperWithCxxObject:(Ice::Object*)arg @@ -709,7 +709,7 @@ static NSString* ICEObject_all__[4] = NSException* nsex = nil; try { - object__->__write([(ICEOutputStream*)os os]); + object__->iceWrite([(ICEOutputStream*)os os]); } catch(const std::exception& ex) { @@ -722,7 +722,7 @@ static NSString* ICEObject_all__[4] = NSException* nsex = nil; try { - object__->__read([(ICEInputStream*)is is]); + object__->iceRead([(ICEInputStream*)is is]); } catch(const std::exception& ex) { diff --git a/objective-c/src/Ice/ObjectAdapterI.mm b/objective-c/src/Ice/ObjectAdapterI.mm index 53c0f8ebad4..b12de280639 100644 --- a/objective-c/src/Ice/ObjectAdapterI.mm +++ b/objective-c/src/Ice/ObjectAdapterI.mm @@ -102,7 +102,7 @@ public: } void - __write(Ice::OutputStream* s) const + iceWrite(Ice::OutputStream* s) const { ICEOutputStream* os = [[ICEOutputStream alloc] initWithCxxStream:s]; [_ex write__:os]; @@ -110,13 +110,13 @@ public: } void - __read(Ice::InputStream*) + iceRead(Ice::InputStream*) { assert(false); } bool - __usesClasses() const + iceUsesClasses() const { return [_ex usesClasses__]; } @@ -141,8 +141,8 @@ public: protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void iceWriteImpl(Ice::OutputStream*) const {} + virtual void iceReadImpl(Ice::InputStream*) {} private: diff --git a/objective-c/src/Ice/Proxy.mm b/objective-c/src/Ice/Proxy.mm index 4c44532c3d8..7ca6bf3ce7d 100644 --- a/objective-c/src/Ice/Proxy.mm +++ b/objective-c/src/Ice/Proxy.mm @@ -196,7 +196,7 @@ BOOL _returnsData; } asyncResult__ = arg.get(); - ASYNCRESULT->__incRef(); + ASYNCRESULT->iceIncRef(); operation_ = [op retain]; proxy_ = [p retain]; return self; @@ -209,7 +209,7 @@ BOOL _returnsData; -(void) dealloc { - ASYNCRESULT->__decRef(); + ASYNCRESULT->iceDecRef(); asyncResult__ = 0; [operation_ release]; [proxy_ release]; @@ -322,7 +322,7 @@ BOOL _returnsData; } communicator__ = [ICECommunicator localObjectWithCxxObjectNoAutoRelease:arg->ice_getCommunicator().get()]; objectPrx__ = arg.get(); - OBJECTPRX->__incRef(); + OBJECTPRX->iceIncRef(); return self; } @@ -333,7 +333,7 @@ BOOL _returnsData; -(void) dealloc { - OBJECTPRX->__decRef(); + OBJECTPRX->iceDecRef(); objectPrx__ = 0; [communicator__ release]; [super dealloc]; @@ -828,7 +828,7 @@ BOOL _returnsData; try { std::pair<const Ice::Byte*, const Ice::Byte*> outParams; - BOOL ok = OBJECTPRX->___end_ice_invoke(outParams, [result asyncResult__]); + BOOL ok = OBJECTPRX->iceI_end_ice_invoke(outParams, [result asyncResult__]); ICEInputStream* is; is = [[ICEInputStream alloc] initWithCxxCommunicator:OBJECTPRX->ice_getCommunicator().get() data:outParams]; @@ -883,7 +883,7 @@ BOOL _returnsData; -(NSUInteger) hash { - return (NSUInteger)OBJECTPRX->__hash(); + return (NSUInteger)OBJECTPRX->iceHash(); } -(NSString*) description { @@ -1342,7 +1342,7 @@ BOOL _returnsData; }, ^(const Ice::AsyncResultPtr& result) { std::pair<const ::Ice::Byte*, const ::Ice::Byte*> outP; - BOOL ret__ = OBJECTPRX->___end_ice_invoke(outP, result); + BOOL ret__ = OBJECTPRX->iceI_end_ice_invoke(outP, result); if(response) { NSMutableData* outEncaps = @@ -1373,7 +1373,7 @@ BOOL _returnsData; context, ^(const Ice::AsyncResultPtr& result) { std::pair<const ::Ice::Byte*, const ::Ice::Byte*> outP; - BOOL ret__ = OBJECTPRX->___end_ice_invoke(outP, result); + BOOL ret__ = OBJECTPRX->iceI_end_ice_invoke(outP, result); if(response) { NSMutableData* outEncaps = @@ -1390,7 +1390,7 @@ BOOL _returnsData; endCppCall(^(const Ice::AsyncResultPtr& r) { std::pair<const ::Ice::Byte*, const ::Ice::Byte*> outP; - ret__ = OBJECTPRX->___end_ice_invoke(outP, r); + ret__ = OBJECTPRX->iceI_end_ice_invoke(outP, r); *outEncaps = [NSMutableData dataWithBytes:outP.first length:(outP.second - outP.first)]; }, result); return ret__; diff --git a/objective-c/src/Ice/SlicedData.mm b/objective-c/src/Ice/SlicedData.mm index f4c746141a2..4b3856e04c7 100644 --- a/objective-c/src/Ice/SlicedData.mm +++ b/objective-c/src/Ice/SlicedData.mm @@ -22,13 +22,13 @@ return nil; } self->slicedData__ = slicedData; - self->slicedData__->__incRef(); + self->slicedData__->iceIncRef(); return self; } -(void) dealloc { - self->slicedData__->__decRef(); + self->slicedData__->iceDecRef(); [super dealloc]; } diff --git a/objective-c/src/Ice/Stream.mm b/objective-c/src/Ice/Stream.mm index 179ec095031..f1f2f04595c 100644 --- a/objective-c/src/Ice/Stream.mm +++ b/objective-c/src/Ice/Stream.mm @@ -46,7 +46,7 @@ public: } virtual void - __write(Ice::OutputStream* stream) const + iceWrite(Ice::OutputStream* stream) const { @try { @@ -59,7 +59,7 @@ public: } virtual void - __read(Ice::InputStream* stream) + iceRead(Ice::InputStream* stream) { @try { @@ -268,7 +268,7 @@ public: } virtual bool - __usesClasses() const + iceUsesClasses() const { return [_ex usesClasses__]; } @@ -292,13 +292,13 @@ public: } virtual void - __write(Ice::OutputStream* s) const + iceWrite(Ice::OutputStream* s) const { [_ex write__:static_cast<ICEOutputStream*>(s->getClosure())]; } virtual void - __read(Ice::InputStream* s) + iceRead(Ice::InputStream* s) { [_ex read__:static_cast<ICEInputStream*>(s->getClosure())]; } @@ -311,8 +311,8 @@ public: protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void iceWriteImpl(Ice::OutputStream*) const {} + virtual void iceReadImpl(Ice::InputStream*) {} private: diff --git a/php/src/php5/Types.cpp b/php/src/php5/Types.cpp index 1ba373c0dac..89c8d04cd4b 100644 --- a/php/src/php5/Types.cpp +++ b/php/src/php5/Types.cpp @@ -3009,7 +3009,7 @@ IcePHP::ObjectWriter::ice_preMarshal() } void -IcePHP::ObjectWriter::__write(Ice::OutputStream* os) const +IcePHP::ObjectWriter::iceWrite(Ice::OutputStream* os) const { Ice::SlicedDataPtr slicedData; @@ -3045,7 +3045,7 @@ IcePHP::ObjectWriter::__write(Ice::OutputStream* os) const } void -IcePHP::ObjectWriter::__read(Ice::InputStream*) +IcePHP::ObjectWriter::iceRead(Ice::InputStream*) { assert(false); } @@ -3116,13 +3116,13 @@ IcePHP::ObjectReader::ice_postUnmarshal() } void -IcePHP::ObjectReader::__write(Ice::OutputStream*) const +IcePHP::ObjectReader::iceWrite(Ice::OutputStream*) const { assert(false); } void -IcePHP::ObjectReader::__read(Ice::InputStream* is) +IcePHP::ObjectReader::iceRead(Ice::InputStream* is) { is->startValue(); @@ -3478,13 +3478,13 @@ IcePHP::ExceptionReader::ice_throw() const } void -IcePHP::ExceptionReader::__write(Ice::OutputStream*) const +IcePHP::ExceptionReader::iceWrite(Ice::OutputStream*) const { assert(false); } void -IcePHP::ExceptionReader::__read(Ice::InputStream* is) +IcePHP::ExceptionReader::iceRead(Ice::InputStream* is) { is->startException(); @@ -3494,7 +3494,7 @@ IcePHP::ExceptionReader::__read(Ice::InputStream* is) } bool -IcePHP::ExceptionReader::__usesClasses() const +IcePHP::ExceptionReader::iceUsesClasses() const { return _info->usesClasses; } diff --git a/php/src/php5/Types.h b/php/src/php5/Types.h index 3805f44c00d..78eba26098a 100644 --- a/php/src/php5/Types.h +++ b/php/src/php5/Types.h @@ -540,8 +540,8 @@ public: virtual void ice_preMarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void iceWrite(Ice::OutputStream*) const; + virtual void iceRead(Ice::InputStream*); private: @@ -567,8 +567,8 @@ public: virtual void ice_postUnmarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void iceWrite(Ice::OutputStream*) const; + virtual void iceRead(Ice::InputStream*); virtual ClassInfoPtr getInfo() const; @@ -601,9 +601,9 @@ public: virtual ExceptionReader* ice_clone() const; virtual void ice_throw() const; - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); - virtual bool __usesClasses() const; + virtual void iceWrite(Ice::OutputStream*) const; + virtual void iceRead(Ice::InputStream*); + virtual bool iceUsesClasses() const; ExceptionInfoPtr getInfo() const; @@ -611,13 +611,13 @@ public: Ice::SlicedDataPtr getSlicedData() const; - using Ice::UserException::__read; - using Ice::UserException::__write; + using Ice::UserException::iceRead; + using Ice::UserException::iceWrite; protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void iceWriteImpl(Ice::OutputStream*) const {} + virtual void iceReadImpl(Ice::InputStream*) {} private: diff --git a/php/src/php7/Types.cpp b/php/src/php7/Types.cpp index f42c754cbb1..df9d5205079 100644 --- a/php/src/php7/Types.cpp +++ b/php/src/php7/Types.cpp @@ -2923,7 +2923,7 @@ IcePHP::ObjectWriter::ice_preMarshal() } void -IcePHP::ObjectWriter::__write(Ice::OutputStream* os) const +IcePHP::ObjectWriter::iceWrite(Ice::OutputStream* os) const { Ice::SlicedDataPtr slicedData; @@ -2959,7 +2959,7 @@ IcePHP::ObjectWriter::__write(Ice::OutputStream* os) const } void -IcePHP::ObjectWriter::__read(Ice::InputStream*) +IcePHP::ObjectWriter::iceRead(Ice::InputStream*) { assert(false); } @@ -3032,13 +3032,13 @@ IcePHP::ObjectReader::ice_postUnmarshal() } void -IcePHP::ObjectReader::__write(Ice::OutputStream*) const +IcePHP::ObjectReader::iceWrite(Ice::OutputStream*) const { assert(false); } void -IcePHP::ObjectReader::__read(Ice::InputStream* is) +IcePHP::ObjectReader::iceRead(Ice::InputStream* is) { is->startValue(); @@ -3383,13 +3383,13 @@ IcePHP::ExceptionReader::ice_throw() const } void -IcePHP::ExceptionReader::__write(Ice::OutputStream*) const +IcePHP::ExceptionReader::iceWrite(Ice::OutputStream*) const { assert(false); } void -IcePHP::ExceptionReader::__read(Ice::InputStream* is) +IcePHP::ExceptionReader::iceRead(Ice::InputStream* is) { is->startException(); @@ -3399,7 +3399,7 @@ IcePHP::ExceptionReader::__read(Ice::InputStream* is) } bool -IcePHP::ExceptionReader::__usesClasses() const +IcePHP::ExceptionReader::iceUsesClasses() const { return _info->usesClasses; } diff --git a/php/src/php7/Types.h b/php/src/php7/Types.h index 27556c48df7..2158c24c1e2 100644 --- a/php/src/php7/Types.h +++ b/php/src/php7/Types.h @@ -537,8 +537,8 @@ public: virtual void ice_preMarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void iceWrite(Ice::OutputStream*) const; + virtual void iceRead(Ice::InputStream*); private: @@ -561,8 +561,8 @@ public: virtual void ice_postUnmarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void iceWrite(Ice::OutputStream*) const; + virtual void iceRead(Ice::InputStream*); virtual ClassInfoPtr getInfo() const; @@ -592,9 +592,9 @@ public: virtual ExceptionReader* ice_clone() const; virtual void ice_throw() const; - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); - virtual bool __usesClasses() const; + virtual void iceWrite(Ice::OutputStream*) const; + virtual void iceRead(Ice::InputStream*); + virtual bool iceUsesClasses() const; ExceptionInfoPtr getInfo() const; @@ -602,13 +602,13 @@ public: Ice::SlicedDataPtr getSlicedData() const; - using Ice::UserException::__read; - using Ice::UserException::__write; + using Ice::UserException::iceRead; + using Ice::UserException::iceWrite; protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void iceWriteImpl(Ice::OutputStream*) const {} + virtual void iceReadImpl(Ice::InputStream*) {} private: diff --git a/python/modules/IcePy/Operation.cpp b/python/modules/IcePy/Operation.cpp index c8dad9a0c96..d20d7408447 100644 --- a/python/modules/IcePy/Operation.cpp +++ b/python/modules/IcePy/Operation.cpp @@ -2114,7 +2114,7 @@ IcePy::AsyncTypedInvocation::end(const Ice::ObjectPrx& proxy, const OperationPtr { AllowThreads allowThreads; // Release Python's global interpreter lock during blocking operations. - ok = proxy->___end_ice_invoke(results, r); + ok = proxy->iceI_end_ice_invoke(results, r); } if(ok) @@ -2803,7 +2803,7 @@ IcePy::AsyncBlobjectInvocation::end(const Ice::ObjectPrx& proxy, const Ice::Asyn { AllowThreads allowThreads; // Release Python's global interpreter lock during blocking operations. - ok = proxy->___end_ice_invoke(results, r); + ok = proxy->iceI_end_ice_invoke(results, r); } // @@ -4142,7 +4142,7 @@ IcePy::TypedServantWrapper::ice_invoke_async(const Ice::AMD_Object_ice_invokePtr // if(!op->pseudoOp) { - __checkMode(op->mode, current.mode); + iceCheckMode(op->mode, current.mode); } UpcallPtr up = new TypedUpcall(op, cb, current.adapter->getCommunicator()); diff --git a/python/modules/IcePy/Proxy.cpp b/python/modules/IcePy/Proxy.cpp index d9b2704b2a8..b02106e5f68 100644 --- a/python/modules/IcePy/Proxy.cpp +++ b/python/modules/IcePy/Proxy.cpp @@ -164,7 +164,7 @@ extern "C" static long proxyHash(ProxyObject* self) { - return static_cast<long>((*self->proxy)->__hash()); + return static_cast<long>((*self->proxy)->iceHash()); } #ifdef WIN32 diff --git a/python/modules/IcePy/Types.cpp b/python/modules/IcePy/Types.cpp index 59be1eb8ab5..2c2b55eeb25 100644 --- a/python/modules/IcePy/Types.cpp +++ b/python/modules/IcePy/Types.cpp @@ -3232,7 +3232,7 @@ IcePy::ObjectWriter::ice_preMarshal() } void -IcePy::ObjectWriter::__write(Ice::OutputStream* os) const +IcePy::ObjectWriter::iceWrite(Ice::OutputStream* os) const { Ice::SlicedDataPtr slicedData; @@ -3266,7 +3266,7 @@ IcePy::ObjectWriter::__write(Ice::OutputStream* os) const } void -IcePy::ObjectWriter::__read(Ice::InputStream*) +IcePy::ObjectWriter::iceRead(Ice::InputStream*) { assert(false); } @@ -3341,13 +3341,13 @@ IcePy::ObjectReader::ice_postUnmarshal() } void -IcePy::ObjectReader::__write(Ice::OutputStream*) const +IcePy::ObjectReader::iceWrite(Ice::OutputStream*) const { assert(false); } void -IcePy::ObjectReader::__read(Ice::InputStream* is) +IcePy::ObjectReader::iceRead(Ice::InputStream* is) { is->startValue(); @@ -3735,7 +3735,7 @@ IcePy::ExceptionWriter::ice_throw() const } void -IcePy::ExceptionWriter::__write(Ice::OutputStream* os) const +IcePy::ExceptionWriter::iceWrite(Ice::OutputStream* os) const { AdoptThread adoptThread; // Ensure the current thread is able to call into Python. @@ -3743,12 +3743,12 @@ IcePy::ExceptionWriter::__write(Ice::OutputStream* os) const } void -IcePy::ExceptionWriter::__read(Ice::InputStream*) +IcePy::ExceptionWriter::iceRead(Ice::InputStream*) { } bool -IcePy::ExceptionWriter::__usesClasses() const +IcePy::ExceptionWriter::iceUsesClasses() const { return _info->usesClasses; } @@ -3790,13 +3790,13 @@ IcePy::ExceptionReader::ice_throw() const } void -IcePy::ExceptionReader::__write(Ice::OutputStream*) const +IcePy::ExceptionReader::iceWrite(Ice::OutputStream*) const { assert(false); } void -IcePy::ExceptionReader::__read(Ice::InputStream* is) +IcePy::ExceptionReader::iceRead(Ice::InputStream* is) { AdoptThread adoptThread; // Ensure the current thread is able to call into Python. @@ -3808,7 +3808,7 @@ IcePy::ExceptionReader::__read(Ice::InputStream* is) } bool -IcePy::ExceptionReader::__usesClasses() const +IcePy::ExceptionReader::iceUsesClasses() const { return _info->usesClasses; } diff --git a/python/modules/IcePy/Types.h b/python/modules/IcePy/Types.h index 921047496b9..07b8c6585a0 100644 --- a/python/modules/IcePy/Types.h +++ b/python/modules/IcePy/Types.h @@ -554,8 +554,8 @@ public: virtual void ice_preMarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void iceWrite(Ice::OutputStream*) const; + virtual void iceRead(Ice::InputStream*); private: @@ -578,8 +578,8 @@ public: virtual void ice_postUnmarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void iceWrite(Ice::OutputStream*) const; + virtual void iceRead(Ice::InputStream*); virtual ClassInfoPtr getInfo() const; @@ -610,15 +610,15 @@ public: #endif virtual void ice_throw() const; - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void iceWrite(Ice::OutputStream*) const; + virtual void iceRead(Ice::InputStream*); - virtual bool __usesClasses() const; + virtual bool iceUsesClasses() const; protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void iceWriteImpl(Ice::OutputStream*) const {} + virtual void iceReadImpl(Ice::InputStream*) {} private: @@ -643,22 +643,22 @@ public: #endif virtual void ice_throw() const; - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void iceWrite(Ice::OutputStream*) const; + virtual void iceRead(Ice::InputStream*); - virtual bool __usesClasses() const; + virtual bool iceUsesClasses() const; PyObject* getException() const; // Borrowed reference. Ice::SlicedDataPtr getSlicedData() const; - using Ice::UserException::__read; - using Ice::UserException::__write; + using Ice::UserException::iceRead; + using Ice::UserException::iceWrite; protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void iceWriteImpl(Ice::OutputStream*) const {} + virtual void iceReadImpl(Ice::InputStream*) {} private: diff --git a/ruby/src/IceRuby/Proxy.cpp b/ruby/src/IceRuby/Proxy.cpp index 0029cad3378..f2221ae8d9d 100644 --- a/ruby/src/IceRuby/Proxy.cpp +++ b/ruby/src/IceRuby/Proxy.cpp @@ -77,7 +77,7 @@ IceRuby_ObjectPrx_hash(VALUE self) ICE_RUBY_TRY { Ice::ObjectPrx p = getProxy(self); - return INT2FIX(p->__hash()); + return INT2FIX(p->iceHash()); } ICE_RUBY_CATCH return Qnil; diff --git a/ruby/src/IceRuby/Types.cpp b/ruby/src/IceRuby/Types.cpp index d0577ddcf09..bde29633bad 100644 --- a/ruby/src/IceRuby/Types.cpp +++ b/ruby/src/IceRuby/Types.cpp @@ -2468,7 +2468,7 @@ IceRuby::ObjectWriter::ice_preMarshal() } void -IceRuby::ObjectWriter::__write(Ice::OutputStream* os) const +IceRuby::ObjectWriter::iceWrite(Ice::OutputStream* os) const { Ice::SlicedDataPtr slicedData; @@ -2502,7 +2502,7 @@ IceRuby::ObjectWriter::__write(Ice::OutputStream* os) const } void -IceRuby::ObjectWriter::__read(Ice::InputStream*) +IceRuby::ObjectWriter::iceRead(Ice::InputStream*) { assert(false); } @@ -2559,13 +2559,13 @@ IceRuby::ObjectReader::ice_postUnmarshal() } void -IceRuby::ObjectReader::__write(Ice::OutputStream*) const +IceRuby::ObjectReader::iceWrite(Ice::OutputStream*) const { assert(false); } void -IceRuby::ObjectReader::__read(Ice::InputStream* is) +IceRuby::ObjectReader::iceRead(Ice::InputStream* is) { is->startValue(); @@ -2855,13 +2855,13 @@ IceRuby::ExceptionReader::ice_throw() const } void -IceRuby::ExceptionReader::__write(Ice::OutputStream*) const +IceRuby::ExceptionReader::iceWrite(Ice::OutputStream*) const { assert(false); } void -IceRuby::ExceptionReader::__read(Ice::InputStream* is) +IceRuby::ExceptionReader::iceRead(Ice::InputStream* is) { is->startException(); @@ -2871,7 +2871,7 @@ IceRuby::ExceptionReader::__read(Ice::InputStream* is) } bool -IceRuby::ExceptionReader::__usesClasses() const +IceRuby::ExceptionReader::iceUsesClasses() const { return _info->usesClasses; } diff --git a/ruby/src/IceRuby/Types.h b/ruby/src/IceRuby/Types.h index 809b34aed0c..a0f6b9dee1d 100644 --- a/ruby/src/IceRuby/Types.h +++ b/ruby/src/IceRuby/Types.h @@ -492,8 +492,8 @@ public: virtual void ice_preMarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void iceWrite(Ice::OutputStream*) const; + virtual void iceRead(Ice::InputStream*); private: @@ -516,8 +516,8 @@ public: virtual void ice_postUnmarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void iceWrite(Ice::OutputStream*) const; + virtual void iceRead(Ice::InputStream*); virtual ClassInfoPtr getInfo() const; @@ -548,22 +548,22 @@ public: #endif virtual void ice_throw() const; - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void iceWrite(Ice::OutputStream*) const; + virtual void iceRead(Ice::InputStream*); - virtual bool __usesClasses() const; + virtual bool iceUsesClasses() const; VALUE getException() const; Ice::SlicedDataPtr getSlicedData() const; - using Ice::UserException::__read; - using Ice::UserException::__write; + using Ice::UserException::iceRead; + using Ice::UserException::iceWrite; protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void iceWriteImpl(Ice::OutputStream*) const {} + virtual void iceReadImpl(Ice::InputStream*) {} private: |