/*

* 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;

}