Support for optionals

1 files changed, 155 insertions, 504 deletions

diff --git a/cpp/src/Ice/StreamI.cpp b/cpp/src/Ice/StreamI.cpp
index b25856f58ad..1db13f0f33c 100644
--- a/cpp/src/Ice/StreamI.cpp
+++ b/cpp/src/Ice/StreamI.cpp
@@ -37,7 +37,7 @@ class UserExceptionFactoryI : public IceInternal::UserExceptionFactory
 {
 public:
 
-    UserExceptionFactoryI(const Ice::UserExceptionReaderFactoryPtr& factory) :
+    UserExceptionFactoryI(const UserExceptionReaderFactoryPtr& factory) :
         _factory(factory)
     {
     }
@@ -49,7 +49,7 @@ public:
 
 private:
 
-    const Ice::UserExceptionReaderFactoryPtr _factory;
+    const UserExceptionReaderFactoryPtr _factory;
 };
 
 }
@@ -57,23 +57,23 @@ private:
 //
 // UserExceptionReader
 //
-Ice::UserExceptionReader::UserExceptionReader(const Ice::CommunicatorPtr& communicator) :
+UserExceptionReader::UserExceptionReader(const CommunicatorPtr& communicator) :
     _communicator(communicator)
 {
 }
 
-Ice::UserExceptionReader::~UserExceptionReader() throw()
+UserExceptionReader::~UserExceptionReader() throw()
 {
 }
 
 void
-Ice::UserExceptionReader::__write(BasicStream*) const
+UserExceptionReader::__write(BasicStream*) const
 {
     assert(false);
 }
 
 void
-Ice::UserExceptionReader::__read(BasicStream* is)
+UserExceptionReader::__read(BasicStream* is)
 {
     InputStreamI* stream = reinterpret_cast<InputStreamI*>(is->closure());
     assert(stream);
@@ -81,13 +81,13 @@ Ice::UserExceptionReader::__read(BasicStream* is)
 }
 
 bool
-Ice::UserExceptionReader::__usesClasses() const
+UserExceptionReader::__usesClasses() const
 {
     return usesClasses();
 }
 
 void
-Ice::UserExceptionReader::__usesClasses(bool b)
+UserExceptionReader::__usesClasses(bool b)
 {
     usesClasses(b);
 }
@@ -95,7 +95,7 @@ Ice::UserExceptionReader::__usesClasses(bool b)
 //
 // InputStreamI
 //
-Ice::InputStreamI::InputStreamI(const Ice::CommunicatorPtr& communicator, const vector<Byte>& data) :
+InputStreamI::InputStreamI(const CommunicatorPtr& communicator, const vector<Byte>& data) :
     _communicator(communicator),
     _closure(0)
 {
@@ -106,7 +106,7 @@ Ice::InputStreamI::InputStreamI(const Ice::CommunicatorPtr& communicator, const
     _is->i = _is->b.begin();
 }
 
-Ice::InputStreamI::InputStreamI(const Ice::CommunicatorPtr& communicator, const pair<const Byte*, const Byte*>& data) :
+InputStreamI::InputStreamI(const CommunicatorPtr& communicator, const pair<const Byte*, const Byte*>& data) :
     _communicator(communicator),
     _closure(0)
 {
@@ -117,230 +117,39 @@ Ice::InputStreamI::InputStreamI(const Ice::CommunicatorPtr& communicator, const
     _is->i = _is->b.begin();
 }
 
-Ice::InputStreamI::~InputStreamI()
+InputStreamI::~InputStreamI()
 {
     delete _is;
 }
 
 CommunicatorPtr
-Ice::InputStreamI::communicator() const
+InputStreamI::communicator() const
 {
     return _communicator;
 }
 
 void
-Ice::InputStreamI::sliceObjects(bool b)
+InputStreamI::sliceObjects(bool b)
 {
     _is->sliceObjects(b);
 }
 
-bool
-Ice::InputStreamI::readBool()
-{
-    bool v;
-    _is->read(v);
-    return v;
-}
-
-vector<bool>
-Ice::InputStreamI::readBoolSeq()
-{
-    vector<bool> v;
-    _is->read(v);
-    return v;
-}
-
-bool*
-Ice::InputStreamI::readBoolSeq(pair<const bool*, const bool*>& p)
-{
-    return _is->read(p);
-}
-
-Byte
-Ice::InputStreamI::readByte()
-{
-    Byte v;
-    _is->read(v);
-    return v;
-}
-
-vector<Byte>
-Ice::InputStreamI::readByteSeq()
-{
-    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()
-{
-    Float v;
-    _is->read(v);
-    return v;
-}
-
-vector<Float>
-Ice::InputStreamI::readFloatSeq()
-{
-    vector<Float> v;
-    _is->read(v);
-    return v;
-}
-
-Float*
-Ice::InputStreamI::readFloatSeq(pair<const Float*, const Float*>& p)
-{
-    return _is->read(p);
-}
-
-Double
-Ice::InputStreamI::readDouble()
-{
-    Double v;
-    _is->read(v);
-    return v;
-}
-
-vector<Double>
-Ice::InputStreamI::readDoubleSeq()
-{
-    vector<Double> v;
-    _is->read(v);
-    return v;
-}
-
-Double*
-Ice::InputStreamI::readDoubleSeq(pair<const Double*, const Double*>& p)
-{
-    return _is->read(p);
-}
-
-string
-Ice::InputStreamI::readString(bool convert)
-{
-    string v;
-    _is->read(v, convert);
-    return v;
-}
-
-vector<string>
-Ice::InputStreamI::readStringSeq(bool convert)
-{
-    vector<string> v;
-    _is->read(v, convert);
-    return v;
-}
-
-wstring
-Ice::InputStreamI::readWstring()
-{
-    wstring v;
-    _is->read(v);
-    return v;
-}
-
-vector<wstring>
-Ice::InputStreamI::readWstringSeq()
-{
-    vector<wstring> v;
-    _is->read(v);
-    return v;
-}
-
 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;
 }
@@ -359,208 +168,232 @@ 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());
 }
 
 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::throwException(const UserExceptionReaderFactoryPtr& factory)
