Merge pull request #778 from UWB-Biocomputing/AndrewDevelopment

[ISSUE-732] Enum Classes

Author: AndrewBMadison

CMakeLists.txt

@@ -12,7 +12,6 @@ cmake_minimum_required(VERSION 3.12)
 #
 #"YES" / GPU choice only available if CUDA library is installed and the GPU is CUDA capable.
 ############################################################################################
-
 if(NOT ENABLE_CUDA)
         set(ENABLE_CUDA NO)
 endif()

Simulator/Connections/Connections.cpp

@@ -38,7 +38,7 @@ Connections::Connections()
 
    // Register loadParameters function with Operation Manager
    function<void()> loadParamsFunc = bind(&Connections::loadParameters, this);
-   opsManager.registerOperation(Operations::op::loadParameters, loadParamsFunc);
+   opsManager.registerOperation(Operations::loadParameters, loadParamsFunc);
 
    // Register registerGraphProperties as Operations registerGraphProperties
    function<void()> regGraphPropsFunc = bind(&Connections::registerGraphProperties, this);

Simulator/Connections/NG911/Connections911.cpp

@@ -97,11 +97,11 @@ BGSIZE Connections911::getEdgeToClosestResponder(const Call &call, BGSIZE vertex
 
    vertexType requiredType;
    if (call.type == "Law")
-      requiredType = LAW;
+      requiredType = vertexType::LAW;
    else if (call.type == "EMS")
-      requiredType = EMS;
+      requiredType = vertexType::EMS;
    else if (call.type == "Fire")
-      requiredType = FIRE;
+      requiredType = vertexType::FIRE;
 
    // loop over the outgoing edges looking for the responder with the shortest
    // Euclidean distance to the call's location.
@@ -145,7 +145,7 @@ bool Connections911::erasePSAP(AllVertices &vertices, Layout &layout)
 
    // Find all psaps
    for (int i = 0; i < numVertices; i++) {
-      if (layout.vertexTypeMap_[i] == PSAP) {
+      if (layout.vertexTypeMap_[i] == vertexType::PSAP) {
          psaps.push_back(i);
       }
    }
@@ -189,13 +189,14 @@ bool Connections911::erasePSAP(AllVertices &vertices, Layout &layout)
          edges_->eraseEdge(destVertex, iEdg);
 
          // Identify all psap-less callers
-         if (layout.vertexTypeMap_[srcVertex] == CALR) {
+         if (layout.vertexTypeMap_[srcVertex] == vertexType::CALR) {
             callersToReroute.push_back(srcVertex);
          }
 
          // Identify all psap-less responders
-         if (layout.vertexTypeMap_[destVertex] == LAW || layout.vertexTypeMap_[destVertex] == FIRE
-             || layout.vertexTypeMap_[destVertex] == EMS) {
+         if (layout.vertexTypeMap_[destVertex] == vertexType::LAW
+             || layout.vertexTypeMap_[destVertex] == vertexType::FIRE
+             || layout.vertexTypeMap_[destVertex] == vertexType::EMS) {
             respsToReroute.push_back(destVertex);
          }
       }
@@ -204,7 +205,7 @@ bool Connections911::erasePSAP(AllVertices &vertices, Layout &layout)
    if (changesMade) {
       // This is here so that we don't delete the vertex if we can't find any edges
       verticesErased.push_back(randPSAP);
-      layout.vertexTypeMap_[randPSAP] = VTYPE_UNDEF;
+      layout.vertexTypeMap_[randPSAP] = vertexType::VTYPE_UNDEF;
    }
 
    // Failsafe
@@ -229,14 +230,14 @@ bool Connections911::erasePSAP(AllVertices &vertices, Layout &layout)
       }
 
       // Insert Caller to PSAP edge
-      BGSIZE iEdg
-         = edges_->addEdge(CP, srcVertex, closestPSAP, Simulator::getInstance().getDeltaT());
+      BGSIZE iEdg = edges_->addEdge(edgeType::CP, srcVertex, closestPSAP,
+                                    Simulator::getInstance().getDeltaT());
 
       // Record added edge
       ChangedEdge addedEdge;
       addedEdge.srcV = srcVertex;
       addedEdge.destV = closestPSAP;
-      addedEdge.eType = CP;
+      addedEdge.eType = edgeType::CP;
       edgesAdded.push_back(addedEdge);
    }
 
@@ -257,14 +258,14 @@ bool Connections911::erasePSAP(AllVertices &vertices, Layout &layout)
       }
 
       // Insert PSAP to Responder edge
-      BGSIZE iEdg
-         = edges_->addEdge(PR, closestPSAP, destVertex, Simulator::getInstance().getDeltaT());
+      BGSIZE iEdg = edges_->addEdge(edgeType::PR, closestPSAP, destVertex,
+                                    Simulator::getInstance().getDeltaT());
 
       // Record added edge
       ChangedEdge addedEdge;
       addedEdge.srcV = closestPSAP;
       addedEdge.destV = destVertex;
