Adding support for stack.ArrayStack in C++ backend

pydatastructs/linear_data_structures/_backend/cpp/arrays/DynamicOneDimensionalArray.hpp

@@ -8,6 +8,7 @@
 #include "DynamicArray.hpp"
 #include "OneDimensionalArray.hpp"
 #include "../../../../utils/_backend/cpp/utils.hpp"
+#include <iostream>
 
 typedef struct {
     PyObject_HEAD

pydatastructs/miscellaneous_data_structures/__init__.py

@@ -5,7 +5,8 @@
     binomial_trees,
     queue,
     disjoint_set,
-    sparse_table
+    sparse_table,
+    _extensions,
 )
 
 from .binomial_trees import (

pydatastructs/miscellaneous_data_structures/_backend/cpp/stack/ArrayStack.hpp

@@ -0,0 +1,106 @@
+#ifndef MISCELLANEOUS_DATA_STRUCTURES_ARRAYSTACK_HPP
+#define MISCELLANEOUS_DATA_STRUCTURES_ARRAYSTACK_HPP
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <cstdlib>
+#include <iostream>
+#include <structmember.h>
+#include "../../../../linear_data_structures/_backend/cpp/arrays/DynamicOneDimensionalArray.hpp"
+
+typedef struct {
+    PyObject_HEAD
+    DynamicOneDimensionalArray* _items;
+} ArrayStack;
+
+static void ArrayStack_dealloc(ArrayStack *self) {
+    DynamicOneDimensionalArray_dealloc(self->_items);
+    Py_TYPE(self)->tp_free(reinterpret_cast<PyObject*>(self));
+}
+
+static PyObject* ArrayStack__new__(PyTypeObject *type, PyObject *args, PyObject *kwds) {
+    // args can be just the data type or the data type and a list of initial values
+
+    ArrayStack *self = reinterpret_cast<ArrayStack*>(type->tp_alloc(type, 0));
+    size_t len_args = PyObject_Length(args);
+
+    if (len_args != 1 && len_args != 2) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Too few arguments to create the stack,"
+                        " pass either only the dtype, or"
+                        " the dtype and a list of initial values");
+        return NULL;
+    }
+
+    PyObject* items = NULL;
+    PyObject* doda_kwds = Py_BuildValue("{}");
+    if (len_args == 1) {
+        // If the only argument is the dtype, redefine the args as a tuple (dtype, 0)
+        // where 0 is the initial array size
+        PyObject* dtype = PyObject_GetItem(args, PyZero);
+        PyObject* extended_args = PyTuple_Pack(2, dtype, PyLong_FromLong(0));
+
+        items = DynamicOneDimensionalArray___new__(&DynamicOneDimensionalArrayType, args, doda_kwds);
+    } else {
+        // If the user provides dtype and initial values list, let the array initializer handle the checks.
+
+        PyObject* doda_args = PyTuple_Pack(2, PyObject_GetItem(args, PyOne), PyObject_GetItem(args, PyZero));
+        items = DynamicOneDimensionalArray___new__(&DynamicOneDimensionalArrayType, doda_args, doda_kwds);
+    }
+
+    if (!items) {
+        return NULL;
+    }
+
+    DynamicOneDimensionalArray* tmp = self->_items;
+    self->_items = reinterpret_cast<DynamicOneDimensionalArray*>(items);
+
+    return reinterpret_cast<PyObject*>(self);
+}
+
+static PyObject* ArrayStack__str__(ArrayStack* self){
+    return DynamicOneDimensionalArray___str__(self->_items);
+}
+
+static PyTypeObject ArrayStackType = {
+        /* tp_name */ PyVarObject_HEAD_INIT(NULL, 0) "ArrayStack",
+        /* tp_basicsize */ sizeof(ArrayStack),
+        /* tp_itemsize */ 0,
+        /* tp_dealloc */ (destructor) ArrayStack_dealloc,
+        /* tp_print */ 0,
+        /* tp_getattr */ 0,
+        /* tp_setattr */ 0,
+        /* tp_reserved */ 0,
+        /* tp_repr */ 0,
+        /* tp_as_number */ 0,
+        /* tp_as_sequence */ 0,
+        /* tp_as_mapping */ 0,
+        /* tp_hash  */ 0,
+        /* tp_call */ 0,
+        /* tp_str */ (reprfunc) ArrayStack__str__,
+        /* tp_getattro */ 0,
+        /* tp_setattro */ 0,
+        /* tp_as_buffer */ 0,
+        /* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+        /* tp_doc */ 0,
+        /* tp_traverse */ 0,
+        /* tp_clear */ 0,
+        /* tp_richcompare */ 0,
+        /* tp_weaklistoffset */ 0,
+        /* tp_iter */ 0,
+        /* tp_iternext */ 0,
+        /* tp_methods */ 0,
+        /* tp_members */ 0,
+        /* tp_getset */ 0,
+        /* tp_base */ 0,
+        /* tp_dict */ 0,
+        /* tp_descr_get */ 0,
+        /* tp_descr_set */ 0,
+        /* tp_dictoffset */ 0,
+        /* tp_init */ 0,
+        /* tp_alloc */ 0,
+        /* tp_new */ ArrayStack__new__,
+};
+
+
+#endif

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

