Fixed issues with dependent lookups

engine/server/application/CentralServer/src/shared/AuctionTransferGameAPI/Base/Archive.h

@@ -2,15 +2,15 @@
 //  The author of this code is Justin Randall
 //
 //  I have made modifications to the ByteStream
-//  and AutoByteStream classes in order to make them suitable 
-//  for use in messaging systems which require objects that 
+//  and AutoByteStream classes in order to make them suitable
+//  for use in messaging systems which require objects that
 //  are copyable and assignable.  It is also desirable for
 //  the ByteStream object to use a flexible allocator system
 //  that may support multi-threaded programming models.
 
 
-#ifndef	BASE_ARCHIVE_H
-#define	BASE_ARCHIVE_H
+#ifndef BASE_ARCHIVE_H
+#define BASE_ARCHIVE_H
 
 
 #include <assert.h>
@@ -19,10 +19,10 @@
 #include "Platform.h"
 
 
-//#if !defined PLATFORM_BASE_SINGLE_THREAD && ( defined _MT || defined _REENTRANT )
-//#   define USE_ARCHIVE_MUTEX
-//#	include "Mutex.h"
-//#endif
+#if !defined PLATFORM_BASE_SINGLE_THREAD && ( defined _MT || defined _REENTRANT )
+#   define USE_ARCHIVE_MUTEX
+#   include "Mutex.h"
+#endif
 
 #ifdef WIN32
 #   include "win32/Archive.h"
@@ -35,11 +35,11 @@
 #endif
 
 #ifdef EXTERNAL_DISTRO
