--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/calendarengines/versit2/src/ICalPropertyParam.cpp Tue Feb 02 10:12:19 2010 +0200
@@ -0,0 +1,439 @@
+/*
+* Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "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: Implements the definition of CICalPropertyParam.
+*
+*/
+
+
+
+// Class include.
+#include "ICalPropertyParam.h" // CICalPropertyParam
+
+//debug
+#include "calendarengines_debug.h"
+
+// User includes.
+#include "ICalContentLineWriter.h" // CICalContentLineWriter
+#include "ICalErrors.h" // Error values
+#include "ICalKeyWords.h" // Literals
+#include "ICalValue.h" // CICalValue
+
+/**
+Static factory constructor. Takes ownership of the passed value pointer and
+deletes it if this function leaves. Note that other values may be added later.
+@param aType The type of parameter.
+@param aValue A value of the parameter - this class takes ownership.
+@return A new property parameter
+@leave Leaves with KErrParameterHasNoValue if aValue is NULL.
+@publishedPartner
+*/
+EXPORT_C CICalPropertyParam* CICalPropertyParam::NewL(const TDesC& aType, CICalValue* aValue)
+ {
+ TRACE_ENTRY_POINT;
+
+ CICalPropertyParam* self = CICalPropertyParam::NewLC(aType, aValue);
+ CleanupStack::Pop(self);
+
+ TRACE_EXIT_POINT;
+ return self;
+ }
+
+/**
+Static factory constructor. Takes ownership of the passed value pointer and
+deletes it if this function leaves. Note that other values may be added later.
+The constructed object is pushed onto the Cleanup Stack.
+@param aType The type of parameter.
+@param aValue A value of the parameter - this class takes ownership.
+@return A new property parameter
+@leave Leaves with KErrParameterHasNoValue if aValue is NULL.
+@publishedPartner
+*/
+EXPORT_C CICalPropertyParam* CICalPropertyParam::NewLC(const TDesC& aType, CICalValue* aValue)
+ {
+ TRACE_ENTRY_POINT;
+
+ // Test that the value is valid before construction.
+ if (!aValue)
+ {
+ User::Leave(KErrParameterHasNoValue);
+ }
+
+ // Push aValue on the Cleanup Stack.
+ CleanupStack::PushL(aValue);
+
+ // Create a new object.
+ CICalPropertyParam* self = new (ELeave) CICalPropertyParam(aValue);
+
+ // Pop aValue from the Cleanup Stack as it is temporarily owned by self.
+ CleanupStack::Pop(aValue);
+
+ // Construct the new object.
+ CleanupStack::PushL(self);
+ self->ConstructL(aType, aValue);
+
+ TRACE_EXIT_POINT;
+ return self;
+ }
+
+/**
+Static factory constructor. Note that other values may be added later. The
+constructed object is pushed onto the Cleanup Stack.
+@param aType The type of parameter.
+@param aValue A value of the parameter passed as a descriptor.
+@return A new property parameter
+@publishedPartner
+*/
+EXPORT_C CICalPropertyParam* CICalPropertyParam::NewL(const TDesC& aType, const TDesC& aValue)
+ {
+ TRACE_ENTRY_POINT;
+
+ CICalPropertyParam* self = NewLC(aType, aValue);
+ CleanupStack::Pop(self);
+
+ TRACE_EXIT_POINT;
+ return self;
+ }
+
+/**
+Static factory constructor. Note that other values may be added later. The
+constructed object is pushed onto the Cleanup Stack.
+@param aType The type of parameter.
+@param aValue A value of the parameter passed as a descriptor.
+@return A new property parameter
+@publishedPartner
+*/
+EXPORT_C CICalPropertyParam* CICalPropertyParam::NewLC(const TDesC& aType, const TDesC& aValue)
+ {
+ TRACE_ENTRY_POINT;
+
+ CICalPropertyParam* self = new (ELeave) CICalPropertyParam;
+ CleanupStack::PushL(self);
+ self->ConstructL(aType, aValue);
+
+ TRACE_EXIT_POINT;
+ return self;
+ }
+
+/**
+Destructor
+@internalTechnology
+*/
+CICalPropertyParam::~CICalPropertyParam()
+ {
+ TRACE_ENTRY_POINT;
+
+ delete iValue;
+ delete iType;
+ iValues.ResetAndDestroy();
+
+ TRACE_EXIT_POINT;
+ }
+
+/**
+Static factory construction. The constructed object is pushed onto the Cleanup
+Stack. Note that this constructor is not exported.
+@return A new blank property parameter.
+@internalTechnology
+*/
+CICalPropertyParam* CICalPropertyParam::NewLC()
+ {
+ TRACE_ENTRY_POINT;
+
+ CICalPropertyParam* self = new (ELeave) CICalPropertyParam;
+ CleanupStack::PushL(self);
+ self->ConstructL(KNullDesC); // No type set - SetTypeL() must be called on this object.
+
+ TRACE_EXIT_POINT;
+ return self;
+ }
+
+/**
+Adds a string to the parameter's list of values. Any quotes are removed from
+the value as they are only used to escape other characters and are not a valid
+parameter value character in themselves.
+@param aValue The value to add.
+@leave Leaves if there is an error adding a value.
+@publishedPartner
+*/
+EXPORT_C void CICalPropertyParam::AddValueL(const TDesC& aValue)
+ {
+ TRACE_ENTRY_POINT;
+
+ // First remove any double quotes. These are used to escape colons, etc.
+ // in property parameter values and do not need to be stored.
+ // Note that double quote is not a valid character here and this assumes
+ // that they should all be removed. There is no check for matching quotes.
+ HBufC* parameterValue = aValue.AllocLC();
+
+ TInt location(parameterValue->Locate(KICalQuoteChar));
+
+ while (location >= 0)
+ {
+ parameterValue->Des().Delete(location, 1);
+ location = parameterValue->Locate(KICalQuoteChar);
+ }
+
+ if (parameterValue->Length() > 0)
+ {
+ // Create a new value and append to the list of values.
+ CICalValue* value = CICalValue::NewLC();
+ value->SetTextL(*parameterValue);
+ User::LeaveIfError(iValues.Append(value));
+ CleanupStack::Pop(value);
+ }
+
+ CleanupStack::PopAndDestroy(parameterValue);
+
+ TRACE_EXIT_POINT;
+ }
+
+/**
+Adds a value to the parameter's list of values, taking ownership. Note that the
+value is deleted if this function leaves.
+@param aValue The value to add.
+@leave Leaves with KErrParameterHasNoValue if aValue is NULL.
+@publishedPartner
+*/
+EXPORT_C void CICalPropertyParam::AddValueL(CICalValue* aValue)
+ {
+ TRACE_ENTRY_POINT;
+
+ if (!aValue)
+ {
+ User::Leave(KErrParameterHasNoValue);
+ }
+
+ // Append the value to the list of values.
+ TInt err(iValues.Append(aValue));
+
+ if (err)
+ {
+ delete aValue;
+ User::Leave(err);
+ }
+ TRACE_EXIT_POINT;
+ }
+
+/**
+Gets the type of the parameter
+@return The type of the property parameter or an empty descriptor if no type is
+set.
+@publishedPartner
+*/
+EXPORT_C const TDesC& CICalPropertyParam::Type() const
+ {
+ TRACE_ENTRY_POINT;
+
+ if (iType)
+ {
+ TRACE_EXIT_POINT;
+ return *iType;
+ }
+
+ // Else type is not set due to SetTypeL() leaving.
+ TRACE_EXIT_POINT;
+ return KNullDesC;
+ }
+
+/**
+Access method for the value array.
+@return The array of values.
+@publishedPartner
+*/
+EXPORT_C const RPointerArray<CICalValue>& CICalPropertyParam::Values() const
+ {
+ TRACE_ENTRY_POINT;
+ TRACE_EXIT_POINT;
+ return iValues;
+ }
+
+/**
+Sets the type of the parameter to a string value
+@param aType the type of the property parameter
+@internalTechnology
+*/
+void CICalPropertyParam::SetTypeL(const TDesC& aType)
+ {
+ TRACE_ENTRY_POINT;
+
+ delete iType;
+ iType = NULL;
+ iType = aType.AllocL();
+
+ TRACE_EXIT_POINT;
+ }
+
+/**
+Export this property parameter using the given line writer. Values are quoted
+if they contain characters that need to be escaped. Assumes it contains at
+least one value from the check in CICalProperty::ExternalizeL().
+@param aWriter The content line writer to export to.
+@internalTechnology
+*/
+void CICalPropertyParam::ExternalizeL(CICalContentLineWriter& aWriter)
+ {
+ TRACE_ENTRY_POINT;
+
+ // Export the property parameter name.
+ aWriter.AppendL(Type());
+ aWriter.AppendL(KICalEquals());
+
+ // Export each property parameter value.
+
+ const TInt lastValue = iValues.Count() - 1;
+
+ for (TInt x = 0; x <= lastValue; ++x)
+ {
+ // Decide if this value needs to be escaped - in other words
+ // if it contains a colon, a semi-colon or a comma.
+ const TDesC& value = iValues[x]->TextL();
+
+ if ((value.Locate(KICalCommaChar) >= 0) ||
+ (value.Locate(KICalColonChar) >= 0) ||
+ (value.Locate(KICalSemiColonChar) >= 0))
+ {
+ // Escape by quoting entire string.
+ aWriter.AppendL(KICalQuote());
+ aWriter.AppendL(value);
+ aWriter.AppendL(KICalQuote());
+ }
+ else
+ {
+ // No need to escape value.
+ aWriter.AppendL(value);
+ }
+
+ // Write out a comma separator between values.
+ if (x < lastValue)
+ {
+ aWriter.AppendL(KICalComma());
+ }
+ }
+ TRACE_EXIT_POINT;
+ }
+
+/**
+Determines if two property parameters are equal. Comparison is case-sensitive.
+@param aParam1 The first property parameter.
+@param aParam2 The second property parameter.
+@return ETrue if they are equal.
+@internalTechnology
+*/
+TBool CICalPropertyParam::EqualsL(const CICalPropertyParam& aParam1, const CICalPropertyParam& aParam2)
+ {
+ TRACE_ENTRY_POINT;
+
+ if (aParam1.Type() != aParam2.Type())
+ {
+ TRACE_EXIT_POINT;
+ return EFalse;
+ }
+
+ const TInt values1 = aParam1.iValues.Count();
+ const TInt values2 = aParam2.iValues.Count();
+
+ if (values1 != values2)
+ {
+ TRACE_EXIT_POINT;
+ return EFalse;
+ }
+
+ for (TInt i = 0; i < values1; i++)
+ {
+ if (aParam1.iValues[i]->TextL() != aParam2.iValues[i]->TextL())
+ {
+ TRACE_EXIT_POINT;
+ return EFalse;
+ }
+ }
+
+ TRACE_EXIT_POINT;
+ return ETrue;
+ }
+
+/**
+Constructor
+@internalTechnology
+*/
+CICalPropertyParam::CICalPropertyParam()
+ {
+ TRACE_ENTRY_POINT;
+ TRACE_EXIT_POINT;
+ }
+
+/**
+Constructor
+@param aValue The initial value.
+@internalTechnology
+*/
+CICalPropertyParam::CICalPropertyParam(CICalValue* aValue)
+ : iValue(aValue)
+ {
+ TRACE_ENTRY_POINT;
+ TRACE_EXIT_POINT;
+ }
+
+/**
+Internal construction.
+@param aType The type of parameter.
+@internalTechnology
+*/
+void CICalPropertyParam::ConstructL(const TDesC& aType)
+ {
+ TRACE_ENTRY_POINT;
+
+ iType = aType.AllocL();
+
+ TRACE_EXIT_POINT;
+ }
+
+/**
+Internal construction.
+@param aType The type of parameter.
+@param aValue A value of the parameter.
+@internalTechnology
+*/
+void CICalPropertyParam::ConstructL(const TDesC& aType, const TDesC& aValue)
+ {
+ TRACE_ENTRY_POINT;
+
+ ConstructL(aType);
+
+ // Add the value.
+ AddValueL(aValue);
+
+ TRACE_EXIT_POINT;
+ }
+
+/**
+Internal construction. Takes ownership of the passed value pointer and
+deletes it if this function leaves.
+@param aType The type of parameter.
+@param aValue A value of the parameter - this class takes ownership.
+@internalTechnology
+*/
+void CICalPropertyParam::ConstructL(const TDesC& aType, CICalValue* aValue)
+ {
+ TRACE_ENTRY_POINT;
+
+ ConstructL(aType);
+
+ // Add the value.
+ iValue = NULL; // If we got this far then we can release direct ownership of the value.
+ AddValueL(aValue); // Value is deleted if this leaves.
+
+ TRACE_EXIT_POINT;
+ }
+
+// End of File