// Copyright (c) 2006-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:

// Methods for attribute node

//

#include <xml/dom/xmlengelement.h>

#include <xml/dom/xmlengdocument.h>

#include <stdapis/libxml2/libxml2_tree.h>

#include "xmlengdomdefs.h"

#include <stdapis/libxml2/libxml2_globals.h>

#include <stdapis/libxml2/libxml2_parserinternals.h>

#include <xml/utils/xmlengmem.h>

#include <xml/utils/xmlengxestrings.h>

#define LIBXML_ATTRIBUTE (static_cast<xmlAttrPtr>(iInternal))

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

// Clones attribute node

//

// @return A copy of the attribute with its value

// @note

//    Namespace of the attribute is reset; use TXmlEngNode::CopyToL(TXmlEngNode), which

//    finds appropriate or creates new namespace declaration on the new

//    parent node (argument should be an TXmlEngElement handle)

// @see CopyToL(TXmlEngNode)

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

//

EXPORT_C TXmlEngAttr TXmlEngAttr::CopyL() const

    {

    if (iInternal)

        {

        xmlAttrPtr attr = xmlCopyProp(NULL, LIBXML_ATTRIBUTE);

        OOM_IF_NULL(attr);

        TXmlEngAttr ncopy(attr);

        attr->doc = NULL;

        OwnerDocument().TakeOwnership(ncopy);

        return attr;

        }

    return NULL;    

    }

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

// @return Attribute's contents

//

// @note For values consisting of more then one TXmlEngTextNode node (as attribute's child)

//       returns only the begining of the value; this happens when the value is

//       represented by list of TXmlEngTextNode and TXmlEngEntityReference nodes.

// @see IsSimpleContents(), WholeValueCopyL()

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

//

EXPORT_C TPtrC8 TXmlEngAttr::Value() const

    {

    if(LIBXML_ATTRIBUTE && LIBXML_ATTRIBUTE->children &&

         LIBXML_ATTRIBUTE->children->type == XML_TEXT_NODE)

        {

        return ((TXmlEngConstString)CAST_XMLCHAR_TO_DOMSTRING(LIBXML_ATTRIBUTE->children->content)).PtrC8();

        }

    return KNullDesC8(); // the value starts with entity reference or is NULL

    }

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

// @return Local name of the attribute

//

// @note Equal to TXmlEngNode::NodeName(), but works faster.

//

// <b>Never call this on NULL object!</b>

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

//

EXPORT_C TPtrC8 TXmlEngAttr::Name() const

    {

    if(LIBXML_ATTRIBUTE)

        {

        return ((TXmlEngConstString)CAST_XMLCHAR_TO_DOMSTRING(LIBXML_ATTRIBUTE->name)).PtrC8();

        }

    return KNullDesC8();

    }

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

// @return Compex value of the attribute,

//         probably consisting of text nodes and entity references

//

// Since the value may be composed from a set of TXmlEngTextNode and EntityRefernce nodes,

// the returned result is newly allocated string, which should be freed by caller.

// 

// <B style="color: red">BE SURE TO FREE THE RESULT STRING!!!</B>

// 

// On Symbian:

// @code

//    // Note the use of AllocAndFreeLC(), which converts value to

//    // UTF-16 descriptor, pushes it to the cleanup stack and

//    // DEALLOCATES string in the returned TDOMString object

//    HBufC* value = attr.WholeValueCopyL().AllocAndFreeLC();

//    ...

//    CleanupStack::PopAndDestroy(); // value;

// @endcode

//

// @see TXmlEngAttr::Value(), TXmlEngNode::Value(),

//      TXmlEngNode::IsSimpleTextContents(), TXmlEngNode::WholeTextContentsCopyL()

//

// @note In most cases using Value() is enough (and it needs no memory allocation).

//       Use IsSimpleTextContents() if there doubts can Value() be used or not safely.

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

//

EXPORT_C void TXmlEngAttr::WholeValueCopyL(RBuf8& aBuffer) const

    {

    if (!LIBXML_ATTRIBUTE) 

    	{

    	User::Leave(KXmlEngErrNullNode);

    	}

    //

    xmlChar* value = xmlNodeListGetString(

        LIBXML_ATTRIBUTE->doc,

        LIBXML_ATTRIBUTE->children,

        1);

    TEST_OOM_FLAG;

    xmlCharAssignToRbuf8L(aBuffer,value);    

    }

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

// Sets new value of the attribute. Provided new value will be escaped as needed.

