]>
Dogcows Code - chaz/yoink/blob - src/moof/resource.hh
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.
28 #include <boost/shared_ptr.hpp>
29 #include <boost/function.hpp>
31 #include <moof/debug.hh>
38 typedef boost::shared_ptr
<resource
> resource_ptr
;
42 * Generic resource class capable of containing any type of resource,
43 * providing a type-safe interface.
49 // XXX: this won't be necessary once the existing code is modified to
50 // use the resource handles
54 * Add a directory to search when looking for resource files.
55 * \param paths A colon-separated list of directory paths.
57 static void add_search_paths(const std::string
& paths
);
61 * Get the path to a resource of a given name.
62 * \param path The name of the resource to find. Upon successful
63 * return, this is changed to an absolute path to the resource.
64 * \return True if a path to a resource was found, false otherwise.
67 static bool find(const std::string
& file
);
69 static std::string
find_file(const std::string
& name
);
71 static std::string
find_file(const std::string
& name
,
72 const std::string
& ext
);
75 * Get the path to a resource of a given name and open it if a resource
77 * \param path The name of the resource to find. Upon successful
78 * return, this is changed to an absolute path to the resource.
79 * \param mode The open mode.
80 * \return The FILE* if the resource was found, 0 otherwise.
83 static FILE* open_file(const std::string
& path
,
84 const std::string
& mode
= "rb");
88 * Register a type with the extension of files which this type can
89 * load. If any type has already been registered with the given file
90 * extension, it will be replaced.
91 * \param extension The file extension.
94 static void register_type(const std::string
& extension
,
95 const std::string
& prefix
= "")
97 loader_ptr
loader(new specific_loader
<T
>(prefix
));
98 printf("registered type with prefix %s", loader
->prefix().c_str());
99 call_registry(extension
, loader
, set
);
103 * Unregister the type associated with a file extension. Resources of
104 * this type will no longer be loadable, although resources which are
105 * already loaded will remain loaded.
106 * \param extension The file extension
108 static void unregister_type(const std::string
& extension
)
111 call_registry(extension
, loader
, set
);
115 static resource_ptr
load(const std::string
& name
);
116 static resource_ptr
load(const std::string
& name
,
117 const std::string
& ext
);
119 static resource_ptr
reload(std::string
& path
);
123 * Construct a resource container.
124 * \param ptr A pointer to the underlying resource data.
127 explicit resource(T
* ptr
) :
129 typeinfo_(const_cast<std::type_info
*>(&typeid(T
))),
130 unloader_(new specific_unloader
<T
>(ptr
)) {}
133 * Deconstruct a resource container.
139 * Reload the resource data. This will cause the resource file to be
140 * reread, and the underlying resource data will change.
146 * Get whether or not the type of the underlying resource data matches
148 * \return True if the types match, false otherwise.
153 return *typeinfo_
== typeid(T
);
157 * Get a pointer to the underlying resource data as long as the type of
158 * the resource data matches the expected type.
159 * \return The resource data, or null if there is a type mismatch.
164 if (check
<T
>()) return (T
*)resource_
;
170 * Reloads some resources which have been modified on disk since they
171 * were loaded. Hotloading must have been enabled at compile-time.
172 * \return The number of resources reloaded.
174 static int reload_as_needed();
179 static resource_ptr
load_with_path(const std::string
& path
);
186 loader(const std::string
& prefix
) :
191 virtual resource
* load(const std::string
& path
)
196 const std::string
& prefix() const
207 typedef boost::shared_ptr
<loader
> loader_ptr
;
210 class specific_loader
: public loader
214 //specific_loader() {}
215 specific_loader(const std::string
& prefix
) :
218 virtual resource
* load(const std::string
& path
)
220 log_info("loading resource of type ", typeid(T
).name());
221 return new resource(new T(path
));
230 virtual ~unloader() {};
233 typedef boost::shared_ptr
<unloader
> unloader_ptr
;
236 class specific_unloader
: public unloader
240 specific_unloader(T
* object
= 0) :
243 virtual ~specific_unloader()
245 log_info("unloading resource of type ", typeid(T
).name());
256 void set_loader(const std::string
& path
, loader_ptr loader
)
264 std::type_info
* typeinfo_
;
265 unloader_ptr unloader_
;
270 typedef std::map
<std::string
,loader_ptr
> type_lookup
;
271 //typedef boost::shared_ptr<type_lookup> type_lookup_ptr;
272 //static type_lookup_ptr type_lookup_;
273 //static type_lookup type_lookup_;
281 static bool call_registry(const std::string
& extension
,
283 registry_action action
);
285 #ifdef USE_HOTLOADING
288 void set_watch_descriptor(int wd
)
297 * The resource handle class provides a nicer way to work with resources.
298 * It allows you to work with a resource pointer as if you already know the
299 * type of the resource.
302 class resource_handle
307 * Construct a null resource handle.
312 * Construct a resource handle.
313 * \param ptr The resource pointer to reference.
315 resource_handle(resource_ptr ptr
) :
318 explicit resource_handle(const std::string
& name
) :
319 resource_(resource::load(name
)) {}
321 resource_handle(const std::string
& name
, const std::string
& ext
) :
322 resource_(resource::load(name
, ext
)) {}
327 * Get whether or not the handle is dereferenceable to the type of this
328 * handle. A resource handle is dereferenceable if it is not a null
329 * handle and if its underlying resource is in fact the same type as is
330 * expected by the handle.
331 * \return True if the handle is dereferenceable, false otherwise.
333 operator bool () const
335 if (!resource_
) return false;
336 return resource_
->check
<T
>();
341 * Get a pointer to the underlying resource.
342 * \return The pointer, or null if this handle is not dereferenceable.
346 if (!*this) return 0;
347 return resource_
->get
<T
>();
351 * Dereference the handle all the way to the underlying resource.
352 * \return A reference to the resource.
353 * \throws std::runtime_error If this is a null handle.
355 T
& get_reference() const
357 if (!*this) throw std::runtime_error("dereference null handle");
358 return *(resource_
->get
<T
>());
363 * Same as get() for getting a pointer to the underlying resources.
364 * \return The pointer, or null if this handle is not dereferenceable.
366 T
* operator -> () const
372 * Same a get_reference() for dereferencing the handle.
373 * \return A reference to the resource.
374 * \throws std::runtime_error If this is a null handle.
376 T
& operator * () const
378 return get_reference();
383 * Unload the resource associated with this handle.
387 resource_
= resource_ptr();
393 resource_ptr resource_
;
399 #endif // _MOOF_RESOURCE_HH_
This page took 0.04619 seconds and 4 git commands to generate.