1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
/* This file is (c) 2008-2010 Konstantin Isakov <ikm@users.berlios.de>
* Part of GoldenDict. Licensed under GPLv3 or later, see the LICENSE file */
#ifndef __FILE_HH_INCLUDED__
#define __FILE_HH_INCLUDED__
#include <cstdio>
#include <string>
#include "ex.hh"
/// A simple wrapper over FILE * operations with added write-buffering,
/// used for non-Qt parts of code.
/// It is possible to ifdef implementation details for some platforms.
namespace File {
DEF_EX( Ex, "File exception", std::exception )
DEF_EX_STR( exCantOpen, "Can't open", Ex )
DEF_EX( exReadError, "Error reading from the file", Ex )
DEF_EX( exWriteError, "Error writing to the file", Ex )
DEF_EX( exSeekError, "File seek error", Ex )
/// Checks if the file exists or not.
bool exists( char const * filename ) throw();
inline bool exists( std::string const & filename ) throw()
{ return exists( filename.c_str() ); }
class Class
{
FILE * f;
char * writeBuffer;
size_t writeBufferLeft;
void open( char const * filename, char const * mode ) throw( exCantOpen );
public:
Class( char const * filename, char const * mode ) throw( exCantOpen );
Class( std::string const & filename, char const * mode ) throw( exCantOpen );
/// Reads the number of bytes to the buffer, throws an error if it
/// failed to fill the whole buffer (short read, i/o error etc).
void read( void * buf, size_t size ) throw( exReadError, exWriteError );
template< typename T >
void read( T & value ) throw( exReadError, exWriteError )
{ read( &value, sizeof( value ) ); }
template< typename T >
T read() throw( exReadError, exWriteError )
{ T value; read( value ); return value; }
/// Attempts reading at most 'count' records sized 'size'. Returns
/// the number of records it managed to read, up to 'count'.
size_t readRecords( void * buf, size_t size, size_t count ) throw( exWriteError );
/// Writes the number of bytes from the buffer, throws an error if it
/// failed to write the whole buffer (short write, i/o error etc).
/// This function employs write buffering, and as such, writes may not
/// end up on disk immediately, or a short write may occur later
/// than it really did. If you don't want write buffering, use
/// writeRecords() function instead.
void write( void const * buf, size_t size ) throw( exWriteError );
template< typename T >
void write( T const & value ) throw( exWriteError )
{ write( &value, sizeof( value ) ); }
/// Attempts writing at most 'count' records sized 'size'. Returns
/// the number of records it managed to write, up to 'count'.
/// This function does not employ buffering, but flushes the buffer if it
/// was used before.
size_t writeRecords( void const * buf, size_t size, size_t count )
throw( exWriteError );
/// Reads a string from the file. Unlike the normal fgets(), this one
/// can strip the trailing newline character, if this was requested.
/// Returns either s or 0 if no characters were read.
char * gets( char * s, int size, bool stripNl = false ) throw( exWriteError );
/// Like the above, but uses its own local internal buffer (1024 bytes
/// currently), and strips newlines by default.
std::string gets( bool stripNl = true ) throw( exReadError, exWriteError );
/// Seeks in the file, relative to its beginning.
void seek( long offset ) throw( exSeekError, exWriteError );
/// Seeks in the file, relative to the current position.
void seekCur( long offset ) throw( exSeekError, exWriteError );
/// Seeks in the file, relative to the end of file.
void seekEnd( long offset = 0 ) throw( exSeekError, exWriteError );
/// Seeks to the beginning of file
void rewind() throw( exSeekError, exWriteError );
/// Tells the current position within the file, relative to its beginning.
size_t tell() throw( exSeekError );
/// Returns true if end-of-file condition is set.
bool eof() throw( exWriteError );
/// Returns the underlying FILE * record, so other operations can be
/// performed on it.
FILE * file() throw( exWriteError );
/// Releases the file handle out of the control of the class. No further
/// operations are valid. The file will not be closed on destruction.
FILE * release() throw( exWriteError );
/// Closes the file. No further operations are valid.
void close() throw( exWriteError );
~Class() throw();
private:
void flushWriteBuffer() throw( exWriteError );
void releaseWriteBuffer() throw( exWriteError );
};
}
#endif
|
