AaronCameron.net

I care not for your petty politics.

• 
• 
• 
• 
• 

Not a Member? - Login or Create an Account

Sunday the 20th of May 2012 @ 03:37pm

Front Page Journal Projects Your Profile About

LibN2L N2L Home Older News Downloads Documentation (n2l5) Class Hierarchy Compound List File List n2l:: Members Functions Whole n2l:: Ref Documentation (libN2L-4) Class Hierarchy Compound List File List n2l:: Members Functions Whole n2l:: Ref Bugtracker Project Page Report a Bug Bug List Related Things Life 2130 Devel Game Journal

LibN2L-4 Library Code Reference Classes Compounds Files Members Method Index Full Reference cDynVar.cpp Go to the documentation of this file. /************************************************************************ Nova-2 Library (libN2L, or simply n2l) Game development C++ Library Copyright (C) 2003 Aaron Cameron This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA A copy of the GNU Lesser General Public License has been provided with this library in the file 'COPYING'. Contact information for the author of this library has been provided with this library in the file 'AUTHOR'. ************************************************************************/ #include "cDynVar.h" #include "n2l/timing.h" #include <stdlib.h> #include <iostream> using namespace std; namespace n2l { tUint cDynVar::smCount[6] = { 0,0,0,0,0,0 }; const cDynVar::tDynVarArray cDynVar::Array; const cDynVar cDynVar::NoKey( cDynVar::Array ); const cDynVar cDynVar::Null( cDynVar::VarType_Null ); /* ********************************************************************** */ cDynVar::cDynVar() : mType(VarType_Null) { memset(&mValue,0,sizeof(tValue)); } /* ********************************************************************** */ cDynVar::cDynVar( const tVarType iType ) : mType(iType) { memset(&mValue,0,sizeof(tValue)); if (mType==VarType_String) { mValue.mString = new char[1]; mValue.mString[0] = '\0'; } if (mType==VarType_Array) { mValue.mArray = new tDynVarArray; } } /* ********************************************************************** */ cDynVar::cDynVar( const cDynVar & iDynVar ) { mType = VarType_Sint32; memset(&mValue,0,sizeof(tValue)); assign(iDynVar); } /* ********************************************************************** */ cDynVar::cDynVar( const char * const iValue ) : mType(VarType_String) { if (!iValue) throw cBadDataUseException( "cDynVar::cDynVar(const char * const)", "Null string" ); mValue.mString = new char[ strlen(iValue)+1 ]; strcpy(mValue.mString,iValue); } /* ********************************************************************** */ cDynVar::cDynVar( const tString & iValue ) : mType(VarType_String) { mValue.mString = new char[ iValue.size()+1 ]; strcpy(mValue.mString,iValue.c_str()); } /* ********************************************************************** */ cDynVar::cDynVar( const tSint iValue ) : mType(VarType_Sint32) { mValue.mSint32 = iValue; } /* ********************************************************************** */ cDynVar::cDynVar( const tUint iValue ) : mType(VarType_Sint32) { mValue.mSint32 = tSint(iValue); } /* ********************************************************************** */ cDynVar::cDynVar( const tFloat iValue ) : mType(VarType_Float) { mValue.mFloat = iValue; } /* ********************************************************************** */ cDynVar::cDynVar( const tBool iValue ) : mType(VarType_Bool) { mValue.mBool = iValue; } /* ********************************************************************** */ cDynVar::cDynVar( const tDynVarArray & iValue ) : mType(VarType_Array) { mValue.mArray = new tDynVarArray( iValue ); } /* ********************************************************************** */ cDynVar::~cDynVar() { if (mType==VarType_String && mValue.mString) { delete []mValue.mString; mValue.mString = 0; } if (mType==VarType_Array && mValue.mArray) { delete mValue.mArray; mValue.mArray = 0; } } /* ********************************************************************** */ void cDynVar::assign( const cDynVar & iDynVar ) { // Let's make sure that we're not self assigning if (&iDynVar == this) return; // Before we do anything, if we're a tString we have to delete // the char* we currently hold if (mType==VarType_String && mValue.mString) { delete []mValue.mString; mValue.mString = 0; } // Also, if we're an array, we have to delete that as well. if (mType==VarType_Array && mValue.mArray) { delete mValue.mArray; mValue.mArray = 0; } // This is safe no matter what, we'll just replace mValue if // we have to mType = iDynVar.mType; mValue = iDynVar.mValue; // If we're copying a string if (mType==VarType_String) { mValue.mString = new char[ iDynVar.size()+1 ]; strcpy(mValue.mString, iDynVar.mValue.mString); } if (mType==VarType_Array) { mValue.mArray = new tDynVarArray( *(iDynVar.mValue.mArray) ); } } /* ********************************************************************** */ cDynVar & cDynVar::operator =( const cDynVar & iDynVar ) { assign(iDynVar); return *this; } /* ********************************************************************** */ void cDynVar::eval( const tString & iValStr ) { // Is the tString empty? if (iValStr.empty()) { assign(0); return; } // Note: This will never evaluate to an array or null // Try to detect the type of information in the tString // First thing we'll do is find out if there's alpha characters // present const tBool IsNumeric = isNumericStr(iValStr,true); // true: . allowed if (!IsNumeric) { assign(iValStr); return; } // Looks numeric, let's make sure const tString::size_type NegPos = iValStr.rfind('-'); if (NegPos!=0 && NegPos!=tString::npos) { // Negative sign somewhere not the beginning of the // value. It's a tString afterall. assign(iValStr); return; } // It is numeric, we need to figure out what kind const tString::size_type DecimalPos = iValStr.find('.'); if (tString::npos!=DecimalPos) { // Is it a float? // Looks like it let's make sure if (DecimalPos!=iValStr.rfind('.')) { // Two or more decimals? It's a tString after all. assign( iValStr ); return; } // Still a float, ok, let's trust it now assign( asFloat(iValStr) ); return; } // It has to be an int assign( asSint32(iValStr) ); } /* ********************************************************************** */ cDynVar::operator const tString() const { static const tString ArrayStr("Array"); static const tString NullStr(""); switch (mType) { case VarType_String: return mValue.mString; case VarType_Sint32: return asString( mValue.mSint32 ); case VarType_Float: return asString( double(mValue.mFloat) ); case VarType_Bool: return asString( mValue.mBool ); case VarType_Array: return ArrayStr; case VarType_Null: return NullStr; } throw cBadDataUseException( "cDynVar::operator tString", "Internal type is unknown" ); } /* ********************************************************************** */ cDynVar::operator const tSint() const { switch (mType) { case VarType_String: return asSint32(mValue.mString); case VarType_Sint32: return mValue.mSint32; case VarType_Float: return tSint32(mValue.mFloat); case VarType_Bool: return tSint32(mValue.mBool); case VarType_Array: return (mValue.mArray->empty()?0:1); case VarType_Null: return 0; } throw cBadDataUseException( "cDynVar::operator n2l::Sint32", "Internal type is unknown" ); } /* ********************************************************************** */ cDynVar::operator const tFloat() const { switch (mType) { case VarType_String: return asFloat(mValue.mString); case VarType_Sint32: return tFloat(mValue.mSint32); case VarType_Float: return mValue.mFloat; case VarType_Bool: return tFloat(mValue.mBool); case VarType_Array: return tFloat(mValue.mArray->empty()?0:1); case VarType_Null: return 0.0f; } throw cBadDataUseException( "cDynVar::operator n2l::float", "Internal type is unknown" ); } /* ********************************************************************** */ cDynVar::operator const tBool() const { switch (mType) { case VarType_String: { if (mValue.mString==0) return false; const tUint32 SLength = strlen(mValue.mString); if (SLength==0) return false; if (mValue.mString[0]=='0') return false; return true; } case VarType_Sint32: return tBool(mValue.mSint32); case VarType_Float: return tBool(mValue.mFloat); case VarType_Bool: return mValue.mBool; case VarType_Array: return tBool(mValue.mArray->empty()?false:true); case VarType_Null: return false; } throw cBadDataUseException( "cDynVar::operator n2l::bool", "Internal type is unknown" ); } /* ********************************************************************** */ const cDynVar::tVarType cDynVar::type() const { return mType; } /* ********************************************************************** */ const tString & cDynVar::anyTypeStr( const tVarType iType ) { static const tString smStringTypeStr("string"); static const tString smSint32TypeStr("int"); static const tString smFloatTypeStr("float"); static const tString smBoolTypeStr("bool"); static const tString smArrayTypeStr("array"); static const tString smNullTypeStr("null"); switch (iType) { case VarType_String: return smStringTypeStr; case VarType_Sint32: return smSint32TypeStr; case VarType_Float: return smFloatTypeStr; case VarType_Bool: return smBoolTypeStr; case VarType_Array: return smArrayTypeStr; case VarType_Null: return smNullTypeStr; } // We have idea what to do with this. throw cBadDataUseException( "cDynVar::typeStr", tString("Type is unknown") + asString(iType) ); } /* ********************************************************************** */ const tString & cDynVar::typeStr() const { return anyTypeStr(mType); } /* ********************************************************************** */ const cDynVar::tSize cDynVar::size() const { switch (mType) { case VarType_String: if (0==mValue.mString) return 0; return strlen(mValue.mString); case VarType_Sint32: return 4; case VarType_Float: return sizeof(float); case VarType_Bool: return sizeof(tBool); case VarType_Array: return mValue.mArray->size(); case VarType_Null: return 0; } // We have idea what to do with this. throw cBadDataUseException( "cDynVar::size", "Internal type is unknown" ); } /* ********************************************************************** */ const cDynVar cDynVar::casted( const tVarType iType ) const { switch (iType) { case VarType_String: return tString(*this); case VarType_Sint32: return tSint32(*this); case VarType_Float: return float(*this); case VarType_Bool: return tBool(*this); case VarType_Array: { if (mType==VarType_Array) return *this; cDynVar temp( cDynVar::Array ); temp[0] = *this; return temp; } case VarType_Null: return Null; } // We have idea what to do with this. throw cBadDataUseException( "cDynVar::casted", "Internal type is unknown" ); } /* ********************************************************************** */ cDynVar & cDynVar::cast( const tVarType iType ) { cDynVar newVar; switch (iType) { case VarType_String: newVar = tString(*this); *this = newVar; return *this; case VarType_Sint32: newVar = tSint32(*this); *this = newVar; return *this; case VarType_Float: newVar = float(*this); *this = newVar; return *this; case VarType_Bool: newVar = tBool(*this); *this = newVar; return *this; case VarType_Array: newVar = cDynVar::Array; newVar[0] = *this; *this = newVar; return *this; case VarType_Null: *this = Null; return *this; } // We have idea what to do with this. throw cBadDataUseException( "cDynVar::cast", "Internal type is unknown" ); } /* ********************************************************************** */ void cDynVar::mkNumeric() { *this = asNumeric(); } /* ********************************************************************** */ const cDynVar cDynVar::asNumeric() const { switch (mType) { case VarType_String: { tUint32 i = 0; while (mValue.mString[i]!='\0' && mValue.mString[i]!='.') ++i; if (mValue.mString[i]=='.') return asFloat(mValue.mString); return asSint32(mValue.mString); } case VarType_Sint32: return *this; case VarType_Float: return *this; case VarType_Bool: return tSint32(mValue.mBool); case VarType_Array: return (mValue.mArray->size()?1:0); case VarType_Null: return 0; } // We have idea what to do with this. throw cBadDataUseException( "cDynVar::asNumeric", "Internal type is unknown" ); } /* ********************************************************************** */ const tBool cDynVar::isNumericType() const { return (mType==VarType_Sint32 || mType==VarType_Float); } /* ********************************************************************** */ const tBool cDynVar::isNumericValue() const { if (mType==VarType_Null) return false; if (mType!=VarType_String && mType!=VarType_Array) return true; if (mType==VarType_String) { // If the string only contains numeric symbols, one or fewer // decimals and one or fewer '-' signs in the first charater // position. const tUint StrLen( strlen(mValue.mString) ); tUbyte dCount = 0; for (tUint cPos=0; cPos<StrLen; ++cPos) { char c = mValue.mString[cPos]; if (c=='-' && cPos==0) continue; if (c=='.') { if (dCount==0) { ++dCount; continue; } else return false; } if (c=='f') { if (cPos+1==StrLen) return true; else return false; } if (c<'0' || c>'9') return false; } return true; } return false; } /* ********************************************************************** */ cDynVar &cDynVar::insert( const cDynVar & iValue ) { if (!isArray()) throw cBadDataUseException( "cDynVar::insert", "Can\'t insert into non-array types" ); cDynVar *next = &((*(mValue.mArray))[ getKey(nextIntegralKey(*(mValue.mArray))) ]); *next = iValue; return *next; } /* ********************************************************************** */ cDynVar &cDynVar::insert(const cDynVar & iKey, const cDynVar & iValue ) { cDynVar *next; if (!isArray()) throw cBadDataUseException( "cDynVar::insert", "Can\'t insert into non-array types" ); if (&iKey==&NoKey) { next = &((*(mValue.mArray))[ getKey(nextIntegralKey(*(mValue.mArray)))]); *next = iValue; } else { if (iKey.isArray()) throw cBadDataUseException( "cDynVar::insert", "Arrays may not be keys" ); next = &((*(mValue.mArray))[ getKey(iKey) ]); *next = iValue; } return *next; } /* ********************************************************************** */ const tBool cDynVar::keyExists( const cDynVar &iKey ) const { if (!isArray()) return false; if (iKey.isNull()) return false; const tDynVarArray::const_iterator IT( mValue.mArray->find(getKey(iKey)) ); return (IT!=mValue.mArray->end()); } /* ********************************************************************** */ const tBool cDynVar::keyExistsAsArray( const cDynVar &iKey ) const { if (!isArray()) return false; if (iKey.isNull()) return false; const tDynVarArray::const_iterator IT( mValue.mArray->find(getKey(iKey)) ); if (IT == mValue.mArray->end()) return false; if (!IT->second.isArray()) return false; return true; } /* ********************************************************************** */ const cDynVar &cDynVar::operator []( const cDynVar &iKey ) const { static const cDynVar NoValue( false ); if (iKey.isNull()) return NoValue; switch (mType) { case VarType_Array: { tDynVarArray::const_iterator vIT( mValue.mArray->find(getKey(iKey)) ); if (vIT==mValue.mArray->end()) return NoValue; return vIT->second; } default: return NoValue; } // switch } /* ********************************************************************** */ cDynVar &cDynVar::operator []( const cDynVar & iKey ) { if (mType!=VarType_Array) throw cBadDataUseException( "cDynVar::operator []", "Non-const [] accessor cannot create a " "key in a non-array structure" ); if (&iKey==&NoKey || iKey.isNull()) return ((*(mValue.mArray))[ getKey(nextIntegralKey(*(mValue.mArray))) ] = false); return (*mValue.mArray)[getKey(iKey)]; } /* ********************************************************************** */ const cDynVar &cDynVar::keyValueOr( const cDynVar &iKey, const cDynVar &iDefault ) const { if (mType!=VarType_Array || &iKey==&NoKey || iKey.isNull()) return iDefault; tDynVarArray::const_iterator vIT( mValue.mArray->find(getKey(iKey)) ); if (vIT==mValue.mArray->end()) return iDefault; return vIT->second; } /* ********************************************************************** */ const cDynVar::tConstIterator cDynVar::begin() const { if (mType!=VarType_Array) throw cBadDataUseException( "cDynVar::begin (const)", "Cannot get the beginning iterator of a " "non-array structure" ); return mValue.mArray->begin(); } /* ********************************************************************** */ const cDynVar::tConstIterator cDynVar::end() const { if (mType!=VarType_Array) throw cBadDataUseException( "cDynVar::end (const)", "Cannot get the end iterator of a " "non-array structure" ); return mValue.mArray->end(); } /* ********************************************************************** */ const cDynVar::tConstIterator cDynVar::find( const cDynVar &iKey ) const { if (mType!=VarType_Array) throw cBadDataUseException( "cDynVar::end (const)", "Cannot get the end iterator of a non-array structure" ); return mValue.mArray->find( iKey ); } /* ********************************************************************** */ const cDynVar cDynVar::operator -( const cDynVar & iRValue ) const { cDynVar lSide, rSide; if (isNumericType()) lSide = *this; else lSide = asNumeric(); if (iRValue.isNumericType()) rSide = iRValue; else rSide = iRValue.asNumeric(); // Do the math if (lSide.mType==VarType_Float || rSide.mType==VarType_Float) return float(lSide)-float(rSide); return tSint32(lSide)-tSint32(rSide); } /* ********************************************************************** */ const cDynVar cDynVar::operator +( const cDynVar & iRValue ) const { cDynVar lSide, rSide; if (isNumericType()) lSide = *this; else lSide = asNumeric(); if (iRValue.isNumericType()) rSide = iRValue; else rSide = iRValue.asNumeric(); // Do the math if (lSide.mType==VarType_Float || rSide.mType==VarType_Float) return float(lSide)+float(rSide); return tSint32(lSide)+tSint32(rSide); } /* ********************************************************************** */ const cDynVar cDynVar::operator *( const cDynVar & iRValue ) const { cDynVar lSide, rSide; if (isNumericType()) lSide = *this; else lSide = asNumeric(); if (iRValue.isNumericType()) rSide = iRValue; else rSide = iRValue.asNumeric(); // Do the math if (lSide.mType==VarType_Float || rSide.mType==VarType_Float) return float(lSide)*float(rSide); return tSint32(lSide)*tSint32(rSide); } /* ********************************************************************** */ const cDynVar cDynVar::operator /( const cDynVar & iRValue ) const { cDynVar lSide, rSide; if (isNumericType()) lSide = *this; else lSide = asNumeric(); if (iRValue.isNumericType()) rSide = iRValue; else rSide = iRValue.asNumeric(); // Do the math if (lSide.mType==VarType_Float || rSide.mType==VarType_Float) return float(lSide)/float(rSide); // Do some auto sensing. We want to send back a float if necessary, // but prefer Sint32 const div_t r = div(tSint32(lSide),tSint32(rSide)); if (r.rem!=0) return float(lSide)/float(rSide); return r.quot; } /* ********************************************************************** */ const cDynVar cDynVar::operator %( const cDynVar & iRValue ) const { return tSint32(*this)%tSint32(iRValue); } /* ********************************************************************** */ const cDynVar cDynVar::operator ==( const cDynVar & iRValue ) const { // String vs String is always compared as tStrings if (mType==VarType_String && iRValue.mType==VarType_String) return (strcmp(mValue.mString,iRValue.mValue.mString)==0); // If not strings and either side is Null, we have some special rules if (isNull() || iRValue.isNull()) { return (tBool(*this)==tBool(iRValue)); } // If the left or right sides are not integer convertable, make them // both strings. if (!isNumericValue() || !iRValue.isNumericValue()) { return tString(*this)==tString(iRValue); } // We know we're dealing with something numeric, or easily // cast to numeric, so continue that way. cDynVar lSide, rSide; if (isNumericType()) lSide = *this; else lSide = asNumeric(); if (iRValue.isNumericType()) rSide = iRValue; else rSide = iRValue.asNumeric(); // Same as normal math, upscale to float if either side is if (lSide.mType==VarType_Float || rSide.mType==VarType_Float) return float(lSide)==float(rSide); // Must be integers, good stuff return tSint32(lSide)==tSint32(rSide); } /* ********************************************************************** */ const cDynVar cDynVar::operator !=( const cDynVar & iRValue ) const { return !(*this==iRValue); } /* ********************************************************************** */ const cDynVar cDynVar::operator >( const cDynVar &iRValue ) const { // String vs String is always compared as tStrings if (mType==VarType_String && iRValue.mType==VarType_String) return (strcmp(mValue.mString,iRValue.mValue.mString)>0); else if (mType==VarType_Null) return false; else if (mType==VarType_String && iRValue.mType==VarType_Null) return mValue.mString[0]!='\0'; // We know we're dealing with something numeric, or easily // cast to numeric, so continue that way. cDynVar lSide, rSide; if (isNumericType()) lSide = *this; else lSide = asNumeric(); if (iRValue.isNumericType()) rSide = iRValue; else rSide = iRValue.asNumeric(); // Same as normal math, upscale to float if either side is if (lSide.mType==VarType_Float || rSide.mType==VarType_Float) return float(lSide)>float(rSide); // Must be integers, good stuff return tSint32(lSide)>tSint32(rSide); } /* ********************************************************************** */ const cDynVar cDynVar::operator <( const cDynVar & iRValue ) const { // String vs String is always compared as tStrings if (mType==VarType_String && iRValue.mType==VarType_String) return (strcmp(mValue.mString,iRValue.mValue.mString)<0); else if (mType==VarType_Null && iRValue.mType==VarType_Null) return false; else if (mType==VarType_Null && iRValue.mType==VarType_String) return iRValue.mValue.mString[0]!='\0'; else if (iRValue.mType==VarType_Null) return false; // We know we're dealing with something numeric, or easily // cast to numeric, so continue that way. cDynVar lSide, rSide; if (isNumericType()) lSide = *this; else lSide = asNumeric(); if (iRValue.isNumericType()) rSide = iRValue; else rSide = iRValue.asNumeric(); // Same as normal math, upscale to float if either side is if (lSide.mType==VarType_Float || rSide.mType==VarType_Float) return float(lSide)<float(rSide); // Must be integers, good stuff return tSint32(lSide)<tSint32(rSide); } /* ********************************************************************** */ const cDynVar cDynVar::operator >=( const cDynVar & iRValue ) const { return !(*this<iRValue); } /* ********************************************************************** */ const cDynVar cDynVar::operator <=( const cDynVar & iRValue ) const { return !(*this>iRValue); } /* ********************************************************************** */ const cDynVar cDynVar::operator !() const { return !(tBool(*this)); } /* ********************************************************************** */ const cDynVar & cDynVar::operator ++() { if (!isNumericType()) mkNumeric(); switch (mType) { case VarType_Sint32: ++mValue.mSint32; return *this; case VarType_Float: ++mValue.mFloat; return *this; case VarType_Null: *this = tSint(0); ++mValue.mSint32; return *this; // Include these to avoid a strict warning case VarType_String: case VarType_Bool: case VarType_Array: break; } // We have idea what to do with this. throw cBadDataUseException( "cDynVar::asNumeric", "Internal type is unknown" ); } /* ********************************************************************** */ const cDynVar & cDynVar::operator --() { if (!isNumericType()) mkNumeric(); switch (mType) { case VarType_Sint32: --mValue.mSint32; return *this; case VarType_Float: --mValue.mFloat; return *this; case VarType_Null: *this = tSint(0); --mValue.mSint32; return *this; // Include these to avoid a strict warning case VarType_String: case VarType_Bool: case VarType_Array: break; } // We have idea what to do with this. throw cBadDataUseException( "cDynVar::asNumeric", "Internal type is unknown" ); } /* ********************************************************************** */ const cDynVar cDynVar::operator ++(int) { cDynVar temp(*this); if (!isNumericType()) mkNumeric(); switch (mType) { case VarType_Sint32: ++mValue.mSint32; return temp; case VarType_Float: ++mValue.mFloat; return temp; case VarType_Null: *this = tSint(0); ++mValue.mSint32; return temp; // Include these to avoid a strict warning case VarType_String: case VarType_Bool: case VarType_Array: break; } // We have idea what to do with this. throw cBadDataUseException( "cDynVar::asNumeric", "Internal type is unknown" ); } /* ********************************************************************** */ const cDynVar cDynVar::operator --(int) { cDynVar temp(*this); if (!isNumericType()) mkNumeric(); switch (mType) { case VarType_Sint32: --mValue.mSint32; return temp; case VarType_Float: --mValue.mFloat; return temp; case VarType_Null: *this = tSint(0); --mValue.mSint32; return temp; // Include these to avoid a strict warning case VarType_String: case VarType_Bool: case VarType_Array: break; } // We have idea what to do with this. throw cBadDataUseException( "cDynVar::asNumeric", "Internal type is unknown" ); } /* ********************************************************************** */ cDynVar & cDynVar::operator +=( const cDynVar & iRValue ) { if (mType==VarType_Array) return *this; mkNumeric(); cDynVar rSide; if (iRValue.isNumericType()) rSide = iRValue; else rSide = iRValue.asNumeric(); if (mType==VarType_Float || rSide.mType==VarType_Float) { *this = float(*this)+float(rSide); return *this; } // Must be integers, good stuff *this = tSint32(*this)+tSint32(rSide); return *this; } /* ********************************************************************** */ cDynVar & cDynVar::operator -=( const cDynVar & iRValue ) { if (mType==VarType_Array) return *this; mkNumeric(); cDynVar rSide; if (iRValue.isNumericType()) rSide = iRValue; else rSide = iRValue.asNumeric(); if (mType==VarType_Float || rSide.mType==VarType_Float) { *this = float(*this)-float(rSide); return *this; } // Must be integers, good stuff *this = tSint32(*this)-tSint32(rSide); return *this; } /* ********************************************************************** */ cDynVar & cDynVar::operator *=( const cDynVar & iRValue ) { if (mType==VarType_Array) return *this; mkNumeric(); cDynVar rSide; if (iRValue.isNumericType()) rSide = iRValue; else rSide = iRValue.asNumeric(); if (mType==VarType_Float || rSide.mType==VarType_Float) { *this = float(*this)*float(rSide); return *this; } // Must be integers, good stuff *this = tSint32(*this)*tSint32(rSide); return *this; } /* ********************************************************************** */ cDynVar & cDynVar::operator /=( const cDynVar & iRValue ) { if (mType==VarType_Array) return *this; mkNumeric(); *this = *this / iRValue; return *this; } /* ********************************************************************** */ const tString cDynVar::dump( const tString & iIndent ) const { tString temp(iIndent+typeStr()); if (mType==VarType_Null) return temp; temp += '('; if (mType==VarType_String) { temp += asString(strlen(mValue.mString)); temp += ") \""; temp += mValue.mString; temp += '\"'; } else if (mType==VarType_Array) { temp += asString(mValue.mArray->size()); temp += ") {"; for (tDynVarArray::const_iterator it=mValue.mArray->begin(); it!=mValue.mArray->end(); ++it) { temp += "\n"; temp += iIndent; temp += " ["; temp += tString(it->first); temp += "]=>\n"; temp += it->second.dump( iIndent+" " ); } temp += "\n"; temp += iIndent; temp += "}"; } else { temp += tString(*this); temp += ')'; } return temp; } /* ********************************************************************** */ const tString cDynVar::serialize() const { tString temp; switch (mType) { case VarType_String: temp = "s:"; temp += asString(tUint32(strlen(mValue.mString))); temp += ":\""; temp += mValue.mString; temp += "\";"; return temp; case VarType_Sint32: temp = "i:"; temp += asString(mValue.mSint32); temp += ";"; return temp; case VarType_Float: temp = "d:"; temp += asString(mValue.mFloat); temp += ";"; return temp; case VarType_Bool: temp = "b:"; temp += asString(mValue.mBool); temp += ";"; return temp; case VarType_Array: { temp = "a:"; temp += asString(mValue.mArray->size()); temp += ":{"; for (tDynVarArray::const_iterator it=mValue.mArray->begin(); it!=mValue.mArray->end(); ++it) { // Key cDynVar key; key.eval(it->first); temp += key.serialize(); temp += it->second.serialize(); } temp += "}"; return temp; case VarType_Null: temp = "N;"; return temp; } // Case array } // switch // We have idea what to do with this. throw cBadDataUseException( "cDynVar::serialize", "Internal type is unknown" ); } /* ********************************************************************** */ void cDynVar::unserialize( const tString &iVarStr ) { static const tChar *White = "\t\n "; if (iVarStr.substr(0,16) == "n2l::cDynVar_100") { unserialize_raw_100( iVarStr, iVarStr.findFirstNotOf( White, 16 ) ); return; } unserialize( iVarStr, 0 ); } /* ********************************************************************** */ void cDynVar::unserialize( const tString &iVarStr, const tString::size_type &iSPos ) { if (iSPos>=iVarStr.size()) { assign(false); // Empty unserialize in PHP is false instead of null return; } tString::size_type ePos; unserializeValue( iVarStr,iSPos,*this,ePos ); } /**************************************************************************/ void cDynVar::unserialize_raw_100( const tString &iVarStr, const tString::size_type &iSPos ) { if (iSPos>=iVarStr.size()) { assign(false); // Empty unserialize in PHP is false instead of null return; } tString::size_type ePos; unserializeValue_raw_100( iVarStr,iSPos,*this,ePos ); } /* ********************************************************************** */ ostream & operator <<( ostream & ioStream, const cDynVar &iVar ) { return ioStream << tString(iVar); } /* ********************************************************************** */ const tSint cDynVar::nextIntegralKey( const tDynVarArray &iArray ) const { tSint k(-1); for (tDynVarArray::const_iterator it=iArray.begin(); it!=iArray.end(); ++it) { if (asSint32(it->first)>k) k = asSint32(it->first); } return ++k; } /* ********************************************************************** */ const tString cDynVar::getKey( const cDynVar & iVar ) const { tString key; if (iVar.isFloat() || iVar.isBool()) { key = asString(tSint(iVar)); } else { key = tString(iVar); } return key; } /* ********************************************************************** */ void cDynVar::unserializeValue( const tString & iVarStr, const tString::size_type iSPos, cDynVar & oValue, tString::size_type & oEPos ) const { if (&iSPos == &oEPos) throw cException( "cDynVar::unserializeValue", "iSPos and oEPos are the same variable. Aaron, don\'t make " "iSPos a const reference no matter how tempting it is." ); tUint timer(n2lGetTicks()); switch (iVarStr[iSPos]) { case 's': { // Unfortunately, we can't trust the size sent // instead we'll just limit by that. const tString::size_type SizeColSPos = iVarStr.find(':',iSPos+1); const tString::size_type SizeColEPos = iVarStr.find(':',SizeColSPos+1); const tString::size_type StrSQuotPos = iVarStr.find('\"',SizeColEPos+1); // If any of the above are npos, the deal is up if (SizeColSPos==tString::npos || SizeColEPos==tString::npos || StrSQuotPos==tString::npos) throw cParsingException("cDynVar::unserialize", "Control char missing from unserialize (decoding str)", iVarStr, "char(npos)" ); // Decode the size const tString::size_type DefinedStrLen = asUint32( iVarStr.substr(SizeColSPos+1,SizeColEPos-SizeColSPos-1)); if (DefinedStrLen+StrSQuotPos+2>iVarStr.size()) throw cParsingException("cDynVar::unserialize", "Defined size is larger then data", iVarStr,"" ); // Find the equote const tString::size_type StrSemiPos = iVarStr.rfind(';',DefinedStrLen+StrSQuotPos+2); const tString::size_type StrEQuotPos = iVarStr.rfind('\"',StrSemiPos-1); if (DefinedStrLen!=(StrEQuotPos-StrSQuotPos-1)) throw cParsingException("cDynVar::unserialize", "Defined size != Provided Str size (decoding str)", iVarStr,"" ); // Other critical relationships if (StrSQuotPos==StrEQuotPos) throw cParsingException("cDynVar::unserialize", "Start and end quote the same (decoding str)", iVarStr, asString(tUint32(StrEQuotPos)) ); if (StrSemiPos==tString::npos || StrEQuotPos==tString::npos) throw cParsingException("cDynVar::unserialize", "Control char missing from unserialize (decoding str)", iVarStr, "char(npos)" ); oEPos = StrSemiPos; oValue.assign( iVarStr.substr(StrSQuotPos+1,StrEQuotPos-StrSQuotPos-1) ); smCount[0] += n2lGetTicks()-timer; return; } case 'i': { const tString::size_type ColPos = iVarStr.find(':',iSPos); const tString::size_type StrSemiPos = iVarStr.find(';',iSPos); if (ColPos!=iSPos+1) throw cParsingException("cDynVar::unserialize", "Missing or misplaced \':\" char (decoding int)", iVarStr, asString(tUint32(ColPos)) ); if (StrSemiPos==tString::npos) throw cParsingException("cDynVar::unserialize", "Missing or misplaced \';\" char (decoding int)", iVarStr, asString(tUint32(StrSemiPos)) ); oEPos = StrSemiPos; oValue.assign( asSint32( iVarStr.substr(ColPos+1,StrSemiPos-ColPos-1)) ); smCount[1] += n2lGetTicks()-timer; return; } case 'd': { const tString::size_type ColPos = iVarStr.find(':',iSPos); const tString::size_type StrSemiPos = iVarStr.find(';',iSPos); if (ColPos!=iSPos+1) throw cParsingException("cDynVar::unserialize", "Missing or misplaced \':\" char (decoding float)", iVarStr, asString(tUint32(ColPos)) ); if (StrSemiPos==tString::npos) throw cParsingException("cDynVar::unserialize", "Missing or misplaced \';\" char (decoding float)", iVarStr, asString(tUint32(StrSemiPos)) ); oEPos = StrSemiPos; oValue.assign( asFloat(iVarStr.substr(ColPos+1,StrSemiPos-ColPos-1)) ); smCount[2] += n2lGetTicks()-timer; return; } case 'b': { const tString::size_type ColPos = iVarStr.find(':',iSPos); const tString::size_type StrSemiPos = iVarStr.find(';',iSPos); if (ColPos!=iSPos+1) throw cParsingException("cDynVar::unserialize", "Missing or misplaced \':\" char (decoding bool)", iVarStr, asString(tUint32(ColPos)) ); if (StrSemiPos==tString::npos) throw cParsingException("cDynVar::unserialize", "Missing or misplaced \';\" char (decoding bool)", iVarStr, asString(tUint32(StrSemiPos)) ); if (StrSemiPos!=(ColPos+2)) throw cParsingException("cDynVar::unserialize", "Bool value not exactly one character " "(decoding bool)", iVarStr, asString(tUint32(ColPos+1)) ); oEPos = StrSemiPos; if (iVarStr[ColPos+1] == '0') oValue.assign(false); else if (iVarStr[ColPos+1] == '1') oValue.assign(true); else throw cParsingException("cDynVar::unserialize", "Bool value not either 1 or 0 (decoding bool)", iVarStr, asString(tUint32(ColPos+1)) ); smCount[3] += n2lGetTicks()-timer; return; } case 'a': { oValue.assign( cDynVar::Array ); const tString::size_type SizeColSPos = iVarStr.find(':',iSPos+1); const tString::size_type SizeColEPos = iVarStr.find(':',SizeColSPos+1); const tString::size_type StrSBrakPos = iVarStr.find('{',SizeColEPos+1); // If any of the above are npos, the deal is up if (SizeColSPos==tString::npos || SizeColEPos==tString::npos || StrSBrakPos==tString::npos) throw cParsingException("cDynVar::unserialize", "Control char missing from unserialize " "(decoding str)", iVarStr, "char(npos)" ); // Decode the size. We can't trust it, but it might be // useful. tString::size_type pos( StrSBrakPos+1 ); cDynVar key,value; while (iVarStr[pos]!='}' && pos<iVarStr.size()) { unserializeValue( iVarStr, pos, key, pos ); ++pos; if (pos>=iVarStr.size()) throw cParsingException("cDynVar::unserialize", "Key with no value", iVarStr, "char(npos)" ); unserializeValue( iVarStr, pos, value, pos ); // Hack to not copy the value. This is dangerous. cDynVar &nValue = oValue.insert(key,cDynVar(0)); nValue.mType = value.mType; nValue.mValue = value.mValue; // Make sure that dallocation of 'value' does not // invalidate the copy we made into nValue. value.mType = VarType_Bool; value.mValue.mBool = false; // I should be shot for this, by the way. ++pos; } if (iVarStr[pos]!='}') throw cParsingException("cDynVar::unserialize", "Missing terminating \'}\'", iVarStr, "char(npos)" ); oEPos = pos; smCount[4] += n2lGetTicks()-timer; return; } case 'N': { const tString::size_type StrSemiPos = iVarStr.find(';',iSPos); if (StrSemiPos!=iSPos+1) throw cParsingException("cDynVar::unserialize", "Missing or misplaced \';\" char (decoding NULL)", iVarStr, asString(tUint32(iSPos)) ); oEPos = StrSemiPos; oValue.assign( Null ); smCount[5] += n2lGetTicks()-timer; return; } default: char type[2] = { iVarStr[iSPos], '\0' }; throw cParsingException( "cDynVar::unserialize", tString("Unknown or unsupported type: ") + type, iVarStr, "char(1)" ); } } // void cDynVar::unserializeValue /**************************************************************************/ void cDynVar::unserializeValue_raw_100( const tString &iVarStr, const tString::size_type iSPos, cDynVar &oValue, tString::size_type &oEPos ) const { static const tChar *White = "\t\n ,"; if (&iSPos == &oEPos) throw cException( "cDynVar::unserializeValue_raw_100", "iSPos and oEPos are the same variable. Aaron, don\'t make " "iSPos a const reference no matter how tempting it is." ); if (iSPos>=iVarStr.size()) throw cParsingException( "cDynVar::unserializeValue_raw_100", "No such position to take a type from", iVarStr, asString(iSPos) ); // Catch special case unary switch (iVarStr[iSPos]) { case 'n': oValue.unset(); oEPos = iSPos+1; return; case '#': throw tString("cDynVar::unserializeValue_raw_100: Comment"); return; default: break; } // Support shorthand for number types. if ((iVarStr[iSPos]>=48 && iVarStr[iSPos]<=57) || (iVarStr[iSPos]=='-') || (iVarStr[iSPos]=='.')) { // It's a straight up number and we'll evaluate it as such. oEPos = iVarStr.findFirstNotOf("0123456789.", iSPos+1); if (oEPos == tString::npos) oEPos = iVarStr.size(); oValue.eval( iVarStr.substr(iSPos, oEPos-iSPos) ); return; } const tString::size_type OPos = iVarStr.find( '(', iSPos+1 ); if (OPos==tString::npos) throw cParsingException( "cDynVar::unserializeValue_raw_100", "Missing value block character: \'(\'", iVarStr, asString(iSPos+1) ); switch (iVarStr[iSPos]) { case 's': { const tString::size_type CPos = findUnescaped( iVarStr, ')', OPos+1, '\\', '"' ); if (CPos == tString::npos) throw cParsingException( "cDynVar::unserializeValue_raw_100", "Missing value block character: \')\' " "(decoding string)", iVarStr, asString(iSPos+1) ); oValue.assign( unescapedString( iVarStr.substr( OPos+1, CPos-OPos-1 ), '\\', '"' ) ); oEPos = CPos+1; break; } case 'b': { const tString::size_type CPos = iVarStr.find(')', OPos+1); if (CPos == tString::npos) throw cParsingException( "cDynVar::unserializeValue_raw_100", "Missing value block character: \')\' " "(decoding bool)", iVarStr, asString(iSPos+1) ); if (CPos == OPos+1) oValue.assign(false); else switch (iVarStr[OPos+1]) { case '1': case 't': case 'T': oValue.assign(true); break; default: oValue.assign(false); break; } oEPos = CPos+1; break; } case 'i': { const tString::size_type CPos = iVarStr.find(')', OPos+1); if (CPos == tString::npos) throw cParsingException( "cDynVar::unserializeValue_raw_100", "Missing value block character: \')\' " "(decoding integer)", iVarStr, asString(iSPos+1) ); if (CPos == OPos+1) oValue.assign(0); else oValue.assign( asSint(iVarStr.substr( OPos+1, CPos-OPos-1 )) ); oEPos = CPos+1; break; } case 'f': { const tString::size_type CPos = iVarStr.find(')', OPos+1); if (CPos == tString::npos) throw cParsingException( "cDynVar::unserializeValue_raw_100", "Missing value block character: \')\' " "(decoding integer)", iVarStr, asString(iSPos+1) ); if (CPos == OPos+1) oValue.assign(0); else oValue.assign( asFloat(iVarStr.substr( OPos+1, CPos-OPos-1 )) ); oEPos = CPos+1; break; } case 'a': { oValue.assign(Array); tString::size_type pos = iVarStr.findFirstNotOf( White, OPos+1 ); while (pos!=tString::npos && iVarStr[pos]!=')') { tBool incInsert = false; pos = iVarStr.findFirstNotOf( White, pos ); cDynVar k; if (pos == tString::npos) throw cParsingException( "cDynVar::unserializeValue_raw_100", "Premature array termination. No key. " "(decoding array)", iVarStr, "end of string" ); if (iVarStr[pos]=='=') incInsert = true; else { unserializeValue_raw_100( iVarStr, pos, k, pos ); pos = iVarStr.find( '=', pos ); if (pos == tString::npos) throw cParsingException( "cDynVar::unserializeValue_raw_100", "Premature array termination. Key but no " "\'=\'. (decoding array)", iVarStr, "end of string" ); } ++pos; pos = iVarStr.findFirstNotOf( White, pos ); if (pos == tString::npos) throw cParsingException( "cDynVar::unserializeValue_raw_100", "Premature array termination. Key but no value. " "(decoding array)", iVarStr, "end of string" ); cDynVar v; unserializeValue_raw_100( iVarStr, pos, v, pos ); // Hack to not copy the value. This is dangerous. cDynVar &nValue = incInsert?oValue.insert(NoKey,cDynVar(0)): oValue.insert(k,cDynVar(0)); nValue.mType = v.mType; nValue.mValue = v.mValue; // Make sure that dallocation of 'v' does not // invalidate the copy we made into nValue. v.mType = VarType_Bool; v.mValue.mBool = false; // I should be shot for this, by the way. pos = iVarStr.findFirstNotOf( White, pos ); }; if (pos == tString::npos) throw cParsingException( "cDynVar::unserializeValue_raw_100", "Premature array termination. Missing \')\'. " "(decoding array)", iVarStr, "end of string" ); oEPos = pos+1; break; } default: throw cParsingException( "cDynVar::unserializeValue_raw_100", "I have no idea what this type is \"" + iVarStr.substr(iSPos,1) + "\"", iVarStr, asString(iSPos) ); }; } /**************************************************************************/ void cDynVar::unserializeStats( tUint &oDString, tUint &oDInt, tUint &oDFloat, tUint &oDBool, tUint &oDArray, tUint &oDNull ) { oDString = smCount[0]; oDInt = smCount[1]; oDFloat = smCount[2]; oDBool = smCount[3]; oDArray = smCount[4]; oDNull = smCount[5]; } /**************************************************************************/ void cDynVar::deepMerge( const cDynVar &iDef, const tBool iIntegersCollide ) { if (&iDef==this) { cDynVar tmp = iDef; deepMerge(tmp); return; } if (mType!=VarType_Array) { cDynVar tmp = *this; *this = cDynVar::Array; insert( tmp ); } if (!iDef.isArray()) { insert( iDef ); return; } cDynVar::tConstIterator Last = iDef.end(); cDynVar key; for (cDynVar::tConstIterator i = iDef.begin(); i!=Last; ++i) { if (!iIntegersCollide) { key.eval(i->first); if (key.isInt()) { insert( i->second ); continue; } } cDynVar::tConstIterator a = find(i->first); if (a!=end()) { if (i->second.isArray() && a->second.isArray()) (*this)[i->first].deepMerge( i->second,iIntegersCollide ); else (*this)[i->first] = i->second; } else insert( i->first, i->second ); } } } // namespace

©2012 Aaron Cameron