diff options
Diffstat (limited to 'gcsdk/webapi_response.cpp')
| -rw-r--r-- | gcsdk/webapi_response.cpp | 2562 |
1 files changed, 2562 insertions, 0 deletions
diff --git a/gcsdk/webapi_response.cpp b/gcsdk/webapi_response.cpp new file mode 100644 index 0000000..82f1105 --- /dev/null +++ b/gcsdk/webapi_response.cpp @@ -0,0 +1,2562 @@ +//========= Copyright � 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( "&", 5 ); + break; + case '\'': + outputBuffer.Put( "'", 6 ); + break; + case '"': + outputBuffer.Put( """, 6 ); + break; + case '<': + outputBuffer.Put( "<", 4 ); + break; + case '>': + outputBuffer.Put( ">", 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; +} + |