/*
* Copyright (c) 2007-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:  Implementation class for OMA 2.1 Drm String Dictionary
*
*/


#include <e32std.h>
#include <ecom/implementationproxy.h>
#include <xml/plugins/dictionarycodepage.h>
#include <xml/xmlframeworkerrors.h>

#include "drmrel2_1stringdict00.h"
#include "drmrel2_1stringdict00tagtable.h"
#include "drmrel2_1stringdict00attributetable.h"
#include "drmrel2_1stringdict00attributevaluetable.h"

using namespace Xml;

// -----------------------------------------------------------------------------
// CDrmRel2_1StringDict00::NewL
// -----------------------------------------------------------------------------
//
MStringDictionary* CDrmRel2_1StringDict00::NewL( TAny* aStringPool )
    {
    CDrmRel2_1StringDict00* self(
       new(ELeave) CDrmRel2_1StringDict00( 
                            reinterpret_cast<RStringPool*>( aStringPool ) ) );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return ( static_cast<MStringDictionary*>( self ) );
    }

// -----------------------------------------------------------------------------
// CDrmRel2_1StringDict00::CDrmRel2_1StringDict00
// -----------------------------------------------------------------------------
//
CDrmRel2_1StringDict00::CDrmRel2_1StringDict00( RStringPool* aStringPool )
    : iStringPool( *aStringPool ), iCodePage( 0 )
    {
    // do nothing;
    }

// -----------------------------------------------------------------------------
// CDrmRel2_1StringDict00::ConstructL
// -----------------------------------------------------------------------------
//
void CDrmRel2_1StringDict00::ConstructL()
    {
    // we don't own this stringpool
    iStringPool.OpenL( DrmRel2_1StringDict00TagTable::Table );
    iStringPool.OpenL( DrmRel2_1StringDict00AttributeTable::Table );
    iStringPool.OpenL( DrmRel2_1StringDict00AttributeValueTable::Table );

    iCodepage00Table = CDictionaryCodePage::NewL(
        &DrmRel2_1StringDict00TagTable::Table, 
        &DrmRel2_1StringDict00AttributeTable::Table, 
        &DrmRel2_1StringDict00AttributeValueTable::Table, 
        0 ); // codepage

    // Construct the correlation mapping
    iCodepage00Table->ConstructIndexMappingL( 
                            iTagCodePage00,
                            CDictionaryCodePage::EStringTypeElement );

    iCodepage00Table->ConstructIndexMappingL( 
                            iAttributeCodePage00,
                            CDictionaryCodePage::EStringTypeAttribute );

    iCodepage00Table->ConstructIndexMappingL( 
                            iAttributeValueCodePage00,
                            CDictionaryCodePage::EStringTypeAttributeValue );
    }

// -----------------------------------------------------------------------------
// CDrmRel2_1StringDict00::Release
// -----------------------------------------------------------------------------
//
void CDrmRel2_1StringDict00::Release()
    {
    delete ( this );
    }

// -----------------------------------------------------------------------------
// CDrmRel2_1StringDict00::~CCDrmRel2_1StringDict00
// -----------------------------------------------------------------------------
//
CDrmRel2_1StringDict00::~CDrmRel2_1StringDict00()
    {
    if ( iCodepage00Table )
        {
        delete iCodepage00Table;
        }
    }

// -----------------------------------------------------------------------------
// CDrmRel2_1StringDict00::ElementL
// -----------------------------------------------------------------------------
//
void CDrmRel2_1StringDict00::ElementL(
    TInt aToken, 
    RString& aElement) const
    {
    TInt index( iCodepage00Table->StringPoolIndexFromToken(
                                aToken, 
                                CDictionaryCodePage::EStringTypeElement ) );

    if ( index == KErrXmlStringPoolTableNotFound )
       {
       User::Leave( KErrXmlUnsupportedElement );
       }

    aElement = iStringPool.String(
                    index,
                    *( iCodepage00Table->StringTable( 
                                CDictionaryCodePage::EStringTypeElement ) ) );
    }

// -----------------------------------------------------------------------------
// CDrmRel2_1StringDict00::AttributeL
// -----------------------------------------------------------------------------
//
void CDrmRel2_1StringDict00::AttributeL(
    TInt aToken, 
    RString& aAttribute) const
    {
    TInt index( iCodepage00Table->StringPoolIndexFromToken(
                           aToken, 
                           CDictionaryCodePage::EStringTypeAttribute ) );

    if ( index == KErrXmlStringPoolTableNotFound )
        {
        User::Leave( KErrXmlUnsupportedAttribute );
        }

    aAttribute = iStringPool.String( 
                        index,
                        *(iCodepage00Table->StringTable( 
                            CDictionaryCodePage::EStringTypeAttribute ) ) );
    }