@@ -0,0 +1,48 @@
+#include <Python.h>
+#include "ArrayStack.hpp"
+
+static struct PyModuleDef stack_struct = {
+    PyModuleDef_HEAD_INIT,
+    "_stack",
+    0,
+    -1,
+    NULL,
+};
+
+PyMODINIT_FUNC PyInit__stack(void) {
+    Py_Initialize();
+    PyObject *stack = PyModule_Create(&stack_struct);
+
+    if (PyType_Ready(&ArrayStackType) < 0) {
+        return NULL;
+    }
+    Py_INCREF(&ArrayStackType);
+    PyModule_AddObject(stack, "ArrayStack", reinterpret_cast<PyObject*>(&ArrayStackType));
+
+    if (PyType_Ready(&ArrayType) < 0) {
+        return NULL;
+    }
+    Py_INCREF(&ArrayType);
+    PyModule_AddObject(stack, "Array", reinterpret_cast<PyObject*>(&ArrayType));
+
+    if (PyType_Ready(&OneDimensionalArrayType) < 0) {
+        return NULL;
+    }
+    Py_INCREF(&OneDimensionalArrayType);
+    PyModule_AddObject(stack, "OneDimensionalArray", reinterpret_cast<PyObject*>(&OneDimensionalArrayType));
+
+    if (PyType_Ready(&DynamicArrayType) < 0) {
+        return NULL;
+    }
+    Py_INCREF(&DynamicArrayType);
+    PyModule_AddObject(stack, "DynamicArray", reinterpret_cast<PyObject*>(&DynamicArrayType));
+
+    if (PyType_Ready(&DynamicOneDimensionalArrayType) < 0) {
+        return NULL;
+    }
+    Py_INCREF(&DynamicOneDimensionalArrayType);
+    PyModule_AddObject(stack, "DynamicOneDimensionalArray", reinterpret_cast<PyObject*>(&DynamicOneDimensionalArrayType));
+
+
+    return stack;
+}

pydatastructs/miscellaneous_data_structures/_extensions.py

@@ -0,0 +1,16 @@
+from setuptools import Extension
+
+project = 'pydatastructs'
+
+module = 'miscellaneous_data_structures'
+
+backend = '_backend'
+
+cpp = 'cpp'
+
+stack = '.'.join([project, module, backend, cpp, '_stack'])
+stack_sources = ['/'.join([project, module, backend, cpp, 'stack', 'stack.cpp'])]
+
+extensions = [
+    Extension(stack, sources=stack_sources),
+]

scripts/build/dummy_submodules_data.py

@@ -1,9 +1,9 @@
 project = 'pydatastructs'
 
-modules = ['linear_data_structures']
+modules = ['linear_data_structures', 'miscellaneous_data_structures']
 
 backend = '_backend'
 
 cpp = 'cpp'
 
-dummy_submodules_list = [('_arrays.py', '_algorithms.py')]
+dummy_submodules_list = [('_arrays.py', '_algorithms.py'), ('_stack',)]

setup.py

@@ -1,12 +1,14 @@
 import setuptools
 from pydatastructs import linear_data_structures
+from pydatastructs import miscellaneous_data_structures
 
 with open("README.md", "r") as fh:
     long_description = fh.read()
 
 extensions = []
 
 extensions.extend(linear_data_structures._extensions.extensions)
+extensions.extend(miscellaneous_data_structures._extensions.extensions)
 
 setuptools.setup(
     name="cz-pydatastructs",