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
|
/*
* The ManaPlus Client
* Copyright (C) 2004-2009 The Mana World Development Team
* Copyright (C) 2009-2010 The Mana Developers
* Copyright (C) 2011-2016 The ManaPlus Developers
*
* This file is part of The ManaPlus Client.
*
* 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
* 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef RESOURCES_RESOURCEMANAGER_RESOURCEMANAGER_H
#define RESOURCES_RESOURCEMANAGER_RESOURCEMANAGER_H
#include "resources/memorycounter.h"
#include "enums/simpletypes/append.h"
#include <map>
#include <set>
#include "localconsts.h"
class Resource;
struct SDL_Surface;
struct SDL_RWops;
/**
* A class for loading and managing resources.
*/
class ResourceManager final : public MemoryCounter
{
friend class Resource;
public:
typedef Resource *(*loader)(SDL_RWops *rw,
const std::string &name);
typedef Resource *(&generator)(const void *const data);
ResourceManager();
A_DELETE_COPY(ResourceManager)
/**
* Destructor. Cleans up remaining resources, warning about resources
* that were still referenced.
*/
~ResourceManager();
/**
* Sets the write directory.
*
* @param path The path of the directory to be added.
* @return <code>true</code> on success, <code>false</code> otherwise.
*/
bool setWriteDir(const std::string &path) const;
/**
* Adds a directory or archive to the search path. If append is true
* then the directory is added to the end of the search path, otherwise
* it is added at the front.
*
* @return <code>true</code> on success, <code>false</code> otherwise.
*/
bool addToSearchPath(const std::string &path,
const Append append) const;
/**
* Remove a directory or archive from the search path.
*
* @return <code>true</code> on success, <code>false</code> otherwise.
*/
bool removeFromSearchPath(const std::string &path) const;
/**
* Searches for zip files and adds them to the search path.
*/
void searchAndAddArchives(const std::string &restrict path,
const std::string &restrict ext,
const Append append) const;
/**
* Searches for zip files and remove them from the search path.
*/
void searchAndRemoveArchives(const std::string &restrict path,
const std::string &restrict ext) const;
/**
* Creates a resource and adds it to the resource map.
*
* @param idPath The resource identifier path.
* @param fun A function for generating the resource.
* @param data Extra parameters for the generator.
* @return A valid resource or <code>NULL</code> if the resource could
* not be generated.
*/
Resource *get(const std::string &idPath,
generator fun,
const void *const data) A_WARN_UNUSED;
Resource *getFromCache(const std::string &idPath) A_WARN_UNUSED;
Resource *getFromCache(const std::string &filename,
const int variant) A_WARN_UNUSED;
/**
* Adds a preformatted resource to the resource map.
*
* @param path The file name.
* @param Resource The Resource to add.
* @return true if successfull, false otherwise.
*/
bool addResource(const std::string &idPath, Resource *const resource);
/**
* Releases a resource, placing it in the set of orphaned resources.
*/
void release(Resource *const res);
void clearDeleted(const bool full = true);
void decRefDelete(Resource *const res);
/**
* Move resource to deleted resources list.
*/
void moveToDeleted(Resource *const res);
void scheduleDelete(SDL_Surface *const surface);
void clearScheduled();
/**
* Deletes the class instance if it exists.
*/
static void deleteInstance();
int size() const A_WARN_UNUSED
{ return CAST_S32(mResources.size()); }
typedef std::map<std::string, Resource*> Resources;
typedef Resources::iterator ResourceIterator;
typedef Resources::const_iterator ResourceCIterator;
#ifdef DEBUG_DUMP_LEAKS
Resources* getResources() A_WARN_UNUSED
{ return &mResources; }
Resources* getOrphanedResources() A_WARN_UNUSED
{ return &mOrphanedResources; }
#endif
bool cleanOrphans(const bool always = false);
void cleanProtected();
bool isInCache(const std::string &idPath) const A_WARN_UNUSED;
Resource *getTempResource(const std::string &idPath) A_WARN_UNUSED;
void clearCache();
int calcMemoryLocal() const override final;
int calcMemoryChilds(const int level) const override final;
std::string getCounterName() const override final
{ return "ResourceManager"; }
static void init();
#ifndef UNITTESTS
private:
#endif
/**
* Deletes the resource after logging a cleanup message.
*/
static void cleanUp(Resource *const resource);
static void logResource(const Resource *const res);
static ResourceManager *instance;
std::set<SDL_Surface*> deletedSurfaces;
Resources mResources;
Resources mOrphanedResources;
std::set<Resource*> mDeletedResources;
time_t mOldestOrphan;
bool mDestruction;
};
extern ResourceManager *resourceManager;
#endif // RESOURCES_RESOURCEMANAGER_RESOURCEMANAGER_H
|