// -----------------------------------------------------------------------------
// CDrmRel2_1StringDict00::AttributeValuePairL
// -----------------------------------------------------------------------------
//
void CDrmRel2_1StringDict00::AttributeValuePairL(
    TInt aToken, 
    RString& aAttribute, 
    RString& aValue) const
    {
    AttributeL( aToken, aAttribute );
    AttributeValueL( aToken, aValue );
    }

// -----------------------------------------------------------------------------
// CDrmRel2_1StringDict00::AttributeValueL
// -----------------------------------------------------------------------------
//
void CDrmRel2_1StringDict00::AttributeValueL( 
    TInt aToken, 
    RString& aValue ) const
    {

    TInt index( iCodepage00Table->StringPoolIndexFromToken(
                    aToken, CDictionaryCodePage::EStringTypeAttributeValue ) );

    if ( index == KErrXmlStringPoolTableNotFound )
        {
        User::Leave( KErrXmlUnsupportedAttributeValue );
        }

    aValue = iStringPool.String( 
                    index,
                    *(iCodepage00Table->StringTable(
                           CDictionaryCodePage::EStringTypeAttributeValue ) ) );
    }

// -----------------------------------------------------------------------------
// CDrmRel2_1StringDict00::CompareThisDictionary
// -----------------------------------------------------------------------------
//
TBool CDrmRel2_1StringDict00::CompareThisDictionary(
    const RString& aDictionaryDescription ) const
    {
    // If this string dictionary has many codepages then all these comparisons 
    // should go here.Remember, the string dictionary loads up all the 
    // RStringTables into its RStringPool on construction. So if the comparison 
    // fails we do not have it.
    return ( ( aDictionaryDescription == 
                            iStringPool.String( 
                                DrmRel2_1StringDict00TagTable::EUri,
                                DrmRel2_1StringDict00TagTable::Table ) ) ||

             ( aDictionaryDescription == 
                            iStringPool.String( 
                                 DrmRel2_1StringDict00TagTable::EPublicId, 
                                 DrmRel2_1StringDict00TagTable::Table ) ) ||

            ( aDictionaryDescription == 
                            iStringPool.String(
                                DrmRel2_1StringDict00TagTable::EFormalPublicId, 
                                DrmRel2_1StringDict00TagTable::Table ) ) );
    }

// -----------------------------------------------------------------------------
// CDrmRel2_1StringDict00::SwitchCodePage
// -----------------------------------------------------------------------------
//
TInt CDrmRel2_1StringDict00::SwitchCodePage(TInt aCodePage)
    {
    // We only have one codepage so can't switch
    if ( aCodePage != iCodePage )
        {
        return KErrXmlMissingStringDictionary;
        }
    return iCodePage;
    }

// -----------------------------------------------------------------------------
// CDrmRel2_1StringDict00::PublicIdentifier
// This method obtains the public identifier from the StringTable.
// Either the formal or non formal public id will do.
// The stringDictionary .rss files must list both these as Wbxml
// documents have one or the other.
//
// @param aPubId The public identifier for this string dictionary.
// -----------------------------------------------------------------------------
//
void CDrmRel2_1StringDict00::PublicIdentifier( RString& aPubId )
    {
    aPubId = iStringPool.String(
        DrmRel2_1StringDict00TagTable::EFormalPublicId,
        *( iCodepage00Table->StringTable( 
                                CDictionaryCodePage::EStringTypeElement ) ) );
    }

// -----------------------------------------------------------------------------
// CDrmRel2_1StringDict00::NamespaceUri
// The element types in the Device Information DTD are defined within
// a namespace associated with the Uri/Urn available from the StringTable.
// The RString need not be closed, but closing is harmless. 
//
// @param aUri The associated namespace for this string dictionary.
// -----------------------------------------------------------------------------
//
void CDrmRel2_1StringDict00::NamespaceUri( RString& aUri )
    {
    aUri = iStringPool.String(
           DrmRel2_1StringDict00TagTable::EUri,
           *( iCodepage00Table->StringTable( 
                                CDictionaryCodePage::EStringTypeElement ) ) );
    }

// Exported proxy for instantiation method resolution
// Define the interface UIDs
const TImplementationProxy ImplementationTable[] = { 
                IMPLEMENTATION_PROXY_ENTRY( 0x2000B490, 
                                            CDrmRel2_1StringDict00::NewL ) };

EXPORT_C const TImplementationProxy* ImplementationGroupProxy( 
    TInt& aTableCount )
    {
    aTableCount = sizeof( ImplementationTable ) / 
                  sizeof( TImplementationProxy );

    return ImplementationTable;
    }