Skip to content

Commit a850e53

Browse files
MarcG-TUEMarcG-TUE
committed
passing test again
1 parent 2d67238 commit a850e53

File tree

6 files changed

+95
-96
lines changed

6 files changed

+95
-96
lines changed

‎include/maxplus/base/fsm/fsm.h‎

Lines changed: 77 additions & 80 deletions
Original file line numberDiff line numberDiff line change
@@ -334,17 +334,17 @@ template <typename StateLabelType, typename EdgeLabelType> class Edge : public A
334334
EdgeLabelType label;
335335
};
336336

337-
template <typename StateLabelType, typename EdgeLabelType>
338-
class SetOfEdges : public Abstract::SetOfEdges {
339-
public:
340-
using CIter = typename SetOfEdges<StateLabelType, EdgeLabelType>::const_iterator;
341-
};
337+
// template <typename StateLabelType, typename EdgeLabelType>
338+
// class SetOfEdges : public Abstract::SetOfEdges {
339+
// public:
340+
// using CIter = typename Abstract::SetOfEdges::const_iterator;
341+
// };
342342

343-
template <typename StateLabelType, typename EdgeLabelType>
344-
class SetOfEdgeRefs : public Abstract::SetOfEdgeRefs {
345-
public:
346-
using CIter = typename SetOfEdgeRefs<StateLabelType, EdgeLabelType>::const_iterator;
347-
};
343+
// template <typename StateLabelType, typename EdgeLabelType>
344+
// class SetOfEdgeRefs : public Abstract::SetOfEdgeRefs {
345+
// public:
346+
// using CIter = typename Abstract::SetOfEdgeRefs::const_iterator;
347+
// };
348348

349349
template <typename StateLabelType, typename EdgeLabelType>
350350
class SetOfStates : public Abstract::SetOfStates {
@@ -364,11 +364,11 @@ class SetOfStates : public Abstract::SetOfStates {
364364
}
365365
};
366366

367-
template <typename StateLabelType, typename EdgeLabelType>
368-
class SetOfStateRefs : public Abstract::SetOfStateRefs {
369-
public:
370-
using CIter = typename SetOfStateRefs::const_iterator;
371-
};
367+
// template <typename StateLabelType, typename EdgeLabelType>
368+
// class SetOfStateRefs : public Abstract::SetOfStateRefs {
369+
// public:
370+
// using CIter = typename SetOfStateRefs::const_iterator;
371+
// };
372372

