add two more patterns

Author: xiao cheng

CMakeLists.txt

@@ -15,4 +15,6 @@ if(Boost_FOUND)
     add_subdirectory(Singleton)
     add_subdirectory(DependencyInjection)
     add_subdirectory(BuildPattern)
+    add_subdirectory(Proto)
+    add_subdirectory(ObjectPool)
 endif()

ObjectPool/CMakeLists.txt

@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.8)
+
+project(ObjectPool)
+
+include_directories(${Boost_INCLUDE_DIRS})
+
+add_executable(${PROJECT_NAME} ObjectPool.hpp main.cpp)
+
+target_link_libraries(${PROJECT_NAME} PUBLIC 
+ gtest_main
+ ${Boost_LIBRARIES}
+ )
+
+ add_test(
+     NAME ${PROJECT_NAME}
+     COMMAND ${PROJECT_NAME}
+ )
+ install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ../bin)

ObjectPool/ObjectPool.hpp

@@ -0,0 +1,115 @@
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <stack>
+#include <tuple>
+
+using namespace std;
+
+class IPoolableObject
+{
+  public:
+    virtual ~IPoolableObject() = default;
+    virtual void reset() = 0;
+
+  protected:
+    IPoolableObject() = default;
+};
+
+class UsedObject : public IPoolableObject
+{
+  public:
+    UsedObject(int init_num = 0) : _num{init_num}, _init_num{init_num} {};
+    void increment() { ++_num; }
+
+    void print() { std::cout << "My number is: " << _num << std::endl; }
+    void reset() override { _num = _init_num; }
+
+  private:
+    int _num;
+    int _init_num;
+};
+
+// parameter pack , can accept any number of arguments
+// Variadic templates
+template <typename T, typename... Args>
+class ObjectPool
+{
+  public:
+    template <typename P>
+    using pointer_type = std::unique_ptr<P, std::function<void(P *)>>;
+
+    ObjectPool(std::size_t init_size = 0, std::size_t max_size = 10, Args &&... args)
+        : _max_size{max_size}, _available{max_size}, _size{0}, _args{args...} // store pack parameter into tuples for later use
+    {
+        static_assert(std::is_base_of<IPoolableObject, T>::value, "Must be poolable object");
+        initialize(init_size);
+    }
+
+    pointer_type<T> get()
+    {
+        if (_pool.empty())
+        {
+            if (_available == 0)
+            {
+                return nullptr;
+            }
+            add();
+        }
+        --_available;
+        auto inst = std::move(_pool.top());
+        _pool.pop();
+        return std::move(inst);
+    }
+
+    std::size_t free() { return _available; }
+    std::size_t max_size() { return _max_size; }
+    std::size_t size() { return _size; }
+    bool empty() { return _pool.empty(); }
+
+  private:
+    // Adds a new object to the pool
+    void add(T *ptr = nullptr)
+    {
+        if (ptr == nullptr)
+        {
+            ptr = create_with_params(std::index_sequence_for<Args...>());
+            ++_size;
+        }
+        else
+        {
+            ptr->reset();
+            ++_available;
+        }
+
+        pointer_type<T> inst(ptr, [this](T *ptr) {
+            // This is the custom deleter of the unique_ptr.
+            // When the object is deleted in the callers context, it will be
+            // returned back to the pool by utilizing the add function
+            add(ptr);
+        });
+
+        _pool.push(std::move(inst));
+    }
+
+    template <std::size_t... Is>
+    T *create_with_params(const std::index_sequence<Is...> &)
+    {
+        return new T(std::get<Is>(_args)...);
+    }
+
+    // Initializes the pool
+    void initialize(std::size_t init_size)
+    {
+        for (std::size_t i = 0; i < init_size; ++i)
+        {
+            add();
+        }
+    }
+
+    std::size_t _max_size;
+    std::size_t _available;
+    std::size_t _size;
+    std::stack<pointer_type<T>> _pool;
+    std::tuple<Args...> _args;
+};

ObjectPool/main.cpp

