ICE-4938: Super compact enoding

14 files changed, 1524 insertions, 1042 deletions

diff --git a/cpp/include/Ice/BasicStream.h b/cpp/include/Ice/BasicStream.h
index bf343b01ff5..b5036a79528 100644
--- a/cpp/include/Ice/BasicStream.h
+++ b/cpp/include/Ice/BasicStream.h
@@ -41,7 +41,7 @@ namespace IceInternal
 {
 
 template<typename T> inline void 
-patchHandle(void* addr, Ice::ObjectPtr& v)
+patchHandle(void* addr, const Ice::ObjectPtr& v)
 {
     IceInternal::Handle<T>* p = static_cast<IceInternal::Handle<T>*>(addr);
     __patch(*p, v); // Generated __patch method, necessary for forward declarations.
@@ -52,7 +52,7 @@ class ICE_API BasicStream : public Buffer
 public:
 
     typedef size_t size_type;
-    typedef void (*PatchFunc)(void*, Ice::ObjectPtr&);
+    typedef void (*PatchFunc)(void*, const Ice::ObjectPtr&);
 
     BasicStream(Instance*, const Ice::EncodingVersion&, bool = false);
     ~BasicStream()
@@ -95,45 +95,45 @@ public:
     void startWriteObject(const Ice::SlicedDataPtr& data)
     {
         assert(_currentWriteEncaps && _currentWriteEncaps->encoder);
-        _currentWriteEncaps->encoder->startObject(data);
+        _currentWriteEncaps->encoder->startInstance(ObjectSlice, data);
     }
     void endWriteObject()
     {
         assert(_currentWriteEncaps && _currentWriteEncaps->encoder);
-        _currentWriteEncaps->encoder->endObject();
+        _currentWriteEncaps->encoder->endInstance();
     }
 
     void startReadObject()
     {
         assert(_currentReadEncaps && _currentReadEncaps->decoder);
-        _currentReadEncaps->decoder->startObject();
+        _currentReadEncaps->decoder->startInstance(ObjectSlice);
     }
     Ice::SlicedDataPtr endReadObject(bool preserve)
     {
         assert(_currentReadEncaps && _currentReadEncaps->decoder);
-        return _currentReadEncaps->decoder->endObject(preserve);
+        return _currentReadEncaps->decoder->endInstance(preserve);
     }
 
     void startWriteException(const Ice::SlicedDataPtr& data)
     {
         assert(_currentWriteEncaps && _currentWriteEncaps->encoder);
-        _currentWriteEncaps->encoder->startException(data);
+        _currentWriteEncaps->encoder->startInstance(ExceptionSlice, data);
     }
     void endWriteException()
     {
         assert(_currentWriteEncaps && _currentWriteEncaps->encoder);
-        _currentWriteEncaps->encoder->endException();
+        _currentWriteEncaps->encoder->endInstance();
     }
 
     void startReadException()
     {
         assert(_currentReadEncaps && _currentReadEncaps->decoder);
-        _currentReadEncaps->decoder->startException();
+        _currentReadEncaps->decoder->startInstance(ExceptionSlice);
     }
     Ice::SlicedDataPtr endReadException(bool preserve)
     {
         assert(_currentReadEncaps && _currentReadEncaps->decoder);
-        return _currentReadEncaps->decoder->endException(preserve);
+        return _currentReadEncaps->decoder->endInstance(preserve);
     }
 
     void startWriteEncaps();
@@ -163,11 +163,6 @@ public:
     {
         assert(_currentWriteEncaps);
 
-        if(_currentWriteEncaps->encoder)
-        {
-            _currentWriteEncaps->encoder->writePendingObjects();
-        }
-
         // Size includes size and version.
         const Ice::Int sz = static_cast<Ice::Int>(b.size() - _currentWriteEncaps->start);
         write(sz, &(*(b.begin() + _currentWriteEncaps->start)));
@@ -250,34 +245,21 @@ public:
     {
         assert(_currentReadEncaps);
 
-        if(_currentReadEncaps->decoder)
-        {
-            _currentReadEncaps->decoder->readPendingObjects();
-        } 
-        else if(i < b.begin() + _currentReadEncaps->start + _currentReadEncaps->sz &&
-                _currentReadEncaps->encoding != Ice::Encoding_1_0)
+        if(_currentReadEncaps->encoding != Ice::Encoding_1_0)
         {
-            //
-            // Read remaining encapsulation optionals. This returns
-            // true if the optionals end with the end marker. The end
-            // marker indicates that there are more to read from the
-            // encapsulation: object instances. In this case, don't
-            // bother reading the objects, just skip to the end of the
-            // encapsulation.
-            //
-            if(skipOpts())
+            skipOpts();
+            if(i != b.begin() + _currentReadEncaps->start + _currentReadEncaps->sz)
             {
-                i = b.begin() + _currentReadEncaps->start + _currentReadEncaps->sz;
+                throwEncapsulationException(__FILE__, __LINE__);
             }
         }
-
-        if(i != b.begin() + _currentReadEncaps->start + _currentReadEncaps->sz)
+        else if(i != b.begin() + _currentReadEncaps->start + _currentReadEncaps->sz)
         {
             if(i + 1 != b.begin() + _currentReadEncaps->start + _currentReadEncaps->sz)
             {
                 throwEncapsulationException(__FILE__, __LINE__);
             }
-
+            
             //
             // Ice version < 3.3 had a bug where user exceptions with
             // class members could be encoded with a trailing byte
@@ -355,7 +337,7 @@ public:
         _currentWriteEncaps->encoder->endSlice();
     }
 
-    std::string startReadSlice() // Returns type ID of next slice
+    std::string startReadSlice()
     {
         assert(_currentReadEncaps && _currentReadEncaps->decoder);
         return _currentReadEncaps->decoder->startSlice();
@@ -387,14 +369,6 @@ public:
             write(static_cast<Ice::Byte>(v));
         }
     }
-    void writeSizeSeq(const std::vector<Ice::Int>& v)
-    {
-        writeSize(static_cast<Ice::Int>(v.size()));
-        for(std::vector<Ice::Int>::const_iterator p = v.begin(); p != v.end(); ++p)
-        {
-            writeSize(*p);
-        }
-    }
     void rewriteSize(Ice::Int v, Container::iterator dest)
     {
         assert(v >= 0);
@@ -428,22 +402,6 @@ public:
             return static_cast<Ice::Int>(static_cast<unsigned char>(byte));
         }
     }
-    void readSizeSeq(std::vector<Ice::Int>& v)
-    {
-        Ice::Int sz = readAndCheckSeqSize(1);
-        if(sz > 0)
-        {
-            v.resize(sz);
-            for(Ice::Int n = 0; n < sz; ++n)
-            {
-                v[n] = readSize();
-            }
-        }
-        else
-        {
-            v.clear();
-        }
-    }
 
     Ice::Int readAndCheckSeqSize(int);
 
@@ -510,7 +468,9 @@ public:
                                                    Ice::StreamableTraits<T>::helper, 
                                                    Ice::StreamableTraits<T>::fixedLength>::optionalFormat))
         {
-            Ice::StreamOptionalHelper<T, Ice::StreamableTraits<T>::helper, Ice::StreamableTraits<T>::fixedLength>::write(this, *v);
+            Ice::StreamOptionalHelper<T, 
+                                      Ice::StreamableTraits<T>::helper, 
+                                      Ice::StreamableTraits<T>::fixedLength>::write(this, *v);
         }
     }
     template<typename T> void read(Ice::Int tag, IceUtil::Optional<T>& v)
@@ -520,7 +480,9 @@ public:
                                                   Ice::StreamableTraits<T>::fixedLength>::optionalFormat))
         {
             v.__setIsSet();
-            Ice::StreamOptionalHelper<T, Ice::StreamableTraits<T>::helper, Ice::StreamableTraits<T>::fixedLength>::read(this, *v);
+            Ice::StreamOptionalHelper<T, 
+                                      Ice::StreamableTraits<T>::helper,
+                                      Ice::StreamableTraits<T>::fixedLength>::read(this, *v);
         }
         else
         {
@@ -778,7 +740,6 @@ public:
     }
     void read(PatchFunc patchFunc, void* patchAddr)
     {
-        assert(patchFunc && patchAddr);
         initReadEncaps();
         _currentReadEncaps->decoder->read(patchFunc, patchAddr);
     }
@@ -800,8 +761,8 @@ public:
     // Read/write/skip optionals
     bool readOptImpl(Ice::Int, Ice::OptionalFormat);
     bool writeOptImpl(Ice::Int, Ice::OptionalFormat);
-    bool skipOpt(Ice::OptionalFormat);
-    bool skipOpts();
+    void skipOpt(Ice::OptionalFormat);
+    void skipOpts();
     
     // Skip bytes from the stream
     void skip(size_type size)
@@ -831,35 +792,6 @@ public:
         write(value, b.begin() + p);
     }
 
-    struct IndirectPatchEntry
-    {
-        Ice::Int index;
-        PatchFunc patchFunc;
-        void* patchAddr;
-    };
-
-    struct PatchEntry
-    {
-        PatchFunc patchFunc;
-        void* patchAddr;
-    };
-
-    typedef std::vector<PatchEntry> PatchList;
-    typedef std::map<Ice::Int, PatchList> PatchMap;
-    typedef std::map<Ice::Int, Ice::ObjectPtr> IndexToPtrMap;
-    typedef std::map<Ice::Int, std::string> TypeIdReadMap;
-
-    typedef std::map<Ice::ObjectPtr, Ice::Int> PtrToIndexMap;
-    typedef std::map<std::string, Ice::Int> TypeIdWriteMap;
-
-    typedef std::vector<Ice::ObjectPtr> ObjectList;
-
-    typedef std::vector<IndirectPatchEntry> IndirectPatchList;
-    typedef std::vector<Ice::Int> IndexList;
-    typedef std::map<Ice::Int, Ice::Int> IndirectionMap;
-
-    typedef std::vector<IndexList> IndexListList;
-
 private:
 
     //
@@ -886,147 +818,338 @@ private:
     class WriteEncaps;
     enum SliceType { NoSlice, ObjectSlice, ExceptionSlice };
 
+    typedef std::vector<Ice::ObjectPtr> ObjectList;
+
     class ICE_API EncapsDecoder : private ::IceUtil::noncopyable
     {
     public:
-        EncapsDecoder(BasicStream* stream, ReadEncaps* encaps, bool sliceObjects) :
-            _stream(stream), _encaps(encaps), _sliceObjects(sliceObjects), _traceSlicing(-1), _sliceType(NoSlice),
-            _compactId(-1), _typeIdIndex(0)
-        {
-        } 
-
-        void read(PatchFunc, void*);
-        void throwException(const UserExceptionFactoryPtr&);
 
-        void startObject();
-        Ice::SlicedDataPtr endObject(bool);
+        virtual ~EncapsDecoder() { }
 
-        void startException();
-        Ice::SlicedDataPtr endException(bool);
+        virtual void read(PatchFunc, void*) = 0;
+        virtual void throwException(const UserExceptionFactoryPtr&) = 0;
 
-        const std::string& startSlice();
-        void endSlice();
-        void skipSlice();
+        virtual void startInstance(SliceType) = 0;
+        virtual Ice::SlicedDataPtr endInstance(bool) = 0;
+        virtual const std::string& startSlice() = 0;
+        virtual void endSlice() = 0;
+        virtual void skipSlice() = 0;
 
-        bool readOpt(Ice::Int readTag, Ice::OptionalFormat expectedFormat)
+        virtual bool readOpt(Ice::Int, Ice::OptionalFormat)
         {
-            if(_sliceType == NoSlice)
-            {
-                return _stream->readOptImpl(readTag, expectedFormat);
-            }
-            else if(_sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS)
-            {
-                return _stream->readOptImpl(readTag, expectedFormat);
-            }
             return false;
         }
 
-        void readPendingObjects();
+        virtual void readPendingObjects()
+        {
+        }
+
+    protected:
 
-    private:
+        EncapsDecoder(BasicStream* stream, ReadEncaps* encaps, bool sliceObjects, const ObjectFactoryManagerPtr& f) :
+            _stream(stream), _encaps(encaps), _sliceObjects(sliceObjects), _servantFactoryManager(f), _typeIdIndex(0)
+        {
+        } 
+
+        std::string readTypeId(bool);
+        Ice::ObjectPtr newInstance(const std::string&);
 
-        const std::string& readTypeId() const;
-        Ice::ObjectPtr readInstance();
         void addPatchEntry(Ice::Int, PatchFunc, void*);
-        Ice::SlicedDataPtr readSlicedData();
-        Ice::ObjectPtr newInstance(const IceInternal::ObjectFactoryManagerPtr&, const std::string&);
+        void unmarshal(Ice::Int, const Ice::ObjectPtr&);
+
+        typedef std::map<Ice::Int, Ice::ObjectPtr> IndexToPtrMap;
+        typedef std::map<Ice::Int, std::string> TypeIdReadMap;
+
+        struct PatchEntry
+        {
+            PatchFunc patchFunc;
+            void* patchAddr;
+        };
+        typedef std::vector<PatchEntry> PatchList;
+        typedef std::map<Ice::Int, PatchList> PatchMap;
 
         BasicStream* _stream;
         ReadEncaps* _encaps;
         const bool _sliceObjects;
+        ObjectFactoryManagerPtr _servantFactoryManager;
+
+        // Encapsulation attributes for object un-marshalling
+        PatchMap _patchMap;
+
+    private:
+
+        // Encapsulation attributes for object un-marshalling
+        IndexToPtrMap _unmarshaledMap;
+        TypeIdReadMap _typeIdMap;
+        Ice::Int _typeIdIndex;
+        ObjectList _objectList;
+    };
+
+    class ICE_API EncapsDecoder10 : public EncapsDecoder
+    {
+    public:
+
+        EncapsDecoder10(BasicStream* stream, ReadEncaps* encaps, bool sliceObjects, const ObjectFactoryManagerPtr& f) : 
+            EncapsDecoder(stream, encaps, sliceObjects, f), _sliceType(NoSlice)
+        {
+        } 
+
+        virtual void read(PatchFunc, void*);
+        virtual void throwException(const UserExceptionFactoryPtr&);
+
+        virtual void startInstance(SliceType);
+        virtual Ice::SlicedDataPtr endInstance(bool);
+        virtual const std::string& startSlice();
+        virtual void endSlice();
+        virtual void skipSlice();
+
+        virtual void readPendingObjects();
+
+    private:
 
-        int _traceSlicing;
-        const char* _slicingCat;
+        void readInstance();
 
-        // Object/exception attributes
+        // Instance attributes
         SliceType _sliceType;
         bool _skipFirstSlice;
-        Ice::SliceInfoSeq _slices;          // Preserved slices.
-        IndexListList _indirectionTables;   // Indirection tables for the preserved slices.
 
         // Slice attributes
-        Ice::Byte _sliceFlags;
         Ice::Int _sliceSize;
         std::string _typeId;
-        Ice::Int _compactId;
-        IndirectPatchList _indirectPatchList;
-        
-        // Encapsulation attributes for object un-marshalling
-        PatchMap _patchMap;
-        IndexToPtrMap _unmarshaledMap;
-        TypeIdReadMap _typeIdMap;
-        Ice::Int _typeIdIndex;
     };
 