373373
template <typename StateLabelType, typename EdgeLabelType> class State : public Abstract::State {
374374
public:
@@ -381,14 +381,13 @@ template <typename StateLabelType, typename EdgeLabelType> class State : public
381381
[[nodiscard]] const StateLabelType &getLabel() const { return this->stateLabel; }
382382

383383
// return all next states reachable via an edge labelled l
384-
std::shared_ptr<SetOfStateRefs<StateLabelType, EdgeLabelType>>
384+
std::shared_ptr<Abstract::SetOfStateRefs>
385385
nextStatesOfEdgeLabel(const EdgeLabelType l) {
386-
auto result = std::make_shared<SetOfStateRefs<StateLabelType, EdgeLabelType>>();
387-
auto es = static_cast<SetOfEdgeRefs<StateLabelType, EdgeLabelType> &>(
386+
auto result = std::make_shared<Abstract::SetOfStateRefs>();
387+
auto es = static_cast<const Abstract::SetOfEdgeRefs &>(
388388
this->getOutgoingEdges());
389-
typename SetOfEdgeRefs<StateLabelType, EdgeLabelType>::CIter i;
390-
for (i = es.begin(); i != es.end(); i++) {
391-
auto *e = static_cast<Edge<StateLabelType, EdgeLabelType> *>(*i);
389+
for (auto& i: es) {
390+
auto *e = static_cast<Edge<StateLabelType, EdgeLabelType> *>(i);
392391
if (e->label == l) {
393392
result->insert(&(e->getDestination()));
394393
}
@@ -399,11 +398,10 @@ template <typename StateLabelType, typename EdgeLabelType> class State : public
399398
// return an arbitrary next state reachable via an edge labelled l
400399
// or null if no such state exists
401400
State<StateLabelType, EdgeLabelType> *nextStateOfEdgeLabel(const EdgeLabelType l) {
402-
auto es = static_cast<SetOfEdgeRefs<StateLabelType, EdgeLabelType> &>(
401+
auto es = static_cast<const Abstract::SetOfEdgeRefs &>(
403402
this->getOutgoingEdges());
404-
typename SetOfEdgeRefs<StateLabelType, EdgeLabelType>::CIter i;
405-
for (i = es.begin(); i != es.end(); i++) {
406-
Edge<StateLabelType, EdgeLabelType> *e = *i;
403+
for (auto& i: es) {
404+
Edge<StateLabelType, EdgeLabelType> *e = i;
407405
if (e->label == l) {
408406
return e->getDestination();
409407
}
@@ -417,7 +415,7 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
417415

418416
private:
419417
SetOfStates<StateLabelType, EdgeLabelType> states;
420-
SetOfEdges<StateLabelType, EdgeLabelType> edges;
418+
Abstract::SetOfEdges edges;
421419
const State<StateLabelType, EdgeLabelType> *initialState;
422420

423421
public:
@@ -444,7 +442,6 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
444442
EdgeLabelType lbl,
445443
State<StateLabelType, EdgeLabelType> &dst) {
446444
bool added = false;
447-
typename SetOfEdges<StateLabelType, EdgeLabelType>::CIter i;
448445
auto ep = std::make_shared<Edge<StateLabelType, EdgeLabelType>>(src, lbl, dst);
449446
auto& e = *ep;
450447
this->edges[e.getId()] = std::move(ep);
@@ -458,7 +455,7 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
458455

459456
void removeState(const State<StateLabelType, EdgeLabelType>& s) {
460457
// remove related edges
461-
SetOfEdgeRefs<StateLabelType, EdgeLabelType> edgesToRemove;
458+
Abstract::SetOfEdgeRefs edgesToRemove;
462459
for(auto& it: this->edges) {
463460
auto& e = *(it.second);
464461
auto src = dynamic_cast<const State<StateLabelType, EdgeLabelType>&>(e.getSource());
@@ -520,12 +517,12 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
520517

521518
SetOfStates<StateLabelType, EdgeLabelType> &getStates() { return this->states; };
522519

523-
SetOfEdges<StateLabelType, EdgeLabelType> &getEdges() { return this->edges; };
520+
Abstract::SetOfEdges &getEdges() { return this->edges; };
524521

525522
Edge<StateLabelType, EdgeLabelType> *
526523
getEdge(const State<StateLabelType, EdgeLabelType> &source,
527524
const State<StateLabelType, EdgeLabelType> &target) {
528-
auto e = static_cast<const SetOfEdgeRefs<StateLabelType, EdgeLabelType> &>(
525+
auto e = static_cast<const Abstract::SetOfEdgeRefs &>(
529526
source.getOutgoingEdges());
530527

531528
// collect all labels in edges of s
@@ -578,12 +575,12 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
578575
if (s->stateLabel == src) {
579576
State<StateLabelType, EdgeLabelType> &srcState = this->getStateLabeled(src);
580577

581-
const SetOfEdgeRefs<StateLabelType, EdgeLabelType> &outgoingEdges =
582-
static_cast<const SetOfEdges<StateLabelType, EdgeLabelType> &>(
578+
const Abstract::SetOfEdgeRefs &outgoingEdges =
579+
static_cast<const Abstract::SetOfEdgeRefs &>(
583580
srcState.getOutgoingEdges());
584581

585-
for (auto it : outgoingEdges) {
586-
auto e = *it;
582+
for (auto& it : outgoingEdges) {
583+
auto e = dynamic_cast<const Edge<StateLabelType, EdgeLabelType> *>(it);
587584
auto dstState = e->getDestination();
588585
if (e->label == lbl && dstState->getLabel() == dst) {
589586
found = e;
@@ -602,12 +599,12 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
602599
result = std::make_shared<FiniteStateMachine<StateLabelType, EdgeLabelType>>();
603600

604601
// maintain map of sets of states to the corresponding new states.
605-
std::map<const SetOfStateRefs<StateLabelType, EdgeLabelType> &,
602+
std::map<const Abstract::SetOfStateRefs &,
606603
State<StateLabelType, EdgeLabelType> *>
607604
newStatesMap;
608605

609606
// queue of states that need to be further explored.
610-
std::list<std::shared_ptr<SetOfStateRefs<StateLabelType, EdgeLabelType>>> unprocessed;
607+
std::list<std::shared_ptr<Abstract::SetOfStateRefs>> unprocessed;
611608

612609
// create initial state
613610
std::shared_ptr<SetOfStates<StateLabelType, EdgeLabelType>> initialStateSet;
@@ -624,12 +621,12 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
624621
unprocessed.push_back(initialStateSet);
625622

626623
while (!unprocessed.empty()) {
627-
std::shared_ptr<SetOfStateRefs<StateLabelType, EdgeLabelType>> Q = *unprocessed.begin();
628-
unprocessed->erase(unprocessed.begin());
624+
Abstract::SetOfStateRefs Q = *(*(unprocessed.begin()));
625+
unprocessed.erase(unprocessed.begin());
629626

630627
// get all outgoing labels
631628
std::set<EdgeLabelType> labels;
632-
for (auto i : Q) {
629+
for (const auto *i : Q) {
633630
auto s = *i;
634631
this->insertOutgoingLabels(s, labels);
635632
}
@@ -639,18 +636,18 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
639636
EdgeLabelType l = *j;
640637

641638
// collect image state in Qnext
642-
std::shared_ptr<SetOfStateRefs<StateLabelType, EdgeLabelType>> Qnext =
643-
std::make_shared<SetOfStateRefs<StateLabelType, EdgeLabelType>>();
639+
std::shared_ptr<Abstract::SetOfStateRefs> Qnext =
640+
std::make_shared<Abstract::SetOfStateRefs>();
644641

645642
// for every state s in Q
646-
for (auto i : *Q) {
647-
auto s = *i;
648-
std::shared_ptr<SetOfStateRefs<StateLabelType, EdgeLabelType>> l_img =
649-
s->nextStatesOfEdgeLabel(l);
643+
for (const auto *i : Q) {
644+
const auto& s = dynamic_cast<State<StateLabelType, EdgeLabelType> &>(*i);
645+
std::shared_ptr<Abstract::SetOfStateRefs> l_img =
646+
s.nextStatesOfEdgeLabel(l);
650647

651648
// add all l-images from s to Qnext
652-
for (auto k : *l_img) {
653-
auto *simg = *k;
649+
for (auto& k : *l_img) {
650+
auto *simg = k;
654651
Qnext->insert(simg);
655652
}
656653
}
@@ -670,7 +667,7 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
670667
}
671668

672669
// add an edge in the new fsm
673-
result->addEdge(newStatesMap[*Q], l, ns);
670+
result->addEdge(newStatesMap[Q], l, ns);
674671
}
675672
}
676673

@@ -686,19 +683,19 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
686683
// partition refinement algorithm
687684

688685
// generate a vector of equivalence classes
689-
std::shared_ptr<std::list<std::shared_ptr<SetOfStateRefs<StateLabelType, EdgeLabelType>>>>
686+
std::shared_ptr<std::list<std::shared_ptr<Abstract::SetOfStateRefs>>>
690687
eqClasses = std::make_shared<std::list<
691-
std::shared_ptr<SetOfStateRefs<StateLabelType, EdgeLabelType>>>>();
688+
std::shared_ptr<Abstract::SetOfStateRefs>>>();
692689

693690
// populate it with s set of all states
694-
std::shared_ptr<SetOfStateRefs<StateLabelType, EdgeLabelType>> initialClass =
695-
std::make_shared<SetOfStateRefs<StateLabelType, EdgeLabelType>>(
691+
std::shared_ptr<Abstract::SetOfStateRefs> initialClass =
692+
std::make_shared<Abstract::SetOfStateRefs>(
696693
*(this->getStates()));
697694
eqClasses->push_back(initialClass);
698695

699696
// initially map all state to the initial class
700697
EquivalenceMap eqMap;
701-
for (auto si : initialClass) {
698+
for (const auto *si : *initialClass) {
702699
eqMap[*si] = initialClass;
703700
}
704701

@@ -708,13 +705,13 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
708705
changed = false;
709706

710707
std::shared_ptr<
711-
std::list<std::shared_ptr<SetOfStateRefs<StateLabelType, EdgeLabelType>>>>
708+
std::list<std::shared_ptr<Abstract::SetOfStateRefs>>>
712709
newEqClasses = std::make_shared<std::list<
713-
std::shared_ptr<SetOfStateRefs<StateLabelType, EdgeLabelType>>>>();
710+
std::shared_ptr<Abstract::SetOfStateRefs>>>();
714711

715712
// for every potential equivalence class
716-
for (auto ic : eqClasses) {
717-
SetOfStateRefs<StateLabelType, EdgeLabelType> *_class = *ic;
713+
for (const auto& ic : *eqClasses) {
714+
std::shared_ptr<Abstract::SetOfStateRefs> _class = ic;
718715

719716
typename SetOfStates<StateLabelType, EdgeLabelType>::iterator i;
720717
i = _class->begin();
@@ -724,10 +721,10 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
724721
State<StateLabelType, EdgeLabelType> *s2 = nullptr;
725722
s1 = *i;
726723

727-
std::shared_ptr<SetOfStateRefs<StateLabelType, EdgeLabelType>> equivSet =
728-
std::make_shared<SetOfStateRefs<StateLabelType, EdgeLabelType>>();
729-
std::shared_ptr<SetOfStateRefs<StateLabelType, EdgeLabelType>> remainingSet =
730-
std::make_shared<SetOfStateRefs<StateLabelType, EdgeLabelType>>();
724+
std::shared_ptr<Abstract::SetOfStateRefs> equivSet =
725+
std::make_shared<Abstract::SetOfStateRefs>();
726+
std::shared_ptr<Abstract::SetOfStateRefs> remainingSet =
727+
std::make_shared<Abstract::SetOfStateRefs>();
731728
equivSet->insert(s1);
732729

733730
// check whether all other states can go with the same label to
@@ -760,11 +757,11 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
760757
std::make_shared<FiniteStateMachine<StateLabelType, EdgeLabelType>>();
761758

762759
// make a state for every equivalence class
763-
std::map<SetOfStateRefs<StateLabelType, EdgeLabelType> *,
760+
std::map<Abstract::SetOfStateRefs *,
764761
State<StateLabelType, EdgeLabelType> *>
765762
newStateMap;
766763
CId sid = 0;
767-
for (auto cli : eqClasses) {
764+
for (const auto& cli : *eqClasses) {
768765
std::shared_ptr<State<StateLabelType, EdgeLabelType>> ns =
769766
std::make_shared<State<StateLabelType, EdgeLabelType>>(sid);
770767
result->addState(ns);
@@ -773,13 +770,13 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
773770
}
774771

775772
// make the appropriate edges
776-
for (auto cli : eqClasses) {
773+
for (const auto& cli : *eqClasses) {
777774
// take a representative state
778-
auto s = *((*cli)->begin());
775+
const auto *s = *(cli->begin());
779776
auto es = s->getOutgoingEdges();
780777
// for every outgoing edge
781-
for (auto edi : es) {
782-
auto ed = *edi;
778+
for (auto *edi : es) {
779+
auto ed = dynamic_cast<Edge<StateLabelType, EdgeLabelType>*>(edi);
783780
result->addEdge(
784781
newStateMap[*cli], ed->label, newStateMap[eqMap[ed->getDestination()]]);
785782
}
@@ -794,11 +791,11 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
794791
private:
795792
void insertOutgoingLabels(State<StateLabelType, EdgeLabelType> *s,
796793
std::set<EdgeLabelType> &labels) {
797-
const SetOfEdgeRefs<StateLabelType, EdgeLabelType> &e = s->getOutgoingEdges();
794+
const Abstract::SetOfEdgeRefs &e = s->getOutgoingEdges();
798795

799796
// collect all labels in edges of s
800-
for (auto i : e) {
801-
auto *ed = *i;
797+
for (auto *i : e) {
798+
auto *ed = dynamic_cast<Edge<StateLabelType, EdgeLabelType>*>(i);
802799
labels.insert(ed->label);
803800
}
804801
};
@@ -853,9 +850,9 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
853850
using ELSState = ::FSM::Labeled::State<CId, CString>;
854851
using ELSEdge = ::FSM::Labeled::Edge<CId, CString>;
855852
using ELSSetOfStates = ::FSM::Labeled::SetOfStates<CId, CString>;
856-
using ELSSetOfEdges = ::FSM::Labeled::SetOfEdges<CId, CString>;
857-
using ELSSetOfStateRefs = ::FSM::Labeled::SetOfStateRefs<CId, CString>;
858-
using ELSSetOfEdgeRefs = ::FSM::Labeled::SetOfEdgeRefs<CId, CString>;
853+
using ELSSetOfEdges = ::FSM::Abstract::SetOfEdges;
854+
using ELSSetOfStateRefs = ::FSM::Abstract::SetOfStateRefs;
855+
using ELSSetOfEdgeRefs = ::FSM::Abstract::SetOfEdgeRefs;
859856

860857
class EdgeLabeledScenarioFSM : public ::FSM::Labeled::FiniteStateMachine<CId, CString> {
861858
public:
@@ -874,18 +871,18 @@ namespace StateStringLabeled {
874871
// make an FSM class with unlabeled edges, based on the labeled one with some dummy char labels
875872
//
876873

877-
class SetOfEdges : public Labeled::SetOfEdges<CString, char> {};
878-
class SetOfEdgeRefs : public Labeled::SetOfEdgeRefs<CString, char> {};
874+
// class SetOfEdges : public Labeled::SetOfEdges<CString, char> {};
875+
// class SetOfEdgeRefs : public Labeled::SetOfEdgeRefs<CString, char> {};
879876

880-
class SetOfStates : public Labeled::SetOfStates<CString, char> {};
881-
class SetOfStateRefs : public Labeled::SetOfStateRefs<CString, char> {};
877+
// class SetOfStates : public Labeled::SetOfStates<CString, char> {};
878+
// class SetOfStateRefs : public Labeled::SetOfStateRefs<CString, char> {};
882879

883880
class State : public Labeled::State<CString, char> {
884881
public:
885882
explicit State(const CString &withLabel) : Labeled::State<CString, char>(withLabel) {}
886883

887-
const SetOfEdgeRefs &getOutgoingEdges() {
888-
return dynamic_cast<const SetOfEdgeRefs &>(
884+
const Abstract::SetOfEdgeRefs &getOutgoingEdges() {
885+
return dynamic_cast<const Abstract::SetOfEdgeRefs &>(
889886
Labeled::State<CString, char>::getOutgoingEdges());
890887
}
891888
};
@@ -905,7 +902,7 @@ class FiniteStateMachine : public Labeled::FiniteStateMachine<CString, char> {
905902

906903
void addEdgeLabeled(const CString &src, const CString &dst);
907904

908-
std::shared_ptr<SetOfStateRefs> reachableStates();
905+
std::shared_ptr<Abstract::SetOfStateRefs> reachableStates();
909906
};
910907

911908
class Edge : public Labeled::Edge<CString, char> {};

0 commit comments

Comments
 (0)