CPP / C++ Notes - Design Patterns

//----- file: FileRepository.hpp ------//
#ifndef __file_repository 
#define __file_repository
#include <std::string>

class FileRepository
{
private:
    std::deque<std::string> _files; 
    // Forbid client code instating a new instance. 
    FileRepository(){
       std::cerr << " [LOG] File Respository Initialized." << "\n";
    }   
    // Forbid client code from creating a copy or using the
    // copy constructor.
    FileRepository(const FileRepository&){}     
public:
    ~FileRepository();

    // Return a reference to not allow client code 
    // to delete object.    
    static auto getInstance() -> FileRepository&;   

    // Use old C++ 'member function' syntax.
    void addFile(std::string fname);
    void clearFiles();
    // C++11 member function declaration looks better. 
    auto showFiles() -> void;
};
#endif 

#include <iostream>
#include "FileRepository.hpp"

FileRepository::~FileRepository(){
      std::cerr << " [LOG] File Respository Deleted. Ok." << "\n";
}

// Static method 
auto FileRepository::getInstance() -> FileRepository& {
     static auto instance = std::unique_ptr<FileRepository>{nullptr};       
     // Initialized once - lazy initialization 
     if(!instance)
          instance.reset(new FileRepository);       
     return *instance.get();
}

void FileRepository::addFile(std::string fname){
     _files.push_back(std::move(fname));
}

void FileRepository::clearFiles(){
     _files.clear();
}
// C++11 Member function declaration 
auto FileRepository::showFiles() -> void {
     for(const auto& file: _files)
        std::cout << " File = " << file << std::endl;
}

 // Load C++ code as it was a script.
 >> .L singleton1.cpp

 // Try to instantiate singleton object without reference. 
 //------------------------------------------------------
 >> FileRepository repo = FileRepository::getInstance()
 ROOT_prompt_2:1:23: error: calling a private constructor of class 'FileRepository'
 FileRepository repo = FileRepository::getInstance()
                       ^
 singleton1.cpp:21:5: note: declared private here
     FileRepository(const FileRepository&){}
     ^
 >> FileRepository& repo = FileRepository::getInstance()
 [LOG] File Respository Initialized.

 (FileRepository &) @0x2fc9640
 >> 

 >> repo.showFiles()
 >> 
 >> repo.addFile("quarterly-sales-report.dat")
 >> repo.addFile("interest-payments.txt")
 >> repo.addFile("taxes-report.xls")
 >> repo.showFiles()
  File = quarterly-sales-report.dat
  File = interest-payments.txt
  File = taxes-report.xls
 >> 
 >> 

 // Try to copy object. 
 >> FileRepository r = repo;
 ROOT_prompt_9:1:20: error: calling a private constructor of class 'FileRepository'
 FileRepository r = repo;
                    ^
 singleton1.cpp:21:5: note: declared private here
     FileRepository(const FileRepository&){}
     ^
 >> 

 // Try to create a new object 
 >> FileRepository& repo2 = FileRepository::getInstance()
 (FileRepository &) @0x2fc9640
 >> repo2.showFiles()
  File = quarterly-sales-report.dat
  File = interest-payments.txt
  File = taxes-report.xls
 >> 

 // Check whether repo and repo2 are the same object (reference equality)
 // -> They are equal under reference equality criteria if they have the same address.
 >> &repo == &repo2
 (bool) true
 >> 

 // Exit REPL.
 >> .q
[LOG] File Respository Deleted. Ok.

FileRepository& repo1 = FileRepository::getInstance();
repo1.addFile("CashFlowStatement.txt");
repo1.addFile("Balance-Sheet.dat");
repo1.addFile("Sales-Report.csv");

FileRepository& repo2 = FileRepository::getInstance();

std::cout << std::boolalpha << "Same object? (&repo == &repo1 ?) = "
          << (&repo1 == &repo2)
          << "\n";
std::cout << "Repository files" << std::endl;
repo2.showFiles();

std::cout << "Add more files" << std::endl;
repo2.addFile("fileX1.pdf");
repo2.addFile("fileX2.pdf");
repo2.addFile("fileX3.pdf");
repo2.showFiles();

clang++ singleton1.cpp -o singleton1.bin -g -std=c++14 -Wall -Wextra && ./singleton1.bin

 [LOG] File Respository Initialized.
Same object? (&repo == &repo1 ?) = true
Repository files
 File = CashFlowStatement.txt
 File = Balance-Sheet.dat
 File = Sales-Report.csv
Add more files
 File = CashFlowStatement.txt
 File = Balance-Sheet.dat
 File = Sales-Report.csv
 File = fileX1.pdf
 File = fileX2.pdf
 File = fileX3.pdf
 [LOG] File Respository Deleted. Ok.

GLFWkeyfun glfwSetKeyCallback   (  GLFWwindow * window
                               , GLFWkeyfun     callback 
                              );

// C notation for function pointer type alias. 
typedef void(* GLFWkeyfun) (GLFWwindow *, int, int, int, int);

// C++ notation for function pointer type alias.  
using GLFWkeyfun = void (*) (GLFWwindow *, int, int, int, int);

// Brief: Draw curve copying data to the GPU 
#include <iostream>
#include <vector> 
#include <array>
#include <functional>
#include <map>
#include <cmath>
#include <cassert>

// -------- OpenGL headers ---------//
#define GL_GLEXT_PROTOTYPES 1 // Necessary for OpenGL >= 3.0 functions
#define GL3_PROTOTYPES      1 // Necessary for OpenGL >= 3.0 functions

#include <GL/gl.h>
#include <GLFW/glfw3.h>

// #include <GL/glew.h>
#include <GL/glu.h>
#include <GL/glut.h>

// Singleton object for registering lambda event handlers for GLFW keyboard typing events.
class KeyboardManager
{
public:
    using KeyCallback = std::function<void (GLFWwindow* window)>;
    using KeyCallbackDB = std::map<int, KeyCallback>;
private:
    KeyCallbackDB m_keydb{};
    GLFWwindow*   m_window = nullptr;

    // Private constructor for not allowing client code creating more 
    // than one instance.
    KeyboardManager()
    {
       std::cerr << " [TRACE] KeyboardManager - Singleton initialized." << "\n";
    }   
    // Forbid client code from creating a copy or using the
    // copy constructor.
    KeyboardManager(const KeyboardManager&){}     
public:
    ~KeyboardManager() = default;

    // This is the unique way to get singleton instance. 
    static KeyboardManager& getInstance()
    {
        static KeyboardManager instance{};
        return instance;
    }

    KeyboardManager& 
    set_window(GLFWwindow* window)
    {
        m_window = window;

        // =>> Note: This lambda must be non-capturing. Otherwise, it will result 
        // in compile-time error. 
        // 
        // =>> Note: All this redundancy and boilerplate code is need because 
        //     the function glfwSetKeyCallback() lacks an extra void* pointer 
        //     for passing custom user data.
        ::glfwSetKeyCallback(m_window 
            ,[](GLFWwindow* window, int key, int scancode, int action, int mods)
            {
                std::cerr << " [TRACE] glfwSetKeyCallback() key = " 
                          << key << " / char " << (char) key <<  '\n';
                // Get singletion instance 
                KeyboardManager& instance = KeyboardManager::getInstance();
                auto it = instance.m_keydb.find(key);
                if(it == instance.m_keydb.end()){ return; }
                // Call callback functions.
                it->second(window);
            });         
         return *this;
    }

    KeyboardManager& 
    add_keyCallback(int key, KeyCallback callback)
    {
        this->m_keydb[key] = callback;
        return *this;
    }    

};


