fixed some resource management bugs

[chaz/yoink] / src / moof / resource.hh

diff --git a/src/moof/resource.hh b/src/moof/resource.hh
index 0f797571c3e1266f493f148b098e06594b32cbc2..eba4b3f2871d59e55a81b661e98776a947b97183 100644 (file)
--- a/src/moof/resource.hh
+++ b/src/moof/resource.hh
@@ -17,6 +17,8 @@
  * Interface for textures, sounds, and other types of resources.
  */
 
+#include "config.h"
+
 #include <cstdio>
 #include <map>
 #include <stdexcept>
@@ -28,10 +30,6 @@
 
 #include <moof/debug.hh>
 
-#if HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
 
 namespace moof {
 
@@ -48,7 +46,7 @@ class resource
 {
 public:
 
-       // FIXME: this won't be necessary once the existing code is modified to
+       // XXX: this won't be necessary once the existing code is modified to
        // use the resource handles
        resource() {}
 
@@ -58,21 +56,21 @@ public:
         */
        static void add_search_paths(const std::string& paths);
 
-       /**
-        * Add directories to search when looking for resource files.
-        * \param pathList The list of directory paths.
-        */
-       static void add_search_paths(const std::vector<std::string>& pathList);
-
 
        /**
         * Get the path to a resource of a given name.
         * \param path The name of the resource to find.  Upon successful
         * return, this is changed to an absolute path to the resource.
         * \return True if a path to a resource was found, false otherwise.
+        * XXX this is legacy
         */
        static bool find(const std::string& file);
 
+       static std::string find_file(const std::string& name);
+
+       static std::string find_file(const std::string& name,
+                                                                const std::string& ext);
+
        /**
         * Get the path to a resource of a given name and open it if a resource
         * was found.
@@ -80,6 +78,7 @@ public:
         * return, this is changed to an absolute path to the resource.
         * \param mode The open mode.
         * \return The FILE* if the resource was found, 0 otherwise.
+        * XXX deprecated
         */
        static FILE* open_file(const std::string& path,
                                                   const std::string& mode = "rb");
@@ -92,11 +91,12 @@ public:
         * \param extension The file extension.
         */
        template <class T>
-       static void register_type(const std::string& extension)
+       static void register_type(const std::string& extension,
+                                                         const std::string& prefix = "")
        {
-               if (!type_lookup_) type_lookup_ = type_lookup_ptr(new type_lookup);
-               loader_ptr loader(new specific_loader<T>);
-               (*type_lookup_)[extension] = loader;
+               loader_ptr loader(new specific_loader<T>(prefix));
+               printf("registered type with prefix %s", loader->prefix().c_str());
+               call_registry(extension, loader, set);
        }
 
        /**
@@ -107,11 +107,14 @@ public:
         */
        static void unregister_type(const std::string& extension)
        {
-               type_lookup_->erase(extension);
+               loader_ptr loader;
+               call_registry(extension, loader, set);
        }
 
 
-       static resource_ptr load(const std::string& path);
+       static resource_ptr load(const std::string& name);
+       static resource_ptr load(const std::string& name,
+                                                        const std::string& ext);
 
        static resource_ptr reload(std::string& path);
 
@@ -173,16 +176,32 @@ public:
 
 private:
 
+       static resource_ptr load_with_path(const std::string& path);
+
        class loader
        {
        public:
 
+               //loader() {}
+               loader(const std::string& prefix) :
+                       prefix_(prefix) {}
+
                virtual ~loader() {}
 
                virtual resource* load(const std::string& path)
                {
                        return 0;
                }
+
+               const std::string& prefix() const
+               {
+                       return prefix_;
+               }
+
+
+       private:
+
+               std::string prefix_;
        };
 
        typedef boost::shared_ptr<loader> loader_ptr;
@@ -192,8 +211,13 @@ private:
        {
        public:
 
+               //specific_loader() {}
+               specific_loader(const std::string& prefix) :
+                       loader(prefix) {}
+
                virtual resource* load(const std::string& path)
                {
+                       log_info("loading resource of type ", typeid(T).name());
                        return new resource(new T(path));
                }
        };
@@ -218,7 +242,7 @@ private:
 
                virtual ~specific_unloader()
                {
-                       log_warning("unloading resource of type ", typeid(T).name());
+                       log_info("unloading resource of type ", typeid(T).name());
                        delete object_;
                }
 
@@ -244,10 +268,21 @@ private:
        loader_ptr              loader_;
 
        typedef std::map<std::string,loader_ptr> type_lookup;
-       typedef boost::shared_ptr<type_lookup> type_lookup_ptr;
-       static type_lookup_ptr type_lookup_;
+       //typedef boost::shared_ptr<type_lookup> type_lookup_ptr;
+       //static type_lookup_ptr type_lookup_;
+       //static type_lookup type_lookup_;
+       
+       enum registry_action
+       {
+               lookup,
+               set
+       };
+
+       static bool call_registry(const std::string& extension,
+                                                         loader_ptr& loader,
+                                                         registry_action action);
 
-#if USE_HOTLOADING
+#ifdef USE_HOTLOADING
        int wd_;
 
        void set_watch_descriptor(int wd)
@@ -280,6 +315,13 @@ public:
        resource_handle(resource_ptr ptr) :
                resource_(ptr) {}
 
+       explicit resource_handle(const std::string& name) :
+               resource_(resource::load(name)) {}
+
+       resource_handle(const std::string& name, const std::string& ext) :
+               resource_(resource::load(name, ext)) {}
+
+
 
        /**
         * Get whether or not the handle is dereferenceable to the type of this
@@ -337,6 +379,15 @@ public:
        }
 
 
+       /**
+        * Unload the resource associated with this handle.
+        */
+       void unload()
+       {
+               resource_ = resource_ptr();
+       }
+
+
 private:
 
        resource_ptr resource_;