Menu
▾
▴
[Scstudio-commits] SF.net SVN: scstudio:[511] trunk
|
From: <koc...@us...> - 2009-12-09 06:38:29
|
Revision: 511
http://scstudio.svn.sourceforge.net/scstudio/?rev=511&view=rev
Author: kocianon
Date: 2009-12-09 06:38:21 +0000 (Wed, 09 Dec 2009)
Log Message:
-----------
New Duplicator - FIX
Modified Paths:
--------------
trunk/src/check/pseudocode/msc_duplicators.cpp
trunk/src/check/pseudocode/msc_duplicators.h
trunk/src/check/time/constraint_syntax.cpp
trunk/src/check/time/constraint_syntax.h
trunk/src/check/time/tightening.h
trunk/src/data/dfs_hmsc_flat_traverser.cpp
trunk/src/data/dfs_hmsc_flat_traverser.h
trunk/tests/CMakeLists.txt
Modified: trunk/src/check/pseudocode/msc_duplicators.cpp
===================================================================
--- trunk/src/check/pseudocode/msc_duplicators.cpp 2009-12-09 01:19:20 UTC (rev 510)
+++ trunk/src/check/pseudocode/msc_duplicators.cpp 2009-12-09 06:38:21 UTC (rev 511)
@@ -120,99 +120,75 @@
}
///////////////////////////////////////////////
-HMscPtr HMscFlatDuplicator::duplicate(HMscPtr hmsc)
+ //! chooses right type of HMscNode, makes and sets copy, return copy
+ HMscNode* HMscDuplicator::process_node(HMscNode* n)
{
- m_hmsc = hmsc;
- if(!hmsc.get())
- return m_hmsc_copy;
+ HMscNode* copy;
+ ReferenceNode* reference_node;
+ ConnectionNode* connection_node;
+ EndNode* end_node;
+ ConditionNode* condition_node;
- m_hmsc_copy = new HMsc(m_hmsc.get());
- set_copy(m_hmsc.get(),m_hmsc_copy.get());
-
- DFSHMscFlatTraverser traverser("FlatDuplicator");
- traverser.add_white_node_found_listener(this);
- traverser.add_node_finished_listener(this);
- traverser.traverse(hmsc);
- create_time_relation();
- return m_hmsc_copy;
- }
-
-
- void HMscFlatDuplicator::on_white_node_found(HMscNode* n)
- {
- HMscNode* copy;
- ReferenceNode* reference_node = dynamic_cast<ReferenceNode*>(n);
- if(reference_node)
+ if((reference_node=dynamic_cast<ReferenceNode*>(n)))
copy = create(reference_node);
-
- ConnectionNode* connection_node = dynamic_cast<ConnectionNode*>(n);
- if(connection_node)
+ else if((connection_node= dynamic_cast<ConnectionNode*>(n)))
copy = create(connection_node);
-
- StartNode* start_node = dynamic_cast<StartNode*>(n);
- if(start_node)
- copy = create(start_node);
-
- EndNode* end_node = dynamic_cast<EndNode*>(n);
- if(end_node)
+ else if((end_node= dynamic_cast<EndNode*>(n)))
copy = create(end_node);
-
- ConditionNode* condition_node = dynamic_cast<ConditionNode*>(n);
- if(condition_node)
+ else if((condition_node=dynamic_cast<ConditionNode*>(n)))
copy = create(condition_node);
+ else
+ throw std::logic_error("Unknown type of HMscNode found. Add this type.");
- m_hmsc_copy->add_node(copy);
set_copy(n,copy);
+ return copy;
}
- void HMscFlatDuplicator::on_node_finished(HMscNode* n)
+ HMscNode* HMscDuplicator::create(ReferenceNode* n)
{
- create_node_relation(n);
- }
-
-HMscNode* HMscFlatDuplicator::create(ReferenceNode* n)
- {
ReferenceNode* copy = new ReferenceNode(n);
- // check whether there is BMsc inside
-
- BMscPtr bmsc = n->get_bmsc();
- if (bmsc.get())
- {
- BMscPtr new_bmsc = BMscDuplicator::duplicate(bmsc);
- copy->set_msc(new_bmsc);
- }
-
+ // check inner msc
+ inner_msc(n);
return static_cast<HMscNode*>(copy);
}
- HMscNode* HMscFlatDuplicator::create(StartNode* n)
- {
- StartNode* copy = new StartNode(n);
- m_hmsc_copy->set_start(copy);
- return static_cast<HMscNode*>(copy);
- }
-
- HMscNode* HMscFlatDuplicator::create(EndNode* n)
+ HMscNode* HMscDuplicator::create(EndNode* n)
{
EndNode* copy = new EndNode(n);
return static_cast<HMscNode*>(copy);
}
-HMscNode* HMscFlatDuplicator::create(ConditionNode* n)
+ HMscNode* HMscDuplicator::create(ConditionNode* n)
{
ConditionNode* copy = new ConditionNode(n);
return static_cast<HMscNode*>(copy);
}
- HMscNode* HMscFlatDuplicator::create(ConnectionNode* n)
+ HMscNode* HMscDuplicator::create(ConnectionNode* n)
{
ConnectionNode* copy = new ConnectionNode(n);
return static_cast<HMscNode*>(copy);
}
+/////////////////
+ HMsc* HMscDuplicator::create(HMsc* hmsc)
+ {
+ HMsc* copy = new HMsc(hmsc);
+ set_copy(hmsc,copy);
+ StartNode* start = create(hmsc->get_start().get());
+ copy->set_start(start);
+ return copy;
+ }
- void HMscFlatDuplicator::create_node_relation(HMscNode* n)
+ StartNode* HMscDuplicator::create(StartNode* n)
{
+ StartNode* copy = new StartNode(n);
+ set_copy(n,copy);
+ return copy;
+ }
+///////////////////
+ void HMscDuplicator::create_node_relation(HMscNode* n)
+ {
PredecessorNode* pre;
pre = dynamic_cast<PredecessorNode*>(n);
if(!pre)
@@ -225,23 +201,23 @@
NodeRelationPtrVector relations;
NodeRelationPtrVector::iterator it;
- NodeRelationPtr rel;
+ NodeRelationPtr rel_copy;
relations = pre->get_successors();
for(it=relations.begin();it!=relations.end();it++)
{
succ = (*it)->get_successor();
- rel=pre_copy->add_successor(get_copy(succ));
- set_copy(it->get(),rel.get());
+ rel_copy=pre_copy->add_successor(get_copy(succ));
+ set_copy(it->get(),rel_copy.get());
}
}
- void HMscFlatDuplicator::create_time_relation()
+ void HMscDuplicator::create_time_relation(HMscPtr hmsc)
{
// get all time relations
- HMscAllTimeRelations rels(m_hmsc);
+ HMscAllTimeRelations rels(hmsc);
TimeRelationRefNodePtrSet::iterator it;
for(it=rels.begin();it!=rels.end();it++)
@@ -259,61 +235,124 @@
ReferenceNode* a_copy = get_copy(a);
ReferenceNode* b_copy = get_copy(b);
// built up new time relation
- TimeRelationRefNodePtr rel_copy;
+ TimeRelationRefNode* rel_copy;
rel_copy = new TimeRelationRefNode(rel.get());
rel_copy->glue_ref_node_a(bottom_a,a_copy);
rel_copy->glue_ref_node_b(bottom_b,b_copy);
- set_copy(rel.get(),rel_copy.get());
+ set_copy(rel.get(),rel_copy);
}
}
-/////////////////////////////////////////////////////////////////////////////
+ void HMscDuplicator::inner_msc(ReferenceNode* ref)
+ {
+ MscPtr msc = ref->get_msc();
+ if(!msc.get())
+ throw std::logic_error("Empty ReferenceNode - inner Msc is NULL pointer.");
+ BMsc* bmsc;
+ HMsc* hmsc;
+ if((bmsc=dynamic_cast<BMsc*>(msc.get())))
+ {
+ inner_msc_found(bmsc);
+ }
+ else if((hmsc=dynamic_cast<HMsc*>(msc.get())))
+ {
+ inner_msc_found(hmsc);
+ }
+ else
+ throw std::logic_error("Couldnt find right type of inner msc.");
+
+ m_to_set_up.push(std::make_pair(ref,msc.get()));
+
+ }
+
+ void HMscDuplicator::inner_msc_found(HMscPtr hmsc)
+ {
+ if(m_hmscs.find(hmsc.get())==m_hmscs.end())
+ {
+ m_to_create_hm.push(hmsc.get());
+ m_hmscs.insert(hmsc.get());
+ }
+ }
+
+ void HMscDuplicator::inner_msc_found(BMscPtr bmsc)
+ {
+ if(m_bmscs.find(bmsc.get())==m_bmscs.end())
+ {
+ m_to_create_bm.push(bmsc.get());
+ m_bmscs.insert(bmsc.get());
+ }
+ }
+
+
HMscPtr HMscDuplicator::duplicate(HMscPtr hmsc)
{
- m_hmsc = hmsc;
+ std::stack<BMscPtr> created_bmsc;
+ std::stack<HMscPtr> created_hmsc;
+ m_hmsc_root = hmsc;
+ if(!hmsc.get()) // null hmsc
+ throw std::logic_error("Null HMsc to duplicate.");
- DFSHMscFlatTraverser traverser("HMscDuplicator attribute");
+ m_to_create_hm.push(hmsc.get()); // insert to the stack to create
+ m_hmscs.insert(m_hmsc_root.get()); // insert as allready found
+
+ HMsc* copy;
+ BMscPtr b_copy;
+ while(!m_to_create_hm.empty())
+ {
+ // std::cerr << "HMscDuplicator: creating hmsc" << std::endl;
+ HMscPtr hmsc = m_to_create_hm.top();
+ m_to_create_hm.pop();
+ copy = create(hmsc.get());
- traverser.add_inner_hmsc_listener(this);
- add_hmsc_as_traversed(hmsc.get());
- DFSHMscsTraverse tra(&traverser);
- tra.traverse(hmsc);
- m_hmsc_copy = m_duplicator.duplicate(hmsc);
- m_hmscs.insert(hmsc.get());
+ HMscNodePtrSet nodes = hmsc->get_nodes();
+ HMscNodePtrSet::iterator it;
+ for(it=nodes.begin();it!=nodes.end();it++)
+ {
+ HMscNodePtr node = process_node(it->get());
+ copy->add_node(node);
+ }
- while(!m_to_create.empty())
+ // create start relations
+ create_node_relation(static_cast<HMscNode*>(hmsc->get_start().get()));
+
+ // create relations
+ for(it=nodes.begin();it!=nodes.end();it++)
+ {
+ create_node_relation(it->get());
+ }
+
+ // create time relations
+ create_time_relation(hmsc);
+ created_hmsc.push(copy);
+ }
+
+ while(!m_to_create_bm.empty())
{
- HMscPtr hmsc = m_to_create.top();
- m_to_create.pop();
- m_duplicator.duplicate(hmsc);
+ // std::cerr << "HMscDuplicator: creating bmsc" << std::endl;
+ BMscPtr bmsc = m_to_create_bm.top();
+ m_to_create_bm.pop();
+ b_copy = BMscDuplicator::duplicate(bmsc);
+ created_bmsc.push(b_copy);
+ set_copy(bmsc.get(),b_copy.get());
}
while(!m_to_set_up.empty())
{
+ // std::cerr << "HMscDuplicator: setting up" << std::endl;
ReferenceNode* n = m_to_set_up.top().first;
- HMscPtr h = m_to_set_up.top().second;
+ Msc* msc = m_to_set_up.top().second;
m_to_set_up.pop();
- ReferenceNode* n_copy = m_duplicator.get_copy(n);
- HMscPtr h_copy = m_duplicator.get_copy(h.get());
- n_copy->set_msc(h_copy);
+ ReferenceNode* n_copy = get_copy(n);
+ n_copy->set_msc(get_copy(msc));
}
-
- return m_hmsc_copy;
+ copy = get_copy(m_hmsc_root.get());
+ return copy;
}
- void HMscDuplicator::on_inner_hmsc_found(HMscPtr hmsc, ReferenceNode* refNode)
- {
- m_to_set_up.push(std::make_pair(refNode,hmsc.get()));
- }
- void HMscDuplicator::on_new_inner_hmsc_found(HMscPtr hmsc, ReferenceNode* refNode)
- {
- m_to_create.push(hmsc.get());
- }
-
/////////////////////////////////////////////////////////////////////////////
EventsCreatorListener::EventsCreatorListener(BMscDuplicator* duplicator, DFSAreaTraverser* traverser, BMsc* bmsc):
Modified: trunk/src/check/pseudocode/msc_duplicators.h
===================================================================
--- trunk/src/check/pseudocode/msc_duplicators.h 2009-12-09 01:19:20 UTC (rev 510)
+++ trunk/src/check/pseudocode/msc_duplicators.h 2009-12-09 06:38:21 UTC (rev 511)
@@ -69,6 +69,18 @@
return static_cast<HMsc*>(get_copy(n));
}
+ BMsc* get_copy(BMsc* p)
+ {
+ MscElement* n = static_cast<MscElement*>(p);
+ return static_cast<BMsc*>(get_copy(n));
+ }
+
+ Msc* get_copy(Msc* p)
+ {
+ MscElement* n = static_cast<MscElement*>(p);
+ return static_cast<Msc*>(get_copy(n));
+ }
+
void set_copy(MscElement* original, MscElement* copy);
void cleanup_attributes();
@@ -165,54 +177,44 @@
};
/**
- * \brief Build up copy of HMsc, does inner BMsc but NOT inner HMsc
+ * \brief HMscDuplicator creates exact copy of HMsc
*/
-class SCPSEUDOCODE_EXPORT HMscFlatDuplicator:
-public Duplicator
-,public WhiteNodeFoundListener
-,public NodeFinishedListener
+
+class SCPSEUDOCODE_EXPORT HMscDuplicator:
+ public Duplicator
{
private:
- HMscPtr m_hmsc;
- HMscPtr m_hmsc_copy;
-public:
+ HMscPtr m_hmsc_root;
- HMscFlatDuplicator()
- {}
+ std::set<HMsc*> m_hmscs; // set of created hmsc
+ std::set<BMsc*> m_bmscs; // set of created bmsc
- HMscPtr duplicate(HMscPtr hmsc);
+ std::stack<BMsc*> m_to_create_bm;
+ std::stack<HMsc*> m_to_create_hm;
+ std::stack<std::pair<ReferenceNode*,Msc*> > m_to_set_up;
- void on_white_node_found(HMscNode* n);
- void on_node_finished(HMscNode* n);
+ void inner_msc(ReferenceNode*);
+ void inner_msc_found(HMscPtr);
+ void inner_msc_found(BMscPtr);
+ HMsc* create(HMsc* hmsc);
+ StartNode* create(StartNode* n);
+
HMscNode* create(ReferenceNode* n);
- HMscNode* create(StartNode* n);
HMscNode* create(EndNode* n);
HMscNode* create(ConditionNode* n);
HMscNode* create(ConnectionNode* n);
+ HMscNode* process_node(HMscNode* n);
void create_node_relation(HMscNode* n);
- void create_time_relation();
-};
+ void create_time_relation(HMscPtr);
-class SCPSEUDOCODE_EXPORT HMscDuplicator: public InnerHMscFoundListener
-{
-private:
- HMscPtr m_hmsc;
- HMscPtr m_hmsc_copy;
- HMscFlatDuplicator m_duplicator;
- std::stack<HMsc*> m_to_create;
- std::stack<std::pair<ReferenceNode*,HMsc*> > m_to_set_up;
-
public:
HMscDuplicator()
{ }
HMscPtr duplicate(HMscPtr hmsc);
- void on_inner_hmsc_found(HMscPtr hmsc, ReferenceNode* refNode);
-
- void on_new_inner_hmsc_found(HMscPtr hmsc, ReferenceNode* refNode);
};
class BMscGraphDuplicator;
@@ -358,4 +360,4 @@
#endif /* _MSC_DUPLICATORS_H */
-// $Id$
+// $Id$
\ No newline at end of file
Modified: trunk/src/check/time/constraint_syntax.cpp
===================================================================
--- trunk/src/check/time/constraint_syntax.cpp 2009-12-09 01:19:20 UTC (rev 510)
+++ trunk/src/check/time/constraint_syntax.cpp 2009-12-09 06:38:21 UTC (rev 511)
@@ -28,6 +28,7 @@
{
m_changed=true;
refNode->set_marked(true);
+ std::cout << "setting marked" << std::endl;
}
}
@@ -255,7 +256,7 @@
traverser.traverse(m_hmsc);
}
-
+/*
HMscPtr HMscConstraintCheck::check(HMscPtr hmsc)
{
m_hmsc = hmsc;
@@ -276,7 +277,7 @@
mark_time_relations(copies);
return p;
-}
+}*/
bool HMscConstraintCheck::check_copy(HMscPtr hmsc)
{
Modified: trunk/src/check/time/constraint_syntax.h
===================================================================
--- trunk/src/check/time/constraint_syntax.h 2009-12-09 01:19:20 UTC (rev 510)
+++ trunk/src/check/time/constraint_syntax.h 2009-12-09 06:38:21 UTC (rev 511)
@@ -108,7 +108,7 @@
std::string m_first_find_with; /// attr of TimeRelation, RefNode first find with
std::stack<MscElement*> to_be_clean; ///< stack of items with atribute
std::set<TimeRelationRefNodePtr> m_active_constraints; ///< global set of active constrains
- HMscFlatDuplicator m_duplicator;
+ HMscDuplicator m_duplicator;
std::set<TimeRelationRefNodePtr> m_broken_rel;
HMscPtr m_hmsc;
@@ -143,7 +143,7 @@
}
/// Checks whether hmsc satisfy deadlock free property.
- HMscPtr check(HMscPtr hmsc);
+// HMscPtr check(HMscPtr hmsc);
bool check_copy(HMscPtr hmsc);
void on_white_node_found(ReferenceNode*);
Modified: trunk/src/check/time/tightening.h
===================================================================
--- trunk/src/check/time/tightening.h 2009-12-09 01:19:20 UTC (rev 510)
+++ trunk/src/check/time/tightening.h 2009-12-09 06:38:21 UTC (rev 511)
@@ -161,7 +161,7 @@
return transform(bmsc);
}
-
+
BMscPtr transform(BMscPtr bmsc);
~BMscTighter() {}
Modified: trunk/src/data/dfs_hmsc_flat_traverser.cpp
===================================================================
--- trunk/src/data/dfs_hmsc_flat_traverser.cpp 2009-12-09 01:19:20 UTC (rev 510)
+++ trunk/src/data/dfs_hmsc_flat_traverser.cpp 2009-12-09 06:38:21 UTC (rev 511)
@@ -112,7 +112,6 @@
////////////////////////////////////////////////////////
void DFSHMscsTraverse::traverse(HMscPtr hmsc)
{
- //set_hmsc_parent(hmsc);
m_to_traverse.push(hmsc.get()); // push to the stack
add_hmsc_as_traversed(hmsc); // add this hmsc as it was traversed
m_traverser->add_inner_hmsc_listener(this);
@@ -135,6 +134,7 @@
void DFSHMscsTraverse::on_new_inner_hmsc_found(HMscPtr hmsc, ReferenceNode* refNode)
{
+ set_hmsc_parent(hmsc);
m_to_traverse.push(hmsc.get());
}
Modified: trunk/src/data/dfs_hmsc_flat_traverser.h
===================================================================
--- trunk/src/data/dfs_hmsc_flat_traverser.h 2009-12-09 01:19:20 UTC (rev 510)
+++ trunk/src/data/dfs_hmsc_flat_traverser.h 2009-12-09 06:38:21 UTC (rev 511)
@@ -152,8 +152,8 @@
TraverseHMscStartListenerPList m_hmsc_start_listeners;
TraverseHMscFinishListenerPList m_hmsc_finish_listeners;
- HMscPtr get_hmsc_parent(HMscPtr);
- void set_hmsc_parent(HMscPtr);
+ HMscPtr get_hmsc_parent(MscPtr);
+ void set_hmsc_parent(MscPtr);
public:
DFSHMscsTraverse(DFSHMscFlatTraverser* t, std::string p="hmsc_parent")
Modified: trunk/tests/CMakeLists.txt
===================================================================
--- trunk/tests/CMakeLists.txt 2009-12-09 01:19:20 UTC (rev 510)
+++ trunk/tests/CMakeLists.txt 2009-12-09 06:38:21 UTC (rev 511)
@@ -177,6 +177,17 @@
scpseudocode
scZ120
)
+
+#ADD_EXECUTABLE(duplicator_test
+
+# duplicator_test.cpp
+#)
+#TARGET_LINK_LIBRARIES(duplicator_test
+# scmsc
+# sctime
+# scpseudocode
+# scZ120
+#)
#
# ADD_EXECUTABLE(bmsc_tightening_test
# bmsc_tightening_test.cpp
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
