remove some deprected stuff

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

diff --git a/src/moof/resource.cc b/src/moof/resource.cc
index 359d1b4dcdfc35fcb3b2bb8d8a3394ecbee60925..57bd99b927df9fabfdee70f22faeae208c2d823b 100644 (file)
--- a/src/moof/resource.cc
+++ b/src/moof/resource.cc
@@ -34,13 +34,39 @@
 namespace moof {
        
 
+bool resource::call_registry(const std::string& extension,
+                                                        loader_ptr& loader,
+                                                        registry_action action)
+{
+       static type_lookup table;
+
+       switch (action)
+       {
+               case set:
+               {
+                       if (loader) table[extension] = loader;
+                       else        table.erase(extension);
+                       break;
+               }
+
+               case lookup:
+               {
+                       std::map<std::string,loader_ptr>::iterator it;
+                       it = table.find(extension);
+                       if (it != table.end()) loader = (*it).second;
+                       break;
+               }
+       }
+
+       return loader;
+}
+
 static std::string search_paths_;
 
 typedef boost::weak_ptr<resource> resource_weakptr;
 static hash<std::string,resource_weakptr,hash_function> resource_table_;
 
-// static member
-resource::type_lookup_ptr resource::type_lookup_;
+static hash<std::string,std::string,hash_function> prefix_table_;
 
 
 #ifdef USE_HOTLOADING
@@ -103,15 +129,21 @@ resource::~resource()
 }
 
 
-resource_ptr resource::load(const std::string& path)
+resource_ptr resource::load(const std::string& name,
+                                                       const std::string& ext)
 {
-       std::string extension = stlplus::extension_part(path);
+       return load_with_path(find_file(name, ext));
+}
+
+resource_ptr resource::load(const std::string& name)
+{
+       return load_with_path(find_file(name));
+}
 
-       if (!find(path))
-       {
-               log_error("trying to load missing resource:", path);
-               return resource_ptr();
-       }
+
+resource_ptr resource::load_with_path(const std::string& path)
+{
+       std::string extension = stlplus::extension_part(path);
 
        hash<std::string,resource_weakptr,hash_function>::iterator it;
        it = resource_table_.find(path);
@@ -122,12 +154,12 @@ resource_ptr resource::load(const std::string& path)
                if (locked) return locked;
        }
 
-       std::map<std::string,loader_ptr>::iterator jt;
-       jt = type_lookup_->find(extension);
-       if (jt != type_lookup_->end())
+       loader_ptr loader;
+       call_registry(extension, loader, lookup);
+       if (loader)
        {
-               resource_ptr rsrc((*jt).second->load(path));
-               rsrc->set_loader(path, (*jt).second);
+               resource_ptr rsrc(loader->load(path));
+               rsrc->set_loader(path, loader);
                resource_table_[path] = rsrc;
 
 #ifdef USE_HOTLOADING
@@ -140,6 +172,7 @@ resource_ptr resource::load(const std::string& path)
                return rsrc;
        }
 
+       log_warning("cannot load resource of unknown type:", path);
        return resource_ptr();
 }
 
@@ -189,23 +222,51 @@ void resource::add_search_paths(const std::string& paths)
 }
 
 
-bool resource::find(const std::string& path)
-{
-       std::string file = stlplus::lookup(path, search_paths_, ":");
-       log_info("found file", file, "in", search_paths_);
-       return !stlplus::lookup(path, search_paths_, ":").empty();
-}
-
 std::string resource::find_file(const std::string& name)
 {
-       log_info("looking for", name, "in", search_paths_);
-       return stlplus::lookup(name, search_paths_, ":");
+       std::vector<std::string> paths;
+       boost::split(paths, search_paths_, boost::is_any_of(":"));
+
+       std::string ext = stlplus::extension_part(name);
+       std::string prefix("hi");
+
+       loader_ptr loader;
+       call_registry(ext, loader, lookup);
+       if (loader) prefix = loader->prefix();
+
+       log_info("find_file:", ext, prefix);
+
+       std::vector<std::string>::iterator it;
+       for (it = paths.begin(); it != paths.end(); ++it)
+       {
+               std::string path = stlplus::create_filespec(*it, name);
+               log_info("looking for", name, "at", path);
+               if (stlplus::file_exists(path)) return path;
+               
+               // try it with the prefix added
+               if (!prefix.empty())
+               {
+                       *it = stlplus::create_filespec(*it, prefix);
+                       path = stlplus::create_filespec(*it, name);
+                       log_info("looking for", name, "at", path);
+                       if (stlplus::file_exists(path)) return path;
+               }
+       }
+
+
+       log_error("cannot find resource file:", name);
+       return std::string();
 }
 
-FILE* resource::open_file(const std::string& path, const std::string& mode)
+std::string resource::find_file(const std::string& name,
+                                                               const std::string& ext)
 {
-       std::string file = stlplus::lookup(path, search_paths_, ":");
-       return fopen(file.c_str(), mode.c_str());
+       std::string actual_ext = stlplus::extension_part(name);
+       if (actual_ext != ext)
+       {
+               return find_file(stlplus::create_filename(name, ext));
+       }
+       return find_file(name);
 }