bridge and composite pattern

Author: xiao cheng

Bridge/CMakeLists.txt

@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.8)
+
+project(Bridge_test)
+
+include_directories(${Boost_INCLUDE_DIRS})
+
+add_executable(${PROJECT_NAME} bridgeTest.cpp)
+
+target_link_libraries(${PROJECT_NAME} PUBLIC 
+ gtest_main
+ ${Boost_LIBRARIES}
+ )
+
+ add_test(
+     NAME ${PROJECT_NAME}
+     COMMAND ${PROJECT_NAME}
+ )
+ install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ../bin)

Bridge/bridgeTest.cpp

@@ -0,0 +1,82 @@
+#include <iostream>
+#include <string>
+#include <sstream>
+
+using namespace std;
+
+struct Renderer
+{
+    virtual string what_to_render_as() const = 0;
+};
+
+struct Shape
+{
+    string name;
+    const Renderer &renderer;
+
+    Shape(const Renderer &renderer) : renderer{renderer}
+    {
+    }
+
+    string str() const
+    {
+        ostringstream oss;
+        oss << "Drawing " << name << " as "
+            << renderer.what_to_render_as();
+        return oss.str();
+    }
+};
+
+struct Triangle : Shape
+{
+    explicit Triangle(const Renderer &renderer)
+        : Shape{renderer}
+    {
+        name = "Triangle";
+    }
+};
+
+struct Square : Shape
+{
+    explicit Square(const Renderer &renderer)
+        : Shape{renderer}
+    {
+        name = "Square";
+    }
+};
+
+struct RasterRenderer : Renderer
+{
+    string what_to_render_as() const override
+    {
+        return "pixels";
+    }
+};
+
+struct VectorRenderer : Renderer
+{
+    string what_to_render_as() const override
+    {
+        return "lines";
+    }
+};
+
+#include "gtest/gtest.h"
+
+namespace
+{
+class Evaluate : public testing::Test
+{
+};
+
+TEST_F(Evaluate, SimpleTest)
+{
+    ASSERT_EQ("Drawing Square as lines", Square{VectorRenderer{}}.str());
+}
+} // namespace
+
+int main(int ac, char *av[])
+{
+    testing::InitGoogleTest(&ac, av);
+    return RUN_ALL_TESTS();
+}

CMakeLists.txt

@@ -21,4 +21,6 @@ if(Boost_FOUND)
     add_subdirectory(RAII)
     add_subdirectory(Decorator)
     add_subdirectory(Adaptor)
+    add_subdirectory(Bridge)
+    add_subdirectory(Composite)
 endif()

Composite/CMakeLists.txt

@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.8)
+
+project(Composite_test)
+
+include_directories(${Boost_INCLUDE_DIRS})
+
+add_executable(${PROJECT_NAME} compositeTest.cpp)
+
+target_link_libraries(${PROJECT_NAME} PUBLIC 
+ gtest_main
+ ${Boost_LIBRARIES}
+ )
+
+ add_test(
+     NAME ${PROJECT_NAME}
+     COMMAND ${PROJECT_NAME}
+ )
+ install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ../bin)

Composite/compositeTest.cpp

