diff -r aba6b8104af3 -r 84a16765cd86 installationservices/swcomponentregistry/source/client/screntries.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/installationservices/swcomponentregistry/source/client/screntries.cpp Fri Mar 19 09:33:35 2010 +0200 @@ -0,0 +1,1219 @@ +/* +* 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 +#include + +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(static_cast(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(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(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; + } + + +///////////////////////////// +// CComponentFilter +///////////////////////////// + +CComponentFilter::CComponentFilter() + { + // empty + } + +CComponentFilter::~CComponentFilter() + { + delete iName; + delete iVendor; + delete iSwType; + delete iFile; + iPropertyList.ResetAndDestroy(); + } + +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) + { + CPropertyEntry *prop = CLocalizablePropertyEntry::NewLC(aName, aValue, aLocale); + iPropertyList.AppendL(prop); + CleanupStack::Pop(prop); + iSetFlag |= EProperty; + } + +EXPORT_C void CComponentFilter::AddPropertyL(const TDesC& aName, TInt64 aValue) + { + CPropertyEntry *prop = CIntPropertyEntry::NewLC(aName, aValue); + iPropertyList.AppendL(prop); + CleanupStack::Pop(prop); + iSetFlag |= EProperty; + } + +EXPORT_C void CComponentFilter::AddPropertyL(const TDesC& aName, const TDesC8& aValue) + { + CPropertyEntry *prop = CBinaryPropertyEntry::NewLC(aName, aValue); + iPropertyList.AppendL(prop); + CleanupStack::Pop(prop); + 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); + 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(static_cast(c)); + aStream >> iInstalledDrives; + aStream >> c; + iRemovable = c; + iPropertyList.Reset(); + InternalizePointersArrayL(iPropertyList, 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(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(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; + }