Module* ptr;

shared_ptr<Module> sm;

unique_ptr<Module> um;

{

Module m1, m2;

Reference r { m1, m2 };

Pointer p { &m1 };

// References can't be changed or zeroed like pointers during runtime.

p.ptr = nullptr;

{

virtual ValueType get() const = 0;

virtual ~Getter_interface() noexcept = default;

{

virtual void change(ValueType c) = 0;

virtual ~Change_interface() noexcept = default;

/**

: 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); /// [reader writer locks](https://www.modernescpp.com/index.php/reader-writer-locks)

return value;

}

void change(ValueType c) override

{

scoped_lock writer_lock(mtx);

value += c;

}

mutable shared_mutex mtx; ///< [shared_mutex](https://en.cppreference.com/w/cpp/thread/shared_mutex)

ValueType value;

{

auto client = [](Setter_interface<int>& s, Getter_interface<int>& g) {

s.set(1);

assert(g.get() == 1);

};

Synchronized_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");

};

Synchronized_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");

{

associations_demo();

synchronized_encapsulated_value();

{

virtual int method() = 0;

virtual ~Interface() noexcept = default;

virtual unique_ptr<Interface> factory_method() = 0;

int client()

{

auto p(factory_method());

return p->method();

};

: Interface {

int data;

int method() override { return data; }

Sample_product(int d = 0)

: data(d)

{

}

: Factory_method_demo {

unique_ptr<Interface> factory_method() override

{

return make_unique<Sample_product>(123);

}

: Abstract_factory {

virtual unique_ptr<Interface> create()

{

return make_unique<Sample_product>();

}

/// @brief is the factory of himself

: Abstract_factory,

Interface {

int method() override { return 1; }

unique_ptr<Interface> create() override

{

auto clone = new Prototype(*this);

return unique_ptr<Interface>(clone);

}

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);

}

{

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);

// stringstream looks like string builder

delete &p;

{

float standalone_method() const

{

return 1.01;

}

/// @brief is a wrapper using different from Standalone interface. AKA Adapter

: public Interface {

Bridge(Standalone& s)

: standalone(s)

{

}

int method() override

{

return this->standalone.standalone_method();

}

Standalone& standalone;

/// @brief is a opaque wrapper with same as wrapped object Interface

: public Interface {

Proxy(Interface& o)

: subject(o)

{

}

int method() override

{

return this->subject.method();

}

Interface& subject;

/// @brief is a partial wrapper of an object with same as wrapped object Interface

: public Interface {

Decorator(Interface& o)

: subject(o)

{

}

int method() override

{

return 100 + this->subject.method();

}

Interface& subject; // decorated object is public

: public Interface {

int method() override

{

for (Interface& i : children)

i.method();

return 0;

}

forward_list<reference_wrapper<Interface>> children;

{

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();

{

/// @brief without arguments

virtual void notify() {};

/// @brief with the only Subject argument

virtual void update(Subject& subject) {};

virtual ~Observer() noexcept = default;

{

void notify_observers()

{

for (Observer& o : observers) {

o.notify();

o.update(*this);

}

}

forward_list<reference_wrapper<Observer>> observers;

{

Observer o;

Subject s;

s.observers.push_front(o);

s.notify_observers();

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);

}

{

Subscriber sub;

Publisher pub;

pub.topic_subscribers["sample_topic"].push_front(sub);

Message m;

pub.publish("sample_topic", m);

Mediator* mediator;

void send(Message&);

void receive(Message&) { }

void register_member(Member& m)

{

m.mediator = this;

members.push_front(m);

}

void dispatch(Message& msg)

{

for (Member& m : members)

m.receive(msg);

}

forward_list<reference_wrapper<Member>> members;

{

Member m1, m2;

Mediator md;

md.register_member(m1);

md.register_member(m2);

Message msg;

m1.send(msg);

{

virtual int execute() { return -1; };

{

virtual string component_accept(Abstract_visitor&) const = 0;

virtual ~Component() = default;

const forward_list<unique_ptr<Abstract_visitor>>& visitors)

{

string res;

for (auto&& v : visitors)

for (auto&& c : components) {

assert(typeid(c) != typeid(Component));

res += string(__func__) + " > " + c->component_accept(*v.get());

}

return res;

{

/// overloaded function for each component subtype

virtual string visit(const Sample_component&) const = 0;

virtual ~Abstract_visitor() noexcept = default;

: public Component

{

string component_accept(Abstract_visitor& visitor) const override

{

assert(typeid(*this) == typeid(Sample_component));

assert(typeid(visitor) != typeid(Abstract_visitor));

return string(__func__) + " > " + visitor.visit(*this);

}

/// @brief is not virtual

string sample_component_method() const

{

return __func__;

}

{

/// @brief is one of many specific visitors with custom method visit

/// Per each of the possible pairs of Sample_visitor and Sample_component

struct Sample_visitor

: public Abstract_visitor {

/// overloaded function for each component

string visit(const Sample_component& sc) const override

{

assert(typeid(*this) == typeid(Sample_visitor));

assert(typeid(sc) == typeid(Sample_component));

return string(__func__) + " > " + sc.sample_component_method();

}

};

forward_list<unique_ptr<Component>> components;

components.emplace_front(new Sample_component);

forward_list<unique_ptr<Abstract_visitor>> visitors;

visitors.emplace_front(new Sample_visitor);

assert(client_visit(components, visitors) == "client_visit > component_accept > visit > sample_component_method");

// flat code of expanded client_visit:

for (auto&& v : visitors) {

if (auto sv = dynamic_cast<Sample_visitor*>(v.get()))

for (auto&& c : components) {

if (auto sc = dynamic_cast<Sample_component*>(c.get()))

// inside component_accept:

sv->visit(*sc);

else {

};

}

else {

/* And so on for each pair of visitor and component.

};

}

void operator()(int arg) { output << "int "; };

void operator()(long arg) { output << "long "; };

void operator()(double arg) { output << "double "; };

void operator()(string arg) { output << "string "; };

{

// trivial visit call

visit([](auto&& arg) {}, variant<int> { 1 });

// practical visit usage

using Components = variant<int, long, double, string>;

vector<Components> comps = { 10, 15l, 1.5, "hello" };

Visitor_op visitors;

for (auto& c : comps)

visit(visitors, c);

assert(output.str() == "int long double string ");

{

/// Specific handler can process a command and return non-negative

virtual int handle(Command& cmnd) { return cmnd.execute(); };

virtual ~Handler() noexcept = default;

: 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;

}

list<reference_wrapper<Handler>> handlers;

{

observer_demo();

publisher_subscriber_demo();

mediator_demo();

Chain_of_responsibility chain;

chain.register_handler(Handler());

Command cmnd;

chain.handle(cmnd);

visitor_demo();

visitor_std_demo();

: 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;

}

/// @brief is concrete Observer

: public Observer {

View(Model& m)

: model(m) {};

void notify() override

{

// check model

(void)model;

}

Model& model;

{

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);

}

{

Model mod;

View view(mod);

mod.register_observer(view);

mod.notify_observers();

Controller ctrl(mod);

ctrl.command(Command());

Command cmnd;

ctrl.command(cmnd);

/**

: Container {

mutex mtx;

bool stoped = false;

condition_variable cv;

void push(T&& v)

{

lock_guard<mutex> { mtx }, Container::push(v);

cv.notify_one();

};

T& pull()

{

unique_lock<mutex> lk(mtx);

cv.wait(lk, [&] { return !this->empty() || stoped; });

if (stoped)

throw "stopped";

T& ret = Container::front();

this->pop();

return ret;

};

void stop()

{

stoped = true;

cv.notify_all();

}

/** @brief [Active object](https://en.wikipedia.org/wiki/Active_object)

: Interface {

typedef function<void()> Command;

Interface& subject;

Active_object(Interface& s)

: subject(s)

{

th = thread([this] {

try {

while (true)

cmd_q.pull()(); // call Command

} catch (...) {

}

});

}

~Active_object() noexcept

{

cmd_q.stop();

th.join();

}

int method() override

{

promise<int> p;

future f = p.get_future();

cmd_q.push([&p, this] { p.set_value(subject.method()); });

auto status = f.wait_for(1s);

if (status != future_status::ready)

throw status;

return f.get();

}

Synchronized_queue<Command> cmd_q; // BTW, Circular buffer is more durable because it doesn't cause OOM

thread th;

{

Sample_product sp(3);

Active_object ao(sp);

assert(ao.method() == 3);

{

oop_demo();

creational_patterns_demo();

structural_patterns_demo();

behavioral_patterns_demo();

architectural_patterns_demo();

concurrency_patterns_demo();