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
|
/* 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_ARCHIVE_H
#define COMMON_ARCHIVE_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"
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;
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 {
Archive *_parent;
String _name;
public:
GenericArchiveMember(String name, Archive *parent);
String getName() const;
SeekableReadStream *createReadStream() const;
};
/**
* 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 createReadStreamForMember.
* 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 createReadStreamForMember.
* Must not remove elements from the list.
*
* @return the number of names added to list
*/
virtual int listMembers(ArchiveMemberList &list) = 0;
/**
* Returns a ArchiveMember representation of the given file.
*/
virtual ArchiveMemberPtr getMember(const String &name) = 0;
/**
* Create a stream bound to a file in the archive.
* @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) const;
// Add an archive keeping the list sorted by ascending priorities.
void insert(const Node& node);
public:
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);
/**
* Create and add a FSDirectory by FSNode
*/
void addDirectory(const String &name, const FSNode &directory, int priority = 0, int depth = 1);
/**
* 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);
virtual ArchiveMemberPtr getMember(const String &name);
/**
* 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;
};
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 Common::Singleton<SingletonBaseType>;
SearchManager();
};
/** Shortcut for accessing the search manager. */
#define SearchMan Common::SearchManager::instance()
} // namespace Common
#endif
|