@@ -0,0 +1,35 @@
+#include "ObjectPool.hpp"
+#include <cassert>
+#include <iostream>
+
+int main() {
+    ObjectPool<UsedObject, int> pool(0, 2, 5);
+    std::cout << "Initialized object pool with max size of " << pool.max_size() << std::endl;
+    std::cout << "Size of the pool: " << pool.size() << std::endl;
+    std::cout << "Available objects: " << pool.free() << std::endl;
+
+    auto inst = pool.get();
+    inst->increment();
+    inst->print();
+
+    std::cout << "Available objects: " << pool.free() << std::endl;
+    std::cout << "Size of the pool: " << pool.size() << std::endl;
+    {
+        auto inst2 = pool.get();
+        inst->increment();
+        inst->print();
+        std::cout << "Instance 2 pointer is " << inst2.get() << std::endl;
+        std::cout << "Available objects: " << pool.free() << std::endl;
+        std::cout << "Size of the pool: " << pool.size() << std::endl;
+    }
+
+    std::cout << "Available objects: " << pool.free() << std::endl;
+    std::cout << "Size of the pool: " << pool.size() << std::endl;
+    auto inst2 = pool.get();
+    std::cout << "Instance 2 pointer is " << inst2.get() << std::endl;
+
+    auto inst3 = pool.get();
+    assert(inst3 == nullptr);
+    assert(pool.empty());
+    std::cout << "Pool is empty, all objects are in use" << std::endl;
+}

Proto/CMakeLists.txt

@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.8)
+
+project(Proto)
+
+include_directories(${Boost_INCLUDE_DIRS})
+
+add_executable(${PROJECT_NAME} Proto.cpp)
+
+target_link_libraries(${PROJECT_NAME} PUBLIC 
+ gtest_main
+ ${Boost_LIBRARIES}
+ )
+
+ add_test(
+     NAME ${PROJECT_NAME}
+     COMMAND ${PROJECT_NAME}
+ )
+ install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ../bin)

Proto/Proto.cpp

@@ -0,0 +1,95 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+using namespace std;
+const int N = 4;
+
+// Prototype
+class Document
+{
+  public:
+    virtual Document *clone() const = 0;
+    virtual void store() const = 0;
+    virtual ~Document() {}
+};
+
+// Concrete prototypes : xmlDoc, plainDoc, spreadsheetDoc
+
+class xmlDoc : public Document
+{
+  public:
+    Document *clone() const { return new xmlDoc; }
+    void store() const { cout << "xmlDoc\n"; }
+};
+
+class plainDoc : public Document
+{
+  public:
+    Document *clone() const { return new plainDoc; }
+    void store() const { cout << "plainDoc\n"; }
+};
+
+class spreadsheetDoc : public Document
+{
+  public:
+    Document *clone() const { return new spreadsheetDoc; }
+    void store() const { cout << "spreadsheetDoc\n"; }
+};
+
+// makeDocument() calls Concrete Portotype's clone() method
+// inherited from Prototype
+class DocumentManager
+{
+  public:
+    static Document *makeDocument(int choice);
+    ~DocumentManager() {}
+
+  private:
+    static Document *mDocTypes[N];
+};
+
+Document *DocumentManager::mDocTypes[] =
+    {
+        0, new xmlDoc, new plainDoc, new spreadsheetDoc};
+
+Document *DocumentManager::makeDocument(int choice)
+{
+    return mDocTypes[choice]->clone();
+}
+
+// for_each op ()
+struct Destruct
+{
+    void operator()(Document *a) const
+    {
+        delete a;
+    }
+};
+
+// Client
+int main()
+{
+    vector<Document *> docs(N);
+    int choice;
+    cout << "quit(0), xml(1), plain(2), spreadsheet(3): \n";
+    while (true)
+    {
+        cout << "Type in your choice (0-3)\n";
+        cin >> choice;
+        if (choice <= 0 || choice >= N)
+            break;
+        docs[choice] = DocumentManager::makeDocument(choice);
+    }
+
+    for (int i = 1; i < docs.size(); ++i)
+        if (docs[i])
+            docs[i]->store();
+
+    Destruct d;
+    // this calls Destruct::operator()
+    for_each(docs.begin(), docs.end(), d);
+
+    return 0;
+}