--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/genericservices/httputils/DelimitedParser/CDelimitedPathSegment.cpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,357 @@
+// Copyright (c) 2001-2009 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:
+//
+
+#include <delimitedpathsegment8.h>
+#include <delimitedpathsegment16.h>
+#include <escapeutils.h>
+
+//
+//
+// Implemetation of CDelimitedPathSegment8
+//
+//
+
+/**
+ Static factory constructor. Uses two phase construction and leaves nothing on
+ the CleanupStack.
+
+ @since 6.0
+ @param aPathSegment A descriptor with the initial path segment.
+ @return A pointer to created object.
+ @post Nothing left on the CleanupStack.
+*/
+EXPORT_C CDelimitedPathSegment8* CDelimitedPathSegment8::NewL(const TDesC8& aPathSegment)
+ {
+ CDelimitedPathSegment8* self = NewLC(aPathSegment);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+/**
+ Static factory constructor. Uses two phase construction and leaves a pointer to
+ created object on the CleanupStack.
+
+ @since 6.0
+ @param aPathSegment A descriptor with the initial path segment.
+ @return A pointer to created object.
+ @post Pointer to created object left of CleanupStack.
+*/
+EXPORT_C CDelimitedPathSegment8* CDelimitedPathSegment8::NewLC(const TDesC8& aPathSegment)
+ {
+ CDelimitedPathSegment8* self = new (ELeave) CDelimitedPathSegment8;
+ CleanupStack::PushL(self);
+ self->ConstructL(aPathSegment);
+ return self;
+ }
+
+/**
+ Destructor.
+
+ @since 6.0
+*/
+EXPORT_C CDelimitedPathSegment8::~CDelimitedPathSegment8()
+ {
+ }
+
+/**
+
+ Escape encodes the parameter then inserts the escaped version in a position before the
+ current parsed parameter. The new parameter should only contain a single path segment
+ parameter, as any parameter delimiters in the parameter will be converted to an escape
+ triple. The parser is left in a state where its current parameter is the same one as before
+ the insertion.
+
+ @since 6.0
+ @param aParam A descriptor with the unescaped path segment parameter
+ @pre The path segment must have been initially parsed.
+ @post The path segment will have been extended to include the new
+ parameter. The current segment will remain as the one before the insertion.
+*/
+EXPORT_C void CDelimitedPathSegment8::InsertAndEscapeCurrentL(const TDesC8& aParam)
+ {
+ // Create escaped version of the parameter
+ HBufC8* escaped = EscapeUtils::EscapeEncodeL(aParam, EscapeUtils::EEscapePath);
+ CleanupStack::PushL(escaped);
+
+ // Insert the segment
+ InsertCurrentL(*escaped);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(escaped);
+ }
+
+/**
+ Escape encodes the parameter then inserts the escaped version at the front of the
+ path segment. The new parameter should only contain a single path segment parameter,
+ as any parameter delimiters in the parameter will be converted to an escape triple.
+ The parser is left in a state where its current parameter is the same one as before
+ the insertion.
+
+ @warning A re-parse is required to ensure that the parser is valid.
+ @since 6.0
+ @param aParam A descriptor with the unescaped path segment parameter
+ @pre The path segment must have been initially parsed.
+ @post The path segment will have been extended to include the new
+ parameter. The current segment will remain as the one before the insertion.
+*/
+EXPORT_C void CDelimitedPathSegment8::PushAndEscapeBackL(const TDesC8& aParam)
+ {
+ // Create escaped version of the parameter
+ HBufC8* escaped = EscapeUtils::EscapeEncodeL(aParam, EscapeUtils::EEscapePath);
+ CleanupStack::PushL(escaped);
+
+ // Insert the segment
+ PushBackL(*escaped);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(escaped);
+ }
+
+/**
+ Escape encodes the parameter then inserts the escaped version at the back of the
+ path segment. The new parameter should only contain a single path segment parameter,
+ as any parameter delimiters in the parameter will be converted to an escape triple.
+ The parser is left in a state where its current parameter is the same one as before
+ the insertion.
+
+ @warning A re-parse is required to ensure that the parser is valid.
+ @since 6.0
+ @param aParam A descriptor with the unescaped path segment parameter.
+ @pre The path segment must have been initially parsed.
+ @post The path segment will have been extended to include the new
+ parameter. The current segment will remain as the one before the insertion.
+*/
+EXPORT_C void CDelimitedPathSegment8::PushAndEscapeFrontL(const TDesC8& aParam)
+ {
+ // Create escaped version of the parameter
+ HBufC8* escaped = EscapeUtils::EscapeEncodeL(aParam, EscapeUtils::EEscapePath);
+ CleanupStack::PushL(escaped);
+
+ // Insert the segment
+ PushFrontL(*escaped);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(escaped);
+ }
+
+/**
+ Constructor. First phase of two-phase construction method. Does non-allocating
+ construction.
+
+ @since 6.0
+*/
+CDelimitedPathSegment8::CDelimitedPathSegment8()
+: CDelimitedDataBase8()
+ {
+ }
+
+/**
+ Second phase of two-phase construction method. Does any allocations required to
+ fully construct the object.
+
+ @since 6.0
+ @param aPathSegment A descriptor with the initial path segment.
+ @pre First phase of construction is complete.
+ @post The object is fully constructed.
+*/
+void CDelimitedPathSegment8::ConstructL(const TDesC8& aPathSegment)
+ {
+ // Call base class ConstructL()
+ CDelimitedDataBase8::ConstructL(aPathSegment);
+
+ // Set the delimiter to ';'
+ SetDelimiter(TChar(';'));
+ }
+
+//
+//
+// Implemetation of CDelimitedPathSegment16
+//
+//
+
+/**
+ Static factory constructor. Uses two phase construction and leaves nothing on the
+ CleanupStack.
+
+ @since 6.0
+ @param aPathSegment A descriptor with the initial path segment.
+ @return A pointer to created object.
+ @post Nothing left on the CleanupStack.
+ */
+EXPORT_C CDelimitedPathSegment16* CDelimitedPathSegment16::NewL(const TDesC16& aPathSegment)
+ {
+ CDelimitedPathSegment16* self = NewLC(aPathSegment);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+/**
+ Static factory constructor. Uses two phase construction and leaves a pointer to created
+ object on the CleanupStack.
+
+ @since 6.0
+ @param aPathSegment A descriptor with the initial path segment.
+ @return A pointer to created object.
+ @post Pointer to created object left of CleanupStack.
+*/
+EXPORT_C CDelimitedPathSegment16* CDelimitedPathSegment16::NewLC(const TDesC16& aPathSegment)
+ {
+ CDelimitedPathSegment16* self = new (ELeave) CDelimitedPathSegment16;
+ CleanupStack::PushL(self);
+ self->ConstructL(aPathSegment);
+ return self;
+ }
+
+/**
+ Destructor.
+
+ @since 6.0
+*/
+EXPORT_C CDelimitedPathSegment16::~CDelimitedPathSegment16()
+ {
+ }
+
+/**
+ Escape encodes the parameter then inserts the escaped version in a position before the
+ current parsed parameter. The new parameter should only contain a single path segment
+ parameter, as any parameter delimiters in the parameter will be converted to an escape
+ triple. The parser is left in a state where its current parameter is the same one as before
+ the insertion.
+
+ @since 6.0
+ @param aParam A descriptor with the unescaped path segment parameter
+ @pre The path segment must have been initially parsed.
+ @post The path segment will have been extended to include the new
+ parameter. The current segment will remain as the one before the insertion.
+*/
+EXPORT_C void CDelimitedPathSegment16::InsertAndEscapeCurrentL(const TDesC16& aParam)
+ {
+ // Need to convert to utf8 first
+ HBufC8* utf8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aParam);
+ CleanupStack::PushL(utf8);
+
+ // Create escaped version of component
+ HBufC8* escaped = EscapeUtils::EscapeEncodeL(*utf8, EscapeUtils::EEscapePath);
+ CleanupStack::PushL(escaped);
+
+ // Convert back to 16-bits
+ HBufC16* converted = HBufC16::NewLC(escaped->Length());
+ converted->Des().Copy(*escaped);
+
+ // Insert the segment
+ InsertCurrentL(*converted);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(3, utf8); // utf8, escaped, converted
+ }
+
+/**
+ Escape encodes the parameter then inserts the escaped version at the back of the path
+ segment. The new parameter should only contain a single path segment parameter, as any
+ parameter delimiters in the parameter will be converted to an escape triple. The parser
+ is left in a state where its current parameter is the same one as before the insertion.
+
+ @warning A re-parse is required to ensure that the parser is valid.
+ @since 6.0
+ @param aParam A descriptor with the unescaped path segment parameter.
+ @pre The path segment must have been initially parsed.
+ @post The path segment will have been extended to include the new
+ parameter. The current segment will remain as the one before the insertion.
+ */
+EXPORT_C void CDelimitedPathSegment16::PushAndEscapeBackL(const TDesC16& aParam)
+ {
+ // Need to convert to utf8 first
+ HBufC8* utf8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aParam);
+ CleanupStack::PushL(utf8);
+
+ // Create escaped version of component
+ HBufC8* escaped = EscapeUtils::EscapeEncodeL(*utf8, EscapeUtils::EEscapePath);
+ CleanupStack::PushL(escaped);
+
+ // Convert back to 16-bits
+ HBufC16* converted = HBufC16::NewLC(escaped->Length());
+ converted->Des().Copy(*escaped);
+
+ // Insert the segment
+ PushBackL(*converted);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(3, utf8); // utf8, escaped, converted
+ }
+
+/**
+ Escape encodes the parameter then inserts the escaped version at the front of the
+ path segment. The new parameter should only contain a single path segment parameter,
+ as any parameter delimiters in the parameter will be converted to an escape triple.
+ The parser is left in a state where its current parameter is the same one as before
+ the insertion.
+
+ @warning A re-parse is required to ensure that the parser is valid.
+ @since 6.0
+ @param aParam A descriptor with the unescaped path segment parameter
+ @pre The path segment must have been initially parsed.
+ @post The path segment will have been extended to include the new
+ parameter. The current segment will remain as the one before the insertion.
+ */
+EXPORT_C void CDelimitedPathSegment16::PushAndEscapeFrontL(const TDesC16& aParam)
+ {
+ // Need to convert to utf8 first
+ HBufC8* utf8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aParam);
+ CleanupStack::PushL(utf8);
+
+ // Create escaped version of component
+ HBufC8* escaped = EscapeUtils::EscapeEncodeL(*utf8, EscapeUtils::EEscapePath);
+ CleanupStack::PushL(escaped);
+
+ // Convert back to 16-bits
+ HBufC16* converted = HBufC16::NewLC(escaped->Length());
+ converted->Des().Copy(*escaped);
+
+ // Insert the segment
+ PushFrontL(*converted);
+
+ // Cleanup
+ CleanupStack::PopAndDestroy(3, utf8); // utf8, escaped, converted
+ }
+
+/**
+ Constructor. First phase of two-phase construction method. Does non-allocating
+ construction.
+
+ @since 6.0
+ */
+CDelimitedPathSegment16::CDelimitedPathSegment16()
+: CDelimitedDataBase16()
+ {
+ }
+
+/**
+ Second phase of two-phase construction method. Does any allocations required to
+ fully construct the object.
+
+ @since 6.0
+ @param aPathSegment A descriptor with the initial path segment.
+ @pre First phase of construction is complete.
+ @post The object is fully constructed.
+ */
+void CDelimitedPathSegment16::ConstructL(const TDesC16& aPathSegment)
+ {
+ // Call base class ConstructL()
+ CDelimitedDataBase16::ConstructL(aPathSegment);
+
+ // Set the delimiter to ';'
+ SetDelimiter(TChar(';'));
+ }
+