int main(int argc, char** argv)
{
    // Initialize GLFW 
    if ( !glfwInit() ){ return -1; }

    glutInit(&argc, argv);

    /* Create a windowed mode window and its OpenGL context */
    GLFWwindow* window = glfwCreateWindow(640, 480, "Simple triangle draw", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }
   .... ...    .... ...    .... ...    .... ... 
   .... ...    .... ...    .... ...    .... ... 

    // Get singleton instance and set window.
    KeyBoardMager& kdb = KeyboardManager::getInstance().set_window(window);

    GLenum draw_type = GL_TRIANGLES;

    // Register events 
    kdb.add_keyCallback('A', [&draw_type](GLFWwindow* win){ draw_type = GL_TRIANGLES; });    
    kdb.add_keyCallback('B', [&draw_type](GLFWwindow* win){ draw_type = GL_LINE_LOOP; });

    kdb.add_keyCallback('C', [&draw_type](GLFWwindow* win){ draw_type = GL_LINES;      });
    kdb.add_keyCallback('D', [&draw_type](GLFWwindow* win){ draw_type = GL_LINE_STRIP; });
    kdb.add_keyCallback('F', [&draw_type](GLFWwindow* win){ draw_type = GL_LINE;       }); 


    // Positive rotatation of 10 degrees around Z axis (counter - clockwise)
    kdb.add_keyCallback(GLFW_KEY_RIGHT, [&](GLFWwindow* win)
        {  
            std::cerr << " [TRACE] Postive rotation around Z axis " << '\n';
            angle = angle + 10.0;
            glUniform1f(uniform_angle, angle);
        });   

   ...    ...    ...    ...    ...    ... 
   ...    ...    ...    ...    ...    ... 

    // ============== R E N D E R - L O O P ===========================//
    //

    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {
       ....        ....        ....        ....        .... 
       ....        ....        ....        ....        .... 
    } 

} // ------ End of main() ---------------------------------------------//

template<typename Impl>
class CRTP_Singleton
{
protected:
    CRTP_Singleton() = default;
public:

    CRTP_Singleton(const CRTP_Singleton&) = delete;
    CRTP_Singleton& operator=(CRTP_Singleton const&) = delete;

    static Impl& getInstance()
    {  
        static Impl impl;
        return impl;  
    }

};

// Singleton object for registering lambda event handlers for GLFW keyboard typing events.
class KeyboardManager: public CRTP_Singleton<KeyboardManager>
{
    friend KeyboardManager::CRTP_Singleton<KeyboardManager>;
public:

    using KeyCallback = std::function<void (GLFWwindow* window)>;
    using KeyCallbackDB = std::map<int, KeyCallback>;
protected:

    KeyCallbackDB m_keydb{};
    GLFWwindow*   m_window = nullptr;

    // Private constructor for not allowing client code creating more 
    // than one instance.
    KeyboardManager(){ }
public:
    ~KeyboardManager() = default;

    KeyboardManager& 
    set_window(GLFWwindow* window)
    {
        m_window = window;
        assert( m_window != nullptr );

    ::glfwSetKeyCallback(m_window 
            ,[](GLFWwindow* window, int key, int scancode, int action, int mods)
            {
                std::cerr << " [TRACE] glfwSetKeyCallback() key = " 
                          << key << " / char " << (char) key <<  '\n';
                // Get singleton instance 
                KeyboardManager& instance = KeyboardManager::getInstance();
                auto it = instance.m_keydb.find(key);
                if(it == instance.m_keydb.end()){ return; }
                std::fprintf(stderr, " [TRACE] Execute callback function. \n");
                // Call callback functions.
                it->second(window);
            });         
         return *this;
    }

    KeyboardManager& 
    add_keyCallback(int key, KeyCallback callback)
    {

        std::fprintf(stderr, " [TRACE] Add callback key. \n");
        this->m_keydb[key] = callback;
        return *this;
    }    

};

 ... ... ... ... .... .... 
 ... ... ... ... .... .... 

 GLFWwindow* window = glfwCreateWindow(640, 480, "Simple triangle draw", NULL, NULL);

 if (!window)
 {
      std::fprintf(stderr, " [ERROR] Unable to open GLFW Window. \n");    
     glfwTerminate();
     return -1;
 }
 ... ... ... ... .... .... 

// Get singleton instance and set window.
auto& kdb = KeyboardManager::getInstance().set_window(window);

GLenum draw_type = GL_LINE_LOOP;

// Register events 
kdb.add_keyCallback('A', [&draw_type](GLFWwindow* win){ draw_type = GL_TRIANGLES; });    

// Positive rotatation of 10 degrees around Z axis (counter - clockwise)
kdb.add_keyCallback(GLFW_KEY_RIGHT, [&](GLFWwindow* win)
    {  
        std::cerr << " [TRACE] Postive rotation around Z axis " << '\n';
        angle = angle + 10.0;
        glUniform1f(uniform_angle, angle);
    });  


 ... ... ... ... .... .... 
 ... ... ... ... .... .... 
 ... ... ... ... .... .... 

class Base{
public:
   Base() = default;
    // Destructor of base class must always be virtual 
    virtual ~Base() = default;   
    virtual auto getType() const -> std::string {
      return "Base";
   }    
   void showType(){
      std::cout << "Class type = " << this->getType() << "\n";
   }
};

class DerivedA: public Base{
public:
    DerivedA(){}
    auto getType() const  -> std::string {
       return "DerivedA";
    }
};

class DerivedB: public Base{
public:
   DerivedB(){}
   auto getType() const -> std::string {
      return "DerivedB";
   }
};

#include <memory> // smart pointers 

auto simpleFactory(const std::string& name) -> std::unique<Base> {
     if(name == "Base")
         return std::make_unique<Base>();
     if(name == "DerivedA")
         return std::make_unique<DerivedA>();
     if(name == "DerivedB")
         return std::make_unique<DerivedB>();
     return nullptr;
}

>> auto base = simpleFactory("Base");
>> if(base) { std::puts("Ok, then proceed."); }
Ok, then proceed.

>> base->getType()
(std::string) "Base"

>> auto da = simpleFactory("DerivedA");
>> da->getType()
(std::string) "DerivedA"
>> 

class Factory{
private:
    using FactoryMap = std::map<std::string, Factory*>;
    // Force global variable to be initialized, thus it avoid
    // the inialization order fisaco. 
    static auto getRegister() -> FactoryMap& {
       static FactoryMap classRegister{};
       return classRegister;
    }
public: 
    /** Register factory object of derived class */
    static
    auto registerFactory(const std::string& name, Factory* factory) -> void {
         auto& reg = Factory::getRegister();
         reg[name] = factory;
    }
    /** Show all registered classes */
    static
    auto showClasses() -> void {
         std::cout << " Registered classes. " << "\n";
         std::cout << " =================== " << "\n";
         for(const auto& pair: Factory::getRegister())
                 std::cout << " + " << pair.first << "\n";
    }       
    /**  Construct derived class returning a raw pointer */
    static
    auto makeRaw(const std::string& name) -> Base* {
         auto it = Factory::getRegister().find(name);
         if(it != Factory::getRegister().end())
                 return it->second->construct();
         return nullptr;
    }

    /** Construct derived class returning an unique ptr  */
    static
    auto makeUnique(const std::string& name) -> std::unique_ptr<Base>{
        return std::unique_ptr<Base>(Factory::makeRaw(name));
    }

    // Destructor 
    virtual
    ~Factory() = default;

    virtual
    auto construct() const -> Base* = 0;
};

template<typename DerivedClass>
class ConcreteFactory: Factory{
public:
   // Register this global object on the Factory register 
   ConcreteFactory(const std::string& name){
      std::cerr << " [TRACE] " << " Registered Class = " << name << "\n";
      Factory::registerFactory(name, this);
   }
   auto construct() const -> Base* {
      return new DerivedClass;
   }    
};

