CWE-ou-minkata/Sources/Plasma/PubUtilLib/plResMgr/plIndexFile.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==*/
#define plIndexFile_cpp		// for version numbers in plVersion.h

#include "plIndexFile.h"
#include "hsStream.h"
#include "plVersion.h"

//--------------------
// plIndexFileHeader
//--------------------

plIndexFileHeader::plIndexFileHeader()
{
	fTimeStamp[ 0 ] = fTimeStamp[ 1 ] = 0;
	fStrTblStartPos = 0;
	fStrTblKnt		= 0;
	fMajorVersion	= plVersion::GetMajorVersion();
	fMinorVersion	= plVersion::GetMinorVersion();
	fExportLocal = 0;
}

void plIndexFileHeader::Write(hsStream *s)	
{	
	s->WriteSwap32(2,fTimeStamp);
	s->WriteSwap32(fStrTblStartPos); 
	s->WriteSwap16(fStrTblKnt);
	s->WriteSwap16(fMajorVersion);
	s->WriteSwap16(fMinorVersion);
	s->WriteSwap16(fExportLocal);
} 
void plIndexFileHeader::Read(hsStream *s)	
{	
	s->ReadSwap32(2,fTimeStamp);
	fStrTblStartPos = s->ReadSwap32(); 
	fStrTblKnt		= s->ReadSwap16();
	fMajorVersion	= s->ReadSwap16();
	fMinorVersion	= s->ReadSwap16();
	fExportLocal = s->ReadSwap16();
} 

//--------------------
// plIndexFileRoom
//--------------------

void plIndexFileRoom::Write(hsStream *s)	
{	
	fRmUoid.Write(s);
	s->WriteSwap32(fTypesInRoom); 
	s->WriteSwap16(fFiller1_16);
	s->WriteSwap32(fFiller2_32);
	s->WriteSwap32(fFiller3_32);
} 
void plIndexFileRoom::Read(hsStream *s)	
{	
	fRmUoid.Read(s);
	fTypesInRoom = s->ReadSwap32(); 
	s->ReadSwap16();
	s->ReadSwap32();
	s->ReadSwap32();
} 
//--------------------
// plIndexFileType
//--------------------


void plIndexFileType::Write(hsStream *s)
{	
	fTypeUoid.Write(s);
	s->WriteSwap32(fNumKeys); 
	s->WriteSwap32(fFiller1_32);
	s->WriteSwap32(fFiller2_32);
}
 
void plIndexFileType::Read(hsStream *s)	
{	
	fTypeUoid.Read(s);
	fNumKeys = s->ReadSwap32(); 
	s->ReadSwap32();
	s->ReadSwap32();
} 
//--------------------
// plIndexFileKey
//--------------------


void plIndexFileKey::Write(hsStream *s)	
{	
	fKeyUoid.Write(s);
	s->WriteSwap32(fStartPos); 
	s->WriteSwap32(fDataLen);
	s->WriteSwap16(fNameIx);
	s->WriteSwap16(fFiller1_16);
}


void plIndexFileKey::Read(hsStream *s)
{	
	fKeyUoid.Read(s);
	fStartPos = s->ReadSwap32(); 
	fDataLen = s->ReadSwap32(); 
	fNameIx = s->ReadSwap16();
	s->ReadSwap16();
}


 

//--------------------
// plIxStrTbl
//--------------------

plIxStrTbl::~plIxStrTbl() 
{ 
	if (fpStrings) delete []fpStrings;  // if strings came from elsewhere, not our responsibility
} 

UInt16 plIxStrTbl::AddString(const char *p)
{	Int16 ix = FindString(p); 
	if (ix != -1) 
		return ix; // duplicate
	fStringTbl.push_back(p); return fStringTbl.size() - 1; 
}

Int16 plIxStrTbl::FindString(const char *p)
{
	for (int i=0; i < fStringTbl.size(); i++)
	{	
		if (!_stricmp(p,fStringTbl[i]))
			return i;
	}
	return -1;
}

void plIxStrTbl::Write(hsStream *s)	
{	
	for (int i=0; i < fStringTbl.size(); i++)
	{	Int32 len= fStringTbl[i] ? strlen(fStringTbl[i]) : 0;
		hsAssert(len < 256,"Name string too long");
		UInt8 l = (UInt8) len;
		s->WriteByte(l);						// FUTURE, don't really need length!
		if (len)
		{
			s->Write(len, fStringTbl[i]);
		}
		s->WriteByte(0);	// Null terminate
	}
}

void plIxStrTbl::Read(hsStream *s)
{	UInt32 pos = s->GetPosition();
	s->FastFwd();
	fTabSize = s->GetPosition() - pos;	// Get size of table
	s->SetPosition(pos);
	fpStrings = new char[fTabSize];
	hsAssert(fpStrings,"new failed");
	s->Read(fTabSize,fpStrings);			// Read all the string in

	char *p = fpStrings;
	while (p < fpStrings + fTabSize)
	{
		UInt8 len = *p;
		p++;
		hsAssert(p < fpStrings + fTabSize,"String Index error");
		fStringTbl.push_back(p);
		p += len + 1; // past len and NULL
	};
}