← Back to branch summary

~ubuntu-branches/ubuntu/natty/spring/natty

« back to all changes in this revision

Viewing changes to rts/System/FileSystem/FileHandler.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Ritchie
  • Date: 2010-09-23 18:56:03 UTC
  • mfrom: (3.1.9 experimental)
  • Revision ID: james.westby@ubuntu.com-20100923185603-st97s5chplo42y7w
Tags: 0.82.5.1+dfsg1-1ubuntu1
https://launchpad.net/bugs/612905
* Latest upstream version for online play
* debian/control: Replace (rather than conflict) spring-engine
  - spring-engine will be a dummy package (LP: #612905)
  - also set maintainer to MOTU

Show diffs side-by-side

added added

removed removed

Lines of Context:
rts/System/FileSystem/FileHandler.cpp
 
1
/* This file is part of the Spring engine (GPL v2 or later), see LICENSE.html */
 
2
 
1
3
#include "StdAfx.h"
2
4
 
3
5
#include "FileHandler.h"
22
24
/******************************************************************************/
23
25
 
24
26
CFileHandler::CFileHandler(const char* filename, const char* modes)
25
 
: ifs(NULL), hpiFileBuffer(NULL), hpiOffset(0), filesize(-1)
 
27
: ifs(NULL), filePos(0), fileSize(-1)
26
28
{
27
29
        GML_RECMUTEX_LOCK(file); // CFileHandler
28
30
 
31
33
 
32
34
 
33
35
CFileHandler::CFileHandler(const string& filename, const string& modes)
34
 
: ifs(NULL), hpiFileBuffer(NULL), hpiOffset(0), filesize(-1)
 
36
: ifs(NULL), filePos(0), fileSize(-1)
35
37
{
36
38
        GML_RECMUTEX_LOCK(file); // CFileHandler
37
39
 
43
45
{
44
46
        GML_RECMUTEX_LOCK(file); // ~CFileHandler
45
47
 
46
 
        if (ifs) {
47
 
                delete ifs;
48
 
        }
49
 
        if (hpiFileBuffer) {
50
 
                delete[] hpiFileBuffer;
51
 
        }
 
48
        delete ifs;
52
49
}
53
50
 
54
51
 
60
57
        ifs = new ifstream(rawpath.c_str(), ios::in | ios::binary);
61
58
        if (ifs && !ifs->bad() && ifs->is_open()) {
62
59
                ifs->seekg(0, ios_base::end);
63
 
                filesize = ifs->tellg();
 
60
                fileSize = ifs->tellg();
64
61
                ifs->seekg(0, ios_base::beg);
65
62
                return true;
66
63
        }
77
74
        }
78
75
 
79
76
        const string file = StringToLower(filename);
80
 
 
81
 
        hpiLength = vfsHandler->GetFileSize(file);
82
 
        if (hpiLength != -1) {
83
 
                hpiFileBuffer = new unsigned char[hpiLength];
84
 
                if (vfsHandler->LoadFile(file, hpiFileBuffer) < 0) {
85
 
                        delete[] hpiFileBuffer;
86
 
                        hpiFileBuffer = NULL;
87
 
                }
88
 
                else {
89
 
                        filesize = hpiLength;
90
 
                        return true;
91
 
                }
 
77
        if (vfsHandler->LoadFile(file, fileBuffer)) {
 
78
                fileSize = fileBuffer.size();
 
79
                return true;
92
80
        }
93
 
        return false;
 
81
        else
 
82
                return false;
94
83
}
95
84
 
96
85
 
124
113
 
125
114
bool CFileHandler::FileExists() const
126
115
{
127
 
        return (ifs || hpiFileBuffer);
 
116
        return (fileSize >= 0);
128
117
}
129
118
 
130
119
 
136
125
                ifs->read((char*)buf, length);
137
126
                return ifs->gcount ();
138
127
        }
139
 
        else if (hpiFileBuffer) {
140
 
                if ((length + hpiOffset) > hpiLength) {
141
 
                        length = hpiLength - hpiOffset;
 
128
        else if (!fileBuffer.empty()) {
 
129
                if ((length + filePos) > fileSize) {
 
130
                        length = fileSize - filePos;
142
131
                }
143
132
                if (length > 0) {
144
 
                        memcpy(buf, &hpiFileBuffer[hpiOffset], length);
145
 
                        hpiOffset += length;
 
133
                        assert(fileBuffer.size() >= filePos+length);
 
134
                        memcpy(buf, &fileBuffer[filePos], length);
 
135
                        filePos += length;
146
136
                }
147
137
                return length;
148
138
        }
161
151
                ifs->clear();
162
152
                ifs->seekg(length, where);
163
153
        }
164
 
        else if (hpiFileBuffer)
 
154
        else if (!fileBuffer.empty())
165
155
        {
166
156
                if (where == std::ios_base::beg)
167
157
                {
168
 
                        hpiOffset = length;
 
158
                        filePos = length;
169
159
                }
170
160
                else if (where == std::ios_base::cur)
171
161
                {
172
 
                        hpiOffset += length;
 
162
                        filePos += length;
173
163
                }
174
164
                else if (where == std::ios_base::end)
175
165
                {
176
 
                        hpiOffset = hpiLength + length;
 
166
                        filePos = fileSize + length;
177
167
                }
178
168
        }
179
169
}
186
176
        if (ifs) {
187
177
                return ifs->peek();
188
178
        }
189
 
        else if (hpiFileBuffer){
190
 
                if (hpiOffset < hpiLength) {
191
 
                        return hpiFileBuffer[hpiOffset];
 
179
        else if (!fileBuffer.empty()){
 
180
                if (filePos < fileSize) {
 
181
                        return fileBuffer.at(filePos);
192
182
                } else {
193
183
                        return EOF;
194
184
                }
204
194
        if (ifs) {
205
195
                return ifs->eof();
206
196
        }
207
 
        if (hpiFileBuffer) {
208
 
                return (hpiOffset >= hpiLength);
 
197
        if (!fileBuffer.empty()) {
 
198
                return (filePos >= fileSize);
209
199
        }
210
200
        return true;
211
201
}
213
203
 
214
204
int CFileHandler::FileSize() const
215
205
{
216
 
   return filesize;
 
206
   return fileSize;
217
207
}
218
208
 
219
209
 
224
214
        if (ifs) {
225
215
                return ifs->tellg();
226
216
        } else {
227
 
                return hpiOffset;
 
217
                return filePos;
228
218
        }
229
219
}
230
220
 
236
226
        if (!FileExists()) {
237
227
                return false;
238
228
        }
239
 
        char* buf = new char[filesize];
240
 
        Read(buf, filesize);
241
 
        data.append(buf, filesize);
 
229
        char* buf = new char[fileSize];
 
230
        Read(buf, fileSize);
 
231
        data.append(buf, fileSize);
242
232
        delete[] buf;
243
233
        return true;
244
234
}