+InputStreamI::throwException(const UserExceptionReaderFactoryPtr& factory)
 {
     UserExceptionFactoryPtr del = new UserExceptionFactoryI(factory);
     _is->throwException(del);
 }
 
 void
-Ice::InputStreamI::startObject()
+InputStreamI::startObject()
 {
     _is->startReadObject();
 }
 
 SlicedDataPtr
-Ice::InputStreamI::endObject(bool preserve)
+InputStreamI::endObject(bool preserve)
 {
     return _is->endReadObject(preserve);
 }
 
 void
-Ice::InputStreamI::startException()
+InputStreamI::startException()
 {
     _is->startReadException();
 }
 
 SlicedDataPtr
-Ice::InputStreamI::endException(bool preserve)
+InputStreamI::endException(bool preserve)
 {
     return _is->endReadException(preserve);
 }
 
 string
-Ice::InputStreamI::startSlice()
+InputStreamI::startSlice()
 {
     return _is->startReadSlice();
 }
 
 void
-Ice::InputStreamI::endSlice()
+InputStreamI::endSlice()
 {
     _is->endReadSlice();
 }
 
-Ice::EncodingVersion
-Ice::InputStreamI::startEncapsulation()
+void
+InputStreamI::skipSlice()
+{
+    _is->skipSlice();
+}
+
+EncodingVersion
+InputStreamI::startEncapsulation()
 {
     return _is->startReadEncaps();
 }
 
 void
-Ice::InputStreamI::endEncapsulation()
+InputStreamI::endEncapsulation()
 {
     _is->endReadEncapsChecked();
 }
 
-Ice::EncodingVersion
-Ice::InputStreamI::skipEncapsulation()
+EncodingVersion
+InputStreamI::skipEncapsulation()
 {
     return _is->skipEncaps();
 }
 
-void
-Ice::InputStreamI::skipSlice()
+EncodingVersion
+InputStreamI::getEncoding()
 {
-    _is->skipSlice();
+    return _is->getReadEncoding();
 }
 
 void
-Ice::InputStreamI::readPendingObjects()
+InputStreamI::readPendingObjects()
 {
     _is->readPendingObjects();
 }
 
 void
-Ice::InputStreamI::rewind()
+InputStreamI::rewind()
 {
     _is->clear();
     _is->i = _is->b.begin();
 }
 
 void
-Ice::InputStreamI::closure(void* p)
+InputStreamI::skip(Int sz)
+{
+    _is->skip(sz);
+}
+
+void
+InputStreamI::skipSize()
+{
+    _is->skipSize();
+}
+
+void
+InputStreamI::closure(void* p)
 {
     _closure = p;
 }
 
 void*
-Ice::InputStreamI::closure() const
+InputStreamI::closure() const
 {
     return _closure;
 }
