diff -r 000000000000 -r e4d67989cc36 lowlevellibsandfws/apputils/inc/BARSREAD.H --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lowlevellibsandfws/apputils/inc/BARSREAD.H Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,280 @@ +// Copyright (c) 1997-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 __BARSREAD_H__ +#define __BARSREAD_H__ + +#include +#include + +class TResourceReaderImpl; + +/** +Interprets resource data read from a resource file. + +To use an instance of this class, pass the buffer containing the resource +data to it by calling SetBuffer(). + +The buffer containing the resource data is created by RResourceFile::AllocReadLC() or +RResourceFile::AllocReadL() which reads the specified resource into it. + +The current position within the buffer is always maintained and any request +for data is always supplied from the current position. The current position +is always updated . + +@see TResourceReader::SetBuffer() +@see RResourceFile::AllocReadL() +@see RResourceFile::AllocReadLC() +@publishedAll +@released +*/ +class TResourceReader + { +public: + IMPORT_C void SetBuffer(const TDesC8* aBuffer); + IMPORT_C const TAny* Ptr(); + + // Read counted strings into allocated buffer + inline HBufC* ReadHBufCL(); + IMPORT_C HBufC8* ReadHBufC8L(); + IMPORT_C HBufC16* ReadHBufC16L(); + + // Build pointer from a counted string + inline TPtrC ReadTPtrC(); + IMPORT_C TPtrC8 ReadTPtrC8(); + IMPORT_C TPtrC16 ReadTPtrC16(); + + // Build pointer from a counted string in an array of counted strings, + // also setting the buffer to be used. + inline TPtrC ReadTPtrC(TInt aIndex,const TDesC8* aBuffer); + IMPORT_C TPtrC8 ReadTPtrC8(TInt aIndex,const TDesC8* aBuffer); + IMPORT_C TPtrC16 ReadTPtrC16(TInt aIndex,const TDesC8* aBuffer); + + // Build an array of strings from a resource array + inline CDesCArrayFlat* ReadDesCArrayL(); + IMPORT_C CDesC8ArrayFlat* ReadDesC8ArrayL(); + IMPORT_C CDesC16ArrayFlat* ReadDesC16ArrayL(); + + IMPORT_C TInt ReadInt8(); + IMPORT_C TUint ReadUint8(); + IMPORT_C TInt ReadInt16(); + IMPORT_C TUint ReadUint16(); + IMPORT_C TInt ReadInt32(); + IMPORT_C TUint ReadUint32(); + IMPORT_C TReal64 ReadReal64() __SOFTFP; + + IMPORT_C void Read(TAny* aPtr,TInt aLength); + IMPORT_C void Rewind(TInt aLength); + IMPORT_C void Advance(TInt aLength); + +private: + void CreateImpl(); + TResourceReaderImpl* Impl(); + const TResourceReaderImpl* Impl() const; + + TPtrC8 ReadTPtrC8L(); + TPtrC16 ReadTPtrC16L(); + TPtrC8 ReadTPtrC8L(TInt aIndex,const TDesC8* aBuffer); + TPtrC16 ReadTPtrC16L(TInt aIndex,const TDesC8* aBuffer); + TInt ReadInt8L(); + TUint ReadUint8L(); + TInt ReadInt16L(); + TUint ReadUint16L(); + TInt ReadInt32L(); + TUint ReadUint32L(); + TReal64 ReadReal64L() __SOFTFP; + +private: + enum + { + KRsReaderSize = 12 + }; + TUint8 iImpl[KRsReaderSize]; + }; + +#if defined(_UNICODE) + +/** +Interprets the data at the current buffer position as leading byte count data +and constructs a build independent heap descriptor containing a copy of this +data. + +The data is interpreted as: + +a byte value defining the number of text characters or the length of binary +data + +followed by: + +the text characters or binary data. This resource data is interpreted as either +8-bit or 16-bit, depending on the build. + +If the value of the leading byte is zero, the function assumes that no data +follows the leading byte and returns a NULL pointer. + +The current position within the resource buffer is updated. If the resulting +position lies beyond the end of the resource buffer, then the function raises +a BAFL 4 panic. + +Use this build independent variant when the resource contains text. If the +resource contains binary data, use the explicit 8-bit variant ReadHBufC8L(). + +@return A pointer to the heap descriptor containing a copy of the data following +the leading byte count at the current position within the resource buffer. +The pointer can be NULL. +*/ +inline HBufC* TResourceReader::ReadHBufCL() + { + return ReadHBufC16L(); + } + +/** +Interprets the data at the current buffer position as leading byte count data +and constructs a non modifiable pointer descriptor to represent this data. + +The data is interpreted as: + +a byte value defining the number of text characters or the length of binary +data + +followed by: + +the text characters or binary data. This resource data is interpreted as either +8-bit or 16-bit, depending on the build. + +If the value of the leading byte is zero, calling Length() on the returned +TPtrC returns zero. + +The current position within the resource buffer is updated. If the resulting +position lies beyond the end of the resource buffer, then the function raises +a BAFL 4 panic. + +Use this build independent variant when the resource contains text. If the +resource contains binary data, use the explicit 8-bit variant ReadTPtrC8(). + +@return A non modifiable pointer descriptor representing the data following +the leading byte count at the current position within the resource buffer. +*/ +inline TPtrC TResourceReader::ReadTPtrC() + { + return ReadTPtrC16(); + } + +/** +Interprets the data within the specified resource buffer as an array of leading +byte count data and constructs a non modifiable pointer descriptor to represent +an element within this array. + +The function sets the buffer containing the resource data and sets the current +position to the start of this buffer. Any buffer set by a previous call to +SetBuffer() etc, is lost. + +The buffer is expected to contain an array of data elements preceded by a +TInt16 value defining the number of elements within that array. + +Each element of the array is interpreted as: + +a byte value defining the number of text characters or the length of binary +data + +followed by: + +the text characters or binary data. This resource data is interpreted as either +8-bit or 16-bit, depending on the build. + +If the value of the leading byte is zero, calling Length() on the returned +TPtrC returns zero. + +The current position within the resource buffer is updated. If the resulting +position lies beyond the end of the resource buffer, then the function raises +a BAFL 4 panic. + +Use this build independent variant when the elements contain text. If the +elements contain binary data, use the explicit 8-bit variant ReadTPtrC8(TInt,const TDesC8*). + +@param aIndex The position of the element within the array. This value is +relative to zero. +@param aBuffer The buffer containing the resource data. +@return A non modifiable pointer descriptor representing the data following +the leading byte count of the element at the specified position within the +array. +*/ +inline TPtrC TResourceReader::ReadTPtrC(TInt aIndex,const TDesC8* aBuffer) + { + return ReadTPtrC16(aIndex, aBuffer); + } + +/** +Interprets the data at the current buffer position as an array of leading byte +count data and constructs a build independent flat array of descriptors. + +Each descriptor in the descriptor array corresponds to an element of the resource +array. + +At the current buffer position, the buffer is expected to contain an array +of data elements preceded by a TInt16 value defining the number of elements +within that array. + +Each element of the array is interpreted as: + +a byte value defining the number of text characters or the length of binary +data + +followed by: + +the text characters or binary data. This resource data is interpreted as either +8-bit or 16-bit, depending on the build. + +The current position within the resource buffer is updated. If the resulting +position lies beyond the end of the resource buffer, then the function raises +a BAFL 4 panic. + +Use this build independent variant when the elements contain text. If the +elements contain binary data, use the explicit 8-bit variant ReadDesC8ArrayL(). + +@return A pointer to a build independent flat descriptor array. +*/ +inline CDesCArrayFlat* TResourceReader::ReadDesCArrayL() + { + return ReadDesC16ArrayL(); + } + +#else // defined(_UNICODE) + +inline HBufC* TResourceReader::ReadHBufCL() + { + return ReadHBufC8L(); + } + +inline TPtrC TResourceReader::ReadTPtrC() + { + return ReadTPtrC8(); + } + +inline TPtrC TResourceReader::ReadTPtrC(TInt aIndex,const TDesC8* aBuffer) + { + return ReadTPtrC8(aIndex, aBuffer); + } + +inline CDesCArrayFlat* TResourceReader::ReadDesCArrayL() + { + return ReadDesC8ArrayL(); + } + +#endif// defined(_UNICODE) + + + +#endif//__BARSREAD_H__