put CString and CException behind namespace

Author: MarcG-TUE

include/maxplus/algebra/mpmatrix.h

@@ -47,10 +47,11 @@
 #include <unordered_set>
 #include <vector>
 
-class CString;
 
 namespace MaxPlus {
 
+class CString;
+
 using namespace Graphs;
 
 /**

include/maxplus/base/exception/exception.h

@@ -44,6 +44,9 @@
 #include "../string/cstring.h"
 #include <exception>
 
+
+namespace MaxPlus {
+
 /*
  * CException
  * CException container class.
@@ -94,11 +97,13 @@ class CException : std::exception {
     friend std::ostream &operator<<(std::ostream &stream, const CException &e);
 };
 
+} // namespace MaxPlus
+
 #define ASSERT(condition, msg)                                                                     \
     {                                                                                              \
         if (!(condition))                                                                          \
-            throw CException(CString(__FILE__) + CString(":") + CString(__LINE__) + CString(": ")  \
-                             + CString(msg));                                                      \
+            throw MaxPlus::CException(MaxPlus::CString(__FILE__) + MaxPlus::CString(":") + MaxPlus::CString(__LINE__) + MaxPlus::CString(": ")  \
+                             + MaxPlus::CString(msg));                                                      \
     }
 
 #define EXCEPTION(msg, ...)                                                                        \

include/maxplus/base/fraction/fraction.h

@@ -47,6 +47,8 @@
 #include <climits>
 #include <cstdint>
 
+namespace MaxPlus {
+
 class CFraction {
 public:
     // Constructor
@@ -279,4 +281,6 @@ using CFractions = std::vector<CFraction>;
 using CFractionsIter = CFractions::iterator;
 using CFractionsCIter = CFractions::const_iterator;
 
+} // namespace MaxPlus
+
 #endif

include/maxplus/base/fsm/fsm.h

@@ -379,7 +379,7 @@ class SetOfStates : public Abstract::SetOfStates {
         if (this->labelIndex.find(l) != this->labelIndex.end()) {
             return *this->labelIndex[l];
         }
-        throw CException("error - state not found in FiniteStateMachine::_withLabel");
+        throw MaxPlus::CException("error - state not found in FiniteStateMachine::_withLabel");
     }
 
     bool hasStateWithLabel(StateLabelType l) {
@@ -544,7 +544,7 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
 
     [[nodiscard]] StateRef<StateLabelType, EdgeLabelType> getInitialState() const override {
         if (this->initialStates.empty()) {
-            throw CException("FSM has no initial state.");
+            throw MaxPlus::CException("FSM has no initial state.");
         }
         auto s = this->initialStates.begin();
         return dynamic_cast<StateRef<StateLabelType, EdgeLabelType>>(*s);
@@ -955,34 +955,34 @@ namespace StateStringLabeled {
 // make an FSM class with unlabeled edges, based on the labeled one with some dummy char labels
 //
 
-class State : public Labeled::State<CString, char> {
+class State : public Labeled::State<MaxPlus::CString, char> {
 public:
-    explicit State(const CString &withLabel) : Labeled::State<CString, char>(withLabel) {}
+    explicit State(const MaxPlus::CString &withLabel) : Labeled::State<MaxPlus::CString, char>(withLabel) {}
 
     const Abstract::SetOfEdgeRefs &getOutgoingEdges() {
         return dynamic_cast<const Abstract::SetOfEdgeRefs &>(
-                Labeled::State<CString, char>::getOutgoingEdges());
+                Labeled::State<MaxPlus::CString, char>::getOutgoingEdges());
     }
 };
 
-class FiniteStateMachine : public Labeled::FiniteStateMachine<CString, char> {
+class FiniteStateMachine : public Labeled::FiniteStateMachine<MaxPlus::CString, char> {
 public:
-    [[nodiscard]] Labeled::StateRef<CString, char> getInitialState() const override {
-        return dynamic_cast<Labeled::StateRef<CString, char>>(Labeled::FiniteStateMachine<CString, char>::getInitialState());
+    [[nodiscard]] Labeled::StateRef<MaxPlus::CString, char> getInitialState() const override {
+        return dynamic_cast<Labeled::StateRef<MaxPlus::CString, char>>(Labeled::FiniteStateMachine<MaxPlus::CString, char>::getInitialState());
     };
 
-    void setInitialStateLabeled(const CString &sl);
+    void setInitialStateLabeled(const MaxPlus::CString &sl);
 
-    void addStateLabeled(const CString &sl);
+    void addStateLabeled(const MaxPlus::CString &sl);
 
     void addEdge(State *src, State *dst);
 
-    void addEdgeLabeled(const CString &src, const CString &dst);
+    void addEdgeLabeled(const MaxPlus::CString &src, const MaxPlus::CString &dst);
 
     std::shared_ptr<Abstract::SetOfStateRefs> reachableStates();
 };
 
-class Edge : public Labeled::Edge<CString, char> {};
+class Edge : public Labeled::Edge<MaxPlus::CString, char> {};
 } // namespace StateStringLabeled
 
 namespace Product {

include/maxplus/base/fsm/iofsm.h

@@ -7,16 +7,16 @@
 #include <utility>
 
 // Input/Output Automaton
-using InputAction = CString;
-using OutputAction = CString;
+using InputAction = MaxPlus::CString;
+using OutputAction = MaxPlus::CString;
 using IOAEdgeLabel = std::pair<InputAction, OutputAction>;
 using IOAState = ::FSM::Labeled::State<CId, IOAEdgeLabel>;
 using IOAStateRef = const IOAState*;
 using IOAEdge = ::FSM::Labeled::Edge<CId, IOAEdgeLabel>;
 using IOAEdgeRef = ::FSM::Labeled::EdgeRef<CId, IOAEdgeLabel>;
-using IOASetOfStates = ::FSM::Labeled::SetOfStates<CId, CString>;
-using IOASetOfStateRefs = ::FSM::Labeled::SetOfStateRefs<CId, CString>;
-using IOASetOfEdges = ::FSM::Labeled::SetOfEdges<CId, CString>;
+using IOASetOfStates = ::FSM::Labeled::SetOfStates<CId, MaxPlus::CString>;
+using IOASetOfStateRefs = ::FSM::Labeled::SetOfStateRefs<CId, MaxPlus::CString>;
+using IOASetOfEdges = ::FSM::Labeled::SetOfEdges<CId, MaxPlus::CString>;
 using IOASetOfEdgeRefs = ::FSM::Abstract::SetOfEdgeRefs;
 
 namespace FSM::Labeled {

include/maxplus/base/string/cstring.h

@@ -41,15 +41,11 @@
 #ifndef BASE_STRING_CSTRING_H
 #define BASE_STRING_CSTRING_H
 
-#ifdef _MSC_VER
-#include <regex> // requires feature pack in VS2008
+#include "../basic_types.h"
+#include <regex>
 #include <string>
 
-#else
-#include <cstring>
-#endif
-
-#include "../basic_types.h"
+namespace MaxPlus {
 
 // Forward class definition
 class CString;
@@ -171,4 +167,6 @@ inline CString operator+(const char *lhs, const CString &rhs) {
 // Tokenize a string
 void stringTok(CStrings &l, const CString &str, const char *tok = " \t\n");
 
+} // namespace MaxPlus
+
 #endif

src/base/analysis/mcm/mcmhoward.cc

@@ -59,6 +59,8 @@
 #include <cstdlib>
 #include <memory>
 
+using namespace MaxPlus;
+
 namespace Graphs {
 /*
  * Howard terminates with an error if MAX_NIterations occur.

src/base/exception/exception.cc

@@ -40,9 +40,13 @@
 
 #include "base/exception/exception.h"
 
+namespace MaxPlus {
+
 // Prototype
 std::ostream &operator<<(std::ostream &stream, const CException &e) {
     e.report(stream);
 
     return stream;
 }
+
+} // namespace MaxPlus

src/base/fsm/fsm.cc

@@ -42,6 +42,8 @@
 #include <memory>
 #include <string>
 
+using namespace MaxPlus;
+
 namespace FSM {
 
 CId FSM::Abstract::WithUniqueID::nextID = 0;

src/base/string/cstring.cc

@@ -45,6 +45,8 @@
 #include <regex>
 #include <sstream>
 
+namespace MaxPlus {
+
 /**
  * CString ()
  * Constructor.
@@ -563,3 +565,5 @@ CString CString::regexReplaceMultiLine(const CString &regex, const CString &repl
         return *this;
     }
 }
+
+} // namespace MaxPlus