//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: Implementation of CLogEventArgument // // $Workfile: $ // $Date: $ // //------------------------------------------------------------------------------------------------------ // $Log: $ // // $NoKeywords: $ //=============================================================================// #pragma warning (disable:4786) #include <stdio.h> #include <stdlib.h> #include <string.h> #include "argument.h" #include "memdbg.h" using namespace std; //------------------------------------------------------------------------------------------------------ // Function: CLogEventArgument::CLogEventArgument // Purpose: Constructor that builds the object out of the passed in string of text // Input: text - text representing the argument //------------------------------------------------------------------------------------------------------ CLogEventArgument::CLogEventArgument(const char* text) { init(text); } //------------------------------------------------------------------------------------------------------ // Function: CLogEventArgument::CLogEventArgument // Purpose: Default constructor //------------------------------------------------------------------------------------------------------ CLogEventArgument::CLogEventArgument() :m_ArgText(NULL),m_Valid(false) {} //------------------------------------------------------------------------------------------------------ // Function: CLogEventArgument::init // Purpose: initializes the argument // Input: text - the text representing the argument //------------------------------------------------------------------------------------------------------ void CLogEventArgument::init(const char* text) { int len=strlen(text); m_ArgText=new TRACKED char[len+1]; strcpy(m_ArgText,text); m_Valid=true; } char* findStartOfSvrID(char* cs) { char* read=&cs[strlen(cs)-1]; while (read != cs) { if (*read=='<' && *(read+1) != 'W') // if we've found a svrID break; read--; } return read; } //------------------------------------------------------------------------------------------------------ // Function: CLogEventArgument::asPlayerGetID // Purpose: treats the argument as a player name, and returns the player ID. // Note: PlayerName args have this form: "name<pid><WON:wonid>" // Output: the ID of the player represented by this argument //------------------------------------------------------------------------------------------------------ int CLogEventArgument::asPlayerGetSvrPID() const { char* read=findStartOfSvrID(m_ArgText); if (read==m_ArgText) return -1; int retval=-1; sscanf(read,"<%i>",&retval); return retval; } /* PID CLogEventArgument::asPlayerGetPID() const { char* openPID=NULL; int svrPID=INVALID_PID; if (openPID=strchr(m_ArgText,'<')) { openPID++; sscanf(openPID,"%i",&svrPID); } unsigned long wonID; if (openPID=strstr(m_ArgText,"<WON:")) { openPID+=5; sscanf(openPID,"%li",&wonID); } return PID(svrPID,wonID); } */ //------------------------------------------------------------------------------------------------------ // Function: CLogEventArgument::asPlayerGetName // Purpose: treats the argument as a player name, and copies/returns the player name. // Note: PlayerName args have this form: "name<pid><WONID:wonid>" // Input: copybuf - the buffer to copy the name into // Output: char* the pointer to the buffer that the name was copied into //------------------------------------------------------------------------------------------------------ char* CLogEventArgument::asPlayerGetName(char* copybuf) const { char* eon=findStartOfSvrID(m_ArgText); bool noPID=(eon==m_ArgText); char old=*eon; if (!noPID) *eon=0; strcpy(copybuf,m_ArgText); if (!noPID) *eon=old; return copybuf; } //------------------------------------------------------------------------------------------------------ // Function: CLogEventArgument::asPlayerGetName // Purpose: an alternate form of the above function that returns the playername // as a C++ string, rather than buffercopying it around // Output: string: the player's name //------------------------------------------------------------------------------------------------------ string CLogEventArgument::asPlayerGetName() const { char* eon=findStartOfSvrID(m_ArgText); bool noPID=(eon==m_ArgText); char old=*eon; if (!noPID) *eon=0; string s(m_ArgText); if (!noPID) *eon=old; return s; } //------------------------------------------------------------------------------------------------------ // Function: CLogEventArgument::asPlayerGetWONID // Purpose: treats the argument as a player name, and returns the player's wonid // Note: PlayerName args have this form: "name<pid><WON:wonid>" // Output: int: the WONID of the player //------------------------------------------------------------------------------------------------------ unsigned long CLogEventArgument::asPlayerGetWONID() const { char* openPID=NULL; unsigned long retval=INVALID_WONID; if (openPID=strstr(m_ArgText,"<WON:")) { openPID+=5; //move past the <WON: string sscanf(openPID,"%lu",&retval); } return retval; } unsigned long CLogEventArgument::asPlayerGetPID() const { int svrPID=asPlayerGetSvrPID(); if (pidMap[svrPID]==0 || pidMap[svrPID]==-1) pidMap[svrPID]=svrPID; return pidMap[svrPID]; } //------------------------------------------------------------------------------------------------------ // Function: CLogEventArgument::getFloatValue // Purpose: treats the argument as a floating point value, and returns it // Output: double //------------------------------------------------------------------------------------------------------ double CLogEventArgument::getFloatValue() const { return atof(m_ArgText); } //------------------------------------------------------------------------------------------------------ // Function: CLogEventArgument::getStringValue // Purpose: treats the argument as a string and returns a pointer to the argument // text itself. note the pointer is const, so the argument can't be modified by // the caller (unless they perform some nefarious casting on the returned pointer) // Output: const char* //------------------------------------------------------------------------------------------------------ const char* CLogEventArgument::getStringValue() const { return m_ArgText; } //------------------------------------------------------------------------------------------------------ // Function: CLogEventArgument::getStringValue // Purpose: an alternate form of the above that copies the string into a caller // supplied buffer then returns a pointer to that buffer // Input: copybuf - the buffer into which the string is to be copied // Output: char* the pointer to the buffer that the caller passed in //------------------------------------------------------------------------------------------------------ char* CLogEventArgument::getStringValue(char* copybuf) const { strcpy(copybuf,m_ArgText); return copybuf; }