/*
* Copyright (c) 2008-2008 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:  Manages MCP plugins, and content publishing.
*
*/

#include "musiccontentmap.h"

#include <mpxlog.h>

// ======== TRACING MACROS ========

// These extend macros in <mpxlog.h>

#ifdef _DEBUG
#define MPX_DEBUG2_8(cstr, p) RDebug::Printf(cstr, p)
#else
#define MPX_DEBUG2_8(cstr, p)
#endif

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

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
RMusicContentVariant::RMusicContentVariant():iType(ETypeNull),iModified(EFalse){}

// ---------------------------------------------------------------------------
// Reset value to null
// ---------------------------------------------------------------------------
//
void RMusicContentVariant::Reset()
    {
    switch (iType)
        {
        case ETypeNull:
        	  return;
        case ETypeInt:
            break;
        case ETypeBufC:
            delete iValue.iBufC;
            iValue.iBufC = 0;
            break;
        case ETypeMap:
      	    if ( iValue.iMap )
      	        {
      	        iValue.iMap->Close();
                iValue.iMap = 0;
      	        }
      	    break;
        }
    iType = ETypeNull;
    iModified = ETrue;
    };
    
// ---------------------------------------------------------------------------
// Set value
// ---------------------------------------------------------------------------
//
TBool RMusicContentVariant::SetL( TInt aInt)
    {
    if (iType != ETypeInt || iValue.iInt != aInt)
        {
        Reset();
        iValue.iInt = aInt;
        iType = ETypeInt;
        iModified = ETrue;
        return ETrue;
        }
    else
        {
        return EFalse;
        }
    }
    
// ---------------------------------------------------------------------------
// Set value
// ---------------------------------------------------------------------------
//
TBool RMusicContentVariant::SetL( const TDesC& aDesc )
    {
    if (iType != ETypeBufC || iValue.iBufC->Compare(aDesc) )
        {
        Reset();
        iValue.iBufC = aDesc.AllocL();
        iType = ETypeBufC;
        iModified = ETrue;
        return ETrue;
        }
    else
        {
        return EFalse;
        }
    }

// ---------------------------------------------------------------------------
// Set value
// ---------------------------------------------------------------------------
//
TBool RMusicContentVariant::SetL( CLiwMap * aMap )
    {
    if (iType != ETypeMap || ! ( *iValue.iMap == *aMap ) )
        {
        Reset();
        TLiwVariant variant;
        variant.SetL ( TLiwVariant (aMap) ); // increase CLiwMap reference counter
        iValue.iMap = aMap;
        iType = ETypeMap;
        iModified = ETrue;
        return ETrue;
        }
    else
        {
        return EFalse;
        }
    }

// ---------------------------------------------------------------------------
// Return whether value has been modified
// ---------------------------------------------------------------------------
//
TBool RMusicContentVariant::IsModified() const
    {
    return iModified;
    }
    
// ---------------------------------------------------------------------------
// Reset modified flag
// ---------------------------------------------------------------------------
//
void RMusicContentVariant::ResetModified()
    {
    iModified = EFalse;
    }
    
// ---------------------------------------------------------------------------
// Return whether value is null
// ---------------------------------------------------------------------------
//
TBool RMusicContentVariant::IsNull() const
    {
    return iType == ETypeNull;
    }

// ---------------------------------------------------------------------------
// Return variant value
// ---------------------------------------------------------------------------
//
TLiwVariant RMusicContentVariant::LiwVariant() const
    {
    switch (iType)
        {
        case ETypeNull:
            return TLiwVariant();
        case ETypeInt:
            return TLiwVariant( iValue.iInt );
        case ETypeBufC:
            return TLiwVariant( iValue.iBufC );
        case ETypeMap:
            return TLiwVariant( iValue.iMap );
        }
    return TLiwVariant();
    }

// ---------------------------------------------------------------------------
// Hash function for the map
// ---------------------------------------------------------------------------
//
static inline TUint32 HashFunction(const TPtrC8& aKey)
   {
   return DefaultHash::Des8(aKey);
   }

// ---------------------------------------------------------------------------
// Identity relation for the map
// ---------------------------------------------------------------------------
//
static inline TBool IdentityRelation(const TPtrC8& aLeft, const TPtrC8& aRight)
   {
   return DefaultIdentity::Des8(aLeft, aRight);
   }

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
RMusicContentMap::RMusicContentMap():
    iMap(
        THashFunction32< TPtrC8 >(&HashFunction), 
        TIdentityRelation< TPtrC8 >(&IdentityRelation) ),
    iModified( EFalse )
    {}

