/*

* 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 Engine

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <s32strm.h>

#include <SenBaseElement.h>

#include <SenBaseAttribute.h>

#include <SenXmlUtils.h>

#include <SenXmlReader.h>

#include <SenDomFragment.h>

// own simple

#include "simplecommon.h"

#include "simpleelement.h"

#include "simplenamespace.h"

#include "simpleattribute.h"

#include "simplebasedocument.h"

#include "simpleutils.h"

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

//

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

// CSimpleBaseDocument::CSimpleBaseDocument

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

//

CSimpleBaseDocument::CSimpleBaseDocument( )

: iRoot( NULL )

    {

    }

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

// CSimpleBaseDocument::~CSimpleBaseDocument

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

//

CSimpleBaseDocument::~CSimpleBaseDocument()

    {

    // Reset and delete namespace C-class entities.

    iNsps.ResetAndDestroy();

    // Just reset array of M-class entities, 

    // do not try to delete entities.

    iMNsps.Reset();

    // Delete root entity.

    delete iRoot;

    }

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

// CSimpleBaseDocument::BaseConstructL

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

//

void CSimpleBaseDocument::BaseConstructL(

    const TDesC8& aNsUri,

    const TDesC8& aLocalName )

    {

    iRoot = CSimpleElement::NewL( aNsUri, aLocalName );

    }

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

// CSimpleBaseDocument::BaseConstructL

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

//

void CSimpleBaseDocument::BaseConstructL(

    const TDesC8& aXml )

    {       

    CSenXmlReader* reader = CSenXmlReader::NewL();

    CleanupStack::PushL(reader);

    //create a CSenDomFragment

    CSenDomFragment* pBase = CSenDomFragment::NewL();

    CleanupStack::PushL( pBase );

    //must set the content handler

    reader->SetContentHandler( *pBase );

    // and the reader

    pBase->SetReader( *reader );

    //do the parsing

    reader->ParseL( aXml );

    // Get the root element

    // OWNERSHIP IS TRANSFERRED

    //

    CSenElement* e = pBase->ExtractElement();

    const TDesC8& p8 = e->LocalName();

    ValidateXmlL( p8 );

    // This is a document root

    iRoot = CSimpleElement::NewL( e, ETrue );

    CleanupStack::PopAndDestroy( pBase );

    CleanupStack::PopAndDestroy( reader );

    }

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

// CSimpleBaseDocument::DefaultNamespace

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

//

TPtrC8 CSimpleBaseDocument::DefaultNamespace()

    {

    TInt err(KErrNone);

    TPtrC8 p8;

    TRAP( err, p8.Set( DoDefaultNamespaceL() ));

    if ( err )

        {

        return TPtrC8();

        }

    return p8;

    }

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

// CSimpleBaseDocument::AddNamespaceL

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

//

void CSimpleBaseDocument::AddNamespaceL(

    const TDesC8& aPrefix,

    const TDesC8& aUri )

    {

    iRoot->BaseElement()->AddNamespaceL( aPrefix, aUri );

    }

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

// CSimpleBaseDocument::NamespacesL

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

//

RPointerArray<MSimpleNamespace>& CSimpleBaseDocument::NamespacesL()

    {

    // Notice: 

    // We have to maintain two arrays, one for C-classes and another

    // for M-classes, since deletion of M-classes does not work.

    // This is not very good design to return RpointerArray of

    // M-classes, but let's not change API for this minor drawback.

    // reset old stuff

    iNsps.ResetAndDestroy();

    iMNsps.Reset();

    RPointerArray<CSenNamespace>& nsa = iRoot->BaseElement()->NamespacesL();

    TInt elemCount = nsa.Count();

    for ( TInt i = 0; i < elemCount; i++ )

        {

        CSenNamespace* ns = nsa[i];

        CSimpleNamespace* simpleNs = CSimpleNamespace::NewL( ns->Prefix(), ns->URI() );

        User::LeaveIfError( iNsps.Append( simpleNs ) );

        User::LeaveIfError( iMNsps.Append( simpleNs ) );

        }

    return iMNsps;

    }

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

// CSimpleBaseDocument::ExternalizeL

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

//

void CSimpleBaseDocument::ExternalizeL( RWriteStream& aStream )

    {

    aStream.WriteL( KSimpleXmlStart );

    iRoot->BaseElement()->WriteAsXMLToL( aStream);

    }

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

// CSimpleBaseDocument::Close

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

//

void CSimpleBaseDocument::Close()

    {

    delete this;

    }

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

// CSimpleBaseDocument::LocalName

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

//

const TDesC8& CSimpleBaseDocument::LocalName()

    {

    return iRoot->LocalName();

    }

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

// CSimpleBaseDocument::DefNamespaceL

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

//

MSimpleNamespace* CSimpleBaseDocument::DefNamespaceL()

    {

    return iRoot->DefNamespaceL();

    }

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

// CSimpleBaseDocument::HasContent

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

//

TBool CSimpleBaseDocument::HasContent()

    {

    return iRoot->HasContent();

    }

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

// CSimpleBaseDocument::ContentUnicodeL

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

//

HBufC* CSimpleBaseDocument::ContentUnicodeL()

    {

    return iRoot->ContentUnicodeL();

    }

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

// CSimpleBaseDocument::SetContentUnicodeL

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

//

void CSimpleBaseDocument::SetContentUnicodeL( const TDesC& aContent )

    {

    iRoot->SetContentUnicodeL( aContent );

    }

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

// CSimpleBaseDocument::SimpleElementsL

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

//

TInt CSimpleBaseDocument::SimpleElementsL( RPointerArray<MSimpleElement>& aElementArray )

    {

    return iRoot->SimpleElementsL( aElementArray );

    }

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

// CSimpleBaseDocument::AttrValueLC

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

//

HBufC* CSimpleBaseDocument::AttrValueLC( const TDesC8& aName )

    {

    return iRoot->AttrValueLC( aName );

    }

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

// CSimpleBaseDocument::AttrValue

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

//

const TDesC8* CSimpleBaseDocument::AttrValue( const TDesC8& aName )

    {

  return iRoot->AttrValue( aName );

    }

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

// CSimpleBaseDocument::AddAttrL

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

//

void CSimpleBaseDocument::AddAttrL( const TDesC8& aName, const TDesC& aValue )

    {

    iRoot->AddAttrL( aName, aValue );

    }

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

// CSimpleBaseDocument::SimpleAttributesL

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

//

TInt CSimpleBaseDocument::SimpleAttributesL( RPointerArray<MSimpleAttribute>& aArray )

    {

    return iRoot->SimpleAttributesL( aArray );

    }

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

// CSimpleBaseDocument::SimpleParentL

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

//

MSimpleElement* CSimpleBaseDocument::SimpleParentL()

    {

    return iRoot->SimpleParentL( );

    }

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

// CSimpleBaseDocument::DetachSimpleL

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

//

void CSimpleBaseDocument::DetachSimpleL()

    {

    return iRoot->DetachSimpleL( );

    }

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

// CSimpleBaseDocument::AddSimpleElementL

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

//

MSimpleElement* CSimpleBaseDocument::AddSimpleElementL(

    const TDesC8& aNsUri,

    const TDesC8& aLocalName )

    {

    return iRoot->AddSimpleElementL( aNsUri, aLocalName );

    }

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

// CSimpleBaseDocument::AddSimpleElementL

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

//

MSimpleElement* CSimpleBaseDocument::AddSimpleElementL(

    const TDesC8& aLocalName )

    {

    return iRoot->AddSimpleElementL( aLocalName );

    }

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

// CSimpleBaseDocument::RemoveSimpleElement

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

//

void CSimpleBaseDocument::RemoveSimpleElement(

    const TDesC8& aNsUri,

    const TDesC8& aLocalName )

    {

    iRoot->RemoveSimpleElement( aNsUri, aLocalName );

    }

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

// CSimpleBaseDocument::Root

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

//

CSimpleElement* CSimpleBaseDocument::Root()

    {

    return iRoot;

    }

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

// CSimpleBaseDocument::DoDefaultNamespaceL

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

//

TPtrC8 CSimpleBaseDocument::DoDefaultNamespaceL()

    {

    RPointerArray<CSenNamespace>& nsa = iRoot->BaseElement()->NamespacesL();

    TInt elemCount = nsa.Count();

    if ( !elemCount )

        {

        User::Leave( KErrNotFound );

        }

    CSenNamespace* ns = nsa[0];

    return ns->URI();

    }