// Register Base class
namespace {
   // Anonymous namespace is used to make the definitions here private to the current
   // compilation unit (current file). It is equivalent to the old C static keyword.
   // It could be placed at Base.cpp 
   ConcreteFactory<Base> factoryBase("Base");
}

// Macro for class registration 
#define REGISER_FACTORY(derivedClass) \
        namespace { auto registry_ ## derivedClass = ConcreteFactory<derivedClass>(#derivedClass);  }

//  Registration with macro. 
REGISER_FACTORY(DerivedA);
REGISER_FACTORY(DerivedB);

Factory::showClasses();
std::cout << "\n";
std::unique_ptr<Base> objBase = Factory::makeUnique("Base");
std::cout << " type of objBase = " << objBase->getType() << "\n";

std::unique_ptr<Base> objDA = Factory::makeUnique("DerivedA");
std::cout << " type of derivedA = " << objDA->getType() << "\n";

std::unique_ptr<Base> objDB = Factory::makeUnique("DerivedB");
std::cout << " type of derivedA = " << objDB->getType() << "\n";

std::unique_ptr<Base> objDC = Factory::makeUnique("Derived-error");
if(!objDC)
   std::cout << " ==> Error: object not found in factory" << '\n';

$ clang++ factory-pattern1.cpp -o factory-pattern1.bin -g -std=c++1z -Wall -Wextra $

$ ./factory-pattern1.bin
 [TRACE]  Registered Class = Base
 [TRACE]  Registered Class = DerivedA
 [TRACE]  Registered Class = DerivedB
 Registered classes. 
 =================== 
 + Base
 + DerivedA
 + DerivedB

 type of objBase = Base
 type of derivedA = DerivedA
 type of derivedA = DerivedB
 ==> Error: object not found in factory

     +-------------------------------------+
     | <<Interface>> IComponent            |
     |-------------------------------------|
     |  +Operation()                       |
     +------------^----------------^-------+
                  |                |
           +------+                +
           |                       +-------+
           |                               |
+----------+-----------+      +-----------------------------+
|  Component           |      | Decorator                   |
|----------------------|      |-----------------------------|
|  +Operation()        |      | Variable: IComponen comp    |
|                      |      |                             |
+----------------------+      | +Decorator(IComopent comp)  |
                              |                             |
                              | +Operation(){               |
                              |   newBehavior();            |
                              |   comp.Operation();         |
                              |  }                          |
                              +-----------------------------+

// Interface IShape (IComponent) 
struct IShape
{
  virtual auto draw() -> void = 0;
  virtual auto description() -> std::string = 0;
  virtual ~IShape() = default;
};

// Component class
class Square: public IShape
{
public:
   auto draw() -> void
   {
      std::cout << " => Draw square" << std::endl;
   }
   auto description() -> std::string 
   {
      return "square";
   }
};

// Component class 
class Triangle: public IShape
{
public:
    auto draw() -> void
    {
       std::cout << " => Draw tringle" << std::endl; 
    }
    auto description() -> std::string
    {
       return "triangle";
    }
};

// Decorator 1 => Draw shape with color
class ColorDecorator: public IShape {
public:
    ColorDecorator(std::shared_ptr<IShape> shape)
       : m_shape(shape) { }
    auto draw() -> void
    {
        // Save color:   push() 
        std::cout << " => [ColorDecorator] Draw object with color blue" << std::endl;
        m_shape->draw();
        // Restore color: pop()
    }
    auto description() -> std::string
    {
        return  m_shape->description() + " ; color = " + m_color;
    }
    // Return a reference to itself (ColorDecorator&)
    auto setColor(const std::string& color) -> decltype(*this)& {
        m_color = color;
        return *this;
    }
private:
    // The decorator owns the decorated object 
    std::shared_ptr<IShape>  m_shape;
    std::string   m_color = "blue";
};

class PositionDecorator: public IShape {
public:
     PositionDecorator(std::shared_ptr<IShape> shape)
      : m_shape(shape){ }

     auto draw() -> void
     {
        // Save transformation matrix:   pushMatrix() 
        std::cout << " =>  [PositionDecorator] Draw object at x = "
                 << m_x << " ; y = " << m_y << std::endl;
        m_shape->draw();
        // Restore transformation matrix: popMatrix()
     }
     auto description() -> std::string
     {
        return  m_shape->description() + " ; position x  = "
                + std::to_string(m_x) +  " , y = " + std::to_string(m_y);
     }
     auto setPosition(double x, double y) -> PositionDecorator& {
        m_x = x, m_y = y;
        return *this;
     }  
private:    
     // The decorator owns the decorated object 
     std::shared_ptr<IShape> m_shape;
     int m_x = 0, m_y = 0;
};

$ clang++ decorator1.cpp -o decorator1.bin -g -std=c++14 -Wall -Wextra
$ ./decorator1.bin

std::puts("\n ======>> Experiment 1 <<===========");
auto shape = std::make_shared<ColorDecorator>(std::make_shared<Square>());
shape->setColor("yellow");
shape->draw();

======>> Experiment 1 <<===========
=> [ColorDecorator] Draw object with color blue
=> Draw square
DESCRIPTION = square ; color = yellow

std::puts("\n ======>> Experiment 2 <<===========");
auto observerd = std::shared_ptr<IShape>{nullptr};

auto shapeWithColorAndPosition =
    [&observerd]{
        auto shape        = std::make_shared<Triangle>();
        observerd         = shape;
        auto shapeColored = std::make_shared<ColorDecorator>(shape);
        shapeColored->setColor("white");
        auto shapePos     = std::make_shared<PositionDecorator>(shapeColored);          
        return  shapePos;
    }();

shapeWithColorAndPosition->setPosition(100, 20);
shapeWithColorAndPosition->draw();
std::cout << " DESCRIPTION = "
                  << shapeWithColorAndPosition->description() << std::endl;

std::cout << " [INFO] observed shape = " << observerd->description() << std::endl;

======>> Experiment 2 <<===========
=>  [PositionDecorator] Draw object at x = 100 ; y = 20
=> [ColorDecorator] Draw object with color blue
=> Draw tringle
DESCRIPTION = triangle ; color = white ; position x  = 100 , y = 20
[INFO] observed shape = triangle

// Strategy interface 
struct IStrategy{
  virtual ~IStrategy(){}
  // Essential: Algorithm encapsulated by strategy object 
  virtual auto compute(double x, double y) const -> double = 0;  
  // Optional: Provides strategy metadata 
  virtual auto name() const -> const std::string = 0;
  // Clone this object (Note: This is a virtual constructor)
  virtual auto clone() const -> IStrategy* = 0;
};

class Context{
private: 
  std::unique_ptr<IStrategy> _strategy;
public:
  Context()
    : _strategy{nullptr} { }
  Context(IStrategy* s)
    : _strategy{s} { }
  Context(const IStrategy& s)
    : _strategy{s.clone()} { }
  auto setStrategy(IStrategy* s){
    _strategy.reset(s);
  }
  auto setStrategy(const IStrategy& s){
    _strategy.reset(s.clone());
  }  
  auto compute(double x, double y) -> void {
    if(_strategy == nullptr)
      std::runtime_error("Error: strategy not set");
    double result = _strategy->compute(x, y);
    std::cout << " strategy = " << _strategy->name() << " "
              << "( x = " << x << " ; "
              << "y = " << y << " )"
              << "\n" ;
    std::cout << "Result = " << result << "\n";
  }
};

class AddStrategy: public IStrategy {
public:
  auto name() const -> const std::string{
    return "add";
  }
  auto compute(double x, double y) const -> double {
    return x + y;
  }
  auto clone() const -> IStrategy* {
    std::cerr << " [TRACE] AddStrategy => I was cloned" << "\n";
    return new AddStrategy(*this);
  }
};

struct MulStrategy: public IStrategy {
public:
  auto name() const -> const std::string{
    return "mul";
  }  
  double compute(double x, double y) const {
    return x + y;
  }
  auto clone() const -> IStrategy* {
    std::cerr << " [TRACE] MulStrategy => I was cloned" << "\n";
    return new MulStrategy(*this);
  }  
};

struct LinearCombStrategy: public IStrategy {
  double a, b, c;
  LinearCombStrategy(double a, double b, double c)
    : a(a), b(b), c(c)
  {
  }
  auto name() const -> const std::string{
    return "Linear combination a * x + b * y + c";
  }    
  auto compute(double x, double y) const -> double{
    return a * x + b * y + c;
  }
  auto clone() const -> IStrategy* {
    std::cerr << " [TRACE] LinearCombStrategy => I was cloned" << "\n";
    return new LinearCombStrategy(*this);
  }  
};

Context ctx;
std::cout << "==== Strategy = add ====" << "\n";
ctx.setStrategy(new AddStrategy);
ctx.compute(3.0, 4.0);

std::cout << "==== Strategy = mul ====" << "\n";
ctx.setStrategy(new MulStrategy);
ctx.compute(3.0, 4.0);

std::cout << "==== Strategy = Linear combination ====" << "\n";
ctx.setStrategy(new LinearCombStrategy(5, 3, 4));
ctx.compute(3.0, 4.0);

std::cout << "==== Strategy = Linear combination [2] ====" << "\n";
auto comb1 = LinearCombStrategy(6.0, 5.0, 10.0);
// Copy stack-allocated object comb1 using the virtual constructor
ctx.setStrategy(comb1);
ctx.compute(5.0, 3.0);  

std::cout << "==== Strategy = Linear combination [2] ====" << "\n";  
// Copy stack-allocated temporary object comb1 using the virtual constructor
// clone
ctx.setStrategy(LinearCombStrategy{6.0, 5.0, 10.0});
ctx.compute(2.0, 6.0);  

$ clang++ strategy-pattern1.cpp -o strategy-pattern1.bin -g -std=c++1z -Wall -Wextra 
$ ./strategy-pattern1.bin
==== Strategy = add ====
 strategy = add ( x = 3 ; y = 4 )
Result = 7
==== Strategy = mul ====
 strategy = mul ( x = 3 ; y = 4 )
Result = 7
==== Strategy = Linear combination ====
 strategy = Linear combination a * x + b * y + c ( x = 3 ; y = 4 )
Result = 31
==== Strategy = Linear combination [2] ====
 [TRACE] LinearCombStrategy => I was cloned
 strategy = Linear combination a * x + b * y + c ( x = 5 ; y = 3 )
Result = 55
==== Strategy = Linear combination [2] ====
 [TRACE] LinearCombStrategy => I was cloned
 strategy = Linear combination a * x + b * y + c ( x = 2 ; y = 6 )
Result = 52

cmake_minimum_required(VERSION 3.9)
project(observer-design-pattern1)

#====== Global Configurations ==================#

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_VERBOSE_MAKEFILE ON)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(Qt5 COMPONENTS Core Widgets REQUIRED)

