expvintl/source-engine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
18051fd0de
source-engine/gcsdk/webapi_response.cpp

2563 lines
76 KiB
C++
Raw Normal View History

1
2020-04-23 00:56:21 +08:00
//========= Copyright <20> 1996-2010, Valve LLC, All rights reserved. ============
//
// Purpose: Implementation for CWebAPIResponse objects
//
//=============================================================================
#include "stdafx.h"
#include "thirdparty/JSON_parser/JSON_parser.h"
using namespace GCSDK;
#include "tier0/memdbgoff.h"
// !FIXME! DOTAMERGE
//IMPLEMENT_CLASS_MEMPOOL_MT( CWebAPIValues, 1000, UTLMEMORYPOOL_GROW_SLOW );
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
//-----------------------------------------------------------------------------
// Purpose: Helper for emitting properly escaped json string values
//-----------------------------------------------------------------------------
void EmitJSONString( CUtlBuffer &outputBuffer, const char *pchValue )
{
outputBuffer.PutChar( '"' );
if ( pchValue )
{
int i = 0;
while( pchValue[i] )
{
switch ( pchValue[i] )
{
case '"':
outputBuffer.Put( "\\\"", 2 );
break;
case '\\':
outputBuffer.Put( "\\\\", 2 );
break;
case '\n':
outputBuffer.Put( "\\n", 2 );
break;
case '\r':
outputBuffer.Put( "\\r", 2 );
break;
case '\t':
outputBuffer.Put( "\\t", 2 );
break;
default:
if ( (uint8) pchValue[i] < 32 )
{
outputBuffer.Put( "\\u00", 4 );
outputBuffer.PutChar( ( pchValue[i] & 16 ) ? '1' : '0' );
outputBuffer.PutChar( "0123456789abcdef"[ pchValue[i] & 0xF ] );
}
else
{
outputBuffer.PutChar( pchValue[i] );
}
}
++i;
}
}
outputBuffer.PutChar( '"' );
}
//-----------------------------------------------------------------------------
// Purpose: Helper for emitting properly escaped XML string values, we always use UTF8,
// so we only really need to encode & ' " < >
//-----------------------------------------------------------------------------
void EmitXMLString( CUtlBuffer &outputBuffer, const char *pchValue )
{
if ( pchValue )
{
int i = 0;
while( pchValue[i] )
{
switch ( pchValue[i] )
{
case '&':
outputBuffer.Put( "&amp;", 5 );
break;
case '\'':
outputBuffer.Put( "&apos;", 6 );
break;
case '"':
outputBuffer.Put( "&quot;", 6 );
break;
case '<':
outputBuffer.Put( "&lt;", 4 );
break;
case '>':
outputBuffer.Put( "&gt;", 4 );
break;
default:
outputBuffer.PutChar( pchValue[i] );
}
++i;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Helper for emitting properly escaped VDF string values, we always use UTF8,
// and we escape only " and \
//-----------------------------------------------------------------------------
void EmitVDFString( CUtlBuffer &outputBuffer, const char *pchValue )
{
outputBuffer.PutChar( '"' );
if ( pchValue )
{
int i = 0;
while( pchValue[i] )
{
switch ( pchValue[i] )
{
case '\\':
outputBuffer.Put( "\\\\", 2 );
break;
case '"':
outputBuffer.Put( "\\\"", 2 );
break;
default:
outputBuffer.PutChar( pchValue[i] );
}
++i;
}
}
outputBuffer.PutChar( '"' );
}
namespace GCSDK
{
enum { k_LineBreakEveryNGroups = 18 }; // line break every 18 groups of 4 characters (every 72 characters)
uint32 Base64EncodeMaxOutput( const uint32 cubData, const char *pszLineBreak )
{
// terminating null + 4 chars per 3-byte group + line break after every 18 groups (72 output chars) + final line break
uint32 nGroups = (cubData+2)/3;
uint32 cchRequired = 1 + nGroups*4 + ( pszLineBreak ? Q_strlen(pszLineBreak)*(1+(nGroups-1)/k_LineBreakEveryNGroups) : 0 );
return cchRequired;
}
bool Base64Encode( const uint8 *pubData, uint32 cubData, char *pchEncodedData, uint32 *pcchEncodedData, const char *pszLineBreak )
{
if ( pchEncodedData == NULL )
{
AssertMsg( *pcchEncodedData == 0, "NULL output buffer with non-zero size passed to Base64Encode" );
*pcchEncodedData = Base64EncodeMaxOutput( cubData, pszLineBreak );
return true;
}
const uint8 *pubDataEnd = pubData + cubData;
char *pchEncodedDataStart = pchEncodedData;
uint32 unLineBreakLen = pszLineBreak ? Q_strlen( pszLineBreak ) : 0;
int nNextLineBreak = unLineBreakLen ? k_LineBreakEveryNGroups : INT_MAX;
const char * const pszBase64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
uint32 cchEncodedData = *pcchEncodedData;
if ( cchEncodedData == 0 )
goto out_of_space;
--cchEncodedData; // pre-decrement for the terminating null so we don't forget about it
// input 3 x 8-bit, output 4 x 6-bit
while ( pubDataEnd - pubData >= 3 )
{
if ( cchEncodedData < 4 + unLineBreakLen )
goto out_of_space;
if ( nNextLineBreak == 0 )
{
memcpy( pchEncodedData, pszLineBreak, unLineBreakLen );
pchEncodedData += unLineBreakLen;
cchEncodedData -= unLineBreakLen;
nNextLineBreak = k_LineBreakEveryNGroups;
}
uint32 un24BitsData;
un24BitsData = (uint32) pubData[0] << 16;
un24BitsData |= (uint32) pubData[1] << 8;
un24BitsData |= (uint32) pubData[2];
pubData += 3;
pchEncodedData[0] = pszBase64Chars[ (un24BitsData >> 18) & 63 ];
pchEncodedData[1] = pszBase64Chars[ (un24BitsData >> 12) & 63 ];
pchEncodedData[2] = pszBase64Chars[ (un24BitsData >> 6) & 63 ];
pchEncodedData[3] = pszBase64Chars[ (un24BitsData ) & 63 ];
pchEncodedData += 4;
cchEncodedData -= 4;
--nNextLineBreak;
}
// Clean up remaining 1 or 2 bytes of input, pad output with '='
if ( pubData != pubDataEnd )
{
if ( cchEncodedData < 4 + unLineBreakLen )
goto out_of_space;
if ( nNextLineBreak == 0 )
{
memcpy( pchEncodedData, pszLineBreak, unLineBreakLen );
pchEncodedData += unLineBreakLen;
cchEncodedData -= unLineBreakLen;
}
uint32 un24BitsData;
un24BitsData = (uint32) pubData[0] << 16;
if ( pubData+1 != pubDataEnd )
{
un24BitsData |= (uint32) pubData[1] << 8;
}
pchEncodedData[0] = pszBase64Chars[ (un24BitsData >> 18) & 63 ];
pchEncodedData[1] = pszBase64Chars[ (un24BitsData >> 12) & 63 ];
pchEncodedData[2] = pubData+1 != pubDataEnd ? pszBase64Chars[ (un24BitsData >> 6) & 63 ] : '=';
pchEncodedData[3] = '=';
pchEncodedData += 4;
cchEncodedData -= 4;
}
if ( unLineBreakLen )
{
if ( cchEncodedData < unLineBreakLen )
goto out_of_space;
memcpy( pchEncodedData, pszLineBreak, unLineBreakLen );
pchEncodedData += unLineBreakLen;
cchEncodedData -= unLineBreakLen;
}
*pchEncodedData = 0;
*pcchEncodedData = pchEncodedData - pchEncodedDataStart;
return true;
out_of_space:
*pchEncodedData = 0;
*pcchEncodedData = Base64EncodeMaxOutput( cubData, pszLineBreak );
AssertMsg( false, "CCrypto::Base64Encode: insufficient output buffer (up to n*4/3+5 bytes required, plus linebreaks)" );
return false;
}
bool Base64Decode( const char *pchData, uint32 cchDataMax, uint8 *pubDecodedData, uint32 *pcubDecodedData, bool bIgnoreInvalidCharacters )
{
uint32 cubDecodedData = *pcubDecodedData;
uint32 cubDecodedDataOrig = cubDecodedData;
if ( pubDecodedData == NULL )
{
AssertMsg( *pcubDecodedData == 0, "NULL output buffer with non-zero size passed to Base64Decode" );
cubDecodedDataOrig = cubDecodedData = ~0u;
}
// valid base64 character range: '+' (0x2B) to 'z' (0x7A)
// table entries are 0-63, -1 for invalid entries, -2 for '='
static const char rgchInvBase64[] = {
62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
-1, -1, -1, -2, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
47, 48, 49, 50, 51
};
COMPILE_TIME_ASSERT( Q_ARRAYSIZE(rgchInvBase64) == 0x7A - 0x2B + 1 );
uint32 un24BitsWithSentinel = 1;
while ( cchDataMax-- > 0 )
{
char c = *pchData++;
if ( (uint8)(c - 0x2B) >= Q_ARRAYSIZE( rgchInvBase64 ) )
{
if ( c == '\0' )
break;
if ( !bIgnoreInvalidCharacters && !( c == '\r' || c == '\n' || c == '\t' || c == ' ' ) )
goto decode_failed;
else
continue;
}
c = rgchInvBase64[(uint8)(c - 0x2B)];
if ( c < 0 )
{
if ( c == -2 ) // -2 -> terminating '='
break;
if ( !bIgnoreInvalidCharacters )
goto decode_failed;
else
continue;
}
un24BitsWithSentinel <<= 6;
un24BitsWithSentinel |= c;
if ( un24BitsWithSentinel & (1<<24) )
{
if ( cubDecodedData < 3 ) // out of space? go to final write logic
break;
if ( pubDecodedData )
{
pubDecodedData[0] = (uint8)( un24BitsWithSentinel >> 16 );
pubDecodedData[1] = (uint8)( un24BitsWithSentinel >> 8);
pubDecodedData[2] = (uint8)( un24BitsWithSentinel );
pubDecodedData += 3;
}
cubDecodedData -= 3;
un24BitsWithSentinel = 1;
}
}
// If un24BitsWithSentinel contains data, output the remaining full bytes
if ( un24BitsWithSentinel >= (1<<6) )
{
// Possibilities are 3, 2, 1, or 0 full output bytes.
int nWriteBytes = 3;
while ( un24BitsWithSentinel < (1<<24) )
{
nWriteBytes--;
un24BitsWithSentinel <<= 6;
}
// Write completed bytes to output
while ( nWriteBytes-- > 0 )
{
if ( cubDecodedData == 0 )
{
AssertMsg( false, "CCrypto::Base64Decode: insufficient output buffer (up to n*3/4+2 bytes required)" );
goto decode_failed;
}
if ( pubDecodedData )
{
*pubDecodedData++ = (uint8)(un24BitsWithSentinel >> 16);
}
--cubDecodedData;
un24BitsWithSentinel <<= 8;
}
}
*pcubDecodedData = cubDecodedDataOrig - cubDecodedData;
return true;
decode_failed:
*pcubDecodedData = cubDecodedDataOrig - cubDecodedData;
return false;
}
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CWebAPIResponse::CWebAPIResponse()
{
m_pValues = NULL;
m_unExpirationSeconds = 0;
m_rtLastModified = 0;
m_bExtendedArrays = false;
m_bJSONAnonymousRootNode = false;
m_eStatusCode = k_EHTTPStatusCode500InternalServerError;
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CWebAPIResponse::~CWebAPIResponse()
{
if ( m_pValues)
delete m_pValues;
m_pValues = NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Outputs formatted data to buffer
//-----------------------------------------------------------------------------
bool CWebAPIResponse::BEmitFormattedOutput( EWebAPIOutputFormat eFormat, CUtlBuffer &outputBuffer, size_t unMaxResultSize )
{
VPROF_BUDGET( "CWebAPIResponse::BEmitFormattedOutput", VPROF_BUDGETGROUP_STEAM );
outputBuffer.Clear();
switch( eFormat )
{
case k_EWebAPIOutputFormat_JSON:
return BEmitJSON( outputBuffer, unMaxResultSize );
case k_EWebAPIOutputFormat_XML:
return BEmitXML( outputBuffer, unMaxResultSize );
case k_EWebAPIOutputFormat_VDF:
return BEmitVDF( outputBuffer, unMaxResultSize );
case k_EWebAPIOutputFormat_ParameterEncoding:
return BEmitParameterEncoding( outputBuffer );
default:
return false;
}
}
//-----------------------------------------------------------------------------
// Purpose: Emits JSON formatted representation of response
//-----------------------------------------------------------------------------
bool CWebAPIResponse::BEmitJSON( CUtlBuffer &outputBuffer, size_t unMaxResultSize )
{
outputBuffer.PutChar( '{' );
outputBuffer.PutChar( '\n' );
CWebAPIValues *pValues = m_pValues;
//if we have an anonymous root, get the first child instead of the root itself
if ( m_bJSONAnonymousRootNode && m_pValues )
{
pValues = m_pValues->GetFirstChild();
}
if ( pValues )
{
if( !CWebAPIValues::BEmitJSONRecursive( pValues, outputBuffer, 1, unMaxResultSize, m_bExtendedArrays ) )
return false;
}
outputBuffer.PutChar( '\n' );
outputBuffer.PutChar( '}' );
if ( !outputBuffer.IsValid() )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Emits KeyValues .vdf style formatted representation of response
//-----------------------------------------------------------------------------
bool CWebAPIResponse::BEmitVDF( CUtlBuffer &outputBuffer, size_t unMaxResultSize )
{
if ( m_pValues )
if( !CWebAPIValues::BEmitVDFRecursive( m_pValues, outputBuffer, 0, 0, unMaxResultSize, m_bExtendedArrays ) )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Emits XML formatted representation of response
//-----------------------------------------------------------------------------
bool CWebAPIResponse::BEmitXML( CUtlBuffer &outputBuffer, size_t unMaxResultSize )
{
const char *pchProlog = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
outputBuffer.Put( pchProlog, Q_strlen( pchProlog ) );
outputBuffer.Put( "<!DOCTYPE ", Q_strlen( "<!DOCTYPE " ) );
if ( m_pValues && m_pValues->GetName() )
EmitXMLString( outputBuffer, m_pValues->GetName() );
outputBuffer.PutChar('>');
outputBuffer.PutChar('\n');
if ( m_pValues )
if( !CWebAPIValues::BEmitXMLRecursive( m_pValues, outputBuffer, 0, unMaxResultSize ) )
return false;
if ( !outputBuffer.IsValid() )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Emits Parameter Encoding formatted representation of response
//-----------------------------------------------------------------------------
bool CWebAPIResponse::BEmitParameterEncoding( CUtlBuffer &outputBuffer )
{
if ( !m_pValues )
return true;
CWebAPIValues *pValue = m_pValues->GetFirstChild();
while ( pValue != NULL )
{
outputBuffer.Put( pValue->GetName(), Q_strlen( pValue->GetName() ) );
outputBuffer.Put( "=", 1 );
CUtlString sValue;
switch ( pValue->GetType() )
{
case k_EWebAPIValueType_Object:
Assert( false );
return false; // no cursive values
case k_EWebAPIValueType_NumericArray:
Assert( false );
return false; // no arrays
case k_EWebAPIValueType_BinaryBlob:
Assert( false );
return false; // no binary
case k_EWebAPIValueType_Int32:
sValue = CNumStr( pValue->GetInt32Value() );
break;
case k_EWebAPIValueType_Int64:
sValue = CNumStr( pValue->GetInt64Value() );
break;
case k_EWebAPIValueType_UInt32:
sValue = CNumStr( pValue->GetUInt32Value() );
break;
case k_EWebAPIValueType_UInt64:
sValue = CNumStr( pValue->GetUInt64Value() );
break;
case k_EWebAPIValueType_Double:
sValue = CNumStr( pValue->GetDoubleValue() );
break;
case k_EWebAPIValueType_String:
pValue->GetStringValue( sValue );
break;
case k_EWebAPIValueType_Bool:
sValue = CNumStr( pValue->GetBoolValue() );
break;
}
outputBuffer.Put( sValue, sValue.Length() );
pValue = pValue->GetNextChild();
if ( pValue )
outputBuffer.Put( "&", 1 );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Resets the response to be empty
//-----------------------------------------------------------------------------
void CWebAPIResponse::Clear()
{
if ( m_pValues )
delete m_pValues;
m_pValues = NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Access the root value element in the response
//-----------------------------------------------------------------------------
CWebAPIValues *CWebAPIResponse::CreateRootValue( const char *pchName )
{
if ( m_pValues )
{
AssertMsg( false, "CWwebAPIResponse::CreateRootValue called while root already existed." );
Clear();
}
m_pValues = new CWebAPIValues( pchName );
return m_pValues;
}
//----------------------------------------------------------------------------
// Purpose: Gets a singleton buffer pool for webapi values
//----------------------------------------------------------------------------
#ifdef GC
static GCConVar webapi_values_max_pool_size_mb( "webapi_values_max_pool_size_mb", "10", "Maximum size in bytes of the WebAPIValues buffer pool" );
static GCConVar webapi_values_init_buffer_size( "webapi_values_init_buffer_size", "65536", "Initial buffer size for buffers in the WebAPIValues buffer pool" );
/*static*/ CBufferPoolMT &CWebAPIValues::GetBufferPool()
{
static CBufferPoolMT s_bufferPool( "WebAPIValues", webapi_values_max_pool_size_mb, webapi_values_init_buffer_size );
return s_bufferPool;
}
#endif
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CWebAPIValues::CWebAPIValues( CWebAPIValues *pParent, const char *pchName, EWebAPIValueType eValueType, const char *pchArrayElementNames )
{
InitInternal( pParent, -1, eValueType, pchArrayElementNames );
SetName( pchName );
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CWebAPIValues::CWebAPIValues( const char *pchName )
{
InitInternal( NULL, -1, k_EWebAPIValueType_Object, NULL );
SetName( pchName );
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CWebAPIValues::CWebAPIValues( const char *pchName, const char *pchArrayElementNames )
{
InitInternal( NULL, -1, k_EWebAPIValueType_NumericArray, pchArrayElementNames );
SetName( pchName );
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CWebAPIValues::CWebAPIValues( CWebAPIValues *pParent, int nNamePos, EWebAPIValueType eValueType, const char *pchArrayElementNames )
{
InitInternal( pParent, nNamePos, eValueType, pchArrayElementNames );
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
void CWebAPIValues::InitInternal( CWebAPIValues *pParent, int nNamePos, EWebAPIValueType eValueType, const char *pchArrayElementNames )
{
if ( NULL == pParent )
{
#ifdef GC
m_pStringBuffer = GetBufferPool().GetBuffer();
#else
m_pStringBuffer = new CUtlBuffer;
#endif
}
else
{
m_pStringBuffer = pParent->m_pStringBuffer;
}
m_nNamePos = nNamePos;
m_eValueType = eValueType;
if ( m_eValueType == k_EWebAPIValueType_NumericArray )
{
Assert( pchArrayElementNames );
m_nArrayChildElementNamePos = m_pStringBuffer->TellPut();
m_pStringBuffer->PutString( pchArrayElementNames );
}
m_pFirstChild = NULL;
m_pLastChild = NULL;
m_pNextPeer = NULL;
m_pParent = pParent;
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CWebAPIValues::~CWebAPIValues()
{
ClearValue();
CWebAPIValues *pChild = m_pFirstChild;
while( pChild )
{
CWebAPIValues *pDelete = pChild;
pChild = pChild->m_pNextPeer;
delete pDelete;
}
m_pFirstChild = NULL;
m_pNextPeer = NULL;
if ( NULL == m_pParent )
{
#ifdef GC
GetBufferPool().ReturnBuffer( m_pStringBuffer );
#else
delete m_pStringBuffer;
#endif
}
// This two ptrs are just for optimized traversal at runtime, deleting just
// our first child and next peer will lead to the full tree being deleted correctly.
m_pLastChild = NULL;
m_pParent = NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Sets the name of the values node
//-----------------------------------------------------------------------------
void CWebAPIValues::SetName( const char * pchName )
{
if ( pchName == NULL )
{
AssertMsg( false, "CWebAPIValues constructed with NULL name, breaks some output serialization. Shouldn't do this." );
m_nNamePos = -1;
}
else
{
// Shouldn't use ', ", &, <, or > in names since they can't output well in XML. : is no good since it implies namespacing in XML.
// Assert about it so we don't end up with responses that are badly formed in XML output.
int unLen = 0;
while ( pchName[unLen] != 0 )
{
if ( pchName[unLen] == '\'' || pchName[unLen] == '"' || pchName[unLen] == '&'
|| pchName[unLen] == '>' || pchName[unLen] == '>' || pchName[unLen] == ':' )
{
AssertMsg( false, "Shouldn't use any of '\"&<>: in CWebAPIValues node names, you used %s", pchName );
break;
}
++unLen;
}
m_nNamePos = m_pStringBuffer->TellPut();
m_pStringBuffer->PutString( pchName );
}
}
//-----------------------------------------------------------------------------
// Purpose: Assert that we don't have any child nodes, this is used when setting a
// native type value. We don't support having both our own value and children. You
// are either an array of more values, or you are a value yourself.
//-----------------------------------------------------------------------------
void CWebAPIValues::AssertNoChildren()
{
AssertMsg( m_pFirstChild == NULL, "CWebAPIValues has child nodes, but you are trying to set a direct value for it. Can't have both children and your own value." );
}
//-----------------------------------------------------------------------------
// Purpose: Clears any existing value, freeing memory if needed
//-----------------------------------------------------------------------------
void CWebAPIValues::ClearValue()
{
m_eValueType = k_EWebAPIValueType_Object;
}
//-----------------------------------------------------------------------------
// Purpose: Setter
//-----------------------------------------------------------------------------
void CWebAPIValues::SetStringValue( const char *pchValue )
{
ClearValue();
AssertNoChildren();
m_eValueType = k_EWebAPIValueType_String;
if ( pchValue == NULL )
{
m_nStrValuePos = -1;
}
else
{
m_nStrValuePos = m_pStringBuffer->TellPut();
m_pStringBuffer->PutString( pchValue );
}
}
//-----------------------------------------------------------------------------
// Purpose: Setter
//-----------------------------------------------------------------------------
void CWebAPIValues::SetInt32Value( int32 nValue )
{
ClearValue();
AssertNoChildren();
m_eValueType = k_EWebAPIValueType_Int32;
m_nValue = nValue;
}
//-----------------------------------------------------------------------------
// Purpose: Setter
//-----------------------------------------------------------------------------
void CWebAPIValues::SetUInt32Value( uint32 unValue )
{
ClearValue();
AssertNoChildren();
m_eValueType = k_EWebAPIValueType_UInt32;
m_unValue = unValue;
}
//-----------------------------------------------------------------------------
// Purpose: Setter
//-----------------------------------------------------------------------------
void CWebAPIValues::SetInt64Value ( int64 lValue )
{
ClearValue();
AssertNoChildren();
m_eValueType = k_EWebAPIValueType_Int64;
m_lValue = lValue;
}
//-----------------------------------------------------------------------------
// Purpose: Setter
//-----------------------------------------------------------------------------
void CWebAPIValues::SetUInt64Value( uint64 ulValue )
{
ClearValue();
AssertNoChildren();
m_eValueType = k_EWebAPIValueType_UInt64;
m_ulValue = ulValue;
}
//-----------------------------------------------------------------------------
// Purpose: Setter
//-----------------------------------------------------------------------------
void CWebAPIValues::SetDoubleValue( double flValue )
{
ClearValue();
AssertNoChildren();
m_eValueType = k_EWebAPIValueType_Double;
m_flValue = flValue;
}
//-----------------------------------------------------------------------------
// Purpose: Setter
//-----------------------------------------------------------------------------
void CWebAPIValues::SetBoolValue( bool bValue )
{
ClearValue();
AssertNoChildren();
m_eValueType = k_EWebAPIValueType_Bool;
m_bValue = bValue;
}
//-----------------------------------------------------------------------------
// Purpose: Setter
//-----------------------------------------------------------------------------
void CWebAPIValues::SetNullValue()
{
ClearValue();
AssertNoChildren();
m_eValueType = k_EWebAPIValueType_Null;
}
//-----------------------------------------------------------------------------
// Purpose: Setter
//-----------------------------------------------------------------------------
void CWebAPIValues::SetBinaryValue( const uint8 *pValue, uint32 unBytes )
{
ClearValue();
AssertNoChildren();
m_eValueType = k_EWebAPIValueType_BinaryBlob;
if ( pValue == NULL || unBytes < 1 )
{
m_BinaryValue.m_nDataPos = 0;
m_BinaryValue.m_unBytes = 0;
}
else
{
m_BinaryValue.m_unBytes = unBytes;
m_BinaryValue.m_nDataPos = m_pStringBuffer->TellPut();
m_pStringBuffer->Put( pValue, unBytes );
}
}
//-----------------------------------------------------------------------------
// Purpose: Get the type currently held by the node
//-----------------------------------------------------------------------------
EWebAPIValueType CWebAPIValues::GetType() const
{
return m_eValueType;
}
//-----------------------------------------------------------------------------
// Purpose: Get int32 value
//-----------------------------------------------------------------------------
int32 CWebAPIValues::GetInt32Value() const
{
// we can read uint64 values this way too
switch ( m_eValueType )
{
case k_EWebAPIValueType_Int32:
return m_nValue;
case k_EWebAPIValueType_UInt32: // because we can't tell the type of an int when we parse this node might have different type
case k_EWebAPIValueType_UInt64:
case k_EWebAPIValueType_String:
{
uint32 uiVal = GetUInt32Value();
AssertMsg( uiVal < INT_MAX, "GetInt32Value called on node with %u, which is too big to fit in an Int32", uiVal );
return (int32)uiVal;
}
}
AssertMsg( false, "Shouldn't call CWebAPIValues::GetInt32Value unless value type is int32, uint32, uint64, or string. %d does not.", m_eValueType );
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: Get uint32 value
//-----------------------------------------------------------------------------
uint32 CWebAPIValues::GetUInt32Value() const
{
// we can read uint64 values this way too
switch ( m_eValueType )
{
case k_EWebAPIValueType_UInt32:
return m_unValue;
case k_EWebAPIValueType_UInt64:
case k_EWebAPIValueType_String:
{
uint64 uiVal = GetUInt64Value();
AssertMsg( uiVal <= UINT_MAX, "GetUInt32Value called on node with %llu, which is too big to fit in an UInt32", uiVal );
return (uint32)uiVal;
}
}
AssertMsg( false, "Shouldn't call CWebAPIValues::GetUInt32Value unless value type is uint32, uint64, or string. %d does not", m_eValueType );
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: Get int64 value
//-----------------------------------------------------------------------------
int64 CWebAPIValues::GetInt64Value() const
{
// we can read int32 values this way too
switch ( m_eValueType )
{
case k_EWebAPIValueType_Int32:
return GetInt32Value();
case k_EWebAPIValueType_Int64:
return m_lValue;
case k_EWebAPIValueType_String:
if ( m_nStrValuePos < 0 )
{
return 0ull;
}
else
{
#if defined(_PS3) || defined(POSIX)
return strtoll( (const char *)m_pStringBuffer->Base() + m_nStrValuePos, NULL, 10);
#else
return _strtoi64( (const char *)m_pStringBuffer->Base() + m_nStrValuePos, NULL, 10);
#endif
}
default:
AssertMsg1( false, "Shouldn't call CWebAPIValues::GetInt64Value unless value type matches. %d does not", m_eValueType );
return 0;
}
}
//-----------------------------------------------------------------------------
// Purpose: Get uint64 value
//-----------------------------------------------------------------------------
uint64 CWebAPIValues::GetUInt64Value() const
{
// we can read uint32 values this way too
switch ( m_eValueType )
{
case k_EWebAPIValueType_UInt32:
return GetUInt32Value();
case k_EWebAPIValueType_UInt64:
return m_ulValue;
case k_EWebAPIValueType_String:
if ( m_nStrValuePos < 0 )
{
return 0ull;
}
else
{
#if defined(_PS3) || defined(POSIX)
return strtoull( (const char *)m_pStringBuffer->Base() + m_nStrValuePos, NULL, 10);
#else
return _strtoui64( (const char *)m_pStringBuffer->Base() + m_nStrValuePos, NULL, 10);
#endif
}
default:
AssertMsg1( false, "Shouldn't call CWebAPIValues::GetUInt64Value unless value type matches. %d does not", m_eValueType );
return 0;
}
}
//-----------------------------------------------------------------------------
// Purpose: Get double value
//-----------------------------------------------------------------------------
double CWebAPIValues::GetDoubleValue() const
{
switch ( m_eValueType )
{
case k_EWebAPIValueType_Int32:
return (double)m_nValue;
case k_EWebAPIValueType_UInt32:
return (double)m_unValue;
case k_EWebAPIValueType_Int64:
return (double)m_lValue;
case k_EWebAPIValueType_UInt64:
return (double)m_ulValue;
case k_EWebAPIValueType_Double:
return m_flValue;
default:
AssertMsg1( false, "Shouldn't call CWebAPIValues::GetDoubleValue unless value type matches. %d does not", m_eValueType );
return 0.0f;
}
}
//-----------------------------------------------------------------------------
// Purpose: Get bool value
//-----------------------------------------------------------------------------
bool CWebAPIValues::GetBoolValue() const
{
if ( m_eValueType != k_EWebAPIValueType_Bool )
{
AssertMsg( false, "Shouldn't call CWebAPIValues::GetBoolValue unless value type matches" );
return false;
}
return m_bValue;
}
//-----------------------------------------------------------------------------
// Purpose: Get string value
//-----------------------------------------------------------------------------
void CWebAPIValues::GetStringValue( CUtlString &stringOut ) const
{
switch ( m_eValueType )
{
case k_EWebAPIValueType_String:
if ( m_nStrValuePos < 0 )
{
stringOut.Clear();
}
else
{
stringOut = (const char *)m_pStringBuffer->Base() + m_nStrValuePos;
}
return;
case k_EWebAPIValueType_Int32:
stringOut = CNumStr( m_nValue ).String();
return;
case k_EWebAPIValueType_Int64:
stringOut = CNumStr( m_lValue ).String();
return;
case k_EWebAPIValueType_UInt32:
stringOut = CNumStr( m_unValue ).String();
return;
case k_EWebAPIValueType_UInt64:
stringOut = CNumStr( m_ulValue ).String();
return;
case k_EWebAPIValueType_Double:
stringOut = CNumStr( m_flValue ).String();
return;
case k_EWebAPIValueType_Bool:
stringOut = m_bValue ? "true" : "false";
return;
default:
AssertMsg1( false, "CWebAPIValues::GetStringValue(), unable to convert data type %d to string", m_eValueType );
stringOut = "";
return;
}
}
//-----------------------------------------------------------------------------
// Purpose: Get binary blob value
//-----------------------------------------------------------------------------
void CWebAPIValues::GetBinaryValue( CUtlBuffer &bufferOut ) const
{
if ( m_eValueType != k_EWebAPIValueType_BinaryBlob )
{
AssertMsg( false, "Shouldn't call CWebAPIValues::GetBinaryValue unless value type matches" );
bufferOut.Clear();
return;
}
bufferOut.Clear();
bufferOut.EnsureCapacity( m_BinaryValue.m_unBytes );
if ( m_BinaryValue.m_unBytes )
bufferOut.Put( (byte*)m_pStringBuffer->Base() + m_BinaryValue.m_nDataPos, m_BinaryValue.m_unBytes );
return;
}
//-----------------------------------------------------------------------------
// Purpose: Create a child array of this node. Note that array nodes can only
// have un-named children, in XML the pchArrayElementNames value will be used
// as the element name for each of the children of the array, in JSON it will simply
// be a numerically indexed [] array.
//-----------------------------------------------------------------------------
CWebAPIValues * CWebAPIValues::CreateChildArray( const char *pchName, const char *pchArrayElementNames )
{
return CreateChildInternal( pchName, k_EWebAPIValueType_NumericArray, pchArrayElementNames );
}
//-----------------------------------------------------------------------------
// Purpose: Create a child of this node. Note, it's possible to create multiple,
// children with the same name, but you really don't want to. We'll assert about it
// in debug builds to detect, but not in release. If you do create duplicates you'll
// have broken JSON output.
//-----------------------------------------------------------------------------
CWebAPIValues * CWebAPIValues::CreateChildObject( const char *pchName )
{
return CreateChildInternal( pchName, k_EWebAPIValueType_Object );
}
//-----------------------------------------------------------------------------
// Purpose: Return an existing child object - otherwise create one and return that.
//-----------------------------------------------------------------------------
CWebAPIValues *CWebAPIValues::FindOrCreateChildObject( const char *pchName )
{
CWebAPIValues *pChild = FindChild( pchName );
if ( pChild )
{
return pChild;
}
return CreateChildObject( pchName );
}
//-----------------------------------------------------------------------------
// Purpose: Add a child object to the array, this should only be called on objects that are of the array type
//-----------------------------------------------------------------------------
CWebAPIValues * CWebAPIValues::AddChildObjectToArray()
{
if ( m_eValueType != k_EWebAPIValueType_NumericArray )
{
AssertMsg( m_eValueType == k_EWebAPIValueType_NumericArray, "Can't add array elements to CWebAPIVAlues unless type is of numeric array." );
return NULL;
}
// Use child element array name as name of all children of arrays
return CreateChildInternal( NULL, k_EWebAPIValueType_Object );
}
//-----------------------------------------------------------------------------
// Purpose: Add a child array to the array, this should only be called on objects that are of the array type
//-----------------------------------------------------------------------------
CWebAPIValues * CWebAPIValues::AddChildArrayToArray( const char * pchArrayElementNames )
{
if ( m_eValueType != k_EWebAPIValueType_NumericArray )
{
AssertMsg( m_eValueType == k_EWebAPIValueType_NumericArray, "Can't add array elements to CWebAPIVAlues unless type is of numeric array." );
return NULL;
}
// Use child element array name as name of all children of arrays
return CreateChildInternal( NULL, k_EWebAPIValueType_NumericArray, pchArrayElementNames );
}
//-----------------------------------------------------------------------------
// Purpose: Internal helper for creating children
//-----------------------------------------------------------------------------
CWebAPIValues * CWebAPIValues::CreateChildInternal( const char *pchName, EWebAPIValueType eValueType, const char *pchArrayElementNames )
{
// Shouldn't create children if you have a direct value. You are either an object or array of children,
// or a native value type. Not both.
AssertMsg( m_eValueType == k_EWebAPIValueType_Object || m_eValueType == k_EWebAPIValueType_NumericArray, "You are trying to create a child node of a CWebAPIValues object, but it has a direct value already. Can't have children and a value." );
if ( m_eValueType != k_EWebAPIValueType_Object && m_eValueType != k_EWebAPIValueType_NumericArray )
ClearValue();
// Shouldn't create named children if you are a numeric array
CWebAPIValues *pNewNode;
if ( m_eValueType == k_EWebAPIValueType_NumericArray )
{
if ( pchName )
{
AssertMsg( false, "Can't create named child of CWebAPIValues object of type NumericArray. Should call AddArrayElement instead of CreateChild*." );
}
// Force name to match what all items in the array should use
pNewNode = new CWebAPIValues( this, m_nArrayChildElementNamePos, eValueType, pchArrayElementNames );
}
else
{
pNewNode = new CWebAPIValues( this, pchName, eValueType, pchArrayElementNames );
}
if ( eValueType == k_EWebAPIValueType_NumericArray )
{
Assert( pchArrayElementNames );
}
if ( !m_pFirstChild )
{
m_pLastChild = m_pFirstChild = pNewNode;
return m_pFirstChild;
}
else
{
CWebAPIValues *pCurLastChild = m_pLastChild;
#ifdef _DEBUG
// In debug, traverse all children so we can check for duplicate names, which will break JSON output!
pCurLastChild = m_pFirstChild;
if ( m_eValueType != k_EWebAPIValueType_NumericArray )
{
if ( Q_stricmp( pCurLastChild->GetName(), pchName ) == 0 )
{
AssertMsg( false, "Trying to create CWebAPIValues child with name %s that conflicts with existing child. Breaks JSON output!", pchName );
}
}
while ( pCurLastChild->m_pNextPeer )
{
pCurLastChild = pCurLastChild->m_pNextPeer;
if ( m_eValueType != k_EWebAPIValueType_NumericArray )
{
if ( Q_stricmp( pCurLastChild->GetName(), pchName ) == 0 )
{
AssertMsg( false, "Trying to create CWebAPIValues child with name %s that conflicts with existing child. Breaks JSON output!", pchName );
}
}
}
// Also, in debug assert last child ptr looks correct
Assert( m_pLastChild == pCurLastChild );
#endif
m_pLastChild = pCurLastChild->m_pNextPeer = pNewNode;
return m_pLastChild;
}
}
//-----------------------------------------------------------------------------
// Purpose: Set a child node's string value
//-----------------------------------------------------------------------------
void CWebAPIValues::SetChildStringValue( const char *pchChildName, const char *pchValue )
{
CreateChildObject( pchChildName )->SetStringValue( pchValue );
}
//-----------------------------------------------------------------------------
// Purpose: Set a child node's int32 value
//-----------------------------------------------------------------------------
void CWebAPIValues::SetChildInt32Value( const char *pchChildName, int32 nValue )
{
CreateChildObject( pchChildName )->SetInt32Value( nValue );
}
//-----------------------------------------------------------------------------
// Purpose: Set a child node's uint32 value
//-----------------------------------------------------------------------------
void CWebAPIValues::SetChildUInt32Value( const char *pchChildName, uint32 unValue )
{
CreateChildObject( pchChildName )->SetUInt32Value( unValue );
}
//-----------------------------------------------------------------------------
// Purpose: Set a child node's int64 value
//-----------------------------------------------------------------------------
void CWebAPIValues::SetChildInt64Value ( const char *pchChildName, int64 lValue )
{
CreateChildObject( pchChildName )->SetInt64Value( lValue );
}
//-----------------------------------------------------------------------------
// Purpose: Set a child node's uint64 value
//-----------------------------------------------------------------------------
void CWebAPIValues::SetChildUInt64Value( const char *pchChildName, uint64 ulValue )
{
CreateChildObject( pchChildName )->SetUInt64Value( ulValue );
}
//-----------------------------------------------------------------------------
// Purpose: Set a child node's double value
//-----------------------------------------------------------------------------
void CWebAPIValues::SetChildDoubleValue( const char *pchChildName, double flValue )
{
CreateChildObject( pchChildName )->SetDoubleValue( flValue );
}
//-----------------------------------------------------------------------------
// Purpose: Set a child node's binary blob value
//-----------------------------------------------------------------------------
void CWebAPIValues::SetChildBinaryValue( const char *pchChildName, const uint8 *pValue, uint32 unBytes )
{
CreateChildObject( pchChildName )->SetBinaryValue( pValue, unBytes );
}
//-----------------------------------------------------------------------------
// Purpose: Set a child node's boolean value
//-----------------------------------------------------------------------------
void CWebAPIValues::SetChildBoolValue( const char *pchChildName, bool bValue )
{
CreateChildObject( pchChildName )->SetBoolValue( bValue );
}
//-----------------------------------------------------------------------------
// Purpose: Set a child node's boolean value
//-----------------------------------------------------------------------------
void CWebAPIValues::SetChildNullValue( const char *pchChildName )
{
CreateChildObject( pchChildName )->SetNullValue();
}
//-----------------------------------------------------------------------------
// Purpose: Get a child node's int32 value or return the default if the node doesn't exist
//-----------------------------------------------------------------------------
int32 CWebAPIValues::GetChildInt32Value( const char *pchChildName, int32 nDefault ) const
{
const CWebAPIValues *pChild = FindChild( pchChildName );
if( pChild )
return pChild->GetInt32Value();
else
return nDefault;
}
//-----------------------------------------------------------------------------
// Purpose: Get a child node's uint32 value or return the default if the node doesn't exist
//-----------------------------------------------------------------------------
uint32 CWebAPIValues::GetChildUInt32Value( const char *pchChildName, uint32 unDefault ) const
{
const CWebAPIValues *pChild = FindChild( pchChildName );
if( pChild )
return pChild->GetUInt32Value();
else
return unDefault;
}
//-----------------------------------------------------------------------------
// Purpose: Get a child node's int64 value or return the default if the node doesn't exist
//-----------------------------------------------------------------------------
int64 CWebAPIValues::GetChildInt64Value( const char *pchChildName, int64 lDefault ) const
{
const CWebAPIValues *pChild = FindChild( pchChildName );
if( pChild )
return pChild->GetInt64Value();
else
return lDefault;
}
//-----------------------------------------------------------------------------
// Purpose: Get a child node's uint64 value or return the default if the node doesn't exist
//-----------------------------------------------------------------------------
uint64 CWebAPIValues::GetChildUInt64Value( const char *pchChildName, uint64 ulDefault ) const
{
const CWebAPIValues *pChild = FindChild( pchChildName );
if( pChild )
return pChild->GetUInt64Value();
else
return ulDefault;
}
//-----------------------------------------------------------------------------
// Purpose: Get a child node's double value or return the default if the node doesn't exist
//-----------------------------------------------------------------------------
double CWebAPIValues::GetChildDoubleValue( const char *pchChildName, double flDefault ) const
{
const CWebAPIValues *pChild = FindChild( pchChildName );
if( pChild )
return pChild->GetDoubleValue();
else
return flDefault;
}
//-----------------------------------------------------------------------------
// Purpose: Get a child node's string value or return the default if the node doesn't exist
//-----------------------------------------------------------------------------
void CWebAPIValues::GetChildStringValue( CUtlString &stringOut, const char *pchChildName, const char *pchDefault ) const
{
const CWebAPIValues *pChild = FindChild( pchChildName );
if( pChild )
{
pChild->GetStringValue( stringOut );
}
else
{
stringOut = pchDefault;
}
}
//-----------------------------------------------------------------------------
// Purpose: Get a child node's binary blob value (returns false if the child wasn't found)
//-----------------------------------------------------------------------------
bool CWebAPIValues::BGetChildBinaryValue( CUtlBuffer &bufferOut, const char *pchChildName ) const
{
const CWebAPIValues *pChild = FindChild( pchChildName );
if( pChild )
{
pChild->GetBinaryValue( bufferOut );
return true;
}
else
{
return false;
}
}
//-----------------------------------------------------------------------------
// Purpose: Get a child node's binary blob value (returns false if the child wasn't found)
//-----------------------------------------------------------------------------
bool CWebAPIValues::IsChildNullValue( const char *pchChildName ) const
{
const CWebAPIValues *pChild = FindChild( pchChildName );
if( pChild )
return pChild->IsNullValue();
else
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Get a child node's bool value or return the default if the node doesn't exist
//-----------------------------------------------------------------------------
bool CWebAPIValues::GetChildBoolValue( const char *pchChildName, bool bDefault ) const
{
const CWebAPIValues *pChild = FindChild( pchChildName );
if( pChild )
return pChild->GetBoolValue();
else
return bDefault;
}
//-----------------------------------------------------------------------------
// Purpose: Find first matching child by name, O(N) on number of children, this class isn't designed for searching
//-----------------------------------------------------------------------------
CWebAPIValues * CWebAPIValues::FindChild( const char *pchName )
{
CWebAPIValues *pCurLastChild = m_pFirstChild;
while ( pCurLastChild )
{
if ( Q_stricmp( pCurLastChild->GetName(), pchName ) == 0 )
return pCurLastChild;
pCurLastChild = pCurLastChild->m_pNextPeer;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Get the first child of this node
//-----------------------------------------------------------------------------
CWebAPIValues * CWebAPIValues::GetFirstChild()
{
return m_pFirstChild;
}
//-----------------------------------------------------------------------------
// Purpose: Call this on the returned value from GetFirstChild() or a previous GetNextChild() call to
// proceed to the next child of the parent GetFirstChild() was originally called on.
//-----------------------------------------------------------------------------
CWebAPIValues * CWebAPIValues::GetNextChild()
{
return m_pNextPeer;
}
//-----------------------------------------------------------------------------
// Purpose: Call this on any node to return the parent of that node
//-----------------------------------------------------------------------------
CWebAPIValues * CWebAPIValues::GetParent()
{
return m_pParent;
}
//-----------------------------------------------------------------------------
// Purpose: Deletes a child node by name
//-----------------------------------------------------------------------------
void CWebAPIValues::DeleteChild( const char *pchName )
{
CWebAPIValues *pChild = NULL; // child we're examining, could be NULL at exit if we don't find it
CWebAPIValues *pPrev = NULL; // previous sibling, or NULL
for ( pChild = m_pFirstChild; pChild != NULL; pPrev = pChild, pChild = pChild->m_pNextPeer )
{
if ( !Q_stricmp( pChild->GetName(), pchName ) )
{
if ( pChild == m_pFirstChild )
{
// first child, fixup parent's pointer to take pChild out
Assert( pPrev == NULL );
m_pFirstChild = pChild->m_pNextPeer;
}
else
{
// not first child, fixup sibling's pointer to take pChild out
Assert( pPrev != NULL );
pPrev->m_pNextPeer = pChild->m_pNextPeer;
}
// clean up next ptr on child so we don't double free
pChild->m_pNextPeer = NULL;
// fixup last child pointer if pChild is the last child
if ( pChild == m_pLastChild )
{
m_pLastChild = pPrev;
}
break;
}
}
// debug only, check that there is no child by the specified name any more and that it was excised OK
AssertMsg( FindChild( pchName ) == NULL, "cwebapivalues deleted child is still lurking" );
Assert( pChild == NULL || pChild->m_pNextPeer == NULL );
// now take the removed child out of the heap
delete pChild;
}
//-----------------------------------------------------------------------------
// Purpose: Emits JSON formatted representation of values
//
// when bEmitOldStyleArrays is true, arrays are emitted as a child of a singlet object, and any empty arrays
// will be emitted as having a single null member.
//
// when bEmitOldStyleArrays is false, arrays are emitted bare (no subobject) and empty arrays
// are emitted empty.
//-----------------------------------------------------------------------------
bool CWebAPIValues::BEmitJSONRecursive( const CWebAPIValues *pCurrent, CUtlBuffer &outputBuffer, int nTabLevel, size_t unMaxResultSize, bool bEmitOldStyleArrays )
{
bool bSuccess = true;
while( pCurrent )
{
// don't let the buffer grow until it consumes all available memory
if( unMaxResultSize && (size_t)outputBuffer.TellMaxPut() > unMaxResultSize )
{
return false;
}
// Can't emit nameless nodes in JSON. Nodes should always have a name.
Assert( pCurrent->GetName() );
if ( pCurrent->GetName() )
{
for( int i=0; i < nTabLevel; ++i )
outputBuffer.PutChar ( '\t' );
if ( !pCurrent->m_pParent || pCurrent->m_pParent->GetType() != k_EWebAPIValueType_NumericArray )
{
EmitJSONString( outputBuffer, pCurrent->GetName() );
outputBuffer.PutChar( ':' );
outputBuffer.PutChar( ' ' );
}
if ( pCurrent->m_eValueType == k_EWebAPIValueType_Object || pCurrent->m_eValueType == k_EWebAPIValueType_NumericArray )
{
if( bEmitOldStyleArrays || pCurrent->m_eValueType == k_EWebAPIValueType_Object )
{
outputBuffer.PutChar( '{' );
outputBuffer.PutChar( '\n' );
}
if ( pCurrent->m_eValueType == k_EWebAPIValueType_NumericArray )
{
if( bEmitOldStyleArrays )
{
for( int i=0; i < nTabLevel+1; ++i )
outputBuffer.PutChar ( '\t' );
EmitJSONString( outputBuffer, (const char *)pCurrent->m_pStringBuffer->Base() + pCurrent->m_nArrayChildElementNamePos );
outputBuffer.PutChar( ':' );
outputBuffer.PutChar( ' ' );
}
outputBuffer.PutChar( '[' );
outputBuffer.PutChar( '\n' );
}
// First add any children
if ( pCurrent->m_pFirstChild )
{
int nChildTabLevel = nTabLevel+1;
if ( pCurrent->m_eValueType == k_EWebAPIValueType_NumericArray && bEmitOldStyleArrays )
++nChildTabLevel;
bSuccess = BEmitJSONRecursive( pCurrent->m_pFirstChild, outputBuffer, nChildTabLevel, unMaxResultSize, bEmitOldStyleArrays );
if ( !bSuccess )
return false;
}
else if ( bEmitOldStyleArrays )
{
for( int i=0; i < nTabLevel + 1; ++i )
outputBuffer.PutChar ( '\t' );
outputBuffer.Put( "null", 4 );
}
outputBuffer.PutChar( '\n' );
for( int i=0; i < nTabLevel; ++i )
outputBuffer.PutChar ( '\t' );
if ( pCurrent->m_eValueType == k_EWebAPIValueType_NumericArray )
{
if( bEmitOldStyleArrays )
outputBuffer.PutChar( '\t' );
outputBuffer.PutChar( ']' );
outputBuffer.PutChar( '\n' );
for( int i=0; i < nTabLevel; ++i )
outputBuffer.PutChar ( '\t' );
}
if( bEmitOldStyleArrays || pCurrent->m_eValueType == k_EWebAPIValueType_Object )
{
outputBuffer.PutChar( '}' );
}
}
else
{
switch ( pCurrent->m_eValueType )
{
case k_EWebAPIValueType_Int32:
{
CNumStr numStr( pCurrent->m_nValue );
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
break;
case k_EWebAPIValueType_Int64:
{
CNumStr numStr( pCurrent->m_lValue );
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
break;
case k_EWebAPIValueType_UInt32:
{
CNumStr numStr( pCurrent->m_unValue );
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
break;
case k_EWebAPIValueType_UInt64:
{
CNumStr numStr( pCurrent->m_ulValue );
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
break;
case k_EWebAPIValueType_Double:
{
CNumStr numStr( pCurrent->m_flValue );
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
break;
case k_EWebAPIValueType_String:
{
if ( pCurrent->m_nStrValuePos < 0 )
outputBuffer.Put( "null", 4 );
else
EmitJSONString( outputBuffer, (const char *)pCurrent->m_pStringBuffer->Base() + pCurrent->m_nStrValuePos );
}
break;
case k_EWebAPIValueType_Bool:
{
if ( !pCurrent->m_bValue )
outputBuffer.Put( "false", 5 );
else
outputBuffer.Put( "true", 4 );
}
break;
case k_EWebAPIValueType_Null:
{
outputBuffer.Put( "null", 4 );
}
break;
case k_EWebAPIValueType_BinaryBlob:
{
if ( pCurrent->m_BinaryValue.m_unBytes == 0 )
outputBuffer.Put( "null", 4 );
else
{
CUtlMemory<char> buffEncoded;
DbgVerify( Base64EncodeIntoUTLMemory( (const uint8 *)pCurrent->m_pStringBuffer->Base() + pCurrent->m_BinaryValue.m_nDataPos, pCurrent->m_BinaryValue.m_unBytes, buffEncoded ) );
EmitJSONString( outputBuffer, buffEncoded.Base() );
}
}
break;
default:
break;
}
}
}
// Now, check for any peers
if ( bSuccess && pCurrent->m_pNextPeer )
{
outputBuffer.PutChar( ',' );
outputBuffer.PutChar( '\n' );
pCurrent = pCurrent->m_pNextPeer;
}
else
{
// We're done, or failing early
pCurrent = NULL;
}
}
return bSuccess && outputBuffer.IsValid();
}
//-----------------------------------------------------------------------------
// Purpose: Emits KeyValues .vdf style formatted representation of values
//-----------------------------------------------------------------------------
bool CWebAPIValues::BEmitVDFRecursive( const CWebAPIValues *pCurrent, CUtlBuffer &outputBuffer, int nTabLevel, uint32 nArrayElement, size_t unMaxResultSize, bool bIncludeArrayElementName )
{
bool bSuccess = true;
// We can have lots of peers, so this is an optimization to avoid tail recursion and resulting stack-overflows!
while( pCurrent )
{
// don't let the buffer grow until it consumes all available memory
if( unMaxResultSize && (size_t)outputBuffer.TellMaxPut() > unMaxResultSize )
{
return false;
}
if ( pCurrent->GetName() )
{
for( int i=0; i < nTabLevel; ++i )
outputBuffer.PutChar ( '\t' );
// Open node, special naming when inside arrays
if ( pCurrent->m_pParent && pCurrent->m_pParent->GetType() == k_EWebAPIValueType_NumericArray )
{
CNumStr numStr( nArrayElement );
numStr.AddQuotes();
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
else
{
EmitVDFString( outputBuffer, pCurrent->GetName() );
}
if ( pCurrent->m_eValueType == k_EWebAPIValueType_Object || pCurrent->m_eValueType == k_EWebAPIValueType_NumericArray )
{
outputBuffer.PutChar( '\n' );
for( int i=0; i < nTabLevel; ++i )
outputBuffer.PutChar ( '\t' );
outputBuffer.PutChar( '{' );
outputBuffer.PutChar( '\n' );
if ( pCurrent->m_eValueType == k_EWebAPIValueType_NumericArray && bIncludeArrayElementName )
{
for( int i=0; i < nTabLevel+1; ++i )
outputBuffer.PutChar ( '\t' );
EmitVDFString( outputBuffer, (const char *)pCurrent->m_pStringBuffer->Base() + pCurrent->m_nArrayChildElementNamePos );
outputBuffer.PutChar( '\n' );
for( int i=0; i < nTabLevel+1; ++i )
outputBuffer.PutChar ( '\t' );
outputBuffer.PutChar( '{' );
outputBuffer.PutChar( '\n' );
}
if ( pCurrent->m_pFirstChild )
{
int nChildTabLevel = nTabLevel+1;
if ( pCurrent->m_eValueType == k_EWebAPIValueType_NumericArray && bIncludeArrayElementName )
++nChildTabLevel;
bSuccess = BEmitVDFRecursive( pCurrent->m_pFirstChild, outputBuffer, nChildTabLevel, 0, unMaxResultSize, bIncludeArrayElementName );
if ( !bSuccess )
return false;
}
if ( pCurrent->m_eValueType == k_EWebAPIValueType_NumericArray && bIncludeArrayElementName )
{
outputBuffer.PutChar( '\n' );
for( int i=0; i < nTabLevel+1; ++i )
outputBuffer.PutChar ( '\t' );
outputBuffer.PutChar( '}' );
}
outputBuffer.PutChar( '\n' );
for( int i=0; i < nTabLevel; ++i )
outputBuffer.PutChar ( '\t' );
outputBuffer.PutChar( '}' );
}
else
{
outputBuffer.PutChar( '\t' );
switch ( pCurrent->m_eValueType )
{
case k_EWebAPIValueType_Int32:
{
CNumStr numStr( pCurrent->m_nValue );
numStr.AddQuotes();
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
break;
case k_EWebAPIValueType_Int64:
{
CNumStr numStr( pCurrent->m_lValue );
numStr.AddQuotes();
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
break;
case k_EWebAPIValueType_UInt32:
{
CNumStr numStr( pCurrent->m_unValue );
numStr.AddQuotes();
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
break;
case k_EWebAPIValueType_UInt64:
{
CNumStr numStr( pCurrent->m_ulValue );
numStr.AddQuotes();
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
break;
case k_EWebAPIValueType_Double:
{
CNumStr numStr( pCurrent->m_flValue );
numStr.AddQuotes();
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
break;
case k_EWebAPIValueType_String:
{
EmitVDFString( outputBuffer, pCurrent->m_nStrValuePos >= 0 ? ( (const char *)pCurrent->m_pStringBuffer->Base() + pCurrent->m_nStrValuePos ) : NULL );
}
break;
case k_EWebAPIValueType_Bool:
{
if ( !pCurrent->m_bValue )
outputBuffer.Put( "\"0\"", 3 );
else
outputBuffer.Put( "\"1\"", 3 );
}
break;
case k_EWebAPIValueType_Null:
{
outputBuffer.Put ("\"\"", 2 );
}
break;
case k_EWebAPIValueType_BinaryBlob:
{
if ( pCurrent->m_BinaryValue.m_unBytes == 0 )
outputBuffer.Put( "\"\"", 2 );
else
{
CUtlMemory<char> buffEncoded;
DbgVerify( Base64EncodeIntoUTLMemory( (const uint8 *)pCurrent->m_pStringBuffer->Base() + pCurrent->m_BinaryValue.m_nDataPos, pCurrent->m_BinaryValue.m_unBytes, buffEncoded ) );
EmitVDFString( outputBuffer, buffEncoded.Base() );
}
}
break;
default:
break;
}
}
}
// Now, check for any peers
if ( bSuccess && pCurrent->m_pNextPeer )
{
outputBuffer.PutChar( '\n' );
pCurrent = pCurrent->m_pNextPeer;
nArrayElement += 1;
}
else
{
// We're done, or failing early
pCurrent = NULL;
}
}
return bSuccess && outputBuffer.IsValid();
}
//-----------------------------------------------------------------------------
// Purpose: Emits XML formatted representation of values
//-----------------------------------------------------------------------------
bool CWebAPIValues::BEmitXMLRecursive( const CWebAPIValues *pCurrent, CUtlBuffer &outputBuffer, int nTabLevel, size_t unMaxResultSize )
{
bool bSuccess = true;
while( pCurrent )
{
// don't let the buffer grow until it consumes all available memory
if( unMaxResultSize && (size_t)outputBuffer.TellMaxPut() > unMaxResultSize )
{
return false;
}
// Can't emit nameless nodes in XML. Nodes should always have a name.
Assert( pCurrent->GetName() );
if ( pCurrent->GetName() )
{
for( int i=0; i < nTabLevel; ++i )
outputBuffer.PutChar ( '\t' );
// Open node
outputBuffer.PutChar( '<' );
EmitXMLString( outputBuffer, pCurrent->GetName() );
outputBuffer.PutChar( '>' );
if ( pCurrent->m_eValueType == k_EWebAPIValueType_Object || pCurrent->m_eValueType == k_EWebAPIValueType_NumericArray )
{
// First add any children
if ( pCurrent->m_pFirstChild )
{
outputBuffer.PutChar( '\n' );
bSuccess = BEmitXMLRecursive( pCurrent->m_pFirstChild, outputBuffer, nTabLevel+1, unMaxResultSize );
if ( !bSuccess )
return false;
outputBuffer.PutChar( '\n' );
// Return to correct tab level, for when we close element below
for( int i=0; i < nTabLevel; ++i )
outputBuffer.PutChar ( '\t' );
}
}
else
{
switch ( pCurrent->m_eValueType )
{
case k_EWebAPIValueType_Int32:
{
CNumStr numStr( pCurrent->m_nValue );
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
break;
case k_EWebAPIValueType_Int64:
{
CNumStr numStr( pCurrent->m_lValue );
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
break;
case k_EWebAPIValueType_UInt32:
{
CNumStr numStr( pCurrent->m_unValue );
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
break;
case k_EWebAPIValueType_UInt64:
{
CNumStr numStr( pCurrent->m_ulValue );
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
break;
case k_EWebAPIValueType_Double:
{
CNumStr numStr( pCurrent->m_flValue );
outputBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
}
break;
case k_EWebAPIValueType_String:
{
if ( pCurrent->m_nStrValuePos < 0 )
outputBuffer.Put( "null", 4 );
else
EmitXMLString( outputBuffer, (const char *)pCurrent->m_pStringBuffer->Base() + pCurrent->m_nStrValuePos );
}
break;
case k_EWebAPIValueType_Bool:
{
if ( !pCurrent->m_bValue )
outputBuffer.Put( "false", 5 );
else
outputBuffer.Put( "true", 4 );
}
break;
case k_EWebAPIValueType_Null:
{
outputBuffer.Put ("null", 4 );
}
break;
case k_EWebAPIValueType_BinaryBlob:
{
if ( pCurrent->m_BinaryValue.m_unBytes == 0 )
outputBuffer.Put( "null", 4 );
else
{
CUtlMemory<char> buffEncoded;
DbgVerify( Base64EncodeIntoUTLMemory( (const uint8 *)pCurrent->m_pStringBuffer->Base() + pCurrent->m_BinaryValue.m_nDataPos, pCurrent->m_BinaryValue.m_unBytes, buffEncoded ) );
EmitXMLString( outputBuffer, buffEncoded.Base() );
}
}
break;
default:
break;
}
}
}
// Close element
outputBuffer.PutChar( '<' );
outputBuffer.PutChar( '/' );
EmitXMLString( outputBuffer, pCurrent->GetName() );
outputBuffer.PutChar( '>' );
// Now, check for any peers
if ( bSuccess && pCurrent->m_pNextPeer )
{
outputBuffer.PutChar( '\n' );
pCurrent = pCurrent->m_pNextPeer;
}
else
{
// We're done, or failing early
pCurrent = NULL;
}
}
return bSuccess && outputBuffer.IsValid();
}
struct JSONParserContext_t
{
CWebAPIValues *m_pCurrentNode;
CWebAPIValues *m_pRootNode;
CUtlString m_sChildName;
bool m_bIsKey;
};
static int JSONParserCallback(void* void_ctx, int type, const JSON_value* value)
{
JSONParserContext_t *ctx = (JSONParserContext_t *)void_ctx;
CWebAPIValues *pCreatedNode = NULL;
switch(type)
{
case JSON_T_ARRAY_BEGIN:
// handle the root node
if( !ctx->m_pRootNode )
{
Assert( !ctx->m_pCurrentNode );
ctx->m_pRootNode = ctx->m_pCurrentNode = new CWebAPIValues( ctx->m_sChildName, "e" );
break;
}
if( ctx->m_pCurrentNode->IsArray() )
{
Assert( ctx->m_sChildName.IsEmpty() );
ctx->m_pCurrentNode = ctx->m_pCurrentNode->AddChildArrayToArray( "e" );
}
else
{
Assert( !ctx->m_sChildName.IsEmpty() );
ctx->m_pCurrentNode = ctx->m_pCurrentNode->CreateChildArray( ctx->m_sChildName, "e" );
ctx->m_sChildName.Clear();
}
break;
case JSON_T_ARRAY_END:
ctx->m_pCurrentNode = ctx->m_pCurrentNode->GetParent();
break;
case JSON_T_OBJECT_BEGIN:
// this might be the start of the root object itself
if( !ctx->m_pRootNode )
{
ctx->m_pRootNode = ctx->m_pCurrentNode = new CWebAPIValues( ctx->m_sChildName );
break;
}
if( ctx->m_pCurrentNode->IsArray() )
{
Assert( ctx->m_sChildName.IsEmpty() );
ctx->m_pCurrentNode = ctx->m_pCurrentNode->AddChildObjectToArray();
}
else
{
Assert( !ctx->m_sChildName.IsEmpty() );
ctx->m_pCurrentNode = ctx->m_pCurrentNode->CreateChildObject( ctx->m_sChildName );
ctx->m_sChildName.Clear();
}
break;
case JSON_T_OBJECT_END:
ctx->m_pCurrentNode = ctx->m_pCurrentNode->GetParent();
break;
case JSON_T_KEY:
ctx->m_sChildName = value->vu.str.value;
break;
case JSON_T_INTEGER:
case JSON_T_FLOAT:
case JSON_T_NULL:
case JSON_T_TRUE:
case JSON_T_FALSE:
case JSON_T_STRING:
// create the new node for this value
if( ctx->m_pCurrentNode->IsArray() )
{
pCreatedNode = ctx->m_pCurrentNode->AddChildObjectToArray();
}
else
{
pCreatedNode = ctx->m_pCurrentNode->CreateChildObject( ctx->m_sChildName );
ctx->m_sChildName.Clear();
}
// set the actual value
switch( type )
{
case JSON_T_INTEGER:
// try to figure out what type to use
if( value->vu.integer_value >= 0 )
{
// unsigned
if( value->vu.integer_value <= UINT_MAX )
{
pCreatedNode->SetUInt32Value( (uint32)value->vu.integer_value );
}
else
{
pCreatedNode->SetUInt64Value( (uint64)value->vu.integer_value );
}
}
else
{
// signed
if( value->vu.integer_value >= INT_MIN )
{
pCreatedNode->SetInt32Value( (int32)value->vu.integer_value );
}
else
{
pCreatedNode->SetInt64Value( value->vu.integer_value );
}
}
break;
case JSON_T_FLOAT:
pCreatedNode->SetDoubleValue( value->vu.float_value );
break;
case JSON_T_NULL:
pCreatedNode->SetNullValue();
break;
case JSON_T_TRUE:
pCreatedNode->SetBoolValue( true );
break;
case JSON_T_FALSE:
pCreatedNode->SetBoolValue( false );
break;
case JSON_T_STRING:
pCreatedNode->SetStringValue( value->vu.str.value );
break;
}
break;
default:
Assert( false );
break;
}
return 1;
}
// parses JSON into a tree of CWebAPIValues nodes with this as the root
CWebAPIValues *CWebAPIValues::ParseJSON( CUtlBuffer &inputBuffer )
{
//
// if there's nothing to parse, just early out
inputBuffer.EatWhiteSpace();
if( inputBuffer.GetBytesRemaining() == 0 )
return NULL;
// if the first character is the start of a string,
// wrap the whole thing in an object so we can parse it.
// We'll unwrap it at the end
char cFirst = *(char *)inputBuffer.PeekGet();
bool bWrapContent = cFirst == '\"';
JSON_config config;
struct JSON_parser_struct* jc = NULL;
init_JSON_config(&config);
JSONParserContext_t context;
context.m_pCurrentNode = NULL;
context.m_pRootNode = NULL;
context.m_bIsKey = false;
config.depth = 19;
config.callback = &JSONParserCallback;
config.allow_comments = 1;
config.handle_floats_manually = 0;
config.callback_ctx = &context;
config.malloc = malloc;
config.free = free;
jc = new_JSON_parser(&config);
bool bSuccess = true;
if( bWrapContent )
JSON_parser_char( jc, '{' );
while( inputBuffer.GetBytesRemaining( ) > 0 )
{
if( !JSON_parser_char( jc, (unsigned char)inputBuffer.GetChar() ) )
{
bSuccess = false;
break;
}
}
if( bWrapContent )
{
JSON_parser_char( jc, '}' );
}
if( bSuccess )
{
if (!JSON_parser_done(jc))
{
bSuccess = false;
}
}
delete_JSON_parser(jc);
// unwrap the root node
if( bWrapContent && bSuccess )
{
CWebAPIValues *pWrapRoot = context.m_pRootNode;
if( !pWrapRoot )
{
bSuccess = false;
}
else
{
CWebAPIValues *pRealRoot = pWrapRoot->GetFirstChild();
if( !pRealRoot )
{
bSuccess = false;
}
else
{
if( pRealRoot->GetNextChild() )
{
bSuccess = false;
}
else
{
pWrapRoot->m_pFirstChild = NULL;
pRealRoot->m_pParent = NULL;
context.m_pRootNode = pRealRoot;
delete pWrapRoot;
}
}
}
}
if( bSuccess )
{
return context.m_pRootNode;
}
else
{
delete context.m_pRootNode;
return NULL;
}
}
CWebAPIValues *CWebAPIValues::ParseJSON( const char *pchJSONString )
{
CUtlBuffer bufJSON( pchJSONString, Q_strlen( pchJSONString), CUtlBuffer::TEXT_BUFFER | CUtlBuffer::READ_ONLY );
return ParseJSON( bufJSON );
}
void CWebAPIValues::CopyFrom( const CWebAPIValues *pSource )
{
switch( pSource->GetType() )
{
case k_EWebAPIValueType_Int32:
SetInt32Value( pSource->GetInt32Value() );
break;
case k_EWebAPIValueType_Int64:
SetInt64Value( pSource->GetInt64Value() );
break;
case k_EWebAPIValueType_UInt32:
SetUInt32Value( pSource->GetUInt32Value() );
break;
case k_EWebAPIValueType_UInt64:
SetUInt64Value( pSource->GetUInt64Value() );
break;
case k_EWebAPIValueType_Double:
SetDoubleValue( pSource->GetDoubleValue() );
break;
case k_EWebAPIValueType_String:
{
CUtlString sValue;
pSource->GetStringValue( sValue );
SetStringValue( sValue );
}
break;
case k_EWebAPIValueType_Bool:
SetBoolValue( pSource->GetBoolValue() );
break;
case k_EWebAPIValueType_Null:
SetNullValue( );
break;
case k_EWebAPIValueType_BinaryBlob:
{
CUtlBuffer bufValue;
pSource->GetBinaryValue( bufValue );
SetBinaryValue( (uint8 *)bufValue.Base(), bufValue.TellMaxPut() );
}
break;
case k_EWebAPIValueType_Object:
{
ClearValue();
m_eValueType = k_EWebAPIValueType_Object;
const CWebAPIValues *pSourceChild = pSource->GetFirstChild();
while( pSourceChild )
{
CWebAPIValues *pChild;
if( pSourceChild->IsArray() )
pChild = CreateChildArray( pSourceChild->GetName(), pSourceChild->GetElementName() );
else
pChild = CreateChildObject( pSourceChild->GetName() );
pChild->CopyFrom( pSourceChild );
pSourceChild = pSourceChild->GetNextChild();
}
}
break;
case k_EWebAPIValueType_NumericArray:
{
// the type should have been set when this node was first created
Assert( m_eValueType == k_EWebAPIValueType_NumericArray );
m_eValueType = k_EWebAPIValueType_NumericArray;
const CWebAPIValues *pSourceChild = pSource->GetFirstChild();
while( pSourceChild )
{
CWebAPIValues *pChild;
if( pSourceChild->IsArray() )
pChild = AddChildArrayToArray( pSourceChild->GetElementName() );
else
pChild = AddChildObjectToArray( );
pChild->CopyFrom( pSourceChild );
pSourceChild = pSourceChild->GetNextChild();
}
}
break;
default:
AssertMsg( false, "Unknown type in CWebAPIValues::CopyFrom" );
break;
}
}
//-----------------------------------------------------------------------------
// Purpose: Fills a WebAPI key values from a corresponding protobuf message.
//-----------------------------------------------------------------------------
bool ProtoBufHelper::RecursiveAddProtoBufToWebAPIValues( CWebAPIValues *pWebAPIRoot, const ::google::protobuf::Message & msg )
{
using ::google::protobuf::FieldDescriptor;
const ::google::protobuf::Descriptor *pDescriptor = msg.GetDescriptor();
const ::google::protobuf::Reflection *pReflection = msg.GetReflection();
for ( int iField = 0; iField < pDescriptor->field_count(); iField++ )
{
const ::google::protobuf::FieldDescriptor *pField = pDescriptor->field( iField );
const char *pFieldName = pField->name().c_str();
if ( pField->is_repeated() )
{
if ( pReflection->FieldSize( msg, pField ) == 0 )
{
continue; // No need to create the array if it is empty
// If the field has been disabled externally, it has been cleared already (and thus will be skipped)
}
// bugbug: Is there a way to get this from the google API?
const char *pchTypeName = "unknown_type";
switch ( pField->cpp_type() )
{
case FieldDescriptor::CPPTYPE_INT32: pchTypeName = "int32"; break;
case FieldDescriptor::CPPTYPE_INT64: pchTypeName = "int64"; break;
case FieldDescriptor::CPPTYPE_UINT32: pchTypeName = "uint32"; break;
case FieldDescriptor::CPPTYPE_DOUBLE: pchTypeName = "double"; break;
case FieldDescriptor::CPPTYPE_FLOAT: pchTypeName = "float"; break;
case FieldDescriptor::CPPTYPE_BOOL: pchTypeName = "bool"; break;
case FieldDescriptor::CPPTYPE_ENUM: pchTypeName = "enum"; break;
case FieldDescriptor::CPPTYPE_STRING:
{
if ( pField->type() == FieldDescriptor::TYPE_STRING )
{
pchTypeName = "string";
}
else
{
AssertMsg1( pField->type() == FieldDescriptor::TYPE_BYTES, "Unrecognized field type: %d", pField->type() );
pchTypeName = "bytes";
}
break;
}
case FieldDescriptor::CPPTYPE_MESSAGE: pchTypeName = "message"; break;
}
CWebAPIValues *pContainer = pWebAPIRoot->CreateChildArray( pFieldName, pchTypeName );
for ( int iRepeated = 0; iRepeated < pReflection->FieldSize( msg, pField ); iRepeated++ )
{
switch ( pField->cpp_type() )
{
case FieldDescriptor::CPPTYPE_INT32: pContainer->SetChildInt32Value( NULL, pReflection->GetRepeatedInt32( msg, pField, iRepeated ) ); break;
case FieldDescriptor::CPPTYPE_INT64: pContainer->SetChildInt64Value( NULL, pReflection->GetRepeatedInt64( msg, pField, iRepeated ) ); break;
case FieldDescriptor::CPPTYPE_UINT32: pContainer->SetChildUInt32Value( NULL, pReflection->GetRepeatedUInt32( msg, pField, iRepeated ) ); break;
case FieldDescriptor::CPPTYPE_UINT64: pContainer->SetChildUInt64Value( NULL, pReflection->GetRepeatedUInt64( msg, pField, iRepeated ) ); break;
case FieldDescriptor::CPPTYPE_DOUBLE: pContainer->SetChildDoubleValue( NULL, pReflection->GetRepeatedDouble( msg, pField, iRepeated ) ); break;
case FieldDescriptor::CPPTYPE_FLOAT: pContainer->SetChildDoubleValue( NULL, pReflection->GetRepeatedFloat( msg, pField, iRepeated ) ); break;
case FieldDescriptor::CPPTYPE_BOOL: pContainer->SetChildBoolValue( NULL, pReflection->GetRepeatedBool( msg, pField, iRepeated ) ); break;
case FieldDescriptor::CPPTYPE_ENUM: pContainer->SetChildInt32Value( NULL, pReflection->GetRepeatedEnum( msg, pField, iRepeated )->number() ); break;
case FieldDescriptor::CPPTYPE_STRING:
{
const std::string &strValue = pReflection->GetRepeatedString( msg, pField, iRepeated );
if ( pField->type() == FieldDescriptor::TYPE_STRING )
{
pContainer->SetChildStringValue( NULL, strValue.c_str() );
}
else
{
// Binary blobs are automatically encoded in Base64 when converted to string by Web request
pContainer->SetChildBinaryValue( NULL, (const uint8 *)strValue.c_str(), strValue.size() );
}
break;
}
case FieldDescriptor::CPPTYPE_MESSAGE:
{
const ::google::protobuf::Message &subMsg = pReflection->GetRepeatedMessage( msg, pField, iRepeated );
CWebAPIValues *pChild = pContainer->CreateChildObject( NULL );
if ( RecursiveAddProtoBufToWebAPIValues( pChild, subMsg ) == false )
{
return false;
}
break;
}
default:
AssertMsg1( false, "Unknown cpp_type %d", pField->cpp_type() );
return false;
}
}
}
else
{
if ( ( ( pReflection->HasField( msg, pField ) == false ) && ( pField->has_default_value() == false ) )
// || pField->options().GetExtension( is_field_disabled_externally ) // Steam vesion supports this
)
{
continue; // If no field set and no default value set, there is no need to send the field
// Or it is externally disabled (it has been cleared already but there still may be a default value set)
}
switch ( pField->cpp_type() )
{
case FieldDescriptor::CPPTYPE_INT32: pWebAPIRoot->SetChildInt32Value( pFieldName, pReflection->GetInt32( msg, pField ) ); break;
case FieldDescriptor::CPPTYPE_INT64: pWebAPIRoot->SetChildInt64Value( pFieldName, pReflection->GetInt64( msg, pField ) ); break;
case FieldDescriptor::CPPTYPE_UINT32: pWebAPIRoot->SetChildUInt32Value( pFieldName, pReflection->GetUInt32( msg, pField ) ); break;
case FieldDescriptor::CPPTYPE_UINT64: pWebAPIRoot->SetChildUInt64Value( pFieldName, pReflection->GetUInt64( msg, pField ) ); break;
case FieldDescriptor::CPPTYPE_DOUBLE: pWebAPIRoot->SetChildDoubleValue( pFieldName, pReflection->GetDouble( msg, pField ) ); break;
case FieldDescriptor::CPPTYPE_FLOAT: pWebAPIRoot->SetChildDoubleValue( pFieldName, pReflection->GetFloat( msg, pField ) ); break;
case FieldDescriptor::CPPTYPE_BOOL: pWebAPIRoot->SetChildBoolValue( pFieldName, pReflection->GetBool( msg, pField ) ); break;
case FieldDescriptor::CPPTYPE_ENUM: pWebAPIRoot->SetChildInt32Value( pFieldName, pReflection->GetEnum( msg, pField )->number() ); break;
case FieldDescriptor::CPPTYPE_STRING:
{
const std::string &strValue = pReflection->GetString( msg, pField );
if ( pField->type() == FieldDescriptor::TYPE_STRING )
{
pWebAPIRoot->SetChildStringValue( pFieldName, strValue.c_str() );
}
else
{
AssertMsg1( pField->type() == FieldDescriptor::TYPE_BYTES, "Unrecognized field type: %d", pField->type() );
// Binary blobs are automatically encoded in Base64 when converted to string by Web request
pWebAPIRoot->SetChildBinaryValue( pFieldName, (const uint8 *)strValue.c_str(), strValue.size() );
}
break;
}
case FieldDescriptor::CPPTYPE_MESSAGE:
{
CWebAPIValues *pChild = pWebAPIRoot->CreateChildObject( pFieldName );
#undef GetMessage // Work around unfortunate Microsoft macro
const ::google::protobuf::Message &subMsg = pReflection->GetMessage( msg, pField );
#ifdef UNICODE
#define GetMessage GetMessageW
#else
#define GetMessage GetMessageA
#endif // !UNICODE
if ( RecursiveAddProtoBufToWebAPIValues( pChild, subMsg ) == false )
{
return false;
}
break;
}
default:
AssertMsg1( false, "Unknown cpp_type %d", pField->cpp_type() );
return false;
}
}
}
return true;
}
Reference in New Issue Copy Permalink