patterns.cpp

Go to the documentation of this file.

#include <bits/stdc++.h>
 
using namespace std;
 
template <typename ValueType>
struct Setter_interface {
    virtual void set(ValueType i) = 0;
    virtual ~Setter_interface() = default;
};
 
template <typename ValueType>
struct Getter_interface {
    virtual ValueType get() const = 0;
    virtual ~Getter_interface() = default;
};
 
template <typename ValueType>
struct Change_interface {
    virtual void change(ValueType c) = 0;
    virtual ~Change_interface() = default;
};
 
template <typename ValueType>
class Synchronised_encapsulated_value
    : public Setter_interface<ValueType>, public Getter_interface<ValueType>, public Change_interface<ValueType>
{
    void set(ValueType i) override {
        scoped_lock writer_lock(mtx);
        value = i;
    }
 
    ValueType get() const override {
        shared_lock reader_lock(mtx); 
        return value;
    }
 
    void change(ValueType c) override {
        scoped_lock writer_lock(mtx);
        value += c;
    }
 
    mutable shared_mutex mtx; 
    ValueType value;
};
 
void oop_demo()
{
    auto client = [] (Setter_interface<int>& s, Getter_interface<int>& g) {
        s.set(1);
        assert(g.get() == 1);
    };
    Synchronised_encapsulated_value<int> v;
    Setter_interface<int>& s = v;
    Getter_interface<int>& g = v;
    client(s, g);
 
    auto client2 = [] (Setter_interface<string>& s, Getter_interface<string>& g) {
        s.set("abc");
        assert(g.get() == "abc");
    };
    Synchronised_encapsulated_value<string> v2;
    Setter_interface<string>& s2(v2);
    Getter_interface<string>& g2(v2);
    Change_interface<string>& c2(v2);
    client2(s2, g2);
    c2.change("de");
    assert(g2.get() == "abcde");
}
 
 
struct Interface
{
    virtual int method() = 0;
    virtual ~Interface() = default;
};
 
#define SINGLETON(Singleton)    \
public:             \
    /* Meyers Singleton realization */ \
    static Singleton& instance() {  \
        static Singleton me;    \
        return me;      \
    }               \
    Singleton(const Singleton&) = delete;           \
    Singleton& operator=(const Singleton&) = delete;    \
    Singleton(Singleton&&) = delete;            \
    Singleton& operator=(Singleton&&) = delete;     \
private: \
    Singleton()
 
struct Singleton_demo
{
    SINGLETON(Singleton_demo) { };
};
 
struct Factory_method_demo
{
    virtual unique_ptr<Interface> factory_method() = 0;
 
    int client() {
        auto p(factory_method());
        return p->method();
    };
};
 
struct Sample_product
    : Interface
{
    int data;
    int method() override { return data; }
    Sample_product(int d = 0) : data(d) {}
};
 
struct Sample_factory_method_demo
    : Factory_method_demo
{
    unique_ptr<Interface> factory_method() override {
        return make_unique<Sample_product>(123);
    }
};
 
struct Abstract_factory
{
    virtual unique_ptr<Interface> create() = 0;
};
 
struct Sample_factory
    : Abstract_factory
{
    virtual unique_ptr<Interface> create() {
        return make_unique<Sample_product>();
    }
};
 
struct Prototype
    : Abstract_factory, Interface
{
 
    int method() override { return 1; }
    unique_ptr<Interface> create() override {
        auto clone = new Prototype(*this);
        return unique_ptr<Interface>(clone);
    }
};
 
struct Builder
{
    int data = 0;
    Builder& add(int i) {
        data += i;
        return *this;
    }
 
    Builder& operator <<(int i) { return add(i); }
 
    Interface& create()
    {
        return *new Sample_product(data);
    }
};
 
void creational_patterns_demo()
{
    Singleton_demo& singe = Singleton_demo::instance();
 
    unique_ptr<Abstract_factory> factory(new Sample_factory());
 
    auto product = factory->create();
 
    Prototype p1;
    auto p2 = p1.create();
 
    Sample_factory_method_demo C;
    assert(C.client() == 123);
 
    Interface& p = (Builder().add(1).add(2) << 3 << 4).create();
    assert(p.method() == 10);
    // strstream looks like string builder
    delete &p;
}
 
 
struct Standalone