diff -r 000000000000 -r e4d67989cc36 genericservices/httputils/DelimitedParser/CDelimitedPath.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/genericservices/httputils/DelimitedParser/CDelimitedPath.cpp Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,330 @@ +// 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 +#include +#include + +// +// +// Implemetation of CDelimitedPath8 +// +// + +/** + Static factory constructor. Uses two phase construction and leaves + nothing on the CleanupStack. + + @param aPath A descriptor with the initial path. + @return A pointer to the newly created object. + */ +EXPORT_C CDelimitedPath8* CDelimitedPath8::NewL(const TDesC8& aPath) + { + CDelimitedPath8* self = NewLC(aPath); + CleanupStack::Pop(self); + return self; + } + +/** + Static factory constructor. Uses two phase construction and leaves a pointer + to created object on the CleanupStack. + + @param aPath A descriptor with the initial path. + @return A pointer to the newly created object. + */ +EXPORT_C CDelimitedPath8* CDelimitedPath8::NewLC(const TDesC8& aPath) + { + CDelimitedPath8* self = new (ELeave) CDelimitedPath8; + CleanupStack::PushL(self); + self->ConstructL(aPath); + return self; + } + +/** + Destructor. +*/ +EXPORT_C CDelimitedPath8::~CDelimitedPath8() + { + } + +/** + Escape encodes the segment then inserts the escaped version in a position before + the current parsed segment. The new segment should only contain a single path segment, + as any path delimiters in the segment will be converted to an escape triple. + The parser is left in a state where its current segment is the same one as before the insertion. + + @pre The path must have been initially parsed. + @param aSegment A descriptor with the unescaped path segment. + @post The path will have been extended to include the new segment. + The current segment will remain as the one before the insertion. + */ +EXPORT_C void CDelimitedPath8::InsertAndEscapeCurrentL(const TDesC8& aSegment) + { + // Create escaped version of the segment + HBufC8* escaped = EscapeUtils::EscapeEncodeL(aSegment, EscapeUtils::EEscapePath); + CleanupStack::PushL(escaped); + + // Insert the segment + InsertCurrentL(*escaped); + + // Cleanup + CleanupStack::PopAndDestroy(escaped); + } + +/** + Escape encodes the segment then inserts the escaped version at the back of the path. + The new segment should only contain a single path segment, as any path delimiters in + the segment will be converted to an escape triple. The parser is left in a state + where its current segment is the same one as before the insertion. + + @pre The delimiter must have been set. + @param aSegment A descriptor with the unescaped path segment. + @post The path will have been extended to include the new segment + */ +EXPORT_C void CDelimitedPath8::PushAndEscapeBackL(const TDesC8& aSegment) + { + // Create escaped version of the segment + HBufC8* escaped = EscapeUtils::EscapeEncodeL(aSegment, EscapeUtils::EEscapePath); + CleanupStack::PushL(escaped); + + // Insert the segment + PushBackL(*escaped); + + // Cleanup + CleanupStack::PopAndDestroy(escaped); + } + +/** + Escape encodes the segment then inserts the escaped version at the front of the path. + The new segment should only contain a single path segment, as any path delimiters in + the segment will be converted to an escape triple. The parser is left in a state where + its current segment is the same one as before the insertion. + + @pre The delimiter must have been set. + @param aSegment A descriptor with the unescaped path segment. + @post The path will have been extended to include the new segment + */ +EXPORT_C void CDelimitedPath8::PushAndEscapeFrontL(const TDesC8& aSegment) + { + // Create escaped version of the segment + HBufC8* escaped = EscapeUtils::EscapeEncodeL(aSegment, EscapeUtils::EEscapePath); + CleanupStack::PushL(escaped); + + // Insert the segment + PushFrontL(*escaped); + + // Cleanup + CleanupStack::PopAndDestroy(escaped); + } + +/** + Constructor. +*/ +CDelimitedPath8::CDelimitedPath8() +: CDelimitedDataBase8() + { + } + +/** + Second phase of two-phase construction method. Does any allocations required to fully construct + the object. + + @param aPath A descriptor with the initial string. + @pre First phase of construction is complete. + @post The object is fully constructed. +*/ +void CDelimitedPath8::ConstructL(const TDesC8& aPath) + { + // Call base class ConstructL() + CDelimitedDataBase8::ConstructL(aPath); + + // Set the delimiter to '/' + SetDelimiter(TChar('/')); + } + +// +// +// Implemetation of CDelimitedPath16 +// +// + +/** + Static factory constructor. Uses two phase construction and leaves nothing on + the CleanupStack. + + @since 6.0 + @param aPath A descriptor with the initial path. + @return A pointer to created object. + @post Nothing left on the CleanupStack. + */ +EXPORT_C CDelimitedPath16* CDelimitedPath16::NewL(const TDesC16& aPath) + { + CDelimitedPath16* self = NewLC(aPath); + 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 aPath A descriptor with the initial path. + @return A pointer to created object. + @post Pointer to created object left of CleanupStack. +*/ +EXPORT_C CDelimitedPath16* CDelimitedPath16::NewLC(const TDesC16& aPath) + { + CDelimitedPath16* self = new (ELeave) CDelimitedPath16; + CleanupStack::PushL(self); + self->ConstructL(aPath); + return self; + } + +/** + Destructor. + + @since 6.0 +*/ +EXPORT_C CDelimitedPath16::~CDelimitedPath16() + { + } + +/** + Escape encodes the segment then inserts the escaped version in a position before the + current parsed segment. The new segment should only contain a single path segment, as + any path delimiters in the segment will be converted to an escape triple. The parser + is left in a state where its current segment is the same one as before the insertion. + + @since 6.0 + @param aSegment A descriptor with the unescaped path segment. + @pre The path must have been initially parsed. + @post The path will have been extended to include the new segment. The + current segment will remain as the one before the insertion. +*/ +EXPORT_C void CDelimitedPath16::InsertAndEscapeCurrentL(const TDesC16& aSegment) + { + // Need to convert to utf8 first + HBufC8* utf8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aSegment); + 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 segment then inserts the escaped version at the back of the path. + The new segment should only contain a single path segment, as any path delimiters in + the segment will be converted to an escape triple. The parser is left in a state where + its current segment 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 aSegment A descriptor with the unescaped path segment. + @pre The delimiter must have been set. + @post The path will have been extended to include the new segment. +*/ +EXPORT_C void CDelimitedPath16::PushAndEscapeBackL(const TDesC16& aSegment) + { + // Need to convert to utf8 first + HBufC8* utf8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aSegment); + 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 segment then inserts the escaped version at the front of the path. + The new segment should only contain a single path segment, as any path delimiters in + the segment will be converted to an escape triple. The parser is left in a state where + its current segment 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 aSegment A descriptor with the unescaped path segment. + @pre The delimiter must have been set. + @post The path will have been extended to include the new segment. +*/ +EXPORT_C void CDelimitedPath16::PushAndEscapeFrontL(const TDesC16& aSegment) + { + // Need to convert to utf8 first + HBufC8* utf8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aSegment); + 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 +*/ +CDelimitedPath16::CDelimitedPath16() +: CDelimitedDataBase16() + { + } + +/** + Second phase of two-phase construction method. Does any allocations required to fully construct + the object. + + @since 6.0 + @param aPath A descriptor with the initial path. + @pre First phase of construction is complete. + @post The object is fully constructed. +*/ +void CDelimitedPath16::ConstructL(const TDesC16& aPath) + { + // Call base class ConstructL() + CDelimitedDataBase16::ConstructL(aPath); + + // Set the delimiter to '/' + SetDelimiter(TChar('/')); + }