summaryrefslogtreecommitdiff
path: root/cpp/include/Ice
diff options
context:
space:
mode:
Diffstat (limited to 'cpp/include/Ice')
-rw-r--r--cpp/include/Ice/BasicStream.h166
-rw-r--r--cpp/include/Ice/Buffer.h224
-rw-r--r--cpp/include/Ice/FactoryTable.h2
-rwxr-xr-xcpp/include/Ice/GCShared.h4
-rw-r--r--cpp/include/Ice/Handle.h186
-rw-r--r--cpp/include/Ice/IncomingAsync.h2
-rw-r--r--cpp/include/Ice/Initialize.h14
-rw-r--r--cpp/include/Ice/Object.h2
-rw-r--r--cpp/include/Ice/Outgoing.h10
-rw-r--r--cpp/include/Ice/OutgoingAsync.h4
-rw-r--r--cpp/include/Ice/Proxy.h156
-rw-r--r--cpp/include/Ice/ProxyHandle.h190
-rwxr-xr-xcpp/include/Ice/StringConverter.h8
13 files changed, 484 insertions, 484 deletions
diff --git a/cpp/include/Ice/BasicStream.h b/cpp/include/Ice/BasicStream.h
index 671c46f49d6..7cab7da51ef 100644
--- a/cpp/include/Ice/BasicStream.h
+++ b/cpp/include/Ice/BasicStream.h
@@ -38,14 +38,14 @@ public:
public:
StreamUTF8BufferI(BasicStream& stream) :
- _stream(stream)
- {
- }
+ _stream(stream)
+ {
+ }
Ice::Byte*
getMoreBytes(size_t howMany, Ice::Byte* firstUnused)
{
- assert(howMany > 0);
+ assert(howMany > 0);
if(firstUnused != 0)
{
@@ -71,7 +71,7 @@ public:
private:
- BasicStream& _stream;
+ BasicStream& _stream;
};
typedef void (*PatchFunc)(void*, Ice::ObjectPtr&);
@@ -102,14 +102,14 @@ public:
void resize(Container::size_type sz)
{
//
- // Check memory limit if stream is not unlimited.
- //
- if(!_unlimited && sz > _messageSizeMax)
- {
- throwMemoryLimitException(__FILE__, __LINE__);
- }
-
- b.resize(sz);
+ // Check memory limit if stream is not unlimited.
+ //
+ if(!_unlimited && sz > _messageSizeMax)
+ {
+ throwMemoryLimitException(__FILE__, __LINE__);
+ }
+
+ b.resize(sz);
}
void startSeq(int, int);
@@ -142,8 +142,8 @@ public:
void checkFixedSeq(int, int); // For sequences of fixed-size types.
void endElement()
{
- assert(_seqDataStack);
- --_seqDataStack->numElements;
+ assert(_seqDataStack);
+ --_seqDataStack->numElements;
}
void endSeq(int);
@@ -364,32 +364,32 @@ public:
void write(Ice::Byte v)
{
- b.push_back(v);
+ b.push_back(v);
}
void write(const Ice::Byte*, const Ice::Byte*);
void read(Ice::Byte& v)
{
- if(i >= b.end())
- {
- throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
- }
- v = *i++;
+ if(i >= b.end())
+ {
+ throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+ }
+ v = *i++;
}
void read(std::pair<const Ice::Byte*, const Ice::Byte*>&);
void write(bool v)
{
- b.push_back(static_cast<Ice::Byte>(v));
+ b.push_back(static_cast<Ice::Byte>(v));
}
void write(const std::vector<bool>&);
void write(const bool*, const bool*);
void read(bool& v)
{
- if(i >= b.end())
- {
- throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
- }
- v = *i++;
+ if(i >= b.end())
+ {
+ throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+ }
+ v = *i++;
}
void read(std::vector<bool>&);
bool* read(std::pair<const bool*, const bool*>&);
@@ -479,11 +479,11 @@ public:
{
Ice::Int sz = static_cast<Ice::Int>(v.size());
if(convert && sz > 0 && _stringConverter != 0)
- {
- writeConverted(v);
- }
- else
- {
+ {
+ writeConverted(v);
+ }
+ else
+ {
writeSize(sz);
if(sz > 0)
{
@@ -491,7 +491,7 @@ public:
resize(pos + sz);
memcpy(&b[pos], v.data(), sz);
}
- }
+ }
}
void write(const std::string*, const std::string*, bool = true);
void read(std::string& v, bool convert = true)
@@ -505,14 +505,14 @@ public:
{
throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
}
- if(convert && _stringConverter != 0)
- {
- _stringConverter->fromUTF8(i, i + sz, v);
- }
- else
- {
+ if(convert && _stringConverter != 0)
+ {
+ _stringConverter->fromUTF8(i, i + sz, v);
+ }
+ else
+ {
std::string(reinterpret_cast<const char*>(&*i), reinterpret_cast<const char*>(&*i) + sz).swap(v);
- }
+ }
i += sz;
}
else
@@ -535,7 +535,7 @@ public:
throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
}
- _wstringConverter->fromUTF8(i, i + sz, v);
+ _wstringConverter->fromUTF8(i, i + sz, v);
i += sz;
}
else
@@ -561,8 +561,8 @@ public:
struct PatchEntry
{
- PatchFunc patchFunc;
- void* patchAddr;
+ PatchFunc patchFunc;
+ void* patchAddr;
};
typedef std::vector<PatchEntry> PatchList;
@@ -598,20 +598,20 @@ private:
{
public:
- ReadEncaps() : patchMap(0), unmarshaledMap(0), typeIdMap(0), typeIdIndex(0), previous(0)
- {
- // Inlined for performance reasons.
- }
- ~ReadEncaps()
- {
- // Inlined for performance reasons.
+ ReadEncaps() : patchMap(0), unmarshaledMap(0), typeIdMap(0), typeIdIndex(0), previous(0)
+ {
+ // Inlined for performance reasons.
+ }
+ ~ReadEncaps()
+ {
+ // Inlined for performance reasons.
delete patchMap;
delete unmarshaledMap;
delete typeIdMap;
- }
- void reset()
+ }
+ void reset()
{
- // Inlined for performance reasons.
+ // Inlined for performance reasons.
delete patchMap;
delete unmarshaledMap;
delete typeIdMap;
@@ -622,40 +622,40 @@ private:
typeIdIndex = 0;
previous = 0;
}
- void swap(ReadEncaps&);
+ void swap(ReadEncaps&);
- Container::size_type start;
- Ice::Int sz;
+ Container::size_type start;
+ Ice::Int sz;
- Ice::Byte encodingMajor;
- Ice::Byte encodingMinor;
+ Ice::Byte encodingMajor;
+ Ice::Byte encodingMinor;
- PatchMap* patchMap;
- IndexToPtrMap* unmarshaledMap;
- TypeIdReadMap* typeIdMap;
- Ice::Int typeIdIndex;
+ PatchMap* patchMap;
+ IndexToPtrMap* unmarshaledMap;
+ TypeIdReadMap* typeIdMap;
+ Ice::Int typeIdIndex;
- ReadEncaps* previous;
+ ReadEncaps* previous;
};
class ICE_API WriteEncaps : private ::IceUtil::noncopyable
{
public:
- WriteEncaps() : writeIndex(0), toBeMarshaledMap(0), marshaledMap(0), typeIdMap(0), typeIdIndex(0), previous(0)
- {
- // Inlined for performance reasons.
- }
- ~WriteEncaps()
+ WriteEncaps() : writeIndex(0), toBeMarshaledMap(0), marshaledMap(0), typeIdMap(0), typeIdIndex(0), previous(0)
+ {
+ // Inlined for performance reasons.
+ }
+ ~WriteEncaps()
{
- // Inlined for performance reasons.
+ // Inlined for performance reasons.
delete toBeMarshaledMap;
delete marshaledMap;
delete typeIdMap;
}
- void reset()
+ void reset()
{
- // Inlined for performance reasons.
+ // Inlined for performance reasons.
delete toBeMarshaledMap;
delete marshaledMap;
delete typeIdMap;
@@ -667,17 +667,17 @@ private:
typeIdIndex = 0;
previous = 0;
}
- void swap(WriteEncaps&);
+ void swap(WriteEncaps&);
- Container::size_type start;
+ Container::size_type start;
- Ice::Int writeIndex;
- PtrToIndexMap* toBeMarshaledMap;
- PtrToIndexMap* marshaledMap;
- TypeIdWriteMap* typeIdMap;
- Ice::Int typeIdIndex;
+ Ice::Int writeIndex;
+ PtrToIndexMap* toBeMarshaledMap;
+ PtrToIndexMap* marshaledMap;
+ TypeIdWriteMap* typeIdMap;
+ Ice::Int typeIdIndex;
- WriteEncaps* previous;
+ WriteEncaps* previous;
};
ReadEncaps* _currentReadEncaps;
@@ -705,10 +705,10 @@ private:
struct SeqData
{
- SeqData(int, int);
- int numElements;
- int minSize;
- SeqData* previous;
+ SeqData(int, int);
+ int numElements;
+ int minSize;
+ SeqData* previous;
};
SeqData* _seqDataStack;
diff --git a/cpp/include/Ice/Buffer.h b/cpp/include/Ice/Buffer.h
index a15b9184b53..b780d84d2fa 100644
--- a/cpp/include/Ice/Buffer.h
+++ b/cpp/include/Ice/Buffer.h
@@ -28,122 +28,122 @@ public:
{
public:
- //
- // Standard vector-like operations.
- //
-
- typedef Ice::Byte value_type;
- typedef Ice::Byte* iterator;
- typedef const Ice::Byte* const_iterator;
- typedef Ice::Byte& reference;
- typedef const Ice::Byte& const_reference;
- typedef Ice::Byte* pointer;
- typedef ptrdiff_t difference_type;
- typedef size_t size_type;
-
- Container(size_type maxCapacity);
-
- ~Container();
-
- iterator begin()
- {
- return _buf;
- }
-
- const_iterator begin() const
- {
- return _buf;
- }
-
- iterator end()
- {
- return _buf + _size;
- }
-
- const_iterator end() const
- {
- return _buf + _size;
- }
-
- size_type size() const
- {
- return _size;
- }
-
- bool empty() const
- {
- return !_size;
- }
-
- void swap(Container&);
-
- void clear();
-
- void resize(size_type n) // Inlined for performance reasons.
+ //
+ // Standard vector-like operations.
+ //
+
+ typedef Ice::Byte value_type;
+ typedef Ice::Byte* iterator;
+ typedef const Ice::Byte* const_iterator;
+ typedef Ice::Byte& reference;
+ typedef const Ice::Byte& const_reference;
+ typedef Ice::Byte* pointer;
+ typedef ptrdiff_t difference_type;
+ typedef size_t size_type;
+
+ Container(size_type maxCapacity);
+
+ ~Container();
+
+ iterator begin()
+ {
+ return _buf;
+ }
+
+ const_iterator begin() const
+ {
+ return _buf;
+ }
+
+ iterator end()
+ {
+ return _buf + _size;
+ }
+
+ const_iterator end() const
+ {
+ return _buf + _size;
+ }
+
+ size_type size() const
+ {
+ return _size;
+ }
+
+ bool empty() const
+ {
+ return !_size;
+ }
+
+ void swap(Container&);
+
+ void clear();
+
+ void resize(size_type n) // Inlined for performance reasons.
+ {
+ if(n == 0)
+ {
+ clear();
+ }
+ else if(n > _capacity)
+ {
+ reserve(n);
+ }
+ _size = n;
+ }
+
+ void reset()
+ {
+ if(_size > 0 && _size * 2 < _capacity)
+ {
+ //
+ // If the current buffer size is smaller than the
+ // buffer capacity, we shrink the buffer memory to the
+ // current size. This is to avoid holding on too much
+ // memory if it's not needed anymore.
+ //
+ if(++_shrinkCounter > 2)
+ {
+ reserve(_size);
+ _shrinkCounter = 0;
+ }
+ }
+ else
+ {
+ _shrinkCounter = 0;
+ }
+ _size = 0;
+ }
+
+ void push_back(value_type v)
+ {
+ resize(_size + 1);
+ _buf[_size - 1] = v;
+ }
+
+ reference operator[](size_type n)
+ {
+ assert(n < _size);
+ return _buf[n];
+ }
+
+ const_reference operator[](size_type n) const
{
- if(n == 0)
- {
- clear();
- }
- else if(n > _capacity)
- {
- reserve(n);
- }
- _size = n;
- }
-
- void reset()
- {
- if(_size > 0 && _size * 2 < _capacity)
- {
- //
- // If the current buffer size is smaller than the
- // buffer capacity, we shrink the buffer memory to the
- // current size. This is to avoid holding on too much
- // memory if it's not needed anymore.
- //
- if(++_shrinkCounter > 2)
- {
- reserve(_size);
- _shrinkCounter = 0;
- }
- }
- else
- {
- _shrinkCounter = 0;
- }
- _size = 0;
- }
-
- void push_back(value_type v)
- {
- resize(_size + 1);
- _buf[_size - 1] = v;
- }
-
- reference operator[](size_type n)
- {
- assert(n < _size);
- return _buf[n];
- }
-
- const_reference operator[](size_type n) const
- {
- assert(n < _size);
- return _buf[n];
- }
-
+ assert(n < _size);
+ return _buf[n];
+ }
+
private:
- Container(const Container&);
- void operator=(const Container&);
- void reserve(size_type);
+ Container(const Container&);
+ void operator=(const Container&);
+ void reserve(size_type);
- pointer _buf;
- size_type _size;
- size_type _capacity;
- size_type _maxCapacity;
- int _shrinkCounter;
+ pointer _buf;
+ size_type _size;
+ size_type _capacity;
+ size_type _maxCapacity;
+ int _shrinkCounter;
};
Container b;
diff --git a/cpp/include/Ice/FactoryTable.h b/cpp/include/Ice/FactoryTable.h
index 81e15a485c0..8a534ab252d 100644
--- a/cpp/include/Ice/FactoryTable.h
+++ b/cpp/include/Ice/FactoryTable.h
@@ -23,7 +23,7 @@ public:
~FactoryTable();
};
-static FactoryTable factoryTableInitializer; // Dummy variable to force initialization of factoryTable
+static FactoryTable factoryTableInitializer; // Dummy variable to force initialization of factoryTable
extern ICE_API FactoryTableDef* factoryTable;
diff --git a/cpp/include/Ice/GCShared.h b/cpp/include/Ice/GCShared.h
index 2812a1b4702..df5dd94262e 100755
--- a/cpp/include/Ice/GCShared.h
+++ b/cpp/include/Ice/GCShared.h
@@ -44,12 +44,12 @@ public:
int __getRefUnsafe() const
{
- return _ref;
+ return _ref;
}
void __decRefUnsafe()
{
- --_ref;
+ --_ref;
}
protected:
diff --git a/cpp/include/Ice/Handle.h b/cpp/include/Ice/Handle.h
index 0fc6212cb93..c224ceace4e 100644
--- a/cpp/include/Ice/Handle.h
+++ b/cpp/include/Ice/Handle.h
@@ -44,143 +44,143 @@ public:
Handle(T* p = 0)
{
- this->_ptr = p;
+ this->_ptr = p;
- if(this->_ptr)
- {
- incRef(this->_ptr);
- }
+ if(this->_ptr)
+ {
+ incRef(this->_ptr);
+ }
}
template<typename Y>
Handle(const Handle<Y>& r)
{
- this->_ptr = r._ptr;
+ this->_ptr = r._ptr;
- if(this->_ptr)
- {
- incRef(this->_ptr);
- }
+ if(this->_ptr)
+ {
+ incRef(this->_ptr);
+ }
}
template<typename Y>
Handle(const ::IceUtil::Handle<Y>& r)
{
- this->_ptr = r._ptr;
+ this->_ptr = r._ptr;
- if(this->_ptr)
- {
- incRef(this->_ptr);
- }
+ if(this->_ptr)
+ {
+ incRef(this->_ptr);
+ }
}
Handle(const Handle& r)
{
- this->_ptr = r._ptr;
+ this->_ptr = r._ptr;
- if(this->_ptr)
- {
- incRef(this->_ptr);
- }
+ if(this->_ptr)
+ {
+ incRef(this->_ptr);
+ }
}
~Handle()
{
- if(this->_ptr)
- {
- decRef(this->_ptr);
- }
+ if(this->_ptr)
+ {
+ decRef(this->_ptr);
+ }
}
Handle& operator=(T* p)
{
- if(this->_ptr != p)
- {
- if(p)
- {
- incRef(p);
- }
-
- T* ptr = this->_ptr;
- this->_ptr = p;
-
- if(ptr)
- {
- decRef(ptr);
- }
- }
- return *this;
+ if(this->_ptr != p)
+ {
+ if(p)
+ {
+ incRef(p);
+ }
+
+ T* ptr = this->_ptr;
+ this->_ptr = p;
+
+ if(ptr)
+ {
+ decRef(ptr);
+ }
+ }
+ return *this;
}
template<typename Y>
Handle& operator=(const Handle<Y>& r)
{
- if(this->_ptr != r._ptr)
- {
- if(r._ptr)
- {
- incRef(r._ptr);
- }
-
- T* ptr = this->_ptr;
- this->_ptr = r._ptr;
-
- if(ptr)
- {
- decRef(ptr);
- }
- }
- return *this;
+ if(this->_ptr != r._ptr)
+ {
+ if(r._ptr)
+ {
+ incRef(r._ptr);
+ }
+
+ T* ptr = this->_ptr;
+ this->_ptr = r._ptr;
+
+ if(ptr)
+ {
+ decRef(ptr);
+ }
+ }
+ return *this;
}
template<typename Y>
Handle& operator=(const ::IceUtil::Handle<Y>& r)
{
- if(this->_ptr != r._ptr)
- {
- if(r._ptr)
- {
- incRef(r._ptr);
- }
-
- T* ptr = this->_ptr;
- this->_ptr = r._ptr;
-
- if(ptr)
- {
- decRef(ptr);
- }
- }
- return *this;
+ if(this->_ptr != r._ptr)
+ {
+ if(r._ptr)
+ {
+ incRef(r._ptr);
+ }
+
+ T* ptr = this->_ptr;
+ this->_ptr = r._ptr;
+
+ if(ptr)
+ {
+ decRef(ptr);
+ }
+ }
+ return *this;
}
Handle& operator=(const Handle& r)
{
- if(this->_ptr != r._ptr)
- {
- if(r._ptr)
- {
- incRef(r._ptr);
- }
-
- T* ptr = this->_ptr;
- this->_ptr = r._ptr;
-
- if(ptr)
- {
- decRef(ptr);
- }
- }
- return *this;
+ if(this->_ptr != r._ptr)
+ {
+ if(r._ptr)
+ {
+ incRef(r._ptr);
+ }
+
+ T* ptr = this->_ptr;
+ this->_ptr = r._ptr;
+
+ if(ptr)
+ {
+ decRef(ptr);
+ }
+ }
+ return *this;
}
template<class Y>
static Handle dynamicCast(const ::IceUtil::HandleBase<Y>& r)
{
#ifdef __BCPLUSPLUS__
- return Handle<T>(dynamic_cast<T*>(r._ptr));
+ return Handle<T>(dynamic_cast<T*>(r._ptr));
#else
- return Handle(dynamic_cast<T*>(r._ptr));
+ return Handle(dynamic_cast<T*>(r._ptr));
#endif
}
@@ -188,15 +188,15 @@ public:
static Handle dynamicCast(Y* p)
{
#ifdef __BCPLUSPLUS__
- return Handle<T>(dynamic_cast<T*>(p));
+ return Handle<T>(dynamic_cast<T*>(p));
#else
- return Handle(dynamic_cast<T*>(p));
+ return Handle(dynamic_cast<T*>(p));
#endif
}
void __clearHandleUnsafe()
{
- this->_ptr = 0;
+ this->_ptr = 0;
}
};
diff --git a/cpp/include/Ice/IncomingAsync.h b/cpp/include/Ice/IncomingAsync.h
index dc6af5ed78a..e7c5ba20ece 100644
--- a/cpp/include/Ice/IncomingAsync.h
+++ b/cpp/include/Ice/IncomingAsync.h
@@ -99,7 +99,7 @@ public:
};
class ICE_API AMD_Array_Object_ice_invoke : public ::Ice::AMD_Array_Object_ice_invoke,
- public IceInternal::IncomingAsync
+ public IceInternal::IncomingAsync
{
public:
diff --git a/cpp/include/Ice/Initialize.h b/cpp/include/Ice/Initialize.h
index 78cd1dbd104..77c8df84026 100644
--- a/cpp/include/Ice/Initialize.h
+++ b/cpp/include/Ice/Initialize.h
@@ -65,22 +65,22 @@ struct InitializationData
};
ICE_API CommunicatorPtr initialize(int&, char*[], const InitializationData& = InitializationData(),
- Int = ICE_INT_VERSION);
+ Int = ICE_INT_VERSION);
ICE_API CommunicatorPtr initialize(Ice::StringSeq&, const InitializationData& = InitializationData(),
- Int = ICE_INT_VERSION);
+ Int = ICE_INT_VERSION);
ICE_API CommunicatorPtr initialize(const InitializationData& = InitializationData(),
- Int = ICE_INT_VERSION);
+ Int = ICE_INT_VERSION);
ICE_API ICE_DEPRECATED_API CommunicatorPtr initializeWithProperties(int&, char*[], const PropertiesPtr&,
- Int = ICE_INT_VERSION);
+ Int = ICE_INT_VERSION);
ICE_API ICE_DEPRECATED_API CommunicatorPtr initializeWithLogger(int&, char*[], const Ice::LoggerPtr&,
- Int = ICE_INT_VERSION);
+ Int = ICE_INT_VERSION);
ICE_API ICE_DEPRECATED_API CommunicatorPtr initializeWithPropertiesAndLogger(int&, char*[], const PropertiesPtr&,
- const Ice::LoggerPtr&,
- Int = ICE_INT_VERSION);
+ const Ice::LoggerPtr&,
+ Int = ICE_INT_VERSION);
ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&);
ICE_API OutputStreamPtr createOutputStream(const CommunicatorPtr&);
diff --git a/cpp/include/Ice/Object.h b/cpp/include/Ice/Object.h
index e740d25a69d..2fe85ed8508 100644
--- a/cpp/include/Ice/Object.h
+++ b/cpp/include/Ice/Object.h
@@ -133,7 +133,7 @@ public:
// Returns true if ok, false if user exception.
virtual void ice_invoke_async(const AMD_Array_Object_ice_invokePtr&, const std::pair<const Byte*, const Byte*>&,
- const Current&) = 0;
+ const Current&) = 0;
virtual IceInternal::DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
};
diff --git a/cpp/include/Ice/Outgoing.h b/cpp/include/Ice/Outgoing.h
index 30e8f0c4d43..2ce534c3466 100644
--- a/cpp/include/Ice/Outgoing.h
+++ b/cpp/include/Ice/Outgoing.h
@@ -85,11 +85,11 @@ private:
enum
{
- StateUnsent,
- StateInProgress,
- StateOK,
- StateUserException,
- StateLocalException
+ StateUnsent,
+ StateInProgress,
+ StateOK,
+ StateUserException,
+ StateLocalException
} _state;
BasicStream _is;
diff --git a/cpp/include/Ice/OutgoingAsync.h b/cpp/include/Ice/OutgoingAsync.h
index 768846e619c..21a3796b156 100644
--- a/cpp/include/Ice/OutgoingAsync.h
+++ b/cpp/include/Ice/OutgoingAsync.h
@@ -77,7 +77,7 @@ public:
virtual void ice_exception(const Ice::Exception&) = 0;
void __invoke(const Ice::ObjectPrx&, const std::string& operation, OperationMode,
- const std::vector<Ice::Byte>&, const Context*);
+ const std::vector<Ice::Byte>&, const Context*);
protected:
@@ -92,7 +92,7 @@ public:
virtual void ice_exception(const Ice::Exception&) = 0;
void __invoke(const Ice::ObjectPrx&, const std::string& operation, OperationMode,
- const std::pair<const Byte*, const Byte*>&, const Context*);
+ const std::pair<const Byte*, const Byte*>&, const Context*);
protected:
diff --git a/cpp/include/Ice/Proxy.h b/cpp/include/Ice/Proxy.h
index 3c7d1b3912a..9a70a3a65c0 100644
--- a/cpp/include/Ice/Proxy.h
+++ b/cpp/include/Ice/Proxy.h
@@ -93,82 +93,82 @@ public:
bool ice_isA(const ::std::string& typeId)
{
- return ice_isA(typeId, 0);
+ return ice_isA(typeId, 0);
}
bool ice_isA(const ::std::string& typeId, const ::Ice::Context& context)
{
- return ice_isA(typeId, &context);
+ return ice_isA(typeId, &context);
}
void ice_ping()
{
- ice_ping(0);
+ ice_ping(0);
}
void ice_ping(const ::Ice::Context& context)
{
- ice_ping(&context);
+ ice_ping(&context);
}
::std::vector< ::std::string> ice_ids()
{
- return ice_ids(0);
+ return ice_ids(0);
}
::std::vector< ::std::string> ice_ids(const ::Ice::Context& context)
{
- return ice_ids(&context);
+ return ice_ids(&context);
}
::std::string ice_id()
{
- return ice_id(0);
+ return ice_id(0);
}
::std::string ice_id(const ::Ice::Context& context)
{
- return ice_id(&context);
+ return ice_id(&context);
}
// Returns true if ok, false if user exception.
bool ice_invoke(const ::std::string& operation,
- ::Ice::OperationMode mode,
- const ::std::vector< ::Ice::Byte>& inParams,
- ::std::vector< ::Ice::Byte>& outParams)
+ ::Ice::OperationMode mode,
+ const ::std::vector< ::Ice::Byte>& inParams,
+ ::std::vector< ::Ice::Byte>& outParams)
{
- const ::Ice::Context* context = 0;
- return ice_invoke(operation, mode, inParams, outParams, context);
+ const ::Ice::Context* context = 0;
+ return ice_invoke(operation, mode, inParams, outParams, context);
}
bool ice_invoke(const ::std::string& operation,
- ::Ice::OperationMode mode,
- const ::std::vector< ::Ice::Byte>& inParams,
- ::std::vector< ::Ice::Byte>& outParams,
- const ::Ice::Context& context)
+ ::Ice::OperationMode mode,
+ const ::std::vector< ::Ice::Byte>& inParams,
+ ::std::vector< ::Ice::Byte>& outParams,
+ const ::Ice::Context& context)
{
- return ice_invoke(operation, mode, inParams, outParams, &context);
+ return ice_invoke(operation, mode, inParams, outParams, &context);
}
bool ice_invoke(const ::std::string& operation,
- ::Ice::OperationMode mode,
- const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
- ::std::vector< ::Ice::Byte>& outParams)
+ ::Ice::OperationMode mode,
+ const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
+ ::std::vector< ::Ice::Byte>& outParams)
{
- const ::Ice::Context* context = 0;
- return ice_invoke(operation, mode, inParams, outParams, context);
+ const ::Ice::Context* context = 0;
+ return ice_invoke(operation, mode, inParams, outParams, context);
}
bool ice_invoke(const ::std::string& operation,
- ::Ice::OperationMode mode,
- const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
- ::std::vector< ::Ice::Byte>& outParams,
- const ::Ice::Context& context)
+ ::Ice::OperationMode mode,
+ const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
+ ::std::vector< ::Ice::Byte>& outParams,
+ const ::Ice::Context& context)
{
- return ice_invoke(operation, mode, inParams, outParams, &context);
+ return ice_invoke(operation, mode, inParams, outParams, &context);
}
void ice_invoke_async(const ::Ice::AMI_Object_ice_invokePtr&, const ::std::string&, ::Ice::OperationMode,
- const ::std::vector< ::Ice::Byte>&);
+ const ::std::vector< ::Ice::Byte>&);
void ice_invoke_async(const ::Ice::AMI_Object_ice_invokePtr&, const ::std::string&, ::Ice::OperationMode,
- const ::std::vector< ::Ice::Byte>&, const ::Ice::Context&);
+ const ::std::vector< ::Ice::Byte>&, const ::Ice::Context&);
void ice_invoke_async(const ::Ice::AMI_Array_Object_ice_invokePtr&, const ::std::string&, ::Ice::OperationMode,
- const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&);
+ const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&);
void ice_invoke_async(const ::Ice::AMI_Array_Object_ice_invokePtr&, const ::std::string&, ::Ice::OperationMode,
- const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&, const ::Ice::Context&);
+ const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&, const ::Ice::Context&);
::Ice::Identity ice_getIdentity() const;
ICE_DEPRECATED_API ::Ice::ObjectPrx ice_newIdentity(const ::Ice::Identity&) const;
@@ -241,11 +241,11 @@ public:
::IceInternal::ReferencePtr __reference() const;
void __copyFrom(const ::Ice::ObjectPrx&);
void __handleException(const ::IceInternal::Handle< ::IceDelegate::Ice::Object>&,
- const ::Ice::LocalException&, int&);
+ const ::Ice::LocalException&, int&);
void __handleExceptionWrapper(const ::IceInternal::Handle< ::IceDelegate::Ice::Object>&,
- const ::IceInternal::LocalExceptionWrapper&);
+ const ::IceInternal::LocalExceptionWrapper&);
void __handleExceptionWrapperRelaxed(const ::IceInternal::Handle< ::IceDelegate::Ice::Object>&,
- const ::IceInternal::LocalExceptionWrapper&, int&);
+ const ::IceInternal::LocalExceptionWrapper&, int&);
void __checkTwowayOnly(const char*) const;
void __checkTwowayOnly(const ::std::string&) const;
@@ -265,15 +265,15 @@ private:
bool ice_invoke(const ::std::string&,
- ::Ice::OperationMode,
- const ::std::vector< ::Ice::Byte>&,
- ::std::vector< ::Ice::Byte>&,
- const ::Ice::Context*);
+ ::Ice::OperationMode,
+ const ::std::vector< ::Ice::Byte>&,
+ ::std::vector< ::Ice::Byte>&,
+ const ::Ice::Context*);
bool ice_invoke(const ::std::string&,
- ::Ice::OperationMode,
- const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
- ::std::vector< ::Ice::Byte>&,
- const ::Ice::Context*);
+ ::Ice::OperationMode,
+ const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
+ ::std::vector< ::Ice::Byte>&,
+ const ::Ice::Context*);
void setup(const ::IceInternal::ReferencePtr&);
friend class ::IceInternal::ProxyFactory;
@@ -298,8 +298,8 @@ public:
virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Context*) = 0;
virtual ::std::string ice_id(const ::Ice::Context*) = 0;
virtual bool ice_invoke(const ::std::string&, ::Ice::OperationMode,
- const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
- ::std::vector< ::Ice::Byte>&, const ::Ice::Context*) = 0;
+ const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
+ ::std::vector< ::Ice::Byte>&, const ::Ice::Context*) = 0;
virtual ::Ice::ConnectionIPtr __getConnection(bool&) const = 0;
};
@@ -320,8 +320,8 @@ public:
virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Context*);
virtual ::std::string ice_id(const ::Ice::Context*);
virtual bool ice_invoke(const ::std::string&, ::Ice::OperationMode,
- const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
- ::std::vector< ::Ice::Byte>&, const ::Ice::Context*);
+ const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
+ ::std::vector< ::Ice::Byte>&, const ::Ice::Context*);
virtual ::Ice::ConnectionIPtr __getConnection(bool&) const;
@@ -353,8 +353,8 @@ public:
virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Context*);
virtual ::std::string ice_id(const ::Ice::Context*);
virtual bool ice_invoke(const ::std::string&, ::Ice::OperationMode,
- const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
- ::std::vector< ::Ice::Byte>&, const ::Ice::Context*);
+ const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
+ ::std::vector< ::Ice::Byte>&, const ::Ice::Context*);
virtual ::Ice::ConnectionIPtr __getConnection(bool&) const;
@@ -388,7 +388,7 @@ struct ProxyIdentityLess : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
{
bool operator()(const ObjectPrx& lhs, const ObjectPrx& rhs) const
{
- return proxyIdentityLess(lhs, rhs);
+ return proxyIdentityLess(lhs, rhs);
}
};
@@ -396,7 +396,7 @@ struct ProxyIdentityEqual : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
{
bool operator()(const ObjectPrx& lhs, const ObjectPrx& rhs) const
{
- return proxyIdentityEqual(lhs, rhs);
+ return proxyIdentityEqual(lhs, rhs);
}
};
@@ -404,7 +404,7 @@ struct ProxyIdentityAndFacetLess : std::binary_function<bool, ObjectPrx&, Object
{
bool operator()(const ObjectPrx& lhs, const ObjectPrx& rhs) const
{
- return proxyIdentityAndFacetLess(lhs, rhs);
+ return proxyIdentityAndFacetLess(lhs, rhs);
}
};
@@ -412,7 +412,7 @@ struct ProxyIdentityAndFacetEqual : std::binary_function<bool, ObjectPrx&, Objec
{
bool operator()(const ObjectPrx& lhs, const ObjectPrx& rhs) const
{
- return proxyIdentityAndFacetEqual(lhs, rhs);
+ return proxyIdentityAndFacetEqual(lhs, rhs);
}
};
@@ -430,16 +430,16 @@ checkedCastImpl(const ::Ice::ObjectPrx& b, const ::Ice::Context* context)
P d = 0;
if(b.get())
{
- typedef typename P::element_type T;
-
- d = dynamic_cast<T*>(b.get());
- if(!d && (context == 0 ?
- b->ice_isA(T::ice_staticId()) :
- b->ice_isA(T::ice_staticId(), *context)))
- {
- d = new T;
- d->__copyFrom(b);
- }
+ typedef typename P::element_type T;
+
+ d = dynamic_cast<T*>(b.get());
+ if(!d && (context == 0 ?
+ b->ice_isA(T::ice_staticId()) :
+ b->ice_isA(T::ice_staticId(), *context)))
+ {
+ d = new T;
+ d->__copyFrom(b);
+ }
}
return d;
}
@@ -450,14 +450,14 @@ uncheckedCastImpl(const ::Ice::ObjectPrx& b)
P d = 0;
if(b)
{
- typedef typename P::element_type T;
-
- d = dynamic_cast<T*>(b.get());
- if(!d)
- {
- d = new T;
- d->__copyFrom(b);
- }
+ typedef typename P::element_type T;
+
+ d = dynamic_cast<T*>(b.get());
+ if(!d)
+ {
+ d = new T;
+ d->__copyFrom(b);
+ }
}
return d;
}
@@ -489,7 +489,7 @@ uncheckedCastImpl< ::Ice::ObjectPrx>(const ::Ice::ObjectPrx& b, const std::strin
::Ice::ObjectPrx d = 0;
if(b)
{
- d = b->ice_facet(f);
+ d = b->ice_facet(f);
}
return d;
}
@@ -504,8 +504,8 @@ checkedCastImpl(const ::Ice::ObjectPrx& b, const std::string& f, const ::Ice::Co
if(bb)
{
- d = new T;
- d->__copyFrom(bb);
+ d = new T;
+ d->__copyFrom(bb);
}
return d;
}
@@ -516,11 +516,11 @@ uncheckedCastImpl(const ::Ice::ObjectPrx& b, const std::string& f)
P d = 0;
if(b)
{
- typedef typename P::element_type T;
+ typedef typename P::element_type T;
- ::Ice::ObjectPrx bb = b->ice_facet(f);
- d = new T;
- d->__copyFrom(bb);
+ ::Ice::ObjectPrx bb = b->ice_facet(f);
+ d = new T;
+ d->__copyFrom(bb);
}
return d;
}
diff --git a/cpp/include/Ice/ProxyHandle.h b/cpp/include/Ice/ProxyHandle.h
index 6c06e30647b..7229b428bdc 100644
--- a/cpp/include/Ice/ProxyHandle.h
+++ b/cpp/include/Ice/ProxyHandle.h
@@ -110,171 +110,171 @@ public:
ProxyHandle(T* p = 0)
{
- this->_ptr = p;
+ this->_ptr = p;
- if(this->_ptr)
- {
- incRef(this->_ptr);
- }
+ if(this->_ptr)
+ {
+ incRef(this->_ptr);
+ }
}
template<typename Y>
ProxyHandle(const ProxyHandle<Y>& r)
{
- this->_ptr = r._ptr;
+ this->_ptr = r._ptr;
- if(this->_ptr)
- {
- incRef(this->_ptr);
- }
+ if(this->_ptr)
+ {
+ incRef(this->_ptr);
+ }
}
template<typename Y>
ProxyHandle(const ::IceUtil::Handle<Y>& r)
{
- this->_ptr = r._ptr;
+ this->_ptr = r._ptr;
- if(this->_ptr)
- {
- incRef(this->_ptr);
- }
+ if(this->_ptr)
+ {
+ incRef(this->_ptr);
+ }
}
ProxyHandle(const ProxyHandle& r)
{
- this->_ptr = r._ptr;
+ this->_ptr = r._ptr;
- if(this->_ptr)
- {
- incRef(this->_ptr);
- }
+ if(this->_ptr)
+ {
+ incRef(this->_ptr);
+ }
}
~ProxyHandle()
{
- if(this->_ptr)
- {
- decRef(this->_ptr);
- }
+ if(this->_ptr)
+ {
+ decRef(this->_ptr);
+ }
}
ProxyHandle& operator=(T* p)
{
- if(this->_ptr != p)
- {
- if(p)
- {
- incRef(p);
- }
-
- if(this->_ptr)
- {
- decRef(this->_ptr);
- }
-
- this->_ptr = p;
- }
- return *this;
+ if(this->_ptr != p)
+ {
+ if(p)
+ {
+ incRef(p);
+ }
+
+ if(this->_ptr)
+ {
+ decRef(this->_ptr);
+ }
+
+ this->_ptr = p;
+ }
+ return *this;
}
template<typename Y>
ProxyHandle& operator=(const ProxyHandle<Y>& r)
{
- if(this->_ptr != r._ptr)
- {
- if(r._ptr)
- {
- incRef(r._ptr);
- }
-
- if(this->_ptr)
- {
- decRef(this->_ptr);
- }
-
- this->_ptr = r._ptr;
- }
- return *this;
+ if(this->_ptr != r._ptr)
+ {
+ if(r._ptr)
+ {
+ incRef(r._ptr);
+ }
+
+ if(this->_ptr)
+ {
+ decRef(this->_ptr);
+ }
+
+ this->_ptr = r._ptr;
+ }
+ return *this;
}
template<typename Y>
ProxyHandle& operator=(const ::IceUtil::Handle<Y>& r)
{
- if(this->_ptr != r._ptr)
- {
- if(r._ptr)
- {
- incRef(r._ptr);
- }
-
- if(this->_ptr)
- {
- decRef(this->_ptr);
- }
-
- this->_ptr = r._ptr;
- }
- return *this;
+ if(this->_ptr != r._ptr)
+ {
+ if(r._ptr)
+ {
+ incRef(r._ptr);
+ }
+
+ if(this->_ptr)
+ {
+ decRef(this->_ptr);
+ }
+
+ this->_ptr = r._ptr;
+ }
+ return *this;
}
ProxyHandle& operator=(const ProxyHandle& r)
{
- if(this->_ptr != r._ptr)
- {
- if(r._ptr)
- {
- incRef(r._ptr);
- }
-
- if(this->_ptr)
- {
- decRef(this->_ptr);
- }
-
- this->_ptr = r._ptr;
- }
- return *this;
+ if(this->_ptr != r._ptr)
+ {
+ if(r._ptr)
+ {
+ incRef(r._ptr);
+ }
+
+ if(this->_ptr)
+ {
+ decRef(this->_ptr);
+ }
+
+ this->_ptr = r._ptr;
+ }
+ return *this;
}
template<class Y>
static ProxyHandle checkedCast(const ProxyHandle<Y>& r)
{
- Y* tag = 0;
- Ice::Context* ctx = 0;
- return ::IceInternal::checkedCastHelper<T>(r, tag, ctx);
+ Y* tag = 0;
+ Ice::Context* ctx = 0;
+ return ::IceInternal::checkedCastHelper<T>(r, tag, ctx);
}
template<class Y>
static ProxyHandle checkedCast(const ProxyHandle<Y>& r, const std::string& f)
{
- Ice::Context* ctx = 0;
- return ::IceInternal::checkedCastImpl<ProxyHandle>(r, f, ctx);
+ Ice::Context* ctx = 0;
+ return ::IceInternal::checkedCastImpl<ProxyHandle>(r, f, ctx);
}
template<class Y>
static ProxyHandle checkedCast(const ProxyHandle<Y>& r, const ::Ice::Context& ctx)
{
- Y* tag = 0;
- return ::IceInternal::checkedCastHelper<T>(r, tag, &ctx);
+ Y* tag = 0;
+ return ::IceInternal::checkedCastHelper<T>(r, tag, &ctx);
}
template<class Y>
static ProxyHandle checkedCast(const ProxyHandle<Y>& r, const std::string& f, const ::Ice::Context& ctx)
{
- return ::IceInternal::checkedCastImpl<ProxyHandle>(r, f, &ctx);
+ return ::IceInternal::checkedCastImpl<ProxyHandle>(r, f, &ctx);
}
template<class Y>
static ProxyHandle uncheckedCast(const ProxyHandle<Y>& r)
{
- Y* tag = 0;
- return::IceInternal::uncheckedCastHelper<T>(r, tag);
+ Y* tag = 0;
+ return::IceInternal::uncheckedCastHelper<T>(r, tag);
}
template<class Y>
static ProxyHandle uncheckedCast(const ProxyHandle<Y>& r, const std::string& f)
{
- return ::IceInternal::uncheckedCastImpl<ProxyHandle>(r, f);
+ return ::IceInternal::uncheckedCastImpl<ProxyHandle>(r, f);
}
};
diff --git a/cpp/include/Ice/StringConverter.h b/cpp/include/Ice/StringConverter.h
index 634b328c1e3..d2aa1dffa7a 100755
--- a/cpp/include/Ice/StringConverter.h
+++ b/cpp/include/Ice/StringConverter.h
@@ -47,13 +47,13 @@ public:
// past the last byte returned by getMoreBytes).
//
virtual Byte* toUTF8(const charT* sourceStart, const charT* sourceEnd,
- UTF8Buffer&) const = 0;
+ UTF8Buffer&) const = 0;
//
// Unmarshals a UTF-8 sequence into a basic_string
//
virtual void fromUTF8(const Byte* sourceStart, const Byte* sourceEnd,
- std::basic_string<charT>& target) const = 0;
+ std::basic_string<charT>& target) const = 0;
};
typedef BasicStringConverter<char> StringConverter;
@@ -71,10 +71,10 @@ class ICE_API UnicodeWstringConverter : public WstringConverter
public:
virtual Byte* toUTF8(const wchar_t* sourceStart, const wchar_t* sourceEnd,
- UTF8Buffer&) const;
+ UTF8Buffer&) const;
virtual void fromUTF8(const Byte* sourceStart, const Byte* sourceEnd,
- std::wstring& target) const;
+ std::wstring& target) const;
};
}
#endif
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-03 21:28:30 +0000