-    class ICE_API EncapsEncoder : private ::IceUtil::noncopyable
+    class ICE_API EncapsDecoder11 : public EncapsDecoder
     {
     public:
-        EncapsEncoder(BasicStream* stream, WriteEncaps* encaps) : 
-            _stream(stream), _encaps(encaps), _sliceType(NoSlice), _objectIdIndex(0), 
-            _typeIdIndex(0)
+
+        EncapsDecoder11(BasicStream* stream, ReadEncaps* encaps, bool sliceObjects, const ObjectFactoryManagerPtr& f) :
+            EncapsDecoder(stream, encaps, sliceObjects, f), _preAllocatedInstanceData(0), _current(0), _objectIdIndex(1)
         {
-        }
+        } 
 
-        void write(const Ice::ObjectPtr&);
-        void write(const Ice::UserException&);
+        virtual void read(PatchFunc, void*);
+        virtual void throwException(const UserExceptionFactoryPtr&);
 
-        void startObject(const Ice::SlicedDataPtr&);
-        void endObject();
+        virtual void startInstance(SliceType);
+        virtual Ice::SlicedDataPtr endInstance(bool);
+        virtual const std::string& startSlice();
+        virtual void endSlice();
+        virtual void skipSlice();
 
-        void startException(const Ice::SlicedDataPtr&);
-        void endException();
+        virtual bool readOpt(Ice::Int, Ice::OptionalFormat);
 
-        void startSlice(const std::string&, int, bool);
-        void endSlice();
+    private:
 
-        bool writeOpt(Ice::Int tag, Ice::OptionalFormat format)
+        Ice::Int readInstance(Ice::Int, PatchFunc, void*);
+        Ice::SlicedDataPtr readSlicedData();
+
+        struct IndirectPatchEntry
         {
-            if(_sliceType == NoSlice)
-            {
-                return _stream->writeOptImpl(tag, format);
-            }
-            else
+            Ice::Int index;
+            PatchFunc patchFunc;
+            void* patchAddr;
+        };
+        typedef std::vector<IndirectPatchEntry> IndirectPatchList;
+
+        typedef std::vector<Ice::Int> IndexList;
+        typedef std::vector<IndexList> IndexListList;
+
+        struct InstanceData
+        {
+            InstanceData(InstanceData* previous) : previous(previous), next(0)
             {
-                if(_stream->writeOptImpl(tag, format))
+                if(previous)
                 {
-                    _sliceFlags |= FLAG_HAS_OPTIONAL_MEMBERS;
-                    return true;
+                    previous->next = this;
                 }
-                else
+            }
+
+            ~InstanceData()
+            {
+                if(next)
                 {
-                    return false;
+                    delete next;
                 }
             }
+
+            // Instance attributes
+            SliceType sliceType;
+            bool skipFirstSlice;
+            Ice::SliceInfoSeq slices; // Preserved slices.
+            IndexListList indirectionTables;
+
+            // Slice attributes
+            Ice::Byte sliceFlags;
+            Ice::Int sliceSize;
+            std::string typeId;
+            int compactId;
+            IndirectPatchList indirectPatchList;
+
+            InstanceData* previous;
+            InstanceData* next;
+        };
+        InstanceData _preAllocatedInstanceData;
+        InstanceData* _current;
+
+        void push(SliceType sliceType)
+        {
+            if(!_current)
+            {
+                _current = &_preAllocatedInstanceData;
+            }
+            else
+            {
+                _current = _current->next ? _current->next : new InstanceData(_current);
+            }
+            _current->sliceType = sliceType;
+            _current->skipFirstSlice = false;
         }
 
-        void writePendingObjects();
+        Ice::Int _objectIdIndex; // The ID of the next object to un-marshal.
+    };
 
-    private:
+    class ICE_API EncapsEncoder : private ::IceUtil::noncopyable
+    {
+    public:
 
-        void writeTypeId(const std::string&);
-        void writeSlicedData(const Ice::SlicedDataPtr&);
-        Ice::Int registerObject(const Ice::ObjectPtr&);
+        virtual ~EncapsEncoder() { }
+
+        virtual void write(const Ice::ObjectPtr&) = 0;
+        virtual void write(const Ice::UserException&) = 0;
+        
+        virtual void startInstance(SliceType, const Ice::SlicedDataPtr&) = 0;
+        virtual void endInstance() = 0;
+        virtual void startSlice(const std::string&, int, bool) = 0;
+        virtual void endSlice() = 0;
+
+        virtual bool writeOpt(Ice::Int, Ice::OptionalFormat)
+        {
+            return false;
+        }
+
+        virtual void writePendingObjects()
+        {
+        }
+
+    protected:
+
+        EncapsEncoder(BasicStream* stream, WriteEncaps* encaps) : _stream(stream), _encaps(encaps), _typeIdIndex(0)
+        {
+        }
+
+        Ice::Int registerTypeId(const std::string&);
 
         BasicStream* _stream;
         WriteEncaps* _encaps;
 
-        // Object/exception attributes
+        typedef std::map<Ice::ObjectPtr, Ice::Int> PtrToIndexMap;
+        typedef std::map<std::string, Ice::Int> TypeIdWriteMap;
+
+        // Encapsulation attributes for object marshalling.
+        PtrToIndexMap _marshaledMap;
+
+    private:
+
+        // Encapsulation attributes for object marshalling.
+        TypeIdWriteMap _typeIdMap;
+        Ice::Int _typeIdIndex;
+    };
+
+    class ICE_API EncapsEncoder10 : public EncapsEncoder
+    {
+    public:
+
+        EncapsEncoder10(BasicStream* stream, WriteEncaps* encaps) : 
+            EncapsEncoder(stream, encaps), _sliceType(NoSlice), _objectIdIndex(0)
+        {
+        }
+
+        virtual void write(const Ice::ObjectPtr&);
+        virtual void write(const Ice::UserException&);
+        
+        virtual void startInstance(SliceType, const Ice::SlicedDataPtr&);
+        virtual void endInstance();
+        virtual void startSlice(const std::string&, int, bool);
+        virtual void endSlice();
+
+        virtual void writePendingObjects();
+
+    private:
+
+        Ice::Int registerObject(const Ice::ObjectPtr&);
+
+        // Instance attributes
         SliceType _sliceType;
         bool _firstSlice;
 
         // Slice attributes
-        Ice::Byte _sliceFlags;
-        Container::size_type _writeSlice;    // Position of the slice data members
-        Container::size_type _sliceFlagsPos; // Position of the slice flags
-        IndexList _indirectionTable;
-        IndirectionMap _indirectionMap;
+        Container::size_type _writeSlice; // Position of the slice data members
 
         // Encapsulation attributes for object marshalling.
         Ice::Int _objectIdIndex;
         PtrToIndexMap _toBeMarshaledMap;
-        PtrToIndexMap _marshaledMap;
-        TypeIdWriteMap _typeIdMap;
-        Ice::Int _typeIdIndex;
+    };
+
+    class ICE_API EncapsEncoder11 : public EncapsEncoder
+    {
+    public:
+
+        EncapsEncoder11(BasicStream* stream, WriteEncaps* encaps) : 
+            EncapsEncoder(stream, encaps), _preAllocatedInstanceData(0), _current(0), _objectIdIndex(1)
+        {
+        }
+
+        virtual void write(const Ice::ObjectPtr&);
+        virtual void write(const Ice::UserException&);
+
+        virtual void startInstance(SliceType, const Ice::SlicedDataPtr&);
+        virtual void endInstance();
+        virtual void startSlice(const std::string&, int, bool);
+        virtual void endSlice();
+
+        virtual bool writeOpt(Ice::Int, Ice::OptionalFormat);
+
+    private:
+
+        void writeSlicedData(const Ice::SlicedDataPtr&);
+        void writeInstance(const Ice::ObjectPtr&);
+
+        struct InstanceData
+        {
+            InstanceData(InstanceData* previous) : previous(previous), next(0)
+            {
+                if(previous)
+                {
+                    previous->next = this;
+                }
+            }
+            
+            ~InstanceData()
+            {
+                if(next)
+                {
+                    delete next;
+                }
+            }
+            
+            // Instance attributes
+            SliceType sliceType;
+            bool firstSlice;
+
+            // Slice attributes
+            Ice::Byte sliceFlags;
+            Container::size_type writeSlice;    // Position of the slice data members
+            Container::size_type sliceFlagsPos; // Position of the slice flags
+            PtrToIndexMap indirectionMap;
+            ObjectList indirectionTable;
+
+            InstanceData* previous;
+            InstanceData* next;
+        };
+        InstanceData _preAllocatedInstanceData;
+        InstanceData* _current;
+
+        Ice::Int _objectIdIndex; // The ID of the next object to marhsal
     };
 
     class ReadEncaps : private ::IceUtil::noncopyable
@@ -1121,14 +1244,6 @@ private:
     int _minSeqSize;
 
     int _sizePos;
-
-    static const Ice::Byte FLAG_HAS_TYPE_ID_STRING;
-    static const Ice::Byte FLAG_HAS_TYPE_ID_INDEX;
-    static const Ice::Byte FLAG_HAS_TYPE_ID_COMPACT;
-    static const Ice::Byte FLAG_HAS_OPTIONAL_MEMBERS;
-    static const Ice::Byte FLAG_HAS_INDIRECTION_TABLE;
-    static const Ice::Byte FLAG_HAS_SLICE_SIZE;
-    static const Ice::Byte FLAG_IS_LAST_SLICE;
 };
 
 } // End namespace IceInternal
diff --git a/cpp/include/Ice/ObjectF.h b/cpp/include/Ice/ObjectF.h
index 5946be23dd0..e74e5ad50c0 100644
--- a/cpp/include/Ice/ObjectF.h
+++ b/cpp/include/Ice/ObjectF.h
@@ -19,7 +19,7 @@ namespace Ice
 class Object;
 ICE_API Object* upCast(Object*);
 typedef IceInternal::Handle< Object > ObjectPtr;
-ICE_API void __patch(ObjectPtr&, ObjectPtr&);
+ICE_API void __patch(ObjectPtr&, const ObjectPtr&);
 
 }
 
diff --git a/cpp/include/Ice/StreamHelpers.h b/cpp/include/Ice/StreamHelpers.h
index 81d30f4d543..ef6b8bf6510 100644
--- a/cpp/include/Ice/StreamHelpers.h
+++ b/cpp/include/Ice/StreamHelpers.h
@@ -51,10 +51,10 @@ enum OptionalFormat
     OptionalFormatF4 = 2,             // Fixed 4 bytes encoding
     OptionalFormatF8 = 3,             // Fixed 8 bytes encoding
     OptionalFormatSize = 4,           // "Size encoding" on 1 to 5 bytes, e.g. enum, class identifier
-    OptionalFormatVSize = 5,          // "Size encoding" on 1 to 5 bytes followed by data, e.g. string, fixed size struct,
-                                      // or containers whose size can be computed prior to marshaling
+    OptionalFormatVSize = 5,          // "Size encoding" on 1 to 5 bytes followed by data, e.g. string, fixed size 
+                                      // struct, or containers whose size can be computed prior to marshaling
     OptionalFormatFSize = 6,          // Fixed size on 4 bytes followed by data, e.g. variable-size struct, container.
-    OptionalFormatEndMarker = 7 
+    OptionalFormatClass = 7 
 };
 
 
@@ -566,7 +566,7 @@ struct GetOptionalFormat<StreamHelperCategoryBuiltin, 1, false>
 template<>
 struct GetOptionalFormat<StreamHelperCategoryClass, 1, false>
 {
-    static const OptionalFormat value = OptionalFormatSize;
+    static const OptionalFormat value = OptionalFormatClass;
 };
 
 template<int minWireSize>
diff --git a/cpp/src/Ice/BasicStream.cpp b/cpp/src/Ice/BasicStream.cpp
index 02b8f3046e0..d64d99f59a1 100644
--- a/cpp/src/Ice/BasicStream.cpp
+++ b/cpp/src/Ice/BasicStream.cpp
@@ -76,15 +76,18 @@ private:
     BasicStream& _stream;
 };
 
+const Byte OPTIONAL_END_MARKER        = 0xFF;
+
+const Byte FLAG_HAS_TYPE_ID_STRING    = (1<<0);
+const Byte FLAG_HAS_TYPE_ID_INDEX     = (1<<1);
+const Byte FLAG_HAS_TYPE_ID_COMPACT   = (1<<0) | (1<<1);
+const Byte FLAG_HAS_OPTIONAL_MEMBERS  = (1<<2);
+const Byte FLAG_HAS_INDIRECTION_TABLE = (1<<3);
+const Byte FLAG_HAS_SLICE_SIZE        = (1<<4);
+const Byte FLAG_IS_LAST_SLICE         = (1<<5);
+
 }
 
-const Byte BasicStream::FLAG_HAS_TYPE_ID_STRING    = (1<<0);
-const Byte BasicStream::FLAG_HAS_TYPE_ID_INDEX     = (1<<1);
-const Byte BasicStream::FLAG_HAS_TYPE_ID_COMPACT   = (1<<0) | (1<<1);
-const Byte BasicStream::FLAG_HAS_OPTIONAL_MEMBERS  = (1<<2);
-const Byte BasicStream::FLAG_HAS_INDIRECTION_TABLE = (1<<3);
-const Byte BasicStream::FLAG_HAS_SLICE_SIZE        = (1<<4);
-const Byte BasicStream::FLAG_IS_LAST_SLICE         = (1<<5);
 
 IceInternal::BasicStream::BasicStream(Instance* instance, const EncodingVersion& encoding, bool unlimited) :
     IceInternal::Buffer(instance->messageSizeMax()),
@@ -127,9 +130,7 @@ IceInternal::BasicStream::clear()
     }
 
     _startSeq = -1;
-
     _sizePos = -1;
-
     _sliceObjects = true;
 }
 
@@ -263,8 +264,6 @@ IceInternal::BasicStream::readPendingObjects()
     if(_currentReadEncaps && _currentReadEncaps->decoder)
     {
         _currentReadEncaps->decoder->readPendingObjects();
-        delete _currentReadEncaps->decoder;
-        _currentReadEncaps->decoder = 0;
     }
     else if(getReadEncoding() == Ice::Encoding_1_0)
     {
@@ -287,8 +286,6 @@ IceInternal::BasicStream::writePendingObjects()
     if(_currentWriteEncaps && _currentWriteEncaps->encoder)
     {
         _currentWriteEncaps->encoder->writePendingObjects();
-        delete _currentWriteEncaps->encoder;
-        _currentWriteEncaps->encoder = 0;
     }
     else if(getWriteEncoding() == Ice::Encoding_1_0)
     {
@@ -305,7 +302,6 @@ IceInternal::BasicStream::writePendingObjects()
     }
 }
 
