165 lines
4.8 KiB
C++
165 lines
4.8 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
// Utilities for serialization/unserialization buffer
|
|
//=============================================================================//
|
|
|
|
#ifndef UTLBUFFERUTIL_H
|
|
#define UTLBUFFERUTIL_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "tier1/utlbuffer.h"
|
|
#include "tier1/utlvector.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
class Vector2D;
|
|
class Vector;
|
|
class Vector4D;
|
|
class QAngle;
|
|
class Quaternion;
|
|
class VMatrix;
|
|
class Color;
|
|
class CUtlBinaryBlock;
|
|
class CUtlString;
|
|
class CUtlCharConversion;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// For string serialization, set the delimiter rules
|
|
//-----------------------------------------------------------------------------
|
|
void SetSerializationDelimiter(CUtlCharConversion *pConv);
|
|
void SetSerializationArrayDelimiter(const char *pDelimiter);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Standard serialization methods for basic types
|
|
//-----------------------------------------------------------------------------
|
|
bool Serialize(CUtlBuffer &buf, const bool &src);
|
|
bool Unserialize(CUtlBuffer &buf, bool &dest);
|
|
|
|
bool Serialize(CUtlBuffer &buf, const int &src);
|
|
bool Unserialize(CUtlBuffer &buf, int &dest);
|
|
|
|
bool Serialize(CUtlBuffer &buf, const float &src);
|
|
bool Unserialize(CUtlBuffer &buf, float &dest);
|
|
|
|
bool Serialize(CUtlBuffer &buf, const Vector2D &src);
|
|
bool Unserialize(CUtlBuffer &buf, Vector2D &dest);
|
|
|
|
bool Serialize(CUtlBuffer &buf, const Vector &src);
|
|
bool Unserialize(CUtlBuffer &buf, Vector &dest);
|
|
|
|
bool Serialize(CUtlBuffer &buf, const Vector4D &src);
|
|
bool Unserialize(CUtlBuffer &buf, Vector4D &dest);
|
|
|
|
bool Serialize(CUtlBuffer &buf, const QAngle &src);
|
|
bool Unserialize(CUtlBuffer &buf, QAngle &dest);
|
|
|
|
bool Serialize(CUtlBuffer &buf, const Quaternion &src);
|
|
bool Unserialize(CUtlBuffer &buf, Quaternion &dest);
|
|
|
|
bool Serialize(CUtlBuffer &buf, const VMatrix &src);
|
|
bool Unserialize(CUtlBuffer &buf, VMatrix &dest);
|
|
|
|
bool Serialize(CUtlBuffer &buf, const Color &src);
|
|
bool Unserialize(CUtlBuffer &buf, Color &dest);
|
|
|
|
bool Serialize(CUtlBuffer &buf, const CUtlBinaryBlock &src);
|
|
bool Unserialize(CUtlBuffer &buf, CUtlBinaryBlock &dest);
|
|
|
|
bool Serialize(CUtlBuffer &buf, const CUtlString &src);
|
|
bool Unserialize(CUtlBuffer &buf, CUtlString &dest);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// You can use this to check if a type serializes on multiple lines
|
|
//-----------------------------------------------------------------------------
|
|
template <class T>
|
|
inline bool SerializesOnMultipleLines() {
|
|
return false;
|
|
}
|
|
|
|
template <>
|
|
inline bool SerializesOnMultipleLines<VMatrix>() {
|
|
return true;
|
|
}
|
|
|
|
template <>
|
|
inline bool SerializesOnMultipleLines<CUtlBinaryBlock>() {
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Vector serialization
|
|
//-----------------------------------------------------------------------------
|
|
template <class T>
|
|
bool Serialize(CUtlBuffer &buf, const CUtlVector<T> &src) {
|
|
extern const char *s_pUtlBufferUtilArrayDelim;
|
|
|
|
int nCount = src.Count();
|
|
|
|
if (!buf.IsText()) {
|
|
buf.PutInt(nCount);
|
|
for (int i = 0; i < nCount; ++i) {
|
|
::Serialize(buf, src[i]);
|
|
}
|
|
return buf.IsValid();
|
|
}
|
|
|
|
if (!SerializesOnMultipleLines<T>()) {
|
|
buf.PutChar('\n');
|
|
for (int i = 0; i < nCount; ++i) {
|
|
::Serialize(buf, src[i]);
|
|
if (s_pUtlBufferUtilArrayDelim && (i != nCount - 1)) {
|
|
buf.PutString(s_pUtlBufferUtilArrayDelim);
|
|
}
|
|
buf.PutChar('\n');
|
|
}
|
|
} else {
|
|
for (int i = 0; i < nCount; ++i) {
|
|
::Serialize(buf, src[i]);
|
|
if (s_pUtlBufferUtilArrayDelim && (i != nCount - 1)) {
|
|
buf.PutString(s_pUtlBufferUtilArrayDelim);
|
|
}
|
|
buf.PutChar(' ');
|
|
}
|
|
}
|
|
|
|
return buf.IsValid();
|
|
}
|
|
|
|
template <class T>
|
|
bool Unserialize(CUtlBuffer &buf, CUtlVector<T> &dest) {
|
|
dest.RemoveAll();
|
|
|
|
MEM_ALLOC_CREDIT_FUNCTION();
|
|
|
|
if (!buf.IsText()) {
|
|
int nCount = buf.GetInt();
|
|
if (nCount) {
|
|
dest.EnsureCapacity(nCount);
|
|
for (int i = 0; i < nCount; ++i) {
|
|
VerifyEquals(dest.AddToTail(), i);
|
|
if (!::Unserialize(buf, dest[i])) return false;
|
|
}
|
|
}
|
|
return buf.IsValid();
|
|
}
|
|
|
|
while (true) {
|
|
buf.EatWhiteSpace();
|
|
if (!buf.IsValid()) break;
|
|
|
|
int i = dest.AddToTail();
|
|
if (!::Unserialize(buf, dest[i])) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endif // UTLBUFFERUTIL_H
|