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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
|
// --------------------------------------------------------------------------
//
// File
// Name: IOStream.cpp
// Purpose: I/O Stream abstraction
// Created: 2003/07/31
//
// --------------------------------------------------------------------------
#include "Box.h"
#include "IOStream.h"
#include "CommonException.h"
#include "Guards.h"
#include "MemLeakFindOn.h"
// --------------------------------------------------------------------------
//
// Function
// Name: IOStream::IOStream()
// Purpose: Constructor
// Created: 2003/07/31
//
// --------------------------------------------------------------------------
IOStream::IOStream()
{
}
// --------------------------------------------------------------------------
//
// Function
// Name: IOStream::IOStream(const IOStream &)
// Purpose: Copy constructor (exceptions)
// Created: 2003/07/31
//
// --------------------------------------------------------------------------
IOStream::IOStream(const IOStream &rToCopy)
{
THROW_EXCEPTION(CommonException, NotSupported)
}
// --------------------------------------------------------------------------
//
// Function
// Name: IOStream::~IOStream()
// Purpose: Destructor
// Created: 2003/07/31
//
// --------------------------------------------------------------------------
IOStream::~IOStream()
{
}
// --------------------------------------------------------------------------
//
// Function
// Name: IOStream::Close()
// Purpose: Close the stream
// Created: 2003/07/31
//
// --------------------------------------------------------------------------
void IOStream::Close()
{
// Do nothing by default -- let the destructor clear everything up.
}
// --------------------------------------------------------------------------
//
// Function
// Name: IOStream::Seek(int, int)
// Purpose: Seek in stream (if supported)
// Created: 2003/07/31
//
// --------------------------------------------------------------------------
void IOStream::Seek(IOStream::pos_type Offset, int SeekType)
{
THROW_EXCEPTION(CommonException, NotSupported)
}
// --------------------------------------------------------------------------
//
// Function
// Name: IOStream::GetPosition()
// Purpose: Returns current position in stream (if supported)
// Created: 2003/08/21
//
// --------------------------------------------------------------------------
IOStream::pos_type IOStream::GetPosition() const
{
THROW_EXCEPTION(CommonException, NotSupported)
}
// --------------------------------------------------------------------------
//
// Function
// Name: IOStream::ConvertSeekTypeToOSWhence(int)
// Purpose: Return an whence arg for lseek given a IOStream seek type
// Created: 2003/08/21
//
// --------------------------------------------------------------------------
int IOStream::ConvertSeekTypeToOSWhence(int SeekType)
{
// Should be nicely optimised out as values are choosen in header file to match OS values.
int ostype = SEEK_SET;
switch(SeekType)
{
case SeekType_Absolute:
ostype = SEEK_SET;
break;
case SeekType_Relative:
ostype = SEEK_CUR;
break;
case SeekType_End:
ostype = SEEK_END;
break;
default:
THROW_EXCEPTION(CommonException, IOStreamBadSeekType)
}
return ostype;
}
// --------------------------------------------------------------------------
//
// Function
// Name: IOStream::ReadFullBuffer(void *, int, int)
// Purpose: Reads bytes into buffer, returning whether or not it managed to
// get all the bytes required. Exception and abort use of stream
// if this returns false.
// Created: 2003/08/26
//
// --------------------------------------------------------------------------
bool IOStream::ReadFullBuffer(void *pBuffer, int NBytes, int *pNBytesRead, int Timeout)
{
int bytesToGo = NBytes;
char *buffer = (char*)pBuffer;
if(pNBytesRead) (*pNBytesRead) = 0;
while(bytesToGo > 0)
{
int bytesRead = Read(buffer, bytesToGo, Timeout);
if(bytesRead == 0)
{
// Timeout or something
return false;
}
// Increment things
bytesToGo -= bytesRead;
buffer += bytesRead;
if(pNBytesRead) (*pNBytesRead) += bytesRead;
}
// Got everything
return true;
}
// --------------------------------------------------------------------------
//
// Function
// Name: IOStream::WriteAllBuffered()
// Purpose: Ensures that any data which has been buffered is written to the stream
// Created: 2003/08/26
//
// --------------------------------------------------------------------------
void IOStream::WriteAllBuffered()
{
}
// --------------------------------------------------------------------------
//
// Function
// Name: IOStream::BytesLeftToRead()
// Purpose: Numbers of bytes left to read in the stream, or
// IOStream::SizeOfStreamUnknown if this isn't known.
// Created: 2003/08/26
//
// --------------------------------------------------------------------------
IOStream::pos_type IOStream::BytesLeftToRead()
{
return IOStream::SizeOfStreamUnknown;
}
// --------------------------------------------------------------------------
//
// Function
// Name: IOStream::CopyStreamTo(IOStream &, int Timeout)
// Purpose: Copies the entire stream to another stream (reading from this,
// writing to rCopyTo). Returns whether the copy completed (ie
// StreamDataLeft() returns false)
// Created: 2003/08/26
//
// --------------------------------------------------------------------------
bool IOStream::CopyStreamTo(IOStream &rCopyTo, int Timeout, int BufferSize)
{
// Make sure there's something to do before allocating that buffer
if(!StreamDataLeft())
{
return true; // complete, even though nothing happened
}
// Buffer
MemoryBlockGuard<char*> buffer(BufferSize);
// Get copying!
while(StreamDataLeft())
{
// Read some data
int bytes = Read(buffer, BufferSize, Timeout);
if(bytes == 0 && StreamDataLeft())
{
return false; // incomplete, timed out
}
// Write some data
if(bytes != 0)
{
rCopyTo.Write(buffer, bytes);
}
}
return true; // completed
}
|
