/*

* Copyright (c) 2008-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: 

* Implement entry classes for Software Components Registry interface.

*

*/

/**

 @file

 @publishedAll

 @released

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "screntries_internal.h"

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

#include "screntries.h"

#include "usiflog.h"

#include <scs/streamingarray.h>

#include <scs/cleanuputils.h>

using namespace Usif;

///////////////////////

// CGlobalComponentId

///////////////////////

CGlobalComponentId::CGlobalComponentId()

	{

	// empty

	}

EXPORT_C CGlobalComponentId::~CGlobalComponentId()

	{

	delete iGlobalIdName;

	delete iSoftwareTypeName;

	}

EXPORT_C CGlobalComponentId* CGlobalComponentId::NewLC()

	{

	CGlobalComponentId *self = new(ELeave) CGlobalComponentId();

	CleanupStack::PushL(self);

	return self;

	}

EXPORT_C CGlobalComponentId* CGlobalComponentId::NewL(const TDesC& aGlobalIdName, const TDesC& aUniqueSwTypeName)

	{

	CGlobalComponentId *self = CGlobalComponentId::NewLC(aGlobalIdName, aUniqueSwTypeName);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CGlobalComponentId* CGlobalComponentId::NewLC(const TDesC& aGlobalIdName, const TDesC& aUniqueSwTypeName)

	{

	CGlobalComponentId *self = CGlobalComponentId::NewLC();

	self->ConstructL(aGlobalIdName, aUniqueSwTypeName);

	return self;

	}

EXPORT_C CGlobalComponentId* CGlobalComponentId::NewL(RReadStream& aStream)

	{

	CGlobalComponentId *self = CGlobalComponentId::NewLC();

	self->InternalizeL(aStream);

	CleanupStack::Pop(self);

	return self;

	}

void CGlobalComponentId::ConstructL(const TDesC& aGlobalIdName, const TDesC& aSoftwareTypeName)

	{

	iGlobalIdName = aGlobalIdName.AllocL();

	iSoftwareTypeName = aSoftwareTypeName.AllocL();

	}

EXPORT_C void CGlobalComponentId::ExternalizeL(RWriteStream& aStream) const

	{

	aStream << *iGlobalIdName;

	aStream << *iSoftwareTypeName;

	}

EXPORT_C void CGlobalComponentId::InternalizeL(RReadStream& aStream)

	{

	// Read global id name

	DeleteObjectZ(iGlobalIdName);

	iGlobalIdName = HBufC::NewL(aStream, KMaxTInt); // No restriction on length

	// Read software type name

	DeleteObjectZ(iSoftwareTypeName);

	iSoftwareTypeName = HBufC::NewL(aStream, KMaxTInt); // No restriction on length

	}

EXPORT_C const TDesC& CGlobalComponentId::GlobalIdName() const

	{

	return *iGlobalIdName;

	}

EXPORT_C const TDesC& CGlobalComponentId::SoftwareTypeName() const

	{

	return *iSoftwareTypeName;

	}

////////////////////////

// CVersionedComponentId

////////////////////////

CVersionedComponentId::CVersionedComponentId()

	{

	// empty

	}

EXPORT_C CVersionedComponentId::~CVersionedComponentId()

	{

	delete iGlobalId;

	delete iVersionFrom;

	delete iVersionTo;

	}

EXPORT_C CVersionedComponentId* CVersionedComponentId::NewLC()

	{

	CVersionedComponentId *self = new(ELeave) CVersionedComponentId();

	CleanupStack::PushL(self);

	return self;

	}

EXPORT_C CVersionedComponentId* CVersionedComponentId::NewL(const CGlobalComponentId& aGlobalId, const TDesC* aVersionFrom, const TDesC* aVersionTo)

	{

	CVersionedComponentId *self = CVersionedComponentId::NewLC(aGlobalId, aVersionFrom, aVersionTo);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CVersionedComponentId* CVersionedComponentId::NewLC(const CGlobalComponentId& aGlobalId, const TDesC* aVersionFrom, const TDesC* aVersionTo)

	{

	CVersionedComponentId *self = CVersionedComponentId::NewLC();

	self->ConstructL(aGlobalId, aVersionFrom, aVersionTo);

	return self;

	}

void CVersionedComponentId::ConstructL(const CGlobalComponentId& aGlobalId, const TDesC* aVersionFrom, const TDesC* aVersionTo)

	{

	iGlobalId = CGlobalComponentId::NewL(aGlobalId.GlobalIdName(), aGlobalId.SoftwareTypeName());

	if(aVersionFrom)

		iVersionFrom = aVersionFrom->AllocL();

	else

		iVersionFrom = KNullDesC().AllocL();

	if(aVersionTo)

		iVersionTo = aVersionTo->AllocL();

	else

		iVersionTo = KNullDesC().AllocL();

	}

EXPORT_C CVersionedComponentId* CVersionedComponentId::NewL(RReadStream& aStream)

	{

	CVersionedComponentId *self = CVersionedComponentId::NewLC();

	self->InternalizeL(aStream);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C void CVersionedComponentId::InternalizeL(RReadStream& aStream)

	{

	// Read global id 

	DeleteObjectZ(iGlobalId);

	iGlobalId = CGlobalComponentId::NewL(aStream);

	// Read version from

	DeleteObjectZ(iVersionFrom);

	iVersionFrom = HBufC::NewL(aStream, KMaxTInt); // No restriction on length

	// Read version to

	DeleteObjectZ(iVersionTo);

	iVersionTo = HBufC::NewL(aStream, KMaxTInt); // No restriction on length

	}

EXPORT_C void CVersionedComponentId::ExternalizeL(RWriteStream& aStream) const

	{

	aStream << *iGlobalId;

	aStream << *iVersionFrom;

	aStream << *iVersionTo;

	}

EXPORT_C const CGlobalComponentId& CVersionedComponentId::GlobalId() const

	{

	return *iGlobalId;

	}

EXPORT_C const TDesC* CVersionedComponentId::VersionFrom() const

	{

	if(!iVersionFrom->Length())

		return NULL;

	else

		return iVersionFrom;

	}

EXPORT_C const TDesC* CVersionedComponentId::VersionTo() const

	{

	if(!iVersionTo->Length())

		return NULL;

	else

		return iVersionTo;

	}

///////////////////////

// CComponentEntry

///////////////////////

CComponentEntry::CComponentEntry()

	{

	// empty

	}

EXPORT_C CComponentEntry::~CComponentEntry()

	{

	delete iName;

	delete iVendor;

	delete iSwType;

	delete iGlobalId;

	delete iVersion;

	delete iInstallTime;

	}

EXPORT_C CComponentEntry* CComponentEntry::NewL()

	{

	CComponentEntry *self = CComponentEntry::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CComponentEntry* CComponentEntry::NewLC()

	{

	CComponentEntry *self = new(ELeave) CComponentEntry();

	CleanupStack::PushL(self);

	return self;

	}

EXPORT_C CComponentEntry* CComponentEntry::NewL(RReadStream& aStream)

	{

	CComponentEntry *self = CComponentEntry::NewLC();

	self->InternalizeL(aStream);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CComponentEntry* CComponentEntry::NewL(const TComponentId& aId, const TDesC& aName, const TDesC& aVendor, const TDesC& aSwType,

		  const TDesC& aGlobalId, TBool aRemovable, TInt64 aSize, const TScomoState& aScomoState, const TDriveList& aInstalledDrives, 

		  const TDesC& aVersion, const TDesC& aInstallTime, TBool aDrmProtected, TBool aHidden, TBool aKnownRevoked, TBool aOriginVerified)

	{

	CComponentEntry *self = CComponentEntry::NewLC(aId, aName, aVendor, aSwType, aGlobalId, aRemovable, aSize, aScomoState, aInstalledDrives, 

												   aVersion, aInstallTime, aDrmProtected, aHidden, aKnownRevoked, aOriginVerified);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CComponentEntry* CComponentEntry::NewLC(const TComponentId& aId, const TDesC& aName, const TDesC& aVendor, const TDesC& aSwType, 

			const TDesC& aGlobalId, TBool aRemovable, TInt64 aSize, const TScomoState& aScomoState, const TDriveList& aInstalledDrives, 

			const TDesC& aVersion, const TDesC& aInstallTime, TBool aDrmProtected, TBool aHidden, TBool aKnownRevoked, TBool aOriginVerified)		

	{

	CComponentEntry *self = new(ELeave) CComponentEntry();

	CleanupStack::PushL(self);

	self->ConstructL(aId, aName, aVendor, aSwType, aGlobalId, aRemovable, aSize, aScomoState, aInstalledDrives, aVersion, aInstallTime,

					 aDrmProtected, aHidden, aKnownRevoked, aOriginVerified);

	return self;

	}

void CComponentEntry::ConstructL(const TComponentId& aId, const TDesC& aName, const TDesC& aVendor, const TDesC& aSwType, const TDesC& aGlobalId,

				TBool aRemovable, TInt64 aSize, const TScomoState& aScomoState, const TDriveList& aInstalledDrives, 

				const TDesC& aVersion, const TDesC& aInstallTime, TBool aDrmProtected, TBool aHidden, TBool aKnownRevoked, TBool aOriginVerified)

	{

	iComponentId = aId;

	iName = aName.AllocL();

	iVendor = aVendor.AllocL();

	iSwType = aSwType.AllocL();

	iGlobalId = aGlobalId.AllocL();

	iRemovable = aRemovable;

	iSize = aSize;

	iScomoState = aScomoState;

	iInstalledDrives.Copy(aInstalledDrives);

	iVersion = aVersion.AllocL();

	iInstallTime = aInstallTime.AllocL();

	iDrmProtected = aDrmProtected;

	iHidden = aHidden;

	iKnownRevoked = aKnownRevoked;

	iOriginVerified = aOriginVerified;

	}

void WriteInt64L(RWriteStream& aStream, TInt64 aValue)

	{

	aStream.WriteInt32L(I64LOW(aValue));

	aStream.WriteInt32L(I64HIGH(aValue));

	}

EXPORT_C void CComponentEntry::ExternalizeL(RWriteStream& aStream) const

	{

	aStream << TCardinality(iComponentId); // Write the compressed value by using cardinality class

	aStream << *iName;

	aStream << *iVendor;

	aStream << *iSwType;

	aStream << *iGlobalId;

	aStream << TCardinality(iRemovable);

	WriteInt64L(aStream, iSize);

	aStream << TCardinality(iScomoState);

	aStream << iInstalledDrives;

	aStream << *iVersion;

	aStream << *iInstallTime;

	aStream << TCardinality(iDrmProtected);

	aStream << TCardinality(iHidden);

	aStream << TCardinality(iKnownRevoked);

	aStream << TCardinality(iOriginVerified);

	}

TInt64 ReadInt64L(RReadStream& aStream)

	{

	TInt32 low32Bit = aStream.ReadInt32L(); 

	TInt32 high32Bit = aStream.ReadInt32L();

	return MAKE_TINT64(high32Bit, low32Bit);

	}

EXPORT_C void CComponentEntry::InternalizeL(RReadStream& aStream)

	{

	TCardinality c;

	// Read component id

	aStream >> c;

	iComponentId = TComponentId(c);

	// Read component name

	DeleteObjectZ(iName);

	iName = HBufC::NewL(aStream, KMaxTInt); // No restriction on length

	// Read vendor name

	DeleteObjectZ(iVendor);

	iVendor = HBufC::NewL(aStream, KMaxTInt); // No restriction on length

	// Read software type

	DeleteObjectZ(iSwType);

	iSwType = HBufC::NewL(aStream, KMaxTInt); // No restriction on length

	// Read global id

	DeleteObjectZ(iGlobalId);

	iGlobalId = HBufC::NewL(aStream, KMaxTInt); // No restriction on length

	// Read if it is in removable

	aStream >> c;

	iRemovable = c;

	// Read install-time component size

	iSize = ReadInt64L(aStream);	

	// Read scomo state

	aStream >> c;

	iScomoState = static_cast<TScomoState>(static_cast<TInt>(c));

	// Read installed drives

	aStream >> iInstalledDrives;

	// Read version

	DeleteObjectZ(iVersion);

	iVersion = HBufC::NewL(aStream, KMaxTInt); // No restriction on length

	// Read install-time of the component

	DeleteObjectZ(iInstallTime);

	iInstallTime = HBufC::NewL(aStream, KMaxTInt); // No restriction on length	

	// Read if it is DRM protected

	aStream >> c;

	iDrmProtected = c;

	// Read if it is hidden

	aStream >> c;

	iHidden = c;

	// Read if it is known revoked

	aStream >> c;

	iKnownRevoked = c;

	// Read if it is origin verified

	aStream >> c;

	iOriginVerified = c;

	}

EXPORT_C const TComponentId& CComponentEntry::ComponentId() const

	{

	return iComponentId;

	}

EXPORT_C const TDesC& CComponentEntry::Name() const

	{

	return *iName;

	}

EXPORT_C const TDesC& CComponentEntry::Vendor() const

	{

	return *iVendor;

	}

EXPORT_C const TDesC& CComponentEntry::SoftwareType() const

	{

	return *iSwType;

	}

EXPORT_C const TDesC& CComponentEntry::GlobalId() const

	{

	return *iGlobalId;

	}

EXPORT_C TBool CComponentEntry::IsRemovable() const

	{

	return iRemovable;

	}

EXPORT_C TInt64 CComponentEntry::ComponentSize() const

	{

	return iSize;

	}

EXPORT_C const TScomoState& CComponentEntry::ScomoState() const

	{

	return iScomoState;

	}

EXPORT_C const TDriveList& CComponentEntry::InstalledDrives() const

	{

	return iInstalledDrives;

	}

EXPORT_C const TDesC& CComponentEntry::Version() const

	{

	return *iVersion;

	}

EXPORT_C TTime CComponentEntry::InstallTimeL() const

	{

	TTime time;

	User::LeaveIfError(time.Set(*iInstallTime));

	return time;

	}

EXPORT_C TBool CComponentEntry::IsDrmProtected() const

	{

	return iDrmProtected;

	}

EXPORT_C TBool CComponentEntry::IsHidden() const

	{

	return iHidden;

	}

EXPORT_C TBool CComponentEntry::IsKnownRevoked() const

	{ 

	return iKnownRevoked;

	}

EXPORT_C TBool CComponentEntry::IsOriginVerified() const

	{

	return iOriginVerified;

	}

///////////////////////

// CPropertyEntry

///////////////////////

CPropertyEntry::CPropertyEntry()

	{

	// empty

	}

EXPORT_C CPropertyEntry::~CPropertyEntry()

	{

	delete iPropertyName;

	}

void CPropertyEntry::ConstructL(const TDesC& aPropertyName)

	{

	iPropertyName = aPropertyName.AllocL();

	}

EXPORT_C const TDesC& CPropertyEntry::PropertyName() const

	{

	return *iPropertyName;

	}

EXPORT_C CPropertyEntry* CPropertyEntry::NewL(RReadStream& aStream)

	{

	TCardinality c;

	aStream >> c;

	TPropertyType propType = TPropertyType(TInt(c));

	CPropertyEntry *property(0);

	switch(propType)

		{

	case EBinaryProperty:

		property = CBinaryPropertyEntry::NewLC();

		break;

	case EIntProperty:

		property = CIntPropertyEntry::NewLC();

		break;

	case ELocalizedProperty:

		property = CLocalizablePropertyEntry::NewLC();

		break;

	default:

		DEBUG_PRINTF2(_L("CPropertyEntry has got an invalid property type = %d"), propType);

		User::Leave(KErrCorrupt);

		}

	property->DoInternalizeL(aStream);

	property->iPropertyName = HBufC::NewL(aStream, KMaxTInt); // No restriction on length

	CleanupStack::Pop(property);

	return property;

	}

EXPORT_C void CPropertyEntry::ExternalizeL(RWriteStream& aStream) const

	{

	TPropertyType t = this->PropertyType();

	aStream << TCardinality(t);

	this->DoExternalizeL(aStream);

	aStream << *iPropertyName;

	}

///////////////////////

// CIntPropertyEntry

///////////////////////

CIntPropertyEntry::CIntPropertyEntry()

	{

	// empty

	}

CIntPropertyEntry::CIntPropertyEntry(TInt64 aPropertyIntValue)

	:	CPropertyEntry(), iIntValue(aPropertyIntValue)

	{

	// empty