// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members
// which accompanies this distribution, and is available
// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

/** ClearAllFields */
inline void RDataBuilderBase::ClearAllFields()
	{DataBuilderFuncs::ClearAllFields(*this);}

/**
Returns if Data Builder Element Exists
@param aIndex id of element we are interested in
@return ETrue if element exists, EFalse otherwise 
 */
inline TBool RDataBuilderArrayBase::ElementExists(const TInt& aIndex) const
	{return DataBuilderFuncs::FieldExists(*this, aIndex);}

/**
Clears builder array element
@param aIndex id of element we wish to clear
 */	
inline void RDataBuilderArrayBase::ClearElement(const TInt& aIndex)
	{DataBuilderFuncs::ClearField(*this, aIndex);}


template<typename T, typename Base>
/**
RDataBuilder field exists implementation
@param aFieldId id of field we are interested in
@return TBool if exists
 */	
inline TBool RDataBuilder<T, Base>::FieldExists(const typename T::TFieldId& aFieldId) const
	{return DataBuilderFuncs::FieldExists(*this, static_cast<TInt>(aFieldId));}


template<typename T, typename Base>
/**
RDataBuilder field exists implementation
@param aFieldId id of field we are interested in
@return TBool if exists
 */	
inline TBool RDataBuilder<T, Base>::IsDataAvailable() const
	{return DataBuilderFuncs::AnyFieldExists(*this);}



template<typename T, typename Base>
/**
RDataBuilder clear field exists
@param aFieldId id of field we are interested in
 */
inline void RDataBuilder<T, Base>::ClearField(const typename T::TFieldId& aFieldId)
	{DataBuilderFuncs::ClearField(*this, static_cast<TInt>(aFieldId));}

template<typename T, typename Base>
/**
RDataBuilder array builder implementation
@param aFieldId id of field we are interested in
@param aArrayBuilder array  we are interested in
 */
inline void RDataBuilder<T, Base>::GetArrayBuilder(const typename T::TFieldId& aFieldId, RDataBuilderArrayBase& aArrayBuilder)
	{DataBuilderFuncs::GetFieldBuilder(*this, static_cast<TInt>(aFieldId), static_cast<RDataBuilderBase&>(aArrayBuilder));}

template<typename T, typename BuilderBase>
template<typename S>
/**
RDataBuilder field exists implementation
@param aFieldId id of field we are interested in
@param aDataBuilder field we are interested in
 */
inline void RDataBuilder<T, BuilderBase>::GetFieldBuilder(const typename T::TFieldId& aFieldId, RDataBuilder<S, RDataBuilderBase>& aDataBuilder)
	{DataBuilderFuncs::GetFieldBuilder(*this, static_cast<TInt>(aFieldId), static_cast<RDataBuilderBase&>(aDataBuilder));}
	
template<typename T>
/**
Set array element
@param aIndex id of element we are interested in
@param aData data to set in field we are interested in
 */
inline void RDataBuilderArray<T>::SetElement(const TInt& aIndex, const T& aData)
	{DataBuilderFuncs::SetField(*this, aIndex, aData);}

template<typename T>
/**
GetFieldBuilder field
@param aIndex index of field we are interested in
@param aDataBuilder data builder field we are interested in
 */
inline void RDataBuilderArray<T>::GetFieldBuilder(const TInt& aIndex, RDataBuilder<T, RDataBuilderBase>& aDataBuilder)
	{DataBuilderFuncs::GetFieldBuilder(*this, aIndex, aDataBuilder);}
	
template<typename T, typename BuilderBase>
template<typename S>
/**
Sets field in DataBuilder
@param aFieldId index of field we are interested in
@param aData data to set in field we are interested in
 */
inline void RDataBuilder<T, BuilderBase>::SetField(const typename T::TFieldId& aFieldId, const S& aData)
	{DataBuilderFuncs::SetField(*this, aFieldId, aData);}

/**
Returns maximum entries
@return Count within array
 */
inline TInt RDataBuilderArrayBase::MaxCount() const
	{return DataBuilderFuncs::MaxCount(*this);}
	
/////////////////////////////////

template<typename T, typename Base>

/**
Returns true if Data Builder Field Exists
@param aFieldId id of field we are interested in
@return ETrue if field exists, EFalse otherwise 
 */
inline TBool RDataReader<T, Base>::FieldExists(const typename T::TFieldId& aFieldId) const
	{return DataReaderFuncs::FieldExists(*this, static_cast<TInt>(aFieldId));}


template<typename T, typename Base>
/**
Returns true if any field exists in the Reader
@param aFieldId id of field we are interested in
@return TBool if exists
 */	
inline TBool RDataReader<T, Base>::IsDataAvailable() const
	{return DataReaderFuncs::AnyFieldExists(*this);}


template<typename T>
/**
Get array element
@param aIndex index of element we are interested in
@param aData data to read in field we are interested in
@return Standard Symbian Error code
 */
inline TInt RDataReaderArray<T>::GetElement(const TInt& aIndex, T& aData) const
	{return DataReaderFuncs::GetField(*this, aIndex, aData);}

template<typename T>
/**
GetFieldReader field exists implementation
@param aIndexid index of field we are interested in
@param aDataReader data reader we are interested in
@return Standard Symbian Error code
 */
inline TInt RDataReaderArray<T>::GetFieldReader(const TInt& aIndex, RDataReader<T, RDataReaderBase>& aDataReader) const
	{return DataReaderFuncs::GetFieldReader(*this, aIndex, aDataReader);}

template<typename T, typename BuilderBase>
template<typename S>
/**
GetField field exists implementation
@param aFieldId index of field we are interested in
@param aData data from reader we are interested in
@return field Id
 */
inline TInt RDataReader<T, BuilderBase>::GetField(const typename T::TFieldId& aFieldId, S& aData) const
	{return DataReaderFuncs::GetField(*this, aFieldId, aData);}

/**
Returns if element exists
@param aIndex index of exists we are interested in
@return ETrue if element exists, EFalse otherwise 
 */	
inline TBool RDataReaderArrayBase::ElementExists(const TInt& aIndex) const
	{return DataReaderFuncs::FieldExists(*this, aIndex);}

template<typename T, typename ReaderBase>

/**
ArrayReader array reader implementation
@param aFieldId id of field we are interested in
@param aArrayBuilder array  we are interested in
@return returns id
 */
inline TInt RDataReader<T, ReaderBase>::GetArrayReader(const typename T::TFieldId& aFieldId, RDataReaderArrayBase& aArrayReader) const
	{return DataReaderFuncs::GetFieldReader(*this, static_cast<TInt>(aFieldId), static_cast<RDataReaderBase&>(aArrayReader));}

template<typename T, typename ReaderBase>
template<typename S>
/**
FieldReader implementation
@param aFieldId id of field we are interested in
@param aDataReader we are interested in
@return returns id
 */
inline TInt RDataReader<T, ReaderBase>::GetFieldReader(const typename T::TFieldId& aFieldId, RDataReader<S, RDataReaderBase>& aDataReader) const
	{return DataReaderFuncs::GetFieldReader(*this, static_cast<TInt>(aFieldId), static_cast<RDataReaderBase&>(aDataReader));}

/**
Returns maximum entries
@return Count within reader array
 */	
inline TInt RDataReaderArrayBase::MaxCount() const
	{return DataReaderFuncs::MaxCount(*this);}