#=============== Target Configurations ============#

       add_executable( observer1 observer-pattern1.cpp )
target_link_libraries( observer1 Qt5::Core Qt5::Gui Qt5::Widgets)

#include <iostream>
#include <iomanip>

#include <QtWidgets>
#include <QApplication>
#include <QSysInfo>

struct IObserver;

struct IObservable 
{
    /** Subscribe to observable notifications */
    virtual void addObserver(IObserver* obs) = 0;

    /** Notify all observers */
    virtual void notify() = 0; 
    virtual     ~IObservable() = default;
};

struct IObserver 
{
    virtual void update(IObservable* sender) = 0;
    virtual     ~IObserver() = default;
};

class BasicObservable: public IObservable 
{
    std::vector<IObserver*> m_observers{};
public:

    void addObserver(IObserver* obs) override 
    {
        m_observers.push_back(obs);
        obs->update(this);
    }

    /** Notify all observers */
    void notify() override  
    {
        for(const auto obs: m_observers){ obs->update(this); }
    }    
};

class CounterModel: public BasicObservable
{
    int m_counter = 0;
public: 

    void increment() 
    { 
        m_counter += 1;
        this->notify();
    }
    void decrement() 
    {
        m_counter -= 1;
        this->notify();
    }
    void reset()
    { 
        m_counter = 0;  
        this->notify();
    }

    void set(int n)
    {
        m_counter = n;
        this->notify();
    }

    int get() const { return m_counter; }
};

/** Concrete observer that prints the subject state in the console (terminal) */
class ConsoleView: public IObserver 
{
    /* override: IObserver::update() */
    void update(IObservable* sender) override 
    {
        /* Note: It can result in undefined behavior. */
        int cnt = static_cast<CounterModel*>(sender)->get();
        std::cout << " [CONSOLE] Counter state changed to = " << cnt << '\n';
    }
};


class FormView: public IObserver {
    QWidget      m_win{};
    QFormLayout* m_form;
    QPushButton* m_btn_increment;
    QPushButton* m_btn_decrement;
    QLabel*      m_label;

    CounterModel& m_model;
public:

    FormView(CounterModel& model): m_model(model)
    {
        m_win.setWindowTitle("Form View");
        m_form = new QFormLayout(&m_win);
        m_btn_increment = new QPushButton("[+]");
        m_btn_decrement = new QPushButton("[-]");
        m_label         = new QLabel("0");

        m_form->addRow("Increment",     m_btn_increment);
        m_form->addRow("Decrement",     m_btn_decrement);
        m_form->addRow("Counter value", m_label);

        m_win.show(); 

        /** ------ Setup event handlers ------------------- **/

        QObject::connect(m_btn_decrement, &QPushButton::clicked, 
            [self = this]{ 
                self->m_model.decrement();
            });

        QObject::connect(m_btn_increment, &QPushButton::clicked, 
            [this](){ 
                m_model.increment(); 
            });
    }

    /* override: IObserver::update() */
    void update(IObservable* sender) override 
    {
        int cnt = static_cast<CounterModel*>(sender)->get();
        m_label->setText(QString::number(cnt)); 
        std::cout << " [QT GUI] Counter state changed to = " << cnt << '\n';
    }
};

class LabelView: public IObserver
{
    QLabel m_label;
public:
    LabelView() 
    {   
        m_label.setWindowTitle("Label View");
        m_label.resize(400, 300);
        m_label.show();
    }

    /* override: IObserver::update() */
    void update(IObservable* sender) override 
    {
        int cnt = static_cast<CounterModel*>(sender)->get();
        m_label.setText(" [LABEL Observer] Counter value = " + QString::number(cnt));
    }

};


int main(int argc, char** argv)
{
    // Useful for debugging
    std::cout << " [INFO] QTVersion = " << ::qVersion() << std::endl;


    QApplication app(argc, argv);

    CounterModel model;     
    ConsoleView  observerA{};
    FormView     observerB{model};
    LabelView    observerC{};

    model.addObserver(&observerA);
    model.addObserver(&observerB);
    model.addObserver(&observerC);

    return app.exec();
}

# Get sources 
$ git clone https://gist.github.com/9331193ae1f9b05e4949160a4e024e84 observer1 && cd observer1

# Build  
$ cmake -H. -B_build -DCMAKE_BUILD_TYPE=Debug && cmake --build _build --target 

# Run: 
$ _build/observer1b 

cmake_minimum_required(VERSION 3.9)
project(observer-design-pattern2)