-namespace NAMESPACE 
+namespace NAMESPACE
 {
 
 #endif
-namespace Base 
+namespace Base
 {
 
 const unsigned MAX_ARRAY_SIZE = 1024;
@@ -54,92 +54,92 @@ const unsigned MAX_ARRAY_SIZE = 1024;
     class ByteStream
     {
         public:
-	        class ReadIterator
-	        {
-	            public:
-		            ReadIterator();
-		            ReadIterator(const ReadIterator & source);
-		            explicit ReadIterator(const ByteStream & source);
-		            ~ReadIterator();
+            class ReadIterator
+            {
+                public:
+                    ReadIterator();
+                    ReadIterator(const ReadIterator & source);
+                    explicit ReadIterator(const ByteStream & source);
+                    ~ReadIterator();
 
-		            ReadIterator &              operator =      (const ReadIterator & source);
-		            void                        advance         (const unsigned int distance);
-		            void                        get             (void * target, const unsigned long int readSize);
-		            const unsigned int          getSize         () const;
-		            const unsigned char * const getBuffer       () const;
-		            const unsigned int          getReadPosition () const;
+                    ReadIterator &              operator =      (const ReadIterator & source);
+                    void                        advance         (const unsigned int distance);
+                    void                        get             (void * target, const unsigned long int readSize);
+                    const unsigned int          getSize         () const;
+                    const unsigned char * const getBuffer       () const;
+                    const unsigned int          getReadPosition () const;
 
                 private:
-		            unsigned int readPtr;
-		            const ByteStream *     stream;
-	        };
+                    unsigned int readPtr;
+                    const ByteStream *     stream;
+            };
 
-        private: 
-	        class Data
-	        {
-		        friend class ByteStream;
-		        friend class ReadIterator;
-	            public:
-		            ~Data();
-		            
-		            static Data * getNewData();
+        private:
+            class Data
+            {
+                friend class ByteStream;
+                friend class ReadIterator;
+                public:
+                    ~Data();
 
-		            const int getRef () const;
-		            void      deref  ();
-		            void      ref    ();
-	            protected:
-		            unsigned char * buffer;
-		            unsigned long   size;
-	            private:
-		            struct DataFreeList
-		            {
-			            ~DataFreeList()
-			            {
-				            std::vector<ByteStream::Data *>::iterator i;
-				            for(i = freeList.begin(); i != freeList.end(); ++i)
-				            {
-					            delete (*i);
-				            }
-			            };
-			            std::vector<Data *> freeList;
-		            };
-		            Data();
+                    static Data * getNewData();
+
+                    const int getRef () const;
+                    void      deref  ();
+                    void      ref    ();
+                protected:
+                    unsigned char * buffer;
+                    unsigned long   size;
+                private:
+                    struct DataFreeList
+                    {
+                        ~DataFreeList()
+                        {
+                            std::vector<ByteStream::Data *>::iterator i;
+                            for(i = freeList.begin(); i != freeList.end(); ++i)
+                            {
+                                delete (*i);
+                            }
+                        };
+                        std::vector<Data *> freeList;
+                    };
+                    Data();
                     //explicit Data(unsigned char * buffer);
-		            static std::vector<Data *> & getDataFreeList();
-		            static void   releaseOldData(Data * oldData);
-	            private:
-		            int             refCount;
-	        };
+                    static std::vector<Data *> & getDataFreeList();
+                    static void   releaseOldData(Data * oldData);
+                private:
+                    int             refCount;
+            };
 
         friend class ReadIterator;
         public:
-	        ByteStream();
-	        ByteStream(const unsigned char * const buffer, const unsigned int bufferSize);
-	        ByteStream(const ByteStream & source);
-	        virtual ~ByteStream();
+            ByteStream();
+            ByteStream(const unsigned char * const buffer, const unsigned int bufferSize);
+            ByteStream(const ByteStream & source);
+            virtual ~ByteStream();
 
         public:
-	        ByteStream(ReadIterator & source);
-	        ByteStream &                operator = (const ByteStream & source);
-	        ByteStream &                operator = (ReadIterator & source);
-	        const ReadIterator &        begin() const;
-	        void                        clear();
-	        const unsigned char * const getBuffer() const;
-	        const unsigned int          getSize() const;
-	        void                        put(const void * const source, const unsigned int sourceSize);
-	        bool                        overwriteEnd(const void * const source, const unsigned int sourceSize);
+            ByteStream(ReadIterator & source);
+            ByteStream &                operator = (const ByteStream & source);
+            ByteStream &                operator = (ReadIterator & source);
+            const ReadIterator &        begin() const;
+            void                        clear();
+            const unsigned char * const getBuffer() const;
+            const unsigned int          getSize() const;
+            void                        put(const void * const source, const unsigned int sourceSize);
+            bool                        overwriteEnd(const void * const source, const unsigned int sourceSize);
 
         private:
-	        void                        get(void * target, ReadIterator & readIterator, const unsigned long int readSize) const;
-	        void                        growToAtLeast(const unsigned int targetSize);
-	        void                        reAllocate(const unsigned int newSize);
+            void                        get(void * target, ReadIterator & readIterator, const unsigned long int readSize) const;
+            void                        growToAtLeast(const unsigned int targetSize);
+            void                        reAllocate(const unsigned int newSize);
 
         private:
-	        unsigned int                allocatedSize;
-	        ReadIterator                beginReadIterator;
-	        Data *                      data;
-	        unsigned int                size;
-			unsigned int				lastPutSize;
+            unsigned int                allocatedSize;
+            ReadIterator                beginReadIterator;
+            Data *                      data;
+            unsigned int                size;
+            unsigned int                lastPutSize;
 
     };
 
@@ -157,7 +157,7 @@ const unsigned MAX_ARRAY_SIZE = 1024;
 #endif
 
         refCount = 0;
-	    delete[] buffer;
+        delete[] buffer;
 
 #if defined(USE_ARCHIVE_MUTEX)
         ByteStreamMutex.Unlock();
@@ -176,14 +176,14 @@ const unsigned MAX_ARRAY_SIZE = 1024;
         ByteStreamMutex.Unlock();
 #endif
 
-	    if(refCount < 1)
-		    releaseOldData(this);
+        if(refCount < 1)
+            releaseOldData(this);
     }
 
     inline std::vector<ByteStream::Data *> & ByteStream::Data::getDataFreeList()
     {
-	    static DataFreeList freeList;
-	    return freeList.freeList;
+        static DataFreeList freeList;
+        return freeList.freeList;
     }
 
     inline ByteStream::Data * ByteStream::Data::getNewData()
@@ -193,30 +193,30 @@ const unsigned MAX_ARRAY_SIZE = 1024;
 #endif
 
         Data * result = 0;
-	    if(getDataFreeList().empty())
-	    {
-		    result = new Data;
-	    }
-	    else
-	    {
-		    result = getDataFreeList().back();
-		    getDataFreeList().pop_back();
-	    }
-	    result->refCount = 1;
+        if(getDataFreeList().empty())
+        {
+            result = new Data;
+        }
+        else
+        {
+            result = getDataFreeList().back();
+            getDataFreeList().pop_back();
+        }
+        result->refCount = 1;
 
 #if defined(USE_ARCHIVE_MUTEX)
         ByteStreamMutex.Unlock();
 #endif
 
-	    return result;
+        return result;
     }
 
     inline const int ByteStream::Data::getRef() const
     {
-	    return refCount;
+        return refCount;
     }
 
