Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

217 lines
6.9 KiB

//========= 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;
}