Add decoupling exercise

Author: xtofl

.travis.yml

@@ -66,4 +66,11 @@ script:
     - cmake ..
     - make
     - ./cpp11training
+    - cd ../..
+    - cd coupling
+    - mkdir build && cd build
+    - cmake ..
+    - make
+    - ./coupled_program
+    - cd ../..
 

coupling/.gitignore

@@ -0,0 +1 @@
+build/

coupling/CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.0.0)
+
+set(CMAKE_CXX_STANDARD 17)
+project(coupled_program)
+
+add_library(graphs coupled_program/graphs/graph.cpp)
+
+add_executable(coupled_program coupled_program/deps.cpp)
+target_link_libraries(coupled_program LINK_PUBLIC graphs)

coupling/coupled_program/deps.cpp

@@ -0,0 +1,16 @@
+#include <iostream>
+#include "graphs/graph.hpp"
+
+int main(int argc, const char **args) {
+    Graph graph;
+
+    auto n1 = graph.addNode({"A"});
+    auto n2 = graph.addNode({"B"});
+    auto n3 = graph.addNode({"C"});
+
+    graph.connect(n1, n2)->name = "a-b";
+    graph.connect(n1, n3)->name = "a-c";
+
+    graph.dump_to(std::cout);
+    return 0;
+}

coupling/coupled_program/graphs/graph.cpp

@@ -0,0 +1,25 @@
+#include "graph.hpp"
+
+Node *Graph::addNode(Node n) {
+    nodes.push_back(std::make_unique<Node>(std::move(n)));
+    return nodes.back().get();
+}
+
+Edge *Graph::connect(Node *a, Node *b) {
+    std::unique_ptr<Edge> edge{new Edge{"", a, b}};
+    edges.push_back(std::move(edge));
+    return edges.back().get();
+}
+
+std::ostream &Graph::dump_to(std::ostream &o) const {
+    o << "Graph: " << "\n";
+    for(const auto &n: nodes){
+        o << "node " << n->name << ":\n";
+        for(const auto &e: edges) {
+            if(e->a == n.get()) {
+                o << " -> " << e->b->name << "(" << e->name << ")\n";
+            }
+        }
+    }
+    return o;
+}

coupling/coupled_program/graphs/graph.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include <memory>
+#include <ostream>
+
+struct Node {
+    std::string name;
+};
+
+struct Edge {
+    std::string name;
+    Node *a;
+    Node *b;
+};
+
+// TODO:
+//
+// 1. install a compilation firewall around
+// the graph representation.
+//
+// In other words, client does not see
+// the actual representation of the contained
+// members.
+//
+// Nor does it need to know what a `vector` is
+// or a `unique_ptr`.
+//
+// This removes the coupling to the STL of this class,
+// and to the std::unique_ptr C++11 addition.
+//
+// 2. decouple the client code from the representation
+// by making the Node and Edge opaque types (handles) too.
+//
+// ADVANCED:
+// You may attempt to even use this class
+// from a C program.
+//
+struct Graph {
+    Node * addNode(Node n);
+    Edge * connect(Node *, Node *);
+    std::ostream & dump_to(std::ostream &o) const;
+private:
+    std::vector<std::unique_ptr<Node>> nodes;
+    std::vector<std::unique_ptr<Edge>> edges;
+};