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;
 
struct Member
{
    Mediator* mediator;
    void send(Message& );
    void receive(Message& ) { }
};
 
struct Mediator
{
    void register_member(Member& m) {
        m.mediator = this;
        members.push_front(m);
    }
    void receive(Message& msg) {
        for (Member& m : members)
            m.receive(msg);
    }
    forward_list<reference_wrapper<Member>> members;
};
 
void Member::send(Message& m)
{
    mediator->receive(m);
}
 
void mediator_demo()
{
    Member m1, m2;
    Mediator md;
    md.register_member(m1);
    md.register_member(m2);
    Message msg;
    m1.send(msg);
}
 
void behavioral_patterns_demo()
{
    Chain_of_responsibility chain;
    chain.register_handler(Handler());
 
    Command cmnd;
    chain.handle(cmnd);
 
    Observer o;
    Subject s;
    s.observers.push_front(o);
 
    visitor_demo();
 
    mediator_demo();
}
 
 
struct Model
    : Subject
{
    void register_observer(Observer& o) {
        observers.push_front(o);
    }
 
    int command(Command& cmnd) {
        int rc = cmnd.execute();
        notify_observers();
        return rc;
    }
 
    int command(Command&& cmnd) {
        int rc = cmnd.execute();
        notify_observers();
        return rc;
    }
};
 
struct View
    : public Observer
{
    View(Model& m) : model(m) {};
 
    void notify() override {
        // check model
        (void)model;
    }
 
    Model& model;
};
 
struct Controller
{
    Model& mod; // can be many models
    Controller(Model& s) : mod(s) { };
 
    int command(Command& cmnd) {
        return mod.command(cmnd);
    }
 
    int command(Command&& cmnd) {
        return mod.command(cmnd);
    }
};
 
struct Subscriber
{
    void message(Message& m) {
    };
};
 
struct Publisher
{
    map<string, forward_list<reference_wrapper<Subscriber>>> topic_subscribers;
 
    void publish(const string& topic, Message& m) {
        for (Subscriber& s : topic_subscribers[topic])
            s.message(m);
    }
};
 
void architectural_patterns_demo()
{
    Model mod;
    View view(mod);
    mod.register_observer(view);
    mod.notify_observers();
    Controller ctrl(mod);
    ctrl.command(Command());
    Command cmnd;
    ctrl.command(cmnd);
 
    Subscriber sub;
    Publisher pub;
    pub.topic_subscribers["sample_topic"].push_front(sub);
    Message m;
    pub.publish("sample_topic", m);
}
 
 
template <typename T,  class Container = std::queue<T>>
class Synchronized_queue
    : Container
{
    mutex mtx;
public:
    condition_variable cv;
    bool stop = false;
    void push(T&& v) {
        scoped_lock<mutex>{mtx}, Container::push(v);
        cv.notify_one();
    };
 
    optional<reference_wrapper<T>> pull() {
        unique_lock<mutex> lk(mtx);
        cv.wait(lk, [&] { return !this->empty() || stop; });
        optional<reference_wrapper<T>> ret;
        if (stop) {
            ret =  nullopt;
        } else {
            ret = make_optional(ref(Container::front()));
            this->pop();
        }
        return ret;
    };
};
 
struct Active_object
    : Interface
{
    typedef function<void()> Command;
    Interface& subject;
    Active_object(Interface& s)
        : subject(s)
    {
        th = thread([this] {
            while (true) {
                auto cmd = cmd_q.pull();
                if (!cmd.has_value())
                    break;
                cmd.value()();
            }
        });
    }
    ~Active_object() {
        cmd_q.stop = true;
        cmd_q.cv.notify_one();
        th.join();
    }
 
    int method() override {
        promise<int> p;
        future f = p.get_future();
        cmd_q.push([&p, this] { p.set_value(subject.method());});
        return f.get();
    }
 
protected:
    Synchronized_queue<Command> cmd_q;
    thread th;
};
 
void concurrency_patterns_demo()
{
    Sample_product sp(3);
    Active_object ao(sp);
    assert(ao.method() == 3);
}
 
 
 
int main()
{
    oop_demo();
    creational_patterns_demo();
    structural_patterns_demo();
    behavioral_patterns_demo();
    architectural_patterns_demo();
    concurrency_patterns_demo();
}