diff -r 000000000000 -r f72a12da539e menufw/hierarchynavigator/hnmetadatamodel/src/hnsimplecondition.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/menufw/hierarchynavigator/hnmetadatamodel/src/hnsimplecondition.cpp	Thu Dec 17 08:40:49 2009 +0200
@@ -0,0 +1,397 @@
+/*
+* 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 <liwservicehandler.h>
+#include <liwvariant.h>
+
+#include "hnsimplecondition.h"
+#include "hnsimpleconditionequal.h"
+#include "hnsimpleconditiondifferent.h"
+#include "hnsimpleconditiongreater.h"
+#include "hnsimpleconditionhas.h"
+#include "hnsimpleconditionhasnot.h"
+#include "hnsimpleconditionsmaller.h"
+#include "hnliwutils.h"
+#include "hnglobals.h"
+#include "hnconvutils.h"
+#include "hnstringhandler.h"
+
+// ======== MEMBER FUNCTIONS ========
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+CHnSimpleCondition* CHnSimpleCondition::NewL( TDesC8 & aElement )
+    {
+    CHnSimpleCondition* self = CHnSimpleCondition::CreateImplementationL( aElement );
+    CleanupStack::PushL(self);
+    self->ConstructL( aElement );
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+CHnSimpleCondition* CHnSimpleCondition::CreateImplementationL(
+        TDesC8 & aElement )
+    {
+    TPtrC8 buffer = aElement;
+    CHnSimpleCondition* ret = NULL;
+    if ( buffer.Find( HnLogicalRelations::KLogicalGreater8 )!= KErrNotFound )
+        {
+        ret =  new( ELeave ) CHnSimpleConditionGreater();
+        }
+    else if ( buffer.Find( HnLogicalRelations::KLogicalDifferent8 ) != 
+        KErrNotFound )
+        {
+        ret = new( ELeave ) CHnSimpleConditionDifferent();
+        }
+    else if ( buffer.Find( HnLogicalRelations::KLogicalEqual8 ) != 
+        KErrNotFound )
+        {
+        ret = new( ELeave ) CHnSimpleConditionEqual();
+        }
+    else if ( buffer.Find( HnLogicalRelations::KLogicalLess8 )!= 
+        KErrNotFound )
+        {
+        ret = new( ELeave ) CHnSimpleConditionSmaller();
+        }
+    else if ( buffer.Find( HnLogicalRelations::KLogicalHas8 )!= 
+        KErrNotFound )
+        {
+        ret = new( ELeave ) CHnSimpleConditionHas();
+        }
+    else if ( buffer.Find( HnLogicalRelations::KLogicalHasNot8 )!= 
+        KErrNotFound )
+        {
+        ret = new( ELeave ) CHnSimpleConditionHasNot();
+        }
+    else
+        {
+        User::Leave( KErrGeneral );
+        }
+    return ret;
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+CHnSimpleCondition::CHnSimpleCondition()
+    {
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+CHnSimpleCondition::~CHnSimpleCondition()
+    {
+    iReferenceRight.Close();
+    iReferenceLeft.Close();
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHnSimpleCondition::RemoveQuotes( RBuf8 & aValue )
+    {
+    TInt quoPos = aValue.Locate('\'');
+    if( quoPos == 0 )
+        {
+        aValue.Delete( 0 , 1 );
+        aValue.Delete( aValue.Length() - 1, 1 );
+        }
+    }
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHnSimpleCondition::ConstructL( TDesC8 & aElement )
+    {
+    TPtrC8 buffer = aElement;
+    TInt pos = GetPositionL( buffer );
+    ASSERT( pos );
+    
+    RBuf8 tempbuf;
+    CleanupClosePushL( tempbuf );
+    tempbuf.CreateL( buffer.Right( buffer.Length() - pos - SignLength() ) );
+    iReferenceRight.Close();
+    iReferenceRight.CreateL( tempbuf );
+    iReferenceRight.Trim();
+    CHnSimpleCondition::RemoveQuotes( iReferenceRight );
+    
+    tempbuf.Close();
+    tempbuf.CreateL( buffer.Left( pos ) );
+    
+    iReferenceLeft.Close();
+    iReferenceLeft.CreateL( tempbuf );
+    iReferenceLeft.Trim();
+    CHnSimpleCondition::RemoveQuotes( iReferenceLeft );
+    
+    CleanupStack::PopAndDestroy( &tempbuf );
+    }
+
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHnSimpleCondition::NormalizeVariantTypeDesL( TLiwVariant* aVar )
+    {
+    if( aVar->TypeId() == LIW::EVariantTypeDesC8 )
+        {
+        TPtrC8 left;
+        aVar->Get( left );
+        HBufC * data = HnConvUtils::Str8ToStrFastLC( left );
+        aVar->SetL( TLiwVariant( data ) );
+        CleanupStack::PopAndDestroy( data );
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TLiwVariant* CHnSimpleCondition::CheckTypes( TLiwVariant* aVarLeft,
+        TLiwVariant* aVarRight, LIW::TVariantTypeId aType1, 
+        LIW::TVariantTypeId aType2 )
+    {
+    LIW::TVariantTypeId varLeftId = aVarLeft->TypeId();
+    LIW::TVariantTypeId varRightId = aVarRight->TypeId();
+     
+    if (varLeftId == aType1 && varRightId == aType2)
+        {
+        return aVarLeft;
+        }
+    else if (varLeftId == aType2 && varRightId == aType1)
+        {
+        return aVarRight;
+        }
+    
+    return NULL;
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHnSimpleCondition::NegotiateListL( TLiwVariant & aVar )
+    {
+    ASSERT( aVar.TypeId() == LIW::EVariantTypeList );
+    
+    CLiwList* temp = CLiwDefaultList::NewL();
+    temp->PushL();
+    aVar.Get( *temp );
+    aVar.SetL( TLiwVariant( TInt32(temp->Count()) ) );
+    CleanupStack::PopAndDestroy( temp );
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHnSimpleCondition::NegotiateMapL( TLiwVariant & aVar  )
+    {
+    ASSERT( aVar.TypeId() == LIW::EVariantTypeMap );
+        
+    CLiwDefaultMap* temp = CLiwDefaultMap::NewL();
+    temp->PushL();
+    aVar.Get( *temp ); 
+    aVar.SetL( TLiwVariant( TInt32(temp->Count()) ) );
+    CleanupStack::PopAndDestroy( temp );
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHnSimpleCondition::NegotiateTUintL( TLiwVariant & aVar )
+    {
+    ASSERT ( aVar.TypeId() == LIW::EVariantTypeDesC );
+    
+    TPtrC temp;
+    TUint integer;
+    
+    aVar.Get(temp);
+    TLex val( temp );
+    val.Val(integer);
+    aVar.Set( integer );
+        
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHnSimpleCondition::NegotiateTBoolL( TLiwVariant & aVar )
+    {    
+    ASSERT( aVar.TypeId() == LIW::EVariantTypeDesC );
+        
+    TPtrC ptr;
+    aVar.Get( ptr );
+     
+    if ( !HnStringHandler::CompareIgnoreCaseL( ptr, KStringTrue ) )
+        {
+        aVar.Set( ETrue );
+        }
+    else
+          {
+          aVar.Set( EFalse );
+           }
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHnSimpleCondition::NegotiateTInt32L( TLiwVariant & aVar )
+    {
+    ASSERT( aVar.TypeId() == LIW::EVariantTypeDesC
+            || aVar.TypeId() == LIW::EVariantTypeTUint );
+   
+    if ( aVar.TypeId() == LIW::EVariantTypeDesC )
+        {
+        TPtrC temp;
+        TInt32 integer;
+        
+        aVar.Get(temp);
+        TLex val( temp );
+        val.Val(integer);
+        aVar.Set( integer );
+        }
+    else if ( aVar.TypeId() == LIW::EVariantTypeTUint )
+        {
+        TUint unsignedValue( 0U );
+        aVar.Get( unsignedValue );
+        if( unsignedValue <= static_cast<TUint>( KMaxTInt32 ) )
+            {
+            aVar.Set( static_cast<TInt32>( unsignedValue ) );
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHnSimpleCondition::NegotiateTInt64L( TLiwVariant & aVar )
+    {
+    ASSERT(aVar.TypeId() == LIW::EVariantTypeDesC );
+    
+    TPtrC temp;
+    TInt64 integer;
+    
+    aVar.Get(temp);
+    TLex val( temp );
+    val.Val(integer);
+    aVar.Set( integer );
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHnSimpleCondition::NegotiateTypesL( TLiwVariant* aVarLeft, 
+        TLiwVariant* aVarRight )
+    {
+    NormalizeVariantTypeDesL( aVarLeft );
+    NormalizeVariantTypeDesL( aVarRight );
+    
+    if (aVarLeft->TypeId() != aVarRight->TypeId())
+        {
+        TLiwVariant* chosen( NULL );
+        
+        chosen = CheckTypes( aVarLeft, aVarRight, LIW::EVariantTypeList, LIW::EVariantTypeDesC );
+        if ( chosen )
+            {
+            NegotiateListL( *chosen );
+            return;
+            }
+        chosen = CheckTypes( aVarLeft, aVarRight, LIW::EVariantTypeMap, LIW::EVariantTypeDesC );
+        if ( chosen )
+            {
+            NegotiateMapL( *chosen );
+            return;
+            }
+        chosen = CheckTypes( aVarLeft, aVarRight, LIW::EVariantTypeDesC, LIW::EVariantTypeTInt32 );
+        if ( chosen )
+            {
+            NegotiateTInt32L( *chosen );
+            return;
+            }
+        chosen = CheckTypes( aVarLeft, aVarRight, LIW::EVariantTypeDesC, LIW::EVariantTypeTUint );
+        if ( chosen )
+            {
+            NegotiateTUintL( *chosen );
+            return;
+            }
+        chosen = CheckTypes( aVarLeft, aVarRight, LIW::EVariantTypeDesC, LIW::EVariantTypeTInt64 );
+        if ( chosen )
+            {
+            NegotiateTInt64L( *chosen );
+            return;
+            }
+        chosen = CheckTypes( aVarLeft, aVarRight, LIW::EVariantTypeDesC, LIW::EVariantTypeTBool );
+        if ( chosen )
+            {
+            NegotiateTBoolL( *chosen );
+            return;
+            }
+        chosen = CheckTypes( aVarLeft, aVarRight, LIW::EVariantTypeTUint, LIW::EVariantTypeTInt32 );
+        if ( chosen )
+            {
+            NegotiateTInt32L( *chosen );
+            return;
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// 
+// ---------------------------------------------------------------------------
+//
+TBool CHnSimpleCondition::ResultL( const CLiwGenericParamList& aQueryResults, 
+        TInt aPos )
+    {
+    TBool ret( EFalse );
+    
+    TLiwVariant varLeft;
+    varLeft.PushL();
+    TInt err1 = HnLiwUtils::GetVariantL( aQueryResults, iReferenceLeft, aPos, varLeft );
+    
+    TLiwVariant varRight;
+    varRight.PushL();
+    TInt err2 = HnLiwUtils::GetVariantL( aQueryResults, iReferenceRight, aPos , varRight );
+    
+    if ( err1 == KErrNone && err2 == KErrNone )
+    	{
+    	NegotiateTypesL( &varLeft, &varRight);
+    	ret = CheckCondition( varLeft, varRight );
+    	}
+    
+    CleanupStack::PopAndDestroy( &varRight );
+    CleanupStack::PopAndDestroy( &varLeft );
+    
+    return ret;
+    }
+