/** @file

* Copyright (c) 2005-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:  UpnpDomInterface

*

*/

// INCLUDE FILES

#include <e32def.h>

#include <e32math.h>

#include <f32file.h>

#include <s32file.h>

#include <e32std.h>

#define KLogFile _L("DLNAWebServer.txt")

#include "upnpdominterface.h"

#include "upnpstring.h"

#include "upnpcustomlog.h"

// ============================ MEMBER FUNCTIONS ===============================

namespace UpnpDomInterface

    {

// -----------------------------------------------------------------------------

// UpnpDomInterface::GetAttrValueL

// Gets the element attribute's value

// -----------------------------------------------------------------------------

//

	EXPORT_C TPtrC8 GetAttrValueL( const TXmlEngElement& aElement,

                    	      	   const TDesC8& aAttribute )	

		{

		if( aElement.NotNull() )

			{

			TPtrC8 val = aElement.AttributeValueL( aAttribute );

			if( val.Length() )	

				{

				// Cleanup

				return val;

				}

			// Cleanup

			return KNullDesC8();

			}

		return KNullDesC8();

		}

// -----------------------------------------------------------------------------

// UpnpDomInterface::GetElementValueL

// Gets value of the indicated element.

// -----------------------------------------------------------------------------

//

	EXPORT_C TPtrC8 GetElementValueL( const TXmlEngElement& aElement )

		{

		if( aElement.IsNull() )

			User::Leave( KErrNotFound );

		if( !aElement.Value().Length() )

			return KNullDesC8();

		return aElement.Value();

		}

// -----------------------------------------------------------------------------

// UpnpDomInterface::AllocElementValueL

// Gets value of the indicated element and allocs it on heap.

// -----------------------------------------------------------------------------

//

	EXPORT_C HBufC* AllocElementValueL( const TXmlEngElement& aElement )

		{

		if( aElement.IsNull() )

			User::Leave( KErrNotFound );

		if( !aElement.Value().Length() )

			return NULL;

		HBufC* ret = HBufC::NewL(aElement.Value().Length());

		ret->Des().Copy(aElement.Value());

		return ret;

		}

// -----------------------------------------------------------------------------

// UpnpDomInterface::CheckTagL

// Checks the element's tag

// -----------------------------------------------------------------------------

//

	EXPORT_C TBool CheckTagL( const TXmlEngElement& aElement,

                    	      const TDesC8& aTag )

		{

        // Check the local name against the wanted tag.

		TInt difference = aElement.Name().Compare( aTag );

		// Check the name of the element, 

        // if it equals to Tag (the wanted value) 

        if ( difference == 0 )

      		return ETrue;

        else 

        	return EFalse;

		}

// -----------------------------------------------------------------------------

// UpnpDomInterface::CheckTagL

// Checks the element's tag

// -----------------------------------------------------------------------------

//

	EXPORT_C TBool CheckTagL( const TXmlEngElement& aElement,

                       		  const TDesC8& aTag,

                       		  const TDesC8& aTagValue )

		{

		// If tag name equals

		if( CheckTagL( aElement, aTag ) )

			{

	        TInt difference = aElement.Value().Compare( aTagValue );

             // If value also equals then that's the tag

             // we're looking for

             if ( difference == 0 || ( !aElement.Value().Length() && !aTagValue.Length() ) )

      		   	return ETrue;

			}

		return EFalse;  				

		}

// -----------------------------------------------------------------------------

// UpnpDomInterface::CheckSubTagL

// Check tag.

// -----------------------------------------------------------------------------

//            

    EXPORT_C TBool CheckSubTagL( const TXmlEngElement& aElement,

                                 const TDesC8& aTag )

        {

        // Go through the elements of the current level.   

        if ( aElement.NotNull() )

            {

			RXmlEngNodeList<TXmlEngElement> childElements;

			CleanupClosePushL(childElements);

			aElement.GetChildElements( childElements );

			while( childElements.HasNext() )

				{

				// Check the name of the sub element, 

                // if it equals to Tag (the wanted value) 

                if ( CheckTagL( childElements.Next(), aTag ) )

                    {

                    CleanupStack::PopAndDestroy(&childElements);

      		        return ETrue;

                    }				

				}

			CleanupStack::PopAndDestroy(&childElements);

            }

        return EFalse;

        }

// -----------------------------------------------------------------------------

// UpnpDomInterface::CheckSubTagL

// Check sub tag.

// -----------------------------------------------------------------------------

//          

    EXPORT_C TBool CheckSubTagL( const TXmlEngElement& aElement,

                                 const TDesC8& aTag,

                                 const TDesC8& aTagValue )

        {

        // Go through the elements of the current level.   

        if ( aElement.NotNull() )

            {

			RXmlEngNodeList<TXmlEngElement> childElements;

			CleanupClosePushL(childElements);

			aElement.GetChildElements( childElements );

			while( childElements.HasNext() )

				{

				// Get a single element of the current level

				TXmlEngElement sub = childElements.Next();

				if( CheckTagL( sub, aTag, aTagValue ) )

				    {

				    CleanupStack::PopAndDestroy(&childElements);

					return ETrue;

				    }

				}

			CleanupStack::PopAndDestroy(&childElements);

            }

		return EFalse;

        }

// -----------------------------------------------------------------------------

// UpnpDomInterface::CheckSubTagPrefixL

// Check sub tag prefix.

// -----------------------------------------------------------------------------

//              

    EXPORT_C TBool CheckSubTagPrefixL( const TXmlEngElement& aElement,

                                       const TDesC8& aNameSpacePrefix,

                                       const TDesC8& aTag,

                                       const TDesC8& aTagValue )

        {

      	// Go through the elements of the current level.   

        if ( aElement.NotNull() )

            {

			RXmlEngNodeList<TXmlEngElement> childElements;

			CleanupClosePushL(childElements);

			aElement.GetChildElements( childElements );

			while( childElements.HasNext() )

				{

				// Get a single element of the current level

				TXmlEngElement sub = childElements.Next();

				if( CheckTagL( sub, aTag, aTagValue ) )

					{

					TXmlEngNamespace ns = sub.LookupNamespaceByPrefixL( aNameSpacePrefix );

					//Does the prefix match or is there is no prefix if empty string was passed

					if( ns.NotNull() || ( ns.IsNull() && aNameSpacePrefix.Length() == 0 ) )

						{

						CleanupStack::PopAndDestroy(&childElements);

						return ETrue;							

						}

					}

                }

            CleanupStack::PopAndDestroy(&childElements);

            }

        return EFalse;

        }

// -----------------------------------------------------------------------------

// UpnpDomInterface::CheckAttributeValueL

// Check attribute value.

// -----------------------------------------------------------------------------

//            

    EXPORT_C TBool CheckAttributeValueL( const TXmlEngElement& aElement,

                                         const TDesC8& aAttribute,

                                         const TDesC8& aValue )

        {

        if ( aElement.NotNull() )

            {

            // Check existence and value of the argument

         	TInt difference = aElement.AttributeValueL( aAttribute ).Compare( aValue );

            if(!difference)

            	return ETrue;

            else

            	return EFalse;

            }

        return EFalse;

        }

// -----------------------------------------------------------------------------

// UpnpDomInterface::DeleteElement

// Delete DOM element from the tree.

// -----------------------------------------------------------------------------

//    

    EXPORT_C TXmlEngElement DeleteElement(TXmlEngElement& aElement)

        {

		if( aElement.IsNull() )

            {

            TXmlEngElement nullElement;

            return nullElement;

            }

        TXmlEngElement parent = aElement.ParentNode().AsElement();

		aElement.Remove();

        return parent;

        }

// -----------------------------------------------------------------------------

// UpnpDomInterface::GetElementL

// Get element.

// -----------------------------------------------------------------------------

//  

    EXPORT_C TBool GetElementL( const TXmlEngElement& aElement, 

                                TXmlEngElement& aWanted, 

                                const TDesC8& aMainTag, 

                                TInt aDepth, 

                                TInt aCurrentDepth )

        {

        if ( aElement.NotNull() )

            {

            aCurrentDepth++;

			RXmlEngNodeList<TXmlEngElement> childElements;

			CleanupClosePushL(childElements);

			aElement.GetChildElements( childElements );

			while( childElements.HasNext() )

				{

				// Get a single element of the current level

				TXmlEngElement sub = childElements.Next();

				// Check the name of the element, 

                // if it equals to MainTag (the wanted value) 

                if ( CheckTagL( sub, aMainTag ) )

                    {

                    aWanted = sub;

                    CleanupStack::PopAndDestroy(&childElements);

      		        return ETrue;

                    }				

				// Else go deeper into the tree. 

                else if ( aDepth < 0 || aDepth > aCurrentDepth )

                    {

                    if ( GetElementL( sub,

                                     aWanted,

                                     aMainTag, 

                                     aDepth, 

                                     aCurrentDepth ) 

                                     == ( TBool ) ETrue )

                        {

                        CleanupStack::PopAndDestroy(&childElements);

                        return ETrue;

                        }

                    }

                else

                    {

                    }

				}

			CleanupStack::PopAndDestroy(&childElements);

            }

        return EFalse;

        }

// -----------------------------------------------------------------------------

// UpnpDomInterface::GetElementL

// Get element.

// -----------------------------------------------------------------------------

//       

    EXPORT_C TBool GetElementL( const TXmlEngElement& aElement, 

    						    TXmlEngElement& aWanted,

                                const TDesC8& aMainTag,

                                const TDesC8& aSubTag,

                                TInt aDepth,

                                TInt aCurrentDepth )

        {

        if ( aElement.NotNull() )

            {

            // Add one Depth level to the counter 

            // (affects only current and deeper levels) 

            aCurrentDepth++;

			RXmlEngNodeList<TXmlEngElement> childElements;

			CleanupClosePushL(childElements);

			aElement.GetChildElements( childElements );

			while( childElements.HasNext() )

				{

				// Get a single element of the current level

				TXmlEngElement sub = childElements.Next();

				// Check the name of the element, 

                // if it equals to MainTag (the wanted value) 

                if ( CheckTagL( sub, aMainTag ) )

                    {

                    // Check that it holds the wanted subtag 

                    // and that the subtags value is the wanted one. 

                    if ( CheckSubTagL( sub, aSubTag ) == ( TBool ) ETrue )

                        {

                        aWanted = sub;

                        CleanupStack::PopAndDestroy(&childElements);

      		        	return ETrue;

                        }

                    }		

				// Else go deeper into the tree. 

                else

                    {

                    if ( aDepth < 0 || aDepth > aCurrentDepth )

                        {

                        if ( GetElementL( sub,

                                         aWanted,

                                         aMainTag,

                                         aSubTag,

                                         aDepth,

                                         aCurrentDepth ) 

                                         == ( TBool )ETrue )

                            {

                            CleanupStack::PopAndDestroy(&childElements);

                            return ETrue;

                            }

                        }

                    }

				}

		    CleanupStack::PopAndDestroy(&childElements);

            }

        return EFalse;

        }

// -----------------------------------------------------------------------------

// UpnpDomInterface::GetElementL

// Get element.

// -----------------------------------------------------------------------------

//            

    EXPORT_C TBool GetElementL( const TXmlEngElement& aElement, 

    						    TXmlEngElement& aWanted,

                                const TDesC8& aMainTag,

                                const TDesC8& aSubTag,

                                const TDesC8& aSubTagValue, 

                                TInt aDepth, TInt aCurrentDepth )

        {

        if ( aElement.NotNull() )

            {

            // Add one Depth level to the counter 

            // (affects only current and deeper levels) 

            aCurrentDepth++;

			RXmlEngNodeList<TXmlEngElement> childElements;

			CleanupClosePushL(childElements);

			aElement.GetChildElements( childElements );

			CleanupStack::Check(&childElements);

			while( childElements.HasNext() )

				{

				// Get a single element of the current level

				TXmlEngElement sub = childElements.Next();

				// Check the name of the element, 

                // if it equals to MainTag (the wanted value) 

                if ( CheckTagL( sub, aMainTag ) )

                    {

                    CleanupStack::Check(&childElements);

                    // Check that it holds the wanted subtag and 

                    // that the subtags value is the wanted one. 

                    if ( CheckSubTagL( sub,

                                      aSubTag,

                                      aSubTagValue ) 

                                      == ( TBool ) ETrue )

                        {

                        aWanted = sub;

                        CleanupStack::PopAndDestroy(&childElements);

      		        	return ETrue;

                        }

                    }		

				// Else go deeper into the tree. 

                else

                    {

                    if ( aDepth < 0 || aDepth > aCurrentDepth )

                        {

                        if ( GetElementL( sub,

                                         aWanted, 

                                         aMainTag,

                                         aSubTag,

                                         aSubTagValue,

                                         aDepth,

                                         aCurrentDepth )

                                         == ( TBool ) ETrue )

                            {

                            CleanupStack::PopAndDestroy(&childElements);

                            return ETrue;

                            }

                        }

                    }

				}

			CleanupStack::PopAndDestroy(&childElements);

            }

        return EFalse;

        }

// -----------------------------------------------------------------------------

// UpnpDomInterface::GetContentElementL

// Get content element.