/*

* Copyright (c) 2002-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:  Abstract SQL connection class*

*/

// -----------------------------------

// TColumn

// -----------------------------------

inline TColumn::TColumn( TColumnDataType aType ) :

	iType( aType )

    {

    iData.iInt32 = 0;

    }

inline TColumnDataType TColumn::Type() const

    {

    // the HBuf types are internal and hidden.

    switch ( iType )

	    {

	    case EColumnHBuf8:

	    	return EColumnDes8;

	    case EColumnHBuf16:

	    	return EColumnDes16;

		case EColumnNullDes8:

			return EColumnDes8;

		case EColumnNullDes16:

			return EColumnDes16;

		default:

			return iType;

	    }

    }

inline void TColumn::Free()

    {

    if ( iType == EColumnHBuf8 )

        {

        delete (HBufC8*)iData.iText.iPtr;

        iData.iText.iPtr = 0;

        }

    else if ( iType == EColumnHBuf16 )

        {

        delete (HBufC16*)iData.iText.iPtr;

        iData.iText.iPtr = 0;

        }

    }

inline void TColumn::Set( TInt32 aVal ) 

    {

    iType = EColumnInt32;

    iData.iInt32 = aVal;

    }

inline void TColumn::Set( TUint32 aVal ) 

    {

    iType = EColumnUint32;

    iData.iUint32 = aVal;

    }

inline void TColumn::Set( TBool aVal )

    {

    iType = EColumnBool;

    iData.iInt32 = aVal;

    }

inline void TColumn::Set( TInt64 aVal )

    {

    iType = EColumnInt64;

    iData.iInt64 = aVal;

    }

inline void TColumn::Set( TReal32 aVal ) 

    {

    iType = EColumnReal32;

    iData.iReal32 = aVal;

    }

inline void TColumn::Set( TReal64 aVal ) 

    {

    iType = EColumnReal64;

    iData.iReal64 = aVal;

    }

inline void TColumn::Set( TTime aVal )

    {

    iType = EColumnTime;

    iData.iInt64 = aVal.Int64();

    }

inline void TColumn::Set( const TDesC8& aVal )

    {

    iType = EColumnDes8;

    iData.iText.iPtr = (TAny*)aVal.Ptr();

    iData.iText.iLen = aVal.Length();

    }

inline void TColumn::Set( const TDesC16& aVal )

    {

    iType = EColumnDes16;

    iData.iText.iPtr = (TAny*)aVal.Ptr();

    iData.iText.iLen = aVal.Length();

    }

inline void TColumn::Set( const HBufC8* aVal )

    {

    iType = ( aVal ? EColumnHBuf8 : EColumnNullDes8 );

    iData.iText.iPtr = (TAny*)aVal;

    }

inline void TColumn::Set( const HBufC16* aVal )

    {

    iType = ( aVal ? EColumnHBuf16 : EColumnNullDes16 );

    iData.iText.iPtr = (TAny*)aVal;

    }

inline void TColumn::NotUsed()

    {

    iType = EColumnNotUsed;

    iData.iText.iPtr = 0;

    }

inline void TColumn::Get( TInt32& aValue ) const

    {

    if( EColumnNullDes16 == iType )

    	{

    	aValue = 0;

    	return;

    	}

    __ASSERT_DEBUG( iType == EColumnInt32, MMdCCommon::Panic( EDatabaseFault ) );

    aValue = iData.iInt32;

    }

inline void TColumn::Get( TUint32& aValue ) const

    {

    if( EColumnNullDes16 == iType )

    	{

    	aValue = 0;

    	return;

    	}

	__ASSERT_DEBUG( iType == EColumnUint32, MMdCCommon::Panic( EDatabaseFault ) );

    aValue = iData.iUint32;

    }

inline void TColumn::Get( TBool& aValue ) const 

    {

    if( EColumnNullDes16 == iType )

    	{

    	aValue = EFalse;

    	return;

    	}

	__ASSERT_DEBUG( iType == EColumnBool, MMdCCommon::Panic( EDatabaseFault ) );

    aValue = iData.iInt32;

    }

