// Copyright (c) 2008-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 "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:
// f32\inc\f32file64.inl
//
//
/**
Reads from the file at the current position.
This is a synchronous function.
Note that when an attempt is made to read beyond the end of the file,
no error is returned.
The descriptor's length is set to the number of bytes read into
it. Therefore, when reading through a file,the end of file has been reached
when the descriptor length, as returned by TDesC8::Length(), is zero.
@param aDes Descriptor into which binary data is read. Any existing contents
are overwritten. On return, its length is set to the number of
bytes read.
@return KErrNone if successful, otherwise one of the other system-wide error
codes.
@see TDesC8::Length
*/
inline TInt RFile64::Read(TDes8& aDes) const
{return RFile::Read(aDes);}
/**
Reads from the file at the current position.
This is an asynchronous function.
Note that when an attempt is made to read beyond the end of the file,
no error is returned.
The descriptor's length is set to the number of bytes read into
it. Therefore, when reading through a file,the end of file has been reached
when the descriptor length, as returned by TDesC8::Length(), is zero.
@param aDes Descriptor into which binary data is read. Any existing contents
are overwritten. On return, its length is set to the number of
bytes read.
NB: this function is asynchronous and the request that it
represents may not complete until some time after the call
to the function has returned. It is important, therefore, that
this descriptor remain valid, or remain in scope, until you have
been notified that the request is complete.
@param aStatus Request status. On completion contains:
KErrNone, if successful, otherwise one of the other system-wide error codes.
@see TDesC8::Length
*/
inline void RFile64::Read(TDes8& aDes,TRequestStatus& aStatus) const
{RFile::Read(aDes, aStatus);}
/**
Reads the specified number of bytes of binary data from the file at the current position.
This is a synchronous function.
Note that when an attempt is made to read beyond the end of the file,
no error is returned.
The descriptor's length is set to the number of bytes read into
it. Therefore, when reading through a file,the end of file has been reached
when the descriptor length, as returned by TDesC8::Length(), is zero.
Assuming aLength is less than the maximum length of the descriptor, the only circumstance
in which Read() can return fewer bytes than requested, is when the end of
file is reached or if an error occurs.
@param aDes Descriptor into which binary data is read. Any existing
contents are overwritten. On return, its length is set to
the number of bytes read.
@param aLength The number of bytes to be read from the file into the descriptor.
If an attempt is made to read more bytes than the descriptor's
maximum length, the function returns KErrOverflow.
This value must not be negative, otherwise the function
returns KErrArgument.
@return KErrNone if successful, otherwise one of the other system-wide error
codes.
*/
inline TInt RFile64::Read(TDes8& aDes,TInt aLength) const
{return RFile::Read(aDes, aLength);}
/**
Reads a specified number of bytes of binary data from the file at the current position.
This is an asynchronous function.
Note that when an attempt is made to read beyond the end of the file,
no error is returned.
The descriptor's length is set to the number of bytes read into it.
Therefore, when reading through a file, the end of file has been reached
when the descriptor length, as returned by TDesC8::Length(), is zero.
Assuming aLength is less than the maximum length of the descriptor, the only
circumstances in which Read() can return fewer bytes than requested is when
the end of file is reached or if an error has occurred.
@param aDes Descriptor into which binary data is read. Any existing
contents are overwritten. On return, its length is set to the
number of bytes read.
NB: this function is asynchronous and the request that it
represents may not complete until some time after the call
to the function has returned. It is important, therefore, that
this descriptor remain valid, or remain in scope, until you have
been notified that the request is complete.
@param aLength The number of bytes to be read from the file into the descriptor.
If an attempt is made to read more bytes than the descriptor's
maximum length, then the function updates aStatus parameter with KErrOverflow.
It must not be negative otherwise the function updates aStatus with KErrArgument.
@param aStatus Request status. On completion contains KErrNone if successful,
otherwise one of the other system-wide error codes.
*/
inline void RFile64::Read(TDes8& aDes,TInt aLength,TRequestStatus& aStatus) const
{ RFile::Read( aDes, aLength, aStatus);}
/**
Writes to the file at the current offset within the file.
This is a synchronous function.
@param aDes The descriptor from which binary data is written.
The function writes the entire contents of aDes to the file.
@return KErrNone if successful, otherwise one of the other system-wide error
codes.
*/
inline TInt RFile64::Write(const TDesC8& aDes)
{return RFile::Write(aDes);}
/**
Writes to the file at the current offset within the file.
This is an asynchronous function.
@param aDes The descriptor from which binary data is written.
The function writes the entire contents of aDes to the file.
NB: this function is asynchronous and the request that it
represents may not complete until some time after the call
to the function has returned. It is important, therefore, that
this descriptor remain valid, or remain in scope, until you have
been notified that the request is complete.
@param aStatus Request status. On completion contains KErrNone if successful,
otherwise one of the other system-wide error codes.
*/
inline void RFile64::Write(const TDesC8& aDes,TRequestStatus& aStatus)
{RFile::Write(aDes, aStatus);}
/**
Writes a portion of a descriptor to the file at the current offset within
the file.
This is a synchronous function.
@param aDes The descriptor from which binary data is written.
@param aLength The number of bytes to be written from the descriptor.
This must not be greater than the length of the descriptor.
It must not be negative.
@return KErrNone if successful; KErrArgument if aLength is negative;
otherwise one of the other system-wide error codes.
@panic FSCLIENT 27 in debug mode, if aLength is greater than the length
of the descriptor aDes.
*/
inline TInt RFile64::Write(const TDesC8& aDes,TInt aLength)
{return RFile::Write(aDes, aLength);}
/**
Writes a portion of a descriptor to the file at the current offset
within the file.
This is an asynchronous function.
@param aDes The descriptor from which binary data is written.
NB: this function is asynchronous and the request that it
represents may not complete until some time after the call
to the function has returned. It is important, therefore, that
this descriptor remain valid, or remain in scope, until you have
been notified that the request is complete.
@param aLength The number of bytes to be written from the descriptor.
This must not be greater than the length of the descriptor.
It must not be negative.
@param aStatus Request status. On completion contains KErrNone if successful;
KErrArgument if aLength is negative;
otherwise one of the other system-wide error codes.
*/
inline void RFile64::Write(const TDesC8& aDes,TInt aLength,TRequestStatus& aStatus)
{RFile::Write(aDes, aLength, aStatus);}
/**
Reads from the file at the specified offset within the file
This is a synchronous function.
Note that when an attempt is made to read beyond the end of the file,
no error is returned.
The descriptor's length is set to the number of bytes read into it.
Therefore, when reading through a file, the end of file has been reached
when the descriptor length, as returned by TDesC8::Length(), is zero.
Note:
1. This function over-rides the base class function RFile::Read
and inlines the base class RFile::Read.
2. The difference is that this function can read beyond 2GB - 1 when
aPos + length of aDes is beyond 2GB - 1.
3. This function is protected using _F32_STRICT_64_BIT_MIGRATION macro
to help migration to 64 bit file addressing. When the macro is defined,
this function becomes a private overload and hence use of
TInt RFile64::Read(TInt64 aPos,TDes8& aDes) const is recommended.
@see TInt RFile::Read(TInt aPos,TDes8& aDes) const
@see TInt RFile64::Read(TInt64 aPos,TDes8& aDes) const
@param aPos Position of first byte to be read. This is an offset from
the start of the file. If no position is specified, reading
begins at the current file position.
If aPos is beyond the end of the file, the function returns
a zero length descriptor.
@param aDes The descriptor into which binary data is read. Any existing content
is overwritten. On return, its length is set to the number of
bytes read.
@return KErrNone if successful, otherwise one of the other system-wide error
codes.
@panic FSCLIENT 19 if aPos is negative.
*/
inline TInt RFile64::Read(TInt aPos,TDes8& aDes) const
{return RFile::Read(aPos, aDes);}
/**
Reads from the file at the specified offset within the file.
This is an asynchronous function.
Note that when an attempt is made to read beyond the end of the file,
no error is returned.
The descriptor's length is set to the number of bytes read into it.
Therefore, when reading through a file, the end of file has been reached
when the descriptor length, as returned by TDesC8::Length(), is zero.
Note:
1. This function over-rides the base class function RFile::Read
and inlines the base class RFile::Read.
2. The difference is that this function can read beyond 2GB - 1 when
aPos + length of aDes is beyond 2GB - 1.
3. This function is protected using _F32_STRICT_64_BIT_MIGRATION macro
to help migration to 64 bit file addressing. When the macro is defined,
this function becomes a private overload and hence use of
void RFile64::Read(TInt64 aPos,TDes8& aDes,TRequestStatus& aStatus) const is recommended.
@see void RFile::Read(TInt aPos,TDes8& aDes,TRequestStatus& aStatus) const
@see void RFile64::Read(TInt64 aPos,TDes8& aDes,TRequestStatus& aStatus) const
@param aPos Position of first byte to be read. This is an offset from
the start of the file. If no position is specified,
reading begins at the current file position.
If aPos is beyond the end of the file, the function returns
a zero length descriptor.
@param aDes The descriptor into which binary data is read. Any existing
content is overwritten. On return, its length is set to
the number of bytes read.
NB: this function is asynchronous and the request that it
represents may not complete until some time after the call
to the function has returned. It is important, therefore, that
this descriptor remain valid, or remain in scope, until you have
been notified that the request is complete.
@param aStatus The request status. On completion, contains an error code of KErrNone
if successful, otherwise one of the other system-wide error codes.
@panic FSCLIENT 19 if aPos is negative.
*/
inline void RFile64::Read(TInt aPos,TDes8& aDes,TRequestStatus& aStatus) const
{RFile::Read(aPos, aDes, aStatus);}
/**
Reads the specified number of bytes of binary data from the file at a specified
offset within the file.
This is a synchronous function.
Note that when an attempt is made to read beyond the end of the file,
no error is returned.
The descriptor's length is set to the number of bytes read into it.
Therefore, when reading through a file, the end of file has been reached
when the descriptor length, as returned by TDesC8::Length(), is zero.
Assuming aLength is less than the maximum length of the descriptor, the only
circumstances in which Read() can return fewer bytes than requested is when
the end of file is reached or if an error has occurred.
Note:
1. This function over-rides the base class function RFile::Read
and inlines the base class RFile::Read.
2. The difference is that this function can read beyond 2GB - 1 when
aPos + aLength is beyond 2GB - 1.
3. This function is protected using _F32_STRICT_64_BIT_MIGRATION macro
to help migration to 64 bit file addressing. When the macro is defined,
this function becomes a private overload and hence use of
TInt RFile64::Read(TInt64 aPos,TDes8& aDes,TInt aLength) const is recommended.
@see TInt RFile::Read(TInt aPos,TDes8& aDes,TInt aLength) const
@see TInt RFile64::Read(TInt64 aPos,TDes8& aDes,TInt aLength) const
@param aPos Position of first byte to be read. This is an offset from
the start of the file. If no position is specified,
reading begins at the current file position.
If aPos is beyond the end of the file, the function returns
a zero length descriptor.
@param aDes The descriptor into which binary data is read. Any existing
contents are overwritten. On return, its length is set to
the number of bytes read.
@param aLength The number of bytes to read from the file into the descriptor.
If an attempt is made to read more bytes than the descriptor's
maximum length, then the function updates aStatus parameter with KErrOverflow.
It must not be negative otherwise the function updates aStatus with KErrArgument.
@return KErrNone if successful, otherwise one of the other system-wide
error codes.
@panic FSCLIENT 19 if aPos is negative.
*/
inline TInt RFile64::Read(TInt aPos,TDes8& aDes,TInt aLength) const
{return RFile::Read(aPos, aDes, aLength);}
/**
Reads the specified number of bytes of binary data from the file at a specified
offset within the file.
This is an asynchronous function.
Note that when an attempt is made to read beyond the end of the file,
no error is returned.
The descriptor's length is set to the number of bytes read into it.
Therefore, when reading through a file, the end of file has been reached
when the descriptor length, as returned by TDesC8::Length(), is zero.
Assuming aLength is less than the maximum length of the descriptor, the only
circumstances in which Read() can return fewer bytes than requested is when
the end of file is reached or if an error has occurred.
Note:
1. This function over-rides the base class function RFile::Read
and inlines the base class RFile::Read.
2. The difference is that this function can read beyond 2GB - 1 when
aPos + aLength is beyond 2GB - 1.
3. This function is protected using _F32_STRICT_64_BIT_MIGRATION macro
to help migration to 64 bit file addressing. When the macro is defined,
this function becomes a private overload and hence use of
void RFile64::Read(TInt64 aPos,TDes8& aDes,TInt aLength,TRequestStatus& aStatus) const is recommended.
@see void RFile::Read(TInt aPos,TDes8& aDes,TInt aLength,TRequestStatus& aStatus) const
@see void RFile64::Read(TInt64 aPos,TDes8& aDes,TInt aLength,TRequestStatus& aStatus) const
@param aPos Position of first byte to be read. This is an offset from
the start of the file. If no position is specified,
reading begins at the current file position.
If aPos is beyond the end of the file, the function returns
a zero length descriptor.
@param aDes The descriptor into which binary data is read. Any existing
contents are overwritten. On return, its length is set to
the number of bytes read.
NB: this function is asynchronous and the request that it
represents may not complete until some time after the call
to the function has returned. It is important, therefore, that
this descriptor remain valid, or remain in scope, until you have
been notified that the request is complete.
@param aLength The number of bytes to read from the file into the descriptor.
If an attempt is made to read more bytes than the descriptor's
maximum length, then the function returns KErrOverflow.
It must not be negative otherwise the function returns KErrArgument.
@param aStatus Request status. On completion contains KErrNone if successful,
otherwise one of the other system-wide error codes.
@panic FSCLIENT 19 if aPos is negative.
*/
inline void RFile64::Read(TInt aPos,TDes8& aDes,TInt aLength,TRequestStatus& aStatus) const
{ RFile::Read(aPos, aDes, aLength, aStatus);}
/**
Writes to the file at the specified offset within the file
This is a synchronous function.
Note:
1. This function over-rides the base class function RFile::Write
and inlines the base class RFile::Write.
2. The difference is that this function can write beyond 2GB - 1 when
aPos + length of aDes is beyond 2GB - 1.
3. This function is protected using _F32_STRICT_64_BIT_MIGRATION macro
to help migration to 64 bit file addressing. When the macro is defined,
this function becomes a private overload and hence use of
TInt RFile64::Write(TInt64 aPos,const TDesC8& aDes) is recommended.
@see TInt RFile::Write(TInt aPos,const TDesC8& aDes)
@see TInt RFile64::Write(TInt64 aPos,const TDesC8& aDes)
@param aPos The offset from the start of the file at which the first
byte is written.
If a position beyond the end of the file is specified, then
the write operation begins at the end of the file.
If the position has been locked, then the write fails.
@param aDes The descriptor from which binary data is written. The function writes
the entire contents of aDes to the file.
@return KErrNone if successful, otherwise one of the other system-wide error
codes.
@panic FSCLIENT 19 if aPos is negative.
*/
inline TInt RFile64::Write(TInt aPos,const TDesC8& aDes)
{return RFile::Write( aPos, aDes);}
/**
Writes to the file at the specified offset within the file
This is an asynchronous function.
Note:
1. This function over-rides the base class function RFile::Write
and inlines the base class RFile::Write.
2. The difference is that this function can write beyond 2GB - 1 when
aPos + length of aDes is beyond 2GB - 1.
3. This function is protected using _F32_STRICT_64_BIT_MIGRATION macro
to help migration to 64 bit file addressing. When the macro is defined,
this function becomes a private overload and hence use of
void RFile64::Write(TInt64 aPos,const TDesC8& aDes,TRequestStatus& aStatus) is recommended.
@see void RFile::Write(TInt aPos,const TDesC8& aDes,TRequestStatus& aStatus)
@see void RFile64::Write(TInt64 aPos,const TDesC8& aDes,TRequestStatus& aStatus)
@param aPos The offset from the start of the file at which the first
byte is written.
If a position beyond the end of the file is specified, then
the write operation begins at the end of the file.
If the position has been locked, then the write fails.
@param aDes The descriptor from which binary data is written. The function
writes the entire contents of aDes to the file.
NB: this function is asynchronous and the request that it
represents may not complete until some time after the call
to the function has returned. It is important, therefore, that
this descriptor remain valid, or remain in scope, until you have
been notified that the request is complete.
@param aStatus Request status. On completion contains KErrNone if successful,
otherwise one of the other system-wide error codes.
@panic FSCLIENT 19 if aPos is negative.
*/
inline void RFile64::Write(TInt aPos,const TDesC8& aDes,TRequestStatus& aStatus)
{RFile::Write(aPos, aDes, aStatus);}
/**
Writes the specified number of bytes to the file at the specified offset within the file.
This is a synchronous function.
Note:
1. This function over-rides the base class function RFile::Write
and inlines the base class RFile::Write.
2. The difference is that this function can write beyond 2GB - 1 when
aPos + aLength is beyond 2GB - 1.
3. This function is protected using _F32_STRICT_64_BIT_MIGRATION macro
to help migration to 64 bit file addressing. When the macro is defined,
this function becomes a private overload and hence use of
TInt RFile64::Write(TInt64 aPos,const TDesC8& aDes,TInt aLength) is recommended.
@see TInt RFile::Write(TInt aPos,const TDesC8& aDes,TInt aLength)
@see TInt RFile64::Write(TInt64 aPos,const TDesC8& aDes,TInt aLength)
@param aPos The offset from the start of the file at which the first
byte is written.
If a position beyond the end of the file is specified, then
the write operation begins at the end of the file.
If the position has been locked, then the write fails.
@param aDes The descriptor from which binary data is written.
@param aLength The number of bytes to be written from aDes .
It must not be negative.
@return KErrNone if successful; KErrArgument if aLength is negative;
otherwise one of the other system-wide error codes.
@panic FSCLIENT 19 if aPos is negative.
*/
inline TInt RFile64::Write(TInt aPos,const TDesC8& aDes,TInt aLength)
{return RFile::Write(aPos, aDes, aLength);}
/**
Writes the specified number of bytes to the file at the specified offset within the file.
This is an asynchronous function.
Note:
1. This function over-rides the base class function RFile::Write
and inlines the base class RFile::Write.
2. The difference is that this function can write beyond 2GB - 1 when
aPos + aLength is beyond 2GB - 1.
3. This function is protected using _F32_STRICT_64_BIT_MIGRATION macro
to help migration to 64 bit file addressing. When the macro is defined,
this function becomes a private overload and hence use of
void RFile64::Write(TInt64 aPos,const TDesC8& aDes,TRequestStatus& aStatus) is recommended.
@see void RFile::Write(TInt aPos,const TDesC8& aDes,TRequestStatus& aStatus)
@see void RFile64::Write(TInt64 aPos,const TDesC8& aDes,TRequestStatus& aStatus)
@param aPos The offset from the start of the file at which the first
byte is written.
If a position beyond the end of the file is specified, then
the write operation begins at the end of the file.
If the position has been locked, then the write fails.
@param aDes The descriptor from which binary data is written.
NB: this function is asynchronous and the request that it
represents may not complete until some time after the call
to the function has returned. It is important, therefore, that
this descriptor remain valid, or remain in scope, until you have
been notified that the request is complete.
@param aLength The number of bytes to be written from aDes.
It must not be negative.
@param aStatus Request status. On completion contains KErrNone if successful;
KErrArgument if aLength is negative;
otherwise one of the other system-wide error codes.
@panic FSCLIENT 19 if aPos is negative.
*/
inline void RFile64::Write(TInt aPos,const TDesC8& aDes,TInt aLength,TRequestStatus& aStatus)
{RFile::Write(aPos, aDes, aLength, aStatus);}