]>
Dogcows Code - chaz/yoink/blob - src/moof/resource.hh
9d991053c21b841be3ebc164e6b538244c80bb82
2 /*] Copyright (c) 2009-2010, Charles McGarvey [**************************
3 **] All rights reserved.
7 * Distributable under the terms and conditions of the 2-clause BSD license;
8 * see the file COPYING for a complete text of the license.
10 **************************************************************************/
12 #ifndef _MOOF_RESOURCE_HH_
13 #define _MOOF_RESOURCE_HH_
17 * Interface for textures, sounds, and other types of resources.
27 #include <boost/shared_ptr.hpp>
28 #include <boost/function.hpp>
30 #include <moof/debug.hh>
37 typedef boost::shared_ptr
<resource
> resource_ptr
;
41 * Generic resource class capable of containing any type of resource,
42 * providing a type-safe interface.
48 // XXX: this won't be necessary once the existing code is modified to
49 // use the resource handles
53 * Add a directory to search when looking for resource files.
54 * \param paths A colon-separated list of directory paths.
56 static void add_search_paths(const std::string
& paths
);
60 * Get the path to a resource of a given name.
61 * \param path The name of the resource to find. Upon successful
62 * return, this is changed to an absolute path to the resource.
63 * \return True if a path to a resource was found, false otherwise.
65 static std::string
find_file(const std::string
& name
);
67 static std::string
find_file(const std::string
& name
,
68 const std::string
& ext
);
71 * Register a type with the extension of files which this type can
72 * load. If any type has already been registered with the given file
73 * extension, it will be replaced.
74 * \param extension The file extension.
77 static void register_type(const std::string
& extension
,
78 const std::string
& prefix
= "")
80 loader_ptr
loader(new specific_loader
<T
>(prefix
));
81 call_registry(extension
, loader
, set
);
85 * Unregister the type associated with a file extension. Resources of
86 * this type will no longer be loadable, although resources which are
87 * already loaded will remain loaded.
88 * \param extension The file extension
90 static void unregister_type(const std::string
& extension
)
93 call_registry(extension
, loader
, set
);
97 static resource_ptr
load(const std::string
& name
);
98 static resource_ptr
load(const std::string
& name
,
99 const std::string
& ext
);
101 static resource_ptr
reload(std::string
& path
);
105 * Construct a resource container.
106 * \param ptr A pointer to the underlying resource data.
109 explicit resource(T
* ptr
) :
111 typeinfo_(const_cast<std::type_info
*>(&typeid(T
))),
112 unloader_(new specific_unloader
<T
>(ptr
)) {}
115 * Deconstruct a resource container.
121 * Reload the resource data. This will cause the resource file to be
122 * reread, and the underlying resource data will change.
128 * Get whether or not the type of the underlying resource data matches
130 * \return True if the types match, false otherwise.
135 return *typeinfo_
== typeid(T
);
139 * Get a pointer to the underlying resource data as long as the type of
140 * the resource data matches the expected type.
141 * \return The resource data, or null if there is a type mismatch.
146 if (check
<T
>()) return (T
*)resource_
;
152 * Reloads some resources which have been modified on disk since they
153 * were loaded. Hotloading must have been enabled at compile-time.
154 * \return The number of resources reloaded.
156 static int reload_as_needed();
161 static resource_ptr
load_with_path(const std::string
& path
);
168 loader(const std::string
& prefix
) :
173 virtual resource
* load(const std::string
& path
)
178 const std::string
& prefix() const
189 typedef boost::shared_ptr
<loader
> loader_ptr
;
192 class specific_loader
: public loader
196 //specific_loader() {}
197 specific_loader(const std::string
& prefix
) :
200 virtual resource
* load(const std::string
& path
)
202 log_info("loading resource of type ", typeid(T
).name());
203 return new resource(new T(path
));
212 virtual ~unloader() {};
215 typedef boost::shared_ptr
<unloader
> unloader_ptr
;
218 class specific_unloader
: public unloader
222 specific_unloader(T
* object
= 0) :
225 virtual ~specific_unloader()
227 log_info("unloading resource of type ", typeid(T
).name());
238 void set_loader(const std::string
& path
, loader_ptr loader
)
246 std::type_info
* typeinfo_
;
247 unloader_ptr unloader_
;
252 typedef std::map
<std::string
,loader_ptr
> type_lookup
;
253 //typedef boost::shared_ptr<type_lookup> type_lookup_ptr;
254 //static type_lookup_ptr type_lookup_;
255 //static type_lookup type_lookup_;
263 static bool call_registry(const std::string
& extension
,
265 registry_action action
);
267 #ifdef USE_HOTLOADING
270 void set_watch_descriptor(int wd
)
279 * The resource handle class provides a nicer way to work with resources.
280 * It allows you to work with a resource pointer as if you already know the
281 * type of the resource.
284 class resource_handle
289 * Construct a null resource handle.
294 * Construct a resource handle.
295 * \param ptr The resource pointer to reference.
297 resource_handle(resource_ptr ptr
) :
300 explicit resource_handle(const std::string
& name
) :
301 resource_(resource::load(name
)) {}
303 resource_handle(const std::string
& name
, const std::string
& ext
) :
304 resource_(resource::load(name
, ext
)) {}
309 * Get whether or not the handle is dereferenceable to the type of this
310 * handle. A resource handle is dereferenceable if it is not a null
311 * handle and if its underlying resource is in fact the same type as is
312 * expected by the handle.
313 * \return True if the handle is dereferenceable, false otherwise.
315 operator bool () const
317 if (!resource_
) return false;
318 return resource_
->check
<T
>();
323 * Get a pointer to the underlying resource.
324 * \return The pointer, or null if this handle is not dereferenceable.
328 if (!*this) return 0;
329 return resource_
->get
<T
>();
333 * Dereference the handle all the way to the underlying resource.
334 * \return A reference to the resource.
335 * \throws std::runtime_error If this is a null handle.
337 T
& get_reference() const
339 if (!*this) throw std::runtime_error("dereference null handle");
340 return *(resource_
->get
<T
>());
345 * Same as get() for getting a pointer to the underlying resources.
346 * \return The pointer, or null if this handle is not dereferenceable.
348 T
* operator -> () const
354 * Same a get_reference() for dereferencing the handle.
355 * \return A reference to the resource.
356 * \throws std::runtime_error If this is a null handle.
358 T
& operator * () const
360 return get_reference();
365 * Unload the resource associated with this handle.
369 resource_
= resource_ptr();
375 resource_ptr resource_
;
381 #endif // _MOOF_RESOURCE_HH_
This page took 0.043452 seconds and 3 git commands to generate.