diff -r 000000000000 -r f72a12da539e menufw/hierarchynavigator/hnutilities/src/hnliwutils.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/menufw/hierarchynavigator/hnutilities/src/hnliwutils.cpp Thu Dec 17 08:40:49 2009 +0200 @@ -0,0 +1,579 @@ +/* +* Copyright (c) 2007-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: +* +*/ + + +#include +#include +#include +#include "hnmdbasekey.h" +#include "hnglobals.h" +#include "hnliwutils.h" +#include "hnconvutils.h" + + +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void HnLiwUtils::SetGenericParamListL( + const RPointerArray & aKeys, + CLiwGenericParamList & aInParam ) + { + // for each key + for ( TInt i( 0 ); i < aKeys.Count(); i++ ) + { + CHnMdBaseKey* key = aKeys[i]; + const TDesC8& keyName = key->KeyName(); + TLiwVariant value; + value.PushL(); + key->ToVariantL( value ); + aInParam.AppendL( TLiwGenericParam( keyName, value ) ); + CleanupStack::PopAndDestroy( &value ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TBool HnLiwUtils::VariantToStringL( + TLiwVariant& aVariant, + RBuf& aBuf ) + { + TBool accepted( ETrue ); + switch ( aVariant.TypeId() ) + { + case LIW::EVariantTypeDesC: + { + aBuf.CreateL( aVariant.AsDes() ); + break; + } + case LIW::EVariantTypeDesC8: + { + HBufC* tmp = HnConvUtils::Str8ToStr( aVariant.AsData() ); + if ( !tmp ) + { + User::Leave( KErrNoMemory ); + } + aBuf.Assign( tmp ); + break; + } + case LIW::EVariantTypeTUid: + { + aBuf.CreateL( KMaxLength ); + aBuf.AppendNum( aVariant.AsTUid().iUid, EHex ); + break; + } + case LIW::EVariantTypeTInt32: + { + aBuf.CreateL( KMaxLength ); + aBuf.AppendNum( aVariant.AsTInt32() ); + break; + } + case LIW::EVariantTypeTInt64: + { + aBuf.CreateL( KMaxLength ); + aBuf.AppendNum( aVariant.AsTInt64() ); + break; + } + case LIW::EVariantTypeTUint: + { + aBuf.CreateL( KMaxLength ); + aBuf.AppendNum( aVariant.AsTUint() ); + break; + } + case LIW::EVariantTypeTBool: + { + aBuf.CreateL( KMaxLength ); + aBuf.AppendNum( aVariant.AsTBool() ); + break; + } + default: + { + accepted = EFalse; + } + } + return accepted; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TBool HnLiwUtils::VariantToStringL( + TLiwVariant& aVariant, + RBuf8& aBuf ) + { + TBool accepted( ETrue ); + switch ( aVariant.TypeId() ) + { + case LIW::EVariantTypeDesC: + { + aBuf.Assign( HnConvUtils::StrToStr8L( aVariant.AsDes() ) ); + break; + } + case LIW::EVariantTypeDesC8: + { + aBuf.CreateL( aVariant.AsData() ); + break; + } + case LIW::EVariantTypeTUid: + { + aBuf.CreateL( KMaxLength ); + aBuf.AppendNum( aVariant.AsTUid().iUid, EHex ); + break; + } + case LIW::EVariantTypeTInt32: + { + aBuf.CreateL( KMaxLength ); + aBuf.AppendNum( aVariant.AsTInt32() ); + break; + } + case LIW::EVariantTypeTInt64: + { + aBuf.CreateL( KMaxLength ); + aBuf.AppendNum( aVariant.AsTInt64() ); + break; + } + case LIW::EVariantTypeTUint: + { + aBuf.CreateL( KMaxLength ); + aBuf.AppendNum( aVariant.AsTUint() ); + break; + } + case LIW::EVariantTypeTBool: + { + aBuf.CreateL( KMaxLength ); + aBuf.AppendNum( aVariant.AsTBool() ); + break; + } + default: + { + accepted = EFalse; + } + } + return accepted; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TInt HnLiwUtils::GetIterableItemCountL( CLiwIterable& aIterable ) + { + TInt count = 0; + TLiwVariant variant; + variant.PushL(); + aIterable.Reset(); + while( aIterable.NextL(variant)) + { + ++count; + } + CleanupStack::PopAndDestroy( &variant ); + return count; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TInt HnLiwUtils::GetStringL( + const CLiwGenericParamList& aParam, + const TDesC8& aPath, + RBuf& aRet ) + { + TInt ret( KErrNone ); + TLiwVariant value; + value.PushL(); + + ret = GetVariantL( aParam, aPath, value ); + if ( ret == KErrNone && !VariantToStringL( value, aRet ) ) + { + ret = KErrBadDescriptor; + } + + CleanupStack::PopAndDestroy( &value ); + return ret; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TInt HnLiwUtils::GetStringL( + const CLiwGenericParamList& aParam, + const TDesC8& aPath, + RBuf8& aRet ) + { + TInt ret( KErrNone ); + TLiwVariant value; + value.PushL(); + + ret = GetVariantL( aParam, aPath, value ); + if ( ret == KErrNone && !VariantToStringL( value, aRet ) ) + { + ret = KErrBadDescriptor; + } + + CleanupStack::PopAndDestroy( &value ); + return ret; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TInt HnLiwUtils::GetStringL( const CLiwGenericParamList& aParam, + const TDesC8& aPath, TInt aPos, RBuf& aRet ) + { + TInt ret( KErrNone ); + TLiwVariant value; + value.PushL(); + + ret = GetVariantL( aParam, aPath, aPos, value ); + if ( ret == KErrNone && !VariantToStringL( value, aRet ) ) + { + ret = KErrBadDescriptor; + } + + CleanupStack::PopAndDestroy( &value ); + return ret; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TInt HnLiwUtils::GetStringL( const CLiwGenericParamList& aParam, + const TDesC8& aPath, TInt aPos, RBuf8& aRet ) + { + TInt ret( KErrNone ); + TLiwVariant value; + value.PushL(); + + ret = GetVariantL( aParam, aPath, aPos, value ); + if ( ret == KErrNone && !VariantToStringL( value, aRet ) ) + { + ret = KErrBadDescriptor; + } + + CleanupStack::PopAndDestroy( &value ); + return ret; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TInt HnLiwUtils::GetInt64L( const CLiwGenericParamList& aParam, + const TDesC8& aPath, TInt aPos, TInt64& aRet ) + { + RBuf8 buf; + TInt err = HnLiwUtils::GetStringL( aParam, aPath, aPos, buf ); + + if ( KErrNone == err ) + { + TInt64 value( KErrNotFound ); + TLex8 lex( buf ); + + if ( KErrNone == lex.Val( value ) ) + { + aRet = value; + err = KErrNone; + } + } + + buf.Close(); + + return err; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TInt HnLiwUtils::GetVariantL( + const CLiwGenericParamList& aParam, + const TDesC8& aPath, + TInt aPos, + TLiwVariant& aRet ) + { + TInt ret( KErrNone ); + RBuf8 path; + CleanupClosePushL( path ); + path.CreateL( aPath ); + // replace index if exist in the path + HnLiwUtils::ReplaceIndexL( path, aPos ); + // fetch variant + ret = HnLiwUtils::GetVariantL( aParam, path, aRet ); + if ( ret == KErrNotFound ) + { + TInt colonFound( aPath.Find( KColon8 ) ); + if ( KErrNotFound != colonFound ) + { + /*TInt pos( 0 ); + TInt rest( aPos ); + while ( ( rest = rest / 10 ) != 0 ) + { + pos++; + }*/ + + path.SetLength( colonFound ); + TLiwVariant tempVariant; + tempVariant.PushL(); + if ( KErrNotFound != HnLiwUtils::GetVariantL( aParam, path, aRet ) ) + { + ret = KErrHidden; + } + else + { + ret = KErrNotFound; + } + CleanupStack::PopAndDestroy( &tempVariant ); + } + } + CleanupStack::PopAndDestroy( &path ); + return ret; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TInt HnLiwUtils::ExtractNameSpaceL( + const CLiwGenericParamList& aParam, + const TDesC8& aNameSpace, + TLiwVariant& aRet ) + { + TInt pos( 0 ); + const TLiwGenericParam* param; + + if ( &aParam != NULL ) + { + param = aParam.FindFirst( pos, aNameSpace ); + if ( pos >= 0 ) + { + aRet.SetL( param->Value() ); + } + } + else + { + pos = KErrNotFound; + } + + return pos; + } + + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TInt HnLiwUtils::GetVariantL( + const CLiwGenericParamList& aParam, + const TDesC8& aPath, + TLiwVariant& aRet ) + { + RArray< TPtrC8 > path; + CleanupClosePushL( path ); + TInt ret( KErrNone ); + TLiwVariant variant; + TLiwVariant lastVariant; + variant.PushL(); + lastVariant.PushL(); + + aRet.SetL( TLiwVariant( aPath ) ); + + ParsePathL( aPath, path ); + + if ( path.Count() > 0 + && ExtractNameSpaceL( aParam, path[0], lastVariant ) != KErrNotFound ) + { + TBool found( ETrue ); + for ( TInt i( 1 ); i < path.Count() && found; i++ ) + { + TPtrC8 name = path[ i ]; + LIW::TVariantTypeId typeId = lastVariant.TypeId(); + // LIW::Type ID 7 + if ( typeId == LIW::EVariantTypeList ) + { + TInt pos( GetPosition( name ) ); + found = (pos != KErrNotFound) ? lastVariant.AsList()->AtL( pos, variant ) : EFalse; + } + // LIW::Type ID 8 + else if ( typeId == LIW::EVariantTypeMap ) + { + found = lastVariant.AsMap()->FindL( name, variant ); + } + // LIW::Type ID 9 + else if ( typeId == LIW::EVariantTypeIterable ) + { + TInt pos( GetPosition( name ) ); + found = GetIterableByPositionL( *lastVariant.AsIterable(), pos, variant ); + } + lastVariant.SetL( variant ); + } + ret = found ? KErrNone : KErrNotFound; + //aRet.SetL( ( ret != KErrNotFound ) ? variant : TLiwVariant( aPath ) ); + if ( found == 0 ) + { + aRet.SetL( TLiwVariant( KNullDesC8 ) ); + } + else + { + aRet.SetL( variant ); + } + } + + CleanupStack::PopAndDestroy( &lastVariant ); + CleanupStack::PopAndDestroy( &variant ); + CleanupStack::PopAndDestroy( &path ); + return ret; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void HnLiwUtils::ParsePathL( + const TDesC8& aPath, + RArray< TPtrC8 >& aPathParts ) + { + TChar ch; // token separator + + TInt colonPos = aPath.Find( KColon8 ); + + if ( colonPos > 0 ) + { + TLex8 lex( aPath ); + + while ( !lex.Eos() ) + { + ch = lex.Get(); + + // namespace + if ( ch == KColon()[0] ) + { + lex.UnGet(); + TPtrC8 nextToken = lex.MarkedToken(); + lex.SkipAndMark( 1 ); + aPathParts.AppendL( nextToken ); + } + // list or map + else if ( ch == KSlash()[0] ) + { + lex.UnGet(); + TPtrC8 nextToken = lex.MarkedToken(); + lex.SkipAndMark( 1 ); + aPathParts.AppendL( nextToken ); + } + // last token + else if ( lex.Eos() ) + { + TPtrC8 nextToken = lex.MarkedToken(); + aPathParts.AppendL( nextToken ); + break; + } + } + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TBool HnLiwUtils::GetIterableByPositionL( CLiwIterable & aIterable, TInt pos, + TLiwVariant & aVariant ) + { + TBool ret(EFalse); + if ( pos >= 0 ) + { + TInt counter = 0; + aIterable.Reset(); + ret = aIterable.NextL( aVariant ); + while ( ret ) + { + if (counter == pos) + { + break; + } + counter++; + ret = aIterable.NextL( aVariant ); + } + } + return ret; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TInt HnLiwUtils::GetPosition( const TDesC8& aPosition ) + { + TInt ret( KErrNotFound ); + TInt pos1 = aPosition.Find( KOpenSquareBracket ); + + if ( pos1 >= 0 ) + { + TInt pos2 = aPosition.Find( KCloseSquareBracket ); + // extract string number ( +1 a character after "[", + // -1 a character before "]" + TPtrC8 num = aPosition.Mid( pos1 + 1, pos2 - 1 ); + // extract number value + TLex8 lex( num ); + lex.Val( ret ); + } + return ret; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TInt HnLiwUtils::ReplaceIndexL( RBuf8& aPath8, TInt aPos ) + { + TInt ret(KErrNotFound); + TInt indexFound( aPath8.Find( KIndex8 ) ); + + if ( !aPath8.Compare( KIndexWithBrackets8 ) ) + { + aPath8.Close(); + aPath8.CreateL( KMaxLength ); + aPath8.AppendNum( aPos ); + ret = aPath8.Length(); + } + else if ( KErrNotFound != indexFound ) + { + RBuf8 indexNum; + CleanupClosePushL( indexNum ); + indexNum.CreateL( KMaxLength ); + indexNum.AppendNum( aPos ); + + TInt indexPos = ret = aPath8.Find( KIndex8 ); + TInt indexLength = KIndex().Length(); + + aPath8.Replace( indexPos, indexLength, indexNum ); + ret += indexNum.Length(); + + CleanupStack::PopAndDestroy( &indexNum ); + } + + return ret; + } +