// 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
	}