// 

// @param  aNewValue   A string value for the attribute

//

// The new value should not contain entity references. Entity references are not expanded,

// but used as text, because the ampersand (&) character of reference is escaped.

// 

// @see SetRawValueL(TDOMString)

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

//

EXPORT_C void TXmlEngAttr::SetValueL(

    const TDesC8& aNewValue)

    {

    if (!LIBXML_ATTRIBUTE) 

    	{

    	User::Leave(KXmlEngErrNullNode);

    	}

    //

    xmlAttrPtr prop = LIBXML_ATTRIBUTE;

    xmlNodePtr new_ch;

    if (!aNewValue.Length())

        {

        new_ch = NULL;

        }

    else

        {

        xmlChar* value = xmlCharFromDesC8L(aNewValue);

        new_ch = xmlNewText(NULL);

        if(!new_ch)

            {

            delete value;

            OOM_HAPPENED;

            };

        new_ch->content = value;

        new_ch->parent = reinterpret_cast<xmlNodePtr>(prop);

        new_ch->doc = prop->doc;

        }   

    xmlFreeNodeList(prop->children);

    prop->children = new_ch;

    prop->last = new_ch;

    }

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

// Sets new value from escaped XML character data that may contain entity references.

//

// The value as if it is an escaped contents from XML file.

// If the value contains entity references, then the resulting

// content of the attribute is a list of TXmlEngTextNode and EntityRefeerence nodes.

// Predefined entities are converted into characters they represent.

//

// @see    TXmlEngAttr::SetValueL(TStringArg)

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

//

EXPORT_C void TXmlEngAttr::SetEscapedValueL(

    const TDesC8& aNewValue)

    {

    if (!LIBXML_ATTRIBUTE) 

    	{

    	User::Leave(KXmlEngErrNullNode);

    	}

    //

    xmlAttrPtr prop = LIBXML_ATTRIBUTE;

    xmlNodePtr new_ch;

    if (!aNewValue.Length())

        {

        prop->last = NULL;

        new_ch = NULL;

        }

    else

        {

        xmlChar* value = xmlCharFromDesC8L(aNewValue);

        new_ch = xmlStringGetNodeList(LIBXML_ATTRIBUTE->doc, value);

        delete value;

        TEST_OOM_FLAG;

        // Set parent property on all child nodes and find pointer to the last node

        xmlNodePtr tmp = new_ch;

        while (tmp)

            {

            tmp->parent = (xmlNodePtr) prop;

            if (!(tmp->next))

                prop->last = tmp;

            tmp = tmp->next;

            }

        }   

    xmlFreeNodeList(prop->children);

    prop->children = new_ch;

    }

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

// Sets new attribute value exactly as presented in the string.

//

// Predefined entities are not converted into characters they represent.

//

// @see    TXmlEngAttr::SetValueL()

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

//

EXPORT_C void TXmlEngAttr::SetValueNoEncL( const TDesC8& aNewValue )

    {

    if (!LIBXML_ATTRIBUTE) 

    	{

    	User::Leave(KXmlEngErrNullNode);

    	}

    //

    xmlAttrPtr prop = LIBXML_ATTRIBUTE;

    xmlNodePtr new_ch;

	if (!aNewValue.Length())

        {

        prop->last = NULL;

        new_ch = NULL;

        }

    else

        {

        xmlChar* value = xmlCharFromDesC8L(aNewValue);

        new_ch = xmlNewText(NULL);

        if(!new_ch)

            {

            delete value;

            OOM_HAPPENED;

            };

        new_ch->name = xmlStringTextNoenc;

        new_ch->content = value;

        new_ch->parent = (xmlNodePtr) prop;

       	prop->last = new_ch;

        }   

    xmlFreeNodeList(prop->children);

    prop->children = new_ch;

    }

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

// @return TXmlEngElement that contains the attribute

//

// Same as TXmlEngNode::ParentNode() but returns TXmlEngElement instead of TXmlEngNode

//

// @note  Copies of attributes [TXmlEngAttr::CopyL()] and newly created attribute nodes

//        [RXmlEngDocument::CreateAttributeL(..)] do not have parent element until they are attached

//        to some element.

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

//

EXPORT_C const TXmlEngElement TXmlEngAttr::OwnerElement() const

    {

    XE_ASSERT_DEBUG(LIBXML_ATTRIBUTE);

    return TXmlEngElement(LIBXML_ATTRIBUTE->parent);

    }