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
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
|
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $URL$
* $Id$
*
*/
#ifndef COMMON_ARCHIVES_H
#define COMMON_ARCHIVES_H
#include "common/fs.h"
#include "common/str.h"
#include "common/hash-str.h"
#include "common/list.h"
#include "common/ptr.h"
#include "common/singleton.h"
#include "common/stream.h"
namespace Common {
class ArchiveMember {
public:
virtual ~ArchiveMember() { }
virtual String getName() const = 0;
virtual SeekableReadStream *open() = 0;
};
typedef List<SharedPtr<ArchiveMember> > ArchiveMemberList;
class Archive;
/**
* Simple ArchiveMemeber implementation which allows
* creation of ArchiveMember compatible objects via
* a simple Archive and name pair.
*
* Note that GenericArchiveMember objects will not
* be working anymore after the 'parent' object
* is destroyed.
*/
class GenericArchiveMember : public ArchiveMember {
Archive *_parent;
String _name;
public:
GenericArchiveMember(String name, Archive *parent);
String getName() const;
SeekableReadStream *open();
};
/**
* FilePtr is a convenient way to keep track of a SeekableReadStream without
* having to worry about releasing its memory.
*/
typedef SharedPtr<SeekableReadStream> FilePtr;
/**
* Archive allows searches of (file)names into an arbitrary container.
* It also supports opening a file and returning an usable input stream.
*/
class Archive {
public:
virtual ~Archive() { }
/**
* Check if a name is present in the Archive. Patterns are not allowed,
* as this is meant to be a quick File::exists() replacement.
*/
virtual bool hasFile(const String &name) = 0;
/**
* Add all the names present in the Archive which match pattern to
* list. Returned names can be used as parameters to openFile.
* Must not remove elements from the list.
*
* @return the number of names added to list
*/
virtual int listMatchingMembers(ArchiveMemberList &list, const String &pattern);
/**
* Add all the names present in the Archive to list. Returned
* names can be used as parameters to openFile.
* Must not remove elements from the list.
*
* @return the number of names added to list
*/
virtual int listMembers(ArchiveMemberList &list) = 0;
/**
* Create a stream bound to a file in the archive.
* @return the newly created input stream
*/
virtual SeekableReadStream *openFile(const String &name) = 0;
};
typedef SharedPtr<Archive> ArchivePtr;
/**
* FSDirectory models a directory tree from the filesystem and allows users
* to access it through the Archive interface. FSDirectory can represent a
* single directory, or a tree with specified depth, rooted in a 'base'
* directory.
* Searching is case-insensitive, as the main intended goal is supporting
* retrieval of game data. First case-insensitive match is returned when
* searching, thus making FSDirectory heavily dependant on the underlying
* FSNode implementation.
*/
class FSDirectory : public Archive {
FSNode _node;
// Caches are case insensitive, clashes are dealt with when creating
// Key is stored in lowercase.
typedef HashMap<String, FSNode, IgnoreCase_Hash, IgnoreCase_EqualTo> NodeCache;
NodeCache _fileCache, _subDirCache;
// look for a match
FSNode lookupCache(NodeCache &cache, const String &name);
// cache management
void cacheDirectoryRecursive(FSNode node, int depth, const String& prefix);
bool _cached;
int _depth;
public:
/**
* Create a FSDirectory representing a tree with the specified depth. Will result in an
* unbound FSDirectory if name is not found on the filesystem or is not a directory.
*/
FSDirectory(const String &name, int depth = 1);
/**
* Create a FSDirectory representing a tree with the specified depth. Will result in an
* unbound FSDirectory if node does not exist or is not a directory.
*/
FSDirectory(const FSNode &node, int depth = 1);
virtual ~FSDirectory();
/**
* This return the underlying FSNode of the FSDirectory.
*/
FSNode getFSNode() const;
/**
* Create a new FSDirectory pointing to a sub directory of the instance.
* @return a new FSDirectory instance
*/
FSDirectory *getSubDirectory(const String &name);
virtual bool hasFile(const String &name);
virtual int listMatchingMembers(ArchiveMemberList &list, const String &pattern);
virtual int listMembers(ArchiveMemberList &list);
virtual SeekableReadStream *openFile(const String &name);
};
/**
* SearchSet enables access to a group of Archives through the Archive interface.
* Its intended usage is a situation in which there are no name clashes among names in the
* contained Archives, hence the simplistic policy of always looking for the first
* match. SearchSet *DOES* guarantee that searches are performed in *DESCENDING*
* priority order. In case of conflicting priorities, insertion order prevails.
*/
class SearchSet : public Archive {
struct Node {
int _priority;
String _name;
ArchivePtr _arc;
Node(int priority, const String &name, ArchivePtr arc)
: _priority(priority), _name(name), _arc(arc) {
}
};
typedef List<Node> ArchiveList;
ArchiveList _list;
ArchiveList::iterator find(const String &name) const;
// Add an archive keeping the list sorted by ascending priorities.
void insert(const Node& node);
public:
/**
* Add a new archive to the searchable set.
*/
void add(const String& name, ArchivePtr archive, int priority = 0);
/**
* Remove an archive from the searchable set.
*/
void remove(const String& name);
/**
* Check if a given archive name is already present.
*/
bool hasArchive(const String &name) const;
/**
* Empties the searchable set.
*/
virtual void clear();
/**
* Change the order of searches.
*/
void setPriority(const String& name, int priority);
virtual bool hasFile(const String &name);
virtual int listMatchingMembers(ArchiveMemberList &list, const String &pattern);
virtual int listMembers(ArchiveMemberList &list);
/**
* Implements openFile from Archive base class. The current policy is
* opening the first file encountered that matches the name.
*/
virtual SeekableReadStream *openFile(const String &name);
};
class SearchManager : public Singleton<SearchManager>, public SearchSet {
public:
SearchManager();
/**
* Add an existing Archive. This is meant to support searching in system-specific
* archives, namely the MACOSX/IPHONE bundles.
*/
void addArchive(const String &name, ArchivePtr archive, int priority = 0);
/**
* Create and add a FSDirectory by name
*/
void addDirectory(const String &name, const String &directory, int priority = 0);
/**
* Create and add a FSDirectory and its subdirectories by name
*/
void addDirectoryRecursive(const String &name, const String &directory, int depth = 4, int priority = 0);
/**
* TODO
*/
virtual void clear();
};
/** Shortcut for accessing the search manager. */
#define SearchMan Common::SearchManager::instance()
} // namespace Common
#endif
|