@@ -568,7 +401,7 @@ Ice::InputStreamI::closure() const
 //
 // 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)
@@ -579,7 +412,7 @@ Ice::OutputStreamI::OutputStreamI(const Ice::CommunicatorPtr& communicator, Basi
     _os->closure(this);
 }
 
-Ice::OutputStreamI::~OutputStreamI()
+OutputStreamI::~OutputStreamI()
 {
     if(_own)
     {
@@ -588,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)
     {
@@ -623,61 +456,61 @@ Ice::OutputStreamI::writeSize(Int sz)
 }
 
 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)
     {
@@ -690,121 +523,139 @@ 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::format(FormatType format)
+OutputStreamI::write(const Double* begin, const Double* end)
+{
+    _os->write(begin, end);
+}
+
+void
+OutputStreamI::writeOptional(Int tag, OptionalType type)
+{
+    _os->writeOpt(tag, type);
+}
+
+void
+OutputStreamI::format(FormatType format)
 {
     _os->format(format);
 }
 
 void
-Ice::OutputStreamI::startObject(const SlicedDataPtr& slicedData)
+OutputStreamI::startObject(const SlicedDataPtr& slicedData)
 {
     _os->startWriteObject(slicedData);
 }
 
 void
-Ice::OutputStreamI::endObject()
+OutputStreamI::endObject()
 {
     _os->endWriteObject();
 }
 
 void
-Ice::OutputStreamI::startException(const SlicedDataPtr& slicedData)
+OutputStreamI::startException(const SlicedDataPtr& slicedData)
 {
     _os->startWriteException(slicedData);
 }
 
 void
-Ice::OutputStreamI::endException()
+OutputStreamI::endException()
 {
     _os->endWriteException();
 }
 
 void
-Ice::OutputStreamI::startSlice(const string& typeId, bool lastSlice)
+OutputStreamI::startSlice(const string& typeId, bool lastSlice)
 {
     _os->startWriteSlice(typeId, lastSlice);
 }
 
 void
-Ice::OutputStreamI::endSlice()
+OutputStreamI::endSlice()
 {
     _os->endWriteSlice();
 }
 
 void
-Ice::OutputStreamI::startEncapsulation(const Ice::EncodingVersion& version)
+OutputStreamI::startEncapsulation(const EncodingVersion& version)
 {
     _os->startWriteEncaps(version);
 }
 
 void
-Ice::OutputStreamI::startEncapsulation()
+OutputStreamI::startEncapsulation()
 {
     _os->startWriteEncaps();
 }
 
 void
-Ice::OutputStreamI::endEncapsulation()
+OutputStreamI::endEncapsulation()
 {
     _os->endWriteEncapsChecked();
 }
 
+EncodingVersion
+OutputStreamI::getEncoding()
+{
+    return _os->getWriteEncoding();
+}
+
 void
-Ice::OutputStreamI::writePendingObjects()
+OutputStreamI::writePendingObjects()
 {
     _os->writePendingObjects();
 }
 
 void
-Ice::OutputStreamI::finished(vector<Byte>& bytes)
+OutputStreamI::finished(vector<Byte>& bytes)
 {
     vector<Byte>(_os->b.begin(), _os->b.end()).swap(bytes);
 }
 
 void
-Ice::OutputStreamI::reset(bool clearBuffer)
+OutputStreamI::reset(bool clearBuffer)
 {
     _os->clear();
     
@@ -820,229 +671,29 @@ Ice::OutputStreamI::reset(bool clearBuffer)
     _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)
-{
-    write(begin, end);
-}
-
-void
-Ice::OutputStreamI::writeInt(Int v)
-{
-    _os->write(v);
-}
-
-void
-Ice::OutputStreamI::writeIntSeq(const vector<Int>& v)
-{
-    if(v.size() == 0)
-    {
-        _os->writeSize(0);
-    }
-    else
-    {
-        _os->write(&v[0], &v[0] + v.size());
-    }
-}
-
-void
-Ice::OutputStreamI::writeIntSeq(const Ice::Int* begin, const Ice::Int* end)
-{
-    write(begin, end);
-}
-
-void
-Ice::OutputStreamI::writeLong(Long v)
-{
-    _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());
-    }
-}
-
-void
-Ice::OutputStreamI::writeLongSeq(const Ice::Long* begin, const Ice::Long* end)
-{
-    write(begin, end);
-}
-
-void
-Ice::OutputStreamI::writeFloat(Float v)
-{
-    _os->write(v);
-}
-
-void
-Ice::OutputStreamI::writeFloatSeq(const vector<Float>& v)
-{
-    if(v.size() == 0)
-    {
-        _os->writeSize(0);
-    }
-    else
-    {
-        _os->write(&v[0], &v[0] + v.size());
-    }
-}
-
-void
-Ice::OutputStreamI::writeFloatSeq(const Ice::Float* begin, const Ice::Float* end)
-{
-    write(begin, end);
-}
-
-void
-Ice::OutputStreamI::writeDouble(Double v)
-{
-    _os->write(v);
-}
-
-void
-Ice::OutputStreamI::writeDoubleSeq(const vector<Double>& v)
-{
-    if(v.size() == 0)
-    {
-        _os->writeSize(0);
-    }
-    else
-    {
-        _os->write(&v[0], &v[0] + v.size());
-    }
-}
-
-void
-Ice::OutputStreamI::writeDoubleSeq(const Ice::Double* begin, const Ice::Double* end)
-{
-    write(begin, end);
-}
-
-void
-Ice::OutputStreamI::write(const Short* begin, const Short* end)
-{
-    _os->write(begin, end);
-}
-
-void
-Ice::OutputStreamI::writeString(const string& v, bool convert)
+OutputStream::size_type
+OutputStreamI::pos()
 {
-    _os->write(v, convert);
+    return _os->pos();
 }
 
 void
