--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imgtools/romtools/rofsbuild/src/cache/cacheentry.cpp	Wed Jun 30 11:35:58 2010 +0800
@@ -0,0 +1,225 @@
+/*
+* Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*
+*/
+
+#include <new>
+#include <cstring>
+#include <string>
+#include <queue>
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "cache/cacheexception.hpp"
+#include "cache/cacheentry.hpp"
+
+
+CacheEntry::CacheEntry(void)
+{
+	this->next                 = (CacheEntry*)0;
+	this->cachedfilebuffer     = (char*)0      ;
+	this->cachedfilebuffersize = 0             ;
+
+	return;
+}
+
+
+void CacheEntry::SetOriginalFilename(const char* OriginalFilename)
+{
+	this->originalfile.clear();
+	this->originalfile.assign(OriginalFilename);
+
+	return;
+}
+
+
+const char* CacheEntry::GetOriginalFilename(void) const
+{
+	return this->originalfile.c_str();
+}
+
+
+void CacheEntry::SetCachedFilename(const char* CachedFilename)
+{
+	this->cachedfile.clear();
+	this->cachedfile.assign(CachedFilename);
+
+	return;
+}
+
+
+const char* CacheEntry::GetCachedFilename(void) const
+{
+	return this->cachedfile.c_str();
+}
+
+
+void CacheEntry::SetOriginalFileCreateTime(time_t* CreateRawTime)
+{
+	this->originalfilecreatetime.clear();
+	this->originalfilecreatetime.assign(ctime(CreateRawTime));
+
+	size_t newlinepos = this->originalfilecreatetime.find("\n");
+	while(newlinepos != std::string::npos)
+	{
+		this->originalfilecreatetime.erase(newlinepos, 1);
+		newlinepos = this->originalfilecreatetime.find(("\n"));
+	}
+
+	return;
+}
+
+
+void CacheEntry::SetOriginalFileCreateTime(const char* CreateRawTime)
+{
+	this->originalfilecreatetime.clear();
+	this->originalfilecreatetime.assign(CreateRawTime);
+
+	return;
+}
+
+
+const char* CacheEntry::GetOriginalFileCreateTime(void) const
+{
+	return this->originalfilecreatetime.c_str();
+}
+
+
+void CacheEntry::SetOriginalFileCompression(const char* CompressionMethodID)
+{
+	this->originalfilecompression.clear();
+	this->originalfilecompression.assign(CompressionMethodID);
+
+	return;
+}
+
+
+void CacheEntry::SetOriginalFileCompression(unsigned int CompressionMethodID)
+{
+	char methodid[30];
+	memset(methodid, 0, sizeof(methodid));
+	sprintf(methodid, "%d", CompressionMethodID);
+
+	this->originalfilecompression.clear();
+	this->originalfilecompression.assign(methodid);
+
+	return;
+}
+
+
+const char* CacheEntry::GetOriginalFileCompressionID(void) const
+{
+	return this->originalfilecompression.c_str();
+}
+
+
+void CacheEntry::SetCachedFileCompression(const char* CompressionMethodID)
+{
+	this->cachedfilecompression.clear();
+	this->cachedfilecompression.assign(CompressionMethodID);
+
+	return;
+}
+
+
+void CacheEntry::SetCachedFileCompression(unsigned int CompressionMethodID)
+{
+	char methodid[128];
+	memset(methodid, 0, sizeof(methodid));
+	sprintf(methodid, "%d", CompressionMethodID);
+
+	this->cachedfilecompression.clear();
+	this->cachedfilecompression.assign(methodid);
+
+	return;
+}
+
+
+const char* CacheEntry::GetCachedFileCompressionID(void) const
+{
+	return this->cachedfilecompression.c_str();
+}
+
+
+void CacheEntry::SetCachedFileBuffer(char* FileBuffer, int FileBufferLen)
+{
+	this->cachedfilebuffer     = (char*)malloc(sizeof(char)*FileBufferLen);
+	memcpy(this->cachedfilebuffer, FileBuffer, FileBufferLen);
+	this->cachedfilebuffersize = FileBufferLen;
+
+	return;
+}
+
+
+const char* CacheEntry::GetCachedFileBuffer(void) const
+{
+	return this->cachedfilebuffer;
+}
+
+
+int CacheEntry::GetCachedFileBufferLen(void) const
+{
+	return this->cachedfilebuffersize;
+}
+
+
+void CacheEntry::AppendEntry(CacheEntry* EntryRef)
+{
+	//the parameter EntryRef must be valid, should be verified by the caller.
+	this->next = EntryRef;
+
+	return;
+}
+
+
+CacheEntry* CacheEntry::GetNextEntry(void) const
+{
+	return this->next;
+}
+
+
+void CacheEntry::SetNextEntry(CacheEntry* EntryRef)
+{
+	this->next = EntryRef;
+
+	return;
+}
+
+
+bool CacheEntry::Equals(CacheEntry* EntryRef)
+{
+	if( (this->originalfile.compare(EntryRef->GetOriginalFilename())==0) &&
+	    (this->originalfilecreatetime.compare(EntryRef->GetOriginalFileCreateTime())==0) &&
+	    (this->originalfilecompression.compare(EntryRef->GetOriginalFileCompressionID())==0) &&
+	    (this->cachedfile.compare(EntryRef->GetCachedFilename())==0) &&
+	    (this->cachedfilecompression.compare(EntryRef->GetCachedFileCompressionID())==0)
+	  )
+		return true;
+
+	return false;
+}
+
+
+CacheEntry::~CacheEntry(void)
+{
+	if(this->cachedfilebuffer)
+	{
+		free(this->cachedfilebuffer);
+		this->cachedfilebuffer = NULL;
+	}
+
+	return;
+}