feat: add NodeType enum and tags

Author: czgdp1807

pydatastructs/graphs/_backend/cpp/AdjacencyList.hpp

@@ -62,13 +62,12 @@ static PyObject* AdjacencyListGraph_new(PyTypeObject* type, PyObject* args, PyOb
     Py_ssize_t num_args = PyTuple_Size(args);
     for (Py_ssize_t i = 0; i < num_args; ++i) {
         PyObject* node_obj = PyTuple_GetItem(args, i);
-        if (!PyObject_IsInstance(node_obj, (PyObject*)&AdjacencyListGraphNodeType)) {
+        AdjacencyListGraphNode* node = reinterpret_cast<AdjacencyListGraphNode*>(node_obj);
+        if (node->type_tag != NodeType::AdjacencyListGraphNode) {
             PyErr_SetString(PyExc_TypeError, "All arguments must be AdjacencyListGraphNode instances");
             return NULL;
         }
 
-        AdjacencyListGraphNode* node = reinterpret_cast<AdjacencyListGraphNode*>(node_obj);
-
         if (self->node_map.find(node->name) != self->node_map.end()) {
             PyErr_Format(PyExc_ValueError, "Duplicate node with name '%s'", node->name.c_str());
             return NULL;
@@ -107,13 +106,12 @@ static PyObject* AdjacencyListGraph_add_vertex(AdjacencyListGraph* self, PyObjec
         return NULL;
     }
 
-    if (!PyObject_IsInstance(node_obj, (PyObject*)&AdjacencyListGraphNodeType)) {
+    AdjacencyListGraphNode* node = reinterpret_cast<AdjacencyListGraphNode*>(node_obj);
+    if (node->type_tag != NodeType::AdjacencyListGraphNode) {
         PyErr_SetString(PyExc_TypeError, "Object is not an AdjacencyListGraphNode");
         return NULL;
     }
 
-    AdjacencyListGraphNode* node = reinterpret_cast<AdjacencyListGraphNode*>(node_obj);
-
     if (self->node_map.find(node->name) != self->node_map.end()) {
         PyErr_SetString(PyExc_ValueError, "Node with this name already exists");
         return NULL;

pydatastructs/graphs/_backend/cpp/AdjacencyMatrix.hpp

@@ -66,13 +66,13 @@ static PyObject* AdjacencyMatrixGraph_new(PyTypeObject* type, PyObject* args, Py
         Py_ssize_t len = PyTuple_Size(vertices);
         for (Py_ssize_t i = 0; i < len; ++i) {
             PyObject* item = PyTuple_GetItem(vertices, i);
-            if (!PyObject_TypeCheck(item, &AdjacencyMatrixGraphNodeType)) {
+            AdjacencyMatrixGraphNode* node = reinterpret_cast<AdjacencyMatrixGraphNode*>(item);
+            if (node->super.type_tag != NodeType::AdjacencyMatrixGraphNode) {
                 PyErr_SetString(PyExc_TypeError, "All elements must be AdjacencyMatrixGraphNode instances");
                 Py_DECREF(self);
                 return NULL;
             }
             Py_INCREF(item);
-            AdjacencyMatrixGraphNode* node = reinterpret_cast<AdjacencyMatrixGraphNode*>(item);
             std::string name =(reinterpret_cast<GraphNode*>(node))->name;
             self->nodes.push_back(node);
             self->node_map[name] = node;

pydatastructs/graphs/_backend/cpp/Algorithms.hpp

@@ -40,7 +40,7 @@ static PyObject* breadth_first_search_adjacency_list(PyObject* self, PyObject* a
 
     for (const auto& [adj_name, adj_obj] : node->adjacent) {
         if (visited.count(adj_name)) continue;
-        if (!PyObject_IsInstance(adj_obj, (PyObject*)&AdjacencyListGraphNodeType)) continue;
+        if (reinterpret_cast<AdjacencyListGraphNode*>(adj_obj)->type_tag != NodeType::AdjacencyListGraphNode) continue;
 
         AdjacencyListGraphNode* adj_node = reinterpret_cast<AdjacencyListGraphNode*>(adj_obj);
 

pydatastructs/utils/_backend/cpp/AdjacencyListGraphNode.hpp

@@ -12,6 +12,7 @@ extern PyTypeObject AdjacencyListGraphNodeType;
 
 typedef struct {
     PyObject_HEAD
+    NodeType type_tag;
     std::string name;
     int internal_id;
     std::variant<std::monostate, int64_t, double, std::string, PyObject *> data;
@@ -34,6 +35,7 @@ static void AdjacencyListGraphNode_dealloc(AdjacencyListGraphNode* self) {
 static PyObject* AdjacencyListGraphNode_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
     AdjacencyListGraphNode* self = PyObject_New(AdjacencyListGraphNode, &AdjacencyListGraphNodeType);
     if (!self) return NULL;
+    self->type_tag = NodeType::AdjacencyListGraphNode;
     new (&self->adjacent) std::unordered_map<std::string, PyObject*>();
     new (&self->name) std::string();
     new (&self->data) std::variant<std::monostate, int64_t, double, std::string, PyObject*>();

pydatastructs/utils/_backend/cpp/AdjacencyMatrixGraphNode.hpp

@@ -23,6 +23,7 @@ static PyObject* AdjacencyMatrixGraphNode_new(PyTypeObject* type, PyObject* args
     }
 
     AdjacencyMatrixGraphNode* self = reinterpret_cast<AdjacencyMatrixGraphNode*>(base_obj);
+    self->super.type_tag = NodeType::AdjacencyMatrixGraphNode;
 
     return reinterpret_cast<PyObject*>(self);
 }

pydatastructs/utils/_backend/cpp/GraphEdge.hpp

@@ -12,6 +12,7 @@ extern PyTypeObject GraphEdgeType;
 
 typedef struct {
     PyObject_HEAD
+    NodeType type_tag;
     PyObject* source;
     PyObject* target;
     std::variant<std::monostate, int64_t, double, std::string> value;
@@ -27,6 +28,7 @@ static void GraphEdge_dealloc(GraphEdge* self) {
 static PyObject* GraphEdge_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
     GraphEdge* self = PyObject_New(GraphEdge, &GraphEdgeType);
     if (!self) return NULL;
+    self->type_tag = NodeType::GraphEdge;
 
     new (&self->value) std::variant<std::monostate, int64_t, double, std::string>();
     self->value_type = DataType::None;

pydatastructs/utils/_backend/cpp/GraphNode.hpp

@@ -5,6 +5,7 @@
 #include <Python.h>
 #include <string>
 #include <variant>
+#include "Node.hpp"
 
 enum class DataType {
     None,
@@ -16,6 +17,7 @@ enum class DataType {
 
 typedef struct {
     PyObject_HEAD
+    NodeType type_tag;
     std::string name;
     int internal_id;
     std::variant<std::monostate, int64_t, double, std::string, PyObject *> data;
@@ -32,6 +34,7 @@ static void GraphNode_dealloc(GraphNode* self) {
 static PyObject* GraphNode_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
     GraphNode* self = reinterpret_cast<GraphNode*>(type->tp_alloc(type, 0));
     if (!self) return NULL;
+    self->type_tag = NodeType::GraphNode;
 
     new (&self->name) std::string();
     new (&self->data) std::variant<std::monostate, int64_t, double, std::string, PyObject*>();

pydatastructs/utils/_backend/cpp/Node.hpp

@@ -6,8 +6,18 @@
 #include <structmember.h>
 #include "utils.hpp"
 
+enum class NodeType {
+    Node,
+    TreeNode,
+    GraphNode,
+    AdjacencyListGraphNode,
+    AdjacencyMatrixGraphNode,
+    GraphEdge
+};
+
 typedef struct {
     PyObject_HEAD
+    NodeType type_tag;
 } Node;
 // Node is an abstract class representing a Node
 
@@ -16,7 +26,7 @@ static void Node_dealloc(Node *self) {
 }
 
 
-static PyTypeObject NodeType = {
+static PyTypeObject NodeObjectType = {
     /* tp_name */ PyVarObject_HEAD_INIT(NULL, 0) "Node",
     /* tp_basicsize */ sizeof(Node),
     /* tp_itemsize */ 0,

pydatastructs/utils/_backend/cpp/TreeNode.hpp

@@ -9,6 +9,7 @@
 
 typedef struct {
     PyObject_HEAD
+    NodeType type_tag;
     PyObject* key;
     PyObject* data; // can store None or a number
     PyObject* left; // can store None or a number
@@ -29,6 +30,9 @@ static void TreeNode_dealloc(TreeNode *self) {
 static PyObject* TreeNode___new__(PyTypeObject* type, PyObject *args, PyObject *kwds) {
     TreeNode *self;
     self = reinterpret_cast<TreeNode*>(type->tp_alloc(type, 0));
+    if (!self)
+        return NULL;
+    self->type_tag = NodeType::TreeNode;
 
     // Assume that arguments are in the order below. Python code is such that this is true.
     self->key = PyObject_GetItem(args, PyZero);
@@ -100,7 +104,7 @@ static PyTypeObject TreeNodeType = {
     /* tp_methods */ 0,
     /* tp_members */ TreeNode_PyMemberDef,
     /* tp_getset */ 0,
-    /* tp_base */ &NodeType, // Class Node is the base class
+    /* tp_base */ &NodeObjectType, // Class Node is the base class
     /* tp_dict */ 0,
     /* tp_descr_get */ 0,
     /* tp_descr_set */ 0,

pydatastructs/utils/_backend/cpp/nodes.cpp

@@ -14,11 +14,11 @@ PyMODINIT_FUNC PyInit__nodes(void) {
     Py_Initialize();
     PyObject *nodes = PyModule_Create(&nodes_struct);
 
-    if (PyType_Ready(&NodeType) < 0) {
+    if (PyType_Ready(&NodeObjectType) < 0) {
         return NULL;
     }
-    Py_INCREF(&NodeType);
-    PyModule_AddObject(nodes, "Node", reinterpret_cast<PyObject*>(&NodeType));
+    Py_INCREF(&NodeObjectType);
+    PyModule_AddObject(nodes, "Node", reinterpret_cast<PyObject*>(&NodeObjectType));
 
     if (PyType_Ready(&TreeNodeType) < 0) {
         return NULL;