MCL/sf/mw/appinstall: comparison iaupdate/IAD/engine/controller/src/iaupdatexmlsubparser.cpp

equal deleted inserted replaced

--1:000000000000
+:ba25891c3a9e
+/*
+* Copyright (c) 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:   ?Description
+*
+*/
+#include <xml/documentparameters.h>
+#include <xml/taginfo.h>
+#include <xml/attribute.h>
+#include "iaupdatexmlsubparser.h"
+EXPORT_C CIAUpdateXmlSubParser::CIAUpdateXmlSubParser()
+: CBase(),
+iAcceptData( ETrue )
+{
+}
+EXPORT_C void CIAUpdateXmlSubParser::ConstructL( const TDesC8& aElementLocalName )
+{
+iElementLocalName = aElementLocalName.AllocL();
+}
+EXPORT_C CIAUpdateXmlSubParser::~CIAUpdateXmlSubParser()
+{
+// Notice, this array also owns the iCurrentSubParser.
+// So, do not delete it twice. ResetAndDestroy here is enough.
+iSubParsers.ResetAndDestroy();
+delete iElementLocalName;
+}
+EXPORT_C void CIAUpdateXmlSubParser::OnStartDocumentL(
+const Xml::RDocumentParameters& aDocParam,
+TInt aErrorCode )
+{
+iAcceptData = ETrue;
+iUnknownElementCounter = 0;
+iIsElementStarted = EFalse;
+iIsElementEnded = EFalse;
+for ( TInt i = 0; i < iSubParsers.Count(); ++i )
+{
+iSubParsers[ i ]->OnStartDocumentL( aDocParam, aErrorCode );
+}
+}
+EXPORT_C void CIAUpdateXmlSubParser::OnEndDocumentL( TInt /*aErrorCode*/ )
+{
+// Nothing to do here.
+// Child class may add more functionality in its own implementation
+// if necessary.
+}
+EXPORT_C void CIAUpdateXmlSubParser::OnStartElementL( const Xml::RTagInfo& aElement,
+const Xml::RAttributeArray& aAttributes,
+TInt aErrorCode )
+{
+if ( CurrentSubParser() )
+{
+// Because current sub parser has been set, it is its responsibility to handle
+// the element.
+CurrentSubParser()->OnStartElementL( aElement, aAttributes, aErrorCode );
+}
+else if ( !IsElementStarted()
+&& ElementTagInfoEquals( aElement ) )
+{
+// The starting element for this sub parser element was called.
+// Reset the flags just in case.
+// And, set the started flag to ETrue;
+iIsElementStarted = ETrue;
+iAcceptData = ETrue;
+iIsElementEnded = EFalse;
+iUnknownElementCounter = 0;
+}
+else if ( IsElementStarted()
+&& AcceptData() )
+{
+// First time case has already been handled.
+// Because flags suggests that the handling of element is
+// job of the sub parser of this sub parser, try to check
+// if we can delegate it to some sub parsers.
+// Also, set the AcceptData flag accordingly.
+// If sub parser is found then, then the job is its responsibility and
+// if sub parser is not found, then some unknown element is at hand.
+// So, in both cases set the flag to false.
+iAcceptData = EFalse;
+// Sub parser has not been set. So, check if we can find a subparser for the job.
+for ( TInt i = 0; i < iSubParsers.Count(); ++i )
+{
+if ( iSubParsers[ i ]->ElementTagInfoEquals( aElement ) )
+{
+// A correct sub parser was found because element tag matched
+// to the given element.
+iCurrentSubParser = iSubParsers[ i ];
+// Now, let the sub parser handle the element.
+CurrentSubParser()->OnStartElementL( aElement, aAttributes, aErrorCode );
+// No need to check sub parsers any more.
+// Notice, that in the scheme there will be only one element of a kind but
+// in action some elements may contain multiple instances of the same element.
+// But, this will be handled inside container element separately.
+break;
+}
+}
+if ( !iCurrentSubParser )
+{
+// Element was unknown.
+++iUnknownElementCounter;
+}
+}
+else
+{
+// If we got some unknown element.
+// Set the AcceptData flag to EFalse.
+iAcceptData = EFalse;
+++iUnknownElementCounter;
+}
+}
+EXPORT_C void CIAUpdateXmlSubParser::OnEndElementL( const Xml::RTagInfo& aElement,
+TInt aErrorCode )
+{
+if ( CurrentSubParser() )
+{
+// Because current sub parser has been set
+// and it has not finished its job yet,
+// it is its responsibility to handle the element.
+CurrentSubParser()->OnEndElementL( aElement, aErrorCode );
+if ( CurrentSubParser()->IsElementEnded() )
+{
+// Because current sub parser has finished its job.
+// This parser should not have any sub parser set any more.
+iCurrentSubParser = NULL;
+// Because the sub parser has finished it job,
+// this parser can now accept new sub elements if necessary.
+// Note, that this does not mean that this element would
+// finish next.
+iAcceptData = ETrue;
+}
+}
+else if( UnknownElementCounter() == 0 )
+{
+// This sub parser has finished its job.
+// Set accept flag to its default now because
+// the element has been handled.
+iAcceptData = ETrue;
+iIsElementStarted = EFalse;
+iIsElementEnded = ETrue;
+}
+else if( UnknownElementCounter() == 1 )
+{
+--iUnknownElementCounter;
+// We have handled all the unknowns now.
+iAcceptData = ETrue;
+}
+else
+{
+// We got the unknown element end now for this sub parser.
+--iUnknownElementCounter;
+}
+}
+EXPORT_C void CIAUpdateXmlSubParser::OnContentL( const TDesC8& aBytes,
+TInt aErrorCode )
+{
+if ( CurrentSubParser() )
+{
+// Because current sub parser has been set, it is its responsibility to handle
+// the element.
+CurrentSubParser()->OnContentL( aBytes, aErrorCode );
+}
+}
+EXPORT_C void CIAUpdateXmlSubParser::OnStartPrefixMappingL( const RString& /*aPrefix*/,
+const RString& /*aUri*/,
+TInt /*aErrorCode*/ )
+{
+// Nothing to do here.
+// Child class may add more functionality in its own implementation
+// if necessary.
+}
+EXPORT_C void CIAUpdateXmlSubParser::OnEndPrefixMappingL( const RString& /*aPrefix*/,
+TInt /*aErrorCode*/ )
+{
+// Nothing to do here.
+// Child class may add more functionality in its own implementation
+// if necessary.
+}
+EXPORT_C void CIAUpdateXmlSubParser::OnIgnorableWhiteSpaceL( const TDesC8& /*aBytes*/,
+TInt /*aErrorCode*/ )
+{
+// Nothing to do here.
+// Child class may add more functionality in its own implementation
+// if necessary.
+}
+EXPORT_C void CIAUpdateXmlSubParser::OnSkippedEntityL( const RString& /*aName*/,
+TInt /*aErrorCode*/ )
+{
+// Nothing to do here.
+// Child class may add more functionality in its own implementation
+// if necessary.
+}
+EXPORT_C void CIAUpdateXmlSubParser::OnProcessingInstructionL( const TDesC8& /*aTarget*/,
+const TDesC8& /*aData*/,
+TInt /*aErrorCode*/ )
+{
+// Nothing to do here.
+// Child class may add more functionality in its own implementation
+// if necessary.
+}
+EXPORT_C void CIAUpdateXmlSubParser::OnError( TInt /*aErrorCode*/ )
+{
+// Nothing to do here.
+// Child class may add more functionality in its own implementation
+// if necessary.
+}
+EXPORT_C TAny* CIAUpdateXmlSubParser::GetExtendedInterface( const TInt32 /*aUid*/ )
+{
+// Nothing to do here.
+// Child class may add more functionality in its own implementation
+// if necessary.
+return NULL;
+}
+EXPORT_C const TDesC8& CIAUpdateXmlSubParser::LocalName() const
+{
+return *iElementLocalName;
+}
+EXPORT_C CIAUpdateXmlSubParser* CIAUpdateXmlSubParser::CurrentSubParser() const
+{
+return iCurrentSubParser;
+}
+EXPORT_C RPointerArray< CIAUpdateXmlSubParser >& CIAUpdateXmlSubParser::SubParsers()
+{
+return iSubParsers;
+}
+EXPORT_C TBool CIAUpdateXmlSubParser::ElementTagInfoEquals( const Xml::RTagInfo& aElement ) const
+{
+// Get the element local name from the given parameter.
+const TDesC8& element( aElement.LocalName().DesC() );
+// Now, chek if the given element has the same name with the element that this
+// parser is created for. Notice, that the element names are specified as case sensitive.
+// But, element values are not specified as case sensitive.
+if ( element == LocalName() )
+{
+// The given element tag matched with the local name of this class object.
+return ETrue;
+}
+else
+{
+// The local names did not match.
+return EFalse;
+}
+}
+EXPORT_C TBool CIAUpdateXmlSubParser::AcceptData() const
+{
+return iAcceptData;
+}
+EXPORT_C TBool CIAUpdateXmlSubParser::IsElementStarted() const
+{
+return iIsElementStarted;
+}
+EXPORT_C TBool CIAUpdateXmlSubParser::IsElementEnded() const
+{
+return iIsElementEnded;
+}
+EXPORT_C TInt CIAUpdateXmlSubParser::UnknownElementCounter() const
+{
+return iUnknownElementCounter;
+}