-    inline void ByteStream::Data::ref() 
+    inline void ByteStream::Data::ref()
     {
 #if defined(USE_ARCHIVE_MUTEX)
         ByteStreamMutex.Lock();
@@ -236,7 +236,7 @@ const unsigned MAX_ARRAY_SIZE = 1024;
 #endif
 
         getDataFreeList().push_back(oldData);
-	    oldData->refCount = 0;
+        oldData->refCount = 0;
 
 #if defined(USE_ARCHIVE_MUTEX)
         ByteStreamMutex.Unlock();
@@ -245,51 +245,51 @@ const unsigned MAX_ARRAY_SIZE = 1024;
 
     inline ByteStream::ReadIterator & ByteStream::ReadIterator::operator = (const ByteStream::ReadIterator & rhs)
     {
-	    if(&rhs != this)
-	    {
-		    readPtr = rhs.readPtr;
-		    stream = rhs.stream;
-	    }
-	    return *this;
+        if(&rhs != this)
+        {
+            readPtr = rhs.readPtr;
+            stream = rhs.stream;
+        }
+        return *this;
     }
 
     inline void ByteStream::ReadIterator::get(void * target, const unsigned long int readSize)
     {
-	    assert(stream);
-	    stream->get(target, *this, readSize);
-	    readPtr += readSize;
+        assert(stream);
+        stream->get(target, *this, readSize);
+        readPtr += readSize;
     }
 
     inline const unsigned int ByteStream::ReadIterator::getSize() const
     {
-	    assert(stream);
-	    return stream->getSize() - readPtr;
+        assert(stream);
+        return stream->getSize() - readPtr;
     }
 
     inline const ByteStream::ReadIterator & ByteStream::begin() const
     {
-	    return beginReadIterator;
+        return beginReadIterator;
     }
 
     inline void ByteStream::ReadIterator::advance(const unsigned int distance)
     {
-	    readPtr += distance;
+        readPtr += distance;
     }
 
     inline const unsigned int ByteStream::ReadIterator::getReadPosition() const
     {
-	    return readPtr;
+        return readPtr;
     }
 
     inline const unsigned char * const ByteStream::ReadIterator::getBuffer() const
     {
-	    if(stream)
-		    return &stream->data->buffer[readPtr];
+        if(stream)
+            return &stream->data->buffer[readPtr];
 
-	    return 0;
+        return 0;
     }
 
-    inline void ByteStream::clear() 
+    inline void ByteStream::clear()
     {
 #if defined(USE_ARCHIVE_MUTEX)
         ByteStreamMutex.Lock();
@@ -304,276 +304,98 @@ const unsigned MAX_ARRAY_SIZE = 1024;
 
     inline const unsigned char * const ByteStream::getBuffer() const
     {
-	    return data->buffer;
+        return data->buffer;
     }
 
     inline const unsigned int ByteStream::getSize() const
     {
-	    return size;
+        return size;
     }
 
     inline void ByteStream::growToAtLeast(const unsigned int targetSize)
     {
-	    if(allocatedSize < targetSize)
-	    {
-		    reAllocate(allocatedSize + allocatedSize + targetSize);
-	    }
+        if(allocatedSize < targetSize)
+        {
+            reAllocate(allocatedSize + allocatedSize + targetSize);
+        }
     }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 
 
-    class AutoVariableBase
-    {
-        public:
-	        AutoVariableBase();
-	        virtual ~AutoVariableBase();
-
-            virtual void     pack(ByteStream & target) const = 0;
-	        virtual void     unpack(ByteStream::ReadIterator & source) = 0;
-    };
-
-
-////////////////////////////////////////////////////////////////////////////////
-
-
-    class AutoByteStream 
-    {
-        public:
-	        AutoByteStream();
-	        virtual ~AutoByteStream();
-	        void                 addVariable(AutoVariableBase & newVariable);
-	        virtual const unsigned int getItemCount() const;
-	        virtual void         pack(ByteStream & target) const;
-	        virtual void         unpack(ByteStream::ReadIterator & source);
-        protected:
-	        std::vector<AutoVariableBase *>	members;
-        private:
-	        AutoByteStream(const AutoByteStream & source);
-    };
-
-
-////////////////////////////////////////////////////////////////////////////////
-
-
-    template<class ValueType>
-    class AutoVariable : public AutoVariableBase
-    {
-    public:
-	    AutoVariable();
-	    explicit AutoVariable(const ValueType & source);
-	    virtual ~AutoVariable();
-
-	    const ValueType & get() const;
-	    virtual void      pack(ByteStream & target) const;
-	    void              set(const ValueType & rhs);
-	    virtual void      unpack(ByteStream::ReadIterator & source);
-
-    private:
-	    ValueType        value;
-    };
-
-    template<class ValueType>
-    AutoVariable<ValueType>::AutoVariable() :
-        AutoVariableBase(),
-        value()
-    {
-    }
-
-    template<class ValueType>
-    AutoVariable<ValueType>::AutoVariable(const ValueType & source) :
-        AutoVariableBase(),
-        value(source)
-    {
-    }
-
-    template<class ValueType>
-    AutoVariable<ValueType>::~AutoVariable()
-    {
-    }
-
-    template<class ValueType>
-    const ValueType & AutoVariable<ValueType>::get() const
-    {
-	    return value;
-    }
-
-    template<class ValueType>
-    void AutoVariable<ValueType>::pack(ByteStream & target) const
-    {
-	    Base::put(target, value);
-    }
-
-    template<class ValueType>
-    void AutoVariable<ValueType>::set(const ValueType & rhs)
-    {
-	    value = rhs;
-    }
-
-    template<class ValueType>
-    void AutoVariable<ValueType>::unpack(ByteStream::ReadIterator & source)
-    {
-        Base::get(source, value);
-    }
-
-
-////////////////////////////////////////////////////////////////////////////////
-
-
-    template<class ValueType>
-    class AutoArray : public AutoVariableBase
-    {
-    public:
-	    AutoArray();
-	    AutoArray(const AutoArray & source);
-	    ~AutoArray();
-
-	    const std::vector<ValueType> & get() const;
-	    void  set(const std::vector<ValueType> & source);
-	    
-	    virtual void pack(ByteStream & target) const;
-	    virtual void unpack(ByteStream::ReadIterator & source);
-
-    private:
-	    std::vector<ValueType>	array;
-    };
-
-    template<class ValueType>
-    inline AutoArray<ValueType>::AutoArray() 
-    {
-    }
-
-    template<class ValueType>
-    inline AutoArray<ValueType>::AutoArray(const AutoArray & source) :
-        array(source.array)
-    {
-    }
-
-    template<class ValueType>
-    inline AutoArray<ValueType>::~AutoArray()
-    {
-    }
-
-    template<class ValueType>
-    inline const std::vector<ValueType> & AutoArray<ValueType>::get() const
-    {
-	    return array;
-    }
-
-    template<class ValueType>
-    inline void AutoArray<ValueType>::set(const std::vector<ValueType> & source)
-    {
-	    array = source;
-    }
-
-    template<class ValueType>
-    inline void AutoArray<ValueType>::pack(ByteStream & target) const
-    {
-	    unsigned int arraySize = array.size();
-	    Base::put(target, arraySize);
-
-	    typename std::vector<ValueType>::const_iterator i;
-	    for(i = array.begin(); i != array.end(); ++i)
-	    {
-		    ValueType v = (*i);
-		    Base::put(target, v);
-	    }
-    }
-
-    template<class ValueType>
-    inline void AutoArray<ValueType>::unpack(ByteStream::ReadIterator & source) 
-    {
-	    unsigned int arraySize;
-	    Base::get(source, arraySize);
-	    ValueType v;
-
-        if (arraySize > MAX_ARRAY_SIZE)
-            arraySize = 0;
-
-	    for(unsigned int i = 0; i < arraySize; ++i)
-	    {
-		    Base::get(source, v);
-		    array.push_back(v);
-	    }
-    }	
-
-
-////////////////////////////////////////////////////////////////////////////////
-
-    
     inline void get(ByteStream::ReadIterator & source, ByteStream & target)
     {
-	    target.put(source.getBuffer(), source.getSize());
-	    source.advance(source.getSize());
+        target.put(source.getBuffer(), source.getSize());
+        source.advance(source.getSize());
     }
 
     inline void get(ByteStream::ReadIterator & source, double & target)
     {
-	    source.get(&target, 8);
+        source.get(&target, 8);
         target = byteSwap(target);
     }
 
     inline void get(ByteStream::ReadIterator & source, float & target)
     {
-	    source.get(&target, 4);
+        source.get(&target, 4);
         target = byteSwap(target);
     }
 
     inline void get(ByteStream::ReadIterator & source, uint64 & target)
     {
-	    source.get(&target, 8);
+        source.get(&target, 8);
         target = byteSwap(target);
     }
 
     inline void get(ByteStream::ReadIterator & source, int64 & target)
     {
-	    source.get(&target, 8);
+        source.get(&target, 8);
         target = byteSwap(target);
     }
 
     inline void get(ByteStream::ReadIterator & source, uint32 & target)
     {
-	    source.get(&target, 4);
+        source.get(&target, 4);
         target = byteSwap(target);
     }
 
     inline void get(ByteStream::ReadIterator & source, int32 & target)
     {
-	    source.get(&target, 4);
+        source.get(&target, 4);
         target = byteSwap(target);
     }
 
     inline void get(ByteStream::ReadIterator & source, uint16 & target)
     {
-	    source.get(&target, 2);
+        source.get(&target, 2);
         target = byteSwap(target);
     }
 
     inline void get(ByteStream::ReadIterator & source, int16 & target)
     {
-	    source.get(&target, 2);
+        source.get(&target, 2);
         target = byteSwap(target);
     }
 
     inline void get(ByteStream::ReadIterator & source, uint8 & target)
     {
-	    source.get(&target, 1);
+        source.get(&target, 1);
     }
 
     inline void get(ByteStream::ReadIterator & source, int8 & target)
     {
-	    source.get(&target, 1);
+        source.get(&target, 1);
     }
 
     inline void get(ByteStream::ReadIterator & source, unsigned char * const target, const unsigned int targetSize)
     {
-	    source.get(target, targetSize);
+        source.get(target, targetSize);
     }
 
     inline void get(ByteStream::ReadIterator & source, bool & target)
     {
-	    source.get(&target, 1);
+        source.get(&target, 1);
     }
 
 
@@ -582,8 +404,8 @@ const unsigned MAX_ARRAY_SIZE = 1024;
 
     inline void put(ByteStream & target, ByteStream::ReadIterator & source)
     {
-	    target.put(source.getBuffer(), source.getSize());
-	    source.advance(source.getSize());
+        target.put(source.getBuffer(), source.getSize());
+        source.advance(source.getSize());
     }
 
     inline void put(ByteStream & target, const double value)
@@ -646,24 +468,24 @@ const unsigned MAX_ARRAY_SIZE = 1024;
 
     inline void put(ByteStream & target, const bool & source)
     {
-	    target.put(&source, 1);
+        target.put(&source, 1);
     }
 
 
     inline void put(ByteStream & target, const unsigned char * const source, const unsigned int sourceSize)
     {
-	    target.put(source, sourceSize);
+        target.put(source, sourceSize);
     }
 
     inline void put(ByteStream & target, const ByteStream & source)
     {
-	    target.put(source.begin().getBuffer(), source.begin().getSize());
+        target.put(source.begin().getBuffer(), source.begin().getSize());
     }
 
     void get(ByteStream::ReadIterator & source, std::string & target);
     void put(ByteStream & target, const std::string & source);
 
-	
+
 ////////////////////////////////////////////////////////////////////////////////
 
 
@@ -727,20 +549,194 @@ const unsigned MAX_ARRAY_SIZE = 1024;
 
     inline bool overwriteEnd(ByteStream & target, const bool & source)
     {
-	    return target.overwriteEnd(&source, 1);
+        return target.overwriteEnd(&source, 1);
     }
 
     inline bool overwriteEnd(ByteStream & target, const unsigned char * const source, const unsigned int sourceSize)
     {
-	    return target.overwriteEnd(source, sourceSize);
+        return target.overwriteEnd(source, sourceSize);
     }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 
+    class AutoVariableBase
+    {
+        public:
+            AutoVariableBase();
+            virtual ~AutoVariableBase();
+
+            virtual void     pack(ByteStream & target) const = 0;
+            virtual void     unpack(ByteStream::ReadIterator & source) = 0;
+    };
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+    class AutoByteStream
+    {
+        public:
+            AutoByteStream();
+            virtual ~AutoByteStream();
+            void                 addVariable(AutoVariableBase & newVariable);
+            virtual const unsigned int getItemCount() const;
+            virtual void         pack(ByteStream & target) const;
+            virtual void         unpack(ByteStream::ReadIterator & source);
+        protected:
+            std::vector<AutoVariableBase *> members;
+        private:
+            AutoByteStream(const AutoByteStream & source);
+    };
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+    template<class ValueType>
+    class AutoVariable : public AutoVariableBase
+    {
+    public:
+        AutoVariable();
+        explicit AutoVariable(const ValueType & source);
+        virtual ~AutoVariable();
+
+        const ValueType & get() const;
+        virtual void      pack(ByteStream & target) const;
+        void              set(const ValueType & rhs);
+        virtual void      unpack(ByteStream::ReadIterator & source);
+
+    private:
+        ValueType        value;
+    };
+
+    template<class ValueType>
+    AutoVariable<ValueType>::AutoVariable() :
+        AutoVariableBase(),
+        value()
+    {
+    }
+
+    template<class ValueType>
+    AutoVariable<ValueType>::AutoVariable(const ValueType & source) :
+        AutoVariableBase(),
+        value(source)
+    {
+    }
+
+    template<class ValueType>
+    AutoVariable<ValueType>::~AutoVariable()
+    {
+    }
+
+    template<class ValueType>
+    const ValueType & AutoVariable<ValueType>::get() const
+    {
+        return value;
+    }
+
+    template<class ValueType>
+    void AutoVariable<ValueType>::pack(ByteStream & target) const
+    {
+        put(target, value);
+    }
+
+    template<class ValueType>
+    void AutoVariable<ValueType>::set(const ValueType & rhs)
+    {
+        value = rhs;
+    }
+
+    template<class ValueType>
+    void AutoVariable<ValueType>::unpack(ByteStream::ReadIterator & source)
+    {
+        get(source, value);
+    }
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+    template<class ValueType>
+    class AutoArray : public AutoVariableBase
+    {
+    public:
+        AutoArray();
+        AutoArray(const AutoArray & source);
+        ~AutoArray();
+
+        const std::vector<ValueType> & get() const;
+        void  set(const std::vector<ValueType> & source);
+
+        virtual void pack(ByteStream & target) const;
+        virtual void unpack(ByteStream::ReadIterator & source);
+
+    private:
+        std::vector<ValueType>  array;
+    };
+
+    template<class ValueType>
+    inline AutoArray<ValueType>::AutoArray()
+    {
+    }
+
+    template<class ValueType>
+    inline AutoArray<ValueType>::AutoArray(const AutoArray & source) :
+        array(source.array)
+    {
+    }
+
+    template<class ValueType>
+    inline AutoArray<ValueType>::~AutoArray()
+    {
+    }
+
+    template<class ValueType>
+    inline const std::vector<ValueType> & AutoArray<ValueType>::get() const
+    {
+        return array;
+    }
+
+    template<class ValueType>
+    inline void AutoArray<ValueType>::set(const std::vector<ValueType> & source)
+    {
+        array = source;
+    }
+
+    template<class ValueType>
+    inline void AutoArray<ValueType>::pack(ByteStream & target) const
+    {
+        unsigned int arraySize = array.size();
+        Base::put(target, arraySize);
+
+        typename std::vector<ValueType>::const_iterator i;
+        for(i = array.begin(); i != array.end(); ++i)
+        {
+            ValueType v = (*i);
+            Base::put(target, v);
+        }
+    }
+
+    template<class ValueType>
+    inline void AutoArray<ValueType>::unpack(ByteStream::ReadIterator & source)
+    {
+        unsigned int arraySize;
+        Base::get(source, arraySize);
+        ValueType v;
+
+        if (arraySize > MAX_ARRAY_SIZE)
+            arraySize = 0;
+
+        for(unsigned int i = 0; i < arraySize; ++i)
+        {
+            Base::get(source, v);
+            array.push_back(v);
+        }
+    }
+
 };
 #ifdef EXTERNAL_DISTRO
 };
 #endif
 
