--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/xml/xmlfw/test/rtest/tsrc/t_parser.cpp	Thu Dec 17 09:29:21 2009 +0200
@@ -0,0 +1,298 @@
+// Copyright (c) 2003-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 <e32std.h>
+#include <ecom/implementationproxy.h>
+
+#include <xml/xmlframeworkerrors.h>
+#include <xml/wbxmlextensionhandler.h>
+#include <xml/stringdictionarycollection.h>
+#include <xml/taginfo.h>
+#include <xml/attribute.h>
+#include <xml/documentparameters.h>
+#include <xml/contenthandler.h>
+#include <xml/plugins/parserinterface.h>
+#include <xml/plugins/parserinitparams.h>
+
+#include "t_testconstants.h"
+
+using namespace Xml;
+
+class CDummyParser : public CBase, public MParser
+	{
+public:
+
+	static MParser* NewL(TAny* aInitParams);
+	virtual ~CDummyParser();
+
+	// From MParser
+
+	TInt EnableFeature(TInt /*aParserFeature*/)
+		{
+		return KErrNotSupported;
+		}
+	TInt DisableFeature(TInt /*aParserFeature*/)
+		{
+		return KErrNone;
+		}
+	TBool IsFeatureEnabled(TInt /*aParserFeature*/) const
+		{
+		return EFalse;
+		}
+	void Release();
+	void ParseChunkL (const TDesC8& aDescriptor);
+	void ParseLastChunkL(const TDesC8& aDescriptor);
+
+	// From MContentSouce
+	
+	void SetContentSink (MContentHandler& aContentHandler);
+
+	RStringPool& StringPool();
+
+private:
+
+	CDummyParser(TParserInitParams* aInitParams);
+	void DoParseL();
+
+	inline void OnStartDocumentL();
+	inline void OnEndDocumentL();
+	inline void OnStartElementL();
+	inline void OnEndElementL();
+	inline void OnContentL();
+	inline void OnStartPrefixMappingL();
+	inline void OnEndPrefixMappingL();
+	inline void OnIgnorableWhiteSpaceL();
+	inline void OnSkippedEntityL();
+	inline void OnProcessingInstructionL();
+	inline void OnExtensionL();
+	inline void OnError(TInt aError);
+
+private:
+	MContentHandler*	iContentHandler;
+	RStringDictionaryCollection*		iStringDictionaryCollection;
+	CCharSetConverter* iCharSetConverter;
+	RElementStack* iElementStack;
+	};
+
+MParser* CDummyParser::NewL(TAny* aInitParams)
+	{
+
+	CDummyParser* self = new(ELeave) CDummyParser(reinterpret_cast<TParserInitParams*>(aInitParams));
+	return (static_cast<MParser*>(self));
+	}
+
+
+
+CDummyParser::CDummyParser(TParserInitParams* aInitParams)
+:	iContentHandler (reinterpret_cast<MContentHandler*>(aInitParams->iContentHandler)),
+	iStringDictionaryCollection (reinterpret_cast<RStringDictionaryCollection*>(aInitParams->iStringDictionaryCollection)),
+	iCharSetConverter (reinterpret_cast<CCharSetConverter*>(aInitParams->iCharSetConverter)),
+	iElementStack (reinterpret_cast<RElementStack*>(aInitParams->iElementStack))
+	{
+	}
+
+
+void CDummyParser::Release()
+	{
+	delete (this);
+	}
+
+
+
+CDummyParser::~CDummyParser()
+	{
+	// We don't own this
+	iContentHandler = NULL;
+	iStringDictionaryCollection = NULL;
+	iCharSetConverter = NULL;
+	iElementStack = NULL;
+	}
+
+
+void CDummyParser::ParseChunkL (const TDesC8& /*aDescriptor*/)
+	{
+	DoParseL();
+	}
+	
+	
+void CDummyParser::ParseLastChunkL(const TDesC8& /*aDescriptor*/)
+	{
+	DoParseL();
+	}
+
+
+RStringPool& CDummyParser::StringPool()
+	{
+	return iStringDictionaryCollection->StringPool();
+	}
+	
+
+
+void CDummyParser::SetContentSink (MContentHandler& aContentHandler)
+/**
+This method allows for the correct streaming of data to another plugin in the chain.
+
+@post				the next plugin in the chain is set to receive our callbacks.
+
+*/
+	{
+	iContentHandler = &aContentHandler;
+	}
+
+
+
+void CDummyParser::DoParseL()
+	{
+	OnStartDocumentL();
+	OnEndDocumentL();
+	OnStartElementL();
+	OnEndElementL();
+	OnContentL();
+	OnStartPrefixMappingL();
+	OnEndPrefixMappingL();
+	OnIgnorableWhiteSpaceL();
+	OnSkippedEntityL();
+	OnProcessingInstructionL();
+	OnExtensionL();
+	//OnError(KErrEof);
+	}
+
+
+
+void CDummyParser::OnStartDocumentL()
+	{
+	RDocumentParameters documentParameters;
+
+	iContentHandler->OnStartDocumentL(documentParameters, KErrorCodeOnStartDocument);
+	}
+
+
+void CDummyParser::OnEndDocumentL()
+	{
+	iContentHandler->OnEndDocumentL(KErrorCodeOnEndDocument);
+	}
+
+
+
+void CDummyParser::OnStartElementL()
+	{
+	RTagInfo element;
+	RAttributeArray attributes;
+
+	iContentHandler->OnStartElementL(element, attributes, KErrorCodeOnStartElement);
+	}
+	
+
+void CDummyParser::OnEndElementL()
+	{
+	RTagInfo element;
+
+	iContentHandler->OnEndElementL(element, KErrorCodeOnEndElement);
+	}
+
+
+
+void CDummyParser::OnContentL()
+	{
+	const TBuf8<2> bytes;
+
+	iContentHandler->OnContentL(bytes, KErrorCodeOnContent);
+	}
+
+
+
+void CDummyParser::OnStartPrefixMappingL()
+	{
+	RString prefix;
+	RString uri;
+
+	iContentHandler->OnStartPrefixMappingL(prefix, uri, KErrorCodeOnStartPrefixMapping);
+	}
+
+
+void CDummyParser::OnEndPrefixMappingL()
+	{
+	RString prefix;
+
+	iContentHandler->OnEndPrefixMappingL(prefix, KErrorCodeOnEndPrefixMapping);
+	}
+
+
+
+void CDummyParser::OnIgnorableWhiteSpaceL()
+	{
+	const TBuf8<2> bytes;
+
+	iContentHandler->OnIgnorableWhiteSpaceL(bytes, KErrorCodeOnIgnorableWhiteSpace);
+	}
+
+
+
+void CDummyParser::OnSkippedEntityL()
+	{
+	RString name;
+
+	iContentHandler->OnSkippedEntityL(name, KErrorCodeOnSkippedEntity);
+	}
+
+
+
+void CDummyParser::OnProcessingInstructionL()
+	{
+	TBuf8<2> target;
+	TBuf8<2> data;
+
+	iContentHandler->OnProcessingInstructionL(target, data, KErrorCodeOnProcessingInstruction);
+	}
+
+
+void CDummyParser::OnExtensionL()
+	{
+	RString data;
+	TInt token = 0;
+
+	MWbxmlExtensionHandler* ptr = 
+		static_cast<MWbxmlExtensionHandler*>
+			(iContentHandler->GetExtendedInterface(MWbxmlExtensionHandler::EExtInterfaceUid));
+
+	if (!ptr)
+		{
+		User::Leave(KErrXmlUnsupportedExtInterface);
+		}
+		
+	ptr->OnExtensionL(data, token, KErrorCodeOnExtension);	
+	}
+
+
+void CDummyParser::OnError(TInt aError)
+	{
+	iContentHandler->OnError(aError);
+	}
+
+
+// __________________________________________________________________________
+// Exported proxy for instantiation method resolution
+// Define the interface UIDs
+const TImplementationProxy ImplementationTable[] = {
+	IMPLEMENTATION_PROXY_ENTRY(0x101FBE53,CDummyParser::NewL)
+};
+
+EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
+	{
+	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
+
+	return ImplementationTable;
+	}
+