diff options
Diffstat (limited to 'cpp/src/Ice/StreamI.cpp')
| -rw-r--r-- | cpp/src/Ice/StreamI.cpp | 728 |
1 files changed, 256 insertions, 472 deletions
diff --git a/cpp/src/Ice/StreamI.cpp b/cpp/src/Ice/StreamI.cpp index b95f5f47075..e1e73f94617 100644 --- a/cpp/src/Ice/StreamI.cpp +++ b/cpp/src/Ice/StreamI.cpp @@ -16,258 +16,140 @@ #endif #include <Ice/StreamI.h> +#include <Ice/Instance.h> +#include <Ice/DefaultsAndOverrides.h> #include <Ice/Initialize.h> #include <Ice/LocalException.h> +#include <Ice/UserExceptionFactory.h> using namespace std; using namespace Ice; using namespace IceInternal; -// -// InputStreamI -// -Ice::InputStreamI::InputStreamI(const Ice::CommunicatorPtr& communicator, const vector<Byte>& data) : - _communicator(communicator) -{ - _is = new BasicStream(getInstance(communicator).get(), true); - _is->closure(this); - _is->writeBlob(data); - _is->i = _is->b.begin(); -} - -Ice::InputStreamI::InputStreamI(const Ice::CommunicatorPtr& communicator, const pair<const Byte*, const Byte*>& data) : - _communicator(communicator) +namespace { - _is = new BasicStream(getInstance(communicator).get(), true); - _is->closure(this); - _is->writeBlob(data.first, data.second - data.first); - _is->i = _is->b.begin(); -} -Ice::InputStreamI::~InputStreamI() +// +// This class implements the internal interface UserExceptionFactory and delegates to +// the user-supplied instance of UserExceptionReaderFactory. +// +class UserExceptionFactoryI : public IceInternal::UserExceptionFactory { - delete _is; -} +public: -CommunicatorPtr -Ice::InputStreamI::communicator() const -{ - return _communicator; -} + UserExceptionFactoryI(const UserExceptionReaderFactoryPtr& factory) : + _factory(factory) + { + } -void -Ice::InputStreamI::sliceObjects(bool b) -{ - _is->sliceObjects(b); -} + virtual void createAndThrow(const string& id) + { + _factory->createAndThrow(id); + } -bool -Ice::InputStreamI::readBool() -{ - bool v; - _is->read(v); - return v; -} +private: -vector<bool> -Ice::InputStreamI::readBoolSeq() -{ - vector<bool> v; - _is->read(v); - return v; -} + const UserExceptionReaderFactoryPtr _factory; +}; -bool* -Ice::InputStreamI::readBoolSeq(pair<const bool*, const bool*>& p) -{ - return _is->read(p); } -Byte -Ice::InputStreamI::readByte() +// +// UserExceptionReader +// +UserExceptionReader::UserExceptionReader(const CommunicatorPtr& communicator) : + _communicator(communicator) { - Byte v; - _is->read(v); - return v; } -vector<Byte> -Ice::InputStreamI::readByteSeq() +UserExceptionReader::~UserExceptionReader() throw() { - pair<const Byte*, const Byte*> p; - _is->read(p); - vector<Byte> v(p.first, p.second); - return v; } void -Ice::InputStreamI::readByteSeq(pair<const Byte*, const Byte*>& p) -{ - _is->read(p); -} - -Short -Ice::InputStreamI::readShort() -{ - Short v; - _is->read(v); - return v; -} - -vector<Short> -Ice::InputStreamI::readShortSeq() -{ - vector<Short> v; - _is->read(v); - return v; -} - -Short* -Ice::InputStreamI::readShortSeq(pair<const Short*, const Short*>& p) -{ - return _is->read(p); -} - -Int -Ice::InputStreamI::readInt() -{ - Int v; - _is->read(v); - return v; -} - -vector<Int> -Ice::InputStreamI::readIntSeq() -{ - vector<Int> v; - _is->read(v); - return v; -} - -Int* -Ice::InputStreamI::readIntSeq(pair<const Int*, const Int*>& p) -{ - return _is->read(p); -} - -Long -Ice::InputStreamI::readLong() -{ - Long v; - _is->read(v); - return v; -} - -vector<Long> -Ice::InputStreamI::readLongSeq() -{ - vector<Long> v; - _is->read(v); - return v; -} - -Long* -Ice::InputStreamI::readLongSeq(pair<const Long*, const Long*>& p) -{ - return _is->read(p); -} - -Float -Ice::InputStreamI::readFloat() +UserExceptionReader::__write(BasicStream*) const { - Float v; - _is->read(v); - return v; + assert(false); } -vector<Float> -Ice::InputStreamI::readFloatSeq() +void +UserExceptionReader::__read(BasicStream* is) { - vector<Float> v; - _is->read(v); - return v; + InputStreamI* stream = reinterpret_cast<InputStreamI*>(is->closure()); + assert(stream); + read(stream); } -Float* -Ice::InputStreamI::readFloatSeq(pair<const Float*, const Float*>& p) +bool +UserExceptionReader::__usesClasses() const { - return _is->read(p); + return usesClasses(); } -Double -Ice::InputStreamI::readDouble() +void +UserExceptionReader::__usesClasses(bool b) { - Double v; - _is->read(v); - return v; + usesClasses(b); } -vector<Double> -Ice::InputStreamI::readDoubleSeq() -{ - vector<Double> v; - _is->read(v); - return v; -} - -Double* -Ice::InputStreamI::readDoubleSeq(pair<const Double*, const Double*>& p) +// +// InputStreamI +// +InputStreamI::InputStreamI(const CommunicatorPtr& communicator, const vector<Byte>& data) : + _communicator(communicator), + _closure(0) { - return _is->read(p); + Instance* instance = getInstance(communicator).get(); + _is = new BasicStream(instance, instance->defaultsAndOverrides()->defaultEncoding, true); + _is->closure(this); + _is->writeBlob(data); + _is->i = _is->b.begin(); } -string -Ice::InputStreamI::readString(bool convert) +InputStreamI::InputStreamI(const CommunicatorPtr& communicator, const pair<const Byte*, const Byte*>& data) : + _communicator(communicator), + _closure(0) { - string v; - _is->read(v, convert); - return v; + Instance* instance = getInstance(communicator).get(); + _is = new BasicStream(instance, instance->defaultsAndOverrides()->defaultEncoding, true); + _is->closure(this); + _is->writeBlob(data.first, data.second - data.first); + _is->i = _is->b.begin(); } -vector<string> -Ice::InputStreamI::readStringSeq(bool convert) +InputStreamI::~InputStreamI() { - vector<string> v; - _is->read(v, convert); - return v; + delete _is; } -wstring -Ice::InputStreamI::readWstring() +CommunicatorPtr +InputStreamI::communicator() const { - wstring v; - _is->read(v); - return v; + return _communicator; } -vector<wstring> -Ice::InputStreamI::readWstringSeq() +void +InputStreamI::sliceObjects(bool b) { - vector<wstring> v; - _is->read(v); - return v; + _is->sliceObjects(b); } Int -Ice::InputStreamI::readSize() +InputStreamI::readSize() { - Int sz; - _is->readSize(sz); - return sz; + return _is->readSize(); } Int -Ice::InputStreamI::readAndCheckSeqSize(int minSize) +InputStreamI::readAndCheckSeqSize(int minSize) { - Int sz; - _is->readAndCheckSeqSize(minSize, sz); - return sz; + return _is->readAndCheckSeqSize(minSize); } ObjectPrx -Ice::InputStreamI::readProxy() +InputStreamI::readProxy() { - Ice::ObjectPrx v; + ObjectPrx v; _is->read(v); return v; } @@ -286,191 +168,251 @@ patchObject(void* addr, ObjectPtr& v) } void -Ice::InputStreamI::readObject(const ReadObjectCallbackPtr& cb) +InputStreamI::readObject(const ReadObjectCallbackPtr& cb) { _callbacks.push_back(cb); // Keep reference to callback. _is->read(patchObject, cb.get()); } -string -Ice::InputStreamI::readTypeId() -{ - string id; - _is->readTypeId(id); - return id; -} - void -Ice::InputStreamI::read(bool& v) +InputStreamI::read(bool& v) { _is->read(v); } void -Ice::InputStreamI::read(::Ice::Byte& v) +InputStreamI::read(Byte& v) { _is->read(v); } void -Ice::InputStreamI::read(::Ice::Short& v) +InputStreamI::read(Short& v) { _is->read(v); } void -Ice::InputStreamI::read(Ice::Int& v) +InputStreamI::read(Int& v) { _is->read(v); } void -Ice::InputStreamI::read(Ice::Long& v) +InputStreamI::read(Long& v) { _is->read(v); } void -Ice::InputStreamI::read(Ice::Float& v) +InputStreamI::read(Float& v) { _is->read(v); } void -Ice::InputStreamI::read(Ice::Double& v) +InputStreamI::read(Double& v) { _is->read(v); } void -Ice::InputStreamI::read(string& v, bool convert) +InputStreamI::read(string& v, bool convert) { _is->read(v, convert); } void -Ice::InputStreamI::read(vector<string>& v, bool convert) +InputStreamI::read(vector<string>& v, bool convert) { _is->read(v, convert); } void -Ice::InputStreamI::read(wstring& v) +InputStreamI::read(wstring& v) { _is->read(v); } void -Ice::InputStreamI::read(pair<const bool*, const bool*>& p, ::IceUtil::ScopedArray<bool>& result) +InputStreamI::read(pair<const bool*, const bool*>& p, ::IceUtil::ScopedArray<bool>& result) { result.reset(_is->read(p)); } void -Ice::InputStreamI::read(pair<const Ice::Byte*, const Ice::Byte*>& p) +InputStreamI::read(pair<const Byte*, const Byte*>& p) { _is->read(p); } void -Ice::InputStreamI::read(pair<const Ice::Short*, const Ice::Short*>& p, ::IceUtil::ScopedArray<Ice::Short>& result) +InputStreamI::read(pair<const Short*, const Short*>& p, ::IceUtil::ScopedArray<Short>& result) { result.reset(_is->read(p)); } void -Ice::InputStreamI::read(pair<const Ice::Int*, const Ice::Int*>& p, ::IceUtil::ScopedArray<Ice::Int>& result) +InputStreamI::read(pair<const Int*, const Int*>& p, ::IceUtil::ScopedArray<Int>& result) { result.reset(_is->read(p)); } void -Ice::InputStreamI::read(pair<const Ice::Long*, const Ice::Long*>& p, ::IceUtil::ScopedArray<Ice::Long>& result) +InputStreamI::read(pair<const Long*, const Long*>& p, ::IceUtil::ScopedArray<Long>& result) { result.reset(_is->read(p)); } void -Ice::InputStreamI::read(pair<const Ice::Float*, const Ice::Float*>& p, ::IceUtil::ScopedArray<Ice::Float>& result) +InputStreamI::read(pair<const Float*, const Float*>& p, ::IceUtil::ScopedArray<Float>& result) { result.reset(_is->read(p)); } void -Ice::InputStreamI::read(pair<const Ice::Double*, const Ice::Double*>& p, - ::IceUtil::ScopedArray<Ice::Double>& result) +InputStreamI::read(pair<const Double*, const Double*>& p, + ::IceUtil::ScopedArray<Double>& result) { result.reset(_is->read(p)); } +bool +InputStreamI::readOptional(Int tag, OptionalType type) +{ + return _is->readOpt(tag, type); +} + void -Ice::InputStreamI::throwException() +InputStreamI::throwException() { _is->throwException(); } void -Ice::InputStreamI::startSlice() +InputStreamI::throwException(const UserExceptionReaderFactoryPtr& factory) { - _is->startReadSlice(); + UserExceptionFactoryPtr del = new UserExceptionFactoryI(factory); + _is->throwException(del); } void -Ice::InputStreamI::endSlice() +InputStreamI::startObject() { - _is->endReadSlice(); + _is->startReadObject(); } -void -Ice::InputStreamI::startEncapsulation() +SlicedDataPtr +InputStreamI::endObject(bool preserve) { - _is->startReadEncaps(); + return _is->endReadObject(preserve); } void -Ice::InputStreamI::endEncapsulation() +InputStreamI::startException() { - _is->endReadEncapsChecked(); + _is->startReadException(); +} + +SlicedDataPtr +InputStreamI::endException(bool preserve) +{ + return _is->endReadException(preserve); +} + +string +InputStreamI::startSlice() +{ + return _is->startReadSlice(); } void -Ice::InputStreamI::skipEncapsulation() +InputStreamI::endSlice() { - _is->skipEncaps(); + _is->endReadSlice(); } void -Ice::InputStreamI::skipSlice() +InputStreamI::skipSlice() { _is->skipSlice(); } +EncodingVersion +InputStreamI::startEncapsulation() +{ + return _is->startReadEncaps(); +} + void -Ice::InputStreamI::readPendingObjects() +InputStreamI::endEncapsulation() +{ + _is->endReadEncapsChecked(); +} + +EncodingVersion +InputStreamI::skipEncapsulation() +{ + return _is->skipEncaps(); +} + +EncodingVersion +InputStreamI::getEncoding() +{ + return _is->getReadEncoding(); +} + +void +InputStreamI::readPendingObjects() { _is->readPendingObjects(); } void -Ice::InputStreamI::rewind() +InputStreamI::rewind() { _is->clear(); _is->i = _is->b.begin(); } +void +InputStreamI::skip(Int sz) +{ + _is->skip(sz); +} + +void +InputStreamI::skipSize() +{ + _is->skipSize(); +} + +void +InputStreamI::closure(void* p) +{ + _closure = p; +} + +void* +InputStreamI::closure() const +{ + return _closure; +} + // // OutputStreamI // -Ice::OutputStreamI::OutputStreamI(const Ice::CommunicatorPtr& communicator, BasicStream* os) : +OutputStreamI::OutputStreamI(const CommunicatorPtr& communicator, BasicStream* os) : _communicator(communicator), _os(os), _own(!os) { if(!_os) { - _os = new BasicStream(getInstance(communicator).get(), true); + Instance* instance = getInstance(communicator).get(); + _os = new BasicStream(instance, instance->defaultsAndOverrides()->defaultEncoding, true); } _os->closure(this); } -Ice::OutputStreamI::~OutputStreamI() +OutputStreamI::~OutputStreamI() { if(_own) { @@ -479,31 +421,31 @@ Ice::OutputStreamI::~OutputStreamI() } CommunicatorPtr -Ice::OutputStreamI::communicator() const +OutputStreamI::communicator() const { return _communicator; } void -Ice::OutputStreamI::writeObject(const ObjectPtr& v) +OutputStreamI::writeObject(const ObjectPtr& v) { _os->write(v); } void -Ice::OutputStreamI::writeException(const UserException& v) +OutputStreamI::writeException(const UserException& v) { _os->write(v); } void -Ice::OutputStreamI::writeProxy(const ObjectPrx& v) +OutputStreamI::writeProxy(const ObjectPrx& v) { _os->write(v); } void -Ice::OutputStreamI::writeSize(Int sz) +OutputStreamI::writeSize(Int sz) { if(sz < 0) { @@ -514,67 +456,61 @@ Ice::OutputStreamI::writeSize(Int sz) } void -Ice::OutputStreamI::writeTypeId(const string& id) -{ - _os->writeTypeId(id); -} - -void -Ice::OutputStreamI::write(bool v) +OutputStreamI::write(bool v) { _os->write(v); } void -Ice::OutputStreamI::write(Byte v) +OutputStreamI::write(Byte v) { _os->write(v); } void -Ice::OutputStreamI::write(Short v) +OutputStreamI::write(Short v) { _os->write(v); } void -Ice::OutputStreamI::write(Int v) +OutputStreamI::write(Int v) { _os->write(v); } void -Ice::OutputStreamI::write(Long v) +OutputStreamI::write(Long v) { _os->write(v); } void -Ice::OutputStreamI::write(Float v) +OutputStreamI::write(Float v) { _os->write(v); } void -Ice::OutputStreamI::write(Double v) +OutputStreamI::write(Double v) { _os->write(v); } void -Ice::OutputStreamI::write(const string& v, bool convert) +OutputStreamI::write(const string& v, bool convert) { _os->write(v, convert); } void -Ice::OutputStreamI::write(const char* v, bool convert) +OutputStreamI::write(const char* v, bool convert) { _os->write(v, convert); } void -Ice::OutputStreamI::write(const vector<string>& v, bool convert) +OutputStreamI::write(const vector<string>& v, bool convert) { if(v.size() == 0) { @@ -587,337 +523,185 @@ Ice::OutputStreamI::write(const vector<string>& v, bool convert) } void -Ice::OutputStreamI::write(const wstring& v) +OutputStreamI::write(const wstring& v) { _os->write(v); } void -Ice::OutputStreamI::write(const bool* begin, const bool* end) +OutputStreamI::write(const bool* begin, const bool* end) { _os->write(begin, end); } void -Ice::OutputStreamI::write(const Byte* begin, const Byte* end) +OutputStreamI::write(const Byte* begin, const Byte* end) { _os->write(begin, end); } void -Ice::OutputStreamI::write(const Int* begin, const Int* end) +OutputStreamI::write(const Short* begin, const Short* end) { _os->write(begin, end); } void -Ice::OutputStreamI::write(const Long* begin, const Long* end) +OutputStreamI::write(const Int* begin, const Int* end) { _os->write(begin, end); } void -Ice::OutputStreamI::write(const Float* begin, const Float* end) +OutputStreamI::write(const Long* begin, const Long* end) { _os->write(begin, end); } void -Ice::OutputStreamI::write(const Double* begin, const Double* end) +OutputStreamI::write(const Float* begin, const Float* end) { _os->write(begin, end); } void -Ice::OutputStreamI::startSlice() -{ - _os->startWriteSlice(); -} - -void -Ice::OutputStreamI::endSlice() -{ - _os->endWriteSlice(); -} - -void -Ice::OutputStreamI::startEncapsulation() -{ - _os->startWriteEncaps(); -} - -void -Ice::OutputStreamI::endEncapsulation() -{ - _os->endWriteEncapsChecked(); -} - -void -Ice::OutputStreamI::writePendingObjects() -{ - _os->writePendingObjects(); -} - -void -Ice::OutputStreamI::finished(vector<Byte>& bytes) -{ - vector<Byte>(_os->b.begin(), _os->b.end()).swap(bytes); -} - -void -Ice::OutputStreamI::reset(bool clearBuffer) -{ - _os->clear(); - - if(clearBuffer) - { - _os->b.clear(); - } - else - { - _os->b.reset(); - } - - _os->i = _os->b.begin(); -} - -void -Ice::OutputStreamI::writeBool(bool v) -{ - _os->write(v); -} - -void -Ice::OutputStreamI::writeBoolSeq(const vector<bool>& v) -{ - _os->write(v); -} - -void -Ice::OutputStreamI::writeBoolSeq(const bool* begin, const bool* end) -{ - write(begin, end); -} - -void -Ice::OutputStreamI::writeByte(Byte v) -{ - _os->write(v); -} - -void -Ice::OutputStreamI::writeByteSeq(const vector<Byte>& v) -{ - if(v.size() == 0) - { - _os->writeSize(0); - } - else - { - _os->write(&v[0], &v[0] + v.size()); - } -} - -void -Ice::OutputStreamI::writeByteSeq(const Ice::Byte* begin, const Ice::Byte* end) -{ - write(begin, end); -} - -void -Ice::OutputStreamI::writeShort(Short v) -{ - _os->write(v); -} - -void -Ice::OutputStreamI::writeShortSeq(const vector<Short>& v) -{ - if(v.size() == 0) - { - _os->writeSize(0); - } - else - { - _os->write(&v[0], &v[0] + v.size()); - } -} - -void -Ice::OutputStreamI::writeShortSeq(const Ice::Short* begin, const Ice::Short* end) +OutputStreamI::write(const Double* begin, const Double* end) { - write(begin, end); + _os->write(begin, end); } void -Ice::OutputStreamI::writeInt(Int v) +OutputStreamI::writeOptional(Int tag, OptionalType type) { - _os->write(v); + _os->writeOpt(tag, type); } void -Ice::OutputStreamI::writeIntSeq(const vector<Int>& v) +OutputStreamI::startObject(const SlicedDataPtr& slicedData) { - if(v.size() == 0) - { - _os->writeSize(0); - } - else - { - _os->write(&v[0], &v[0] + v.size()); - } + _os->startWriteObject(slicedData); } void -Ice::OutputStreamI::writeIntSeq(const Ice::Int* begin, const Ice::Int* end) +OutputStreamI::endObject() { - write(begin, end); + _os->endWriteObject(); } void -Ice::OutputStreamI::writeLong(Long v) +OutputStreamI::startException(const SlicedDataPtr& slicedData) { - _os->write(v); -} - -void -Ice::OutputStreamI::writeLongSeq(const vector<Long>& v) -{ - if(v.size() == 0) - { - _os->writeSize(0); - } - else - { - _os->write(&v[0], &v[0] + v.size()); - } + _os->startWriteException(slicedData); } void -Ice::OutputStreamI::writeLongSeq(const Ice::Long* begin, const Ice::Long* end) +OutputStreamI::endException() { - write(begin, end); + _os->endWriteException(); } void -Ice::OutputStreamI::writeFloat(Float v) +OutputStreamI::startSlice(const string& typeId, bool lastSlice) { - _os->write(v); + _os->startWriteSlice(typeId, lastSlice); } void -Ice::OutputStreamI::writeFloatSeq(const vector<Float>& v) +OutputStreamI::endSlice() { - if(v.size() == 0) - { - _os->writeSize(0); - } - else - { - _os->write(&v[0], &v[0] + v.size()); - } + _os->endWriteSlice(); } void -Ice::OutputStreamI::writeFloatSeq(const Ice::Float* begin, const Ice::Float* end) +OutputStreamI::startEncapsulation(const EncodingVersion& version, FormatType format) { - write(begin, end); + _os->startWriteEncaps(version, format); } void -Ice::OutputStreamI::writeDouble(Double v) +OutputStreamI::startEncapsulation() { - _os->write(v); + _os->startWriteEncaps(); } void -Ice::OutputStreamI::writeDoubleSeq(const vector<Double>& v) +OutputStreamI::endEncapsulation() { - if(v.size() == 0) - { - _os->writeSize(0); - } - else - { - _os->write(&v[0], &v[0] + v.size()); - } + _os->endWriteEncapsChecked(); } -void -Ice::OutputStreamI::writeDoubleSeq(const Ice::Double* begin, const Ice::Double* end) +EncodingVersion +OutputStreamI::getEncoding() { - write(begin, end); + return _os->getWriteEncoding(); } void -Ice::OutputStreamI::write(const Short* begin, const Short* end) +OutputStreamI::writePendingObjects() { - _os->write(begin, end); + _os->writePendingObjects(); } void -Ice::OutputStreamI::writeString(const string& v, bool convert) +OutputStreamI::finished(vector<Byte>& bytes) { - _os->write(v, convert); + vector<Byte>(_os->b.begin(), _os->b.end()).swap(bytes); } void -Ice::OutputStreamI::writeStringSeq(const vector<string>& v, bool convert) +OutputStreamI::reset(bool clearBuffer) { - if(v.size() == 0) + _os->clear(); + + if(clearBuffer) { - _os->writeSize(0); + _os->b.clear(); } else { - _os->write(&v[0], &v[0] + v.size(), convert); + _os->b.reset(); } + + _os->i = _os->b.begin(); } -void -Ice::OutputStreamI::writeWstring(const wstring& v) +OutputStream::size_type +OutputStreamI::pos() { - _os->write(v); + return _os->pos(); } void -Ice::OutputStreamI::writeWstringSeq(const vector<wstring>& v) +OutputStreamI::rewrite(Int sz, size_type p) { - if(v.size() == 0) - { - _os->writeSize(0); - } - else - { - _os->write(&v[0], &v[0] + v.size()); - } + _os->rewrite(sz, p); } // // ObjectReader // void -Ice::ObjectReader::__write(BasicStream*) const +ObjectReader::__write(BasicStream*) const { assert(false); } void -Ice::ObjectReader::__read(BasicStream* is, bool rid) +ObjectReader::__read(BasicStream* is) { InputStreamI* stream = reinterpret_cast<InputStreamI*>(is->closure()); assert(stream); - read(stream, rid); + read(stream); } void -Ice::ObjectReader::__write(const Ice::OutputStreamPtr&) const +ObjectReader::__write(const OutputStreamPtr&) const { assert(false); } void -Ice::ObjectReader::__read(const Ice::InputStreamPtr&, bool) +ObjectReader::__read(const InputStreamPtr&) { assert(false); } @@ -926,7 +710,7 @@ Ice::ObjectReader::__read(const Ice::InputStreamPtr&, bool) // ObjectWriter // void -Ice::ObjectWriter::__write(BasicStream* os) const +ObjectWriter::__write(BasicStream* os) const { OutputStreamI* stream = reinterpret_cast<OutputStreamI*>(os->closure()); assert(stream); @@ -934,19 +718,19 @@ Ice::ObjectWriter::__write(BasicStream* os) const } void -Ice::ObjectWriter::__read(BasicStream*, bool) +ObjectWriter::__read(BasicStream*) { assert(false); } void -Ice::ObjectWriter::__write(const Ice::OutputStreamPtr&) const +ObjectWriter::__write(const OutputStreamPtr&) const { assert(false); } void -Ice::ObjectWriter::__read(const Ice::InputStreamPtr&, bool) +ObjectWriter::__read(const InputStreamPtr&) { assert(false); } @@ -954,17 +738,17 @@ Ice::ObjectWriter::__read(const Ice::InputStreamPtr&, bool) // // UserExceptionWriter // -Ice::UserExceptionWriter::UserExceptionWriter(const Ice::CommunicatorPtr& communicator) : +UserExceptionWriter::UserExceptionWriter(const CommunicatorPtr& communicator) : _communicator(communicator) { } -Ice::UserExceptionWriter::~UserExceptionWriter() throw() +UserExceptionWriter::~UserExceptionWriter() throw() { } void -Ice::UserExceptionWriter::__write(BasicStream* os) const +UserExceptionWriter::__write(BasicStream* os) const { OutputStreamI* stream = reinterpret_cast<OutputStreamI*>(os->closure()); if(!stream) @@ -978,13 +762,13 @@ Ice::UserExceptionWriter::__write(BasicStream* os) const } void -Ice::UserExceptionWriter::__read(BasicStream*, bool) +UserExceptionWriter::__read(BasicStream*) { assert(false); } bool -Ice::UserExceptionWriter::__usesClasses() const +UserExceptionWriter::__usesClasses() const { return usesClasses(); } |