Add the FactoryMethod pattern

Author: urbytes21

CMakeLists.txt

@@ -109,6 +109,7 @@ set(APP_SOURCES
     "src/patterns/behavioral/State.cpp"
     "src/patterns/behavioral/Observer.cpp"
     "src/patterns/creational/Singleton.cpp"
+    "src/patterns/creational/FactoryMethod.cpp"
 )
 
 # Test files

docs/uml/patterns_creational_factorymethod.drawio.svg

@@ -0,0 +1,173 @@
+// cppcheck-suppress-file [functionStatic]
+
+// Factory Method is a creational design pattern that provides an interface for creating objects in a superclass,
+// but allows subclasses to alter the type of objects that will be created.
+// Appicability:
+// (*)  when you don’t know beforehand the exact types and dependencies of the objects your code should work with.
+// (**) when you want to provide users of your library or framework with a way to extend its internal components.
+// (***)when you want to save system resources by reusing existing objects instead of rebuilding them each time.
+// UML: docs/uml/patterns_creational_factorymethod.drawio.svg
+
+#include <iostream>
+#include <string>
+namespace
+{
+    namespace FactoryMethod
+    {
+        /**
+         * The Product interface declares the operations that all concrete products must
+         * implement.
+         */
+        class IGdbProduct
+        {
+        public:
+            virtual ~IGdbProduct() = default;
+            virtual void launch() const = 0;
+        };
+
+        /**
+         * Concrete Products provide various implementations of the Product interface.
+         */
+        class LinuxGdbProduct : public IGdbProduct
+        {
+        public:
+            void launch() const override
+            {
+                std::cout
+                    << "\tsudo apt update && sudo apt install -y gdb && gdb --version\n";
+            }
+        };
+
+        class WindowsGdbProduct : public IGdbProduct
+        {
+        public:
+            void launch() const override
+            {
+                std::cout << "\tpacman -Syu mingw-w64-x86_64-gdb && gdb --version\n";
+            }
+        };
+
+        class MacOsGdbProduct : public IGdbProduct
+        {
+        public:
+            void launch() const override
+            {
+                std::cout << "\tbrew install gdb && gdb --version\n";
+            }
+        };
+
+        /**
+         * The Creator class declares the factory method that is supposed to return an
+         * object of a Product class. The Creator's subclasses usually provide the
+         * implementation of this method.
+         */
+        class IGdbCreator
+        {
+        public:
+            virtual ~IGdbCreator() = default;
+            virtual IGdbProduct *factoryMethod() = 0;
+            virtual void launchGdb() = 0;
+        };
+
+        class AbstractGdbCreater : public IGdbCreator
+        {
+        public:
+            //  Call the factory method to create a Product object.
+
+            void launchGdb() override final
+            {
+                IGdbProduct *gdb = this->factoryMethod();
+                gdb->launch();
+                delete gdb;
+            }
+        };
+
+        /**
+         * Concrete Creators override the factory method in order to change the
+         * resulting product's type.
+         */
+        class WindowsGdbCreator : public AbstractGdbCreater
+        {
+        public:
+            IGdbProduct *factoryMethod() override
+            {
+                return new WindowsGdbProduct();
+            }
+        };
+
+        class LinuxGdbCreator : public AbstractGdbCreater
+        {
+        public:
+            IGdbProduct *factoryMethod() override
+            {
+                return new LinuxGdbProduct();
+            }
+        };
+
+        class MacOsGdbCreator : public AbstractGdbCreater
+        {
+        public:
+            IGdbProduct *factoryMethod() override
+            {
+                return new MacOsGdbProduct();
+            }
+        };
+
+        /**
+         * The client code works with an instance of a concrete creator, albeit through its base interface.
+         * As long as the client keeps working with the creator via the base interface, you can pass it any creator's subclass.
+         */
+        namespace ClientCode
+        {
+            void clientCode(IGdbCreator *gdb)
+            {
+                if (gdb != nullptr)
+                    gdb->launchGdb();
+            }
+        }
+
+        class GdbCreatorFactory
+        {
+        public:
+            static IGdbCreator *createGdbCreator(const std::string &os)
+            {
+                if (os == "linux")
+                {
+                    return new LinuxGdbCreator();
+                }
+                else if (os == "windows")
+                {
+                    return new WindowsGdbCreator();
+                }
+                else if (os == "macos")
+                {
+                    return new MacOsGdbCreator();
+                }
+                else
+                {
+                    std::cout << "OS not support yet - " << os << "\n";
+                    return nullptr;
+                }
+            }
+        };
+
+        void run()
+        {
+            std::string os = "linux";
+            IGdbCreator *gdb = GdbCreatorFactory::createGdbCreator(os);
+            ClientCode::clientCode(gdb);
+            delete gdb;
+        }
+    }
+}
+
+struct FactoryMethodAutoRunner
+{
+    FactoryMethodAutoRunner()
+    {
+        std::cout << "\n--- FactoryMethod Pattern Example ---\n";
+        FactoryMethod::run();
+    }
+};
+
+static FactoryMethodAutoRunner instance;