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
{
    float standalone_method() const {
        return 1.01;
    }
};
 
struct Bridge
    : public Interface
{
    Bridge(Standalone& s): standalone(s) {
//      trace(typeid(*this).name());
    }
    int method() override {
        return this->standalone.standalone_method();
    }
private:
    Standalone& standalone;
};
 
struct Proxy
    : public Interface
{
    Proxy(Interface& o): subject(o) {}
    int method() override {
        return this->subject.method();
    }
private:
    Interface& subject;
};
 
struct Decorator
    : public Interface
{
    Decorator(Interface& o): subject(o) {}
    int method() override {
        return 100 + this->subject.method();
    }
    Interface& subject; // decorated object is public
};
 
struct Composite
    : public Interface
{
    int method() override {
        //trace();
        for (Interface& i : children) i.method();
        return 0;
    }
    forward_list<reference_wrapper<Interface>> children;
};
 
void structural_patterns_demo()
{
    Standalone sa;
    Bridge br(sa);
    br.method();
    Proxy p(br);
    Decorator dec(br);
    dec.method();
    dec.subject.method();
    p.method();
    Composite comp;
    comp.children.push_front(p);
    comp.method();
}
 
 
struct Subject;
 
struct Observer
{
    virtual void notify() {};
    virtual void update(Subject& subject) {};
    virtual ~Observer() = default;
};
 
struct Subject
{
    void notify_observers() {
        for (Observer& o : observers)  {
            o.notify();
            o.update(*this);
        }
    }
    forward_list<reference_wrapper<Observer>> observers;
};
 
struct Command
{
    virtual int execute() { return -1; };
};
 
 
struct Visitor;
 
struct Component
{
    virtual string component_accept(Visitor&) const = 0;
    virtual ~Component() = default;
};
 
struct Sample_component;
struct Visitor
{
    virtual string visit(const Sample_component&) const = 0;
    virtual ~Visitor() = default;
};
 
struct Sample_component
    : public Component
{
    string component_accept(Visitor& visitor) const override {
        return string(__func__) + " > " + visitor.visit(*this);
    }
    string component_method() const {
        return __func__;
    }
};
 
string client_visit(const forward_list<unique_ptr<Component>>& components,
            const forward_list<unique_ptr<Visitor>>& visitors)
{
    string res;
    for (auto&& comp : components) 
        for (auto&& vis : visitors) {
            res += string(__func__) + " > " + comp->component_accept(*vis.get());
        }
    return res;
}
 
void visitor_demo()
{
    struct Sample_visitor
        : public Visitor {
        string visit(const Sample_component& c) const override {
            return string(__func__) + " > " + c.component_method();
        }
    };
 
    forward_list<unique_ptr<Component>> components;
    components.emplace_front(new Sample_component);
    Sample_visitor v;
    forward_list<unique_ptr<Visitor>> visitors;
    visitors.emplace_front(new Sample_visitor);
    assert(client_visit(components, visitors) ==
          "client_visit > component_accept > visit > component_method");
}
 
 
struct Handler
{
    virtual int handle(Command& cmnd) { return cmnd.execute(); };
    virtual ~Handler() = default;
};
 
struct Chain_of_responsibility
    : Handler
{
    void register_handler(Handler&& h, bool front = false) {
        if (front)
            handlers.push_front(h);
        else
            handlers.push_back(h);
    }
    int handle(Command& cmnd) override {
        int rc = -1;
        for (Handler& h : handlers)
            if ((rc = h.handle(cmnd)) >= 0)
                return rc;
        return rc;
    }
private:
    list<reference_wrapper<Handler>> handlers;
};
 
struct Message { };
 
struct Mediator;