CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plStreamLogger/plStreamLogger.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 "plStreamLogger.h"
#include "hsExceptions.h"

#ifdef STREAM_LOGGER

//
// Base Stream Logger
//

void plStreamLogger::LogEntry(plGenericType::Types type, unsigned int size, void* value, const char* desc)
{
	if (fList)
	{
		plGenericVar var(desc);
		var.Value().SetVar(type,size,value);
		Event e(Event::kValue,size,var);
		fList->push_back(e);
		fEntryWaiting = false;
	}
}

void plStreamLogger::ILogEntryWaiting()
{
	fEntryWaiting = true;
}

bool plStreamLogger::IsLogEntryWaiting()
{
	return fEntryWaiting;
}

//
// Read-Only Logging Stream
//

void hsReadOnlyLoggingStream::LogStringString(const char* s)
{
	if (fList)
	{
		plGenericVar var;

		var.SetName(s);
		fList->push_back(Event(Event::kString,0,var));
	}
}

void hsReadOnlyLoggingStream::LogSubStreamStart(const char* desc)
{
	if (fList)
	{
		plGenericVar var;
		if (!fDescStack.empty())
		{
			var.SetName(fDescStack.front().c_str());
			fDescStack.pop_front();
		}
		else
			var.SetName(desc);
		fList->push_back(Event(Event::kSubStart,0,var));
	}
}

void hsReadOnlyLoggingStream::LogSubStreamEnd()
{
	if (fList)
	{
		plGenericVar var;
		fList->push_back(Event(Event::kSubEnd,0,var));
	}
}

void hsReadOnlyLoggingStream::LogSubStreamPushDesc(const char* desc)
{
	fDescStack.push_back(std::string(desc));
}

void hsReadOnlyLoggingStream::Rewind()
{
	hsThrow( "can't rewind a logging stream");
}

void hsReadOnlyLoggingStream::FastFwd()
{
	hsThrow( "can't fast forward a logging stream");
}

void hsReadOnlyLoggingStream::SetPosition(UInt32 position)
{
	hsThrow( "can't set position on a logging stream");
}

void hsReadOnlyLoggingStream::Skip(UInt32 deltaByteCount)
{
	hsReadOnlyStream::Skip(deltaByteCount);
	if (deltaByteCount > 0 && !IsLogEntryWaiting())
	{
		LogEntry(plGenericType::kNone,deltaByteCount,nil,"Unknown Skip");
	}
}

UInt32 hsReadOnlyLoggingStream::Read(UInt32 byteCount, void * buffer)
{
	UInt32 ret = hsReadOnlyStream::Read(byteCount,buffer);
	if (ret > 0 && !IsLogEntryWaiting())
	{
		LogEntry(plGenericType::kNone,byteCount,nil,"Unknown Read");
	}

	return ret;
}


void hsReadOnlyLoggingStream::LogSkip(UInt32 deltaByteCount, const char* desc)
{
	ILogEntryWaiting();
	Skip(deltaByteCount);
	if (deltaByteCount > 0)
	{
		LogEntry(plGenericType::kNone,deltaByteCount,nil,desc);
	}
}

UInt32 hsReadOnlyLoggingStream::LogRead(UInt32 byteCount, void * buffer, const char* desc)
{
	ILogEntryWaiting();
	UInt32 ret = Read(byteCount,buffer);
	if (ret > 0)
	{
		LogEntry(plGenericType::kNone,byteCount,nil,desc);
	}

	return ret;
}
char *hsReadOnlyLoggingStream::LogReadSafeString()
{
	LogSubStreamStart("push me");
	UInt16 numChars; 
	LogReadSwap(&numChars,"NumChars");

	numChars &= ~0xf000; // XXX: remove when hsStream no longer does this.
	if (numChars > 0)
	{		
		char *name = TRACKED_NEW char[numChars+1];
		ILogEntryWaiting();
		UInt32 ret = Read(numChars, name);
		name[numChars] = '\0';
		if (ret > 0)
		{
			LogEntry(plGenericType::kString,ret,name,"Value");
		}
		LogSubStreamEnd();
		return name;
	}
	LogSubStreamEnd();
	return nil;
}

char *hsReadOnlyLoggingStream::LogReadSafeStringLong()
{
	LogSubStreamStart("push me");
	UInt32 numChars; 
	LogReadSwap(&numChars,"NumChars");
	if (numChars > 0)
	{
		char *name = TRACKED_NEW char[numChars+1];
		ILogEntryWaiting();
		UInt32 ret = Read(numChars, name);
		name[numChars] = '\0';
		if (ret > 0)
		{
			LogEntry(plGenericType::kString,ret,name,"Value");
		}
		LogSubStreamEnd();
		return name;
	}
	LogSubStreamEnd();
	return nil;
}
#endif