1 files changed, 118 insertions, 0 deletions

diff --git a/include/konforka/resource_pile.h b/include/konforka/resource_pile.h
new file mode 100644
index 0000000..d76a07b
--- a/dev/null
+++ b/include/konforka/resource_pile.h
@@ -0,0 +1,118 @@
+#ifndef __KONFORKA_RESOURCE_PILE_H
+#define __KONFORKA_RESOURCE_PILE_H
+
+#include <map>
+#include <konforka/responsible_wrapper.h>
+
+/**
+ * @file
+ * @brief resource-piling base support.
+ *
+ * Base for implementing resource-piling.
+ */
+
+namespace konforka {
+    using std::multimap;
+    using std::pair;
+
+    /**
+     * @brief template base class for resource piling.
+     *
+     * @param key_t the type used for keying resources.
+     * @param value_t the type of resource itself.
+     * @param factory_t the factory class, providing value_t allocate(key_t)
+     * static member.
+     */
+    template<typename key_t,typename value_t,typename factory_t>
+        class resource_pile_base : public responsible_wrapper<value_t> {
+            /**
+             * @brief the type of the pile container itself.
+             */
+            typedef multimap<key_t,value_t> pile_t;
+            /*
+             * @brief the pile of resources.
+             */
+            static pile_t pile;
+            public:
+            /**
+             * @brief stored value for the key associated with the resource
+             * contained.
+             */
+            key_t _key;
+
+            /**
+             * @brief default constructor fetches or allocates resource.
+             *
+             * @param k the key for resource.
+             * @see allocate
+             */
+            resource_pile_base(const key_t& k) {
+                allocate(k);
+            }
+            /**
+             * @brief destructor releases the resource back to pile.
+             */
+            virtual ~resource_pile_base() { this->drop(); }
+
+            /**
+             * @brief this is where the resource is handed back to pile.
+             */
+            void release() {
+                pile.insert(pair<key_t,value_t>(_key,this->opkele));
+            }
+
+            /**
+             * @brief fetch from pile or allocate the resource.
+             *
+             * Try to see if we have a piled resource keyed to the argument. If
+             * we do -- fetch it from the pile, otherwise allocate anew.
+             *
+             * @param k the key for resource.
+             */
+            void allocate(const key_t& k) {
+                this->drop();
+                typename pile_t::iterator i = pile.find(k);
+                if(i==pile.end()) {
+                    this->attach(factory_t::allocate(k));
+                }else{
+                    this->attach(i->second);
+                    try{ pile.erase(i); }catch(...){ _key = k; throw; }
+                }
+                _key = k;
+            }
+
+        };
+
+    template<typename key_t,typename value_t,typename factory_t>
+        typename resource_pile_base<key_t,value_t,factory_t>::pile_t
+            resource_pile_base<key_t,value_t,factory_t>::pile;
+
+    /**
+     * @brief the generic single parameter new-based resource factory.
+     *
+     * The generic resource factory using new as a way to allocate resource
+     * using the single-parameter constructor.
+     *
+     * @param key_t the key type.
+     * @param value_t the resource type.
+     *
+     * @see resource_pile_base
+     */
+    template<typename key_t,typename value_t>
+        struct resource_pile_generic_ptr_factory {
+            public:
+                /**
+                 * @brief allocate the resource using new.
+                 *
+                 * @param k the key.
+                 * @return pointer to the newly allocated object.
+                 */
+                static value_t *allocate(const key_t& k) {
+                    return new value_t(k);
+                }
+        };
+
+}
+
+#endif /* __KONFORKA_RESOURCE_PILE_H */
+/* vim:set ft=cpp: */