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