/*
* Copyright (c) 2008-2010 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>
#include <usif/scr/screntries_platform.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
	}

EXPORT_C CIntPropertyEntry::~CIntPropertyEntry()
	{
	// empty
	}

EXPORT_C CIntPropertyEntry* CIntPropertyEntry::NewL(const TDesC& aPropertyName, TInt64 aPropertyValue)
	{
	CIntPropertyEntry *self = CIntPropertyEntry::NewLC(aPropertyName, aPropertyValue);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CIntPropertyEntry* CIntPropertyEntry::NewLC(const TDesC& aPropertyName, TInt64 aPropertyValue)
	{
	CIntPropertyEntry *self = new (ELeave) CIntPropertyEntry(aPropertyValue);
	CleanupStack::PushL(self);
	self->ConstructL(aPropertyName);
	return self;
	}

void CIntPropertyEntry::ConstructL(const TDesC& aPropertyName)
	{
	CPropertyEntry::ConstructL(aPropertyName);
	}

CIntPropertyEntry* CIntPropertyEntry::NewLC()
	{
	CIntPropertyEntry *self = new(ELeave) CIntPropertyEntry();
	CleanupStack::PushL(self);
	return self;
	}
		
void CIntPropertyEntry::DoExternalizeL(RWriteStream& aStream) const
	{
	aStream.WriteInt32L(I64LOW(iIntValue));
	aStream.WriteInt32L(I64HIGH(iIntValue));
	}

void CIntPropertyEntry::DoInternalizeL(RReadStream& aStream)
	{
	TInt32 low32Bit = aStream.ReadInt32L(); 
	TInt32 high32Bit = aStream.ReadInt32L();
	iIntValue = MAKE_TINT64(high32Bit, low32Bit);	
	}

EXPORT_C CPropertyEntry::TPropertyType CIntPropertyEntry::PropertyType() const
	{
	return CPropertyEntry::EIntProperty;
	}

EXPORT_C TInt CIntPropertyEntry::IntValue()
	{
	return static_cast<TInt>(iIntValue);
	}

EXPORT_C TInt64 CIntPropertyEntry::Int64Value()
	{
	return iIntValue;
	}

///////////////////////
// CBinaryPropertyEntry
///////////////////////

CBinaryPropertyEntry::CBinaryPropertyEntry()
	{
	// empty
	}

EXPORT_C CBinaryPropertyEntry::~CBinaryPropertyEntry()
	{
	delete iValue;
	}
	
EXPORT_C CBinaryPropertyEntry* CBinaryPropertyEntry::NewL(const TDesC& aPropertyName, const TDesC8& aPropertyValue)
	{
	CBinaryPropertyEntry *self = CBinaryPropertyEntry::NewLC(aPropertyName, aPropertyValue);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CBinaryPropertyEntry* CBinaryPropertyEntry::NewLC(const TDesC& aPropertyName, const TDesC8& aPropertyValue)
	{
	CBinaryPropertyEntry *self = new(ELeave) CBinaryPropertyEntry();
	CleanupStack::PushL(self);
	self->ConstructL(aPropertyName, aPropertyValue);
	return self;
	}

void CBinaryPropertyEntry::ConstructL(const TDesC& aPropertyName, const TDesC8& aPropertyValue)
	{
	CPropertyEntry::ConstructL(aPropertyName);
	iValue = aPropertyValue.AllocL();
	}

CBinaryPropertyEntry* CBinaryPropertyEntry::NewLC()
	{
	CBinaryPropertyEntry *self = new(ELeave) CBinaryPropertyEntry();
	CleanupStack::PushL(self);
	return self;
	}
			
void CBinaryPropertyEntry::DoExternalizeL(RWriteStream &aStream) const	
	{
	aStream << *iValue;
	}

void CBinaryPropertyEntry::DoInternalizeL(RReadStream& aStream)
	{
	DeleteObjectZ(iValue);
	iValue = HBufC8::NewL(aStream, KMaxTInt); // No restriction on length
	}

EXPORT_C CBinaryPropertyEntry::TPropertyType CBinaryPropertyEntry::PropertyType() const
	{
	return CBinaryPropertyEntry::EBinaryProperty;
	}
			
EXPORT_C const TDesC8& CBinaryPropertyEntry::BinaryValue()
	{
	return *iValue;
	}	

///////////////////////
// CLocalizablePropertyEntry
///////////////////////

CLocalizablePropertyEntry::CLocalizablePropertyEntry()
	{
	// empty
	}

CLocalizablePropertyEntry::CLocalizablePropertyEntry(TLanguage aLocale) : iLocale(aLocale)
	{
	// empty
	}

EXPORT_C CLocalizablePropertyEntry::~CLocalizablePropertyEntry()
	{
	delete iStrValue;
	}

EXPORT_C CLocalizablePropertyEntry* CLocalizablePropertyEntry::NewL(const TDesC& aPropertyName, const TDesC& aPropertyValue, TLanguage aLocale)
	{
	CLocalizablePropertyEntry *self = CLocalizablePropertyEntry::NewLC(aPropertyName, aPropertyValue, aLocale);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CLocalizablePropertyEntry* CLocalizablePropertyEntry::NewLC( const TDesC& aPropertyName, const TDesC& aPropertyValue, TLanguage aLocale)
	{
	CLocalizablePropertyEntry *self = new(ELeave) CLocalizablePropertyEntry(aLocale);
	CleanupStack::PushL(self);
	self->ConstructL(aPropertyName, aPropertyValue);
	return self;
	}

CLocalizablePropertyEntry* CLocalizablePropertyEntry::NewLC()
	{
	CLocalizablePropertyEntry *self = new(ELeave) CLocalizablePropertyEntry();
	CleanupStack::PushL(self);
	return self;
	}

void CLocalizablePropertyEntry::ConstructL(const TDesC& aPropertyName, const TDesC& aPropertyValue)
	{
	CPropertyEntry::ConstructL(aPropertyName);
	iStrValue = aPropertyValue.AllocL();
	}

void CLocalizablePropertyEntry::DoExternalizeL(RWriteStream &aStream) const
	{
	aStream << *iStrValue;
	aStream.WriteInt32L(iLocale);
	}

void CLocalizablePropertyEntry::DoInternalizeL(RReadStream& aStream)
	{
	iStrValue = HBufC::NewL(aStream, KMaxTInt); // No restriction on length
	iLocale = TLanguage(aStream.ReadInt32L());
	}

EXPORT_C CPropertyEntry::TPropertyType CLocalizablePropertyEntry::PropertyType() const
	{
	return CPropertyEntry::ELocalizedProperty;
	}

EXPORT_C TLanguage CLocalizablePropertyEntry::LocaleL() const
	{
	return iLocale;
	}

EXPORT_C const TDesC& CLocalizablePropertyEntry::StrValue() const
	{
	return *iStrValue;
	}

///////////////////////
// CLocalizableCommonData
///////////////////////

CLocalizableCommonData::CLocalizableCommonData()
	{
	// empty
	}

CLocalizableCommonData::CLocalizableCommonData(TLanguage aLocale)
	:	iLocale(aLocale)
	{
	// empty
	}

CLocalizableCommonData::~CLocalizableCommonData()
	{
	// empty
	}

EXPORT_C TLanguage CLocalizableCommonData::Locale() const
	{
	return iLocale;
	}

void CLocalizableCommonData::ExternalizeL(RWriteStream& aStream) const
	{
	aStream.WriteInt32L(Locale());
	}

void CLocalizableCommonData::InternalizeL(RReadStream& aStream)
	{
	TLanguage locale = static_cast<TLanguage>(aStream.ReadInt32L());
	iLocale = locale;
	}

/////////////////////////////
// CLocalizableComponentInfo
/////////////////////////////

CLocalizableComponentInfo::CLocalizableComponentInfo()
	{
	// empty
	}

CLocalizableComponentInfo::CLocalizableComponentInfo(TLanguage aLocale)
	:	CLocalizableCommonData(aLocale)
	{
	// empty
	}

CLocalizableComponentInfo::~CLocalizableComponentInfo()
	{
	delete iName;
	delete iVendor;
	}

EXPORT_C CLocalizableComponentInfo* CLocalizableComponentInfo::NewL(const TDesC& aName, const TDesC& aVendor, TLanguage aLocale)
	{
	CLocalizableComponentInfo *self = CLocalizableComponentInfo::NewLC(aName, aVendor, aLocale);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CLocalizableComponentInfo* CLocalizableComponentInfo::NewLC(const TDesC& aName, const TDesC& aVendor, TLanguage aLocale)
	{
	CLocalizableComponentInfo *self = new(ELeave) CLocalizableComponentInfo(aLocale);
	CleanupStack::PushL(self);
	self->ConstructL(aName, aVendor);
	return self;
	}

EXPORT_C CLocalizableComponentInfo* CLocalizableComponentInfo::NewL(RReadStream& aStream)
	{
	CLocalizableComponentInfo* self = new(ELeave) CLocalizableComponentInfo();
	CleanupStack::PushL(self);
	self->InternalizeL(aStream);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C void CLocalizableComponentInfo::ConstructL(const TDesC& aName, const TDesC& aVendor)
	{
	iName = aName.AllocL();
	iVendor = aVendor.AllocL();
	}


EXPORT_C void CLocalizableComponentInfo::ExternalizeL(RWriteStream& aStream) const
	{
	CLocalizableCommonData::ExternalizeL(aStream);
	aStream << *iName;
	aStream << *iVendor;
	}
		
EXPORT_C void CLocalizableComponentInfo::InternalizeL(RReadStream& aStream)
	{
	CLocalizableCommonData::InternalizeL(aStream);
	
	delete iName;
	iName = HBufC::NewL(aStream, KMaxTInt); // No restriction on length
	
	delete iVendor;
	iVendor = HBufC::NewL(aStream, KMaxTInt); // No restriction on length
	}

EXPORT_C const TDesC& CLocalizableComponentInfo::NameL() const
	{
	return *iName;
	}

EXPORT_C const TDesC& CLocalizableComponentInfo::VendorL() const
	{
	return *iVendor;
	}
			
/////////////////////////////
// TCustomAccessInfo
/////////////////////////////

EXPORT_C TCustomAccessInfo::TCustomAccessInfo(TSecureId aSecureId, TAccessMode aAccessMode)
    {
    iSecureId = aSecureId;
    iAccessMode = aAccessMode;
    }

EXPORT_C TSecureId TCustomAccessInfo::SecureId() const
    {
    return iSecureId;
    }

EXPORT_C TAccessMode TCustomAccessInfo::AccessMode() const
    {
    return iAccessMode;
    }

/////////////////////////////
// CSoftwareTypeRegInfo
/////////////////////////////

EXPORT_C CSoftwareTypeRegInfo* CSoftwareTypeRegInfo::NewL(const TDesC& aUniqueSoftwareTypeName)
	{
	CSoftwareTypeRegInfo* self = new (ELeave) CSoftwareTypeRegInfo();
	CleanupStack::PushL(self);
	self->iUniqueSoftwareTypeName = HBufC::NewL(aUniqueSoftwareTypeName.Length());
	self->iUniqueSoftwareTypeName->Des().Copy(aUniqueSoftwareTypeName);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CSoftwareTypeRegInfo* CSoftwareTypeRegInfo::NewL(RReadStream& aStream)
	{
	CSoftwareTypeRegInfo* self = new (ELeave) CSoftwareTypeRegInfo();
	CleanupStack::PushL(self);
	self->InternalizeL(aStream);
	CleanupStack::Pop(self);
	return self;
	}

CSoftwareTypeRegInfo::CSoftwareTypeRegInfo()
	{
	}

EXPORT_C CSoftwareTypeRegInfo::~CSoftwareTypeRegInfo()
	{
	delete iUniqueSoftwareTypeName;
	iCustomAccessList.Close();
	iMimeTypes.Close();
	iLocalizedSoftwareTypeNames.Close();
	delete iLauncherExecutable;
	}

EXPORT_C void CSoftwareTypeRegInfo::ExternalizeL(RWriteStream& aStream) const
	{
	aStream << *iUniqueSoftwareTypeName;
	aStream << iSifPluginUid.iUid;
	
	//Sids
	const TInt numSids = iCustomAccessList.Count();
	aStream.WriteInt32L(numSids);
	for (TInt i=0; i< numSids; ++i)
	    {
	    TUid sid = iCustomAccessList[i].SecureId();
	    aStream << sid.iUid;
	    aStream.WriteInt32L(iCustomAccessList[i].AccessMode());
	    }
	
	// MIME types
	const TInt numMimeTypes = iMimeTypes.Count();
	aStream.WriteInt32L(numMimeTypes);
	for (TInt i=0; i<numMimeTypes; ++i)
		{
		aStream << *iMimeTypes[i];
		}
	 
	// Localized names
	const TInt numLocalizedNames = iLocalizedSoftwareTypeNames.Count();
	aStream.WriteInt32L(numLocalizedNames);
	for (TInt i=0; i<numLocalizedNames; ++i)
		{
		aStream << *iLocalizedSoftwareTypeNames[i];
		}

	// Launcher executable
	aStream << *iLauncherExecutable;
	}

void CSoftwareTypeRegInfo::InternalizeL(RReadStream& aStream)
	{
	ASSERT(iUniqueSoftwareTypeName == NULL);
	
	iUniqueSoftwareTypeName = HBufC::NewL(aStream, EUniqueSwTypeNameMaxLength);
	
	iSifPluginUid = TUid::Uid(aStream.ReadInt32L());
	
	// Sids
	const TInt numSids = aStream.ReadInt32L();
	for (TInt i=0; i<numSids; ++i)
	    {
	    TSecureId secId(TUid::Uid(aStream.ReadInt32L()));
	    TCustomAccessInfo customAccessInfo(secId, static_cast<TAccessMode>(aStream.ReadInt32L()));
	    iCustomAccessList.AppendL(customAccessInfo);
	    }
	        
	// MIME types
	const TInt numMimeTypes = aStream.ReadInt32L();
	for (TInt i=0; i<numMimeTypes; ++i)
		{
		HBufC* mimeType = HBufC::NewLC(aStream, EUniqueSwTypeNameMaxLength);
		iMimeTypes.AppendL(mimeType);
		CleanupStack::Pop(mimeType);
		}
	
	// Localized names
	const TInt numLocalizedNames = aStream.ReadInt32L();
	for (TInt i=0; i<numLocalizedNames; ++i)
		{
		CLocalizedSoftwareTypeName* name = CLocalizedSoftwareTypeName::NewL(aStream);
		CleanupStack::PushL(name);
		iLocalizedSoftwareTypeNames.AppendL(name);
		CleanupStack::Pop(name);
		}

	iLauncherExecutable = HBufC::NewL(aStream, ELauncherExecutableMaxLength);
	}

EXPORT_C void CSoftwareTypeRegInfo::SetMimeTypeL(const TDesC& aMimeType)
	{
	HBufC* mimeType = HBufC::NewLC(aMimeType.Length());
	mimeType->Des().Copy(aMimeType);
	iMimeTypes.AppendL(mimeType);
	CleanupStack::Pop(mimeType);
	}

EXPORT_C void CSoftwareTypeRegInfo::SetLocalizedSoftwareTypeNameL(TLanguage aLanguage, const TDesC& aName)
	{
	CLocalizedSoftwareTypeName* name = CLocalizedSoftwareTypeName::NewLC(aName, aLanguage);
	iLocalizedSoftwareTypeNames.AppendL(name);
	CleanupStack::Pop(name);
	}

EXPORT_C void CSoftwareTypeRegInfo::SetLauncherExecutableL(const TDesC& aLauncherExecutable)
    {
    HBufC* launcherExecutable = HBufC::NewLC(aLauncherExecutable.Length());
    launcherExecutable->Des().Copy(aLauncherExecutable);
    iLauncherExecutable = launcherExecutable;
    CleanupStack::Pop(launcherExecutable);
    }

/////////////////////////////
// CComponentFilter
/////////////////////////////

CComponentFilter::CComponentFilter()
	{
	// empty 
	}

CComponentFilter::~CComponentFilter()
	{
	delete iName;
	delete iVendor;
	delete iSwType;
	delete iFile;
	iPropertyList.ResetAndDestroy();
	iPropertyOperatorList.Reset();
	}

EXPORT_C CComponentFilter* CComponentFilter::NewL()
	{
	CComponentFilter *self = CComponentFilter::NewLC();
	CleanupStack::Pop(self);
	return self;
	}
		
EXPORT_C CComponentFilter* CComponentFilter::NewLC()
	{
	CComponentFilter *self = new(ELeave) CComponentFilter();
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}
		
EXPORT_C CComponentFilter* CComponentFilter::NewL(RReadStream& aStream)
	{
	CComponentFilter *self = CComponentFilter::NewLC();
	self->InternalizeL(aStream);
	CleanupStack::Pop(self);
	return self;
	}

void CComponentFilter::ConstructL()
	{
	iName   = KNullDesC().AllocL();
	iVendor = KNullDesC().AllocL();
	iSwType = KNullDesC().AllocL();
	iFile   = KNullDesC().AllocL();
	}

EXPORT_C void CComponentFilter::SetNameL(const TDesC& aName)
	{
	DeleteObjectZ(iName);
	iName = aName.AllocL();
	iSetFlag |= EName;
	}
		
EXPORT_C void CComponentFilter::SetVendorL(const TDesC& aVendor)
	{
	DeleteObjectZ(iVendor);
	iVendor = aVendor.AllocL();
	iSetFlag |= EVendor;
	}

EXPORT_C void CComponentFilter::SetSoftwareTypeL(const TDesC& aSwType)
	{
	DeleteObjectZ(iSwType);
	iSwType = aSwType.AllocL();
	iSetFlag |= ESoftwareType;
	}

EXPORT_C void CComponentFilter::SetRemovable(TBool aValue)
	{
	iRemovable = aValue;
	iSetFlag |= ERemovable;
	}

EXPORT_C void CComponentFilter::SetDrmProtected(TBool aValue)
	{
	iDrmProtected = aValue;
	iSetFlag |= EDrmProtected;
	}

EXPORT_C void CComponentFilter::SetHidden(TBool aValue)
	{
	iHidden = aValue;
	iSetFlag |= EHidden;
	}

EXPORT_C void CComponentFilter::SetKnownRevoked(TBool aValue)
	{
	iKnownRevoked = aValue;
	iSetFlag |= EKnownRevoked;
	}

EXPORT_C void CComponentFilter::SetOriginVerified(TBool aValue)
	{
	iOriginVerified = aValue;
	iSetFlag |= EOriginVerified;
	}

EXPORT_C void CComponentFilter::SetScomoStateL(TScomoState aScomoState)
	{
	iScomoState = aScomoState;
	iSetFlag |= EScomoState;
	}
		
EXPORT_C void CComponentFilter::SetInstalledDrivesL(const TDriveList& aDrives)
	{
	iInstalledDrives.Copy(aDrives);
	iSetFlag |= EInstalledDrive;
	}
					
EXPORT_C void CComponentFilter::AddPropertyL(const TDesC& aName, const TDesC& aValue, TLanguage aLocale,
        TDbOperator aNameOperator, TDbOperator aValueOperator)
	{
	CPropertyEntry *prop = CLocalizablePropertyEntry::NewLC(aName, aValue, aLocale);
	iPropertyList.AppendL(prop);
	CleanupStack::Pop(prop);
	iPropertyOperatorList.AppendL(TPropertyOperator(aNameOperator, aValueOperator));
	iSetFlag |= EProperty;
	}

EXPORT_C void CComponentFilter::AddPropertyL(const TDesC& aName, TInt64 aValue, TDbOperator aNameOperator, 
        TDbOperator aValueOperator)
	{
	CPropertyEntry *prop = CIntPropertyEntry::NewLC(aName, aValue);
	iPropertyList.AppendL(prop);
	CleanupStack::Pop(prop);
	iPropertyOperatorList.AppendL(TPropertyOperator(aNameOperator, aValueOperator));
	iSetFlag |= EProperty;
	}

EXPORT_C void CComponentFilter::AddPropertyL(const TDesC& aName, const TDesC8& aValue, TDbOperator aNameOperator, 
        TDbOperator aValueOperator)
	{
	CPropertyEntry *prop = CBinaryPropertyEntry::NewLC(aName, aValue);
	iPropertyList.AppendL(prop);
	CleanupStack::Pop(prop);
	iPropertyOperatorList.AppendL(TPropertyOperator(aNameOperator, aValueOperator));
	iSetFlag |= EProperty;	
	}

EXPORT_C void CComponentFilter::SetFileL(const TDesC& aFile)
	{
	DeleteObjectZ(iFile);
	iFile = aFile.AllocL();
	iSetFlag |= EFile;
	}
		
EXPORT_C void CComponentFilter::ExternalizeL(RWriteStream& aStream) const
	{
	aStream.WriteUint16L(iSetFlag);
	aStream << *iName;
	aStream << *iVendor;
	aStream << *iSwType;
	aStream << TCardinality(iScomoState);
	aStream << iInstalledDrives;
	aStream << TCardinality(iRemovable);
	ExternalizePointersArrayL(iPropertyList, aStream);
	ExternalizeFixedLengthArrayL(iPropertyOperatorList, aStream);
	aStream << *iFile;
	aStream << TCardinality(iDrmProtected);
	aStream << TCardinality(iHidden);
	aStream << TCardinality(iKnownRevoked);
	aStream << TCardinality(iOriginVerified);
	}
		
void CComponentFilter::InternalizeL(RReadStream& aStream)
	{
	iSetFlag = aStream.ReadUint16L();
	DeleteObjectZ(iName);
	iName = HBufC::NewL(aStream, KMaxTInt); // No restriction on length
	DeleteObjectZ(iVendor);
	iVendor = HBufC::NewL(aStream, KMaxTInt); // No restriction on length
	DeleteObjectZ(iSwType);
	iSwType = HBufC::NewL(aStream, KMaxTInt); // No restriction on length
	TCardinality c;
	aStream >> c;
	iScomoState = static_cast<TScomoState>(static_cast<TInt>(c));
	aStream >> iInstalledDrives;
	aStream >> c;
	iRemovable = c;
	iPropertyList.Reset();
	InternalizePointersArrayL(iPropertyList, aStream);
	iPropertyOperatorList.Reset();
	InternalizeFixedLengthArrayL(iPropertyOperatorList, aStream);
	DeleteObjectZ(iFile);
	iFile = 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;
	}

/////////////////////////////
// CLocalizedSoftwareTypeName
/////////////////////////////

CLocalizedSoftwareTypeName::CLocalizedSoftwareTypeName()
	{
	// empty
	}

CLocalizedSoftwareTypeName::CLocalizedSoftwareTypeName(TLanguage aLocale)
	:	CLocalizableCommonData(aLocale)
	{
	// empty
	}

CLocalizedSoftwareTypeName::~CLocalizedSoftwareTypeName()
	{
	delete iName;
	}

EXPORT_C CLocalizedSoftwareTypeName* CLocalizedSoftwareTypeName::NewL(const TDesC& aName, TLanguage aLocale)
	{
	CLocalizedSoftwareTypeName *self = CLocalizedSoftwareTypeName::NewLC(aName, aLocale);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CLocalizedSoftwareTypeName* CLocalizedSoftwareTypeName::NewLC(const TDesC& aName, TLanguage aLocale)
	{
	CLocalizedSoftwareTypeName *self = new(ELeave) CLocalizedSoftwareTypeName(aLocale);
	CleanupStack::PushL(self);
	self->ConstructL(aName);
	return self;
	}

EXPORT_C CLocalizedSoftwareTypeName* CLocalizedSoftwareTypeName::NewL(RReadStream& aStream)
	{
	CLocalizedSoftwareTypeName* self = new(ELeave) CLocalizedSoftwareTypeName();
	CleanupStack::PushL(self);
	self->InternalizeL(aStream);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C void CLocalizedSoftwareTypeName::ConstructL(const TDesC& aName)
	{
	iName = aName.AllocL();
	}


EXPORT_C void CLocalizedSoftwareTypeName::ExternalizeL(RWriteStream& aStream) const
	{
	CLocalizableCommonData::ExternalizeL(aStream);
	aStream << *iName;
	}
		
EXPORT_C void CLocalizedSoftwareTypeName::InternalizeL(RReadStream& aStream)
	{
	CLocalizableCommonData::InternalizeL(aStream);
	
	delete iName;
	iName = HBufC::NewL(aStream, KMaxTInt); // No restriction on length
	}

EXPORT_C const TDesC& CLocalizedSoftwareTypeName::NameL() const
	{
	return *iName;
	}


////////////////
// CScrLogEntry
////////////////

CScrLogEntry::CScrLogEntry()
	{
	//empty
	}

CScrLogEntry::~CScrLogEntry()
	{
	delete iComponentName;
	delete iSwTypeName;
	delete iVersion;   
	delete iGlobalId;
	}


EXPORT_C CScrLogEntry* CScrLogEntry::NewL(const TDesC& aComponentName, const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId, const TDesC& aVersion, const TScrComponentOperationType aCompOpType)
	{
	CScrLogEntry *self = CScrLogEntry::NewLC(aComponentName, aUniqueSwTypeName, aGlobalId, aVersion, aCompOpType);
	CleanupStack::Pop(self);
	return self;
	}
		
EXPORT_C CScrLogEntry* CScrLogEntry::NewLC(const TDesC& aComponentName, const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId, const TDesC& aVersion, const TScrComponentOperationType aCompOpType)
	{
	CScrLogEntry *self = new(ELeave) CScrLogEntry();
	CleanupStack::PushL(self);
	self->ConstructL(aComponentName, aUniqueSwTypeName, aGlobalId, aVersion, aCompOpType);
	return self;
	}

EXPORT_C CScrLogEntry* CScrLogEntry::NewLC(RReadStream& aStream)
	{
	CScrLogEntry *self = new(ELeave) CScrLogEntry();
	CleanupStack::PushL(self);
	self->InternalizeL(aStream);
	return self;
	}
		
void CScrLogEntry::ConstructL(const TDesC& aComponentName, const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId, const TDesC& aVersion, const TScrComponentOperationType aCompOpType)
	{
	iComponentName = aComponentName.AllocL();
	iSwTypeName = aUniqueSwTypeName.AllocL();
	iGlobalId = aGlobalId.AllocL();
	iVersion = aVersion.AllocL();
	iOpType = aCompOpType;
	iRecordTime.HomeTime();
	}
		
	
EXPORT_C void CScrLogEntry::ExternalizeL(RWriteStream& aStream) const
	{
	aStream << *iComponentName;
	aStream << *iSwTypeName;
	aStream << *iGlobalId; 
	aStream << *iVersion; 
	aStream.WriteInt32L(static_cast<TInt>(iOpType)); 
	WriteInt64L(aStream, iRecordTime.Int64());
	}
		 
	
EXPORT_C void CScrLogEntry::InternalizeL(RReadStream& aStream) 
	{
	DeleteObjectZ(iComponentName);
	iComponentName = HBufC::NewL(aStream, KMaxTInt); // No restriction on length
	DeleteObjectZ(iSwTypeName);
	iSwTypeName = HBufC::NewL(aStream, KMaxTInt); // No restriction on length
	DeleteObjectZ(iGlobalId);
	iGlobalId = HBufC::NewL(aStream, KMaxTInt); // No restriction on length
	DeleteObjectZ(iVersion);
	iVersion = HBufC::NewL(aStream, KMaxTInt); // No restriction on length
	iOpType = static_cast<TScrComponentOperationType>(aStream.ReadInt32L());
	iRecordTime = TTime(ReadInt64L(aStream));
	}
	    
	  
EXPORT_C const TDesC& CScrLogEntry::ComponentName() const
	{
	return *iComponentName;
	}

EXPORT_C const TDesC& CScrLogEntry::SoftwareTypeName() const
	{
	return *iSwTypeName;
	}

EXPORT_C const TDesC& CScrLogEntry::GlobalId() const
	{
	return *iGlobalId;
	}
	
EXPORT_C const TDesC& CScrLogEntry::ComponentVersion() const
	{
	return *iVersion;
	}
	
EXPORT_C const TTime CScrLogEntry::OperationTime() const
	{
	return iRecordTime;
	}
	
EXPORT_C TScrComponentOperationType CScrLogEntry::OperationType() const
	{
	return iOpType;
	}

EXPORT_C TComponentId CScrLogEntry::ComponentId() const
	{
	return iComponentId;
	}

EXPORT_C CComponentFilter::TPropertyOperator::TPropertyOperator(TDbOperator aNameOperator, TDbOperator aValueOperator):
        iNameOperator(aNameOperator),
        iValueOperator(aValueOperator)
    {
    }

void CComponentFilter::TPropertyOperator::ExternalizeL(RWriteStream& aStream) const
    {
    aStream.WriteInt32L(iNameOperator);
    aStream.WriteInt32L(iValueOperator);
    }

EXPORT_C void CComponentFilter::TPropertyOperator::InternalizeL(RReadStream& aStream)
    {
    iNameOperator = static_cast<TDbOperator>(aStream.ReadInt32L());
    iValueOperator = static_cast<TDbOperator>(aStream.ReadInt32L());
    }

EXPORT_C CComponentFilter::TDbOperator CComponentFilter::TPropertyOperator::NameOperator() const
    {
    return iNameOperator;
    }

EXPORT_C CComponentFilter::TDbOperator CComponentFilter::TPropertyOperator::ValueOperator() const
    {
    return iValueOperator;
    }