refactoring the scene class

[chaz/yoink] / src / Moof / Mippleton.hh

diff --git a/src/Moof/Mippleton.hh b/src/Moof/Mippleton.hh
index 7058eccf76214911933a61a7d3fca5a07de4fcf9..7ad17823a45862cfe7eae2b7f0d03148c34db692 100644 (file)
--- a/src/Moof/Mippleton.hh
+++ b/src/Moof/Mippleton.hh
@@ -38,35 +38,28 @@
  * after the last interested code releases its hold on the object.
  */
 
-#include <Moof/Hash.hh>
 #include <string>
 
+#include <boost/shared_ptr.hpp>
+
+#include <Moof/Hash.hh>
+
+
 namespace Mf {
 
 
 template <class T>
 class Mippleton
 {
-       typedef std::pair<unsigned,T*>                                                          ptr_value_t;
-       typedef std::pair<std::string,ptr_value_t>                                      ptr_map_pair_t;
-       typedef stlplus::hash<std::string,ptr_value_t,hash_string>      ptr_map_t;
-       //typedef std::map<std::string,ptr_value_t>     ptr_map_t;
-
-       static ptr_map_t        ptrs_;
-       std::string                     name_;
+       typedef std::pair<unsigned,T*>                                                  PtrValue;
+       typedef stlplus::hash<std::string,PtrValue,getHash>             PtrMap;
 
-public:
-       explicit Mippleton(const std::string& name) :
-               name_(name) {}
-
-       inline const std::string& getName() const
-       {
-               return name_;
-       }
+       static PtrMap   ptrs_;
+       std::string             name_;
 
-       inline static T* retain(const std::string& name)
+       static T* retain(const std::string& name)
        {
-               typename ptr_map_t::iterator it = ptrs_.find(name);
+               typename PtrMap::iterator it = ptrs_.find(name);
 
                if (it != ptrs_.end())
                {
@@ -76,14 +69,19 @@ public:
                else
                {
                        T* newObj = new T(name);
-                       ptrs_.insert(ptr_map_pair_t(name, ptr_value_t(1, newObj)));
+                       ptrs_.insert(std::make_pair(name, std::make_pair(1, newObj)));
                        return newObj; 
                }
        }
 
-       inline static void releaseByName(const std::string& name)
+       static void release(T* obj)
        {
-               typename ptr_map_t::iterator it;
+               releaseByName(obj->name_);
+       }
+
+       static void releaseByName(const std::string& name)
+       {
+               typename PtrMap::iterator it;
 
                if ((it = ptrs_.find(name)) != ptrs_.end() && --(*it).second.first == 0)
                {
@@ -92,15 +90,24 @@ public:
                }
        }
 
-       inline static void release(T* obj)
+public:
+
+       explicit Mippleton(const std::string& name) :
+               name_(name) {}
+
+       const std::string& getName() const
+       {
+               return name_;
+       }
+
+       static boost::shared_ptr<T> getInstance(const std::string& name)
        {
-               releaseByName(obj->getName());
+               return boost::shared_ptr<T>(retain(name), &release);
        }
 };
 
 template <class T>
-stlplus::hash< std::string,std::pair<unsigned,T*>,hash_string >
-//std::map< std::string,std::pair<unsigned,T*> >
+stlplus::hash< std::string,std::pair<unsigned,T*>,getHash >
        Mippleton<T>::ptrs_;