#====== Global Configurations ==================#

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_VERBOSE_MAKEFILE ON)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(Qt5 COMPONENTS Core Widgets REQUIRED)

#=============== Target Configurations ============#

add_executable( observer2 observer-pattern2.cpp )
target_link_libraries( observer2 Qt5::Core Qt5::Gui Qt5::Widgets)

#include <iostream>
#include <iomanip>
#include <functional> 

#include <QtWidgets>
#include <QApplication>
#include <QSysInfo>

using ObserverCallback = std::function<void (void* sender)>;

struct IObservable 
{
    /** Subscribe to observable notifications */
    virtual void addObserver(ObserverCallback obs) = 0;

    /** Notify all observers */
    virtual void notify() = 0; 
    virtual     ~IObservable() = default;
};

class Observable: public IObservable 
{
    void* m_sender = nullptr;
    std::vector<ObserverCallback> m_observers{};

public:

    Observable(){ }
    Observable(void* sender): m_sender(sender){ }

    void addObserver(ObserverCallback callback) override 
    {
        m_observers.push_back(callback);
        callback(m_sender);
    }

    /** Notify all observers */
    void notify() override  
    {
        for(const auto callback: m_observers){ callback(m_sender); }
    }    
};

class CounterModel
{
    int m_counter{0};
    Observable m_obs{this};
public: 
    void increment() { m_counter += 1; m_obs.notify(); }
    void decrement() { m_counter -= 1; m_obs.notify(); }
    int  get() const { return m_counter; }

    void onCounterChanged(ObserverCallback callback)
    {
        m_obs.addObserver(callback);
    }
};

class FormView {
    QWidget      m_win{};
    QFormLayout* m_form;
    QPushButton* m_btn_increment;
    QPushButton* m_btn_decrement;
    QLabel*      m_label;

    CounterModel& m_model;
public:

    FormView(CounterModel& model): m_model(model)
    {
        m_win.setWindowTitle("Form View");
        m_form = new QFormLayout(&m_win);
        m_btn_increment = new QPushButton("[+]");
        m_btn_decrement = new QPushButton("[-]");
        m_label         = new QLabel("0");

        m_form->addRow("Increment",     m_btn_increment);
        m_form->addRow("Decrement",     m_btn_decrement);
        m_form->addRow("Counter value", m_label);

        m_win.show(); 

        /** ------ Setup event handlers ------------------- **/

        QObject::connect(m_btn_decrement, &QPushButton::clicked, 
            [self = this]{ 
                self->m_model.decrement();
            });

        QObject::connect(m_btn_increment, &QPushButton::clicked, 
            [this](){ 
                m_model.increment(); 
            });
    }

    void update(void* sender)  
    {
        int cnt = reinterpret_cast<CounterModel*>(sender)->get();
        m_label->setText(QString::number(cnt)); 
        std::cout << " [QT GUI] Counter state changed to = " << cnt << '\n';
    }
};

class LabelView
{
    QLabel m_label;
public:
    LabelView() 
    {   
        m_label.setWindowTitle("Label View");
        m_label.resize(400, 300);
        m_label.show();
    }

    void notify(void* sender)
    {
        int cnt = reinterpret_cast<CounterModel*>(sender)->get();
        m_label.setText(" [LABEL Observer] Counter value = " + QString::number(cnt));
    }

};


int main(int argc, char** argv)
{
    QApplication app(argc, argv);

    CounterModel model;     

    model.onCounterChanged([](void* sender){
        int cnt = static_cast<CounterModel*>(sender)->get();
        std::cout << " [CONSOLE VIEW] Counter state changed to = " << cnt << '\n';
    });

    FormView   observerB{model};
    LabelView  observerC{};

    model.onCounterChanged([&](void* sender){
        observerB.update(sender);
    });

    model.onCounterChanged([&](void* sender){ 
        observerC.notify(sender); 
    });

    return app.exec();
}

#include <iostream>
#include <string> 

enum class HttpMethod {
    GET, POST, DELETE, PUT, HEAD, PATCH, UKNOWN_METHOD
};

struct HttpRequest {
     std::string  path    = "/";
     HttpMethod   method  = HttpMethod::GET;
     std::string  payload = "";
     // Missing - http headers ---- //

     bool isGET()    const { return method == HttpMethod::GET;    }
     bool isPOST()   const { return method == HttpMethod::POST;   }
     bool isDELETE() const { return method == HttpMethod::DELETE; }
};

/** Process server Http GET request and returns a response. */
void dispatch_request(HttpRequest const& req)
{
   // Http route:  http://www.mysite.com/
   if(req.isGET() && ( req.path == "/" || req.path == ""))
   {
       std::printf(" => Serve index page, web site homepage \n");

   // Http route:  http://www.mysite.com/download 
   } else if( req.isGET() && req.path == "/download" ) 
   {
        std::printf(" => Serve http://www.mysite.com/dowload page. ");

    // Http route:  http://www.mysite.com/upload 
    } else if( req.isPOST() && req.path == "/upload") 
    {
       std::printf(" => Upload document to web server \n");

     // Http route:  http://www.mysite.com/<error-failure>
     } else {
         std::printf(" => Error: 404 - Not Found resource: '%s' \n", req.path.c_str());
     }
}


int main(int argc, char** argv)
{
    auto req1 = HttpRequest{ "/", HttpMethod::GET, "" };
    dispatch_request(req1);

    auto req2 = HttpRequest{ "/error/resource", HttpMethod::GET, "" };
    dispatch_request(req2); 

    auto req3 = HttpRequest{ "/upload", HttpMethod::POST, "file data" };
    dispatch_request(req3);


    return 0;
}

$ g++ chain-of-responsibility1.cpp -o cor1 -std=c++1z -Wall -Wextra

$ ./cor1 
 => Serve index page, web site homepage 
 => Error: 404 - Not Found resource: '/error/resource' 
 => Upload document to web server   

#include <iostream>
#include <string> 

enum class HttpMethod {
   GET, POST, DELETE, PUT, HEAD
};

/** Request object - encapsulates a http request */
struct HttpRequest {
    std::string  path    = "/";
    HttpMethod   method  = HttpMethod::GET;
    std::string  payload = "";
    // Missing - http headers implementation ---- //

    bool isGET()    const { return method == HttpMethod::GET;    }
    bool isPOST()   const { return method == HttpMethod::POST;   }
    bool isDELETE() const { return method == HttpMethod::DELETE; }
};

/** Interface class for generic node of chain of responsibility */
class IHttpHandler {
public:
    virtual void handle(const HttpRequest& req) = 0;
    virtual void set_next(IHttpHandler* next) = 0;
    virtual ~IHttpHandler() = default; 
};

class BasicHttpHandler: public IHttpHandler {
protected:
   /** Note: the keyword 'protected' allows derived classes
    *  (aka subclasses) to access the 'm_next' pointer. But 
    *  this keyword forbids any external code from accessing 
    *  the pointer m_next.
    */
   IHttpHandler* m_next = nullptr;

public:
    BasicHttpHandler(IHttpHandler* next = nullptr)
     : m_next(next){ }


    virtual ~BasicHttpHandler() {
       delete m_next;
       m_next = nullptr;
    }

    /** Set next request in the chain */
    void set_next(IHttpHandler* next)
    {
       m_next = next;
    }

};

class HttpGetHandler: public BasicHttpHandler {
   std::string m_path; 
public:

    HttpGetHandler(std::string path): m_path(path){ }

    void handle(const HttpRequest& req) override
    {
        // Checks whether this handler object can process the request. 
        if(req.method == HttpMethod::GET && m_path == req.path) {
                std::printf( " [RESPONSE] <HttpGetHandler> Return Html and http response with " 
                             "status code 200 for resource: %s \n", m_path.c_str());
        } else {
                // If the request cannot be handle, this hanlder forwards the request to 
                // the next handler in the chain. 
                m_next->handle(req); 
        }
    }

};