-Ice::OutputStreamI::writeStringSeq(const vector<string>& v, bool convert)
+OutputStreamI::rewrite(size_type p, Int sz)
 {
-    if(v.size() == 0)
-    {
-        _os->writeSize(0);
-    }
-    else
-    {
-        _os->write(&v[0], &v[0] + v.size(), convert);
-    }
-}
-
-void
-Ice::OutputStreamI::writeWstring(const wstring& v)
-{
-    _os->write(v);
-}
-
-void
-Ice::OutputStreamI::writeWstringSeq(const vector<wstring>& v)
-{
-    if(v.size() == 0)
-    {
-        _os->writeSize(0);
-    }
-    else
-    {
-        _os->write(&v[0], &v[0] + v.size());
-    }
+    _os->rewrite(p, sz);
 }
 
 //
 // ObjectReader
 //
 void
-Ice::ObjectReader::__write(BasicStream*) const
+ObjectReader::__write(BasicStream*) const
 {
     assert(false);
 }
 
 void
-Ice::ObjectReader::__read(BasicStream* is)
+ObjectReader::__read(BasicStream* is)
 {
     InputStreamI* stream = reinterpret_cast<InputStreamI*>(is->closure());
     assert(stream);
@@ -1050,13 +701,13 @@ Ice::ObjectReader::__read(BasicStream* is)
 }
 
 void
-Ice::ObjectReader::__write(const Ice::OutputStreamPtr&) const
+ObjectReader::__write(const OutputStreamPtr&) const
 {
     assert(false);
 }
 
 void
-Ice::ObjectReader::__read(const Ice::InputStreamPtr&)
+ObjectReader::__read(const InputStreamPtr&)
 {
     assert(false);
 }
@@ -1065,7 +716,7 @@ Ice::ObjectReader::__read(const Ice::InputStreamPtr&)
 // ObjectWriter
 //
 void
-Ice::ObjectWriter::__write(BasicStream* os) const
+ObjectWriter::__write(BasicStream* os) const
 {
     OutputStreamI* stream = reinterpret_cast<OutputStreamI*>(os->closure());
     assert(stream);
@@ -1073,19 +724,19 @@ Ice::ObjectWriter::__write(BasicStream* os) const
 }
 
 void
-Ice::ObjectWriter::__read(BasicStream*)
+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&)
+ObjectWriter::__read(const InputStreamPtr&)
 {
     assert(false);
 }
@@ -1093,17 +744,17 @@ Ice::ObjectWriter::__read(const Ice::InputStreamPtr&)
 //
 // 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)
@@ -1117,13 +768,13 @@ Ice::UserExceptionWriter::__write(BasicStream* os) const
 }
 
 void
-Ice::UserExceptionWriter::__read(BasicStream*)
+UserExceptionWriter::__read(BasicStream*)
 {
     assert(false);
 }
 
 bool
-Ice::UserExceptionWriter::__usesClasses() const
+UserExceptionWriter::__usesClasses() const
 {
     return usesClasses();
 }