/*

* Copyright (c) 2002 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:  This class is used for storing and parsing properties

*

*/

//  INCLUDE FILES

#include <logger.h>

#include "cmmaplayerproperties.h"

const TInt KPropertyNameEndChar = '=';

const TInt KPropertyEndChar = '&';

const TInt KDefaultGranularity = 8;

CMMAPlayerProperties* CMMAPlayerProperties::NewL(const TDesC& aProperties,

        MMMAParameterRule& aRule)

{

    CMMAPlayerProperties* props = new(ELeave) CMMAPlayerProperties(aProperties, aRule);

    return props;

}

CMMAPlayerProperties::~CMMAPlayerProperties()

{

}

CMMAPlayerProperties::CMMAPlayerProperties(const TDesC& aProperties, MMMAParameterRule& aRule) :

        iProperties(aProperties),

        iRule(aRule)

{

}

TBool CMMAPlayerProperties::GetProperty(const TDesC& aKey,

                                        TInt& aValue) const

{

    return iRule.FindProperty(aKey, aValue);

}

TBool CMMAPlayerProperties::GetProperty(const TDesC& aKey, TPtrC& aValue) const

{

    return iRule.FindProperty(aKey, aValue);

}

TBool CMMAPlayerProperties::Compare(const TDesC& aKey, const TDesC& aValue) const

{

    return iRule.Compare(aKey, aValue);

}

TBool CMMAPlayerProperties::Compare(const TDesC& aKey, const TInt& aValue) const

{

    return iRule.Compare(aKey, aValue);

}

// Parse property values: "key=value&key2=value2&..."

void CMMAPlayerProperties::ValidateL() const

{

    // Empty properties are valid

    if (iProperties.Length() == 0)

    {

        return;

    }

    TInt pos = 0;

    while (pos != KErrNotFound)

    {

        // Getting everything from 'pos' to end and finding '&'

        TPtrC property = iProperties.Mid(pos);

        TInt valueEndPos = property.Locate(KPropertyEndChar);

        if (valueEndPos != KErrNotFound)

        {

            // This is not last property, clipping remaining chars

            property.Set(iProperties.Mid(pos, valueEndPos));

        }

        TInt keyEndPos = property.Locate(KPropertyNameEndChar);

        // if we are getting KErrNotFound then properties is not valid

        if (keyEndPos == KErrNotFound)

        {

            User::Leave(KErrArgument);

        }

        // "key=value"

        TPtrC propertyKey(property.Left(keyEndPos));

        TPtrC propertyValue(property.Mid(keyEndPos + 1));

        // check is the pair valid, leave if not

        // check also that this key was expected, leave if not

        TPtrC tmp;

        TInt tmpInt;

        if (!iRule.ValidateAndStoreL(propertyKey, propertyValue) ||

                !(iRule.FindProperty(propertyKey, tmp) ||

                  iRule.FindProperty(propertyKey, tmpInt)))

        {

            User::Leave(KErrArgument);

        }

        // prepare for next token or mark end

        if (valueEndPos != KErrNotFound)

        {

            pos += valueEndPos + 1;

        }

        else

        {

            pos = valueEndPos;

        }

    }

}

CMMAParameterRuleSet* CMMAParameterRuleSet::NewLC()

{

    CMMAParameterRuleSet* self = new(ELeave)CMMAParameterRuleSet();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

}

CMMAParameterRuleSet::~CMMAParameterRuleSet()

{

    if (iRules)

    {

        iRules->Reset();

        delete iRules;

    }

}

CMMAParameterRuleSet::CMMAParameterRuleSet()

{

}

void CMMAParameterRuleSet::ConstructL()

{

    iRules = new(ELeave)CArrayPtrSeg< MMMAParameterRule >(KDefaultGranularity);

}

#define LOOPUNTILRULE( endRule ) \

    TInt rules = iRules->Count(); \

    TInt i( 0 ); \

    while( ( i < rules ) && \

           endRule ) \

        { \

        i++; \

        }

TBool CMMAParameterRuleSet::ValidateAndStoreL(const TDesC& aKey, const TDesC& aValue)

{

    LOOPUNTILRULE(iRules->At(i)->ValidateAndStoreL(aKey, aValue));

    // if loop has ended before end then some validation has failed.

    return (i == rules);

}

TBool CMMAParameterRuleSet::Compare(const TDesC& aKey, const TDesC& aValue)

{

    LOOPUNTILRULE(!iRules->At(i)->Compare(aKey, aValue));

    // if loop has ended before end then key-value pair has been found

    return (i != rules);

}

TBool CMMAParameterRuleSet::Compare(const TDesC& aKey, const TInt aValue)

{

    LOOPUNTILRULE(!iRules->At(i)->Compare(aKey, aValue));

    // if loop has ended before end then key-value pair has been found

    return (i != rules);

}

TBool CMMAParameterRuleSet::FindProperty(const TDesC& aKey, TPtrC& aValue)

{

    LOOPUNTILRULE(!iRules->At(i)->FindProperty(aKey, aValue));

    // if loop has ended before end then key has been found

    return (i != rules);

}

TBool CMMAParameterRuleSet::FindProperty(const TDesC& aKey, TInt& aValue)

{

    LOOPUNTILRULE(!iRules->At(i)->FindProperty(aKey, aValue));

    // if loop has ended before end then key has been found

    return (i != rules);

}