-      addedEdge.eType = PR;
+      addedEdge.eType = edgeType::PR;
       edgesAdded.push_back(addedEdge);
    }
 
@@ -281,8 +282,9 @@ bool Connections911::eraseRESP(AllVertices &vertices, Layout &layout)
 
    // Find all resps
    for (int i = 0; i < numVertices; i++) {
-      if (layout.vertexTypeMap_[i] == LAW || layout.vertexTypeMap_[i] == FIRE
-          || layout.vertexTypeMap_[i] == EMS) {
+      if (layout.vertexTypeMap_[i] == vertexType::LAW
+          || layout.vertexTypeMap_[i] == vertexType::FIRE
+          || layout.vertexTypeMap_[i] == vertexType::EMS) {
          resps.push_back(i);
       }
    }
@@ -325,7 +327,7 @@ bool Connections911::eraseRESP(AllVertices &vertices, Layout &layout)
    if (changesMade) {
       // This is here so that we don't delete the vertex if we can't find any edges
       verticesErased.push_back(randRESP);
-      layout.vertexTypeMap_[randRESP] = VTYPE_UNDEF;
+      layout.vertexTypeMap_[randRESP] = vertexType::VTYPE_UNDEF;
    }
 
    return changesMade;
@@ -339,22 +341,22 @@ string Connections911::ChangedEdge::toString()
    string type_s;
 
    switch (eType) {
-      case CP:
+      case edgeType::CP:
          type_s = "CP";
          break;
-      case PR:
+      case edgeType::PR:
          type_s = "PR";
          break;
-      case PP:
+      case edgeType::PP:
          type_s = "PP";
          break;
-      case PC:
+      case edgeType::PC:
          type_s = "PC";
          break;
-      case RP:
+      case edgeType::RP:
          type_s = "RP";
          break;
-      case RC:
+      case edgeType::RC:
          type_s = "RC";
          break;
       default:

Simulator/Core/FunctionNodes/GenericFunctionNode.cpp

@@ -14,15 +14,15 @@
 #include <functional>
 
 /// Constructor, Function Signature: void ()
-GenericFunctionNode::GenericFunctionNode(const Operations::op &operation,
+GenericFunctionNode::GenericFunctionNode(const Operations &operation,
                                          const std::function<void()> &func)
 {
    operationType_ = operation;
    function_ = func;
 }
 
 /// Invokes the stored function if the sent operation type matches the operation type the function is stored as.
-bool GenericFunctionNode::invokeFunction(const Operations::op &operation) const
+bool GenericFunctionNode::invokeFunction(const Operations &operation) const
 {
    if (operation == operationType_) {
       __invoke(function_);

Simulator/Core/FunctionNodes/GenericFunctionNode.h

@@ -17,13 +17,13 @@ using namespace std;
 class GenericFunctionNode : public IFunctionNode {
 public:
    /// Constructor, Function Signature: void ()
-   GenericFunctionNode(const Operations::op &operationType, const std::function<void()> &function);
+   GenericFunctionNode(const Operations &operationType, const std::function<void()> &function);
 
    /// Destructor
    ~GenericFunctionNode() = default;
 
    /// Invokes the stored function if the sent operation type matches the operation type the function is stored as.
-   bool invokeFunction(const Operations::op &operation) const override;
+   bool invokeFunction(const Operations &operation) const override;
 
 private:
    std::function<void()> function_;   ///< Stored function.

Simulator/Core/FunctionNodes/IFunctionNode.h

@@ -19,9 +19,9 @@ class IFunctionNode {
    virtual ~IFunctionNode() = default;
 
    /// Invokes the stored function if the sent operation type matches the operation type the function is stored as.
-   virtual bool invokeFunction(const Operations::op &operation) const = 0;
+   virtual bool invokeFunction(const Operations &operation) const = 0;
 
 protected:
    /// The operation type of the stored function.
-   Operations::op operationType_;
+   Operations operationType_;
 };

Simulator/Core/OperationManager.cpp

@@ -27,7 +27,7 @@ OperationManager &OperationManager::getInstance()
 /// Called by lower level classes constructors on creation to register their operations with their operation type.
 /// This method can be overloaded to handle different function signatures.
 /// Handles function signature: void ()
-void OperationManager::registerOperation(const Operations::op &operation,
+void OperationManager::registerOperation(const Operations &operation,
                                          const function<void()> &function)
 {
    try {
@@ -41,7 +41,7 @@ void OperationManager::registerOperation(const Operations::op &operation,
 }
 
 /// Takes in a operation type and invokes all registered functions that are classified as that operation type.
-void OperationManager::executeOperation(const Operations::op &operation) const
+void OperationManager::executeOperation(const Operations &operation) const
 {
    LOG4CPLUS_INFO(logger_, "Executing operation " + operationToString(operation));
    if (functionList_.size() > 0) {
@@ -52,24 +52,24 @@ void OperationManager::executeOperation(const Operations::op &operation) const
 }
 
 /// Takes in the operation enum and returns the enum as a string. Used for debugging purposes.
-string OperationManager::operationToString(const Operations::op &operation) const
+string OperationManager::operationToString(const Operations &operation) const
 {
    switch (operation) {
-      case Operations::op::printParameters:
+      case Operations::printParameters:
          return "printParameters";
-      case Operations::op::loadParameters:
+      case Operations::loadParameters:
          return "loadParameters";
-      case Operations::op::serialize:
+      case Operations::serialize:
          return "serialize";
-      case Operations::op::deserialize:
+      case Operations::deserialize:
          return "deserialize";
-      case Operations::op::deallocateGPUMemory:
+      case Operations::deallocateGPUMemory:
          return "deallocateGPUMemory";
-      case Operations::op::restoreToDefault:
+      case Operations::restoreToDefault:
          return "restoreToDefault";
-      case Operations::op::copyToGPU:
+      case Operations::copyToGPU:
          return "copyToGPU";
-      case Operations::op::copyFromGPU:
+      case Operations::copyFromGPU:
          return "copyFromGPU";
       default:
          return "Operation isn't in OperationManager::operationToString()";

Simulator/Core/OperationManager.h

@@ -33,13 +33,13 @@ class OperationManager {
    /// Called by lower level classes constructors on creation to register their operations with their operation type.
    /// This method can be overloaded to handle different function signatures.
    /// Handles function signature: void ()
-   void registerOperation(const Operations::op &operation, const function<void()> &function);
+   void registerOperation(const Operations &operation, const function<void()> &function);
 
    /// Takes in a operation type and invokes all registered functions that are classified as that operation type.
-   void executeOperation(const Operations::op &operation) const;
+   void executeOperation(const Operations &operation) const;
 
    /// Takes in the operation enum and returns the enum as a string. Used for debugging purposes.
-   string operationToString(const Operations::op &operation) const;
+   string operationToString(const Operations &operation) const;
 
    /// Delete copy and move methods to avoid copy instances of the singleton
    OperationManager(const OperationManager &operationManager) = delete;

Simulator/Core/Operations.h

@@ -9,19 +9,16 @@
 
 #pragma once
 
-class Operations {
-public:
+enum class Operations {
    /// Available operations the OperationManager can register and execute.
-   enum op {
-      printParameters,
-      loadParameters,
-      registerGraphProperties,
-      setup,
-      serialize,
-      deserialize,
-      deallocateGPUMemory,   // Make sure deallocate memory isn't called until all GPU memory is copied back.
-      restoreToDefault,   // Not sure what this refers to.
-      copyToGPU,
-      copyFromGPU
-   };
+   printParameters,
+   loadParameters,
+   registerGraphProperties,
+   setup,
+   serialize,
+   deserialize,
+   deallocateGPUMemory,   // Make sure deallocate memory isn't called until all GPU memory is copied back.
+   restoreToDefault,   // Not sure what this refers to.
+   copyToGPU,
+   copyFromGPU
 };

Simulator/Edges/AllEdges.cpp

@@ -16,7 +16,7 @@ AllEdges::AllEdges() : totalEdgeCount_(0), maxEdgesPerVertex_(0), countVertices_
    // OperationManager. This will register the appropriate overridden method
    // for the actual (sub)class of the object being created.
    function<void()> loadParametersFunc = std::bind(&AllEdges::loadParameters, this);
-   OperationManager::getInstance().registerOperation(Operations::op::loadParameters,
+   OperationManager::getInstance().registerOperation(Operations::loadParameters,
                                                      loadParametersFunc);
 
    // Register printParameters function as a printParameters operation in the
@@ -76,7 +76,7 @@ void AllEdges::setupEdges(int numVertices, int maxEdges)
 
    if (maxTotalEdges != 0) {
       W_.assign(maxTotalEdges, 0);
-      type_.assign(maxTotalEdges, ETYPE_UNDEF);
+      type_.assign(maxTotalEdges, edgeType::ETYPE_UNDEF);
       inUse_.assign(maxTotalEdges, false);
       edgeCounts_.assign(numVertices, 0);
       destVertexIndex_.assign(maxTotalEdges, 0);
@@ -128,25 +128,25 @@ edgeType AllEdges::edgeOrdinalToType(int typeOrdinal)
 {
    switch (typeOrdinal) {
       case 0:
-         return II;
+         return edgeType::II;
       case 1:
-         return IE;
+         return edgeType::IE;
       case 2:
-         return EI;
+         return edgeType::EI;
       case 3:
-         return EE;
+         return edgeType::EE;
       case 4:
-         return CP;
+         return edgeType::CP;
       case 5:
-         return PR;
+         return edgeType::PR;
       case 6:
-         return PC;
+         return edgeType::PC;
       case 7:
-         return PP;
+         return edgeType::PP;
       case 8:
-         return RP;
+         return edgeType::RP;
       default:
-         return ETYPE_UNDEF;
+         return edgeType::ETYPE_UNDEF;
    }
 }