-
 Int
 IceInternal::BasicStream::readAndCheckSeqSize(int minSize)
 {
@@ -1619,33 +1615,13 @@ IceInternal::BasicStream::writeException(const Ice::UserException& e)
 {
     initWriteEncaps();
     _currentWriteEncaps->encoder->write(e);
-
-    //
-    // Reset the encoder, the writing of the exception wrote
-    // pending objects if any.
-    //
-    delete _currentWriteEncaps->encoder;
-    _currentWriteEncaps->encoder = 0;
 }
 
 void
 IceInternal::BasicStream::throwException(const UserExceptionFactoryPtr& factory)
 {
     initReadEncaps();
-    try
-    {
-        _currentReadEncaps->decoder->throwException(factory);
-    }
-    catch(const Ice::UserException&)
-    {
-        //
-        // Reset the decoder, the reading of the exception wrote
-        // pending objects if any.
-        //
-        delete _currentReadEncaps->decoder;
-        _currentReadEncaps->decoder = 0;
-        throw;
-    }
+    _currentReadEncaps->decoder->throwException(factory);
 }
 
 void
@@ -1662,9 +1638,7 @@ IceInternal::BasicStream::readOptImpl(Int readTag, OptionalFormat expectedFormat
         return false; // Optional members aren't supported with the 1.0 encoding.
     }
 
-    Int tag = 0;
-    OptionalFormat format;
-    do
+    while(true)
     {
         if(i >= b.begin() + _currentReadEncaps->start + _currentReadEncaps->sz)
         {
@@ -1673,38 +1647,40 @@ IceInternal::BasicStream::readOptImpl(Int readTag, OptionalFormat expectedFormat
 
         Byte v;
         read(v);
-        format = static_cast<OptionalFormat>(v & 0x07); // First 3 bits.
-        tag = static_cast<Int>(v >> 3);
-        if(tag == 31)
+        if(v == OPTIONAL_END_MARKER)
+        {
+            --i; // Rewind
+            return false;
+        }
+        
+        OptionalFormat format = static_cast<OptionalFormat>(v & 0x07); // First 3 bits.
+        Int tag = static_cast<Int>(v >> 3);
+        if(tag == 30)
         {
             tag = readSize();
         }
-    }
-    while(format != OptionalFormatEndMarker && tag < readTag && skipOpt(format)); // Skip optional data members
-    
-    if(format == OptionalFormatEndMarker || tag > readTag)
-    {
-        //
-        // Rewind the stream to correctly read the next optional data
-        // member tag & format next time.
-        //
-        i -= tag < 31 ? 1 : (tag < 255 ? 2 : 6);
-        return false; // No optional data members with the requested tag.
-    } 
-    
-    assert(readTag == tag);
-    if(format != expectedFormat)
-    {
-        ostringstream os;
-        os << "invalid optional data member `" << tag << "': unexpected format";
-        throw MarshalException(__FILE__, __LINE__, os.str());
-    }
 
-    //
-    // We have an optional data member with the requested tag and
-    // format.
-    // 
-    return true;
+        if(tag > readTag)
+        {
+            i -= tag < 30 ? 1 : (tag < 255 ? 2 : 6); // Rewind
+            return false; // No optional data members with the requested tag.
+        }
+        else if(tag < readTag)
+        {
+            skipOpt(format); // Skip optional data members
+        }
+        else
+        {
+            if(format != expectedFormat)
+            {
+                ostringstream os;
+                os << "invalid optional data member `" << tag << "': unexpected format";
+                throw MarshalException(__FILE__, __LINE__, os.str());
+            }
+            return true;
+        }
+    }
+    return true; // Keep the compiler happy.
 }
 
 bool
@@ -1716,95 +1692,97 @@ IceInternal::BasicStream::writeOptImpl(Int tag, OptionalFormat type)
     }
 
     Byte v = static_cast<Byte>(type);
-    if(tag < 31)
+    if(tag < 30)
     {
-        v |= tag << 3;
+        v |= static_cast<Byte>(tag << 3);
         write(v);
     }
     else
     {
-        v |= 0x0F8; // tag = 31
+        v |= 0xF0; // tag = 30
         write(v);
         writeSize(tag);
     }
     return true;
 }
 
-bool
+void
 IceInternal::BasicStream::skipOpt(OptionalFormat type)
 {
-    int sz;
     switch(type)
     {
     case Ice::OptionalFormatF1:
     {
-        sz = 1;
+        skip(1);
         break;
     }
     case Ice::OptionalFormatF2:
     {
-        sz = 2;
+        skip(2);
         break;
     }
     case Ice::OptionalFormatF4:
     {
-        sz = 4;
+        skip(4);
         break;
     }
     case Ice::OptionalFormatF8:
     {
-        sz = 8;
+        skip(8);
         break;
     }
     case Ice::OptionalFormatSize:
     {
         skipSize();
-        return true;
+        break;
     }
     case Ice::OptionalFormatVSize:
     {
-        sz = readSize();
+        skip(readSize());
         break;
     }
     case Ice::OptionalFormatFSize:
     {
+        Int sz;
         read(sz);
+        skip(sz);
         break;
     }
-    default:
+    case Ice::OptionalFormatClass:
     {
-        return false;
+        read(0, 0);
+        break;
     }
     }
-    skip(sz);
-    return true;
 }
 
-bool
+void
 BasicStream::skipOpts()
 {
     //
     // Skip remaining un-read optional members.
     // 
-    OptionalFormat format;
-    do
+    while(true)
     {
         if(i >= b.begin() + _currentReadEncaps->start + _currentReadEncaps->sz)
         {
-            return false; // End of encapsulation also indicates end of optionals.
+            return; // End of encapsulation also indicates end of optionals.
         }
 
         Byte v;
         read(v);
-        format = static_cast<OptionalFormat>(v & 0x07); // Read first 3 bits.
-        if(static_cast<Int>(v >> 3) == 31)
+        if(v == OPTIONAL_END_MARKER)
+        {
+            return;
+        }
+
+        OptionalFormat format = static_cast<OptionalFormat>(v & 0x07); // Read first 3 bits.
+        if(static_cast<Int>(v >> 3) == 30)
         {
             skipSize();
         }
+        skipOpt(format);
     }
-    while(skipOpt(format));
-    assert(format == OptionalFormatEndMarker);
-    return true;
 }
 
 void
@@ -1830,7 +1808,15 @@ IceInternal::BasicStream::initReadEncaps()
 
     if(!_currentReadEncaps->decoder) // Lazy initialization.
     {
-        _currentReadEncaps->decoder = new EncapsDecoder(this, _currentReadEncaps, _sliceObjects);
+        ObjectFactoryManagerPtr factoryManager = _instance->servantFactoryManager();
+        if(_currentReadEncaps->encoding == Encoding_1_0)
+        {
+            _currentReadEncaps->decoder = new EncapsDecoder10(this, _currentReadEncaps, _sliceObjects, factoryManager);
+        }
+        else
+        {
+            _currentReadEncaps->decoder = new EncapsDecoder11(this, _currentReadEncaps, _sliceObjects, factoryManager);
+        }
     }
 }
 
@@ -1850,529 +1836,563 @@ IceInternal::BasicStream::initWriteEncaps()
 
     if(!_currentWriteEncaps->encoder) // Lazy initialization.
     {
-        _currentWriteEncaps->encoder = new EncapsEncoder(this, _currentWriteEncaps);
+        if(_currentWriteEncaps->encoding == Encoding_1_0)
+        {
+            _currentWriteEncaps->encoder = new EncapsEncoder10(this, _currentWriteEncaps);
+        }
+        else
+        {
+            _currentWriteEncaps->encoder = new EncapsEncoder11(this, _currentWriteEncaps);
+        }
     }
 }
 
-void
-IceInternal::BasicStream::EncapsEncoder::write(const ObjectPtr& v)
+string
+IceInternal::BasicStream::EncapsDecoder::readTypeId(bool isIndex)
 {
-    if(v)
+    if(isIndex)
     {
-        //
-        // Register the object.
-        //
-        Int index = registerObject(v);
-
-        if(_encaps->encoding == Encoding_1_0)
-        {
-            //
-            // Object references are encoded as a negative integer in 1.0.
-            //
-            _stream->write(-index);
-        }
-        else if(_sliceType != NoSlice && _encaps->format == SlicedFormat)
-        {
-            //
-            // An object reference that appears inside a slice of an
-            // object or exception encoded as a positive non-zero
-            // index into a per-slice indirection table.
-            //
-            // We use _indirectionMap to keep track of the object
-            // references in the current slice; it maps the object
-            // reference to the position in the indirection list. Note
-            // that the position is offset by one (e.g., the first
-            // position = 1).
-            //
-            IndirectionMap::iterator p = _indirectionMap.find(index);
-            if(p == _indirectionMap.end())
-            {
-                _indirectionTable.push_back(index);
-                const Int sz = static_cast<Int>(_indirectionTable.size()); // Position + 1
-                _indirectionMap.insert(make_pair(index, sz));
-                _stream->writeSize(sz);
-            }
-            else
-            {
-                _stream->writeSize(p->second);
-            }
-        }
-        else
+        Int index = _stream->readSize();
+        TypeIdReadMap::const_iterator k = _typeIdMap.find(index);
+        if(k == _typeIdMap.end())
         {
-            _stream->writeSize(index);
+            throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
         }
+        return k->second;
     }
     else
     {
-        //
-        // Write nil reference.
-        //
-        if(_encaps->encoding == Encoding_1_0)
-        {
-            _stream->write(0);
-        }
-        else
-        {
-            _stream->writeSize(0);
-        }
+        string typeId;
+        _stream->read(typeId, false);
+        _typeIdMap.insert(make_pair(++_typeIdIndex, typeId));
+        return typeId;
     }
 }
 
-void
-IceInternal::BasicStream::EncapsEncoder::write(const UserException& v)
+Ice::ObjectPtr
+IceInternal::BasicStream::EncapsDecoder::newInstance(const string& typeId)
 {
+    Ice::ObjectPtr v;
+
     //
-    // User exception with the 1.0 encoding start with a boolean
-    // flag that indicates whether or not the exception uses
-    // classes. 
-    //
-    // This allows reading the pending objects even if some part of
-    // the exception was sliced. With encoding > 1.0, we don't need
-    // this, each slice indirect patch table indicates the presence of
-    // objects.
+    // Try to find a factory registered for the specific type.
     //
-    bool usesClasses;
-    if(_encaps->encoding == Encoding_1_0)
+    ObjectFactoryPtr userFactory = _servantFactoryManager->find(typeId);
+    if(userFactory)
     {
-        usesClasses = v.__usesClasses();
-        _stream->write(usesClasses);
+        v = userFactory->create(typeId);
     }
-    else
+
+    //
+    // If that fails, invoke the default factory if one has been
+    // registered.
+    //
+    if(!v)
     {
-        usesClasses = true; // Always call writePendingObjects
+        userFactory = _servantFactoryManager->find("");
+        if(userFactory)
+        {
+            v = userFactory->create(typeId);
+        }
     }
-    v.__write(_stream);
-    if(usesClasses)
+
+    //
+    // Last chance: check the table of static factories (i.e.,
+    // automatically generated factories for concrete classes).
+    //
+    if(!v)
     {
-        writePendingObjects();
+        ObjectFactoryPtr of = IceInternal::factoryTable->getObjectFactory(typeId);
+        if(of)
+        {
+            v = of->create(typeId);
+            assert(v);
+        }
     }
+
+    return v;
 }
 
 void
-IceInternal::BasicStream::EncapsEncoder::startObject(const SlicedDataPtr& data)
+IceInternal::BasicStream::EncapsDecoder::addPatchEntry(Int index, PatchFunc patchFunc, void* patchAddr)
 {
-    _sliceType = ObjectSlice;
-    _firstSlice = true;
-    if(data)
+    assert(index > 0);
+
+    //
+    // Check if already un-marshalled the object. If that's the case,
+    // just patch the object smart pointer and we're done.
+    //
+    IndexToPtrMap::iterator p = _unmarshaledMap.find(index);
+    if(p != _unmarshaledMap.end())
     {
-        writeSlicedData(data);
+        (*patchFunc)(patchAddr, p->second);
+        return;
     }
-}
 
-void
-IceInternal::BasicStream::EncapsEncoder::endObject()
-{
-    if(_encaps->encoding == Encoding_1_0)
+    //
+    // Add patch entry if the object isn't un-marshalled yet, the
+    // smart pointer will be patched when the instance is
+    // un-marshalled.
+    //
+
+    PatchMap::iterator q = _patchMap.find(index);
+    if(q == _patchMap.end())
     {
         //
-        // Write the Object slice.
+        // We have no outstanding instances to be patched for this
+        // index, so make a new entry in the patch map.
         //
-        startSlice(Object::ice_staticId(), -1, true);
-        _stream->writeSize(0); // For compatibility with the old AFM.
-        endSlice();
-    }
-    _sliceType = NoSlice;
-}
-
-void
-IceInternal::BasicStream::EncapsEncoder::startException(const SlicedDataPtr& data)
-{
-    _sliceType = ExceptionSlice;
-    _firstSlice = true;
-    if(data)
-    {
-        writeSlicedData(data);
+        q = _patchMap.insert(make_pair(index, PatchList())).first;
     }
-}
 
-void 
-IceInternal::BasicStream::EncapsEncoder::endException()
-{
-    _sliceType = NoSlice;
+    //
+    // Append a patch entry for this instance.
+    //
+    PatchEntry e;
+    e.patchFunc = patchFunc;
+    e.patchAddr = patchAddr;
+    q->second.push_back(e);
 }
 
 void
-IceInternal::BasicStream::EncapsEncoder::startSlice(const string& typeId, int compactId, bool last)
+IceInternal::BasicStream::EncapsDecoder::unmarshal(Int index, const Ice::ObjectPtr& v)
 {
-    assert(_indirectionTable.empty() && _indirectionMap.empty());
-    _sliceFlags = 0;
-    _sliceFlagsPos = _stream->b.size();
+    //
+    // Add the object to the map of un-marshalled objects, this must
+    // be done before reading the objects (for circular references).
+    // 
+    _unmarshaledMap.insert(make_pair(index, v));
 
     //
-    // Encode the slice size for the old encoding and if using the
-    // sliced format.
+    // Read the object.
     //
-    if(_encaps->encoding == Encoding_1_0 || _encaps->format == SlicedFormat)
-    {
-        _sliceFlags |= FLAG_HAS_SLICE_SIZE;
-    }
+    v->__read(_stream);
 
     //
-    // This is the last slice.
+    // Patch all instances now that the object is un-marshalled.
     //
-    if(last)
+    PatchMap::iterator patchPos = _patchMap.find(index);
+    if(patchPos != _patchMap.end())
     {
-        _sliceFlags |= FLAG_IS_LAST_SLICE;
+        assert(patchPos->second.size() > 0);
+        
+        //
+        // Patch all pointers that refer to the instance.
+        //
+        for(PatchList::iterator k = patchPos->second.begin(); k != patchPos->second.end(); ++k)
+        {
+            (*k->patchFunc)(k->patchAddr, v);
+        }
+        
+        //
+        // Clear out the patch map for that index -- there is nothing left
+        // to patch for that index for the time being.
+        //
+        _patchMap.erase(patchPos);
     }
 
-    //
-    // For object slices, encode the flag and the type ID either as a
-    // string or index. For exception slices, don't encode slice flags
-    // for the old encoding and always encode the type ID a string.
-    //
-    if(_sliceType == ObjectSlice)
+    if(_objectList.empty() && _patchMap.empty())
     {
-        _stream->write(Byte(0)); // Placeholder for the slice flags
+        try
+        {
+            v->ice_postUnmarshal();
+        }
+        catch(const std::exception& ex)
+        {
+            Warning out(_stream->instance()->initializationData().logger);
+            out << "std::exception raised by ice_postUnmarshal:\n" << ex;
+        }
+        catch(...)
+        {
+            Warning out(_stream->instance()->initializationData().logger);
+            out << "unknown exception raised by ice_postUnmarshal";
+        }
+    }
+    else
+    {
+        _objectList.push_back(v);
 
-        //
-        // Encode the type ID (only in the first slice for the compact
-        // encoding).
-        // 
-        if(_encaps->format == SlicedFormat || _encaps->encoding == Encoding_1_0 || _firstSlice)
+        if(_patchMap.empty())
         {
-            if(_encaps->encoding != Encoding_1_0 && compactId >= 0)
-            {
-                _sliceFlags |= FLAG_HAS_TYPE_ID_COMPACT;
-                _stream->writeSize(compactId);
-            }
-            else
+            //
+            // Iterate over the object list and invoke ice_postUnmarshal on
+            // each object.  We must do this after all objects have been
+            // unmarshaled in order to ensure that any object data members
+            // have been properly patched.
+            //
+            for(ObjectList::iterator p = _objectList.begin(); p != _objectList.end(); ++p)
             {
-                //
-                // If the type ID has already been seen, write the index
-                // of the type ID, otherwise allocate a new type ID and
-                // write the string.
-                //
-                TypeIdWriteMap::const_iterator p = _typeIdMap.find(typeId);
-                if(p != _typeIdMap.end())
+                try
                 {
-                    _sliceFlags |= FLAG_HAS_TYPE_ID_INDEX;
-                    _stream->writeSize(p->second);
+                    (*p)->ice_postUnmarshal();
                 }
-                else
+                catch(const std::exception& ex)
                 {
-                    _sliceFlags |= FLAG_HAS_TYPE_ID_STRING;
-                    _typeIdMap.insert(make_pair(typeId, ++_typeIdIndex));
-                    _stream->write(typeId, false);
+                    Warning out(_stream->instance()->initializationData().logger);
+                    out << "std::exception raised by ice_postUnmarshal:\n" << ex;
+                }
+                catch(...)
+                {
+                    Warning out(_stream->instance()->initializationData().logger);
+                    out << "unknown exception raised by ice_postUnmarshal";
                 }
             }
+            _objectList.clear();
         }
     }
-    else
-    {
-        if(_encaps->encoding != Encoding_1_0)
-        {
-            _stream->write(Byte(0)); // Placeholder for the slice flags
-        }
-        _stream->write(typeId, false);
-    }
-
-    if(_sliceFlags & FLAG_HAS_SLICE_SIZE)
-    {
-        _stream->write(Int(0)); // Placeholder for the slice length.
-    }
-
-    _writeSlice = _stream->b.size();
-    _firstSlice = false;
 }
 
 void