inline void TColumn::Get( TInt64& aValue ) const

    {

    if( EColumnNullDes16 == iType )

    	{

    	aValue = 0;

    	return;

    	}

	__ASSERT_DEBUG( iType == EColumnInt64, MMdCCommon::Panic( EDatabaseFault ) );

    aValue = iData.iInt64;

    }

inline void TColumn::Get( TReal32& aValue ) const

    {

    if( EColumnNullDes16 == iType )

    	{

    	aValue = 0.0f;

    	return;

    	}

	__ASSERT_DEBUG( iType == EColumnReal32, MMdCCommon::Panic( EDatabaseFault ) );

    aValue = iData.iReal32;

    }

inline void TColumn::Get( TReal64& aValue ) const

    {

    if( EColumnNullDes16 == iType )

    	{

    	aValue = 0.0f;

    	return;

    	}

	__ASSERT_DEBUG( iType == EColumnReal64, MMdCCommon::Panic( EDatabaseFault ) );

    aValue = iData.iReal64;

    }

inline void TColumn::Get( TTime& aValue ) const

    {

    if( EColumnNullDes16 == iType )

    	{

    	aValue = TTime( 0 );

    	return;

    	}

	__ASSERT_DEBUG( iType == EColumnTime, MMdCCommon::Panic( EDatabaseFault ) );

    aValue = TTime(iData.iInt64);

    }

inline void TColumn::Get( TPtrC8& aValue ) const

    {

    if ( iType == EColumnDes8 )

        {

        aValue.Set(

            (TUint8*)iData.iText.iPtr,

            iData.iText.iLen );

        }

    else if ( iType == EColumnHBuf8 )

        {

        aValue.Set(

            ((HBufC8*)iData.iText.iPtr)->Des() );

        }

    else if ( iType == EColumnNullDes8 ||

        iType == EColumnNullDes16 )

        {

        aValue.Set( KNullDesC8().Ptr(), 0 );

        }

    else MMdCCommon::Panic( EDatabaseFault );

    }

inline void TColumn::Get( TPtrC16& aValue ) const

    {

    if ( iType == EColumnDes16 )

        {

        aValue.Set(

            (TUint16*)iData.iText.iPtr,

            iData.iText.iLen );

        }

    else if ( iType == EColumnHBuf16 )

        {

        aValue.Set(

            ((HBufC16*)iData.iText.iPtr)->Des() );

        }

    else if ( iType == EColumnNullDes16 )

        {

        aValue.Set( KNullDesC16().Ptr(), 0 );

        }

    else MMdCCommon::Panic( EDatabaseFault );

    }

inline TBool TColumn::IsNull()

    {

    return ( iType == EColumnNullDes8 ||

        iType == EColumnNullDes16  ||

        ( iData.iText.iPtr == NULL &&

          ( iType == EColumnDes8 || iType == EColumnDes16 ||

            iType == EColumnHBuf8 || iType == EColumnHBuf16 ) ) );

    }

// -----------------------------------

// RRowData

// -----------------------------------

inline RRowData::RRowData()

    : iColumns( 16 )

    {

    }

inline void RRowData::Close()

    {

    Free();

    iColumns.Close();

    }

inline void RRowData::Free()

    {

    const TInt count( Size() );

    for ( TInt i=0; i<count; ++i )

        {

        iColumns[i].Free();

        }

    }

inline TInt RRowData::Size() const

    {

    return iColumns.Count();

    }

inline TColumn& RRowData::Column( TInt aIndex )

    {

    return iColumns[aIndex];

    }

inline const TColumn& RRowData::Column( TInt aIndex ) const

    {

    return iColumns[aIndex];

    }

inline TColumn& RRowData::AppendL( const TColumn& aColumn )

    {

    iColumns.AppendL( aColumn );

    return iColumns[ Size()-1 ];

    }

inline void RRowData::Reset()

    {

    iColumns.Reset();

    }

inline void RRowData::AppendColumnTypesL( RRowData& aColumnTypeRow )

	{

	Free();

	Reset();

	const TInt columnCount = aColumnTypeRow.Size();

	ReserveL( columnCount );

	for( TInt i = 0; i < columnCount; i++ )

		{

	    iColumns.Append( aColumnTypeRow.Column( i ).Type() ); 

		}

	}

inline void RRowData::ReserveL( TInt aColumnCount )

	{

	iColumns.ReserveL( aColumnCount );

	}