Add Composite Pattern project

Author: akormous

Code/CompositePattern/CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.10)
+
+# set project name
+project(CompositePattern)
+
+set(SOURCES
+    include/MenuComponent.hpp
+    include/MenuItem.hpp
+    include/Menu.hpp
+    src/MenuItem.cpp
+    src/Menu.cpp
+    src/main.cpp
+)
+add_executable(CompositePattern ${SOURCES})
+
+target_include_directories(CompositePattern
+    PRIVATE
+        ${PROJECT_SOURCE_DIR}/include
+)
+

Code/CompositePattern/README.md

@@ -0,0 +1,57 @@
+# Diner Menu and Sub-Menus
+
+A common interface for Menu and Menu Items.
+
+
+```mermaid
+classDiagram
+direction LR
+
+class MenuComponent {
+    +getName()
+    +getDescription()
+    +getPrice()
+    +isVegetarian()
+    +print()
+    +add(Component)
+    +remove(Component)
+    +getChild(int)
+}
+
+class Waitress
+
+class MenuItem {
+    +getName()
+    +getDescription()
+    +getPrice()
+    +isVegetarian()
+    +print()
+}
+
+class Menu {
+    -menuComponents
+    +getName()
+    +getDescription()
+    +print()
+    +add(Component)
+    +remove(Component)
+    +getChild(int)
+}
+
+Waitress --> MenuComponent
+
+MenuComponent <|-- MenuItem
+MenuComponent <|-- Menu
+MenuComponent <-- Menu
+```
+
+- MenuComponent represents the interface for both MenuItem and Menu, it is an abstract class because there will be default implementation of methods
+- The Waitress will only interact with MenuComponent
+- MenuItem overrides the methods that make sense for a menu item
+- Why do we need default implementations? If the leaf (MenuItem) or the composite (Menu) doesn't want to implement some of the methods, they can fall back on some basic behavior
+
+## But this is not Single responsibility! What's happenin?
+
+Yeah, its true. This patterns throws Single-Responsiblity principle out of the water. But it is trade-off with *Transparency*.
+Allowing the Component interface to contain child management operations and the leaf operations, a client can treat both composites and leaf nodes uniformly. It becomes transparent to the client.
+

Code/CompositePattern/include/Menu.hpp

@@ -0,0 +1,22 @@
+#pragma once
+#include "MenuComponent.hpp"
+#include <vector>
+
+using namespace std;
+
+class Menu : public MenuComponent {
+public:
+    Menu(string name, string description);
+    ~Menu() {}
+    void add(MenuComponent* component);
+    void remove(MenuComponent* component);
+    MenuComponent* getChild(int i);
+    
+    string getName();
+    string getDescription();
+    void print();
+private:
+    vector<MenuComponent*> menuComponents;
+    string name;
+    string description;
+};

Code/CompositePattern/include/MenuComponent.hpp

@@ -0,0 +1,44 @@
+#pragma once
+#include<string>
+#include<stdexcept>
+
+class MenuComponent {
+public:
+    virtual ~MenuComponent() {}
+
+    // methods that make sense for both maybe
+    std::string getName() {
+        throw std::runtime_error("Operation is not supported");
+    }
+
+    std::string getDescription() {
+        throw std::runtime_error("Operation is not supported");
+    }
+
+    double getPrice() {
+        throw std::runtime_error("Operation is not supported");
+    }
+    
+    bool isVegetarian() {
+        throw std::runtime_error("Operation is not supported");
+    }
+
+    virtual void print() {
+        throw std::runtime_error("Operation is not supported");
+    }
+
+    // methods that make sense for Menu (composite)
+    void add() {
+        throw std::runtime_error("Operation is not supported");
+    }
+
+    void remove() {
+        throw std::runtime_error("Operation is not supported");
+    }
+
+    MenuComponent getChild() {
+        throw std::runtime_error("Operation is not supported");
+    }
+private:
+
+};

Code/CompositePattern/include/MenuItem.hpp