-IceInternal::BasicStream::EncapsEncoder::endSlice()
+IceInternal::BasicStream::EncapsDecoder10::read(PatchFunc patchFunc, void* patchAddr)
 {
-    //
-    // Write the optional member end marker if some optional members
-    // were encoded. Note that the optional members are encoded before
-    // the indirection table and are included in the slice size.
-    //
-    if(_sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS)
-    {
-        assert(_encaps->encoding != Encoding_1_0);
-        _stream->write(static_cast<Byte>(OptionalFormatEndMarker));
-    }
+    assert(patchFunc && patchAddr);
 
     //
-    // Write the slice length if necessary.
+    // Object references are encoded as a negative integer in 1.0.
     //
-    if(_sliceFlags & FLAG_HAS_SLICE_SIZE)
+    Int index;
+    _stream->read(index);
+    if(index > 0)
     {
-        Int sz = static_cast<Int>(_stream->b.size() - _writeSlice + sizeof(Int));
-        Byte* dest = &(*(_stream->b.begin() + _writeSlice - sizeof(Int)));
-        _stream->write(sz, dest);
+        throw MarshalException(__FILE__, __LINE__, "invalid object id");
     }
+    index = -index;
 
-    //
-    // Only write the indirection table if it contains entries.
-    //
-    if(!_indirectionTable.empty())
+    if(index == 0)
     {
-        assert(_encaps->encoding != Encoding_1_0);
-        assert(_encaps->format == SlicedFormat);
-        _sliceFlags |= FLAG_HAS_INDIRECTION_TABLE;
-
         //
-        // Write the indirection table as a sequence<size> to conserve space.
+        // Calling the patch function for null instances is necessary for correct functioning of Ice for
+        // Python and Ruby.
         //
-        _stream->writeSizeSeq(_indirectionTable);
-
-        _indirectionTable.clear();
-        _indirectionMap.clear();
-    }
-
-    //
-    // Finally, update the slice flags (or the object slice has index
-    // type ID boolean for the 1.0 encoding)
-    //
-    if(_encaps->encoding == Encoding_1_0)
-    {
-        if(_sliceType == ObjectSlice) // No flags for 1.0 exception slices.
-        {
-            Byte* dest = &(*(_stream->b.begin() + _sliceFlagsPos));
-            *dest = static_cast<Byte>(_sliceFlags & FLAG_HAS_TYPE_ID_INDEX ? true : false);
-        }
+        ObjectPtr nil;
+        patchFunc(patchAddr, nil);
     }
     else
     {
-        Byte* dest = &(*(_stream->b.begin() + _sliceFlagsPos));
-        *dest = _sliceFlags;
+        addPatchEntry(index, patchFunc, patchAddr);
     }
 }
 
 void
-IceInternal::BasicStream::EncapsEncoder::writePendingObjects()
+IceInternal::BasicStream::EncapsDecoder10::throwException(const UserExceptionFactoryPtr& factory)
 {
+    assert(_sliceType == NoSlice);
+
+    //
+    // User exception with the 1.0 encoding start with a boolean flag
+    // that indicates whether or not the exception has classes.
+    //
+    // This allows reading the pending objects even if some part of
+    // the exception was sliced.
     //
-    // With the 1.0 encoding, write pending objects if the marshalled
-    // data uses classes. Otherwise with encoding > 1.0, only write
-    // pending objects if some non-nil references were written.
+    bool usesClasses;
+    _stream->read(usesClasses);
+
+    _sliceType = ExceptionSlice;
+    _skipFirstSlice = false;
+
     //
-    if(_encaps->encoding != Encoding_1_0)
+    // Read the first slice header.
+    //
+    startSlice();
+    const string mostDerivedId = _typeId;
+    UserExceptionFactoryPtr exceptionFactory = factory;
+    while(true)
     {
-        if(_toBeMarshaledMap.empty())
-        {
-            return;
-        }
-        else 
+        //
+        // Look for a statically-generated factory for this ID.
+        //
+        if(!exceptionFactory)
         {
-            //
-            // Write end marker for encapsulation optionals before encoding 
-            // the pending objects.
-            //
-            _stream->write(static_cast<Byte>(OptionalFormatEndMarker));
+            exceptionFactory = factoryTable->getExceptionFactory(_typeId);
         }
-    }
 
-    while(!_toBeMarshaledMap.empty())
-    {
         //
-        // Consider the to be marshalled objects as marshalled now,
-        // this is necessary to avoid adding again the "to be
-        // marshalled objects" into _toBeMarshaledMap while writing
-        // objects.
+        // We found a factory, we get out of this loop.
         //
-        _marshaledMap.insert(_toBeMarshaledMap.begin(), _toBeMarshaledMap.end());
-
-        PtrToIndexMap savedMap;
-        savedMap.swap(_toBeMarshaledMap);
-        _stream->writeSize(static_cast<Int>(savedMap.size()));
-        for(PtrToIndexMap::iterator p = savedMap.begin(); p != savedMap.end(); ++p)
+        if(exceptionFactory)
         {
             //
-            // Ask the instance to marshal itself. Any new class
-            // instances that are triggered by the classes marshaled
-            // are added to toBeMarshaledMap.
+            // Got factory -- ask the factory to instantiate the
+            // exception, initialize the exception members, and throw
+            // the exception.
             //
-            if(_encaps->encoding == Encoding_1_0)
-            {
-                _stream->write(p->second);
-            }
-            else
-            {
-                _stream->writeSize(p->second);
-            }
-
             try
             {
-                p->first->ice_preMarshal();
-            }
-            catch(const std::exception& ex)
-            {
-                Warning out(_stream->instance()->initializationData().logger);
-                out << "std::exception raised by ice_preMarshal:\n" << ex;
+                exceptionFactory->createAndThrow(_typeId);
             }
-            catch(...)
+            catch(UserException& ex)
             {
-                Warning out(_stream->instance()->initializationData().logger);
-                out << "unknown exception raised by ice_preMarshal";
+                ex.__read(_stream);
+                if(usesClasses)
+                {
+                    readPendingObjects();
+                }
+                throw;
+        
+                // Never reached.
             }
+        }
 
-            p->first->__write(_stream);
+        //
+        // Slice off what we don't understand.
+        //
+        skipSlice(); 
+        try
+        {
+            startSlice();
+        }
+        catch(UnmarshalOutOfBoundsException& ex)
+        {
+            //
+            // An oversight in the 1.0 encoding means there is no marker to indicate
+            // the last slice of an exception. As a result, we just try to read the
+            // next type ID, which raises UnmarshalOutOfBoundsException when the
+            // input buffer underflows.
+            //
+            // Set the reason member to a more helpful message.
+            //
+            ex.reason = "unknown exception type `" + mostDerivedId + "'";
+            throw;
         }
     }
-    _stream->writeSize(0); // Zero marker indicates end of sequence of sequences of instances.
 }
 
-void
-IceInternal::BasicStream::EncapsEncoder::writeSlicedData(const SlicedDataPtr& slicedData)
+void 
+IceInternal::BasicStream::EncapsDecoder10::startInstance(SliceType sliceType)
 {
-    assert(slicedData);
+    assert(_sliceType == sliceType);
+    _skipFirstSlice = true;
+}
 
+SlicedDataPtr
+IceInternal::BasicStream::EncapsDecoder10::endInstance(bool)
+{
     //
-    // We only remarshal preserved slices if the target encoding is > 1.0 and we are
-    // using the sliced format. Otherwise, we ignore the preserved slices, which
-    // essentially "slices" the object into the most-derived type known by the sender.
+    // Read the Ice::Object slice.
     //
-    if(_encaps->encoding == Encoding_1_0 || _encaps->format != SlicedFormat)
-    {
-        return;
-    }
-
-    for(SliceInfoSeq::const_iterator p = slicedData->slices.begin(); p != slicedData->slices.end(); ++p)
+    if(_sliceType == ObjectSlice)
     {
-        startSlice((*p)->typeId, (*p)->compactId, (*p)->isLastSlice);
- 
-        //
-        // Write the bytes associated with this slice.
-        //
-        _stream->writeBlob((*p)->bytes);
-        
-        if((*p)->hasOptionalMembers)
-        {
-            _sliceFlags |= FLAG_HAS_OPTIONAL_MEMBERS;
-        }
-
-        //
-        // Assemble and write the indirection table. The table must have the same order
-        // as the list of objects.
-        //
-        for(vector<ObjectPtr>::const_iterator q = (*p)->objects.begin(); q != (*p)->objects.end(); ++q)
+        startSlice();
+        Int sz = _stream->readSize(); // For compatibility with the old AFM.
+        if(sz != 0)
         {
-            _indirectionTable.push_back(registerObject(*q));
+            throw MarshalException(__FILE__, __LINE__, "invalid Object slice");
         }
-
         endSlice();
     }
+    _sliceType = NoSlice;
+    return 0;
 }
 
-Int 
-IceInternal::BasicStream::EncapsEncoder::registerObject(const ObjectPtr& v)
+const std::string&
+IceInternal::BasicStream::EncapsDecoder10::startSlice()
 {
-    assert(v);
-
     //
-    // Look for this instance in the to-be-marshaled map.
+    // If first slice, don't read the header, it was already read in
+    // readInstance or throwException to find the factory.
     //
-    PtrToIndexMap::const_iterator p = _toBeMarshaledMap.find(v);
-    if(p != _toBeMarshaledMap.end())
+    if(_skipFirstSlice)
     {
-        return p->second;
+        _skipFirstSlice = false;
+        return _typeId;
     }
 
     //
-    // Didn't find it, try the marshaled map next.
+    // For objects, first read the type ID boolean which indicates
+    // whether or not the type ID is encoded as a string or as an
+    // index. For exceptions, the type ID is always encoded as a 
+    // string.
     //
-    PtrToIndexMap::const_iterator q = _marshaledMap.find(v);
-    if(q != _marshaledMap.end())
+    if(_sliceType == ObjectSlice)
     {
-        return q->second;
+        bool isIndex;
+        _stream->read(isIndex);
+        _typeId = readTypeId(isIndex);
+    } 
+    else
+    {
+        _stream->read(_typeId, false);
     }
 
-    //
-    // We haven't seen this instance previously, create a new
-    // index, and insert it into the to-be-marshaled map.
-    //
-    _toBeMarshaledMap.insert(make_pair(v, ++_objectIdIndex));
-    return _objectIdIndex;
+    _stream->read(_sliceSize);
+    if(_sliceSize < 4)
+    {
+        throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
+    }
+    return _typeId;
 }
 
 void
-IceInternal::BasicStream::EncapsDecoder::read(PatchFunc patchFunc, void* patchAddr)
+IceInternal::BasicStream::EncapsDecoder10::endSlice()
 {
-    ObjectPtr v;
+}            
+
+void
+IceInternal::BasicStream::EncapsDecoder10::skipSlice()
+{
+    if(_stream->instance()->traceLevels()->slicing > 0)
+    {
+        const Ice::LoggerPtr& logger = _stream->instance()->initializationData().logger;
+        if(_sliceType == ExceptionSlice)
+        {
+            traceSlicing("exception", _typeId, _stream->instance()->traceLevels()->slicingCat, logger);
+        }
+        else
+        {
+            traceSlicing("object", _typeId, _stream->instance()->traceLevels()->slicingCat, logger);
+        }
+    }
+    assert(_sliceSize >= 4);
+    _stream->skip(_sliceSize - sizeof(Int));
+}
+
+void
+IceInternal::BasicStream::EncapsDecoder10::readPendingObjects()
+{
+    Int num;
+    do
+    {
+        num = _stream->readSize();
+        for(Int k = num; k > 0; --k)
+        {
+            readInstance();
+        }
+    }
+    while(num);
+
+    if(!_patchMap.empty())
+    {
+        //
+        // If any entries remain in the patch map, the sender has sent an index for an object, but failed
+        // to supply the object.
+        //
+        throw MarshalException(__FILE__, __LINE__, "index for class received, but no instance");
+    }
+}
 
