diff -r 000000000000 -r bde4ae8d615e os/kernelhwsrv/userlibandfileserver/fileserver/inc/f32file64.inl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/kernelhwsrv/userlibandfileserver/fileserver/inc/f32file64.inl Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,562 @@ +// 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);}