-#endif	
+#endif

external/ours/library/archive/src/shared/AutoDeltaByteStream.h

@@ -85,10 +85,10 @@ private:
 	only AutoDeltaByteStreams may interpret a delta package at run time.
 
 	AutoDeltaByteStream objects can also deserialize from ByteStream and
-	AutoByteStream objects using the unpack() method. To unpack a 
+	AutoByteStream objects using the unpack() method. To unpack a
 	delta ByteStream, AutoDeltaByteStream provides unpackDeltas().
 
-	AutoDeltaVariable objects, which are contained by a 
+	AutoDeltaVariable objects, which are contained by a
 	AutoDeltaByteStream, can set threshold values to trigger a
 	change (e.g. a value representing heading may need to change
 	by more than 3 degrees before the object is considered "changed").
@@ -131,20 +131,20 @@ private:
 	{
 		MyAutoDeltaByteStream a;
 		MyAutoDeltaByteStream b;
-		
+
 		a.setValue(2.0f);	// change of 2, not enough to trigger a delta
 		b.setValue(1.0f);
 
 		b.unpackDeltas(a.packDeltas());
 		assert(b.getValue() == 1.0f);	// no deltas from (a)
 
-		a.setValue(5.0f);	// large enough change 
+		a.setValue(5.0f);	// large enough change
 		b.unpackDeltas(a.packDeltas());
 		assert(b.getValue() == a.getValue() && b.getValue() == 5.0f);
 	}
 	\endcode
 
