Update stack.cpp

Here is the updated code for stack.py in c++ implementation. I have checked the array.py and array.cpp and then imported the required modules/ libraries.

Author: Kushagra9399

pydatastructs/miscellaneous_data_structures/_backend/cpp/stack/stack.cpp

@@ -1,48 +1,147 @@
 #include <Python.h>
-#include "ArrayStack.hpp"
+#include <vector>
+#include <stdexcept>
+#include "SinglyLinkedList.hpp"
+#include "DynamicOneDimensionalArray.hpp"
 
-static struct PyModuleDef stack_struct = {
+// Forward declarations for types in the module
+extern PyTypeObject ArrayStackType;
+extern PyTypeObject LinkedListStackType;
+
+static struct PyModuleDef stackmodule = {
     PyModuleDef_HEAD_INIT,
     "_stack",
-    0,
+    "Stack Data Structure Module",
     -1,
-    NULL,
+    NULL
 };
 
-PyMODINIT_FUNC PyInit__stack(void) {
-    Py_Initialize();
-    PyObject *stack = PyModule_Create(&stack_struct);
+// Stack base class (Abstract class)
+class Stack {
+public:
+    virtual void push(PyObject* x) = 0;
+    virtual PyObject* pop() = 0;
+    virtual bool is_empty() = 0;
+    virtual PyObject* peek() = 0;
+    virtual Py_ssize_t __len__() = 0;
+    virtual const char* __str__() = 0;
+};
 
-    if (PyType_Ready(&ArrayStackType) < 0) {
-        return NULL;
+// ArrayStack Implementation (Derived class)
+class ArrayStack : public Stack {
+public:
+    std::vector<PyObject*> items; // Dynamic array to store items
+
+    ArrayStack() {}
+
+    ArrayStack(std::vector<PyObject*> initial_items) {
+        items = initial_items;
     }
-    Py_INCREF(&ArrayStackType);
-    PyModule_AddObject(stack, "ArrayStack", reinterpret_cast<PyObject*>(&ArrayStackType));
 
-    if (PyType_Ready(&ArrayType) < 0) {
-        return NULL;
+    void push(PyObject* x) override {
+        items.push_back(x);
     }
-    Py_INCREF(&ArrayType);
-    PyModule_AddObject(stack, "Array", reinterpret_cast<PyObject*>(&ArrayType));
 
-    if (PyType_Ready(&OneDimensionalArrayType) < 0) {
-        return NULL;
+    PyObject* pop() override {
+        if (is_empty()) {
+            throw std::out_of_range("Stack is empty");
+        }
+        PyObject* top_element = items.back();
+        items.pop_back();
+        return top_element;
     }
-    Py_INCREF(&OneDimensionalArrayType);
-    PyModule_AddObject(stack, "OneDimensionalArray", reinterpret_cast<PyObject*>(&OneDimensionalArrayType));
 
-    if (PyType_Ready(&DynamicArrayType) < 0) {
-        return NULL;
+    bool is_empty() override {
+        return items.empty();
     }
-    Py_INCREF(&DynamicArrayType);
-    PyModule_AddObject(stack, "DynamicArray", reinterpret_cast<PyObject*>(&DynamicArrayType));
 
-    if (PyType_Ready(&DynamicOneDimensionalArrayType) < 0) {
-        return NULL;
+    PyObject* peek() override {
+        if (is_empty()) {
+            throw std::out_of_range("Stack is empty");
+        }
+        return items.back();
+    }
+
+    Py_ssize_t __len__() override {
+        return items.size();
+    }
+
+    const char* __str__() override {
+        std::string result = "[";
+        for (size_t i = 0; i < items.size(); ++i) {
+            result += PyUnicode_AsUTF8(PyObject_Str(items[i]));
+            if (i != items.size() - 1) {
+                result += ", ";
+            }
+        }
+        result += "]";
+        return result.c_str();
+    }
+};
+
+// LinkedListStack Implementation (Derived class)
+class LinkedListStack : public Stack {
+public:
+    SinglyLinkedList stack; // Linked list to store the stack elements
+
+    LinkedListStack() {}
+
+    LinkedListStack(std::vector<PyObject*> initial_items) {
+        for (auto& item : initial_items) {
+            push(item);
+        }
+    }
+
+    void push(PyObject* x) override {
+        stack.appendleft(x);
+    }
+
+    PyObject* pop() override {
+        if (is_empty()) {
+            throw std::out_of_range("Stack is empty");
+        }
+        return stack.popleft();
     }
-    Py_INCREF(&DynamicOneDimensionalArrayType);
-    PyModule_AddObject(stack, "DynamicOneDimensionalArray", reinterpret_cast<PyObject*>(&DynamicOneDimensionalArrayType));
 
+    bool is_empty() override {
+        return stack.size() == 0;
+    }
+
+    PyObject* peek() override {
+        return stack.head;
+    }
+
+    Py_ssize_t __len__() override {
+        return stack.size();
+    }
+
+    const char* __str__() override {
+        std::string result = "[";
+        auto node = stack.head;
+        while (node != nullptr) {
+            result += PyUnicode_AsUTF8(PyObject_Str(node->data));
+            if (node->next != nullptr) {
+                result += ", ";
+            }
+            node = node->next;
+        }
+        result += "]";
+        return result.c_str();
+    }
+};
+
+// Python Module Initialization
+PyMODINIT_FUNC PyInit__stack(void) {
+    PyObject *stack_module = PyModule_Create(&stackmodule);
+    if (PyType_Ready(&ArrayStackType) < 0)
+        return NULL;
+    Py_INCREF(&ArrayStackType);
+    PyModule_AddObject(stack_module, "ArrayStack", (PyObject*)&ArrayStackType);
+
+    if (PyType_Ready(&LinkedListStackType) < 0)
+        return NULL;
+    Py_INCREF(&LinkedListStackType);
+    PyModule_AddObject(stack_module, "LinkedListStack", (PyObject*)&LinkedListStackType);
 
-    return stack;
+    return stack_module;
 }