diff -r 2a9601315dfc -r 98ccebc37403 javauis/mmapi_qt/baseline/src/cmmaplayerproperties.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javauis/mmapi_qt/baseline/src/cmmaplayerproperties.cpp	Fri May 14 15:47:24 2010 +0300
@@ -0,0 +1,381 @@
+/*
+* 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