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
|
/* 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/stream.h"
namespace Common {
/**
* 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 names to the provided list according to the pattern. Returned
* names can be used as parameters to fileOpen.
* Must not remove elements from the list.
*
* @return The number of names added to list.
*/
virtual int matchPattern(StringList &list, const String &pattern) = 0;
/**
* Add all the names present in the Archive. Returned
* names can be used as parameters to fileOpen.
* Must not remove elements from the list.
*
* @return The number of names added to list.
*/
virtual int getAllNames(StringList &list) {
return matchPattern(list, "*");
}
/**
* 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
* FilesystemNode implementation.
*/
class FSDirectory : public Archive {
FilesystemNode _node;
// Caches are case insensitive, clashes are dealt with when creating
// Key is stored in lowercase.
typedef HashMap<String, FilesystemNode, IgnoreCase_Hash, IgnoreCase_EqualTo> NodeCache;
NodeCache _fileCache, _subDirCache;
// look for a match
FilesystemNode lookupCache(NodeCache &cache, const String &name);
// cache management
void cacheDirectoryRecursive(FilesystemNode 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 FilesystemNode &node, int depth = 1);
virtual ~FSDirectory();
/**
* This return the underlying FSNode of the FSDirectory.
*/
FilesystemNode getFSNode() const;
/**
* Create a new FSDirectory pointing to a sub directory of the instance.
* @return A new FSDirectory instance conveniently wrapped in a SharedPtr.
*/
SharedPtr<FSDirectory> getSubDirectory(const String &name);
virtual bool hasFile(const String &name);
virtual int matchPattern(StringList &list, const String &pattern);
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 {
uint _priority;
String _name;
ArchivePtr _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:
SearchSet();
virtual ~SearchSet();
/**
* Add a new Archive to the searchable set.
*/
void add(const String& name, ArchivePtr archive, uint priority = 0);
/**
* Remove an Archive from the searchable set.
*/
void remove(const String& name);
/**
* Empties the searchable set.
*/
void clear();
/**
* Change the order of searches.
*/
void setPriority(const String& name, uint priority);
virtual bool hasFile(const String &name);
virtual int matchPattern(StringList &list, const String &pattern);
/**
* 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);
};
} // namespace Common
#endif
|