void CMMAParameterRuleSet::AppendRuleL(MMMAParameterRule* aRule)

{

    iRules->AppendL(aRule);

}

TMMAParameterRuleBase::TMMAParameterRuleBase(const TDesC& aKey) :

        iKey(aKey),

        iAssigned(EFalse)

{}

TBool TMMAParameterRuleBase::ValidateAndStoreL(const TDesC& aKey, const TDesC& aValue)

{

    if ((aKey.Length() == 0) ||

            (aValue.Length() == 0))

    {

        // key or value length is zero, fail

        User::Leave(KErrArgument);

    }

    TBool isValid = ETrue;

    // this is same key as in rule

    if (iKey.Compare(aKey) == 0)

    {

        //if this key is already assigned then there is same key more than once

        if (iAssigned)

        {

            User::Leave(KErrArgument);

        }

        isValid = ValidateValueL(aValue);

        // if it was valid we mark this key as assigned

        if (isValid)

        {

            iAssigned = ETrue;

        }

    }

    return isValid;

}

TBool TMMAParameterRuleBase::Compare(const TDesC& /*aKey*/, const TDesC& /*aValue*/)

{

    // by default we do not found this key

    return EFalse;

}

TBool TMMAParameterRuleBase::Compare(const TDesC& /*aKey*/, const TInt /*aValue*/)

{

    // by default we do not found this key

    return EFalse;

}

TBool TMMAParameterRuleBase::FindProperty(const TDesC& /*aKey*/, TPtrC& /*aValue*/)

{

    // by default we do not found this key

    return EFalse;

}

TBool TMMAParameterRuleBase::FindProperty(const TDesC& /*aKey*/, TInt& /*aValue*/)

{

    // by default we do not found this key

    return EFalse;

}

TMMAParameterRuleInt::TMMAParameterRuleInt(const TDesC& aKey) :

        TMMAParameterRuleBase(aKey),

        iUpperLimit(KMaxTInt),

        iLowerLimit(KMinTInt)

{}

TMMAParameterRuleInt::TMMAParameterRuleInt(const TDesC& aKey,

        const TInt aLowerLimit) :

        TMMAParameterRuleBase(aKey),

        iUpperLimit(KMaxTInt),

        iLowerLimit(aLowerLimit)

{}

TMMAParameterRuleInt::TMMAParameterRuleInt(const TDesC& aKey,

        const TInt aLowerLimit,

        const TInt aUpperLimit) :

        TMMAParameterRuleBase(aKey),

        iUpperLimit(aUpperLimit),

        iLowerLimit(aLowerLimit)

{}

TBool TMMAParameterRuleInt::ValidateValueL(const TDesC& aValue)

{

    TLex lex(aValue);

    TInt valueInt = 0;

    if ((lex.Val(valueInt) != KErrNone) ||

            !lex.Eos())

    {

        User::Leave(KErrArgument);

    }

    if ((valueInt < iLowerLimit) ||

            (valueInt > iUpperLimit))

    {

        // value is not valid

        return EFalse;

    }

    else

    {

        // value is valid, store it

        iValue = valueInt;

        return ETrue;

    }

}

TBool TMMAParameterRuleInt::Compare(const TDesC& aKey, const TInt aValue)

{

    TBool match = EFalse;

    if (iAssigned &&

            (iKey.Compare(aKey) == 0) &&

            (aValue == iValue))

    {

        match = ETrue;

    }

    return match;

}

TBool TMMAParameterRuleInt::FindProperty(const TDesC& aKey, TInt& aValue)

{

    TBool match = EFalse;

    if (iAssigned &&

            iKey.Compare(aKey) == 0)

    {

        aValue = iValue;

        match = ETrue;

    }

    return match;

}

TMMAParameterRuleDes::TMMAParameterRuleDes(const TDesC& aKey) :

        TMMAParameterRuleBase(aKey),

        iValidValues(NULL),

        iArraySize(0)

{}

TMMAParameterRuleDes::TMMAParameterRuleDes(const TDesC& aKey,

        const TMMAStaticStrArray* aValidValues,

        const TInt aArraySize) :

        TMMAParameterRuleBase(aKey),

        iValidValues(aValidValues),

        iArraySize(aArraySize)

{}

TBool TMMAParameterRuleDes::ValidateValueL(const TDesC& aValue)

{

    TInt i = 0;

    while ((i < iArraySize) &&

            aValue.Compare(iValidValues[i]()) != 0)

    {

        i++;

    }

    // if there is not valid values then we treat every value as valid

    if (iValidValues &&

            (i == iArraySize))

    {

        // there was no hit

        return EFalse;

    }

    // find match or every value is valid, storing

    iValue.Set(aValue);

    return ETrue;

}

TBool TMMAParameterRuleDes::Compare(const TDesC& aKey, const TDesC& aValue)

{

    TBool match = EFalse;

    if (iAssigned &&

            (iKey.Compare(aKey) == 0) &&

            (iValue.Compare(aValue) == 0))

    {

        match = ETrue;

    }

    return match;

}

TBool TMMAParameterRuleDes::FindProperty(const TDesC& aKey, TPtrC& aValue)

{

    TBool match = EFalse;

    if (iAssigned &&

            iKey.Compare(aKey) == 0)

    {

        aValue.Set(iValue);

        match = ETrue;

    }

    return match;

}

//  END OF FILE