@@ -0,0 +1,25 @@
+#pragma once
+#include "MenuComponent.hpp"
+
+using namespace std;
+
+/*
+Leaf
+*/
+class MenuItem : public MenuComponent {
+public:
+
+    MenuItem(string name, string description, bool vegetarian, double price);
+    ~MenuItem() {}
+    string getName();
+    string getDescription();
+    bool isVegetarian();
+    double getPrice();
+    void print();
+
+private:
+    string name;
+    string description;
+    bool vegetarian;
+    double price;
+};

Code/CompositePattern/install.sh

@@ -0,0 +1,2 @@
+cmake --debug-output -B build -S .
+cmake --build build

Code/CompositePattern/run.sh

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

Code/CompositePattern/src/Menu.cpp

@@ -0,0 +1,42 @@
+#include "Menu.hpp"
+#include<iostream>
+#include<algorithm>
+
+using namespace std;
+
+Menu::Menu(string name, string description) {
+    this->name = name;
+    this->description = description;
+}
+
+void Menu::add(MenuComponent* component) {
+    this->menuComponents.push_back(component);
+}
+
+void Menu::remove(MenuComponent* component) {
+    vector<MenuComponent*>::iterator it = std::find(menuComponents.begin(), menuComponents.end(), component);
+    if(it != menuComponents.end()) {
+        menuComponents.erase(it);
+    }
+}
+
+MenuComponent* Menu::getChild(int i) {
+    return this->menuComponents[i];
+}
+
+string Menu::getName() {
+    return name;
+}
+
+string Menu::getDescription() {
+    return description;
+}
+
+void Menu::print() {
+    cout << "------------------------------" << endl;
+    cout << name << " - " << description << endl;
+    cout << "------------------------------" << endl;
+    for(auto it = menuComponents.begin(); it != menuComponents.end(); it++) {
+        (*it)->print();
+    }
+}

Code/CompositePattern/src/MenuItem.cpp

@@ -0,0 +1,34 @@
+#include "MenuItem.hpp"
+#include<iostream>
+
+MenuItem::MenuItem(string name, string description, bool vegetarian, double price) {
+        this->name = name;
+        this->description = description;
+        this->vegetarian = vegetarian;
+        this->price = price;
+}
+
+string MenuItem::getName() {
+    return name;
+}
+
+string MenuItem::getDescription() {
+    return description;
+}
+
+bool MenuItem::isVegetarian() {
+    return vegetarian;
+}
+
+double MenuItem::getPrice() {
+    return price;
+}
+
+void MenuItem::print() {
+    cout << getName();
+    if(isVegetarian()) {
+        cout << " (v)";
+    }
+    cout << ", " << getPrice();
+    cout << " - " << getDescription() << endl;
+}

Code/CompositePattern/src/main.cpp

@@ -0,0 +1,33 @@
+#include<bits/stdc++.h>
+#include "Menu.hpp"
+#include "MenuItem.hpp"
+
+using namespace std;
+
+
+int main() {
+    Menu* dinerMenu = new Menu("Diner", "Delicious as always");
+    
+    Menu* dinerSubMenu = new Menu("Diwali Special", "Celebrate the festival with great taste");
+    dinerSubMenu->add(new MenuItem("Paneer Tikka", "very nice", true, 3.99));
+    dinerSubMenu->add(new MenuItem("Chole Bhature", "very nice", true, 7.99));
+    dinerSubMenu->add(new MenuItem("Deluxe Thali", "very nice", true, 12.99));
+    dinerSubMenu->add(new MenuItem("Malai Chaap", "very nice", true, 6.99));
+    
+
+    dinerMenu->add(new MenuItem("Chicken 69", "the best we got", false, 9.99));
+    dinerMenu->add(new MenuItem("Fish and Rice", "good ol' fish and rice", false, 16.99));
+    dinerMenu->add(dinerSubMenu);
+
+
+    dinerMenu->print();
+
+    cout << "-------------------------" << endl;
+    cout << "DELETING SUB MENU" << endl;
+    cout << "-------------------------" << endl;
+
+    dinerMenu->remove(dinerSubMenu);
+    
+    dinerMenu->print();
+    return 0;
+}