@@ -0,0 +1,221 @@
+#include <memory>
+#include <vector>
+#include <deque>
+#include <string>
+#include <iostream>
+
+class IGraphic
+{
+  public:
+    virtual auto type() const -> const std::string = 0;
+    virtual auto draw() -> void = 0;
+    virtual auto rotate(double) -> void = 0;
+    virtual ~IGraphic() = default;
+};
+
+using cstring = const char *;
+using GNode = std::shared_ptr<IGraphic>;
+
+class Group : public IGraphic
+{
+  private:
+    std::vector<GNode> _nodes;
+    std::string _id;
+    static constexpr cstring _type = "Group";
+
+  public:
+    Group(const std::string &id) : _id(id)
+    {
+        std::cout << " [TRACE] Create group = " << id << "\n";
+    }
+    ~Group()
+    {
+        std::cout << " [TRACE] Destroy group - id = << " << _id << "\n";
+    }
+
+    auto begin() const -> decltype(_nodes.begin())
+    {
+        return _nodes.begin();
+    }
+    auto end() const -> decltype(_nodes.end())
+    {
+        return _nodes.end();
+    }
+
+    auto clear() -> void
+    {
+        _nodes.clear();
+    }
+    auto size() -> size_t
+    {
+        return _nodes.size();
+    }
+    auto add(GNode n) -> void
+    {
+        std::cout << " [TRACE] id = " << _id
+                  << "; Add object = " << n->type() << "\n";
+        _nodes.push_back(n);
+    }
+    auto add(IGraphic *n) -> void
+    {
+        std::cout << " [TRACE] id = " << _id
+                  << " ; Add object = " << n->type() << "\n";
+        _nodes.push_back(std::shared_ptr<IGraphic>(n));
+    }
+    // Add stack-allocated object
+    auto addFromStack(IGraphic *n) -> void
+    {
+        std::cout << " [TRACE] id = " << _id
+                  << " ; Add object = " << n->type() << "\n";
+        // Dummy deleter to avoid core dump by avoiding deleting
+        // stack-allocated object or non-owned pointer.
+        auto s = std::shared_ptr<IGraphic>(n, [](IGraphic *) { return; });
+        _nodes.push_back(s);
+    }
+
+    // Note: Template methods should always be in the header files
+    template <class Node>
+    auto addNew(const std::string &id) -> void
+    {
+        auto n = std::make_unique<Node>(id);
+        std::cout << " [TRACE] id = " << _id
+                  << " ; Add object = " << n->type() << "\n";
+        _nodes.push_back(std::move(n));
+    }
+
+    // ======> Interface IGraphic <<=========//
+
+    auto type() const -> const std::string override
+    {
+        return _type;
+    }
+    auto draw() -> void override
+    {
+        std::cout << " [TRACE] Draw group - id =  " << _id << "\n";
+        for (const auto &obj : _nodes)
+            obj->draw();
+    }
+    auto rotate(double angle) -> void override
+    {
+        std::cout << " [TRACE] Rotate group - id = " << _id << "\n";
+        for (const auto &obj : _nodes)
+            obj->rotate(angle);
+    }
+};
+
+class Line : public IGraphic
+{
+  private:
+    static constexpr cstring _type = "Line";
+    std::string _id;
+
+  public:
+    Line(const std::string &id) : _id{id} {}
+    auto type() const -> const std::string override
+    {
+        return _type;
+    }
+    auto draw() -> void override
+    {
+        std::cout << " [TRACE] Draw line - id = " << _id << "\n";
+    }
+    auto rotate(double angle) -> void override
+    {
+        std::cout << " [TRACE] Rotate line ; id = " << _id
+                  << "; angle = " << angle << "\n";
+    }
+};
+
+class Triangle : public IGraphic
+{
+  private:
+    static constexpr cstring _type = "Triangle";
+    std::string _id;
+
+  public:
+    Triangle(const std::string &id) : _id{id} {}
+    auto type() const -> const std::string override
+    {
+        return _type;
+    }
+    auto draw() -> void override
+    {
+        std::cout << " [TRACE] Draw triangle - id = " << _id << "\n";
+    }
+    auto rotate(double angle) -> void override
+    {
+        std::cout << " [TRACE] Rotate triangle"
+                  << " id = " << _id
+                  << " angle = " << angle << "\n";
+    }
+};
+
+// Count total number of elements
+auto countElements(const Group &group) -> size_t
+{
+    size_t n = 0;
+    for (const auto &g : group)
+    {
+        if (g->type() == "Group")
+        {
+            auto p = static_cast<Group *>(g.get());
+            n += countElements(*p);
+        }
+        else
+        {
+            ++n;
+        }
+    }
+    return n;
+}
+
+int main()
+{
+    const char nl = '\n';
+
+    std::cout << "=== Objects construction === " << nl;
+
+    auto groupA = Group("groupA");
+    groupA.add(new Triangle("triangleA1"));
+    groupA.add(new Line("lineA1"));
+    groupA.addNew<Line>("LineA2");
+
+    auto groupB = std::make_shared<Group>("GroupB");
+    groupB->add(new Triangle("triangleB1"));
+    groupB->addNew<Triangle>("triangleB2");
+    groupB->addNew<Line>("LineB1");
+    groupB->addNew<Line>("LineB2");
+    auto triangleB3 = Triangle("triangleB3");
+    groupB->addFromStack(&triangleB3);
+    groupA.add(groupB);
+
+    std::cout << nl << "=== End of object construction === " << nl;
+    std::cout << "Total of elements of groupA = " << countElements(groupA) << "\n";
+    std::cout << "Total of elements of groupB = " << countElements(*groupB) << "\n";
+
+    std::cout << nl << " [*] ==> Draw group B"
+              << "\n";
+    groupB->draw();
+
+    std::cout << nl << " [*] ==> Rotate group B"
+              << "\n";
+    groupB->rotate(90);
+
+    std::cout << nl << " [*] ==> Draw group A"
+              << "\n";
+    groupA.draw();
+
+    std::cout << nl << " [*] ==> Rotate group A"
+              << "\n";
+    groupA.rotate(15);
+
+    std::cout << nl << " [*] ==> Remove objects from group B"
+              << "\n";
+    groupB->clear();
+    groupA.draw();
+
+    std::cout << "=== End of Program ===="
+              << "\n";
+
+    return 0;
+}