class HttpUploadHandler: public BasicHttpHandler {

    void handle(const HttpRequest& req) override
    {
       if( req.method == HttpMethod::POST && req.path == "/upload" ) 
            std::printf( " [RESPONSE] <HttpUploadHandler> Uploading data: '%s' \n"
                         , req.payload.c_str());
       else 
            m_next->handle(req); 
    }

};

class HttpError404Handler: public BasicHttpHandler {    
    void handle(const HttpRequest& req) override
    {
        std::printf(" [RESPONSE] <HttpError404Handler>" 
                    " Error 404 Not found resource: %s \n", req.path.c_str());
    }

};

struct HttpServer 
{
    // First handler in the chain 
    IHttpHandler* m_hnd; 

    HttpServer() {
        IHttpHandler* hnd_index =  new HttpGetHandler("/");

        IHttpHandler* hnd_download = new HttpGetHandler("/download");
        hnd_index->set_next(hnd_download);

        IHttpHandler* hnd_upload = new HttpUploadHandler();
        hnd_download->set_next(hnd_upload);

        IHttpHandler* hnd_error = new HttpError404Handler(); 
        hnd_upload->set_next(hnd_error);

        m_hnd = hnd_index;      
    }

    ~HttpServer() {
         delete m_hnd; 
         m_hnd = nullptr;
    }

    void dispatch_request(const HttpRequest& req)
    {
         std::printf("\n [TRACE] Process request => path = %s \n", req.path.c_str());
         m_hnd->handle(req);
         std::printf(" ---------------------------------------\n");
    }
};


int main(int argc, char** argv)
{
    HttpServer server;

    auto req1 = HttpRequest{ "/", HttpMethod::GET, "" };
    server.dispatch_request(req1); 

    auto req2 = HttpRequest{ "/error/resource", HttpMethod::GET, "" };
    server.dispatch_request(req2);  

    auto req3 = HttpRequest{ "/upload", HttpMethod::POST, "file data" };
    server.dispatch_request(req3);  


    return 0;
}

$ g++  chain-of-responsibility2.cpp -o cor2 -std=c++1z -Wall -Wextra

$ ./cor2 

 [TRACE] Process request => path = / 
 [RESPONSE] <HttpGetHandler> Return Html and http response with status code 200 for resource: / 
 ---------------------------------------

 [TRACE] Process request => path = /error/resource 
 [RESPONSE] <HttpError404Handler> Error 404 Not found resource: /error/resource 
 ---------------------------------------

 [TRACE] Process request => path = /upload 
 [RESPONSE] <HttpUploadHandler> Uploading data: 'file data' 
 ---------------------------------------  

#include <iostream>
#include <string> 
#include <memory>

enum class HttpMethod {
   GET, POST, DELETE, PUT, HEAD
};

/** Request object - encapsulates a http request */
struct HttpRequest {
    std::string  path    = "/";
    HttpMethod   method  = HttpMethod::GET;
    std::string  payload = "";
    // Missing - http headers implementation ---- //

    bool isGET()    const { return method == HttpMethod::GET;    }
    bool isPOST()   const { return method == HttpMethod::POST;   }
    bool isDELETE() const { return method == HttpMethod::DELETE; }
};

/** Interface class for generic node of chain of responsibility */
class IHttpHandler {
public:
    /** Predicate that checks whether request can be handled */
    virtual bool can_handle(const HttpRequest& req) = 0;

    /** Process (aka handle) request */
    virtual void do_handle(const HttpRequest& req) = 0;

    virtual void handle(const HttpRequest& req) = 0;

    ~IHttpHandler() = default; 
};

class BasicHttpHandler: public IHttpHandler {
      std::shared_ptr<IHttpHandler> m_next;

public:
    BasicHttpHandler(std::shared_ptr<IHttpHandler> next = nullptr)
       : m_next(next){ }

    virtual ~BasicHttpHandler() = default;

    void set_next(std::shared_ptr<IHttpHandler> next)
    {
        m_next = next;
    }

    /** Note: The keyword 'final' causes compile-time error if this 
     * method is overriden by any class derived from this one. 
     */
    void handle(const HttpRequest& req) final 
    {
        if(this->can_handle(req)) 
          this->do_handle(req);
        else if(m_next != nullptr)
           m_next->handle(req);
        else 
           throw std::runtime_error(" There is no handle for this request.");
    }
};

class HttpGetHandler: public BasicHttpHandler {
     std::string m_path; 
public:
    HttpGetHandler(std::string path): m_path(path){ }

    bool can_handle(const HttpRequest& req) override
    {
         return req.method == HttpMethod::GET && m_path == req.path;
    }

    void do_handle(const HttpRequest& req) override
    {

        std::printf( " [RESPONSE] <HttpGetHandler> Return Html and http response with " 
                                 "status code 200 for resource: %s \n", m_path.c_str());
    }

};

class HttpUploadHandler: public BasicHttpHandler {

     bool can_handle(const HttpRequest& req) override
     {
          return req.method == HttpMethod::POST && req.path == "/upload";
     }

     void do_handle(const HttpRequest& req) override
     {
           std::printf( " [RESPONSE] <HttpUploadHandler> Uploading data: '%s' \n"
                       , req.payload.c_str());
     }
};

class HttpError404Handler: public BasicHttpHandler {
    bool can_handle(const HttpRequest& req) override
    {
        return true; 
    }

    void do_handle(const HttpRequest& req) override
    {
        std::printf(" [RESPONSE] <HttpError404Handler>" 
                   " Error 404 Not found resource: %s \n", req.path.c_str());
    }

};

struct HttpServer 
{
    std::shared_ptr<IHttpHandler> m_hnd; 

    HttpServer() {
           auto hnd_index = std::make_shared<HttpGetHandler>("/");

           auto hnd_download = std::make_shared<HttpGetHandler>("/download");
           hnd_index->set_next(hnd_download);

           auto hnd_upload = std::make_shared<HttpUploadHandler>();
           hnd_download->set_next(hnd_upload);

           auto hnd_error = std::make_shared<HttpError404Handler>(); 
           hnd_upload->set_next(hnd_error);

           m_hnd = hnd_index;       
   }

    void dispatch_request(const HttpRequest& req)
    {
         std::printf("\n [TRACE] Process request => path = %s \n", req.path.c_str());
         m_hnd->handle(req);
         std::printf(" ---------------------------------------\n");
    }
};


int main(int argc, char** argv)
{
     HttpServer server;

     auto req1 = HttpRequest{ "/", HttpMethod::GET, "" };
     server.dispatch_request(req1); 

     auto req2 = HttpRequest{ "/error/resource", HttpMethod::GET, "" };
     server.dispatch_request(req2);     

     auto req3 = HttpRequest{ "/upload", HttpMethod::POST, "file data" };
     server.dispatch_request(req3);     


     return 0;
}

$ g++  chain-of-responsibility3.cpp -o cor3 -std=c++1z -Wall -Wextra

$ ./cor3

 [TRACE] Process request => path = / 
 [RESPONSE] <HttpGetHandler> Return Html and http response with status code 200 for resource: / 
 ---------------------------------------

 [TRACE] Process request => path = /error/resource 
 [RESPONSE] <HttpError404Handler> Error 404 Not found resource: /error/resource 
 ---------------------------------------

 [TRACE] Process request => path = /upload 
 [RESPONSE] <HttpUploadHandler> Uploading data: 'file data' 
 ---------------------------------------

#include <iostream>
#include <string>
#include <vector>  
#include <memory>

enum class HttpMethod {
   GET, POST, DELETE, PUT, HEAD
};