// ---------------------------------------------------------------------------
// Reset a value in the map
// ---------------------------------------------------------------------------
//
void RMusicContentMap::Reset( TPtrC8 aKey )
    {
    MPX_DEBUG2_8("RMusicContentMap::Reset %S", &aKey);
     RMusicContentVariant * value = iMap.Find( aKey );
    if ( value  )
        {
        iModified |= !value->IsNull();
        value->Reset();
        }
    }
    
// ---------------------------------------------------------------------------
// Set a value in the map
// ---------------------------------------------------------------------------
//
void RMusicContentMap::SetL( TPtrC8 aKey, const TDesC& aValue )
    {
    MPX_DEBUG2_8("RMusicContentMap::SetL %S", &aKey);
    iModified |= AtL( aKey ).SetL( aValue );
    }
    
// ---------------------------------------------------------------------------
// Set a value in the map
// ---------------------------------------------------------------------------
//
void RMusicContentMap::SetL( TPtrC8 aKey, const TInt& aValue )
    {
    MPX_DEBUG2_8("RMusicContentMap::SetL %S", &aKey);
    iModified |= AtL( aKey ).SetL( aValue );
    }
    
// ---------------------------------------------------------------------------
// Set a value in the map
// ---------------------------------------------------------------------------
//
void RMusicContentMap::SetL( TPtrC8 aKey, CLiwMap * aMap )
    {
    MPX_DEBUG2_8("RMusicContentMap::SetL %S", &aKey);
    iModified |= AtL( aKey ).SetL( aMap );
    }
    
// ---------------------------------------------------------------------------
// Return whether map has been modified
// ---------------------------------------------------------------------------
//
TBool RMusicContentMap::IsModified() const
    {
    return iModified;
    }
    
// ---------------------------------------------------------------------------
// Get modified values
// ---------------------------------------------------------------------------
//
CLiwMap * RMusicContentMap::GetModifiedLC()
    {
    MPX_FUNC("RMusicContentMap::GetModifiedLC");
    CLiwMap * result = NULL;
    if (iModified)
        {
        result = CLiwDefaultMap::NewLC();
        THashMapIter<TPtrC8, RMusicContentVariant> iter( iMap );
        while( const RMusicContentVariant * ptr = iter.NextValue() )
            {
            if ( ! ptr->IsModified() ) continue;
/*            	
            if ( ptr->IsNull() )
                {
                MPX_DEBUG2_8("RMusicContentMap::GetModifiedL skipping %S (is null)", iter.CurrentKey());
                }
            else
*/
                {
                MPX_DEBUG2_8("RMusicContentMap::GetModifiedL publishing %S", iter.CurrentKey());
                result->InsertL( *iter.CurrentKey(), ptr->LiwVariant() );
                }
            iter.CurrentValue()->ResetModified();
            }
        iModified = EFalse;
        }
    return result;
    }
    
// ---------------------------------------------------------------------------
// Get all values
// ---------------------------------------------------------------------------
//
CLiwMap * RMusicContentMap::GetAllLC()
    {
    MPX_FUNC("RMusicContentMap::GetAllL");
    CLiwMap * result = NULL;
    result = CLiwDefaultMap::NewLC();
    THashMapIter<TPtrC8, RMusicContentVariant> iter( iMap );
    while( const RMusicContentVariant * ptr = iter.NextValue() )
        {
/*        if ( ptr->IsNull() )
            {
            MPX_DEBUG2_8("RMusicContentMap::GetAllL skipping %S (is null)", iter.CurrentKey());
            }
        else
*/            {
            MPX_DEBUG2_8("RMusicContentMap::GetAllL publishing %S", iter.CurrentKey());
            result->InsertL( *iter.CurrentKey(), ptr->LiwVariant() );
            }
        iter.CurrentValue()->ResetModified();
        }
    iModified = EFalse;
    return result;
    }
    
// ---------------------------------------------------------------------------
// Close map
// ---------------------------------------------------------------------------
//
void RMusicContentMap::Close()
    {
    MPX_FUNC("RMusicContentMap::Close");
    THashMapIter<TPtrC8, RMusicContentVariant> iter( iMap );
    while( iter.NextValue() )
        {
        iter.CurrentValue()->Reset();
        }
    iMap.Close();
    }

RMusicContentVariant& RMusicContentMap::AtL (TPtrC8 aKey)
    {
    RMusicContentVariant * value = iMap.Find( aKey );
    if (! value )
        {
        iMap.InsertL ( aKey, RMusicContentVariant() );
        value = iMap.Find( aKey );
        }
    return *value;
    }