/*

* Copyright (c) 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:   SIMPLE document

*

*/

#ifndef simpledocument_H

#define simpledocument_H

#include <e32std.h>

#include "simplecommon.h"

#include "msimpledocument.h"

#include "simplebasedocument.h"

// FORWARD DECLARATION

class CSimpleNamespace;

class CSimpleContent;

class CBodyPart;

class MSimpleContent;

// class RPointerArray;

/**

 *  CSimpleDocument

 *

 *  SIMPLE Engine core.

 *

 *  @lib simplexmlutils

 *  @since S60 3.2

 */

class CSimpleDocument : public CSimpleBaseDocument, public MSimpleDocument

    {

public:

public:

    /**

     * Two-phased constructor.

     * @since S60 3.2

     * @return CSimpleDocument

     */

    static CSimpleDocument* NewL( );

    /**

     * Two-phased constructor.

     * @since S60 3.2

     * @param aXml XML document

     * @return CSimpleDocument

     */

    static CSimpleDocument* NewL( const TDesC8& aXml );

    /**

     * Two-phased constructor.

     * @since S60 3.2

     * @param aData MIME multipart data     

     * @param aBoundary MIME multipart boundary     

     * @param aStart MIME multipart start content-id  

     * @return CSimpleDocument

     */

    static CSimpleDocument* NewInMultiPartL( 

        const TDesC8& aData, const TDesC8& aBoundary, const TDesC8& aStart );    

    /**

     * Destructor.

     */

    virtual ~CSimpleDocument();

    /**

     * Validates root element name

     * Leaves if not valid

     * @param aName element name

     */

    void ValidateXmlL( const TDesC8& aName );

// from base class MSimpleDocument

    /**

     * From MSimpleDocument

     * Entity's URI getter. URI is specified in a factory method

     *

     * @since S60 3.2

     * @return URI

     */

    const TDesC8* EntityURI();

    /**

     * From MSimpleDocument

     * Entity's URI setter.

     *

     * @since S60 3.2

     * @return URI

     */

    void SetEntityURIL( const TDesC8& aValue );

    /**

     * From MSimpleDocument

     * Document's default namespace accessor. It is PIDF namespace.

     *

     * @since S60 3.2

     * @return default namespace URI

     */

    TPtrC8 DefaultNamespace();

    /**

     * From MSimpleDocument

     * Add new newspace

     *

     * @since S60 3.2

     * @param aPrefix:  Namespace prefix

     * @param aUri: Namespace URI

     */

    void AddNamespaceL( const TDesC8& aPrefix,

                        const TDesC8& aUri);

    /**

     * From MSimpleDocument

     * Gets all namespaces of this element in an array.

     *

     * @since S60 3.2

     * @return array of namespaces. Array will be empty if element has

     *         no namespaces.

     *         Any modifications made on the returned items

     *         DOES NOT modify the real childs.

     *         Do NOT call ResetAndDestroy() for the array,

     *         you may call Reset() only. The array is valid only till

     *         the next call of this method in this entity.      

     */

    RPointerArray<MSimpleNamespace>& NamespacesL();

    /**

     * Copies content from given element to this element appending to the 

	 * existing content if there is any.

     * @since S60 3.2

     * @param aSource The source element.

     */

	void CopyFromL( MSimpleDocument& aSource );

    /**

     * Externalize the document into write stream.

     *

     * @since S60 3.2

     * @param aStream write stream

     */

    void ExternalizeL( RWriteStream& aStream );

    /**

     * Get direct contents

     * @param aContents array of contents [out]. 

     *        This is walid till the AddDirectContentL method. 

     */     

    void GetDirectContentsL( RPointerArray<MSimpleContent>& aContents );

    /**

     * Add content

     * @param aContent content, the data content is copied into document.

     * @param aCopyContent ETrue if buffer of each content is copied or 

     *        ownership is transferred just without copy.     

     */

    void AddDirectContentL( MSimpleContent& aContent, TBool aCopyContent );

// from base class MSimpleEntity

    /**

     * Destroy this element entity and all its descendant elements

     *

     * @since S60 3.2

     */

    void Close();

    /**

     * Getter for Element's local name.

     * LocalName and Namespace are given in factory method.

     * @return KNullDesC if not set

     */

    const TDesC8& LocalName();

    /**

     * Getter for Element's default namespace.

     *

     * @since S60 3.2

     * @return const pointer to the CSenNamespace object of this Element.

     *        NULL if not set. Ownership is transferred.

     */

    MSimpleNamespace* DefNamespaceL();

    /**

     * Method for checking if the element has any content within.

     *

     * @since S60 3.2

     * @return ETrue if has content, EFalse if not.

     */

    TBool HasContent();

    /**

     * Getter for the content of the element, unicode version.

     *

     * @since S60 3.2

     * @return content as unicode. Ownership IS TRANSFERRED to the caller.

     */

    HBufC* ContentUnicodeL();

    /**

     * Sets the content to the element. Old content is overwritten.

     *

     * @since S60 3.2

     * @param aContent: The content to be set. Can be KNullDesC

     */

    void SetContentUnicodeL(const TDesC& aContent);

    /**

     * Getting the child elements of this element matching the given criteria.

     * @param aElementArray:    Array to be filled with the matching elements,

     *                          or empty array if no matching found.

     *                          Any modifications made on the returned items

     *                          modify the real childs too.

     * @return KErrNone     ok

     *         KErrNotFound No child elements exist.

     */

    TInt SimpleElementsL( RPointerArray<MSimpleElement>& aElementArray );

    /**

     * Gets the value of the given attribute.

     *

     * @since S60 3.2

     * @param aName:    Name of the attribute in question.

     * @return the value of the attribute, or NULL if not found. Ownership is

     *        TRANSFERRED.

     */

    HBufC* AttrValueLC( const TDesC8& aName );

    /**

     * Gets the value of the given attribute.

     * @param aName:    Name of the attribute in question.

     * @return the value of the attribute, or NULL if not found. Ownership is

     *         NOT TRANSFERRED.

     */

    const TDesC8* AttrValue(const TDesC8& aName);

    /**

     * Adds an attribute. If attribute is already existing,

     * the value of the attribute will be replaced.

     *

     * @since S60 3.2

     * @param aName     Name of the attribute to be added.

     * @param aValue    Value of the attribute to be added.

     */

    void AddAttrL(const TDesC8& aName, const TDesC& aValue);

    /**

     * From MSimpleElement

     * Gets all the attributes of this element in an array.

     *

     * @since S60 3.2

     * @param aArray: Array to be filled with the attributes,

     *                       or empty array if no matching found.

     * @return KErrNone ok

     *         KErrNotFound No child elements exist.

     */

    TInt SimpleAttributesL( RPointerArray<MSimpleAttribute>& aArray );

    /**

     * Gets the parent element of this element.

     *

     * @since S60 3.2

     * @return the parent element or NULL if no parent set.

     *        Ownership IS TRANSFERRED to the caller.

     */

    MSimpleElement* SimpleParentL();

    /**

     * Detach the element from its parent.

     * If the element, or one of its children, is dependent

     * on a namespace declared in the scope of the parent

     * copy those namespace declarations to this element.

     * Leaves with KErrNotFound if parent was not set and

     * nothing to detach.

     *

     * @since S60 3.2

     */

    void DetachSimpleL();

    /**

     * Constructs and adds a new element to the children elements.

     * Sets this element to be the new parent of the given element.

     *

     * @since S60 3.2

     * @param aNsUri:       namespace URI of the new element

     * @param aLocalName:   local name of the new element

     * @return the added Element

     * Leave codes:

     *      KErrSenInvalidCharacters if aLocalName contains illegal characters.

     *      KErrSenZeroLengthDescriptor if aLocalName is zero length.

     */

    MSimpleElement* AddSimpleElementL(

        const TDesC8& aNsUri,

        const TDesC8& aLocalName);

    /**

     * Constructs and adds a new element to the children elements.

     * Sets this element to be the new parent of the given element.

     * Note: Element is created with no specific namespace, default namespace

     * of some of the upper level elements are in effect if there is such a

     * namespace.

     *

     * @since S60 3.2

     * @param aLocalName:   local name of the new element

     * @return the added Element. OWNERSHIP IS TRANSFERRED.

     *  Leave codes:

     *      KErrSenInvalidCharacters if aLocalName contains illegal characters.

     *      KErrSenZeroLengthDescriptor if aLocalName is zero length.

     */

    MSimpleElement* AddSimpleElementL(

        const TDesC8& aLocalName );

    /**

     * Remove an element from the childs.

     *

     * @since S60 3.2

     * @param   aNsUri:     the namespace URI of the element to be removed.

     * @param   aLocalName: the local name of the element to be removed.

     */

    void RemoveSimpleElement(

        const TDesC8& aNsUri,

        const TDesC8& aLocalName);

protected:

private:

    /**

     * Two-phase constructor

     */

    void ConstructL(

        const TDesC8& aNsUri,

        const TDesC8& aLocalName );

    /**

     * Two-phase constructor

     */

    void ConstructMultiPartL(

        const TDesC8& aData, const TDesC8& aBoundary, const TDesC8& aStart );        

    /**

     * Two-phase constructor

     */

    void ConstructL(

        const TDesC8& aXml );              

    /**

     * constructor

     */

    CSimpleDocument();

	/**

	 * ClenupStack operation

	 * aPtrArray RPointerArray<CBodyPart>

	 */

	static void ResetAndDestroy( TAny* aPtrArray );	 

    /**

     * DoConstructL

     * Handles XML parsing of MIME multiparts

     * @param aParts MIME multipart parts

     * @param aStart MIME multipart start content-id     

     */

    void DoConstructL( RPointerArray<CBodyPart>& aParts, const TDesC8& aStart );

    HBufC8* DoComposeMultiPartL( RPointerArray<CBodyPart>& aBodyArray,

                                const TDesC8& aBoundary);  

    void DoExternalizeMultiPartL( 

        RPointerArray<CBodyPart>& aBodies, 

        RPointerArray<HBufC8>& aBuffers,

        RWriteStream& aStream );                              	   

private:    // data

    /**

     * Direct contents in MIME multipart 

     */

    RPointerArray<CSimpleContent> iContents;

    };

#endif      // simpledocument_H

// End of File