+void
+IceInternal::BasicStream::EncapsDecoder10::readInstance()
+{
     Int index;
-    if(_encaps->encoding == Encoding_1_0)
+    _stream->read(index);
+
+    if(index <= 0)
+    {
+        throw MarshalException(__FILE__, __LINE__, "invalid object id");
+    }
+
+    _sliceType = ObjectSlice;
+    _skipFirstSlice = false;
+
+    //
+    // Read the first slice header.
+    //
+    startSlice();
+    const string mostDerivedId = _typeId;
+    ObjectPtr v;
+    while(true)
     {
         //
-        // Object references are encoded as a negative integer in 1.0.
+        // For the 1.0 encoding, the type ID for the base Object class
+        // marks the last slice.
         //
-        _stream->read(index);
-        if(index > 0)
+        if(_typeId == Object::ice_staticId())
         {
-            throw MarshalException(__FILE__, __LINE__, "invalid object id");
+            throw NoObjectFactoryException(__FILE__, __LINE__, "", mostDerivedId);
         }
-        index = -index;
-    }
-    else
-    {
+        
+        v = newInstance(_typeId);
+
         //
-        // Later versions use a size.
+        // We found a factory, we get out of this loop.
         //
-        index = _stream->readSize();
-        if(index < 0)
+        if(v)
+        {
+            break;
+        }
+
+        //
+        // If object slicing is disabled, stop un-marshalling.
+        //
+        if(!_sliceObjects)
         {
-            throw MarshalException(__FILE__, __LINE__, "invalid object id");
+            throw NoObjectFactoryException(__FILE__, __LINE__, "object slicing is disabled", _typeId);
         }
+
+        //
+        // Slice off what we don't understand.
+        //
+        skipSlice();
+        startSlice(); // Read next Slice header for next iteration.
     }
 
-    if(index == 0)
+    //
+    // Un-marshal the object and add-it to the map of un-marshaled objects.
+    //
+    unmarshal(index, v);
+}
+
+void
+IceInternal::BasicStream::EncapsDecoder11::read(PatchFunc patchFunc, void* patchAddr)
+{
+    Int index = _stream->readSize();
+    if(index < 0)
+    {
+        throw MarshalException(__FILE__, __LINE__, "invalid object id");
+    }
+    else if(index == 0)
     {
         //
         // Calling the patch function for null instances is necessary for correct functioning of Ice for
         // Python and Ruby.
         //
-        ObjectPtr nil;
-        patchFunc(patchAddr, nil);
+        if(patchFunc)
+        {
+            ObjectPtr nil;
+            patchFunc(patchAddr, nil);
+        }
     }
-    else if(_sliceType != NoSlice && _sliceFlags & FLAG_HAS_INDIRECTION_TABLE)
+    else if(_current && _current->sliceFlags & FLAG_HAS_INDIRECTION_TABLE)
     {
         //
-        // Maintain a list of indirect references. Note that the indirect index
-        // starts at 1, so we decrement it by one to derive an index into
-        // the indirection table that we'll read at the end of the slice.
+        // When reading an object within a slice and there's an
+        // indirect object table, always read an indirect reference
+        // that points to an object from the indirect object table
+        // marshaled at the end of the Slice.
+        //
+        // Maintain a list of indirect references. Note that the
+        // indirect index starts at 1, so we decrement it by one to
+        // derive an index into the indirection table that we'll read
+        // at the end of the slice.
         //
-        IndirectPatchEntry e;
-        e.index = index - 1;
-        e.patchFunc = patchFunc;
-        e.patchAddr = patchAddr;
-        _indirectPatchList.push_back(e);
+        if(patchFunc)
+        {
+            IndirectPatchEntry e;
+            e.index = index - 1;
+            e.patchFunc = patchFunc;
+            e.patchAddr = patchAddr;
+            _current->indirectPatchList.push_back(e);
+        }
     }
     else
     {
-        addPatchEntry(index, patchFunc, patchAddr);
+        readInstance(index, patchFunc, patchAddr);
     }
 }
 
 void