-	
+
 */
 class AutoDeltaByteStream : public AutoByteStream
 {
@@ -252,13 +252,13 @@ inline const unsigned short int AutoDeltaVariableBase::getIndex() const
 //-----------------------------------------------------------------------
 /**
 	@brief Get a pointer to this variable's owner ByteStream
-		
+
 	As the AutoDeltaVariableBase is used in a non-const
 	manner, it will insert itself into it's owner AutoDeltaByteStream::dirtyList
-	set. 
+	set.
 
 	When the AutoDeltaByteStream executes AutoDeltaByteStream::packDeltas(),
-	it will iterate through this set to determine which 
+	it will iterate through this set to determine which
 	variables may be dirty, invoke AutoDeltaVariableBase::isDirty() on
 	each variable in the set, and if it is dirty, include the value
 	in the ByteStream buffer.
@@ -305,7 +305,7 @@ inline void AutoDeltaVariableBase::setIndex(const unsigned short int newIndex)
 
 //-----------------------------------------------------------------------
 /**
-	@brief set the AutoDeltaVariableBase::owner member to the address of 
+	@brief set the AutoDeltaVariableBase::owner member to the address of
 	some AutoDeltaByteStream instance.
 
 	A AutoDeltaVariableBase or derived object must put itself on
@@ -346,10 +346,10 @@ inline void AutoDeltaVariableBase::touch()
 		MyAutoDeltaByteStream();
 		~MyAutoDeltaByteStream() {};
 
-		void      setValue(const int value) 
+		void      setValue(const int value)
 			{ i = value; };
 
-		const int getValue() const 
+		const int getValue() const
 			{ return i; };
 
 	private:
@@ -442,8 +442,8 @@ lastValue(ValueType())
 	@brief AutoDeltaVariable copy constructor
 
 	This copy constructor will perform a deep copy of the current
-	value from the source AutoDeltaVariable. It does not copy 
-	AutoDeltaVariableBase members such as the owner. The owner MUST 
+	value from the source AutoDeltaVariable. It does not copy
+	AutoDeltaVariableBase members such as the owner. The owner MUST
 	be set explicitly.
 
 	@author Justin Randall
@@ -473,7 +473,7 @@ lastValue(source.currentValue)
 	MyAutoDeltaByteStream::MyAutoDeltaByteStream()
 	{
 		// set myAutoInt current value to 35
-		myAutoInt(35); 
+		myAutoInt(35);
 		myAutoInt.setOwner(this);
 
 		// copy myAutoInt
@@ -521,7 +521,7 @@ inline AutoDeltaVariable<ValueType>::~AutoDeltaVariable()
 //-----------------------------------------------------------------------
 
 template<typename ValueType>
-inline AutoDeltaVariable<ValueType> & AutoDeltaVariable<ValueType>::operator =(const AutoDeltaVariable<ValueType> & rhs) 
+inline AutoDeltaVariable<ValueType> & AutoDeltaVariable<ValueType>::operator =(const AutoDeltaVariable<ValueType> & rhs)
 {
 	if(&rhs != this)
 		set(rhs.currentValue);
@@ -531,7 +531,7 @@ inline AutoDeltaVariable<ValueType> & AutoDeltaVariable<ValueType>::operator =(c
 //-----------------------------------------------------------------------
 
 template<typename ValueType>
-inline AutoDeltaVariable<ValueType> & AutoDeltaVariable<ValueType>::operator =(const ValueType & rhs) 
+inline AutoDeltaVariable<ValueType> & AutoDeltaVariable<ValueType>::operator =(const ValueType & rhs)
 {
 	if(rhs != currentValue)
 		set(rhs);
@@ -540,7 +540,7 @@ inline AutoDeltaVariable<ValueType> & AutoDeltaVariable<ValueType>::operator =(c
 
 //-----------------------------------------------------------------------
 /**
-	@brief assign the lastValue to the currentValue to avert isDirty() 
+	@brief assign the lastValue to the currentValue to avert isDirty()
 	returning true.
 
 	@author Justin Randall
@@ -578,7 +578,7 @@ inline const ValueType & AutoDeltaVariable<ValueType>::get() const
 
 	When a AutoDeltaVariable is used in a non-const manner, it is placed
 	on the AutoDeltaByteStream::dirtyList until AutoDeltaByteStream::packDeltas()
-	is invoked. All members on the list are checked to see if their value 
+	is invoked. All members on the list are checked to see if their value
 	has changed enough to warrant a new delta ByteStream.
 
 	Any change in values triggers isDirty() to return true.
@@ -629,7 +629,7 @@ inline const bool AutoDeltaVariable<ValueType>::isDirty() const
 template<typename ValueType>
 inline void AutoDeltaVariable<ValueType>::pack(ByteStream & target) const
 {
-	Archive::put(target, currentValue);
+	put(target, currentValue);
 }
 
 //-----------------------------------------------------------------------
@@ -672,7 +672,7 @@ inline void AutoDeltaVariable<ValueType>::set(const ValueType & source)
 	MUST contain the value -- that is, variables must be retrieve in the
 	order they were packed.
 
-	AutoByteStream classes and their derivatives automatically pack and 
+	AutoByteStream classes and their derivatives automatically pack and
 	unpack data in the correct order. This protected method is visible
 	only to ByteStreams.
 
@@ -691,7 +691,8 @@ inline void AutoDeltaVariable<ValueType>::set(const ValueType & source)
 template<typename ValueType>
 inline void AutoDeltaVariable<ValueType>::unpack(ReadIterator & source)
 {
-	Archive::get(source, currentValue);
+	using Archive::get;
+	get(source, currentValue);
 	clearDelta();
 }
 
@@ -700,7 +701,8 @@ inline void AutoDeltaVariable<ValueType>::unpack(ReadIterator & source)
 template<typename ValueType>
 inline void AutoDeltaVariable<ValueType>::unpackDelta(ReadIterator & source)
 {
-	Archive::get(source, currentValue);
+	using Archive::get;
+	get(source, currentValue);
 	touch();
 }