/** Request object - encapsulates a http request */
struct HttpRequest {
     std::string  path    = "/";
     HttpMethod   method  = HttpMethod::GET;
     std::string  payload = "";
     // Missing - http headers implementation ---- //

     bool isGET()    const { return method == HttpMethod::GET;    }
     bool isPOST()   const { return method == HttpMethod::POST;   }
     bool isDELETE() const { return method == HttpMethod::DELETE; }
};

/** Interface class for generic node of chain of responsibility */
class IHttpHandler {
public:
    /** Predicate that checks whether request can be handled */
    virtual bool can_handle(const HttpRequest& req) = 0;

    /** Process (aka handle) http request and returns http response. */
    virtual void handle(const HttpRequest& req) = 0;

    ~IHttpHandler() = default; 
};

class HttpGetHandler: public IHttpHandler {
    std::string m_path; 
public:
    HttpGetHandler(std::string path): m_path(path){ }

    bool can_handle(const HttpRequest& req) override
    {
        return req.method == HttpMethod::GET && m_path == req.path;
    }

    void handle(const HttpRequest& req) override
    {
        std::printf( " [RESPONSE] <HttpGetHandler> Return Html and http response with " 
                     "status code 200 for resource: %s \n", m_path.c_str());
    }

};

/* This class allows creating http handlers (transaction handlers)
 * using C++ lambdas. 
 */
template<typename predicate_t, typename action_t>
class AdapterHandler: public IHttpHandler 
{
  predicate_t m_predicate; 
  action_t    m_action;
  public:

  AdapterHandler(predicate_t predicate, action_t action)
    :  m_predicate(predicate), m_action(action) { }

  bool can_handle(const HttpRequest& req) override
  {
      return m_predicate(req);
  }

  void handle(const HttpRequest& req) override
  {
     return m_action(req);
  }

};


struct HttpServer 
{
      std::vector<std::shared_ptr<IHttpHandler>> m_handlers; 

      HttpServer() {
             addHandler(std::make_shared<HttpGetHandler>("/"));
             addHandler(std::make_shared<HttpGetHandler>("/download"));

             addLambdaHandler(
               [](const HttpRequest& req)
               { 
                   return req.method == HttpMethod::POST && req.path == "/upload";     
               }
              ,[](const HttpRequest& req)
               { 
                       std::printf( " [RESPONSE] <HttpUploadHandler> Uploading data: '%s' \n"
                                   , req.payload.c_str());        
                }
             );

            addLambdaHandler(
                [](const HttpRequest& req){ return true; }
               ,[](const HttpRequest& req){ 
                               std::printf(" [RESPONSE] <HttpError404Handler>" 
                                           " Error 404 Not found resource: %s \n", req.path.c_str());
               }
            );
    }

    void addHandler(std::shared_ptr<IHttpHandler> hnd)
    {
        m_handlers.push_back(hnd);
    }

   template<typename predicate_t, typename action_t>
   void addLambdaHandler(predicate_t pred, action_t action)
   {
     using T = AdapterHandler<predicate_t, action_t>;
     auto hnd = std::make_shared<T>(pred, action);
     m_handlers.push_back( hnd );
   }

   void dispatch_request(const HttpRequest& req)
   {
      std::printf("\n [TRACE] Process request => path = %s \n", req.path.c_str());
      for(const auto& hnd: m_handlers) 
        if(hnd->can_handle(req)) {
            hnd->handle(req); 
            return;
        }

     std::printf(" ---------------------------------------\n");
  }
};


int main(int argc, char** argv)
{
    HttpServer server;

    auto req1 = HttpRequest{ "/", HttpMethod::GET, "" };
    server.dispatch_request(req1); 

    auto req2 = HttpRequest{ "/error/resource", HttpMethod::GET, "" };
    server.dispatch_request(req2);  

    auto req3 = HttpRequest{ "/upload", HttpMethod::POST, "file data" };
    server.dispatch_request(req3);  

    return 0;
}

$ g++ chain-of-responsibility4.cpp -o cor4 -std=c++1z -Wall -Wextra

$ ./cor4

 [TRACE] Process request => path = / 
 [RESPONSE] <HttpGetHandler> Return Html and http response with status code 200 for resource: / 

 [TRACE] Process request => path = /error/resource 
 [RESPONSE] <HttpError404Handler> Error 404 Not found resource: /error/resource 

 [TRACE] Process request => path = /upload 
 [RESPONSE] <HttpUploadHandler> Uploading data: 'file data'

// Forward reference
class Circle;
class Square;
class Blob;

class IVisitor{
public:
    virtual ~IVisitor() = default;
    virtual void visit(Circle& sh) = 0;
    virtual void visit(Square& sh) = 0;
    virtual void visit(Blob& sh) = 0;
};

// Shape interface - The base class must define the method accept
class IShape{
public:
    virtual ~IShape() = default;    
    virtual void accept(IVisitor& v) = 0;
};

class Circle: public IShape{
public:
     double radius;
     Circle(double radius): radius(radius) { }
     void accept(IVisitor& v) override {
             v.visit(*this);
     }
};

class Square: public IShape{
public:
    double side;
    Square(double side): side(side) { }
    void accept(IVisitor& v) override {
        v.visit(*this);
    }
};

class Blob: public IShape{
public:
    Blob(){}
    void accept(IVisitor& v) override {
        v.visit(*this);
    }
};

// Operation which prints name of the class hierarchy
class PrintNameVisitor: public IVisitor{
public:
    void visit(Circle& sh) override
    {
      std::cout << " => Shape is a circle of radius = "
                << sh.radius
                << "\n";
    }
    void visit(Square& sh) override
    {
       std::cout << " => Shape is a square of side = "
                 << sh.side
                 << "\n";       
    }
    void visit(Blob& ) override
    {
       std::cout << " => Shape is a blob with an undefined shape"
                 << "\n";
    }
};

class ComputeAreaVisitor: public IVisitor{
private:
    double _area = 0.0;
public:
    ComputeAreaVisitor() = default;
    double getArea(){
      return _area;
    }
    void visit(Circle& sh) override
    {
       // CircleArea =  PI * radius^2
       _area = 3.1415 * sh.radius * sh.radius;
    }
    void visit(Square& sh) override
    {
       _area = sh.side * sh.side;
    }
    void visit(Blob& ) override
    {
       _area = 100.0;
    }
};

// Lambda function are used for adding new behavior to the object.
template<class Result>
class FunctionAdapter: public IVisitor{
    template<typename T> using Func = std::function<Result (T& sh)>;
    Result       _res;
    Func<Circle> _fn_circle;
    Func<Square> _fn_square;
    Func<Blob>   _fn_blob;
public:
    Result get(){
            return _res;
    }
    FunctionAdapter(Func<Circle> fnCircle, Func<Square> fnSquare, Func<Blob> fnBlob)
       : _res{}
       , _fn_circle{fnCircle}
       , _fn_square{fnSquare}
       , _fn_blob{fnBlob}
    {       
    }       
    void visit(Circle& sh) override { _res = _fn_circle(sh); }
    void visit(Square& sh) override { _res = _fn_square(sh);}
    void visit(Blob& sh)   override { _res = _fn_blob(sh); }
};

$ clang++ visitor1.cpp -o visitor1.bin -g -std=c++14 -Wall -Wextra && ./visitor1.bin

// Sample shapes 
auto s1 = Circle(3.0);
auto s2 = Square(4.0);
auto s3 = Blob();

std::cout << "===> Experiment 1: PrintNameVisitor " << "\n";
auto visitor1 = PrintNameVisitor();
s1.accept(visitor1);
s2.accept(visitor1);
s3.accept(visitor1);    

