CWE-ou-minkata/Sources/Plasma/PubUtilLib/plNetClient/plNetObjectDebugger.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "plNetObjectDebugger.h"
#include "hsResMgr.h"
#include "hsTemplates.h"

#include "pnUtils/pnUtils.h"
#include "pnKeyedObject/hsKeyedObject.h"

#include "plStatusLog/plStatusLog.h"
#include "plResMgr/plKeyFinder.h"
#include "plNetClient/plNetClientMgr.h"
#include "plAgeLoader/plAgeLoader.h"

plNetObjectDebugger::DebugObject::DebugObject(const char* objName, plLocation& loc, UInt32 flags) : 
fLoc(loc), 
fFlags(flags)
{ 
	std::string tmp = objName;
	hsStrLower((char*)tmp.c_str());
	fObjName = tmp;
}

//
// return true if string matches objName according to flags
//
bool plNetObjectDebugger::DebugObject::StringMatches(const char* str) const
{
	if (!str)
		return false;

	if (fFlags & kExactStringMatch)
		return !stricmp(str, fObjName.c_str());

	if (fFlags & kEndStringMatch)
	{
		int len=strlen(str);
		if (len>fObjName.size())
			return false;
		return !stricmp(str, fObjName.c_str()+fObjName.size()-len);
	}

	if (fFlags & kStartStringMatch)
	{
		int len=strlen(str);
		if (len>fObjName.size())
			return false;
		return !strnicmp(str, fObjName.c_str(), strlen(str));
	}

	if (fFlags & kSubStringMatch)
	{
		std::string tmp = str;
		hsStrLower((char*)tmp.c_str());
		return (strstr(tmp.c_str(), fObjName.c_str()) != nil);
	}

	hsAssert(false, "missing flags");
	return false;
}

//
// if both objName and pageName are provided, and this object has page info,
//		return true if object matches both string and location.
// else just return true if object matches string
// 
bool plNetObjectDebugger::DebugObject::ObjectMatches(const char* objName, const char* pageName)
{
	if (!objName)
		return false;

	if (!pageName || (fFlags & kPageMatch)==0)
	{
		// only have enough info to match by objName
		return StringMatches(objName);
	}

	plLocation loc;
	loc = plKeyFinder::Instance().FindLocation(NetCommGetAge()->ageDatasetName, pageName);
	return (StringMatches(objName) && loc==fLoc);
}

//
// try to match by plLocation
//
bool plNetObjectDebugger::DebugObject::ObjectMatches(const hsKeyedObject* obj)
{
	if (!obj || !obj->GetKey())
		return false;

	if ((fFlags & kPageMatch)==0)
	{
		// match based on object name only
		return StringMatches(obj->GetKeyName());
	}

	return (obj->GetKey()->GetUoid().GetLocation()==fLoc);
}

/////////////////////////////////////////////////////////////////
// plNetObjectDebugger
/////////////////////////////////////////////////////////////////
plNetObjectDebugger::plNetObjectDebugger() : fStatusLog(nil), fDebugging(false)
{
}

plNetObjectDebugger::~plNetObjectDebugger() 
{ 
	ClearAllDebugObjects();	
	delete fStatusLog;
}

//
// STATIC
//
plNetObjectDebugger* plNetObjectDebugger::GetInstance()
{
	static plNetObjectDebugger gNetObjectDebugger;
	
	if (plNetObjectDebuggerBase::GetInstance()==nil)
		plNetObjectDebuggerBase::SetInstance(&gNetObjectDebugger);

	return &gNetObjectDebugger;
}

//
// create StatusLog if necessary
//
void plNetObjectDebugger::ICreateStatusLog() const
{
	if (!fStatusLog)
	{
		fStatusLog = plStatusLogMgr::GetInstance().CreateStatusLog(40, "NetObject.log", 
			plStatusLog::kFilledBackground | plStatusLog::kAlignToTop | plStatusLog::kTimestamp );
	}
}

bool plNetObjectDebugger::AddDebugObject(const char* objName, const char* pageName)
{
	if (!objName)
		return false;

	int size=strlen(objName)+1;
	hsTempArray<char> tmpObjName(size);
	memset(tmpObjName, 0, size);

	//
	// set string matching flags
	//
	int len = strlen(objName);
	UInt32 flags=0;
	if (objName[0]=='*')
	{
		if (objName[len-1]=='*')
		{
			flags = kSubStringMatch;	// *foo*
			strncpy(tmpObjName, objName+1, strlen(objName)-2);
		}
		else
		{
			flags = kEndStringMatch;	// *foo
			strncpy(tmpObjName, objName+1, strlen(objName)-1);
		}
	}

	if (!flags && objName[len-1]=='*')
	{
		flags = kStartStringMatch;		// foo*
		strncpy(tmpObjName, objName, strlen(objName)-1);
	}

	if (!flags)
	{
		flags = kExactStringMatch;
		strcpy(tmpObjName, objName);
	}

	//
	// set plLocation
	//
	plLocation loc;
	if (pageName)
	{
		loc = plKeyFinder::Instance().FindLocation(NetCommGetAge()->ageDatasetName, pageName);
		flags |= kPageMatch;
	}

	fDebugObjects.push_back(TRACKED_NEW DebugObject(tmpObjName, loc, flags));

	ICreateStatusLog();

	return true;
}

bool plNetObjectDebugger::RemoveDebugObject(const char* objName, const char* pageName)
{
	bool didIt=false;
	if (!pageName)
	{
		DebugObjectList::iterator it =fDebugObjects.begin();
		for( ; it != fDebugObjects.end(); )
		{
			if ( (*it) && (*it)->ObjectMatches(objName, pageName))
			{
				delete *it;
				it = fDebugObjects.erase(it);
				didIt=true;
			}
			else
				it++;
		}
	}

	return didIt;
}

void plNetObjectDebugger::ClearAllDebugObjects()
{
	DebugObjectList::iterator it =fDebugObjects.begin();
	for( ; it != fDebugObjects.end(); it++)
	{
		delete *it;
	}
	fDebugObjects.clear();
}

//
// write to status log if there's a string match
//
void plNetObjectDebugger::LogMsgIfMatch(const char* msg) const
{
	if (GetNumDebugObjects()==0 || !msg)
		return;

	// extract object name from msg, expects '...object:foo,...'
	std::string tmp = msg;
	hsStrLower((char*)tmp.c_str());
	std::string objTag="object";
	const char* c=strstr(tmp.c_str(), objTag.c_str());
	if (c && c != tmp.c_str())
	{
		c+=objTag.size();

		// move past spaces
		while ( *c || *c==' ' )
			c++;

		char objName[128];
		int i=0;
		
		// copy objName token
		while(*c && *c != ',' && *c != ' ' && i<127)
			objName[i++] = *c++;	
		objName[i]=0;

		DebugObjectList::const_iterator it = fDebugObjects.begin();
		for( objName[0]; it != fDebugObjects.end(); it++)
		{
			if ((*it) && (*it)->StringMatches(objName))
			{
				LogMsg(msg);
				break;
			}
		}
	}
}

void plNetObjectDebugger::LogMsg(const char* msg) const
{
	DEBUG_MSG(msg);
}
	
bool plNetObjectDebugger::IsDebugObject(const hsKeyedObject* obj) const
{
	DebugObjectList::const_iterator it =fDebugObjects.begin();
	for( ; it != fDebugObjects.end(); it++)
		if ((*it) && (*it)->ObjectMatches(obj))
		{
			return true;
		}

	return false;
}