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
270
271
272
273
274
275
276
277
278
279
280
281
|
/* 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.
*
*/
#ifndef COMMON_ARCHIVE_H
#define COMMON_ARCHIVE_H
#include "common/str.h"
#include "common/list.h"
#include "common/ptr.h"
#include "common/singleton.h"
namespace Common {
class FSNode;
class SeekableReadStream;
/**
* ArchiveMember is an abstract interface to represent elements inside
* implementations of Archive.
*
* Archive subclasses must provide their own implementation of ArchiveMember,
* and use it when serving calls to listMembers() and listMatchingMembers().
* Alternatively, the GenericArchiveMember below can be used.
*/
class ArchiveMember {
public:
virtual ~ArchiveMember() { }
virtual SeekableReadStream *createReadStream() const = 0;
virtual String getName() const = 0;
virtual String getDisplayName() const { return getName(); }
};
typedef SharedPtr<ArchiveMember> ArchiveMemberPtr;
typedef List<ArchiveMemberPtr> ArchiveMemberList;
struct ArchiveMemberListComparator {
bool operator()(const ArchiveMemberPtr &a, const ArchiveMemberPtr &b) {
return a->getName() < b->getName();
}
};
class Archive;
/**
* Simple ArchiveMember 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 {
const Archive *_parent;
const String _name;
public:
GenericArchiveMember(const String &name, const Archive *parent);
String getName() const;
SeekableReadStream *createReadStream() const;
};
/**
* Archive allows managing of member of arbitrary containers in a uniform
* fashion, allowing lookup by (file)names.
* It also supports opening a file and returning an usable input stream.
*/
class Archive {
public:
virtual ~Archive() { }
/**
* Check if a member with the given 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) const = 0;
/**
* Add all members of the Archive matching the specified pattern to list.
* Must only append to list, and not remove elements from it.
*
* @return the number of members added to list
*/
virtual int listMatchingMembers(ArchiveMemberList &list, const String &pattern) const;
/**
* Add all members of the Archive to list.
* Must only append to list, and not remove elements from it.
*
* @return the number of names added to list
*/
virtual int listMembers(ArchiveMemberList &list) const = 0;
/**
* Returns a ArchiveMember representation of the given file.
*/
virtual const ArchiveMemberPtr getMember(const String &name) const = 0;
/**
* Create a stream bound to a member with the specified name in the
* archive. If no member with this name exists, 0 is returned.
* @return the newly created input stream
*/
virtual SeekableReadStream *createReadStreamForMember(const String &name) const = 0;
};
/**
* 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;
Archive *_arc;
bool _autoFree;
Node(int priority, const String &name, Archive *arc, bool autoFree)
: _priority(priority), _name(name), _arc(arc), _autoFree(autoFree) {
}
};
typedef List<Node> ArchiveNodeList;
ArchiveNodeList _list;
ArchiveNodeList::iterator find(const String &name);
ArchiveNodeList::const_iterator find(const String &name) const;
// Add an archive keeping the list sorted by descending priority.
void insert(const Node& node);
bool _ignoreClashes;
public:
SearchSet() : _ignoreClashes(false) { }
virtual ~SearchSet() { clear(); }
/**
* Add a new archive to the searchable set.
*/
void add(const String& name, Archive *arch, int priority = 0, bool autoFree = true);
/**
* Create and add a FSDirectory by name
*/
void addDirectory(const String &name, const String &directory, int priority = 0, int depth = 1, bool flat = false);
/**
* Create and add a FSDirectory by FSNode
*/
void addDirectory(const String &name, const FSNode &directory, int priority = 0, int depth = 1, bool flat = false);
/**
* Create and add a sub directory by name (caseless).
*
* It is also possible to add sub directories of sub directories (of any depth) with this function.
* The path seperator for this case is SLASH for *all* systems.
*
* An example would be:
*
* "game/itedata"
*
* In this example the code would first try to search for all directories matching
* "game" (case insensitive) in the path "directory" first and search through all
* of the matches for "itedata" (case insensitive too).
*
* Note that it will add *all* matches found!
*
* Even though this method is currently implemented via addSubDirectoriesMatching it is not safe
* to assume that this method is using anything other than a simple case insensitive compare.
* Thus do not use any tokens like '*' or '?' in the "caselessName" parameter of this function!
*/
void addSubDirectoryMatching(const FSNode &directory, const String &caselessName, int priority = 0, int depth = 1, bool flat = false) {
addSubDirectoriesMatching(directory, caselessName, true, priority, depth, flat);
}
/**
* Create and add sub directories by pattern.
*
* It is also possible to add sub directories of sub directories (of any depth) with this function.
* The path seperator for this case is SLASH for *all* systems.
*
* An example would be:
*
* "game/itedata"
*
* In this example the code would first try to search for all directories matching
* "game" in the path "directory" first and search through all of the matches for
* "itedata". If "ingoreCase" is set to true, the code would do a case insensitive
* match, otherwise it is doing a case sensitive match.
*
* This method works of course also with tokens. For a list of available tokens
* see the documentation for Common::matchString.
*
* @see Common::matchString
*/
void addSubDirectoriesMatching(const FSNode &directory, String origPattern, bool ignoreCase, int priority = 0, int depth = 1, bool flat = false);
/**
* 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) const;
virtual int listMatchingMembers(ArchiveMemberList &list, const String &pattern) const;
virtual int listMembers(ArchiveMemberList &list) const;
virtual const ArchiveMemberPtr getMember(const String &name) const;
/**
* Implements createReadStreamForMember from Archive base class. The current policy is
* opening the first file encountered that matches the name.
*/
virtual SeekableReadStream *createReadStreamForMember(const String &name) const;
/**
* Ignore clashes when adding directories. For more details see the corresponding parameter
* in FSDirectory documentation
*/
void setIgnoreClashes(bool ignoreClashes) { _ignoreClashes = ignoreClashes; }
};
class SearchManager : public Singleton<SearchManager>, public SearchSet {
public:
/**
* Resets the search manager to the default list of search paths (system
* specific dirs + current dir).
*/
virtual void clear();
private:
friend class Singleton<SingletonBaseType>;
SearchManager();
};
/** Shortcut for accessing the search manager. */
#define SearchMan Common::SearchManager::instance()
} // namespace Common
#endif
|