// Copyright (c) 1998-2009 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:

// SQL AND and OR node class

// 

//

#include "UQ_STD.H"

// class CSqlMultiNode

inline CSqlMultiNode::CSqlMultiNode( TType aType )

 :	CSqlSearchCondition( aType )

	{ __ASSERT( aType == EOr || aType == EAnd ); }

inline TInt CSqlMultiNode::Size() const

	{ return ( const TUint8* )iEnd - ( const TUint8* )this; }

inline TBool CSqlMultiNode::IsFull() const

	{ return ( Size() & ( EGranularity - 1 ) ) == 0; }

inline TInt CSqlMultiNode::Size( TInt aLeaves )

	{ return _FOFF( CSqlMultiNode, iLeaves[ aLeaves ] ); }

CSqlMultiNode::~CSqlMultiNode()

	{

	TEntry* p = iLeaves;

	TEntry* e = iEnd;

	while ( p < e )

		delete *p++;

	}

CSqlMultiNode* CSqlMultiNode::New( TType aType, TInt aSize )

	{

	aSize = ( aSize + ( EGranularity - 1 ) ) & ~( EGranularity - 1 );

	__ASSERT( aSize >= static_cast<TInt>( sizeof( CSqlMultiNode ) ) );

	aSize -= sizeof( CSqlMultiNode );

	return new( aSize )  CSqlMultiNode( aType );	// get the extra size for the entries

	}

CSqlMultiNode* CSqlMultiNode::Grow( CSqlMultiNode* aNode, TInt aExtraSize )

	{

	TInt size = aNode->Size();

	CSqlMultiNode* self = New( aNode->NodeType(), size + aExtraSize );

	if ( self )

		{

		aNode->iEnd = aNode->iLeaves;

		self->iEnd = ( TEntry* )Mem::Copy( self->iLeaves, aNode->iLeaves, size - Size( 0 ) );

		}

	delete aNode;

	return self;

	}

CSqlMultiNode* CSqlMultiNode::Concatenate( CSqlMultiNode* aLeft, CSqlMultiNode* aRight )

	{

	TInt lsize = aLeft->Size();

	TInt rsize = aRight->Size();

	if ( rsize > lsize )

		return Concatenate( aRight, aLeft );	// right node larger--flip over

	rsize -= Size( 0 );

	if ( (aLeft->IsFull()) ||											// if left node is already full 

		 (( lsize & ( EGranularity - 1 ) ) + rsize > EGranularity ) )	// or available space in the left node is not enough for a new data

			aLeft = Grow( aLeft, rsize );								// then increase left node to accomadate right node

	if ( aLeft )

		{

		aRight->iEnd = aRight->iLeaves;

		aLeft->iEnd = ( TEntry* )Mem::Copy( aLeft->iEnd, aRight->iLeaves, rsize );

		}

	delete aRight;

	return aLeft;

	}

CSqlSearchCondition* CSqlMultiNode::New( TType aType, CSqlSearchCondition* aLeft, CSqlSearchCondition* aRight )

//

// Full NULL propagation, cleaning up any of either node on failure

//

	{

	if ( aLeft && aRight )

		{

		if ( aLeft->NodeType() == aType )

			{	// we can merge into aLeft

			CSqlMultiNode* left = aLeft->MultiNode();

			if ( aRight->NodeType() == aType )

				return Concatenate( left, aRight->MultiNode() );

			// append right subnode onto left

			if ( left->IsFull() )

				{

				left = Grow( left, sizeof( TEntry ) );

				if ( !left )

					goto grow_failed;

				}

			TEntry* e = left->iEnd;

			*e++ = aRight;

			left->iEnd = e;

			return left;

			}

		else if ( aRight->NodeType() == aType )

			return New( aType, aRight, aLeft );	// swap left and right

		else

			{	// neither node is not of the required type

			CSqlMultiNode* self = New( aType, Size( 2 ) );

			if ( self )

				{

				TEntry* e = self->iLeaves;

				*e++ = aLeft;

				*e++ = aRight;

				self->iEnd = e;

				return self;

				}

			}

		}

	delete aLeft;

grow_failed:

	delete aRight;

	return 0;

	}

void CSqlMultiNode::Remove( CSqlSearchCondition* aSubNode )

//

// Remove the subnode from the leaf-set

//

	{

	TEntry* p = iLeaves - 1;

	TEntry* e = --iEnd;

	do

		{

		__ASSERT( p < e );

		} while ( *++p != aSubNode );

	while ( p<e )

		{

		TEntry e = *++p;

		p[ -1 ] = e;

		}

	delete aSubNode;

	}

CSqlSearchCondition* CSqlMultiNode::Reduce (CSqlMultiNode* aNode )

//

// If we have less than two leaves, then simplify the expression

//

	{

	CSqlSearchCondition* node = aNode;

	if ( aNode->iEnd - aNode->iLeaves <= 1 )

		{

		if ( aNode->iEnd - aNode->iLeaves == 1 )

			{

			aNode->iEnd = aNode->iLeaves;

			node = aNode->iLeaves[ 0 ];

			}

		else

			node = 0;

		delete aNode;

		}

	return node;

	}

void CSqlMultiNode::BindL( const RDbTableRow& aSource )

	{

	__ASSERT( iEnd - iLeaves > 1 );

	const TEntry* p = iLeaves;

	const TEntry* e = iEnd;

	do ( *p++ )->BindL( aSource );

		while ( p < e );

	}

TBool CSqlMultiNode::EvaluateL( const TTextOps& aTextOp ) const

	{

	__ASSERT( iEnd - iLeaves > 1 );

	const TEntry* p = iLeaves;

	const TEntry* e = iEnd - 1;			// all except the last sub-node

	do

		{

		TBool b = ( *p++ )->EvaluateL( aTextOp );

		if ( NodeType() == EOr )

			{

			if ( b )

				return b;

			}

		else

			{

			if ( !b )

				return b;

			}

		} while ( p < e );

	return ( *p )->EvaluateL( aTextOp );	// the last subnode

	}