-IceInternal::BasicStream::EncapsDecoder::throwException(const UserExceptionFactoryPtr& factory)
+IceInternal::BasicStream::EncapsDecoder11::throwException(const UserExceptionFactoryPtr& factory)
 {
-    assert(_sliceType == NoSlice);
-
-    //
-    // User exception with the 1.0 encoding start with a boolean flag
-    // that indicates whether or not the exception has classes.
-    //
-    // This allows reading the pending objects even if some part of
-    // the exception was sliced. With encoding > 1.0, we don't need
-    // this, each slice indirect patch table indicates the presence of
-    // objects.
-    //
-    bool usesClasses;
-    if(_encaps->encoding == Encoding_1_0)
-    {
-        _stream->read(usesClasses);
-    }
-    else
-    {
-        usesClasses = true; // Always call readPendingObjects.
-    }
+    assert(!_current);
 
-    _sliceType = ExceptionSlice;
-    _skipFirstSlice = false;
+    push(ExceptionSlice);
 
     //
     // Read the first slice header.
     //
     startSlice();
-    const string mostDerivedId = _typeId;
+    const string mostDerivedId = _current->typeId;
     UserExceptionFactoryPtr exceptionFactory = factory;
     while(true)
     {
@@ -2381,7 +2401,7 @@ IceInternal::BasicStream::EncapsDecoder::throwException(const UserExceptionFacto
         //
         if(!exceptionFactory)
         {
-            exceptionFactory = factoryTable->getExceptionFactory(_typeId);
+            exceptionFactory = factoryTable->getExceptionFactory(_current->typeId);
         }
 
         //
@@ -2396,15 +2416,11 @@ IceInternal::BasicStream::EncapsDecoder::throwException(const UserExceptionFacto
             //
             try
             {
-                exceptionFactory->createAndThrow(_typeId);
+                exceptionFactory->createAndThrow(_current->typeId);
             }
             catch(UserException& ex)
             {
                 ex.__read(_stream);
-                if(usesClasses)
-                {
-                    readPendingObjects();
-                }
                 throw;
         
                 // Never reached.
@@ -2412,20 +2428,6 @@ IceInternal::BasicStream::EncapsDecoder::throwException(const UserExceptionFacto
         }
 
         //
-        // Performance sensitive, so we use lazy initialization for
-        // tracing.
-        //
-        if(_traceSlicing == -1)
-        {
-            _traceSlicing = _stream->instance()->traceLevels()->slicing;
-            _slicingCat = _stream->instance()->traceLevels()->slicingCat;
-        }
-        if(_traceSlicing > 0)
-        {
-            traceSlicing("exception", _typeId, _slicingCat, _stream->instance()->initializationData().logger);
-        }
-
-        //
         // Slice off what we don't understand.
         //
         skipSlice(); 
@@ -2433,7 +2435,7 @@ IceInternal::BasicStream::EncapsDecoder::throwException(const UserExceptionFacto
         //
         // If this is the last slice, raise an exception and stop un-marshalling.
         //
-        if(_sliceFlags & FLAG_IS_LAST_SLICE)
+        if(_current->sliceFlags & FLAG_IS_LAST_SLICE)
         {
             if(mostDerivedId.length() > 2 && mostDerivedId[0] == ':' && mostDerivedId[1] == ':')
             {
@@ -2445,217 +2447,123 @@ IceInternal::BasicStream::EncapsDecoder::throwException(const UserExceptionFacto
             }
         }
 
-        try
-        {
-            startSlice();
-        }
-        catch(UnmarshalOutOfBoundsException& ex)
-        {
-            //
-            // An oversight in the 1.0 encoding means there is no marker to indicate
-            // the last slice of an exception. As a result, we just try to read the
-            // next type ID, which raises UnmarshalOutOfBoundsException when the
-            // input buffer underflows.
-            //
-            if(_encaps->encoding == Encoding_1_0)
-            {
-                // Set the reason member to a more helpful message.
-                ex.reason = "unknown exception type `" + mostDerivedId + "'";
-            }
-            throw;
-        }
-    }
-}
-
-void 
-IceInternal::BasicStream::EncapsDecoder::startObject()
-{
-    assert(_sliceType == ObjectSlice);
-    _skipFirstSlice = true;
-}
-
-SlicedDataPtr
-IceInternal::BasicStream::EncapsDecoder::endObject(bool preserve)
-{
-    if(_encaps->encoding == Encoding_1_0)
-    {
-        //
-        // Read the Ice::Object slice.
-        //
         startSlice();
-
-        //
-        // For compatibility with the old AFM.
-        //
-        Int sz = _stream->readSize();
-        if(sz != 0)
-        {
-            throw MarshalException(__FILE__, __LINE__, "invalid Object slice");
-        }
-
-        endSlice();
     }
-
-    _sliceType = NoSlice;
-    SlicedDataPtr slicedData;
-    if(preserve)
-    {
-        slicedData = readSlicedData();
-    }
-    _slices.clear();
-    _indirectionTables.clear();
-    return slicedData;
 }
 
 void 
-IceInternal::BasicStream::EncapsDecoder::startException()
+IceInternal::BasicStream::EncapsDecoder11::startInstance(SliceType sliceType)
 {
-    assert(_sliceType == ExceptionSlice);
-    _skipFirstSlice = true;
+    assert(_current->sliceType == sliceType);
+    _current->skipFirstSlice = true;
 }
 
-SlicedDataPtr 
-IceInternal::BasicStream::EncapsDecoder::endException(bool preserve)
+SlicedDataPtr
+IceInternal::BasicStream::EncapsDecoder11::endInstance(bool preserve)
 {
-    _sliceType = NoSlice;
     SlicedDataPtr slicedData;
     if(preserve)
     {
         slicedData = readSlicedData();
     }
-    _slices.clear();
-    _indirectionTables.clear();
+    _current->slices.clear();
+    _current->indirectionTables.clear();
+    _current = _current->previous;
     return slicedData;
 }
 
-const string&
-IceInternal::BasicStream::EncapsDecoder::startSlice()
+const std::string&
+IceInternal::BasicStream::EncapsDecoder11::startSlice()
 {
     //
     // If first slice, don't read the header, it was already read in
     // readInstance or throwException to find the factory.
     //
-    if(_skipFirstSlice)
+    if(_current->skipFirstSlice)
     {
-        _skipFirstSlice = false;
-        return _typeId;
+        _current->skipFirstSlice = false;
+        return _current->typeId;
     }
 
-    //
-    // Read the slice flags. For the 1.0 encoding there's no flag but
-    // just a boolean for object slices. The boolean indicates whether
-    // or not the type ID is encoded as a string or as an index.
-    //
-    if(_encaps->encoding == Encoding_1_0)
-    {
-        _sliceFlags = FLAG_HAS_SLICE_SIZE;
-        if(_sliceType == ObjectSlice) // For exceptions, the type ID is always encoded as a string
-        {
-            bool isIndex;
-            _stream->read(isIndex);
-            _sliceFlags |= isIndex ? FLAG_HAS_TYPE_ID_INDEX : FLAG_HAS_TYPE_ID_STRING;
-        }
-    }
-    else
-    {
-        _stream->read(_sliceFlags);
-    }
+    _stream->read(_current->sliceFlags);
 
     //
     // Read the type ID, for object slices the type ID is encoded as a
     // string or as an index, for exceptions it's always encoded as a
     // string.
     //
-    if(_sliceType == ObjectSlice)
+    if(_current->sliceType == ObjectSlice)
     {
-        if((_sliceFlags & FLAG_HAS_TYPE_ID_COMPACT) == FLAG_HAS_TYPE_ID_COMPACT) // Must be checked first!
+        if((_current->sliceFlags & FLAG_HAS_TYPE_ID_COMPACT) == FLAG_HAS_TYPE_ID_COMPACT) // Must be checked first!
         {
-            _typeId.clear();
-            _compactId = _stream->readSize();
+            _current->typeId.clear();
+            _current->compactId = _stream->readSize();
         }
-        else if(_sliceFlags & FLAG_HAS_TYPE_ID_INDEX)
+        else if(_current->sliceFlags & (FLAG_HAS_TYPE_ID_STRING | FLAG_HAS_TYPE_ID_INDEX))
         {
-            Int index = _stream->readSize();
-            TypeIdReadMap::const_iterator k = _typeIdMap.find(index);
-            if(k == _typeIdMap.end())
-            {
-                throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
-            }
-            _typeId = k->second;
-            _compactId = -1;
-        }
-        else if(_sliceFlags & FLAG_HAS_TYPE_ID_STRING)
-        {
-            _stream->read(_typeId, false);
-            _typeIdMap.insert(make_pair(++_typeIdIndex, _typeId));
-            _compactId = -1;
+            _current->typeId = readTypeId(_current->sliceFlags & FLAG_HAS_TYPE_ID_INDEX);
+            _current->compactId = -1;
         }
         else
         {
-            // Only the most derived slice encodes the type ID for the
-            // compact format.
-            _typeId.clear();
-            _compactId = -1;
+            // Only the most derived slice encodes the type ID for the compact format.
+            _current->typeId.clear();
+            _current->compactId = -1;
         }
     } 
     else
     {
-        _stream->read(_typeId, false);
+        _stream->read(_current->typeId, false);
     }
 
     //
     // Read the slice size if necessary.
     //
-    if(_sliceFlags & FLAG_HAS_SLICE_SIZE)
+    if(_current->sliceFlags & FLAG_HAS_SLICE_SIZE)
     {
-        _stream->read(_sliceSize);
-        if(_sliceSize < 4)
+        _stream->read(_current->sliceSize);
+        if(_current->sliceSize < 4)
         {
             throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
         }
     }
     else
     {
-        _sliceSize = 0;
+        _current->sliceSize = 0;
     }
 
-    //
-    // Reset the indirect patch list for this new slice.
-    //
-    _indirectPatchList.clear();
-    return _typeId;
+    return _current->typeId;
 }
 
 void
-IceInternal::BasicStream::EncapsDecoder::endSlice()
+IceInternal::BasicStream::EncapsDecoder11::endSlice()
 {
-    if(_sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS)
+    if(_current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS)
     {
         _stream->skipOpts();
     }
 
     //
-    // Read the indirection table if one is present and transform the
-    // indirect patch list into patch entries with direct references.
+    // Read the indirect object table if one is present.
     //
-    if(_sliceFlags & FLAG_HAS_INDIRECTION_TABLE)
+    if(_current->sliceFlags & FLAG_HAS_INDIRECTION_TABLE)
     {
-        //
-        // The table is written as a sequence<size> to conserve space.
-        //
-        IndexList indirectionTable;
-        _stream->readSizeSeq(indirectionTable);
+        IndexList indirectionTable(_stream->readAndCheckSeqSize(1));
+        for(IndexList::iterator p = indirectionTable.begin(); p != indirectionTable.end(); ++p)
+        {
+            *p = readInstance(_stream->readSize(), 0, 0);
+        }        
 
         //
         // Sanity checks. If there are optional members, it's possible
         // that not all object references were read if they are from
         // unknown optional data members.
         //
-        if(indirectionTable.empty() && !_indirectPatchList.empty())
+        if(indirectionTable.empty())
         {
             throw MarshalException(__FILE__, __LINE__, "empty indirection table");
         }
-        else if(!indirectionTable.empty() && _indirectPatchList.empty() && !(_sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS))
+        if(_current->indirectPatchList.empty() && !(_current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS))
         {
             throw MarshalException(__FILE__, __LINE__, "no references to indirection table");
         }
@@ -2663,147 +2571,166 @@ IceInternal::BasicStream::EncapsDecoder::endSlice()
         //
         // Convert indirect references into direct references.
         //
-        for(IndirectPatchList::iterator p = _indirectPatchList.begin(); p != _indirectPatchList.end(); ++p)
+        IndirectPatchList::iterator p;
+        for(p = _current->indirectPatchList.begin(); p != _current->indirectPatchList.end(); ++p)
         {
             assert(p->index >= 0);
             if(p->index >= static_cast<Int>(indirectionTable.size()))
             {
                 throw MarshalException(__FILE__, __LINE__, "indirection out of range");
             }
-            const Int id = indirectionTable[p->index];
-            if(id <= 0)
-            {
-                //
-                // Entries in the table must be positive, just like a regular object reference.
-                //
-                throw MarshalException(__FILE__, __LINE__, "invalid id in object indirection table");
-            }
-            addPatchEntry(id, p->patchFunc, p->patchAddr);
+            addPatchEntry(indirectionTable[p->index], p->patchFunc, p->patchAddr);
         }
+        _current->indirectPatchList.clear();
     }
 }            
 
 void
-IceInternal::BasicStream::EncapsDecoder::readPendingObjects()
+IceInternal::BasicStream::EncapsDecoder11::skipSlice()
 {
-    //
-    // With the 1.0 encoding, we read pending objects if the marshaled
-    // data uses classes. Otherwise, only read pending objects if some
-    // non-nil references were read.
-    //
-    if(_encaps->encoding != Encoding_1_0)
-    {        
-        if(_patchMap.empty())
+    if(_stream->instance()->traceLevels()->slicing > 0)
+    {
+        const Ice::LoggerPtr& logger = _stream->instance()->initializationData().logger;
+        if(_current->sliceType == ExceptionSlice)
         {
-            return;
+            traceSlicing("exception", _current->typeId, _stream->instance()->traceLevels()->slicingCat, logger);
         }
         else
         {
-            //
-            // Read unread encapsulation optionals before reading the
-            // pending objects.
-            //
-            _stream->skipOpts();
+            traceSlicing("object", _current->typeId, _stream->instance()->traceLevels()->slicingCat, logger);
         }
     }
 
-    Int num;
-    ObjectList objectList;
-    do
+    Container::iterator start = _stream->i;
+
+    if(_current->sliceFlags & FLAG_HAS_SLICE_SIZE)
     {
-        num = _stream->readSize();
-        for(Int k = num; k > 0; --k)
+        assert(_current->sliceSize >= 4);
+        _stream->skip(_current->sliceSize - sizeof(Int));
+    }
+    else
+    {
+        if(_current->sliceType == ObjectSlice)
         {
-            objectList.push_back(readInstance());
+            throw NoObjectFactoryException(
+                __FILE__, __LINE__, 
+                "compact format prevents slicing (the sender should use the sliced format instead)", 
+                _current->typeId);
+        }
+        else
+        {
+            if(_current->typeId.length() > 2 && _current->typeId[0] == ':' && _current->typeId[1] == ':')
+            {
+                throw UnknownUserException(__FILE__, __LINE__, _current->typeId.substr(2));
+            }
+            else
+            {
+                throw UnknownUserException(__FILE__, __LINE__, _current->typeId);
+            }
         }
     }
-    while(num);
 
-    if(!_patchMap.empty())
+    //
+    // Preserve this slice.
+    //
+    SliceInfoPtr info = new SliceInfo;
+    info->typeId = _current->typeId;
+    info->compactId = _current->compactId;
+    info->hasOptionalMembers = _current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS;
+    info->isLastSlice = _current->sliceFlags & FLAG_IS_LAST_SLICE;
+    if(info->hasOptionalMembers)
     {
         //
-        // If any entries remain in the patch map, the sender has sent an index for an object, but failed
-        // to supply the object.
+        // Don't include the optional member end marker. It will be re-written by
+        // endSlice when the sliced data is re-written.
         //
-        throw MarshalException(__FILE__, __LINE__, "index for class received, but no instance");
+        vector<Byte>(start, _stream->i - 1).swap(info->bytes);
+    }
+    else
+    {
+        vector<Byte>(start, _stream->i).swap(info->bytes);
     }
 
+    _current->indirectionTables.push_back(IndexList());
+
     //
-    // Iterate over the object list and invoke ice_postUnmarshal on
-    // each object.  We must do this after all objects have been
-    // unmarshaled in order to ensure that any object data members
-    // have been properly patched.
+    // Read the indirect object table. We read the instances or their
+    // IDs if the instance is a reference to an already un-marhsaled
+    // object.
     //
-    for(ObjectList::iterator p = objectList.begin(); p != objectList.end(); ++p)
+    // The SliceInfo object sequence is initialized only if
+    // readSlicedData is called.
+    //
+    if(_current->sliceFlags & FLAG_HAS_INDIRECTION_TABLE)
     {
-        try
+        IndexList& table = _current->indirectionTables.back();
+        table.resize(_stream->readAndCheckSeqSize(1));
+        for(IndexList::iterator p = table.begin(); p != table.end(); ++p)
         {
-            (*p)->ice_postUnmarshal();
-        }
-        catch(const std::exception& ex)
-        {
-            Warning out(_stream->instance()->initializationData().logger);
-            out << "std::exception raised by ice_postUnmarshal:\n" << ex;
-        }
-        catch(...)
-        {
-            Warning out(_stream->instance()->initializationData().logger);
-            out << "unknown exception raised by ice_postUnmarshal";
+            *p = readInstance(_stream->readSize(), 0, 0);
         }
     }
+
+    _current->slices.push_back(info);
 }
 
-ObjectPtr
-IceInternal::BasicStream::EncapsDecoder::readInstance()
+bool
+IceInternal::BasicStream::EncapsDecoder11::readOpt(Ice::Int readTag, Ice::OptionalFormat expectedFormat)
 {
-    Int index;
-    if(_encaps->encoding == Encoding_1_0)
+    if(!_current)
     {
-        _stream->read(index);
+        return _stream->readOptImpl(readTag, expectedFormat);
     }
-    else
+    else if(_current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS)
     {
-        index = _stream->readSize();
+        return _stream->readOptImpl(readTag, expectedFormat);
     }
+    return false;
+}
 
-    ObjectPtr v;
-    if(index <= 0)
+Int
+IceInternal::BasicStream::EncapsDecoder11::readInstance(Int index, PatchFunc patchFunc, void* patchAddr)
+{
+    assert(index > 0);
+    
+    if(index > 1)
     {
-        throw MarshalException(__FILE__, __LINE__, "invalid object id");
+        if(patchFunc)
+        {
+            addPatchEntry(index, patchFunc, patchAddr);
+        }
+        return index;
     }
 
-    _sliceType = ObjectSlice;
-    _skipFirstSlice = false;
+    push(ObjectSlice);
+
+    //
+    // Get the object ID before we start reading slices. If some
+    // slices are skiped, the indirect object table are still read and
+    // might read other objects.
+    //
+    index = ++_objectIdIndex;
 
     //
     // Read the first slice header.
     //
     startSlice();
-    const string mostDerivedId = _typeId;
-    const ObjectFactoryManagerPtr servantFactoryManager = _stream->instance()->servantFactoryManager();
-    const CompactIdResolverPtr compactIdResolver = _stream->instance()->initializationData().compactIdResolver;
+    const string mostDerivedId = _current->typeId;
+    Ice::ObjectPtr v;
+    const CompactIdResolverPtr& compactIdResolver = _stream->instance()->initializationData().compactIdResolver;
     while(true)
     {
-        //
-        // For the 1.0 encoding, the type ID for the base Object class
-        // marks the last slice.
-        //
-        if(_typeId == Object::ice_staticId())
-        {
-            throw NoObjectFactoryException(__FILE__, __LINE__, "", mostDerivedId);
-        }
-        
-        if(_compactId >= 0)
+        if(_current->compactId >= 0)
         {
             //
             // Translate a compact (numeric) type ID into a string type ID.
             //
-            _typeId.clear();
+            _current->typeId.clear();
             if(compactIdResolver)
             {
                 try
                 {
-                    _typeId = compactIdResolver->resolve(_compactId);
+                    _current->typeId = compactIdResolver->resolve(_current->compactId);
                 }
                 catch(const LocalException&)
                 {
@@ -2812,7 +2739,7 @@ IceInternal::BasicStream::EncapsDecoder::readInstance()
                 catch(const std::exception& ex)
                 {
                     ostringstream ostr;
-                    ostr << "exception in CompactIdResolver for ID " << _compactId;
+                    ostr << "exception in CompactIdResolver for ID " << _current->compactId;
                     string msg = ostr.str();
                     string what = ex.what();
                     if(!what.empty())
@@ -2824,19 +2751,19 @@ IceInternal::BasicStream::EncapsDecoder::readInstance()
                 catch(...)
                 {
                     ostringstream ostr;
-                    ostr << "unknown exception in CompactIdResolver for ID " << _compactId;
+                    ostr << "unknown exception in CompactIdResolver for ID " << _current->compactId;
                     throw MarshalException(__FILE__, __LINE__, ostr.str());
                 }
             }
-            if(_typeId.empty())
+            if(_current->typeId.empty())
             {
-                _typeId = IceInternal::factoryTable->getTypeId(_compactId);
+                _current->typeId = IceInternal::factoryTable->getTypeId(_current->compactId);
             }
         }
 
-        if(!_typeId.empty())
+        if(!_current->typeId.empty())
         {
-            v = newInstance(servantFactoryManager, _typeId);
+            v = newInstance(_current->typeId);
 
             //
             // We found a factory, we get out of this loop.
@@ -2848,24 +2775,11 @@ IceInternal::BasicStream::EncapsDecoder::readInstance()
         }
 
         //
-        // Performance sensitive, so we use lazy initialization for tracing.
-        //
-        if(_traceSlicing == -1)
-        {
-            _traceSlicing = _stream->instance()->traceLevels()->slicing;
-            _slicingCat = _stream->instance()->traceLevels()->slicingCat;
-        }
-        if(_traceSlicing > 0)
-        {
-            traceSlicing("class", _typeId, _slicingCat, _stream->instance()->initializationData().logger);
-        }
-
-        //
         // If object slicing is disabled, stop un-marshalling.
         //
         if(!_sliceObjects)
         {
-            throw NoObjectFactoryException(__FILE__, __LINE__, "object slicing is disabled", _typeId);
+            throw NoObjectFactoryException(__FILE__, __LINE__, "object slicing is disabled", _current->typeId);
         }
 
         //
@@ -2876,14 +2790,14 @@ IceInternal::BasicStream::EncapsDecoder::readInstance()
         //
         // If this is the last slice, keep the object as an opaque UnknownSlicedObject.
         //
-        if(_sliceFlags & FLAG_IS_LAST_SLICE)
+        if(_current->sliceFlags & FLAG_IS_LAST_SLICE)
         {
             //
             // Provide a factory with an opportunity to supply the object.
             // We pass the "::Ice::Object" ID to indicate that this is the
             // last chance to preserve the object.
             //
-            v = newInstance(servantFactoryManager, Object::ice_staticId());
+            v = newInstance(Object::ice_staticId());
             if(!v)
             {
                 v = new UnknownSlicedObject(mostDerivedId);
@@ -2894,230 +2808,537 @@ IceInternal::BasicStream::EncapsDecoder::readInstance()
         
         startSlice(); // Read next Slice header for next iteration.
     }
-     
-    //
-    // Add the object to the map of un-marshalled objects, this must
-    // be done before reading the objects (for circular references).
-    // 
-    _unmarshaledMap.insert(make_pair(index, v));
 
     //
-    // Read the object.
+    // Un-marshal the object
     //
-    v->__read(_stream);
+    unmarshal(index, v);
+
+    if(!_current && !_patchMap.empty())
+    {
+        //
+        // If any entries remain in the patch map, the sender has sent an index for an object, but failed
+        // to supply the object.
+        //
+        throw MarshalException(__FILE__, __LINE__, "index for class received, but no instance");
+    }
+
+    if(patchFunc)
+    {
+        patchFunc(patchAddr, v);
+    }
+    return index;
+}
+
+SlicedDataPtr 
+IceInternal::BasicStream::EncapsDecoder11::readSlicedData()
+{
+    if(_current->slices.empty()) // No preserved slices.
+    {
+        return 0;
+    }
 
     //
-    // Patch all instances now that the object is un-marshalled.
+    // The indirectionTables member holds the indirection table for
+    // each slice in slices.
     //
-    PatchMap::iterator patchPos = _patchMap.find(index);
-    if(patchPos != _patchMap.end())
+    assert(_current->slices.size() == _current->indirectionTables.size());
+    for(SliceInfoSeq::size_type n = 0; n < _current->slices.size(); ++n)
     {
-        assert(patchPos->second.size() > 0);
-        
         //
-        // Patch all pointers that refer to the instance.
+        // We use the "objects" list in SliceInfo to hold references
+        // to the target objects. Note that the objects might not have
+        // been read yet in the case of a circular reference to an
+        // enclosing object.
         //
-        for(PatchList::iterator k = patchPos->second.begin(); k != patchPos->second.end(); ++k)
+        const IndexList& table = _current->indirectionTables[n];
+        vector<ObjectPtr>& objects = _current->slices[n]->objects;
+        objects.resize(table.size());
+        IndexList::size_type j = 0;
+        for(IndexList::const_iterator p = table.begin(); p != table.end(); ++p)
         {
-            (*k->patchFunc)(k->patchAddr, v);
+            addPatchEntry(*p, &patchHandle<Object>, &objects[j++]);
         }
-        
-        //
-        // Clear out the patch map for that index -- there is nothing left
-        // to patch for that index for the time being.
-        //
-        _patchMap.erase(patchPos);
     }
+    return new SlicedData(_current->slices);
+}
 
-    return v;
+Int
+IceInternal::BasicStream::EncapsEncoder::registerTypeId(const string& typeId)
+{
+    TypeIdWriteMap::const_iterator p = _typeIdMap.find(typeId);
+    if(p != _typeIdMap.end())
+    {
+        return p->second;
+    }
+    else
+    {
+        _typeIdMap.insert(make_pair(typeId, ++_typeIdIndex));
+        return -1;
+    }
 }
 
 void
-IceInternal::BasicStream::EncapsDecoder::addPatchEntry(Int index, PatchFunc patchFunc, void* patchAddr)
+IceInternal::BasicStream::EncapsEncoder10::write(const ObjectPtr& v)
 {
-    assert(index > 0);
-
     //
-    // Check if already un-marshalled the object. If that's the case,
-    // just patch the object smart pointer and we're done.
+    // Object references are encoded as a negative integer in 1.0.
     //
-    IndexToPtrMap::iterator p = _unmarshaledMap.find(index);
-    if(p != _unmarshaledMap.end())
+    if(v)
     {
-        (*patchFunc)(patchAddr, p->second);
-        return;
+        _stream->write(-registerObject(v));
     }
-
-    //
-    // Add patch entry if the object isn't un-marshalled yet, the
-    // smart pointer will be patched when the instance is
-    // un-marshalled.
-    //
-
-    PatchMap::iterator q = _patchMap.find(index);
-    if(q == _patchMap.end())
+    else
     {
-        //
-        // We have no outstanding instances to be patched for this
-        // index, so make a new entry in the patch map.
-        //
-        q = _patchMap.insert(make_pair(index, PatchList())).first;
+        _stream->write(0);
     }
+}
 
+void
+IceInternal::BasicStream::EncapsEncoder10::write(const UserException& v)
+{
     //
-    // Append a patch entry for this instance.
+    // User exception with the 1.0 encoding start with a boolean
+    // flag that indicates whether or not the exception uses
+    // classes. 
     //
-    PatchEntry e;
-    e.patchFunc = patchFunc;
-    e.patchAddr = patchAddr;
-    q->second.push_back(e);
+    // This allows reading the pending objects even if some part of
+    // the exception was sliced.
+    //
+    bool usesClasses = v.__usesClasses();
+    _stream->write(usesClasses);
+    v.__write(_stream);
+    if(usesClasses)
+    {
+        writePendingObjects();
+    }
 }
 
 void
-IceInternal::BasicStream::EncapsDecoder::skipSlice()
+IceInternal::BasicStream::EncapsEncoder10::startInstance(SliceType sliceType, const SlicedDataPtr&)
 {
-    Container::iterator start = _stream->i;
+    _sliceType = sliceType;
+    _firstSlice = true;
+}
 
-    if(_sliceFlags & FLAG_HAS_SLICE_SIZE)
+void
+IceInternal::BasicStream::EncapsEncoder10::endInstance()
+{
+    if(_sliceType == ObjectSlice)
     {
-        assert(_sliceSize >= 4);
-        _stream->skip(_sliceSize - sizeof(Int));
+        //
+        // Write the Object slice.
+        //
+        startSlice(Object::ice_staticId(), -1, true);
+        _stream->writeSize(0); // For compatibility with the old AFM.
+        endSlice();
     }
-    else
+    _sliceType = NoSlice;
+}
+
+void
+IceInternal::BasicStream::EncapsEncoder10::startSlice(const string& typeId, int, bool last)
+{
+    //
+    // For object slices, encode a boolean to indicate how the type ID
+    // is encoded and the type ID either as a string or index. For
+    // exception slices, always encode the type ID as a string.
+    //
+    if(_sliceType == ObjectSlice)
     {
-        if(_sliceType == ObjectSlice)
+        Int index = registerTypeId(typeId);
+        if(index < 0)
         {
-            throw NoObjectFactoryException(
-                __FILE__, __LINE__, 
-                "compact format prevents slicing (the sender should use the sliced format instead)", 
-                _typeId);
+            _stream->write(false);
+            _stream->write(typeId, false);
         }
         else
         {
-            throw UnknownUserException(__FILE__, __LINE__, _typeId.substr(2));
+            _stream->write(true);
+            _stream->writeSize(index);
         }
     }
+    else
+    {
+        _stream->write(typeId, false);
+    }
 
-    if(_encaps->encoding != Encoding_1_0)
+    _stream->write(Int(0)); // Placeholder for the slice length.
+
+    _writeSlice = _stream->b.size();
+    _firstSlice = false;
+}
+
+void
+IceInternal::BasicStream::EncapsEncoder10::endSlice()
+{
+    //
+    // Write the slice length.
+    //
+    Int sz = static_cast<Int>(_stream->b.size() - _writeSlice + sizeof(Int));
+    Byte* dest = &(*(_stream->b.begin() + _writeSlice - sizeof(Int)));
+    _stream->write(sz, dest);
+}
+
+void
+IceInternal::BasicStream::EncapsEncoder10::writePendingObjects()
+{
+    while(!_toBeMarshaledMap.empty())
     {
         //
-        // Preserve this slice.
+        // Consider the to be marshalled objects as marshalled now,
+        // this is necessary to avoid adding again the "to be
+        // marshalled objects" into _toBeMarshaledMap while writing
+        // objects.
         //
-        SliceInfoPtr info = new SliceInfo;
-        info->typeId = _typeId;
-        info->compactId = _compactId;
-        info->hasOptionalMembers = _sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS;
-        info->isLastSlice = _sliceFlags & FLAG_IS_LAST_SLICE;
-        if(info->hasOptionalMembers)
+        _marshaledMap.insert(_toBeMarshaledMap.begin(), _toBeMarshaledMap.end());
+
+        PtrToIndexMap savedMap;
+        savedMap.swap(_toBeMarshaledMap);
+        _stream->writeSize(static_cast<Int>(savedMap.size()));
+        for(PtrToIndexMap::iterator p = savedMap.begin(); p != savedMap.end(); ++p)
         {
             //
-            // Don't include the optional member end marker. It will be re-written by
-            // endSlice when the sliced data is re-written.
+            // Ask the instance to marshal itself. Any new class
+            // instances that are triggered by the classes marshaled
+            // are added to toBeMarshaledMap.
             //
-            vector<Byte>(start, _stream->i - 1).swap(info->bytes);
+            _stream->write(p->second);
+
+            try
+            {
+                p->first->ice_preMarshal();
+            }
+            catch(const std::exception& ex)
+            {
+                Warning out(_stream->instance()->initializationData().logger);
+                out << "std::exception raised by ice_preMarshal:\n" << ex;
+            }
+            catch(...)
+            {
+                Warning out(_stream->instance()->initializationData().logger);
+                out << "unknown exception raised by ice_preMarshal";
+            }
+
+            p->first->__write(_stream);
+        }
+    }
+    _stream->writeSize(0); // Zero marker indicates end of sequence of sequences of instances.
+}
+
+Int 
+IceInternal::BasicStream::EncapsEncoder10::registerObject(const ObjectPtr& v)
+{
+    assert(v);
+
+    //
+    // Look for this instance in the to-be-marshaled map.
+    //
+    PtrToIndexMap::const_iterator p = _toBeMarshaledMap.find(v);
+    if(p != _toBeMarshaledMap.end())
+    {
+        return p->second;
+    }
+
+    //
+    // Didn't find it, try the marshaled map next.
+    //
+    PtrToIndexMap::const_iterator q = _marshaledMap.find(v);
+    if(q != _marshaledMap.end())
+    {
+        return q->second;
+    }
+
+    //
+    // We haven't seen this instance previously, create a new
+    // index, and insert it into the to-be-marshaled map.
+    //
+    _toBeMarshaledMap.insert(make_pair(v, ++_objectIdIndex));
+    return _objectIdIndex;
+}
+
+void
+IceInternal::BasicStream::EncapsEncoder11::write(const ObjectPtr& v)
+{
+    if(!v)
+    {
+        _stream->writeSize(0); // Nil reference.
+    }
+    else if(_current && _encaps->format == SlicedFormat)
+    {
+        //
+        // If writting an object within a slice and using the sliced
+        // format, write an index from the object indirection
+        // table. The indirect object table is encoded at the end of
+        // each slice and is always read (even if the Slice is
+        // unknown).
+        // 
+        PtrToIndexMap::const_iterator p = _current->indirectionMap.find(v);
+        if(p == _current->indirectionMap.end())
+        {
+            _current->indirectionTable.push_back(v);
+            Int idx = static_cast<Int>(_current->indirectionTable.size()); // Position + 1 (0 is reserved for nil)
+            _current->indirectionMap.insert(make_pair(v, idx));
+            _stream->writeSize(idx); 
         }
         else
         {
-            vector<Byte>(start, _stream->i).swap(info->bytes);
+            _stream->writeSize(p->second);
         }
-        _slices.push_back(info);
+    }
+    else
+    {
+        writeInstance(v); // Write the instance or a reference if already marshaled.
+    }
+}
 
-        _indirectionTables.push_back(IndexList());
+void
+IceInternal::BasicStream::EncapsEncoder11::write(const UserException& v)
+{
+    v.__write(_stream);
+}
 
-        if(_sliceFlags & FLAG_HAS_INDIRECTION_TABLE)
-        {
-            //
-            // Read the indirection table, which is written as a sequence<size> to conserve space.
-            //
-            _stream->readSizeSeq(_indirectionTables.back());
-        }
+void
+IceInternal::BasicStream::EncapsEncoder11::startInstance(SliceType sliceType, const SlicedDataPtr& data)
+{
+    if(!_current)
+    {
+        _current = &_preAllocatedInstanceData;
+    }
+    else
+    {
+        _current = _current->next ? _current->next : new InstanceData(_current);
+    }
+    _current->sliceType = sliceType;
+    _current->firstSlice = true;
+
+    if(data)
+    {
+        writeSlicedData(data);
     }
 }
 
-SlicedDataPtr 
-IceInternal::BasicStream::EncapsDecoder::readSlicedData()
+void
+IceInternal::BasicStream::EncapsEncoder11::endInstance()
+{
+    _current = _current->previous;
+}
+
+void
+IceInternal::BasicStream::EncapsEncoder11::startSlice(const string& typeId, int compactId, bool last)
 {
-    if(_slices.empty()) // No preserved slices.
+    assert(_current->indirectionTable.empty() && _current->indirectionMap.empty());
+
+    _current->sliceFlagsPos = _stream->b.size();
+
+    _current->sliceFlags = 0;
+    if(_encaps->format == SlicedFormat)
     {
-        return 0;
+        _current->sliceFlags |= FLAG_HAS_SLICE_SIZE; // Encode the slice size if using the sliced format.
     }
+    if(last)
+    {
+        _current->sliceFlags |= FLAG_IS_LAST_SLICE; // This is the last slice.
+    }
+
+    _stream->write(Byte(0)); // Placeholder for the slice flags
 
     //
-    // The _indirectionTables member holds the indirection table for each slice
-    // in _slices.
+    // For object slices, encode the flag and the type ID either as a
+    // string or index. For exception slices, always encode the type
+    // ID a string.
     //
-    assert(_slices.size() == _indirectionTables.size());
-
-    for(SliceInfoSeq::size_type n = 0; n < _slices.size(); ++n)
+    if(_current->sliceType == ObjectSlice)
     {
         //
-        // We use the "objects" list in SliceInfo to hold references to the target
-        // objects. Note however that we may not have actually read these objects
-        // yet, so they need to be treated just like we had read the object references
-        // directly (i.e., we add them to the patch list).
-        //
-        // Another important note: the SlicedData object that we return here must
-        // not be destroyed before readPendingObjects is called, otherwise the
-        // patch references will refer to invalid addresses.
-        //
-        const IndexList& table = _indirectionTables[n];
-        _slices[n]->objects.resize(table.size());
-        IndexList::size_type j = 0;
-        for(IndexList::const_iterator p = table.begin(); p != table.end(); ++p)
+        // Encode the type ID (only in the first slice for the compact
+        // encoding).
+        // 
+        if(_encaps->format == SlicedFormat || _current->firstSlice)
         {
-            const Int id = *p;
-            if(id <= 0)
+            if(compactId >= 0)
             {
-                throw MarshalException(__FILE__, __LINE__, "invalid id in object indirection table");
+                _current->sliceFlags |= FLAG_HAS_TYPE_ID_COMPACT;
+                _stream->writeSize(compactId);
+            }
+            else
+            {
+                Int index = registerTypeId(typeId);
+                if(index < 0)
+                {
+                    _current->sliceFlags |= FLAG_HAS_TYPE_ID_STRING;
+                    _stream->write(typeId, false);
+                }
+                else
+                {
+                    _current->sliceFlags |= FLAG_HAS_TYPE_ID_INDEX;
+                    _stream->writeSize(index);
+                }
             }
-            addPatchEntry(id, &patchHandle<Object>, &_slices[n]->objects[j++]);
         }
     }
+    else
+    {
+        _stream->write(typeId, false);
+    }
 
-    return new SlicedData(_slices);
+    if(_current->sliceFlags & FLAG_HAS_SLICE_SIZE)
+    {
+        _stream->write(Int(0)); // Placeholder for the slice length.
+    }
+
+    _current->writeSlice = _stream->b.size();
+    _current->firstSlice = false;
 }
 
-Ice::ObjectPtr
-IceInternal::BasicStream::EncapsDecoder::newInstance(const ObjectFactoryManagerPtr& servantFactoryManager,
-                                                     const string& typeId)
+void
+IceInternal::BasicStream::EncapsEncoder11::endSlice()
 {
-    Ice::ObjectPtr v;
+    //
+    // Write the optional member end marker if some optional members
+    // were encoded. Note that the optional members are encoded before
+    // the indirection table and are included in the slice size.
+    //
+    if(_current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS)
+    {
+        _stream->write(OPTIONAL_END_MARKER);
+    }
 
     //
-    // Try to find a factory registered for the specific type.
+    // Write the slice length if necessary.
     //
-    ObjectFactoryPtr userFactory = servantFactoryManager->find(typeId);
-    if(userFactory)
+    if(_current->sliceFlags & FLAG_HAS_SLICE_SIZE)
     {
-        v = userFactory->create(typeId);
+        Int sz = static_cast<Int>(_stream->b.size() - _current->writeSlice + sizeof(Int));
+        Byte* dest = &(*(_stream->b.begin() + _current->writeSlice - sizeof(Int)));
+        _stream->write(sz, dest);
     }
 
     //
-    // If that fails, invoke the default factory if one has been
-    // registered.
+    // Only write the indirection table if it contains entries.
     //
-    if(!v)
+    if(!_current->indirectionTable.empty())
     {
-        userFactory = servantFactoryManager->find("");
-        if(userFactory)
+        assert(_encaps->format == SlicedFormat);
+        _current->sliceFlags |= FLAG_HAS_INDIRECTION_TABLE;
+
+        //
+        // Write the indirection object table.
+        //
+        _stream->writeSize(static_cast<Int>(_current->indirectionTable.size()));
+        ObjectList::const_iterator p;
+        for(p = _current->indirectionTable.begin(); p != _current->indirectionTable.end(); ++p)
         {
-            v = userFactory->create(typeId);
+            writeInstance(*p);
         }
+        _current->indirectionTable.clear();
+        _current->indirectionMap.clear();
     }
 
     //
-    // Last chance: check the table of static factories (i.e.,
-    // automatically generated factories for concrete classes).
+    // Finally, update the slice flags.
     //
-    if(!v)
+    Byte* dest = &(*(_stream->b.begin() + _current->sliceFlagsPos));
+    *dest = _current->sliceFlags;
+}
+
+bool 
+IceInternal::BasicStream::EncapsEncoder11::writeOpt(Ice::Int tag, Ice::OptionalFormat format)
+{
+    if(!_current)
     {
-        ObjectFactoryPtr of = IceInternal::factoryTable->getObjectFactory(typeId);
-        if(of)
+        return _stream->writeOptImpl(tag, format);
+    }
+    else
+    {
+        if(_stream->writeOptImpl(tag, format))
         {
-            v = of->create(typeId);
-            assert(v);
+            _current->sliceFlags |= FLAG_HAS_OPTIONAL_MEMBERS;
+            return true;
+        }
+        else
+        {
+            return false;
         }
     }
+}
 
-    return v;
+void
+IceInternal::BasicStream::EncapsEncoder11::writeSlicedData(const SlicedDataPtr& slicedData)
+{
+    assert(slicedData);
+
+    //
+    // We only remarshal preserved slices if we are using the sliced
+    // format. Otherwise, we ignore the preserved slices, which
+    // essentially "slices" the object into the most-derived type
+    // known by the sender.
+    //
+    if(_encaps->format != SlicedFormat)
+    {
+        return;
+    }
+
+    for(SliceInfoSeq::const_iterator p = slicedData->slices.begin(); p != slicedData->slices.end(); ++p)
+    {
+        startSlice((*p)->typeId, (*p)->compactId, (*p)->isLastSlice);
+ 
+        //
+        // Write the bytes associated with this slice.
+        //
+        _stream->writeBlob((*p)->bytes);
+        
+        if((*p)->hasOptionalMembers)
+        {
+            _current->sliceFlags |= FLAG_HAS_OPTIONAL_MEMBERS;
+        }
+
+        //
+        // Make sure to also re-write the object indirection table.
+        //
+        _current->indirectionTable = (*p)->objects;
+
+        endSlice();
+    }
 }
+
+void
+IceInternal::BasicStream::EncapsEncoder11::writeInstance(const ObjectPtr& v)
+{
+    assert(v);
+
+    //
+    // If the instance was already marshaled, just write it's ID.
+    //
+    PtrToIndexMap::const_iterator q = _marshaledMap.find(v);
+    if(q != _marshaledMap.end())
+    {
+        _stream->writeSize(q->second);
+        return;
+    }
+
+    //
+    // We haven't seen this instance previously, create a new ID,
+    // insert it into the marshaled map, and write the instance.
+    //
+    _marshaledMap.insert(make_pair(v, ++_objectIdIndex));
+
+    try
+    {
+        v->ice_preMarshal();
+    }
+    catch(const std::exception& ex)
+    {
+        Warning out(_stream->instance()->initializationData().logger);
+        out << "std::exception raised by ice_preMarshal:\n" << ex;
+    }
+    catch(...)
+    {
+        Warning out(_stream->instance()->initializationData().logger);
+        out << "unknown exception raised by ice_preMarshal";
+    }
+
+    _stream->writeSize(1); // Object instance marker.
+    v->__write(_stream);
+}
+
diff --git a/cpp/src/Ice/Object.cpp b/cpp/src/Ice/Object.cpp
index 93256b730d0..5d472d8f542 100644
--- a/cpp/src/Ice/Object.cpp
+++ b/cpp/src/Ice/Object.cpp
@@ -23,7 +23,7 @@ using namespace IceInternal;
 Object* Ice::upCast(Object* p) { return p; }
 
 void 
-Ice::__patch(ObjectPtr& obj, ObjectPtr& v)
+Ice::__patch(ObjectPtr& obj, const ObjectPtr& v)
 {
     obj = v;
 }
diff --git a/cpp/src/Ice/StreamI.cpp b/cpp/src/Ice/StreamI.cpp
index c6db6768358..5df5ec83b38 100644
--- a/cpp/src/Ice/StreamI.cpp
+++ b/cpp/src/Ice/StreamI.cpp
@@ -169,7 +169,7 @@ namespace
 {
 
 void
-patchObject(void* addr, ObjectPtr& v)
+patchObject(void* addr, const ObjectPtr& v)
 {
     ReadObjectCallback* cb = static_cast<ReadObjectCallback*>(addr);
     assert(cb);
diff --git a/cpp/src/Slice/CsUtil.cpp b/cpp/src/Slice/CsUtil.cpp
index 699bcb37c0e..0bfc5b7c519 100644
--- a/cpp/src/Slice/CsUtil.cpp
+++ b/cpp/src/Slice/CsUtil.cpp
@@ -180,7 +180,7 @@ Slice::CsGenerator::getOptionalFormat(const TypePtr& type)
         }
         case Builtin::KindObject:
         {
-            return "Ice.OptionalFormat.Size";
+            return "Ice.OptionalFormat.Class";
         }
         case Builtin::KindObjectProxy:
         {
@@ -225,7 +225,7 @@ Slice::CsGenerator::getOptionalFormat(const TypePtr& type)
 
     ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
     assert(cl);
-    return "Ice.OptionalFormat.Size";
+    return "Ice.OptionalFormat.Class";
 }
 
 string
diff --git a/cpp/src/Slice/JavaUtil.cpp b/cpp/src/Slice/JavaUtil.cpp
index 6b6559b4f2f..e98b2d8aa05 100644
--- a/cpp/src/Slice/JavaUtil.cpp
+++ b/cpp/src/Slice/JavaUtil.cpp
@@ -613,7 +613,7 @@ Slice::JavaGenerator::getOptionalFormat(const TypePtr& type)
         }
         case Builtin::KindObject:
         {
-            return "Ice.OptionalFormat.Size";
+            return "Ice.OptionalFormat.Class";
         }
         case Builtin::KindObjectProxy:
         {
@@ -658,7 +658,7 @@ Slice::JavaGenerator::getOptionalFormat(const TypePtr& type)
 
     ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
     assert(cl);
-    return "Ice.OptionalFormat.Size";
+    return "Ice.OptionalFormat.Class";
 }
 
 string
diff --git a/cpp/src/Slice/Parser.cpp b/cpp/src/Slice/Parser.cpp
index 4867c3af593..71b55d05b14 100644
--- a/cpp/src/Slice/Parser.cpp
+++ b/cpp/src/Slice/Parser.cpp
@@ -283,7 +283,7 @@ Slice::Builtin::minWireSize() const
         4, // KindFloat
         8, // KindDouble
         1, // KindString: at least one byte for an empty string.
-        4, // KindObject: at least 4 bytes (to marshal an index instead of an instance).
+        1, // KindObject: at least 4 bytes (to marshal an index instead of an instance).
         2  // KindObjectProxy: at least an empty identity for a nil proxy, that is, 2 bytes.
     };
 
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index d2d650df4e6..336cd1e6cbe 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -3229,7 +3229,7 @@ Slice::Gen::ObjectDeclVisitor::visitClassDecl(const ClassDeclPtr& p)
         H << nl << _dllExport << "::Ice::Object* upCast(" << scoped << "*);";
         H << nl << "typedef ::IceInternal::Handle< " << scoped << "> " << p->name() << "Ptr;";
         H << nl << "typedef ::IceInternal::ProxyHandle< ::IceProxy" << scoped << "> " << p->name() << "Prx;";
-        H << nl << _dllExport << "void __patch(" << p->name() << "Ptr&, ::Ice::ObjectPtr&);";
+        H << nl << _dllExport << "void __patch(" << p->name() << "Ptr&, const ::Ice::ObjectPtr&);";
     }
     else
     {
@@ -4105,7 +4105,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
     {
         C << sp << nl << "void "
           << (_dllExport.empty() ? "" : "ICE_DECLSPEC_EXPORT ");
-        C << nl << scope.substr(2) << "__patch(" << p->name() << "Ptr& handle, ::Ice::ObjectPtr& v)";
+        C << nl << scope.substr(2) << "__patch(" << p->name() << "Ptr& handle, const ::Ice::ObjectPtr& v)";
         C << sb;
         C << nl << "handle = " << scope << p->name() << "Ptr::dynamicCast(v);";
         C << nl << "if(v && !handle)";
diff --git a/cpp/test/Ice/optional/AllTests.cpp b/cpp/test/Ice/optional/AllTests.cpp
index 0d2abc181fd..d0145d44212 100644
--- a/cpp/test/Ice/optional/AllTests.cpp
+++ b/cpp/test/Ice/optional/AllTests.cpp
@@ -145,7 +145,36 @@ public:
 private:
 
     IceUtil::Optional<APtr> a;
+};
+
+class FObjectReader : public Ice::ObjectReader
+{
+public:
 
+    virtual void
+    read(const Ice::InputStreamPtr& in)
+    {
+        _f = new F();
+        in->startObject();
+        in->startSlice();
+        // Don't read af on purpose
+        //in->read(1, _f->af);
+        in->endSlice();
+        in->startSlice();
+        in->read(_f->ae);
+        in->endSlice();
+        in->endObject(false);
+    }
+
+    FPtr 
+    getF()
+    {
+        return _f;
+    }
+
+private:
+
+    FPtr _f;
 };
 
 class FactoryI : public Ice::ObjectFactory
@@ -186,6 +215,10 @@ public:
         {
             return new DObjectReader;
         }
+        else if(typeId == "::Test::F")
+        {
+            return new FObjectReader;
+        }
         
         return 0;
     }
@@ -657,6 +690,33 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
 
     cout << "ok" << endl;
 
+    cout << "testing marshalling of objects with optional objects..." << flush;
+    {
+        FPtr f = new F();
+
+        f->af = new A();
+        f->ae = *f->af;
+
+        FPtr rf = FPtr::dynamicCast(initial->pingPong(f));
+        test(rf->ae == *rf->af);
+
+        factory->setEnabled(true);
+        out = Ice::createOutputStream(communicator);
+        out->startEncapsulation();
+        out->write(f);
+        out->endEncapsulation();
+        out->finished(inEncaps);
+        in = Ice::createInputStream(communicator, inEncaps);
+        in->startEncapsulation();
+        in->read(obj);
+        in->endEncapsulation();
+        factory->setEnabled(false);
+
+        rf = dynamic_cast<FObjectReader*>(obj.get())->getF();
+        test(rf->ae && !rf->af);
+    }
+    cout << "ok" << endl;
+
     cout << "testing optional with default values... " << flush;
     WDPtr wd = WDPtr::dynamicCast(initial->pingPong(new WD()));
     test(*wd->a == 5);
@@ -867,6 +927,26 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
         in->endEncapsulation();
     }
 
+    {
+        FPtr f = new F();
+        f->af = new A();
+        (*f->af)->requiredA = 56;
+        f->ae = *f->af;
+
+        out = Ice::createOutputStream(communicator);
+        out->startEncapsulation();
+        out->write(1, makeOptional(f));
+        out->write(2, makeOptional(f->ae));
+        out->endEncapsulation();
+        out->finished(inEncaps);
+
+        in = Ice::createInputStream(communicator, inEncaps);
+        in->startEncapsulation();
+        IceUtil::Optional<APtr> a;
+        in->read(2, a);
+        in->endEncapsulation();
+        test(a && *a && (*a)->requiredA == 56);        
+    }
     cout << "ok" << endl;
 
     cout << "testing optional parameters and custom sequences... " << flush;
diff --git a/cpp/test/Ice/optional/Test.ice b/cpp/test/Ice/optional/Test.ice
index d693ae649a2..269a8ea4bfa 100644
--- a/cpp/test/Ice/optional/Test.ice
+++ b/cpp/test/Ice/optional/Test.ice
@@ -163,6 +163,16 @@ class OptionalWithCustom
     optional(3) ClassVarStruct s;
 };
 
+class E
+{
+    A ae;
+};
+
+class F extends E
+{
+    optional(1) A af;
+};
+
 class Initial
 {
     void shutdown();
diff --git a/cpp/test/Ice/slicing/exceptions/AllTests.cpp b/cpp/test/Ice/slicing/exceptions/AllTests.cpp
index 0ea733dde2c..69bfcb491b3 100644
--- a/cpp/test/Ice/slicing/exceptions/AllTests.cpp
+++ b/cpp/test/Ice/slicing/exceptions/AllTests.cpp
@@ -781,6 +781,9 @@ allTests(const Ice::CommunicatorPtr& communicator)
             //
             test(test->ice_getEncodingVersion() != Ice::Encoding_1_0);
         }
+        catch(const Ice::OperationNotExistException&)
+        {
+        }
         catch(...)
         {
             test(false);
@@ -805,6 +808,9 @@ allTests(const Ice::CommunicatorPtr& communicator)
             test(ex.kp == "preserved");
             test(ex.kpd == "derived");
         }
+        catch(const Ice::OperationNotExistException&)
+        {
+        }
         catch(...)
         {
             test(false);
@@ -821,6 +827,9 @@ allTests(const Ice::CommunicatorPtr& communicator)
             test(ex.kp == "preserved");
             test(ex.kpd == "derived");
         }
+        catch(const Ice::OperationNotExistException&)
+        {
+        }
         catch(...)
         {
             test(false);
@@ -842,6 +851,9 @@ allTests(const Ice::CommunicatorPtr& communicator)
             test(pc->pc == "pc");
             test(ex.p2 == ex.p1);
         }
+        catch(const Ice::OperationNotExistException&)
+        {
+        }
         catch(const KnownPreservedDerived& ex)
         {
             //
@@ -862,6 +874,9 @@ allTests(const Ice::CommunicatorPtr& communicator)
             test->relayUnknownPreservedAsKnownPreserved(relay);
             test(false);
         }
+        catch(const Ice::OperationNotExistException&)
+        {
+        }
         catch(const Preserved2& ex)
         {
             test(ex.b == "base");
diff --git a/cpp/test/Ice/slicing/objects/AllTests.cpp b/cpp/test/Ice/slicing/objects/AllTests.cpp
index 5d07fa30fcc..b4415e1a625 100644
--- a/cpp/test/Ice/slicing/objects/AllTests.cpp
+++ b/cpp/test/Ice/slicing/objects/AllTests.cpp
@@ -477,9 +477,16 @@ public:
     }
 
     void 
-    exception(const ::Ice::Exception&)
+    exception(const ::Ice::Exception& ex)
     {
-        test(false);
+        if(!dynamic_cast<const Ice::OperationNotExistException*>(&ex))
+        {
+            test(false);
+        }
+        else
+        {
+            called();
+        }
     }
  
     BPtr rb;
@@ -724,6 +731,9 @@ allTests(const Ice::CommunicatorPtr& communicator)
             SBasePtr sb = test->SBSUnknownDerivedAsSBaseCompact();
             test(sb->sb == "SBSUnknownDerived.sb");
         }
+        catch(const Ice::OperationNotExistException&)
+        {
+        }
         catch(...)
         {
             test(false);
@@ -740,6 +750,9 @@ allTests(const Ice::CommunicatorPtr& communicator)
             SBasePtr sb = test->SBSUnknownDerivedAsSBaseCompact();
             test(false);
         }
+        catch(const Ice::OperationNotExistException&)
+        {
+        }
         catch(const Ice::NoObjectFactoryException&)
         {
             // Expected.
@@ -1964,6 +1977,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
     cout << "ok" << endl;
 
     cout << "preserved classes... " << flush;
+    try
     {
         //
         // Server knows the most-derived class PDerived.
@@ -1980,7 +1994,11 @@ allTests(const Ice::CommunicatorPtr& communicator)
         test(p2->ps == "preserved");
         test(p2->pb == p2);
     }
+    catch(const Ice::OperationNotExistException&)
+    {
+    }
 
+    try
     {
         //
         // Server only knows the base (non-preserved) type, so the object is sliced.
@@ -1994,7 +2012,11 @@ allTests(const Ice::CommunicatorPtr& communicator)
         test(!p2);
         test(r->pi == 3);
     }
+    catch(const Ice::OperationNotExistException&)
+    {
+    }
 
+    try
     {
         //
         // Server only knows the intermediate type Preserved. The object will be sliced to
@@ -2018,7 +2040,11 @@ allTests(const Ice::CommunicatorPtr& communicator)
             test(p2->pbs[0] == p2);
         }
     }
+    catch(const Ice::OperationNotExistException&)
+    {
+    }
 
+    try
     {
         //
         // Server only knows the intermediate type CompactPDerived. The object will be sliced to
@@ -2042,7 +2068,11 @@ allTests(const Ice::CommunicatorPtr& communicator)
             test(p2->pbs[0] == p2);
         }
     }
+    catch(const Ice::OperationNotExistException&)
+    {
+    }
 
+    try
     {
         //
         // Send an object that will have multiple preserved slices in the server.
@@ -2089,7 +2119,11 @@ allTests(const Ice::CommunicatorPtr& communicator)
             test(p3->pcd3 == p3->pbs[10]);
         }
     }
+    catch(const Ice::OperationNotExistException&)
+    {
+    }
 
+    try
     {
         //
         // Obtain an object with preserved slices and send it back to the server.
@@ -2103,6 +2137,9 @@ allTests(const Ice::CommunicatorPtr& communicator)
             test->ice_encodingVersion(Ice::Encoding_1_0)->checkPBSUnknown(p);
         }
     }
+    catch(const Ice::OperationNotExistException&)
+    {
+    }
 
     cout << "ok" << endl;
 
@@ -2223,6 +2260,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
     cout << "ok" << endl;
 
     cout << "garbage collection for preserved classes... " << flush;
+    try
     {
         //
         // Register a factory in order to substitute our own subclass of PNode. This provides
@@ -2351,6 +2389,9 @@ allTests(const Ice::CommunicatorPtr& communicator)
             test(false);
         }
     }
+    catch(const Ice::OperationNotExistException&)
+    {
+    }
     cout << "ok" << endl;
 
     return test;