--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/genericservices/httputils/Test/t_uriparser/TDelimitedDataCommon.cpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,531 @@
+// 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 <e32base.h>
+
+//
+//
+// Implementation of LOCAL functions - helper functions
+//
+//
+
+template<class HBufCType, class TPtrCType, class TDelimitedParserType>
+TInt DoDelimitedDataParsingL(const TDelimitedParserType& aParser, VA_LIST& aSegments)
+ {
+ // Loop through the list
+ TPtrCType parseSegment;
+ HBufCType* pExpected = GetNextArgLC<HBufCType>(aSegments);
+ while( pExpected )
+ {
+ // Get the parsed segment - test GetNext()
+ if( aParser.GetNext(parseSegment) == KErrNotFound )
+ {
+ // Should have found something - error!
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ return KErrNotFound;
+ }
+ // Got the segment - compare against expected
+ if( parseSegment.Compare(*pExpected) != 0 )
+ {
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ return KErrNotFound;
+ }
+ // Ok, test Dec()...
+ if( aParser.Dec() != KErrNone )
+ {
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ return KErrNotFound;
+ }
+ // Test Peek()
+ if( aParser.Peek(parseSegment) == KErrNotFound )
+ {
+ // Should have found something - error!
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ return KErrNotFound;
+ }
+ // Got the segment - compare against expected
+ if( parseSegment.Compare(*pExpected) != 0 )
+ {
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ return KErrNotFound;
+ }
+ // Ok, test Inc()...
+ if( aParser.Inc() != KErrNone )
+ {
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ return KErrNotFound;
+ }
+ // Ok get next expected segment
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ pExpected = GetNextArgLC<HBufCType>(aSegments);
+ }
+ // Got to the end - should parse no more segments
+ if( aParser.GetNext(parseSegment) != KErrNotFound )
+ {
+ // Should not have found something - error!
+ return KErrNotFound;
+ }
+ // Ok, test Dec()...
+ if( aParser.Dec() != KErrNone )
+ {
+ return KErrNotFound;
+ }
+ // Test Peek()
+ if( aParser.Peek(parseSegment) == KErrNotFound )
+ {
+ // Should have found something - error!
+ return KErrNotFound;
+ }
+ // Ok, test Inc()...
+ if( aParser.Inc() != KErrNone )
+ {
+ return KErrNotFound;
+ }
+ // Ok, test Eos()
+ if( !aParser.Eos() != KErrNone )
+ {
+ return KErrNotFound;
+ }
+ return KErrNone;
+ }
+
+template<class HBufCType>
+HBufCType* GetNextArgLC(VA_LIST& aList)
+ {
+ const TDesC* arg = VA_ARG(aList, const TDesC*);
+ if( arg == NULL )
+ {
+ return NULL;
+ }
+ HBufCType* buf = HBufCType::NewLC(arg->Length());
+ buf->Des().Copy(*arg);
+ return buf;
+ }
+
+template<class TDelimitedParserType>
+TInt DoDelimiterPresenceTest(const TDelimitedParserType& aParser, TBool aFrontDelim, TBool aBackDelim)
+ {
+ TBool frontDelim = aParser.FrontDelimiter();
+ if( (!frontDelim && aFrontDelim) | (frontDelim && !aFrontDelim) )
+ {
+ return KErrNotFound;
+ }
+ TBool backDelim = aParser.BackDelimiter();
+ if( (!backDelim && aBackDelim) | (backDelim && !aBackDelim) )
+ {
+ return KErrNotFound;
+ }
+ return KErrNone;
+ }
+
+template<class HBufCType, class TPtrCType, class TDelimitedParserType>
+TInt DoDelimitedDataRemainderTestL(const TDelimitedParserType& aParser, VA_LIST& aRemainders)
+ {
+ // Loop through the list
+ TPtrCType parseRemainder;
+ HBufCType* pExpected = GetNextArgLC<HBufCType>(aRemainders);
+ while( pExpected )
+ {
+ // Get the remaining data
+ if( aParser.Remainder(parseRemainder) == KErrNotFound )
+ {
+ // Should have found something - error!
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ return KErrNotFound;
+ }
+ // Got the remainder - compare against expected
+ if( parseRemainder.Compare(*pExpected) != 0 )
+ {
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ return KErrNotFound;
+ }
+ // Ok, parse the to the next segment...
+ if( aParser.Inc() != KErrNone )
+ {
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ return KErrNotFound;
+ }
+ // Ok get next expected remainder
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ pExpected = GetNextArgLC<HBufCType>(aRemainders);
+ }
+ // Got to the end - should get no remainder
+ if( aParser.Remainder(parseRemainder) != KErrNotFound )
+ {
+ // Should not have found something - error!
+ return KErrNotFound;
+ }
+ return KErrNone;
+ }
+
+template<class TDelimitedParserType, class TDesCType>
+TInt DoDelimitedDataDes(const TDelimitedParserType& aParser, const TDesCType& aDelimitedData)
+ {
+ if( aParser.Des().Compare(aDelimitedData) != 0)
+ {
+ return KErrNotFound;
+ }
+ return KErrNone;
+ }
+
+template<class HBufCType, class CDelimitedDataType>
+TInt DoDelimitedDataPushFrontL(CDelimitedDataType* aParser, VA_LIST& aData)
+ {
+ // Loop through the list
+ TInt error = KErrNone;
+ HBufCType* pData = GetNextArgLC<HBufCType>(aData);
+ HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);
+ while( pExpected && pData )
+ {
+ // Push front
+ TRAP(error, aParser->PushFrontL(*pData));
+ if( error != KErrNone )
+ {
+ CleanupStack::PopAndDestroy(2, pData); // pData, pExpected
+ return error;
+ }
+ // Check against expected
+ if( aParser->Parser().Des().Compare(*pExpected) != 0 )
+ {
+ CleanupStack::PopAndDestroy(2, pData); // pData, pExpected
+ return KErrNotFound;
+ }
+ // Ok get next set of data
+ CleanupStack::PopAndDestroy(2, pData); // pData, pExpected
+ pData = GetNextArgLC<HBufCType>(aData);
+ pExpected = GetNextArgLC<HBufCType>(aData);
+ }
+ return KErrNone;
+ }
+
+template<class HBufCType, class CDelimitedDataType>
+TInt DoDelimitedDataPushBackL(CDelimitedDataType* aParser, VA_LIST& aData)
+ {
+ // Loop through the list
+ TInt error = KErrNone;
+ HBufCType* pData = GetNextArgLC<HBufCType>(aData);
+ HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);
+ while( pExpected && pData )
+ {
+ // Push front
+ TRAP(error, aParser->PushBackL(*pData));
+ if( error != KErrNone )
+ {
+ CleanupStack::PopAndDestroy(2, pData); // pData, pExpected
+ return error;
+ }
+ // Check against expected
+ if( aParser->Parser().Des().Compare(*pExpected) != 0 )
+ {
+ CleanupStack::PopAndDestroy(2, pData); // pData, pExpected
+ return KErrNotFound;
+ }
+ // Ok get next set of data
+ CleanupStack::PopAndDestroy(2, pData); // pData, pExpected
+ pData = GetNextArgLC<HBufCType>(aData);
+ pExpected = GetNextArgLC<HBufCType>(aData);
+ }
+ return KErrNone;
+ }
+
+template<class HBufCType, class CDelimitedDataType>
+TInt DoDelimitedDataPopFrontL(CDelimitedDataType* aParser, VA_LIST& aData)
+ {
+ // Loop through the list
+ TInt error = KErrNone;
+ HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);
+ while( pExpected )
+ {
+ // Push front
+ TRAP(error, aParser->PopFrontL());
+ if( error != KErrNone )
+ {
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ return error;
+ }
+ // Check against expected
+ if( aParser->Parser().Des().Compare(*pExpected) != 0 )
+ {
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ return KErrNotFound;
+ }
+ // Ok get next set of data
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ pExpected = GetNextArgLC<HBufCType>(aData);
+ }
+ return KErrNone;
+ }
+
+template<class HBufCType, class CDelimitedDataType>
+TInt DoDelimitedDataPopBackL(CDelimitedDataType* aParser, VA_LIST& aData)
+ {
+ // Loop through the list
+ TInt error = KErrNone;
+ HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);
+ while( pExpected )
+ {
+ // Push front
+ TRAP(error, aParser->PopBackL());
+ if( error != KErrNone )
+ {
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ return error;
+ }
+ // Check against expected
+ if( aParser->Parser().Des().Compare(*pExpected) != 0 )
+ {
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ return KErrNotFound;
+ }
+ // Ok get next set of data
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ pExpected = GetNextArgLC<HBufCType>(aData);
+ }
+ return KErrNone;
+ }
+
+template<class CDelimitedDataType>
+TInt DoDelimitedDataAddAndTrimFrontAndBackDelimiterL(CDelimitedDataType* aParser)
+ {
+ TInt error = KErrNone;
+ // Add front delimiter
+ TRAP(error, aParser->AddFrontDelimiterL());
+ if( error != KErrNone )
+ {
+ return KErrNotFound;
+ }
+ if( !aParser->Parser().FrontDelimiter() )
+ {
+ return KErrNotFound;
+ }
+ // Trim front delimiter
+ TRAP(error, aParser->TrimFrontDelimiterL());
+ if( error != KErrNone )
+ {
+ return KErrNotFound;
+ }
+ if( aParser->Parser().FrontDelimiter() )
+ {
+ return KErrNotFound;
+ }
+ // Add back delimiter
+ TRAP(error, aParser->AddBackDelimiterL());
+ if( error != KErrNone )
+ {
+ return KErrNotFound;
+ }
+ if( !aParser->Parser().BackDelimiter() )
+ {
+ return KErrNotFound;
+ }
+ // Trim back delimiter
+ TRAP(error, aParser->TrimBackDelimiterL());
+ if( error != KErrNone )
+ {
+ return KErrNotFound;
+ }
+ if( aParser->Parser().BackDelimiter() )
+ {
+ return KErrNotFound;
+ }
+ return KErrNone;
+ }
+
+template<class CDelimitedDataType>
+TInt DoDelimitedDataParseToPosition(CDelimitedDataType* aParser, TInt aStartPos)
+ {
+ // Parse to correct place - initial parse must have been done
+ TInt i=0;
+ while( i < aStartPos && !aParser->Parser().Eos() )
+ {
+ aParser->Parser().Inc();
+ ++i;
+ }
+ if( i != aStartPos )
+ {
+ return KErrNotFound;
+ }
+ return KErrNone;
+ }
+
+template<class HBufCType, class TPtrCType, class CDelimitedDataType>
+TInt DoDelimitedDataInsertL(CDelimitedDataType* aParser, VA_LIST& aData)
+ {
+ // Loop through the list and insert!
+ TInt error = KErrNone;
+ HBufCType* pData = GetNextArgLC<HBufCType>(aData);
+ HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);
+ while( pExpected && pData )
+ {
+ // Get copy of current segment
+ TPtrCType seg;
+ aParser->Parser().Peek(seg);
+ HBufCType* segCopy = seg.AllocLC();
+ // Insert current
+ TRAP(error, aParser->InsertCurrentL(*pData));
+ if( error != KErrNone )
+ {
+ CleanupStack::PopAndDestroy(3, pData); // pData, pExpected, segCopy
+ return error;
+ }
+ // Check against expected
+ if( aParser->Parser().Des().Compare(*pExpected) != 0 )
+ {
+ CleanupStack::PopAndDestroy(3, pData); // pData, pExpected, segCopy
+ return KErrNotFound;
+ }
+ // Check that the current segment hasn't changed
+ aParser->Parser().Peek(seg);
+ if( segCopy->Compare(seg) != 0 )
+ {
+ CleanupStack::PopAndDestroy(3, pData); // pData, pExpected, segCopy
+ return KErrNotFound;
+ }
+ // Ok get next set of data
+ CleanupStack::PopAndDestroy(3, pData); // pData, pExpected, segCopy
+ pData = GetNextArgLC<HBufCType>(aData);
+ pExpected = GetNextArgLC<HBufCType>(aData);
+ }
+ return KErrNone;
+ }
+
+template<class HBufCType, class TPtrCType, class CDelimitedDataType>
+TInt DoDelimitedDataRemoveL(CDelimitedDataType* aParser, VA_LIST& aData)
+ {
+ // Loop through the list
+ TInt error = KErrNone;
+ HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);
+ while( pExpected )
+ {
+ // Remove current
+ TRAP(error, aParser->RemoveCurrentL());
+ if( error != KErrNone )
+ {
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ return error;
+ }
+ // Check against expected
+ if( aParser->Parser().Des().Compare(*pExpected) != 0 )
+ {
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ return KErrNotFound;
+ }
+ // Ok get next set of data
+ CleanupStack::PopAndDestroy(pExpected); // pExpected
+ pExpected = GetNextArgLC<HBufCType>(aData);
+ }
+ return KErrNone;
+ }
+
+template<class HBufCType, class TPtrCType, class CDelimitedDataType>
+TInt DoDelimitedDataInsertAndEscapeL(CDelimitedDataType* aParser, VA_LIST& aData)
+ {
+ // Loop through the list and insert!
+ TInt error = KErrNone;
+ HBufCType* pData = GetNextArgLC<HBufCType>(aData);
+ HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);
+ while( pExpected && pData )
+ {
+ // Get copy of current segment
+ TPtrCType seg;
+ aParser->Parser().Peek(seg);
+ HBufCType* segCopy = seg.AllocLC();
+ // Insert current
+ TRAP(error, aParser->InsertAndEscapeCurrentL(*pData));
+ if( error != KErrNone )
+ {
+ CleanupStack::PopAndDestroy(3, pData); // pData, pExpected, segCopy
+ return error;
+ }
+ // Check against expected
+ if( aParser->Parser().Des().Compare(*pExpected) != 0 )
+ {
+ CleanupStack::PopAndDestroy(3, pData); // pData, pExpected, segCopy
+ return KErrNotFound;
+ }
+ // Check that the current segment hasn't changed
+ aParser->Parser().Peek(seg);
+ if( segCopy->Compare(seg) != 0 )
+ {
+ CleanupStack::PopAndDestroy(3, pData); // pData, pExpected, segCopy
+ return KErrNotFound;
+ }
+ // Ok get next set of data
+ CleanupStack::PopAndDestroy(3, pData); // pData, pExpected, segCopy
+ pData = GetNextArgLC<HBufCType>(aData);
+ pExpected = GetNextArgLC<HBufCType>(aData);
+ }
+ return KErrNone;
+ }
+
+template<class HBufCType, class CDelimitedDataType>
+TInt DoDelimitedDataPushAndEscapeFrontL(CDelimitedDataType* aParser, VA_LIST& aData)
+ {
+ // Loop through the list
+ TInt error = KErrNone;
+ HBufCType* pData = GetNextArgLC<HBufCType>(aData);
+ HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);
+ while( pExpected && pData )
+ {
+ // Push front
+ TRAP(error, aParser->PushAndEscapeFrontL(*pData));
+ if( error != KErrNone )
+ {
+ CleanupStack::PopAndDestroy(2, pData); // pData, pExpected
+ return error;
+ }
+ // Check against expected
+ if( aParser->Parser().Des().Compare(*pExpected) != 0 )
+ {
+ CleanupStack::PopAndDestroy(2, pData); // pData, pExpected
+ return KErrNotFound;
+ }
+ // Ok get next set of data
+ CleanupStack::PopAndDestroy(2, pData); // pData, pExpected
+ pData = GetNextArgLC<HBufCType>(aData);
+ pExpected = GetNextArgLC<HBufCType>(aData);
+ }
+ return KErrNone;
+ }
+
+template<class HBufCType, class CDelimitedDataType>
+TInt DoDelimitedDataPushAndEscapeBackL(CDelimitedDataType* aParser, VA_LIST& aData)
+ {
+ // Loop through the list
+ TInt error = KErrNone;
+ HBufCType* pData = GetNextArgLC<HBufCType>(aData);
+ HBufCType* pExpected = GetNextArgLC<HBufCType>(aData);
+ while( pExpected && pData )
+ {
+ // Push front
+ TRAP(error, aParser->PushAndEscapeBackL(*pData));
+ if( error != KErrNone )
+ {
+ CleanupStack::PopAndDestroy(2, pData); // pData, pExpected
+ return error;
+ }
+ // Check against expected
+ if( aParser->Parser().Des().Compare(*pExpected) != 0 )
+ {
+ CleanupStack::PopAndDestroy(2, pData); // pData, pExpected
+ return KErrNotFound;
+ }
+ // Ok get next set of data
+ CleanupStack::PopAndDestroy(2, pData); // pData, pExpected
+ pData = GetNextArgLC<HBufCType>(aData);
+ pExpected = GetNextArgLC<HBufCType>(aData);
+ }
+ return KErrNone;
+ }