diff -r 000000000000 -r 62f9d29f7211 webservices/wsfragment/src/senfragmentbase.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsfragment/src/senfragmentbase.cpp	Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,1632 @@
+/*
+* Copyright (c) 2002-2006 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:        Class implements XML base fragment using libxml2 classes
+*
+*/
+
+
+
+
+
+
+
+
+// INCLUDE FILES
+#include <flogger.h>
+#include <utf.h>
+#include <s32mem.h>
+#include "SenFragmentBase.h"
+#include "SenParser.h"
+#include "wslibxml2utils.h"
+
+#include <SenXmlConstants.h>
+
+#include <xml/attribute.h>               // needed for RAttributeArray
+#include <xml/parserfeature.h>           // for TParserFeature enumeration
+#include <xmlengserializationoptions.h> // for TSerializationOptions
+#include <xmlengbinarycontainer.h>
+#include <xmlengnodelist.h>
+
+
+typedef unsigned char xmlChar; // from "libxml/Libxml2_xmlstring.h"
+
+using namespace Xml;
+
+// ***************************************************************************
+// Fragment class state constants are as following (declared in subclasses):
+// KSenStateNotSet                  = -1;
+// KSenStateIgnore                  =  0; // even ones ignore(0),
+// KSenStateSave                    =  1; // and odd ones save(1)
+// KSenStateResume                  =  2;
+// KStateParsingFramework           =  4;
+// KStateParsingSoapFault           =  5;  // odd, save
+// KStateParsingServiceDescription  =  6;
+// KStateParsingResourceOffering    =  11; // odd, save
+// KStateParsingCredentials         =  12;
+// KStateParsingService             =  13; // odd state, saves content
+// KStateParsingPwTransforms        =  14;
+// KStateParsingSoapHeader          =  20; // ignore state (even num)
+// KStateParsingSoapBody            =  40; // ignore state (even num)
+// KStateParsingSingleCredential    =  122;
+// KStateParsingProviderPolicy      =  1222;
+
+namespace
+    {
+    const TInt KFlatBufSize = 128;
+    _LIT(KSenFragmentPanic, "SenFragment");
+    
+    TBool EncodeXmlEscapesL( const TDesC8& aOriginal, HBufC8*& aEncoded )
+        {
+        TBool retVal = EFalse;
+        delete aEncoded;
+        aEncoded = NULL;
+    
+        if (aOriginal == KNullDesC8)
+            {
+            return retVal;
+            }
+        TPtrC8 tokens[] =
+            {
+            KSenEscapedAmp(),
+            KSenEscapedApos(),
+            KSenEscapedDblQuot(),
+            KSenEscapedGt(),
+            KSenEscapedLt()  
+            };
+        TText16 tokenChars[] =
+            {
+            '&',
+            '\'',
+            '\"',
+            '>',
+            '<'
+            };
+        
+        // Replace escaped characters, if any
+        for (TInt i = 0; i < aOriginal.Length(); i++)
+            {
+            TBool foundChar = EFalse;
+            //for (TInt j = 0; j < (sizeof(tokenChars) / sizeof(TText16)); j++)
+            for (TInt j = 0; j < 5; j++)
+                {
+                if (aOriginal[i] == tokenChars[j])
+                    {
+                    if ( !aEncoded )
+                        {
+                        aEncoded =
+                            HBufC8::NewL(aOriginal.Length() * KSenMaxXmlEscapedLength);
+                        aEncoded->Des().Append(aOriginal.Left(i));
+                        }
+                    foundChar = ETrue;
+                    aEncoded->Des().Append(tokens[j]);
+                    retVal = ETrue; // indicate, that encoding was done
+                    break;
+                    }
+                }
+            if (!foundChar)
+                {
+                if (aEncoded)
+                    {
+                    
+                    aEncoded->Des().Append(aOriginal[i]);
+                    }
+                }
+            }
+        return retVal;
+        }
+    }
+
+EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(const TXmlEngElement& aElement)
+    {
+    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;
+    CleanupStack::PushL(pNew);
+    pNew->BaseConstructL(aElement);
+    CleanupStack::Pop(pNew);
+    return pNew;
+    }
+
+EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(const TDesC8& aLocalName)
+    {
+    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;
+    CleanupStack::PushL(pNew);
+    pNew->BaseConstructL(aLocalName);
+    CleanupStack::Pop(pNew);
+    return pNew;
+    }
+
+EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(const TDesC8& aNsUri,
+                                                  const TDesC8& aLocalName
+    )
+    {
+    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;
+    CleanupStack::PushL(pNew);
+    pNew->BaseConstructL(aNsUri, aLocalName);
+    CleanupStack::Pop(pNew);
+    return pNew;
+    }
+
+EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(const TDesC8& aNsUri,
+                                                  const TDesC8& aLocalName,
+                                                  const TDesC8& aPrefix,
+                                                  const RAttributeArray& aAttrs
+    )
+    {
+    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;
+    CleanupStack::PushL(pNew);
+    pNew->BaseConstructL(aNsUri, aLocalName, aPrefix, aAttrs);
+    CleanupStack::Pop(pNew);
+    return pNew;
+    }
+
+EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(const TDesC8& aNsUri,
+                                                  const TDesC8& aLocalName,
+                                                  const TDesC8& aPrefix,
+                                                  const RAttributeArray& aAttrs,
+                                                  TXmlEngElement& aParent
+    )
+    {
+    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;
+    CleanupStack::PushL(pNew);
+    pNew->BaseConstructL(aNsUri, aLocalName, aPrefix, aAttrs, aParent);
+    CleanupStack::Pop(pNew);
+    return pNew;
+    }
+
+EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(const TDesC8& aNsUri,
+                                                  const TDesC8& aLocalName,
+                                                  const TDesC8& aPrefix,
+                                                  const RAttributeArray& aAttrs,
+                                                  TXmlEngElement& aParent,
+                                                  RSenDocument& aOwnerDocument
+    )
+    {
+    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;
+    CleanupStack::PushL(pNew);
+    pNew->BaseConstructL(aNsUri, aLocalName, aPrefix, aAttrs, aParent,
+                         aOwnerDocument);
+    CleanupStack::Pop(pNew);
+    return pNew;
+    }
+
+EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(const TDesC8& aNsUri,
+                                                  const TDesC8& aLocalName,
+                                                  const TDesC8& aPrefix
+    )
+    {
+    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;
+    CleanupStack::PushL(pNew);
+    pNew->BaseConstructL(aNsUri, aLocalName, aPrefix);
+    CleanupStack::Pop(pNew);
+    return pNew;
+    }
+    
+EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(TXmlEngElement& aRootElement,
+                                                  RSenDocument& aOwnerDocument)
+    {
+    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;
+    CleanupStack::PushL(pNew);
+    pNew->BaseConstructL(aRootElement, aOwnerDocument);
+    CleanupStack::Pop(pNew);
+    return pNew;
+    }
+
+EXPORT_C CSenFragmentBase::~CSenFragmentBase()
+    {
+    if ( ipNamespaceArray )
+        {
+        ipNamespaceArray->ResetAndDestroy();
+        delete ipNamespaceArray;
+        }
+    iDocument.Close();
+    if ( ipContentBuf )
+    	{
+                
+        delete ipContentBuf;
+        ipContentBuf = NULL;
+        
+        delete ipContentWriteStream;
+        ipContentWriteStream = NULL;
+        }
+        
+     if ( ipDelegate )
+        {
+        delete ipDelegate;
+        ipDelegate = NULL;
+        }   
+    }
+
+EXPORT_C CSenFragmentBase::CSenFragmentBase()
+:   iState(KSenStateIgnore),
+    ipParser(NULL),
+    ipOwner(NULL),
+    ipDelegate(NULL)
+    {
+    }
+
+EXPORT_C void CSenFragmentBase::BaseConstructL(const TXmlEngElement& aSrc)
+    {
+    iElement = aSrc.CopyL();
+    iDocument = RSenDocument::NewL();
+    iDocument.SetDocumentElement(iElement);
+    }
+
+EXPORT_C void CSenFragmentBase::BaseConstructL(const TDesC8& aLocalName)
+    {
+    iDocument = RSenDocument::NewL();
+    if ( aLocalName != KNullDesC8 )
+        {
+        iDocument.CreateDocumentElementL(aLocalName);
+        iElement = iDocument.DocumentElement();
+        }
+    }
+
+EXPORT_C void CSenFragmentBase::BaseConstructL(const TDesC8& aNsUri,
+                                               const TDesC8& aLocalName
+    )
+    {
+    iDocument = RSenDocument::NewL();
+    iDocument.CreateDocumentElementL(aLocalName, aNsUri);
+    iElement = iDocument.DocumentElement();
+    }
+
+EXPORT_C void CSenFragmentBase::BaseConstructL(const TDesC8& aNsUri,
+                                               const TDesC8& aLocalName,
+                                               const TDesC8& aPrefix,
+                                               const RAttributeArray& aAttrs
+    )
+    {
+    iDocument = RSenDocument::NewL();
+    if (aPrefix == KNullDesC8)
+        {
+        iDocument.CreateDocumentElementL(aLocalName, aNsUri);
+        }
+    else
+        {
+        iDocument.CreateDocumentElementL(aLocalName, aNsUri, aPrefix);
+        }
+
+    iElement = iDocument.DocumentElement();
+    AddAttributesL(aAttrs);
+    }
+
+EXPORT_C void CSenFragmentBase::BaseConstructL(
+    const TDesC8& aNsUri,
+    const TDesC8& aLocalName,
+    const TDesC8& aPrefix,
+    const RAttributeArray& aAttributes,
+    TXmlEngElement& aParent
+    )
+    {
+    iDocument = RSenDocument::NewL();
+    iElement = aParent.AddNewElementL(aLocalName);
+
+    if (aNsUri != KNullDesC8 || aPrefix != KNullDesC8)
+        {
+        if (aPrefix == KNullDesC8)
+            {
+            // Check if namespace declaration for the root tag
+            // is already defined in parent element.
+            TXmlEngNamespace ns = aParent.LookupNamespaceByUriL(aNsUri);
+            if ( ns.IsNull() )
+                {
+                // Namespace declaration will be added to iElement
+                iElement.AddNamespaceDeclarationL(aNsUri, KNullDesC8);
+                }
+
+            WsXmlUtils domUtils;       
+            domUtils.XmlEngRenameElementL(iElement, aLocalName, aNsUri, KNullDesC8);
+            }
+        else
+            {
+            // Check if namespace declaration for the root tag
+            // is already defined in parent element.
+            TXmlEngNamespace ns = aParent.LookupNamespaceByUriL(aNsUri);
+            if ( ns.IsNull() )
+                {
+                // Namespace declaration will be added to iElement
+                iElement.AddNamespaceDeclarationL(aNsUri, aPrefix);
+                }
+
+            WsXmlUtils domUtils;
+            domUtils.XmlEngRenameElementL(iElement, aLocalName, aNsUri, aPrefix);
+            }
+        }
+    
+    aParent.AppendChildL(iElement);
+
+    AddAttributesL(aAttributes);
+    }
+
+EXPORT_C void CSenFragmentBase::BaseConstructL(
+    const TDesC8& aNsUri,
+    const TDesC8& aLocalName,
+    const TDesC8& aPrefix,
+    const RAttributeArray& aAttributes,
+    TXmlEngElement& aParent,
+    RSenDocument& aOwnerDocument
+    )
+    {
+    iDocument = aOwnerDocument.Copy();
+    iElement = aParent.AddNewElementL(aLocalName);
+    
+    if ( aNsUri != KNullDesC8 || aPrefix != KNullDesC8 )
+        {
+        if ( aPrefix == KNullDesC8 )
+            {
+            // Check if namespace declaration for the root tag
+            // is already defined in parent element.
+            TXmlEngNamespace ns = aParent.LookupNamespaceByUriL(aNsUri);
+            if ( ns.IsNull() )
+                {
+                // Namespace declaration will be added to iElement
+                iElement.AddNamespaceDeclarationL(aNsUri, KNullDesC8);
+                }
+
+            WsXmlUtils domUtils;
+            domUtils.XmlEngRenameElementL(iElement, aLocalName, aNsUri, KNullDesC8);
+            }
+        else
+            {
+            // Check if namespace declaration for the root tag
+            // is already defined in parent element.
+            TXmlEngNamespace ns = aParent.LookupNamespaceByUriL(aNsUri);
+            if ( ns.IsNull() )
+                {
+                // Namespace declaration will be added to iElement
+                iElement.AddNamespaceDeclarationL(aNsUri, aPrefix);
+                }
+            WsXmlUtils domUtils;
+            domUtils.XmlEngRenameElementL(iElement, aLocalName, aNsUri, aPrefix);
+            }
+        }
+    
+    aParent.AppendChildL(iElement);
+
+    AddAttributesL(aAttributes);
+    }
+
+EXPORT_C void CSenFragmentBase::BaseConstructL(const TDesC8& aNsUri,
+                                               const TDesC8& aLocalName,
+                                               const TDesC8& aPrefix
+    )
+    {
+    iDocument = RSenDocument::NewL();
+    if ( aNsUri == KNullDesC8 && aPrefix == KNullDesC8 )
+        {
+        iDocument.CreateDocumentElementL(aLocalName);
+        }
+    else
+        {
+        if ( aPrefix == KNullDesC8 )
+            {
+            iDocument.CreateDocumentElementL(aLocalName, aNsUri, KNullDesC8);
+            }
+        else
+            {
+            iDocument.CreateDocumentElementL(aLocalName, aNsUri, aPrefix);
+            }
+        }
+    iElement = iDocument.DocumentElement();
+    }
+    
+EXPORT_C void CSenFragmentBase::BaseConstructL(TXmlEngElement& aRootElement,
+                                               RSenDocument& aOwnerDocument)
+    {
+    iDocument = aOwnerDocument.Copy();
+    iElement = aRootElement;
+    }
+
+EXPORT_C void CSenFragmentBase::AddNamespacesL()
+    {
+    if (ipParser)
+        {
+        if ( ipParser->IsFeatureEnabled(EReportNamespaceMapping) )
+            {
+            // Add namespaces, if any
+            if ( ipNamespaceArray )
+                {
+                TInt count = ipNamespaceArray->Count();
+                for (TInt i=0; i < count; i++)
+                    {
+                    CSenNamespaceData* pNamespace = (*ipNamespaceArray)[i];
+                    TXmlEngNamespace ns =
+                                AsElementL().LookupNamespaceByUriL(*pNamespace->ipNamespaceUri);
+                    if ( ns.IsNull() )
+                        {
+                        if (pNamespace->ipPrefix == NULL)
+                            {
+                            AsElementL().AddNamespaceDeclarationL(*pNamespace->ipNamespaceUri,
+                                                                  KNullDesC8);
+                            }
+                        else
+                            {
+                            AsElementL().AddNamespaceDeclarationL(*pNamespace->ipNamespaceUri,
+                                                                  *pNamespace->ipPrefix);
+                            }
+                        }
+                    }
+                ipNamespaceArray->ResetAndDestroy();
+                }
+            }
+        }
+    }
+    
+EXPORT_C void CSenFragmentBase::AddAttributesToElementL(TXmlEngElement aElement,
+                                               const RAttributeArray& apAttrs)
+    {
+    TInt count(apAttrs.Count());
+
+    for(TInt i=0; i<count; i++)
+        {
+        TPtrC8 localName = apAttrs[i].Attribute().LocalName().DesC();
+        TPtrC8 value = apAttrs[i].Value().DesC();
+
+        if (apAttrs[i].Attribute().Uri().DesC() == KNullDesC8)
+            {
+            aElement.AddNewAttributeL(localName, value);
+            }
+        else
+            {
+            TPtrC8 namespaceUri = apAttrs[i].Attribute().Uri().DesC();
+            TPtrC8 prefix(KNullDesC8);
+            if ( apAttrs[i].Attribute().Prefix().DesC() != KNullDesC8 )
+                {
+                prefix.Set(apAttrs[i].Attribute().Prefix().DesC());
+                }
+                
+            TXmlEngNamespace ns = aElement.LookupNamespaceByUriL(namespaceUri);
+            if ( ns.NotNull() )
+                {
+                if (ns.Prefix() == KNullDesC8 && prefix == KNullDesC8)
+                    {
+                    aElement.AddNewAttributeWithNsL(localName, value, namespaceUri);
+                    }
+                else if ( ns.Prefix() == prefix )
+                    {
+                    aElement.AddNewAttributeL(localName, value, ns);
+                    }
+                else
+                    {
+                    aElement.AddNewAttributeL(localName, value, namespaceUri, prefix);
+                    }
+                }
+            else
+                {
+                if ( prefix == KNullDesC8 )
+                    {
+                    aElement.AddNamespaceDeclarationL(namespaceUri, KNullDesC8);
+                    aElement.AddNewAttributeWithNsL(localName, value, namespaceUri);
+                    }
+                else
+                    {
+                    aElement.AddNewAttributeL(localName, value, namespaceUri, prefix);
+                    }
+                }
+            }
+        }
+    }
+
+EXPORT_C void CSenFragmentBase::AddAttributesL(const RAttributeArray& apAttrs)
+    {
+    AddAttributesToElementL(AsElementL(), apAttrs);
+    }
+
+EXPORT_C RSenDocument& CSenFragmentBase::AsDocumentL()
+    {
+    return iDocument;
+    }
+
+EXPORT_C TXmlEngElement CSenFragmentBase::AsElementL()
+    {
+    __ASSERT_ALWAYS(iElement.NotNull(), User::Panic(KSenFragmentPanic, EFragmentElementNotInitialized));
+    
+    return iElement;
+    }
+    
+void CSenFragmentBase::RenameL(const TDesC8& aLocalName, const TDesC8& aPrefix, const TDesC8& aNamespace)
+    {
+    WsXmlUtils domUtils;       
+    domUtils.XmlEngRenameElementL(AsElementL(), aLocalName, aNamespace, aPrefix); // Note that in TElement the *prefix* is the last arg(!)
+    }
+
+void CSenFragmentBase::RenameL(const TDesC8& aLocalName, const TDesC8& aNamespace)
+    {
+    WsXmlUtils domUtils;       
+    domUtils.XmlEngRenameElementL(AsElementL(), aLocalName, aNamespace, KNullDesC8); // Note that in TElement the *prefix* is the last arg(!)
+    }
+    
+void CSenFragmentBase::RenameLocalNameL(const TDesC8& aLocalName)
+    {
+    WsXmlUtils domUtils;       
+    domUtils.XmlEngRenameElementL(AsElementL(), aLocalName, KNullDesC8, KNullDesC8); // Note that in TElement the *prefix* is the last arg(!)
+    }
+
+void CSenFragmentBase::RenameNamespaceL(const TDesC8& aNamespace)
+    {
+    WsXmlUtils domUtils;       
+    domUtils.XmlEngRenameElementL(AsElementL(), KNullDesC8, aNamespace, KNullDesC8); // Note that in TElement the *prefix* is the last arg(!)
+    }
+    
+void CSenFragmentBase::RenameNamespaceL(const TDesC8& aPrefix, const TDesC8& aNamespace)
+    {
+    WsXmlUtils domUtils;       
+    domUtils.XmlEngRenameElementL(AsElementL(), KNullDesC8, aNamespace, aPrefix); // Note that in TElement the *prefix* is the last arg(!)
+    }
+    
+void CSenFragmentBase::RenamePrefixL(const TDesC8& aPrefix)
+    {
+    WsXmlUtils domUtils;       
+    domUtils.XmlEngRenameElementL(AsElementL(), KNullDesC8, KNullDesC8, aPrefix); // Note that in TElement the *prefix* is the last arg(!)
+    }
+    
+EXPORT_C TXmlEngElement CSenFragmentBase::ExtractElement()
+    {
+    TXmlEngElement element = iDocument.DocumentElement();
+
+    if ( element.IsSameNode(iElement) )
+        {
+        // Unlink only when element is root element of this document.
+        //
+        // This fragment maybe delegate and element is still part
+        // of other Fragment's DOM Tree.
+        iElement.Unlink();
+        }
+
+    TXmlEngElement retElement = iElement;        
+    TXmlEngElement nullElement;
+    iElement = nullElement;
+    
+    return retElement;
+    }
+
+EXPORT_C void CSenFragmentBase::SetParser(CSenParser& aParser)
+    {
+    ipParser = &aParser;
+    }
+
+EXPORT_C void CSenFragmentBase::OnDelegateParsingL(CSenFragmentBase& aDelegate)
+    {
+    // Delegate parsing to a new Fragment, until we encounter 
+    // the end of an element with the given qualified name
+    aDelegate.SetOwner(*this);
+    aDelegate.ipParser = ipParser;
+    aDelegate.StartSavingContent();
+    SetContentHandler(aDelegate);
+    }
+
+EXPORT_C void CSenFragmentBase::OnDelegateParsingL(const RTagInfo& aElement, 
+                                                   const RAttributeArray& aAttributes, 
+                                                   TInt /*aErrorCode*/)
+    {
+    // Delegate parsing to a new Fragment, until we encounter the end of an
+    // element with the given qualified name
+    const TPtrC8 saxLocalName   = aElement.LocalName().DesC();
+    const TPtrC8 saxNsUri       = aElement.Uri().DesC();
+    const TPtrC8 saxPrefix      = aElement.Prefix().DesC();
+
+    TXmlEngElement element = AsElementL();
+    RSenDocument document = AsDocumentL();
+
+
+    __ASSERT_ALWAYS(
+        ipDelegate == NULL,
+        User::Panic(KSenFragmentPanic, EDelegatedFragmentAlreadySet)
+        );
+    ipDelegate = CSenFragmentBase::NewL(saxNsUri, 
+                                        saxLocalName, 
+                                        saxPrefix, 
+                                        aAttributes, 
+                                        element, 
+                                        document);
+
+    OnDelegateParsingL(*ipDelegate);
+    }
+
+EXPORT_C void CSenFragmentBase::StartSavingContent()
+    {
+    iState = KSenStateSave;
+    }
+
+EXPORT_C void CSenFragmentBase::SetOwner(CSenFragmentBase& aFragment)
+    {
+    ipOwner = &aFragment;
+    }
+
+EXPORT_C void CSenFragmentBase::OnResumeParsingFromL(const RTagInfo& aElement, TInt aErrorCode)
+    {
+    SetContentHandler(*this);
+    
+    // Destroy delegate
+    if ( ipDelegate )
+        {
+        HBufC8* pAsXml = ipDelegate->AsXmlL();
+        CleanupStack::PushL(pAsXml);
+                
+        delete ipDelegate; // free memory
+        ipDelegate = NULL;
+        
+        if ( !ipContentBuf )
+            {
+            ipContentBuf = CBufFlat::NewL(KFlatBufSize);
+            ipContentWriteStream = new (ELeave) RBufWriteStream;
+            ipContentWriteStream->Open(*ipContentBuf);
+            }
+        ipContentWriteStream->WriteL(*pAsXml);
+        
+        CleanupStack::PopAndDestroy(pAsXml);
+        }
+    
+    TInt currentState = KSenStateNotSet; // == -1
+    if ( iElement.NotNull() )
+        {
+        const TPtrC8 saxLocalName   = aElement.LocalName().DesC();
+        const TPtrC8 saxNsUri       = aElement.Uri().DesC();
+        TPtrC8 localName            = iElement.Name();
+        TPtrC8 nsUri                = iElement.NamespaceUri();
+    
+        if(localName == saxLocalName  && nsUri == saxNsUri)
+            {
+            currentState = iState;
+            // Before calling EndElementL, which may execute
+            // unpredictable amount of code in subclasses, the
+            // the state must be set to "ignore"
+            iState = KSenStateResume;
+            }
+        }
+    
+    OnEndElementL(aElement, aErrorCode);
+    // now check if current state was to be preserved
+    if(currentState!=KSenStateNotSet) // IOP
+        {
+        // restore the state preserved prior to
+        // "set ignore for endelement" -case
+        iState = currentState;
+        }
+    }
+
+EXPORT_C void CSenFragmentBase::OnStartElementL(const RTagInfo& aElement, 
+                                                const RAttributeArray& aAttributes, 
+                                                TInt aErrorCode) 
+    {
+    const TPtrC8 saxLocalName   = aElement.LocalName().DesC();
+    const TPtrC8 saxNsUri       = aElement.Uri().DesC();
+    const TPtrC8 saxPrefix      = aElement.Prefix().DesC();
+    
+    if ( iElement.IsNull() )
+        {
+        if ( saxNsUri == KNullDesC8 && saxPrefix == KNullDesC8 )
+            {
+            iDocument.CreateDocumentElementL(saxLocalName);
+            }
+        else
+            {
+            if ( saxPrefix == KNullDesC8 )
+                {
+                iDocument.CreateDocumentElementL(saxLocalName,
+                                                 saxNsUri,
+                                                 KNullDesC8);
+                }
+            else
+                {
+                iDocument.CreateDocumentElementL(saxLocalName,
+                                                 saxNsUri,
+                                                 saxPrefix);
+                }
+            }
+        iElement = iDocument.DocumentElement();        
+        }    
+    
+    TXmlEngElement element = AsElementL();
+    
+    TPtrC8 localName =  element.Name();
+    TPtrC8 nsUri(KNullDesC8);
+    if (element.NamespaceUri() != KNullDesC8)
+        {
+        nsUri.Set(element.NamespaceUri());
+        }
+    
+    if(iState == KSenStateIgnore)
+        {
+        if(localName == saxLocalName && nsUri == saxNsUri) 
+            {
+            iState = KSenStateSave;
+            AddNamespacesL();
+            AddAttributesL(aAttributes);
+            }
+        }
+    else if((iState & KSenStateSave) == KSenStateSave)
+        {
+        if(localName == saxLocalName && nsUri == saxNsUri)
+            {
+            // start a new BaseFragment otherwise we loose
+            // track of nested elements with the same name
+            OnDelegateParsingL(aElement, aAttributes, aErrorCode);
+            }
+        else
+            {
+            OnWriteStartElementL(aElement, aAttributes);
+            }
+        }
+    }
+
+EXPORT_C void CSenFragmentBase::OnEndElementL(const RTagInfo& aElement, TInt aErrorCode)
+    {
+    const TPtrC8 saxLocalName   = aElement.LocalName().DesC();
+    const TPtrC8 saxNsUri       = aElement.Uri().DesC();
+    const TPtrC8 saxPrefix      = aElement.Prefix().DesC();
+
+    TXmlEngElement element = AsElementL();
+
+    TPtrC8 localName =  element.Name();
+    TPtrC8 nsUri(KNullDesC8);
+    if (element.NamespaceUri() != KNullDesC8)
+        {
+        nsUri.Set(element.NamespaceUri());
+        }
+
+    if(localName == saxLocalName && nsUri == saxNsUri)
+        {
+        if(iState != KSenStateResume && ipOwner)
+            {
+            if ( ipContentBuf )
+                {
+                SetContentL(ipContentBuf->Ptr(0));
+            
+                delete ipContentBuf;
+                ipContentBuf = NULL;
+                delete ipContentWriteStream;
+                ipContentWriteStream = NULL;
+                }
+
+            ipOwner->OnResumeParsingFromL(aElement, aErrorCode);
+            return; // This is mandatory, since ResumeParsingFromL 
+                    // de-allocates delegate fragment!
+            }
+        iState = KSenStateIgnore;
+        }
+    if((iState & KSenStateSave) == KSenStateSave)
+        {
+        OnWriteEndElementL(aElement);
+        }
+    }
+
+EXPORT_C void CSenFragmentBase::OnContentL(const TDesC8& aBytes, TInt /*aErrorCode*/)
+    {
+    if((iState & KSenStateSave) == KSenStateSave)
+        {
+        if ( !ipContentBuf )
+            {
+            ipContentBuf = CBufFlat::NewL(KFlatBufSize);
+            ipContentWriteStream = new (ELeave) RBufWriteStream;
+            ipContentWriteStream->Open( *ipContentBuf );
+            }   
+        HBufC8* reEncoded = NULL;
+        TBool contentIncludesEncodedChars = EncodeXmlEscapesL( aBytes, reEncoded);
+        if ( contentIncludesEncodedChars )
+            {
+            CleanupStack::PushL( reEncoded );
+            ipContentWriteStream->WriteL( *reEncoded );
+            CleanupStack::PopAndDestroy( reEncoded  );
+            }
+        else
+            {
+            ipContentWriteStream->WriteL( aBytes );
+            }
+        }
+    }
+    
+EXPORT_C void CSenFragmentBase::OnStartDocumentL( const RDocumentParameters& /*aDocParam*/,
+                                                  TInt /*aErrorCode*/ )
+    {
+    if ( !ipContentBuf )
+        {
+        ipContentBuf = CBufFlat::NewL(KFlatBufSize);
+        ipContentWriteStream = new (ELeave) RBufWriteStream;
+        ipContentWriteStream->Open(*ipContentBuf);
+        }
+    }
+
+EXPORT_C void CSenFragmentBase::OnEndDocumentL(TInt /*aErrorCode*/)
+    {
+    if ( ipNamespaceArray)
+        {
+        ipNamespaceArray->ResetAndDestroy();
+        delete ipNamespaceArray;
+        ipNamespaceArray = NULL;
+        }
+    
+    if ( ipContentBuf )
+        {
+        if ( ipContentBuf->Ptr(0).Length() > 0 )
+            {
+            SetContentL(ipContentBuf->Ptr(0));
+            }
+
+        delete ipContentBuf;
+        ipContentBuf = NULL;
+        delete ipContentWriteStream;
+        ipContentWriteStream = NULL;
+        }
+    }
+
+EXPORT_C void CSenFragmentBase::OnStartPrefixMappingL(
+                                    const RString& aPrefix,
+                                    const RString& aUri,
+                                    TInt /*aErrorCode*/)
+    {
+    if ( !ipNamespaceArray )
+        {
+        ipNamespaceArray = new (ELeave) RPointerArray<CSenNamespaceData>;
+        }
+
+    CSenNamespaceData* pNamespaceData = new (ELeave) CSenNamespaceData;
+    CleanupStack::PushL(pNamespaceData);
+    pNamespaceData->ipNamespaceUri  = aUri.DesC().AllocL();
+    if (aPrefix.DesC() != KNullDesC8)
+        {
+        pNamespaceData->ipPrefix    = aPrefix.DesC().AllocL();
+        }
+    User::LeaveIfError(ipNamespaceArray->Append(pNamespaceData));
+    CleanupStack::Pop(pNamespaceData);
+    }
+
+EXPORT_C void CSenFragmentBase::OnEndPrefixMappingL(
+                                    const RString& /*aPrefix*/,
+                                    TInt /*aErrorCode*/)
+    {
+    }
+
+EXPORT_C void CSenFragmentBase::OnIgnorableWhiteSpaceL(
+                                    const TDesC8& /*aBytes*/,
+                                    TInt /*aErrorCode*/)
+    {
+    }
+
+EXPORT_C void CSenFragmentBase::OnSkippedEntityL(
+                                    const RString& /*aName*/,
+                                    TInt /*aErrorCode*/)
+    {
+    }
+
+EXPORT_C void CSenFragmentBase::OnProcessingInstructionL(
+                                    const TDesC8& /*aTarget*/,
+                                    const TDesC8& /*aData*/,
+                                    TInt /*aErrorCode*/)
+    {
+    }
+
+EXPORT_C void CSenFragmentBase::OnError(TInt /*aErrorCode*/)
+    {
+    }
+
+EXPORT_C TAny* CSenFragmentBase::GetExtendedInterface(const TInt32 /*aUid*/)
+    {
+    return NULL;
+    }    
+
+
+EXPORT_C void CSenFragmentBase::ResetContentL()
+    {
+    TXmlEngElement element = AsElementL();
+    element.RemoveChildren();
+    }
+
+EXPORT_C TPtrC8 CSenFragmentBase::ContentL()
+    {
+    TXmlEngElement element = AsElementL();
+    return element.Text();
+    }
+
+
+EXPORT_C HBufC* CSenFragmentBase::AsXmlUnicodeL()
+    {
+    HBufC8* pAsXml = AsXmlL();
+    CleanupStack::PushL(pAsXml);
+    HBufC16* pBuf = HBufC16::NewL(2 * pAsXml->Length());
+    CleanupStack::PushL(pBuf);
+    TPtr16 des = pBuf->Des();
+    TInt ret = CnvUtfConverter::ConvertToUnicodeFromUtf8(des, *pAsXml);
+    User::LeaveIfError(ret);
+    CleanupStack::Pop(pBuf);
+    CleanupStack::PopAndDestroy(pAsXml);
+    return pBuf;
+    }
+
+EXPORT_C HBufC8* CSenFragmentBase::AsXmlL()
+    {
+    TXmlEngElement element = AsElementL();
+    
+    TUint optionFlags = 0;
+    // Omit following declarations from the beginning of XML Document:
+    // <?xml version=\"1.0\...
+    //   encoding="..."
+    //   standalone="..."
+    // ?>
+    optionFlags = optionFlags | TXmlEngSerializationOptions::KOptionOmitXMLDeclaration;
+    
+    // Allow encoding declaration (if KOptionOmitXMLDeclaration is _not_ set)
+    //optionFlags = optionFlags | TSerializationOptions::KOptionEncoding;
+    
+    // Allow standalone declaration (if KOptionOmitXMLDeclaration is _not_ set)
+    //optionFlags = optionFlags | TSerializationOptions::KOptionStandalone;
+
+    TXmlEngSerializationOptions options(optionFlags);
+
+    RBuf8 asXml;
+    iDocument.SaveL(asXml, element, options);
+    CleanupClosePushL(asXml);
+    HBufC8* pAsXml = asXml.AllocL();
+    CleanupStack::PopAndDestroy(&asXml);
+
+    return pAsXml;
+    }
+    
+
+EXPORT_C void CSenFragmentBase::WriteAsXMLToL(RWriteStream& aWs)
+    {
+    HBufC8* pAsXml = AsXmlL();
+    CleanupStack::PushL(pAsXml);
+    aWs.WriteL(*pAsXml);
+    CleanupStack::PopAndDestroy(pAsXml);
+    }
+
+EXPORT_C TPtrC8 CSenFragmentBase::ContentOf(const TDesC8& aLocalName)
+    {
+    TInt err( KErrNone );
+    RXmlEngNodeList<TXmlEngElement> list;
+    TRAP(   
+        err, 
+        TXmlEngElement element = AsElementL(); 
+        element.GetElementsByTagNameL(list, aLocalName);
+        )
+    if ( !err && list.Count() > 0 )
+        {
+        TXmlEngElement firstElement = list.Next();
+        return firstElement.Text();
+        }
+    return KNullDesC8();
+    }
+
+EXPORT_C TXmlEngElement CSenFragmentBase::SetContentOfL(const TDesC8& aLocalName,
+                                                      const TDesC8& aContent)
+    {
+    TXmlEngElement element = AsElementL();
+    RXmlEngNodeList<TXmlEngElement> list;
+    CleanupClosePushL(list);
+    
+    element.GetElementsByTagNameL(list, aLocalName);
+        
+    if ( list.Count() > 0 )
+        {
+        TXmlEngElement firstElement = list.Next();
+        firstElement.SetTextNoEncL(aContent);
+        return firstElement;
+        }
+    CleanupStack::PopAndDestroy(&list);
+
+    TXmlEngElement newElement = element.AddNewElementL(aLocalName);
+    newElement.SetTextNoEncL(aContent);
+    return newElement;
+    }
+
+EXPORT_C void CSenFragmentBase::OnWriteStartElementL(const RTagInfo& aElement,  
+                                                     const RAttributeArray& aAttributes)
+    {
+    const TPtrC8 saxLocalName   = aElement.LocalName().DesC();
+    const TPtrC8 saxNsUri       = aElement.Uri().DesC();
+    const TPtrC8 saxPrefix      = aElement.Prefix().DesC();
+    
+    if ( !ipContentBuf )
+        {
+        ipContentBuf = CBufFlat::NewL(KFlatBufSize);
+        ipContentWriteStream = new (ELeave) RBufWriteStream;
+        ipContentWriteStream->Open(*ipContentBuf);
+        }
+    
+    ipContentWriteStream->WriteL(KSenLessThan);
+    if (saxPrefix != KNullDesC8)
+        {
+        ipContentWriteStream->WriteL(saxPrefix);
+        ipContentWriteStream->WriteL(KSenColon);
+        }
+    ipContentWriteStream->WriteL(saxLocalName);
+
+    TInt startPoint(0);
+    if ( !ipParser->IsFeatureEnabled(EReportNamespaceMapping) )
+        {
+        if ( !ipNamespaceArray)
+            {
+            ipNamespaceArray = new (ELeave) RPointerArray<CSenNamespaceData>;
+            }
+
+        // Collect namespace declaration from this element (if it's not
+        // previously defined)
+        TBool found(EFalse);
+        if ( saxNsUri != KNullDesC8 )
+            {
+            // Check if element of this document has already handled
+            // namespace definition.
+            TXmlEngNamespace ns = AsElementL().LookupNamespaceByUriL(saxNsUri);
+            if ( ns.NotNull() )
+                {
+                found = ETrue;
+                }
+            else
+                {
+                // Check if internal namespace array has already handled
+                // namespace defintion. <= Means that one of the parent
+                // elements (in flat content) has already namespace
+                // definition we are dealing with.
+                TInt jcount = ipNamespaceArray->Count();
+                for (TInt j=0; j < jcount; j++)
+                    {
+                    CSenNamespaceData* pNamespace = (*ipNamespaceArray)[j];
+                    if ( pNamespace->ipPrefix && *(pNamespace->ipPrefix) == saxPrefix )
+                        {
+                        if ( *pNamespace->ipNamespaceUri == saxNsUri )
+                            {
+                            found = ETrue;
+                            break;
+                            }
+                        }
+                    }
+                }
+            }
+
+        startPoint = ipNamespaceArray->Count();
+        if ( !found )
+            {
+            CSenNamespaceData* pNamespaceData = new (ELeave) CSenNamespaceData;
+            CleanupStack::PushL(pNamespaceData);
+            TInt retVal = ipNamespaceArray->Append(pNamespaceData);
+            User::LeaveIfError(retVal);
+            CleanupStack::Pop(pNamespaceData);
+            if (retVal == KErrNone )
+                {
+                pNamespaceData->ipNamespaceUri  = saxNsUri.AllocL();
+                pNamespaceData->ipPrefix        = saxPrefix.AllocL();
+                pNamespaceData->ipLocalName     = saxLocalName.AllocL();
+                }
+            }
+        
+        // Collect new (not previously defined) namespaces from attributes
+        TInt attCount(aAttributes.Count());
+        for ( TInt i = 0; i < attCount; i++)
+            {
+            found = EFalse;
+            TPtrC8 nsUri = aAttributes[i].Attribute().Uri().DesC();
+            if ( nsUri != KNullDesC8 )
+                {
+                TPtrC8 nsPrefix = aAttributes[i].Attribute().Prefix().DesC();
+                TBool found(EFalse);
+                // Check if element of this document has already handled
+                // namespace definition.
+                TXmlEngNamespace ns = AsElementL().LookupNamespaceByUriL(nsUri);
+                if ( ns.NotNull() )
+                    {
+                    found = ETrue;
+                    }
+                else
+                    {
+                    // Check if internal namespace array has already handled
+                    // namespace defintion. <= Means that one of the parent
+                    // elements (in flat content) has already namespace
+                    // definition we are dealing with.
+                    TInt jcount = ipNamespaceArray->Count();
+                    for (TInt j=0; j < jcount; j++)
+                        {
+                        CSenNamespaceData* pNamespace = (*ipNamespaceArray)[j];
+                        if ( pNamespace->ipPrefix && *(pNamespace->ipPrefix) == nsPrefix )
+                            {
+                            if ( *pNamespace->ipNamespaceUri == nsUri )
+                                {
+                                found = ETrue;
+                                break;
+                                }
+                            }
+                        }
+                    }
+                    
+                // If namespace was not found
+                // namespace will be added to internal array 
+                if ( !found )
+                    {
+                    CSenNamespaceData* pNamespaceData
+                                            = new (ELeave) CSenNamespaceData;
+                    CleanupStack::PushL(pNamespaceData);
+                    TInt retVal = ipNamespaceArray->Append(pNamespaceData);
+                    User::LeaveIfError(retVal);
+                    CleanupStack::Pop(pNamespaceData);
+                    if (retVal == KErrNone )
+                        {
+                        pNamespaceData->ipNamespaceUri  = nsUri.AllocL();
+                        pNamespaceData->ipPrefix        = nsPrefix.AllocL();
+                        if ( startPoint == ipNamespaceArray->Count() )
+                            {
+                            pNamespaceData->ipLocalName = saxLocalName.AllocL();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        
+    // Write namespaces, if any
+    if ( ipNamespaceArray )
+        {
+        TInt count = ipNamespaceArray->Count();
+        for (TInt i=startPoint; i < count; i++)
+            {
+            CSenNamespaceData* pNamespace = (*ipNamespaceArray)[i];
+            ipContentWriteStream->WriteL(KSenSpace);
+            ipContentWriteStream->WriteL(KSenXmlns);
+            if ( pNamespace->ipPrefix && *(pNamespace->ipPrefix) != KNullDesC8 )
+                {
+                ipContentWriteStream->WriteL(KSenColon);
+                ipContentWriteStream->WriteL(*pNamespace->ipPrefix);
+                }
+            ipContentWriteStream->WriteL(KSenEqualsDblQuot);
+            ipContentWriteStream->WriteL(*pNamespace->ipNamespaceUri);
+            ipContentWriteStream->WriteL(KSenDblQuot);
+            }
+            
+        if ( ipParser->IsFeatureEnabled(EReportNamespaceMapping) )
+            {
+            ipNamespaceArray->ResetAndDestroy();
+            }
+        }
+
+    // Write attributes, if any
+    TInt attCount(aAttributes.Count());
+    for (TInt i = 0; i < attCount; i++)
+        {
+        TPtrC8 prefix   = aAttributes[i].Attribute().Prefix().DesC();
+        TPtrC8 lAttName = aAttributes[i].Attribute().LocalName().DesC();
+        TPtrC8 attValue = aAttributes[i].Value().DesC();
+
+        ipContentWriteStream->WriteL(KSenSpace);
+        if (prefix != KNullDesC8)
+            {
+            ipContentWriteStream->WriteL(prefix);
+            ipContentWriteStream->WriteL(KSenColon);
+            }
+        ipContentWriteStream->WriteL(lAttName);
+
+        ipContentWriteStream->WriteL(KSenEqualsDblQuot);
+        ipContentWriteStream->WriteL(attValue);
+        ipContentWriteStream->WriteL(KSenDblQuot);
+        }
+
+    ipContentWriteStream->WriteL(KSenGreaterThan);
+    }
+
+EXPORT_C void CSenFragmentBase::OnWriteEndElementL(const RTagInfo& aElement)
+    {
+    const TPtrC8 saxLocalName = aElement.LocalName().DesC();
+    const TPtrC8 saxNsUri = aElement.Uri().DesC();
+    const TPtrC8 saxPrefix = aElement.Prefix().DesC();
+
+    if ( !ipContentBuf )
+        {
+        ipContentBuf = CBufFlat::NewL(KFlatBufSize);
+        ipContentWriteStream = new (ELeave) RBufWriteStream;
+        ipContentWriteStream->Open(*ipContentBuf);
+        }
+    
+    if ( ipNamespaceArray && !ipParser->IsFeatureEnabled(EReportNamespaceMapping) )
+        {
+        TInt foundIndex(KErrNotFound);
+        TInt jcount = ipNamespaceArray->Count();
+        for (TInt j=jcount-1; j >= 0 ; j--)
+            {
+            CSenNamespaceData* pNamespace = (*ipNamespaceArray)[j];
+            if ( pNamespace->ipLocalName != NULL )
+                {
+                if ( *pNamespace->ipLocalName == saxLocalName )
+                    {
+                    foundIndex = j;
+                    }
+                break;
+                }
+            }
+        if ( foundIndex != KErrNotFound )
+            {
+            for (TInt j=foundIndex; j < jcount; j++)
+                {
+                delete (*ipNamespaceArray)[foundIndex];
+                ipNamespaceArray->Remove(foundIndex);
+                }
+            }
+        }
+
+    // Check if EndTag should be written or not.
+    // There is no need to write EndTag if
+    // previous tag is StartTag for this element
+    // and there is no content for the element.
+    TBool writeEndTag = ETrue;        
+    TInt size = ipContentBuf->Size();
+    if ( size > 1 )
+        {
+        // Check if first character before this possible
+        // EndTag is '>'
+        if ( ipContentBuf->Ptr(size-1) == KSenGreaterThan )
+            {
+            // This element does not have content
+            // There is possibility that EndTag is not needed
+            TInt colon = KErrNotFound;
+            TInt space = KErrNotFound;
+            TBool insideDblQuot = EFalse;
+            
+            // Search backwards first '<'.
+            // Search also first ':' and space which
+            // are right after '<' (if those characters
+            // can be found).
+            // 
+            // => Following situations are handled:
+            // 1) <prefix:localname attr...>
+            // 2) <prefix:localname>
+            // 3) <localname>
+            TInt i=size-2;
+            TPtrC8 currentCharacter(KNullDesC8);
+            for (; i > 0; i--)
+                {
+                currentCharacter.Set(ipContentBuf->Ptr(i).Left(1));
+                
+                if ( currentCharacter == KSenDblQuot ) 
+                    {
+                    if ( insideDblQuot )
+                        {
+                        insideDblQuot = EFalse;
+                        }
+                    else
+                        {
+                        insideDblQuot = ETrue;
+                        }
+                    }
+                else if ( !insideDblQuot )
+                    {
+                    if ( currentCharacter == KSenSlash ) 
+                        {
+                        i = KErrNotFound;
+                        break;
+                        }
+                    else if ( currentCharacter == KSenLessThan ) 
+                        {
+                        break;
+                        }
+                    else if ( currentCharacter == KSenColon )
+                        {
+                        colon = i;
+                        }
+                    else if ( currentCharacter == KSenSpace )
+                        {
+                        colon = KErrNotFound;
+                        space = i;
+                        }
+                    }
+                }
+
+            // Now that we know place of '<' character and
+            // also places of ':' and space characters (if
+            // those two characters exist),
+            // we can find out possible prefix and localname.
+            if ( i > 0 )
+                {
+                TPtrC8 localNamePtr(KNullDesC8);
+                TPtrC8 prefixPtr(KNullDesC8);
+                if ( colon != KErrNotFound )
+                    {
+                    // Both Prefix and LocalName can be found.
+                    if ( space != KErrNotFound )
+                        {
+                        localNamePtr.Set(ipContentBuf->Ptr(colon+1).MidTPtr(0, space-colon-1));
+                        }
+                    else
+                        {
+                        localNamePtr.Set(ipContentBuf->Ptr(colon+1).MidTPtr(0, size-colon-2));
+                        }
+                    prefixPtr.Set(ipContentBuf->Ptr(i+1).MidTPtr(0, colon-i-1));
+                    }
+                else
+                    {
+                    // Only LocalName can be found.
+                    if ( space != KErrNotFound )
+                        {
+                        localNamePtr.Set(ipContentBuf->Ptr(i+1).MidTPtr(0, space-i-1));
+                        }
+                    else
+                        {
+                        localNamePtr.Set(ipContentBuf->Ptr(i+1).MidTPtr(0, size-i-2));
+                        }
+                    }
+                
+                // Do comparison for localname and prefix of
+                // this EndTag
+                if ( ( localNamePtr == saxLocalName ) && 
+                     ( prefixPtr == saxPrefix ) )
+                    {
+                    // LocalName and prefix matched. So
+                    // the EndTag should not be written.
+                    // => Now the last character '>' of StartTag can
+                    //    be replaced with characters '\' and '>'
+                    //    which means that element is closed without
+                    //    separate EndTag.
+                    ipContentBuf->Delete((ipContentBuf->Size()-1),1);
+                    ipContentBuf->InsertL((ipContentBuf->Size()), KSenSlash);
+                    ipContentWriteStream->WriteL(KSenGreaterThan);
+                    writeEndTag = EFalse;
+                    }
+                }
+            }
+        }
+    
+    if ( writeEndTag )
+        {
+        ipContentWriteStream->WriteL(KSenLessThanSlash());
+        
+        if ( saxPrefix.Length() > 0)
+            {
+            HBufC8*  pQName = HBufC8::NewLC( saxPrefix.Length()
+                                             +KSenColon().Length()
+                                             +saxLocalName.Length());
+            TPtr8 qname = pQName->Des();
+            qname.Append(saxPrefix);
+            qname.Append(KSenColon);
+            qname.Append(saxLocalName);
+            ipContentWriteStream->WriteL(qname);
+            CleanupStack::PopAndDestroy(pQName);
+            }
+        else
+            {
+            ipContentWriteStream->WriteL(saxLocalName);
+            }
+       
+        ipContentWriteStream->WriteL(KSenGreaterThan());
+        }    
+    }
+
+EXPORT_C TXmlEngNamespace CSenFragmentBase::Namespace(const TDesC8& aPrefix)
+    {
+    TXmlEngNamespace ns;
+    if (aPrefix.Length() == 0) return ns;
+    TRAP_IGNORE
+        (    
+        TXmlEngElement element = AsElementL();
+        ns = element.LookupNamespaceByPrefixL(aPrefix);
+        )
+    return ns;
+    }
+
+/*EXPORT_C void CSenFragmentBase::DetachL()
+    {
+    //First add all the namespaces referred to in the content.
+    if (iNamespaces.Count() > 0)
+        {
+        TInt count(iNamespaces.Count());
+        for (TInt i=0; i<count; i++)
+            {
+            CSenNamespace* pNamespace = (CSenNamespace*) iNamespaces[i];
+            ipElement->AddNamespaceL(*pNamespace, EFalse);
+            //TRAPD(err, ipElement->AddNamespaceL(*pNamespace, EFalse));
+            //if (err) ;
+            }
+        }
+    //Detach the element from its parent.
+    ipElement->DetachL();
+    }*/
+
+EXPORT_C TPtrC8 CSenFragmentBase::LocalName() const
+    {
+    __ASSERT_ALWAYS(iElement.NotNull(), User::Panic(KSenFragmentPanic, EFragmentElementNotInitialized));
+        
+    return iElement.Name();
+    }
+
+EXPORT_C TPtrC8 CSenFragmentBase::NsUri() const
+    {
+    __ASSERT_ALWAYS(iElement.NotNull(), User::Panic(KSenFragmentPanic, EFragmentElementNotInitialized));
+
+    return iElement.NamespaceUri();
+    }
+
+EXPORT_C TPtrC8 CSenFragmentBase::NsPrefix() const
+    {
+    __ASSERT_ALWAYS(iElement.NotNull(), User::Panic(KSenFragmentPanic, EFragmentElementNotInitialized));
+
+    return iElement.Prefix();
+    }
+    
+EXPORT_C TBool CSenFragmentBase::ConsistsOfL(TXmlEngElement& aElement, TXmlEngElement& aCandidate)
+    {
+    // First check the names and namespaces
+    TPtrC8 elementLocalName         = aElement.Name();
+    TPtrC8 candidateLocalName       = aCandidate.Name();
+    // Check localnames (element should always have localname
+    //                  <=> localname can't be Null).
+    if ( elementLocalName != candidateLocalName )
+        {
+        return EFalse;
+        }
+        
+    TPtrC8 elementNamespaceUri      = aElement.NamespaceUri();
+    TPtrC8 candidateNamespaceUri    = aCandidate.NamespaceUri();
+    // Check namespaceUris (element does not always have namespaceUri
+    //                      <=> namespaceUri can be Null).
+    if ( elementNamespaceUri != KNullDesC8 && candidateNamespaceUri != KNullDesC8 )
+        {
+        if ( elementNamespaceUri != candidateNamespaceUri )
+            {
+            return EFalse;
+            }
+        }
+    else
+        {
+        if ( elementNamespaceUri != KNullDesC8 || candidateNamespaceUri != KNullDesC8 )
+            {
+            return EFalse;
+            }
+        }
+        
+    TPtrC8 elementPrefix            = aElement.Prefix();
+    TPtrC8 candidatePrefix          = aCandidate.Prefix();
+    // Check prefixes (element does not always have prefix
+    //                 <=> prefix can be Null).
+    if ( elementPrefix != KNullDesC8 && candidatePrefix != KNullDesC8 )
+        {
+        if ( elementPrefix != candidatePrefix )
+            {
+            return EFalse;
+            }
+        }
+    else
+        {
+        if ( elementPrefix != KNullDesC8 || candidatePrefix != KNullDesC8 )
+            {
+            return EFalse;
+            }
+        }
+
+    RBuf8 candidateContent;
+    aCandidate.WholeTextContentsCopyL(candidateContent);
+    CleanupClosePushL(candidateContent);
+    RBuf8 content;
+    aElement.WholeTextContentsCopyL(content);
+    CleanupClosePushL(content);
+    if ( candidateContent != content )
+        {
+        CleanupStack::PopAndDestroy(&content);
+        CleanupStack::PopAndDestroy(&candidateContent);
+        return EFalse;  // Content doesn't match => no match
+        }
+    CleanupStack::PopAndDestroy(&content);
+    CleanupStack::PopAndDestroy(&candidateContent);
+    
+    // Then handle the children
+    RXmlEngNodeList<TXmlEngElement> candidateChildren;
+    CleanupClosePushL(candidateChildren);
+    aCandidate.GetChildElements(candidateChildren);
+
+    RXmlEngNodeList<TXmlEngElement> children;
+    CleanupClosePushL(children);
+    aElement.GetChildElements(children);
+    
+    // Element should have at least as many child elements
+    // as candidateElement has.
+    TInt childrenCount = children.Count();
+    TInt candidateChildrenCount = candidateChildren.Count();
+    if ( childrenCount < candidateChildrenCount )
+        {
+        CleanupStack::PopAndDestroy(&children);
+        CleanupStack::PopAndDestroy(&candidateChildren);
+        return EFalse;
+        }
+    
+    // Every child element of candidate should be found
+    // from element.
+    while ( candidateChildren.HasNext() )
+        {
+        TXmlEngElement candidateMatchChild = candidateChildren.Next();
+        RXmlEngNodeList<TXmlEngElement> matchChilds;
+        CleanupClosePushL(matchChilds);
+
+        aElement.GetElementsByTagNameL(matchChilds,
+                                       candidateMatchChild.Name(),
+                                       candidateMatchChild.NamespaceUri());
+        if ( !matchChilds.HasNext() )
+            {
+            CleanupStack::PopAndDestroy(&matchChilds);
+            CleanupStack::PopAndDestroy(&children);
+            CleanupStack::PopAndDestroy(&candidateChildren);
+            return EFalse;
+            }
+        else
+            {
+            TBool found = EFalse;
+            while ( matchChilds.HasNext() )
+                {
+                TXmlEngElement matchChild = matchChilds.Next();
+                found = ConsistsOfL(matchChild, candidateMatchChild);
+                if ( found ) break;
+                }
+            if ( !found )
+                {
+                CleanupStack::PopAndDestroy(&matchChilds);
+                CleanupStack::PopAndDestroy(&children);
+                CleanupStack::PopAndDestroy(&candidateChildren);
+                return EFalse;
+                }
+            }
+            
+        CleanupStack::PopAndDestroy(&matchChilds);
+        }
+        
+    CleanupStack::PopAndDestroy(&children);
+    CleanupStack::PopAndDestroy(&candidateChildren);
+    return ETrue;    
+    }
+
+EXPORT_C TBool CSenFragmentBase::ConsistsOfL(CSenFragmentBase& aCandidate)
+    {
+    TXmlEngElement element          = AsElementL();
+    TXmlEngElement candidateElement = aCandidate.AsElementL();
+    return ConsistsOfL(element, candidateElement);
+    }
+
+EXPORT_C void CSenFragmentBase::SetContentHandler(
+                                            CSenFragmentBase& aContentHandler)
+    {
+    ipParser->SetContentHandler(aContentHandler);
+    }
+
+EXPORT_C void CSenFragmentBase::SetContentL(const TDesC8& aContent)
+    {
+    TXmlEngElement element = AsElementL();
+    element.SetTextNoEncL(aContent);
+    }
+
+EXPORT_C void CSenFragmentBase::AddContentL(const TDesC8& aContent)
+    {
+    TPtrC8 content = ContentL();
+    TXmlEngElement element = AsElementL();
+    if ( content.Length() > 0 )
+        {
+        HBufC8* pContent = HBufC8::NewLC( content.Length() + aContent.Length() );
+        TPtr8 ptrContent = pContent->Des();
+        ptrContent.Append(content);
+        ptrContent.Append(aContent);
+        element.SetTextNoEncL(*pContent);
+        CleanupStack::PopAndDestroy(pContent);
+        }
+    else
+        {
+        element.SetTextNoEncL(aContent);
+        }
+    }
+    
+EXPORT_C void CSenFragmentBase::SetDocument(RSenDocument& aDocument)
+    {
+    iDocument.Close();
+    iDocument = aDocument.Copy();
+    }
+
+CSenNamespaceData::~CSenNamespaceData()
+    {
+    delete ipNamespaceUri;
+    delete ipPrefix;
+    delete ipLocalName;
+    }
+
+// End of File
+
+