diff --git a/engine/server/application/CentralServer/src/shared/AuctionTransferGameAPI/Base/Archive.h b/engine/server/application/CentralServer/src/shared/AuctionTransferGameAPI/Base/Archive.h index f12fb37d..a15f6cba 100644 --- a/engine/server/application/CentralServer/src/shared/AuctionTransferGameAPI/Base/Archive.h +++ b/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 @@ -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::iterator i; - for(i = freeList.begin(); i != freeList.end(); ++i) - { - delete (*i); - } - }; - std::vector 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::iterator i; + for(i = freeList.begin(); i != freeList.end(); ++i) + { + delete (*i); + } + }; + std::vector freeList; + }; + Data(); //explicit Data(unsigned char * buffer); - static std::vector & getDataFreeList(); - static void releaseOldData(Data * oldData); - private: - int refCount; - }; + static std::vector & 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::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 members; - private: - AutoByteStream(const AutoByteStream & source); - }; - - -//////////////////////////////////////////////////////////////////////////////// - - - template - 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 - AutoVariable::AutoVariable() : - AutoVariableBase(), - value() - { - } - - template - AutoVariable::AutoVariable(const ValueType & source) : - AutoVariableBase(), - value(source) - { - } - - template - AutoVariable::~AutoVariable() - { - } - - template - const ValueType & AutoVariable::get() const - { - return value; - } - - template - void AutoVariable::pack(ByteStream & target) const - { - Base::put(target, value); - } - - template - void AutoVariable::set(const ValueType & rhs) - { - value = rhs; - } - - template - void AutoVariable::unpack(ByteStream::ReadIterator & source) - { - Base::get(source, value); - } - - -//////////////////////////////////////////////////////////////////////////////// - - - template - class AutoArray : public AutoVariableBase - { - public: - AutoArray(); - AutoArray(const AutoArray & source); - ~AutoArray(); - - const std::vector & get() const; - void set(const std::vector & source); - - virtual void pack(ByteStream & target) const; - virtual void unpack(ByteStream::ReadIterator & source); - - private: - std::vector array; - }; - - template - inline AutoArray::AutoArray() - { - } - - template - inline AutoArray::AutoArray(const AutoArray & source) : - array(source.array) - { - } - - template - inline AutoArray::~AutoArray() - { - } - - template - inline const std::vector & AutoArray::get() const - { - return array; - } - - template - inline void AutoArray::set(const std::vector & source) - { - array = source; - } - - template - inline void AutoArray::pack(ByteStream & target) const - { - unsigned int arraySize = array.size(); - Base::put(target, arraySize); - - typename std::vector::const_iterator i; - for(i = array.begin(); i != array.end(); ++i) - { - ValueType v = (*i); - Base::put(target, v); - } - } - - template - inline void AutoArray::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 members; + private: + AutoByteStream(const AutoByteStream & source); + }; + + +//////////////////////////////////////////////////////////////////////////////// + + + template + 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 + AutoVariable::AutoVariable() : + AutoVariableBase(), + value() + { + } + + template + AutoVariable::AutoVariable(const ValueType & source) : + AutoVariableBase(), + value(source) + { + } + + template + AutoVariable::~AutoVariable() + { + } + + template + const ValueType & AutoVariable::get() const + { + return value; + } + + template + void AutoVariable::pack(ByteStream & target) const + { + put(target, value); + } + + template + void AutoVariable::set(const ValueType & rhs) + { + value = rhs; + } + + template + void AutoVariable::unpack(ByteStream::ReadIterator & source) + { + get(source, value); + } + + +//////////////////////////////////////////////////////////////////////////////// + + + template + class AutoArray : public AutoVariableBase + { + public: + AutoArray(); + AutoArray(const AutoArray & source); + ~AutoArray(); + + const std::vector & get() const; + void set(const std::vector & source); + + virtual void pack(ByteStream & target) const; + virtual void unpack(ByteStream::ReadIterator & source); + + private: + std::vector array; + }; + + template + inline AutoArray::AutoArray() + { + } + + template + inline AutoArray::AutoArray(const AutoArray & source) : + array(source.array) + { + } + + template + inline AutoArray::~AutoArray() + { + } + + template + inline const std::vector & AutoArray::get() const + { + return array; + } + + template + inline void AutoArray::set(const std::vector & source) + { + array = source; + } + + template + inline void AutoArray::pack(ByteStream & target) const + { + unsigned int arraySize = array.size(); + Base::put(target, arraySize); + + typename std::vector::const_iterator i; + for(i = array.begin(); i != array.end(); ++i) + { + ValueType v = (*i); + Base::put(target, v); + } + } + + template + inline void AutoArray::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 diff --git a/external/ours/library/archive/src/shared/AutoDeltaByteStream.h b/external/ours/library/archive/src/shared/AutoDeltaByteStream.h index e8821a74..53b4d07d 100644 --- a/external/ours/library/archive/src/shared/AutoDeltaByteStream.h +++ b/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::~AutoDeltaVariable() //----------------------------------------------------------------------- template -inline AutoDeltaVariable & AutoDeltaVariable::operator =(const AutoDeltaVariable & rhs) +inline AutoDeltaVariable & AutoDeltaVariable::operator =(const AutoDeltaVariable & rhs) { if(&rhs != this) set(rhs.currentValue); @@ -531,7 +531,7 @@ inline AutoDeltaVariable & AutoDeltaVariable::operator =(c //----------------------------------------------------------------------- template -inline AutoDeltaVariable & AutoDeltaVariable::operator =(const ValueType & rhs) +inline AutoDeltaVariable & AutoDeltaVariable::operator =(const ValueType & rhs) { if(rhs != currentValue) set(rhs); @@ -540,7 +540,7 @@ inline AutoDeltaVariable & AutoDeltaVariable::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::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::isDirty() const template inline void AutoDeltaVariable::pack(ByteStream & target) const { - Archive::put(target, currentValue); + put(target, currentValue); } //----------------------------------------------------------------------- @@ -672,7 +672,7 @@ inline void AutoDeltaVariable::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::set(const ValueType & source) template inline void AutoDeltaVariable::unpack(ReadIterator & source) { - Archive::get(source, currentValue); + using Archive::get; + get(source, currentValue); clearDelta(); } @@ -700,7 +701,8 @@ inline void AutoDeltaVariable::unpack(ReadIterator & source) template inline void AutoDeltaVariable::unpackDelta(ReadIterator & source) { - Archive::get(source, currentValue); + using Archive::get; + get(source, currentValue); touch(); }