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

#ifndef __ASSERT
#define __ASSERT(a)
#endif

// Class RSqlLiteral
inline TBool RSqlLiteral::IsNull() const
	{return iType==ENull;}
inline TInt32 RSqlLiteral::Int32() const
	{__ASSERT(iType==EInt32);return iVal.iInt32;}
inline TUint32 RSqlLiteral::Uint32() const
	{__ASSERT(iType==EUint32);return iVal.iUint32;}
inline const TInt64& RSqlLiteral::Int64() const
	{__ASSERT(iType==EInt64);return iVal.iInt64;}
inline const TReal32& RSqlLiteral::Real32() const
	{__ASSERT(iType==EReal32);return iVal.iReal32;}
inline const TReal64& RSqlLiteral::Real64() const
	{__ASSERT(iType==EReal64);return iVal.iReal64;}
inline const TTime& RSqlLiteral::Time() const
	{__ASSERT(iType==ETime);return iVal.iTime;}
inline const TPtrC RSqlLiteral::DesC() const
	{__ASSERT(iType==EPtr);return TPtrC(iVal.iPtr.iPtr,iVal.iPtr.iEnd-iVal.iPtr.iPtr);}
inline const TText* RSqlLiteral::Ptr() const
	{__ASSERT(iType==EPtr);return iVal.iPtr.iPtr;}
inline const TText* RSqlLiteral::End() const
	{__ASSERT(iType==EPtr);return iVal.iPtr.iEnd;}
inline const HBufC8& RSqlLiteral::Text8() const
	{__ASSERT(iType==EBuf8);return *(const HBufC8*)iVal.iAlloc;}
inline const HBufC16& RSqlLiteral::Text16() const
	{__ASSERT(iType==EBuf16);return *(const HBufC16*)iVal.iAlloc;}
inline const HMatcherPattern8& RSqlLiteral::Pattern8() const
	{__ASSERT(iType==EPattern8);return *(const HMatcherPattern8*)iVal.iAlloc;}
inline const HMatcherPattern16& RSqlLiteral::Pattern16() const
	{__ASSERT(iType==EPattern16);return *(const HMatcherPattern16*)iVal.iAlloc;}
inline const HBufC8& RSqlLiteral::Blob() const
	{__ASSERT(iType==EBlob);return *(const HBufC8*)iVal.iAlloc;}

// Class RSqlColumnList
inline RSqlColumnList::RSqlColumnList()
	:RArray<TPtrC>(EGranularity)
	{}

// Class CSqlSearchCondition
inline CSqlSearchCondition::TType CSqlSearchCondition::NodeType() const
	{return iType;}
inline CSqlMultiNode* CSqlSearchCondition::MultiNode()
	{__ASSERT(iType==EAnd||iType==EOr);return STATIC_CAST(CSqlMultiNode*,this);}
inline CSqlNullPredicate* CSqlSearchCondition::NullPredicate()
	{__ASSERT(iType==EIsNull||iType==EIsNotNull);return STATIC_CAST(CSqlNullPredicate*,this);}
inline CSqlCompPredicate* CSqlSearchCondition::CompPredicate()
	{__ASSERT(iType==ELess||iType==ELessEqual||iType==EEqual||iType==EGreaterEqual||iType==EGreater||iType==ENotEqual);return STATIC_CAST(CSqlCompPredicate*,this);}
inline CSqlLikePredicate* CSqlSearchCondition::LikePredicate()
	{__ASSERT(iType==ELike||iType==ENotLike);return STATIC_CAST(CSqlLikePredicate*,this);}

// Class CSqlMultiNode
inline TInt CSqlMultiNode::Count() const
	{return iEnd-iLeaves;}
inline CSqlSearchCondition* CSqlMultiNode::SubNode(TInt aIndex) const
	{__ASSERT(TUint(aIndex)<TUint(Count()));return iLeaves[aIndex];}
inline void CSqlMultiNode::SetSubNode(TInt aIndex,CSqlSearchCondition* aSearchCondition) 
	{__ASSERT(TUint(aIndex)<TUint(Count()));iLeaves[aIndex]=aSearchCondition;}

// Class CSqlBoundNode
inline TBool CSqlBoundNode::IsBound() const
	{return iSource!=0;}
inline TDbColNo CSqlBoundNode::ColNo() const
	{__ASSERT(IsBound());return iColumn.iBound.iNumber;}
inline TDbColType CSqlBoundNode::ColType() const
	{return iColumn.iBound.iType;}

// Class CSqlLiteralNode 
inline const RSqlLiteral& CSqlLiteralNode::Value() const
	{return iLiteral;}
inline RSqlLiteral& CSqlLiteralNode::Value()
	{return iLiteral;}

// Class CSqlQuery
inline const TDesC& CSqlQuery::Table() const
	{return iTable;}
inline TBool CSqlQuery::HasColumnList() const
	{return iColumns.Count()!=0;}
inline const RSqlColumnList& CSqlQuery::ColumnList() const
	{return iColumns;}
inline TBool CSqlQuery::HasSearchCondition() const
	{return iSearchCondition!=0;}
inline CSqlSearchCondition& CSqlQuery::SearchCondition()
	{__ASSERT(HasSearchCondition());return *iSearchCondition;}
inline CSqlSearchCondition* CSqlQuery::AdoptSearchCondition()
	{__ASSERT(HasSearchCondition());CSqlSearchCondition* rr=iSearchCondition;iSearchCondition=0;return rr;}
inline TBool CSqlQuery::HasSortSpecification() const
	{return iSortSpecification!=0;}
inline CDbKey& CSqlQuery::SortSpecification()
	{__ASSERT(HasSortSpecification());return *iSortSpecification;}

// Class CSqlDMLStatement
inline CSqlQuery& CSqlDMLStatement::Query()
	{return iQuery;}
inline CSqlValues& CSqlDMLStatement::Values()
	{__ASSERT(iValues);return *iValues;}
inline CSqlValues* CSqlDMLStatement::AdoptValues()
	{__ASSERT(iValues);CSqlValues* v=iValues;iValues=NULL;return v;}
inline TBool CSqlDMLStatement::HasValues() const
	{return iValues!=NULL;}

// Class CSqlModifyStatement
inline TBool CSqlModifyStatement::IsUpdate() const
	{return HasValues();}

//class TSqlParser2

inline Sql::TStatementType TSqlParser2::StatementType() const
	{
	return iStatementType;
	}

inline const TDesC& TSqlParser2::TableName() const
	{
	return iTableName;
	}

inline static void HexDecodeL(const TDesC& aHex, RBuf8& aOutput)
	{
	TUint len = (TUint)aHex.Length();

	// allocate buffer for result
	aOutput.CreateL(len / 2);
	if (len<1)
		return;
	
	TLex extractor(aHex);
	TLex converter;
	TUint8 val;
	while (!extractor.Eos())
		{
		// get next value
		extractor.Mark();
		extractor.Inc();
		if (extractor.Eos())
			{
			User::Leave(KErrArgument);
			}
		extractor.Inc();
		converter.Assign(extractor.MarkedToken());
		TInt err = converter.Val(val, EHex);
		User::LeaveIfError(err);
		
		// add to result
		aOutput.Append(&val, 1);
		}
	}