===> Experiment 1: PrintNameVisitor 
 => Shape is a circle of radius = 3
 => Shape is a square of side = 4
 => Shape is a blob with an undefined shape

std::cout << "===> Experiment 2: ComputeAreaVisitor " << "\n";
auto visitor2 = ComputeAreaVisitor();
s1.accept(visitor2);
std::cout << "Area of shape 1 = " << visitor2.getArea() << "\n";
s2.accept(visitor2);
std::cout << "Area of shape 2 = " << visitor2.getArea() << "\n";
s3.accept(visitor2);
std::cout << "Area of shape 3 = " << visitor2.getArea() << "\n";

===> Experiment 2: ComputeAreaVisitor 
Area of shape 1 = 28.2735
Area of shape 2 = 16
Area of shape 3 = 100

auto visitor3 = FunctionAdapter<std::string>{
    [](Circle& ){ return "circle"; },
    [](Square& ){ return "square"; },
    [](Blob&   ){ return "blob";   },
 };
s1.accept(visitor3);
std::cout << "Type of shape 1 = " << visitor3.get() << "\n";
s2.accept(visitor3);
std::cout << "Type of shape 2 = " << visitor3.get() << "\n";
s3.accept(visitor3);
std::cout << "Type of shape 3 = " << visitor3.get() << "\n";

===> Experiment 3: FunctionAdapter 
Type of shape 1 = circle
Type of shape 2 = square
Type of shape 3 = blob

std::cout << "===> Experiment 4: FunctionAdapter " << "\n";
// Creates operation to compute shape perimiter
auto visitor4 = FunctionAdapter<double>{
        [](Circle& s){ return 2 * 3.1415 * s.radius * s.radius ; },
        [](Square& s){ return 4.0 * s.side; },
        [](Blob&    ){ return -100.0;   },
 }; 
s1.accept(visitor4);
std::cout << "Perimeter of shape 1 = " << visitor4.get() << "\n";
s2.accept(visitor4);
std::cout << "Perimeter of shape 2 = " << visitor4.get() << "\n";
s3.accept(visitor4);
std::cout << "Perimeter of shape 3 = " << visitor4.get() << "\n";

===> Experiment 4: FunctionAdapter 
Perimeter of shape 1 = 56.547
Perimeter of shape 2 = 16
Perimeter of shape 3 = -100

// Shape interface - The base class must define the method accept
class IShape{
public:
    virtual ~IShape() = default;
};

template<typename Implementation>
class VisitableShape: public IShape{
public:
    /** Accept any visitor class which implements
      * the method:
      * void Visitor::visit(Implementation& impl);
      *********************************************/
      template<typename Visitor>
      void accept(Visitor&& v) {
         v.visit(static_cast<Implementation&>(*this));
      }
};

class Circle: public VisitableShape<Circle> {
public:
    double radius;
    Circle(double radius): radius(radius) { }
};

class Square: public VisitableShape<Square> {
public:
    double side;
    Square(double side): side(side) { }
};

class Blob: public VisitableShape<Blob> {
public:
    Blob(){}
};

template<class Result>
class FunctionAdapter{  
    // Lambda function are used for adding new behavior to the object.
     template<typename T> using Func = std::function<Result (T& sh)>;
     Result       _res;
     Func<Circle> _fn_circle;
     Func<Square> _fn_square;
     Func<Blob>   _fn_blob;
public:
     Result get(){ return _res; }
     FunctionAdapter(Func<Circle> fnCircle, Func<Square> fnSquare, Func<Blob> fnBlob)
             : _res{}
             , _fn_circle{fnCircle}
             , _fn_square{fnSquare}
             , _fn_blob{fnBlob}
     {
     }
     void visit(Circle& sh)  { _res = _fn_circle(sh); }
     void visit(Square& sh)  { _res = _fn_square(sh);}
     void visit(Blob& sh)    { _res = _fn_blob(sh); }

     template<class Visitable>
     Result operator()(Visitable& visitable){
             this->visit(visitable);
             return this->get();
     }
};

auto visitorGetName = FunctionAdapter<std::string>{
     [](Circle& ){ return "circle"; },
     [](Square& ){ return "square"; },
     [](Blob&   ){ return "blob";   },
};

// Creates operation to compute shape perimeter
auto visitorGetArea = FunctionAdapter<double>{
     [](Circle& s){ return 2 * 3.1415 * s.radius * s.radius ; },
     [](Square& s){ return 4.0 * s.side; },
     [](Blob&    ){ return -100.0;   },
};

>> .L visitor2.cpp

>> auto s1 = Circle(3.0);
>> auto s2 = Square(4.0);
>> auto s3 = Blob();

>> s1.accept(visitorGetName)
>> visitorGetName.get()
"circle"

>> s2.accept(visitorGetName)
>> visitorGetName.get()
"square"

>> visitorGetName(s1)
"circle"

>> visitorGetName(s2)
"square"

>> visitorGetArea(s1)
(double) 56.547000

>> s1.accept(visitorGetArea)
>> visitorGetArea.get()
(double) 56.547000

>> visitorGetArea(s2)
(double) 16.000000

>> s2.accept(visitorGetArea)
>> visitorGetArea.get()
(double) 16.000000

>> visitorGetArea(s2)
(double) 16.000000

>> visitorGetArea(s3)
(double) -100.00000
>> 

#include <iostream>
#include <cstdio>
#include <string>
#include <memory>
#include <functional>
#include<type_traits>
// C++17 Variant std::variant and std::visit 
#include <variant> 

class Circle{
public:
    double radius;
    Circle(double radius): radius(radius) { }
};

class Square{
public:
    double side;
    Square(double side): side(side) { }
};

class Blob{
public:
    Blob(){}
};

struct PrintNameVisitor{
    void operator()(const Circle& sh){
         std::cout << " SHAPE = Circle of radius " << sh.radius << std::endl;
    }
    void operator()(const Square& sh){
         std::cout << " SHAPE = Square of radius " << sh.side << std::endl;
    }
    void operator()(const Blob&){
         std::cout << " SHAPE = Blob - no one knows how it looks like. " << std::endl;
    }   
};

/** Visitor which adpts a function */
template<typename Result>
class FunctionVisitor{
private:    
     template<typename Input> using FN = std::function<Result (const Input&)>;
     FN<Circle> fn_circle;
     FN<Square> fn_square;
     FN<Blob>   fn_blob;
public:
    FunctionVisitor(FN<Circle> fnCircle, FN<Square> fnSquare, FN<Blob> fnBlob)
     : fn_circle(fnCircle)
      ,fn_square(fnSquare)
      ,fn_blob(fnBlob){ }
    //Result get() const { return result; }
    Result operator()(const Circle& sh){ return fn_circle(sh); }
    Result operator()(const Square& sh){ return fn_square(sh); }
    Result operator()(const Blob& sh){  return fn_blob(sh);   }
};

template<typename Input, typename Result>
using FnVisit = std::function<Result (const Input&)>;

/** Make a visitor using a functional-programming way 
 * Visitor with lambdas look like "pattern matching"  
 * from functional languages.
 */
template<typename Result = void>
auto makeVisitor(FnVisit<Circle, Result> fnCircle,
                 FnVisit<Square, Result> fnSquare,
                 FnVisit<Blob, Result>   fnBlob ){
        return [=](auto&& a){
                   using C = std::decay_t<decltype(a)>;
                   if constexpr(std::is_same_v<C, Circle>){               
                        return fnCircle(a);
                   }
                   if constexpr(std::is_same_v<C, Square>){
                        return fnSquare(a);
                   }
                   if constexpr(std::is_same_v<C, Blob>){               
                       return fnBlob(a);
                   }
                   std::cerr << "WARNING - Not returned valid result";
                   return Result{};
             };
} //-- EoF makeVisitor ----//