diff -r 5cc91383ab1e -r 7333d7932ef7 secureswitools/swisistools/source/rscparser/barsread2.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/secureswitools/swisistools/source/rscparser/barsread2.cpp Tue Aug 31 15:21:33 2010 +0300 @@ -0,0 +1,346 @@ +// Copyright (c) 2009 - 2010 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: +// Resource reader +// +/** +* @file barsread2.cpp +* +* @internalComponent +* @released +*/ +#include +#include +#include "barsc2.h" +#include "barsread2.h" +#include "barsreadimpl.h" + +/** It creates the implementation in place - iImpl array, +and sets the default. +*/ +RResourceReader::RResourceReader() : + iRscBuffer(NULL) + { + new (iImpl) TResourceReaderImpl; + } + +/** The method calls RResourceReader::Close() method to release +allocated by the instance resources. +*/ +RResourceReader::~RResourceReader() + { + Close(); + } + +/** +Sets the buffer containing the resource data. + +The current position within the buffer is set to the start of the buffer so +that subsequent calls to the interpreting functions, for example ReadInt8L(), +start at the beginning of this buffer. +@param aRscFile A pointer to the CResourceFile object, used as a resource data supplier. +@param aResourceId Numeric id of the resource to be read. +*/ +void RResourceReader::OpenL(CResourceFile* aRscFile, TInt aResourceId) +{ + if (aRscFile) + { + Close(); + iRscBuffer = aRscFile->AllocReadL(aResourceId); + Impl()->SetBuffer(iRscBuffer); + } + else + { + std::string errMsg="Failed : Invalid Argument : CResourceFile* "; + throw CResourceFileException(errMsg); + } +} + +/** +Destroys the buffer containing the resource data. + +Open() method should be called if you want to set +the buffer and current position again. + +If a one or more copies of the same RResourceReader object exist - they share the same +resource data buffer. So destroying the RResourceReader object you will destroy the +shared resource data buffer. + +@post Buffer pointer is set to NULL. +@post Buffer current position pointer is set to NULL. +*/ +void RResourceReader::Close() + { + delete iRscBuffer; + iRscBuffer = NULL; + Impl()->ResetBuffer(); + } + +/** Interprets the data at the current buffer position as leading byte count data +and constructs an 8 bit non modifiable pointer to represent this data. + +The data is interpreted as: + +a byte value defining the number of text characters or the length of binary +data (the resource string/binary data length is limited to 255 characters max) + +followed by: + +the 8 bit text characters or binary data. + +If the value of the leading byte is zero, calling Length() on the returned +PtrC8 returns zero. + +The current position within the resource buffer is updated. + +Use this explicit 8 bit variant when the resource contains binary data. If +the resource contains text, then use the build independent variant ReadTPtrCL(). + +In general, this type of resource data corresponds to one of the following: + +a LTEXT type in a resource STRUCT declaration. + +a variable length array within a STRUCT declaration which includes the LEN +BYTE keywords. + +@pre Open() is called to initialize RResourceReader data members. +@return 8bit non modifiable pointer representing +the data following the leading byte count at the +current position within the resource buffer. +@post Current buffer position is updated. +@leave KErrEof The new buffer position is beyond the buffer end. */ +PtrC8* RResourceReader::ReadTPtrC8L() + { + return Impl()->ReadTPtrC8L(); + } + +/** Interprets the data at the current buffer position as leading byte count data +and constructs a 16 bit non modifiable pointer to represent this data. + +The data is interpreted as: + +a byte value defining the number of 16 bit text characters +(the resource string/binary data length is limited to 255 characters max) + +followed by: + +the 16 bit text characters. + +If the value of the leading byte is zero, calling Length() on the returned +PtrC16 returns zero. + +The current position within the resource buffer is updated. + +Do not use this explicit 16 bit variant when the resource contains binary +data; use the explicit 8 bit variant instead. If the resource contains text, +use the build independent variant ReadTPtrCL(). + +@pre Open() is called to initialize RResourceReader data members. +@return 16 bit non modifiable pointer representing +the data following the leading byte count at the +current position within the resource buffer. +@post Current buffer position is updated. +@leave KErrCorrupt The new buffer position is beyond the buffer end. */ + +PtrC16* RResourceReader::ReadTPtrC16L() + { + return Impl()->ReadTPtrC16L(); + } + + +/** Interprets the data at the current buffer position as a TInt8 type and returns +the value as a TInt. + +The current position within the resource buffer is updated. + +In general, a TInt8 corresponds to a BYTE type in a resource STRUCT declaration. + +Note that in Symbian OS, a TInt is at least as big as a TInt8. + +@pre Open() is called to initialize RResourceReader data members. +@return The TInt8 value taken from the resource buffer. +@post Current buffer position is updated. +@leave KErrEof The new buffer position is beyond the buffer end. */ +TInt RResourceReader::ReadInt8L() + { + return Impl()->ReadInt8L(); + } + +/** Interprets the data at the current buffer position as a TUint8 type and returns +the value as a TUint. + +The current position within the resource buffer is updated. + +In general, a TUint8 corresponds to a BYTE type in a resource STRUCT declaration. + +Note that in Symbian OS, a TUint is at least as big as a TUint8. + +@pre Open() is called to initialize RResourceReader data members. +@return The TUint8 value taken from the resource buffer. +@post Current buffer position is updated. +@leave KErrEof The new buffer position is beyond the buffer end. */ +TUint32 RResourceReader::ReadUint8L() + { + return Impl()->ReadUint8L(); + } + +/** Interprets the data at the current buffer position as a TInt16 type and returns +the value as a TInt. + +The current position within the resource buffer is updated. + +In general, a TInt16 corresponds to a WORD type in a resource STRUCT declaration. + +Note that in Symbian OS, a TInt is at least as big as a TInt16. + +@pre Open() is called to initialize RResourceReader data members. +@return The TInt16 value taken from the resource buffer. +@post Current buffer position is updated. +@leave KErrEof The new buffer position is beyond the buffer end. */ +TInt RResourceReader::ReadInt16L() + { + return Impl()->ReadInt16L(); + } + + +/** Interprets the data at the current buffer position as a TInt32 type and returns +the value as a TInt. + +The current position within the resource buffer is updated. + +In general, a TInt32 corresponds to a LONG type in a resource STRUCT declaration. + +Note that in Symbian OS, TInt and TInt32 are the same size. + +@pre Open() is called to initialize RResourceReader data members. +@return The TInt32 value taken from the resource buffer. +@post Current buffer position is updated. +@leave KErrEof The new buffer position is beyond the buffer end. */ +TInt RResourceReader::ReadInt32L() + { + return Impl()->ReadInt32L(); + } + +/** Interprets the data at the current buffer position as a TUint32 type and returns +the value as a TUint. + +The current position within the resource buffer is updated. + +In general, a TUint32 corresponds to a LONG type in a resource STRUCT declaration. + +Note that in Symbian OS a TUint is the same size as a TUint32. + +@pre Open() is called to initialize RResourceReader data members. +@return The TUint32 value taken from the resource buffer. +@post Current buffer position is updated. +@leave KErrEof The new buffer position is beyond the buffer end. */ +TUint32 RResourceReader::ReadUint32L() + { + return Impl()->ReadUint32L(); + } + +/** Copies a specified length of data from the resource buffer, starting at the +current position within the buffer, into the location pointed to by a specified +pointer. No assumption is made about the type of data at being read. + +The current position within the resource buffer is updated. + +@pre Open() is called to initialize RResourceReader data members. +@param aPtr Pointer to the target location for data copied from the resource buffer. +@param aLength The length of data to be copied from the resource buffer. +@post Current buffer position is updated. +@leave KErrEof The new buffer position is beyond the buffer end. */ +void RResourceReader::ReadL(TAny* aPtr,TInt aLength) + { + Impl()->ReadL(aPtr,aLength); + } + +/** Interprets the data at the current buffer position as leading byte count data +and constructs a build independent heap buffer 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 (the resource string/binary data length is limited to 255 characters max) + +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. + +Use this build independent variant when the resource contains text. If the +resource contains binary data, use the explicit 8 bit variant ReadHBufC8L(). + +@pre Open() is called to initialize RResourceReader data members. +@return Pointer to the heap buffer containing a copy of +the data following the leading byte count at the +current position within the resource buffer. The +pointer can be NULL. +@post Current buffer position is updated. +@leave KErrCorrupt The resulting position lies beyond the end of the resource buffer. */ +Ptr16* RResourceReader::ReadHBufCL() + { + return Impl()->ReadHBufCL(); + } + +/** Interprets the data at the current buffer position as leading byte count data +and constructs a non modifiable pointer to represent this data. + +The data is interpreted as: + +a byte value defining the number of text characters or the length of binary +data (the resource string/binary data length is limited to 255 characters max) + +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. + +Use this build independent variant when the resource contains text. If the +resource contains binary data, use the explicit 8 bit variant ReadTPtrC8L(). + +@pre Open() is called to initialize RResourceReader data members. +@return Non modifiable pointer representing the +data following the leading byte count of the element +at the specified position within the array. +@post Current buffer position is updated. +@leave KErrCorrupt The resulting position lies beyond the end of the resource buffer. */ +PtrC16* RResourceReader::ReadTPtrCL() + { + return ReadTPtrC16L(); + } + +/** @internalComponent +@return Non-const pointer to the implementation object. */ +TResourceReaderImpl* RResourceReader::Impl() + { + return reinterpret_cast (iImpl); + } + +/** @internalComponent +@return Const pointer to the implementation object. */ +const TResourceReaderImpl* RResourceReader::Impl() const + { + return reinterpret_cast (iImpl); + } +