Menu
▾
▴
[Scstudio-commits] SF.net SVN: scstudio:[943] trunk
|
From: <ma...@us...> - 2010-09-16 16:18:22
|
Revision: 943
http://scstudio.svn.sourceforge.net/scstudio/?rev=943&view=rev
Author: madzin
Date: 2010-09-16 16:18:15 +0000 (Thu, 16 Sep 2010)
Log Message:
-----------
first part of refactoring process
Modified Paths:
--------------
trunk/src/membership/membership_alg.cpp
trunk/src/membership/membership_alg.h
trunk/tests/membership/CMakeLists.txt
Modified: trunk/src/membership/membership_alg.cpp
===================================================================
--- trunk/src/membership/membership_alg.cpp 2010-09-16 15:32:05 UTC (rev 942)
+++ trunk/src/membership/membership_alg.cpp 2010-09-16 16:18:15 UTC (rev 943)
@@ -29,68 +29,27 @@
#include <limits>
#include <map>
-//MembershipAlg object to be albe to use print_report
-MembershipAlg* mem;
-
-// map of bmsc names and configurations which were checked
-std::map<std::wstring, std::set<ConfigurationPtr> > checked;
-
-std::map<TimeRelationRefNodePtr, ConfigurationPtr> top_time_references;
-std::map<TimeRelationRefNodePtr, ConfigurationPtr> bottom_time_references;
-
-std::vector<Event*> attributed_events;
-
-//save ordering of coregion events in appropriate coregion
-std::map<CoregionAreaPtr, CoregionOrderingPtr> coregion_ordering;
-//snapshots of context for each coregion
-std::map<CoregionAreaPtr, SnapshotContextPtr> snapshots;
-//checked possibilities of coregion ordering
-std::map<CoregionAreaPtr, std::vector<CoregionOrderingPtr> > checked_orderings;
-
-//name of instances on which a user is focused on
-std::vector<std::wstring> focused_instances;
-
-//identification for receive events
-int max_id;
-
-BMscPtr global_bmsc;
-BMscIntervalSetMatrix* time_matrix;
-
InstancePtr find_instance(InstancePtrList instances, std::wstring name);
-HMscPtr search_bmsc(BMscPtr bmsc, BMscPtr bmsc_f);
-HMscPtr search_hmsc(HMscPtr hmsc, BMscPtr bmsc_f);
+HMscPtr search_bmsc(MembershipContext* c, BMscPtr bmsc, BMscPtr bmsc_f);
+HMscPtr search_hmsc(MembershipContext* c, HMscPtr hmsc, BMscPtr bmsc_f);
/*
- * find name of the instance among fosuces instances
- */
-bool contain_focused_instances(std::wstring instance)
-{
- for(unsigned int i = 0; i < focused_instances.size(); i++)
- {
- if(focused_instances[i] == instance)
- return true;
- }
-
- return false;
-}
-
-/*
* checks whole branch from defined node in HMSC
*/
-bool check_branch(HMscNodePtr node, ConfigurationPtr b);
+bool check_branch(MembershipContext* c, HMscNodePtr node, ConfigurationPtr b);
/*
* adds searched configuration to map of checked configurations
*
* configuration - state of node in searched HMSC and state of bMSC which is looked for
*/
-void add_checked_branch(ReferenceNodePtr ref_node, ConfigurationPtr searched_conf);
+void add_checked_branch(MembershipContext* c, ReferenceNodePtr ref_node, ConfigurationPtr searched_conf);
/*
* checks if instance contains any event
*/
-bool is_empty_instance(InstancePtrList node_instances, InstancePtrList b_instances);
+bool is_empty_instance(MembershipContext* c, InstancePtrList node_instances, InstancePtrList b_instances);
/*
* compares strict order area from HMSC node with matching strict order area from bMSC which is looked for
@@ -100,7 +59,7 @@
* type: membership - checks matching events and adds receive ordering
* receive_ordering - checks receive ordering
*/
-bool strict_strict(std::vector<Event*>& node_events, std::vector<Event*>& b_events, enum check_type type);
+bool strict_strict(MembershipContext* c, std::vector<Event*>& node_events, std::vector<Event*>& b_events, enum check_type type);
/*
* compares coregion area from HMSC node with matching strict order area from bMSC which is looked for
@@ -110,14 +69,14 @@
* type: membership - checks matching events and adds receive ordering
* receive_ordering - checks receive ordering
*/
-bool coregion_strict(std::vector<Event*>& node_events, std::vector<Event*>& b_events, enum check_type type);
+bool coregion_strict(MembershipContext* c, std::vector<Event*>& node_events, std::vector<Event*>& b_events, enum check_type type);
/*
* compares strict order area from HMSC node and coregion area from bMSC which is looked for
*
* DEVELOPMENT WAS STOPPED
*/
-bool strict_coregion(StrictOrderAreaPtr node_strict, std::vector<Event*>& node_events,
+bool strict_coregion(MembershipContext* c, StrictOrderAreaPtr node_strict, std::vector<Event*>& node_events,
CoregionAreaPtr b_coregion, std::vector<Event*>& b_events);
/*
@@ -125,7 +84,7 @@
*
* DEVELOPMENT WAS STOPPED
*/
-bool coregion_coretion(CoregionAreaPtr node_coregion, std::vector<Event*>& node_events,
+bool coregion_coregion(MembershipContext* c, CoregionAreaPtr node_coregion, std::vector<Event*>& node_events,
CoregionAreaPtr b_coregion, std::vector<Event*>& b_events);
/*
@@ -136,12 +95,12 @@
/*
* compares events attributes
*/
-bool compare_events_attribute(Event* a, Event* b);
+bool compare_events_attribute(MembershipContext* c, Event* a, Event* b);
/*
* tries to find configuration into map of seared configuration
*/
-bool look_at_checked_conf(ReferenceNodePtr node, ConfigurationPtr b);
+bool look_at_checked_conf(MembershipContext* c, ReferenceNodePtr node, ConfigurationPtr b);
/*
* compares one instance from HMSC node with matching instance from bMSC which is looked for
@@ -151,7 +110,7 @@
* receive_ordering - checks receive ordering
* old_position - events where the checking starts
*/
-bool check_instance(InstancePtr node_instance, enum check_type type, PositionPtr old_position);
+bool check_instance(MembershipContext* c, InstancePtr node_instance, enum check_type type, PositionPtr old_position);
/*
* compares bMsc from HMSC node with matching scenario in bMSC which is looked for
@@ -160,7 +119,7 @@
* receive_ordering - checks receive ordering
* old_conf - HMSC node configuration of start searching
*/
-bool check_node(ReferenceNodePtr node, enum check_type type, ConfigurationPtr old_conf);
+bool check_node(MembershipContext* c, ReferenceNodePtr node, enum check_type type, ConfigurationPtr old_conf);
/*
* in case events are send events, adds attribute to both events and to both receive event in case messages are complete
@@ -168,12 +127,12 @@
* parameters: node_e - event from HMSC node
* b_e - event from bMSC
*/
-void set_identification(Event* node_e, Event* b_e);
+void set_identification(MembershipContext* c, Event* node_e, Event* b_e);
/*
* checks whether node has null pointer to reference bMSC
*/
-bool is_node_null(ReferenceNodePtr node);
+bool is_node_null(MembershipContext* c, ReferenceNodePtr node);
/*
* checks whether instance contains any event
@@ -194,25 +153,25 @@
* checks time constraints in HMSC node
*/
//TODO skontrolovat co to vlastne robi, a kde kontrolujem casove obmedzenia v ramci bMSC z dajakeho HMSC nodu
-bool check_node_time(ReferenceNodePtr node, ConfigurationPtr conf);
+bool check_node_time(MembershipContext* c, ReferenceNodePtr node, ConfigurationPtr conf);
-bool check_node_time_themself(const std::vector<TimeRelationRefNodePtr>& themself_vec, ReferenceNodePtr node, ConfigurationPtr conf);
+bool check_node_time_themself(MembershipContext* c, const std::vector<TimeRelationRefNodePtr>& themself_vec, ReferenceNodePtr node, ConfigurationPtr conf);
/*
* finds the maximum event of HMSC node and returns time interval value of matching event in bMSC
*/
-Event* get_max_event(ReferenceNodePtr node, ConfigurationPtr conf);
+Event* get_max_event(MembershipContext* c, ReferenceNodePtr node, ConfigurationPtr conf);
/*
* returns map where the key is instance name and the value is vector of the event identifications
* (in case of coregion area)
*/
-std::map<std::wstring, std::vector<int> > get_node_last_events(ReferenceNodePtr node);
+std::map<std::wstring, std::vector<int> > get_node_last_events(MembershipContext* c, ReferenceNodePtr node);
/*
* finds the minimum event of HMSC node and returns time interval value of matching event in bMSC
*/
-Event* get_min_event(ConfigurationPtr conf);
+Event* get_min_event(MembershipContext* c, ConfigurationPtr conf);
/*
* compare absolut position, is the fist parameter before (more minimal) than the second
@@ -221,20 +180,21 @@
* 1 - the fist is before the second
* 2 - the second is before the first
*/
-int compare_absolut_position(Event* first, Event* second);
+int compare_absolut_position(MembershipContext* c, Event* first, Event* second);
/*
* returns the last event on instance
*/
-Event* get_last_instance_event(Event* start);
+Event* get_last_instance_event(MembershipContext* c, Event* start);
/*
* compares events time relations
*
- * paramterers: a - HMSC node
+ * paramterers: c - membership context
+ * a - HMSC node
* b - bMSC node
*/
-bool compare_events_time_relations(Event* a, Event* b);
+bool compare_events_time_relations(MembershipContext* c, Event* a, Event* b);
/*
* finds event in bMSC on instance by id
@@ -242,13 +202,8 @@
* parameters: label - label of instance where the event should be
* id - id of event which is looked for
*/
-Event* find_event_on_instance_by_id(std::wstring label, int id, StrictEventPtr start_event = NULL);
+Event* find_event_on_instance_by_id(MembershipContext* c, std::wstring label, int id, StrictEventPtr start_event = NULL);
-/*
- * removes event attribute "indentification"
- */
-void remove_events_attributes(std::vector<Event*> vec);
-
/*
* return matrix of time intervals among each nodes
*/
@@ -257,9 +212,9 @@
/*
*
*/
-void update_maximum_set(std::set<Event*>& max, Event* new_element);
+void update_maximum_set(MembershipContext* c, std::set<Event*>& max, Event* new_element);
-void update_minimum_set(std::set<Event*>& min, Event* new_element);
+void update_minimum_set(MembershipContext* c, std::set<Event*>& min, Event* new_element);
/*
* Returns precondition list of the membership algorithm
@@ -275,71 +230,14 @@
}
/*
-bool check_time_consistency_and_syntax(MscPtr msc, MscPtr bmsc)
-{
- HMscPtr hmsc = boost::dynamic_pointer_cast<HMsc > (msc);
- BMscPtr bmsc_f = boost::dynamic_pointer_cast<BMsc > (bmsc);
- ChannelMapperPtr mapper;
- ConsistencyChecker checker;
- ConstraintsChecker checker2;
- SRChannelMapperPtr srm = SRChannelMapper::instance(); //sender-receiver
-// SRMChannelMapperPtr srlm = SRMChannelMapper::instance(); //sender-receiver-label
-
- if (bmsc_f == NULL)
- {
- mem->print_report(RS_ERROR, L"MSC which is looked for, must be bMSC.");
- return NULL;
- }
-
- std::list<BMscPtr> consistency_results = checker.check(bmsc_f,srm);
- std::list<BMscPtr> constraints_results = checker2.check(bmsc_f,srm);
-
- if(!consistency_results.empty() || !consistency_results.empty())
- {
- mem->print_report(RS_ERROR, L"MSC which is looked for, is not time consistent or time constraints.");
- return false;
- }
-
- if (hmsc == NULL)
- {
- BMscPtr bmsc_scecification = boost::dynamic_pointer_cast<BMsc > (msc);
-
- if(bmsc_scecification != NULL)
- {
- std::list<BMscPtr> consistency_resultsII = checker.check(bmsc_scecification,srm);
- std::list<BMscPtr> constraints_resultsII = checker2.check(bmsc_scecification,srm);
-
- if(!consistency_resultsII.empty() || !constraints_resultsII.empty())
- {
- mem->print_report(RS_ERROR, L"MSC which is specification, is not time consistent or time constraints.");
- return false;
- }
- }
- }
- else
- {
-// std::list<HMscPtr> consistency_resultsIII = checker.check(hmsc,srm);
-// if(!consistency_resultsIII.empty())
-// {
-// mem->print_report(RS_ERROR, L"MSC which is specification, is not time consistent.");
-// return false;
-// }
- }
-
- return true;
-}
-*/
-
-/*
* Tries finding bMsc in Msc
*/
-MscPtr MembershipAlg::find(MscPtr msc, MscPtr bmsc)
+MscPtr MembershipAlg::find(MscPtr msc, MscPtr bmsc, std::vector<std::wstring> instances)
{
- mem = this;
+ MembershipContext* c = new MembershipContext();
+ c->set_mem(this);
+ c->set_focused_instances(instances);
-// if(!check_time_consistency_and_syntax(msc, bmsc))
-// return false;
-
HMscPtr hmsc = boost::dynamic_pointer_cast<HMsc > (msc);
BMscPtr bmsc_f = boost::dynamic_pointer_cast<BMsc > (bmsc);
@@ -350,15 +248,15 @@
return NULL;
}
- global_bmsc = bmsc_f;
+ c->set_bmsc(bmsc_f);
if (hmsc != NULL)
- return search_hmsc(hmsc, bmsc_f);
+ return search_hmsc(c, hmsc, bmsc_f);
else
{
BMscPtr bmsc = boost::dynamic_pointer_cast<BMsc > (msc);
if(bmsc != NULL)
- return search_bmsc(bmsc, bmsc_f);
+ return search_bmsc(c, bmsc, bmsc_f);
else
{
print_report(RS_ERROR, stringize() << "Membership algorithm cannot recognize a type of browsed MSC");
@@ -367,20 +265,17 @@
}
}
-MscPtr MembershipAlg::find(MscPtr msc, MscPtr bmsc, std::vector<std::wstring> instances)
+MscPtr MembershipAlg::find(MscPtr msc, MscPtr bmsc)
{
- focused_instances.insert(focused_instances.begin(), instances.begin(), instances.end());
-
- return this->find(msc, bmsc);
+ std::vector<std::wstring> instances;
+ return this->find(msc, bmsc, instances);
}
/*
* Tries to find bMSC in HMSC
*/
-HMscPtr search_hmsc(HMscPtr hmsc, BMscPtr bmsc_f)
+HMscPtr search_hmsc(MembershipContext* c, HMscPtr hmsc, BMscPtr bmsc_f)
{
- max_id = 0;
-
BMscGraphDuplicator duplicator;
HMscPtr dup_hmsc;
@@ -411,7 +306,7 @@
//get time matrix
BMscIntervalSetMatrix time_matrix2 = get_bmsc_matrix(bmsc_f);
- time_matrix = &time_matrix2;
+ c->set_time_matrix(&time_matrix2);
//creates configuration of defined bMSC
ConfigurationPtr searched_conf = new Configuration(bmsc_f->get_instances());
@@ -419,7 +314,7 @@
StartNodePtr start_node = dup_hmsc->get_start();
//strt of searching
- if (check_branch(start_node, searched_conf))
+ if (check_branch(c, start_node, searched_conf))
{
return new HMsc(); //TODO return path in hmsc
}
@@ -433,16 +328,16 @@
/*
* Checks branch if the communication is coressponding
- * parameters :
+ *
+ * parameters : c - membership context
* node - reference node
* b - MSC configuration for search
*/
-bool check_branch(HMscNodePtr hmsc_node, ConfigurationPtr b)
+bool check_branch(MembershipContext* c, HMscNodePtr hmsc_node, ConfigurationPtr b)
{
//remove attributes from previous computation
- if(!attributed_events.empty()){
- remove_events_attributes(attributed_events);
- attributed_events.clear();
+ if(!c->get_attributed_events().empty()){
+ c->clear_attributed_events();
}
//checks end node
@@ -450,7 +345,7 @@
if (end != NULL)
{
- if (b->is_null(focused_instances))
+ if (b->is_null(c))
return true;
else
return false;
@@ -473,7 +368,7 @@
{
HMscNode* succ = dynamic_cast<HMscNode*> ((*it)->get_successor());
ConfigurationPtr old = new Configuration(b);
- if (check_branch(succ, b))
+ if (check_branch(c, succ, b))
return true;
else
b = old;
@@ -484,15 +379,11 @@
else
{
//when deosn't exist empty path to EndNode
-// if (b->is_null() && !is_node_null(node))
-// return false;
-
- //when deosn't exist empty path to EndNode
- if (b->is_null(focused_instances) && !is_node_null(node))
+ if (b->is_null(c) && !is_node_null(c, node))
return false;
//checks if this node with this configuration was checked
- if (!look_at_checked_conf(node, b))
+ if (!look_at_checked_conf(c, node, b))
return false;
ConfigurationPtr old_config_I, old_config_II;
@@ -501,29 +392,26 @@
old_config_II = new Configuration(b);
//tries to matching events between searched MSC and bMSC which is looked for
- if (!check_node(node, membership, b))
+ if (!check_node(c, node, membership, b))
{
- remove_events_attributes(attributed_events);
- attributed_events.clear();
+ c->clear_attributed_events();
return false;
}
//checks time constraints for this node
- if(focused_instances.empty())
+ if(c->get_focused_instances().empty())
{
- if(!check_node_time(node, old_config_II))
+ if(!check_node_time(c, node, old_config_II))
{
- remove_events_attributes(attributed_events);
- attributed_events.clear();
+ c->clear_attributed_events();
return false;
}
}
//checks the ordering of events (by attribute which was set at check_node(node, membership,b))
- if (!check_node(node, receive_ordering, old_config_I))
+ if (!check_node(c, node, receive_ordering, old_config_I))
{
- remove_events_attributes(attributed_events);
- attributed_events.clear();
+ c->clear_attributed_events();
return false;
}
@@ -536,8 +424,7 @@
if(!b->compare(old_config_I))
return false;
- remove_events_attributes(attributed_events);
- attributed_events.clear();
+ c->clear_attributed_events();
NodeRelationPtrVector successors = node->get_successors();
NodeRelationPtrVector::iterator it;
@@ -554,7 +441,7 @@
{
ConfigurationPtr back_up = new Configuration(b);
- if (check_branch(hmsc_succ, b))
+ if (check_branch(c, hmsc_succ, b))
return true;
else
b = back_up;
@@ -568,7 +455,7 @@
/*
* Compare StrictOrderArea in bMSC from HMSC node and StrictOrderArea in bMSC from defined events
*/
-bool strict_strict(std::vector<Event*>& node_events, std::vector<Event*>& b_events, enum check_type type)
+bool strict_strict(MembershipContext* c, std::vector<Event*>& node_events, std::vector<Event*>& b_events, enum check_type type)
{
if (node_events.size() != 1 || b_events.size() != 1)
return false;
@@ -583,11 +470,11 @@
if (!compare_events(node_e, b_e))
return false;
- set_identification(node_e, b_e);
+ set_identification(c, node_e, b_e);
}
else
{
- if (!compare_events_attribute(node_e, b_e))
+ if (!compare_events_attribute(c, node_e, b_e))
return false;
}
@@ -614,75 +501,18 @@
*
* DEVELOPMENT WAS STOPPED
*/
-bool strict_coregion(StrictOrderAreaPtr node_strict, std::vector<Event*>& node_events,
+bool strict_coregion(MembershipContext* c, StrictOrderAreaPtr node_strict, std::vector<Event*>& node_events,
CoregionAreaPtr b_coregion, std::vector<Event*>& b_events)
{
- mem->print_report(RS_ERROR, L"unsuported function: finded bMSC cannot contain coregion");
+ c->get_mem()->print_report(RS_ERROR, L"unsuported function: finded bMSC cannot contain coregion");
return false;
-
- /* if(b_events.size() > 1)
- {
- //neni su rovnake
- }
- else
- Event* b_event = b_events.front();
- Event* node_event = node_events.front();
-
- while(node_e != NULL && b_e != NULL)
- {
- if(compare_events(node_e, b_e))
- {
- node_e = node_e->get_successor();
- b_e = node_e->get_successor();
- }
- else
- {
- //neni su rovnake
- }
- }
-
- if(node_e == NULL)
- node_events.clear();
- else
- b_events.clear();
- */
- // return true;
-
- /*
- Event* node_e = node_events.front();
- std::vector<Event*>::iterator it;
- bool stop = false;
-
- while(node_e != NULL || b_events.empty())
- {
- for(it = b_events.begin(); it! = b_events.end(); it++)
- {
- if(compare_events(node_e, *it))
- {
- node_e = node_e->get_successor();
- *it = (*it)->get_successor();
-
- if(*it == NULL)
- b_events.remove(it);
-
- stop = true;
- break;
- }
- }
-
- if(!stop)
- //neni su rovnake
-
- }
- */
}
/*
* checks attributes in guessed coregion message ordering
*/
-bool check_coregion_attributes(std::vector<Event*>& node_events, std::vector<Event*>& b_events)
+bool check_coregion_attributes(MembershipContext* c, std::vector<Event*>& node_events, std::vector<Event*>& b_events)
{
- std::map<CoregionAreaPtr, CoregionOrderingPtr>::iterator map_it;
EventAreaPtr node_e_a;
if(!node_events.empty())
@@ -694,28 +524,27 @@
if(cor == NULL)
{
- mem->print_report(RS_ERROR, L"Error: Unexpected behaviour 98");
+ c->get_mem()->print_report(RS_ERROR, L"Error: Unexpected behaviour 98");
return false;
}
- map_it = coregion_ordering.find(cor);
+ CoregionOrderingPtr ordering = c->find_coregion_ordering(cor);
- if(map_it == coregion_ordering.end())
+ if(ordering == NULL)
{
- std::cerr << "Error: Unexpected behaviour 100" << std::endl;
+ throw std::runtime_error("Unexpected behaviour");
return false;
}
- CoregionOrderingPtr ordering = map_it->second;
CoregionOrderingPtr back_up = new CoregionOrdering(ordering);
Event* node_e = ordering->getFirst().get();
StrictEvent* b_e = dynamic_cast<StrictEvent*> (b_events.front());
while (node_e != NULL && b_e != NULL)
{
- if (!compare_events_attribute(node_e, b_e))
+ if (!compare_events_attribute(c, node_e, b_e))
{
- checked_orderings[cor].push_back(new CoregionOrdering(back_up));
+ c->add_checked_ordering(cor, new CoregionOrdering(back_up));
return false;
}
ordering->removeFirst();
@@ -742,36 +571,40 @@
/*
* coretion_strict for receive_ordering type
*/
-bool coregion_strict_receive_ordering(std::vector<Event*>& node_events, std::vector<Event*>& b_events)
+bool coregion_strict_receive_ordering(MembershipContext* c, std::vector<Event*>& node_events, std::vector<Event*>& b_events)
{
- if(!check_coregion_attributes(node_events, b_events))
+ if(!check_coregion_attributes(c, node_events, b_events))
{
Event* e = node_events.front();
if(e == NULL)
{
- std::cerr << "Error: Unexpected behaviour 101" << std::endl;
+ throw std::runtime_error("Unexpected behaviour");
return false;
}
EventAreaPtr a = e->get_general_area();
CoregionAreaPtr cor = boost::dynamic_pointer_cast<CoregionArea>(a);
- std::map<CoregionAreaPtr, SnapshotContextPtr>::iterator snap_it;
+ SnapshotContextPtr snap = c->find_snapshot(cor);
- snap_it = snapshots.find(cor);
-
- if(snap_it == snapshots.end())
+ if(snap == NULL)
{
- std::cerr << "Error: Unexpected behaviour 102" << std::endl;
+ throw std::runtime_error("Unexpected behaviour");
return false;
}
- std::vector<Event*> snap_node_events = snap_it->second->getNodeEvents();
- std::vector<Event*> snap_b_events = snap_it->second->getBMSCEvents();
+ std::vector<Event*> snap_node_events = snap->getNodeEvents();
+ std::vector<Event*> snap_b_events = snap->getBMSCEvents();
- coregion_ordering[cor]->deleteOrdering();
+ if(c->find_coregion_ordering(cor) == NULL)
+ {
+ throw std::runtime_error("Unexpected behaviour");
+ return false;
+ }
- return coregion_strict(snap_node_events, snap_b_events, membership);
+ c->find_coregion_ordering(cor)->deleteOrdering();
+
+ return coregion_strict(c, snap_node_events, snap_b_events, membership);
}
//check_coregion_attributes is OK
@@ -785,11 +618,11 @@
* b_events - event in bmsc
* type - type of searching
*/
-bool coregion_strict(std::vector<Event*>& node_events, std::vector<Event*>& b_events,
+bool coregion_strict(MembershipContext* c, std::vector<Event*>& node_events, std::vector<Event*>& b_events,
enum check_type type)
{
if(type == receive_ordering)
- return coregion_strict_receive_ordering(node_events, b_events);
+ return coregion_strict_receive_ordering(c, node_events, b_events);
StrictEvent* b_e = dynamic_cast<StrictEvent*> (b_events.front());
std::vector<Event*> acceptable_events;
@@ -801,16 +634,15 @@
if (node_events.empty())
return true;
- std::map<CoregionAreaPtr, SnapshotContextPtr>::iterator snap_it;
Event* e = node_events.front();
EventAreaPtr e_a = e->get_general_area();
CoregionAreaPtr cor = boost::dynamic_pointer_cast<CoregionArea>(e_a);
- snap_it = snapshots.find(cor);
+ SnapshotContextPtr snap = c->find_snapshot(cor);
- if(snap_it == snapshots.end())
+ if(snap == NULL)
{
SnapshotContextPtr snap = new SnapshotContext(node_events, b_events);
- snapshots.insert(std::make_pair(cor, snap));
+ c->add_snapshot(cor, snap);
}
//it is supposed that the bMSC contains just one strict event area on one instance
@@ -840,30 +672,18 @@
for (accept_it = acceptable_events.begin(); accept_it != acceptable_events.end(); accept_it++)
{
- std::map<CoregionAreaPtr, CoregionOrderingPtr>::iterator map_it;
EventAreaPtr node_e_a = (*accept_it)->get_general_area();
CoregionAreaPtr cor = boost::dynamic_pointer_cast<CoregionArea> (node_e_a);
if(cor == NULL)
{
- std::cerr << "Error: Unexpected behaviour 98" << std::endl;
+ throw std::runtime_error("Unexpected behaviour");
return false;
}
- map_it = coregion_ordering.find(cor);
+ CoregionAreaPtr map_first = cor;
+ CoregionOrderingPtr map_second = c->find_coregion_ordering(cor);
- CoregionAreaPtr map_first;
- CoregionOrderingPtr map_second;
-
- if (map_it != coregion_ordering.end()){
- map_first = map_it->first;
- map_second = map_it->second;
- }
- else{
- map_first = cor;
- map_second = NULL;
- }
-
bool result = false;
result = compare_events(*accept_it, b_e);
@@ -871,27 +691,27 @@
if(result)
{
//set identification to events
- set_identification(*accept_it, b_e);
+ set_identification(c, *accept_it, b_e);
CoregionEvent* cor_e = dynamic_cast<CoregionEvent*> (*accept_it);
//save current coregion ordering
- if(map_it == coregion_ordering.end())
+ if(map_second == NULL)
{
std::vector<CoregionEventPtr> cor_vec;
if(cor_e == NULL)
{
- std::cerr << "Error: Unexpected behaviour 99" << std::endl;
+ throw std::runtime_error("Unexpected behaviour");
return false;
}
cor_vec.push_back(cor_e);
- coregion_ordering.insert(std::make_pair(cor, new CoregionOrdering(cor_vec)));
+ c->add_coregion_ordering(cor, new CoregionOrdering(cor_vec));
}
else
{
- map_it->second->addLast(cor_e);
+ map_second->addLast(cor_e);
}
node_e = dynamic_cast<CoregionEvent*> (*accept_it);
@@ -934,29 +754,28 @@
b_events.clear();
b_events.push_back(b_e);
- if (coregion_strict(node_events, b_events, type))
+ if (coregion_strict(c, node_events, b_events, type))
{
if (b_events.size() == 1 && *(b_events.begin()) == NULL)
b_events.clear();
- std::map<CoregionAreaPtr, std::vector<CoregionOrderingPtr> >::iterator checked_it;
- checked_it = checked_orderings.find(map_first);
+ std::vector<CoregionOrderingPtr> checked_orderings = c->find_checked_ordering(map_first);
CoregionOrderingPtr current_ordering = map_second;
//when it tries first ordering
- if(checked_it == checked_orderings.end())
+ if(checked_orderings.empty())
return true;
if(current_ordering == NULL)
{
- std::cerr << "Error: unexpected behaviour 102" << std::endl;
+ throw std::runtime_error("Unexpected behaviour");
return false;
}
//checks whether the ordering was not consider in previous computation
- for(unsigned int i = 0; i < checked_it->second.size(); i++)
+ for(unsigned int i = 0; i < checked_orderings.size(); i++)
{
- if(current_ordering->compare(checked_it->second.at(i)))
+ if(current_ordering->compare(checked_orderings[i]))
{
current_ordering->deleteOrdering();
return false;
@@ -972,14 +791,13 @@
node_events.clear();
- std::map<CoregionAreaPtr, CoregionOrderingPtr>::iterator map_it;
EventAreaPtr e_a = (*accept_it)->get_general_area();
CoregionAreaPtr cor = boost::dynamic_pointer_cast<CoregionArea> (e_a);
- map_it = coregion_ordering.find(cor);
+ CoregionOrderingPtr map_ordering = c->find_coregion_ordering(cor);
- if(map_it != coregion_ordering.end())
- map_it->second->removeLast();
+ if(map_ordering != NULL )
+ map_ordering->removeLast();
for (it_o = old_node_events.begin(); it_o != old_node_events.end(); it_o++)
node_events.push_back(*it_o);
@@ -995,62 +813,11 @@
*
* DEVELOPMENT WAS STOPPED
*/
-bool coregion_coretion(CoregionAreaPtr node_coregion, std::vector<Event*>& node_events,
+bool coregion_coregion(MembershipContext* c, CoregionAreaPtr node_coregion, std::vector<Event*>& node_events,
CoregionAreaPtr b_coregion, std::vector<Event*>& b_events)
{
- mem->print_report(RS_ERROR, L"Error: unsuported function (bMSC flow cannot contain coregion");
+ c->get_mem()->print_report(RS_ERROR, L"Error: unsuported function (bMSC flow cannot contain coregion");
return false;
-
- /*
- std::vector<Event*>::iterator node_it, b_it;
- CoregionEvent* node_e = NULL;
- CoregionEvent* b_e = NULL;
-
- for (node_it = node_events.begin(); node_it != node_events.end(); node_it++)
- {
- for (b_it = b_events.begin(); b_it != b_events.end();)
- {
- if (compare_events(*node_it, *b_it))
- {
- while (node_e != NULL && b_e != NULL)
- {
- if (compare_events(node_e, b_e))
- {
- // node_e = node_e->get_successors();
- // b_e = node_e->get_successors();
- }
- else
- {
- //neni su rovnake
- }
- }
-
- if ((node_e == NULL) == (b_e == NULL))
- {
- //neni su rovnake
- }
- else
- {
- std::vector<Event*>::iterator a = node_it++;
- std::vector<Event*>::iterator b = b_it++;
- node_events.erase(a);
- b_events.erase(b);
- }
-
- }
- }
- }
-
- if (b_events.empty() != node_events.empty())
- {
- //neni su rovnake
- }
-
- b_events.clear();
- node_events.clear();
-
- return true;
- */
}
/*
@@ -1073,24 +840,17 @@
/*
* Add checked branch to map of checked branches
*/
-void add_checked_branch(ReferenceNodePtr ref_node, ConfigurationPtr conf)
+void add_checked_branch(MembershipContext* c, ReferenceNodePtr ref_node, ConfigurationPtr conf)
{
BMscPtr bmsc = ref_node->get_bmsc();
if(bmsc == NULL)
{
- std::cerr << "Internal error: checked_branch" << std::endl;
+ throw std::runtime_error("Unexpected behaviour");
return;
}
- std::wstring bmsc_name = bmsc->get_label();
- std::set<ConfigurationPtr> conf_set;
- conf_set.insert(conf);
-
- if(checked.find(bmsc_name) == checked.end())
- checked.insert(std::make_pair(bmsc_name, conf_set));
- else
- checked.find(bmsc_name)->second.insert(conf);
+ c->add_checked_conf(bmsc->get_label(), conf);
}
/*
@@ -1134,7 +894,7 @@
}
//parameters node_e, b_e
-bool compare_events_attribute(Event* a, Event* b)
+bool compare_events_attribute(MembershipContext* c, Event* a, Event* b)
{
IncompleteMessagePtr incom_a = boost::dynamic_pointer_cast<IncompleteMessage > (a->get_message());
IncompleteMessagePtr incom_b = boost::dynamic_pointer_cast<IncompleteMessage > (b->get_message());
@@ -1165,18 +925,19 @@
b_id = b->get_attribute("identification", -2, b_set);
- if(focused_instances.empty() || contain_focused_instances(a->get_matching_event()->get_instance()->get_label()))
+ if(c->get_focused_instances().empty()
+ || c->contain_focused_instances(a->get_matching_event()->get_instance()->get_label()))
{
if (a_set || b_set || a_id != b_id)
return false;
- return compare_events_time_relations(a,b);
+ return compare_events_time_relations(c, a,b);
}
else
return true;
}
-bool compare_events_time_relations(Event* node_a, Event* bmsc_a)
+bool compare_events_time_relations(MembershipContext* c, Event* node_a, Event* bmsc_a)
{
TimeRelationEventPtrList node_intervals = node_a->get_time_relations();
TimeRelationEventPtrList::iterator it;
@@ -1192,11 +953,11 @@
if(time_node_b_id_set)
{
- std::cerr << "Error: Unexpected behaviour 3" << std::endl;
+ throw std::runtime_error("Unexpected behaviour");
return false;
}
- Event* bmsc_b = find_event_on_instance_by_id((*it)->get_event_b()->get_instance()->get_label(), time_node_b_id);
+ Event* bmsc_b = find_event_on_instance_by_id(c, (*it)->get_event_b()->get_instance()->get_label(), time_node_b_id);
if(bmsc_b == NULL)
return false;
@@ -1204,7 +965,7 @@
MscTimeIntervalSetD result, hmsc_inter, bmsc_inter;
hmsc_inter = (*it)->get_interval_set();
- bmsc_inter = time_matrix->operator()(bmsc_a, bmsc_b);
+ bmsc_inter = c->get_time_matrix()->operator()(bmsc_a, bmsc_b);
result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter);
if(result.is_empty())
@@ -1212,7 +973,7 @@
else
if(result != bmsc_inter)
{
-mem->print_report(RS_WARNING, L"Warning: the HMSC interval do not cover whole bMSC interval");
+c->get_mem()->print_report(RS_WARNING, L"Warning: the HMSC interval do not cover whole bMSC interval");
return false;
}
}
@@ -1221,13 +982,13 @@
return true;
}
-Event* find_event_on_instance_by_id(std::wstring label, int id, StrictEventPtr start_event)
+Event* find_event_on_instance_by_id(MembershipContext* c, std::wstring label, int id, StrictEventPtr start_event)
{
EventAreaPtr first;
if(start_event == NULL)
{
- InstancePtrList instances = global_bmsc->get_instances();
+ InstancePtrList instances = c->get_bmsc()->get_instances();
InstancePtrList::iterator it;
InstancePtr instance;
@@ -1254,7 +1015,7 @@
//function finds event only in bMSC which is looked for, so coregion area is not allowed
if(str == NULL)
{
- mem->print_report(RS_ERROR, L"Error: bMSC which is looked for contains coregion area");
+ c->get_mem()->print_report(RS_ERROR, L"Error: bMSC which is looked for contains coregion area");
return NULL;
}
@@ -1264,7 +1025,7 @@
event_id = str->get_attribute("identification", -1, event_set);
if(event_set)
- attributed_events.push_back(str.get());
+ c->add_attributed_event(str.get());
StrictEventPtr old;
@@ -1282,7 +1043,7 @@
if(strict == NULL)
{
- mem->print_report(RS_ERROR, L"Error: Node was not found");
+ c->get_mem()->print_report(RS_ERROR, L"Error: Node was not found");
return NULL;
}
@@ -1290,7 +1051,7 @@
if(str == NULL)
{
- mem->print_report(RS_ERROR, L"Error: Node was not found");
+ c->get_mem()->print_report(RS_ERROR, L"Error: Node was not found");
return NULL;
}
}
@@ -1298,7 +1059,7 @@
event_id = str->get_attribute("identification", -1, event_set);
if(event_set)
- attributed_events.push_back(str.get());
+ c->add_attributed_event(str.get());
}
return str.get();
@@ -1310,7 +1071,7 @@
* bmsc - where the bmsc_f is looking for
* bmsc_f - pattern
*/
-HMscPtr search_bmsc(BMscPtr bmsc, BMscPtr bmsc_f)
+HMscPtr search_bmsc(MembershipContext* c, BMscPtr bmsc, BMscPtr bmsc_f)
{
//creates HMSC
HMscPtr hmsc = new HMsc(L"membership");
@@ -1331,7 +1092,7 @@
node->add_successor(succ);
else
{
- std::cout << "Error: Unexpected behaviour 43" << std::endl;
+ throw std::runtime_error("Unexpected behaviour");
return NULL;
}
@@ -1346,17 +1107,17 @@
node->add_successor(succ);
else
{
- std::cout << "Error: Unexpected behaviour 23" << std::endl;
+ throw std::runtime_error("Unexpected behaviour");
return NULL;
}
- return search_hmsc(hmsc, bmsc_f);
+ return search_hmsc(c, hmsc, bmsc_f);
}
/*
* Checks if the instance is empty
*/
-bool is_empty_instance(InstancePtrList node_instances, InstancePtrList b_instances)
+bool is_empty_instance(MembershipContext* c, InstancePtrList node_instances, InstancePtrList b_instances)
{
InstancePtrList::iterator node_instence_it, b_instance_it;
@@ -1368,13 +1129,13 @@
//in case the user is not focused on this instance the algorithm skip the checking of them
bool skip = false;
- if(!focused_instances.empty())
+ if(!c->get_focused_instances().empty())
{
skip = true;
- for(unsigned int i = 0; i < focused_instances.size(); i++)
+ for(unsigned int i = 0; i < c->get_focused_instances().size(); i++)
{
- if(focused_instances[i] == (*node_instence_it)->get_label())
+ if(c->get_focused_instances().at(i) == (*node_instence_it)->get_label())
skip = false;
}
}
@@ -1425,23 +1186,17 @@
/*
* Checks if the node was checked with this configuration
*/
-bool look_at_checked_conf(ReferenceNodePtr node, ConfigurationPtr b)
+bool look_at_checked_conf(MembershipContext* c, ReferenceNodePtr node, ConfigurationPtr b)
{
- std::map<std::wstring, std::set<ConfigurationPtr> >::iterator it_checked;
- it_checked = checked.find(node->get_msc()->get_label());
+ const std::set<ConfigurationPtr> checked_conf = c->find_checked_conf(node->get_msc()->get_label());
- if (it_checked != checked.end())
+ if (!checked_conf.empty())
{
- std::set<ConfigurationPtr>::iterator conf_it;
+ std::set<ConfigurationPtr>::const_iterator conf_it;
- for (conf_it = it_checked->second.begin(); conf_it != it_checked->second.end();
- conf_it++)
- {
+ for (conf_it = checked_conf.begin(); conf_it != checked_conf.end(); conf_it++)
if (b->compare(*conf_it))
- {
return false;
- }
- }
}
return true;
@@ -1450,9 +1205,9 @@
/*
* Checks instance
*/
-bool check_instance(InstancePtr node_instance, enum check_type type, PositionPtr old_position)
+bool check_instance(MembershipContext* c, InstancePtr node_instance, enum check_type type, PositionPtr old_position)
{
- if(!focused_instances.empty() && !contain_focused_instances(node_instance->get_label()))
+ if(!c->get_focused_instances().empty() && !c->contain_focused_instances(node_instance->get_label()))
return true;
std::vector<Event*> node_events, b_events;
@@ -1504,7 +1259,7 @@
}
else
{
- std::cerr << "Tipecast failed" << std::endl;
+ throw std::runtime_error("Unexpected behaviour");
return false;
}
}
@@ -1513,7 +1268,7 @@
if (node_events.empty())
node_events.push_back(node_strict->get_first().get());
else
- std::cout << "Error: Unexpected error 24" << std::endl;
+ throw std::runtime_error("Unexpected behaviour");
}
bool result;
@@ -1524,18 +1279,18 @@
switch ((node_strict != NULL) + (b_strict != NULL))
{
case 2:
- result = strict_strict(node_events, b_events, type);
+ result = strict_strict(c, node_events, b_events, type);
break;
case 1:
if (node_strict != NULL)
- result = strict_coregion(node_strict, node_events, b_coregion, b_events);
+ result = strict_coregion(c, node_strict, node_events, b_coregion, b_events);
else
- result = coregion_strict(node_events, b_events, type);
+ result = coregion_strict(c, node_events, b_events, type);
break;
case 0:
- result = coregion_coretion(node_coregion, node_events, b_coregion, b_events);
+ result = coregion_coregion(c, node_coregion, node_events, b_coregion, b_events);
break;
default:
@@ -1614,7 +1369,7 @@
* Receive_ordering mode: bMSCs are traversed second time, old_conf defines points
* from where it starts traverse,
*/
-bool check_node(ReferenceNodePtr node, enum check_type type, ConfigurationPtr conf)
+bool check_node(MembershipContext* c, ReferenceNodePtr node, enum check_type type, ConfigurationPtr conf)
{
//get msc from the node
ConfigurationPtr old_conf = new Configuration(conf);
@@ -1624,7 +1379,7 @@
if (bmsc == NULL)
{
- mem->print_report(RS_ERROR, L"Error: Some reference node does not refers to bMSC");
+ c->get_mem()->print_report(RS_ERROR, L"Error: Some reference node does not refers to bMSC");
return false;
}
@@ -1636,9 +1391,9 @@
std::set<PositionPtr> positions = conf->get_positions();
std::set<PositionPtr>::iterator position_it;
- if (focused_instances.empty() && node_instances.size() > b_instances.size())
+ if (c->get_focused_instances().empty() && node_instances.size() > b_instances.size())
{
- if (!is_empty_instance(node_instances, b_instances))
+ if (!is_empty_instance(c, node_instances, b_instances))
return false;
}
@@ -1666,9 +1421,9 @@
if (node_instance == NULL)
continue; //remember position and continue in cycle
- if (!check_instance(node_instance, type, *position_it))
+ if (!check_instance(c, node_instance, type, *position_it))
{
- add_checked_branch(node, old_conf);
+ add_checked_branch(c, node, old_conf);
return false;
}
}
@@ -1676,22 +1431,23 @@
return true;
}
-void set_identification(Event* node_e, Event* b_e)
+void set_identification(MembershipContext* c, Event* node_e, Event* b_e)
{
if (node_e->is_send())
{
- node_e->set_attribute("identification", max_id);
- attributed_events.push_back(node_e);
- b_e->set_attribute("identification", max_id++);
- attributed_events.push_back(b_e);
+ node_e->set_attribute("identification", c->get_max_id());
+ c->add_attributed_event(node_e);
+ b_e->set_attribute("identification", c->get_max_id());
+ c->add_attributed_event(b_e);
+ c->increase_max_id();
CompleteMessagePtr node_message = node_e->get_complete_message();
if (node_message != NULL)
{
Event* event = node_message->get_receive_event();
- event->set_attribute("identification", max_id);
- attributed_events.push_back(event);
+ event->set_attribute("identification", c->get_max_id());
+ c->add_attributed_event(event);
}
CompleteMessagePtr b_message = b_e->get_complete_message();
@@ -1699,14 +1455,15 @@
if (b_message != NULL)
{
Event* event = b_message->get_receive_event();
- event->set_attribute("identification", max_id++);
- attributed_events.push_back(event);
+ event->set_attribute("identification", c->get_max_id());
+ c->add_attributed_event(event);
+ c->increase_max_id();
}
}
}
-bool is_node_null(ReferenceNodePtr node)
+bool is_node_null(MembershipContext* c, ReferenceNodePtr node)
{
MscPtr msc = node->get_msc();
@@ -1714,7 +1471,7 @@
if(bmsc == NULL)
{
- std::cerr << "Internal Error: typecast failed" << std::endl;
+ throw std::runtime_error("Unexpected behaviour");
return false;
}
@@ -1723,7 +1480,8 @@
for(it = instances.begin(); it != instances.end(); it++)
{
- if(focused_instances.empty() || contain_focused_instances((*it)->get_label()))
+ if(c->get_focused_instances().empty()
+ || c->contain_focused_instances((*it)->get_label()))
{
if(!is_instance_null(*it))
return false;
@@ -1788,7 +1546,7 @@
return true;
}
-bool check_node_time(ReferenceNodePtr node, ConfigurationPtr conf)
+bool check_node_time(MembershipContext* c, ReferenceNodePtr node, ConfigurationPtr conf)
{
TimeRelationRefNodePtrSet top = node->get_time_relations_top();
TimeRelationRefNodePtrSet bottom = node->get_time_relations_bottom();
@@ -1796,10 +1554,7 @@
std::vector<TimeRelationRefNodePtr> top_vec, bottom_vec, themself_vec;
-//top_time_references, bottom_time_references su tam ulozene uzly kde sa zacina casovy interval, a su usporiadane podla top/bottom. To znamena casovy interval na node_a je pripojeny na top/bottom.
-
//top_vec, bottom_vec su tam ulozene intervaly kde je aktualny node pripojeny ako koniec intervalu, su usporiadane podla top/bottom.
-
for(it = top.begin(); it!=top.end(); it++)
{
if((*it)->get_ref_node_b() == node.get())
@@ -1810,7 +1565,7 @@
top_vec.push_back(*it);
}
else
- top_time_references.insert(std::make_pair(*it, conf));
+ c->add_top_time_ref(*it, conf);
}
for(it = bottom.begin(); it!=bottom.end(); it++)
@@ -1821,7 +1576,7 @@
bottom_vec.push_back(*it);
}
else
- bottom_time_references.insert(std::make_pair(*it, conf));
+ c->add_bottom_time_ref(*it, conf);
}
//relation between the first and the second hmsc node
@@ -1836,34 +1591,34 @@
if(!themself_vec.empty())
{
- if(!check_node_time_themself(themself_vec, node, conf))
+ if(!check_node_time_themself(c, themself_vec, node, conf))
return false;
}
if(!top_vec.empty())
- min_b = get_min_event(conf);
+ min_b = get_min_event(c, conf);
if(!bottom_vec.empty())
- max_b = get_max_event(node, conf);
+ max_b = get_max_event(c, node, conf);
std::vector<TimeRelationRefNodePtr>::iterator it_vec;
- std::map<TimeRelationRefNodePtr, ConfigurationPtr>::iterator it_map;
+ ConfigurationPtr map_conf;
if(max_b != NULL)
{
for(it_vec = bottom_vec.begin(); it_vec != bottom_vec.end(); it_vec++)
{
- it_map = top_time_references.find(*it_vec);
+ map_conf = c->find_top_time_ref(*it_vec);
- if(it_map == top_time_references.end())
+ if(map_conf == NULL)
continue;
- min_a = get_min_event(it_map->second);
+ min_a = get_min_event(c, map_conf);
MscTimeIntervalSetD result, hmsc_inter, bmsc_inter;
hmsc_inter = (*it_vec)->get_interval_set();
- bmsc_inter = time_matrix->operator()(min_a, max_b);
+ bmsc_inter = c->get_time_matrix()->operator()(min_a, max_b);
result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter);
if(result.is_empty())
@@ -1871,7 +1626,7 @@
else
if(result != bmsc_inter)
{
-mem->print_report(RS_ERROR, L"Warning: the HMSC interval do not cover whole bMSC interval");
+c->get_mem()->print_report(RS_ERROR, L"Warning: the HMSC interval do not cover whole bMSC interval");
return false;
}
@@ -1879,17 +1634,17 @@
for(it_vec = bottom_vec.begin(); it_vec != bottom_vec.end(); it_vec++)
{
- it_map = bottom_time_references.find(*it_vec);
+ map_conf = c->find_bottom_time_ref(*it_vec);
- if(it_map == bottom_time_references.end())
+ if(map_conf == NULL)
continue;
- max_a = get_max_event(it_map->first->get_ref_node_a(), it_map->second);
+ max_a = get_max_event(c, (*it_vec)->get_ref_node_a(), map_conf);
MscTimeIntervalSetD hmsc_inter = (*it_vec)->get_interval_set();
MscTimeIntervalSetD result, bmsc_inter_set;
- bmsc_inter_set = time_matrix->operator()(max_a, max_b);
+ bmsc_inter_set = c->get_time_matrix()->operator()(max_a, max_b);
result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter_set);
if(result.is_empty())
@@ -1897,7 +1652,7 @@
else
if(result != bmsc_inter_set)
{
-mem->print_report(RS_ERROR, L"Warning: the HMSC interval do not cover whole bMSC interval");
+c->get_mem()->print_report(RS_ERROR, L"Warning: the HMSC interval do not cover whole bMSC interval");
return false;
}
}
@@ -1908,17 +1663,17 @@
{
for(it_vec = top_vec.begin(); it_vec != top_vec.end(); it_vec++)
{
- it_map = bottom_time_references.find(*it_vec);
+ map_conf = c->find_bottom_time_ref(*it_vec);
- if(it_map == bottom_time_references.end())
+ if(map_conf == NULL)
continue;
- max_a = get_max_event(it_map->first->get_ref_node_a(), it_map->second);
+ max_a = get_max_event(c, (*it_vec)->get_ref_node_a(), map_conf);
MscTimeIntervalSetD hmsc_inter = (*it_vec)->get_interval_set();
MscTimeIntervalSetD result, bmsc_inter_set;
- bmsc_inter_set = time_matrix->operator()(max_a, min_b);
+ bmsc_inter_set = c->get_time_matrix()->operator()(max_a, min_b);
result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter_set);
if(result.is_empty())
@@ -1926,24 +1681,24 @@
else
if(result != bmsc_inter_set)
{
-mem->print_report(RS_ERROR, L"Warning: the HMSC interval do not cover whole bMSC interval");
+c->get_mem()->print_report(RS_ERROR, L"Warning: the HMSC interval do not cover whole bMSC interval");
return false;
}
}
for(it_vec = top_vec.begin(); it_vec != top_vec.end(); it_vec++)
{
- it_map = top_time_references.find(*it_vec);
+ map_conf = c->find_top_time_ref(*it_vec);
- if(it_map == top_time_references.end())
+ if(map_conf == NULL)
continue;
- min_a = get_min_event(it_map->second);
+ min_a = get_min_event(c, map_conf);
MscTimeIntervalSetD hmsc_inter = (*it_vec)->get_interval_set();
MscTimeIntervalSetD result, bmsc_inter_set;
- bmsc_inter_set = time_matrix->operator()(min_a, min_b);
+ bmsc_inter_set = c->get_time_matrix()->operator()(min_a, min_b);
result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter_set);
if(result.is_empty())
@@ -1951,7 +1706,7 @@
else
if(result != bmsc_inter_set)
{
-mem->print_report(RS_ERROR, L"Warning: the HMSC interval do not cover whole bMSC interval");
+c->get_mem()->print_report(RS_ERROR, L"Warning: the HMSC interval do not cover whole bMSC interval");
return false;
}
}
@@ -1961,27 +1716,28 @@
}
-bool check_node_time_themself(const std::vector<TimeRelationRefNodePtr>& themself_vec, ReferenceNodePtr node, ConfigurationPtr conf)
+bool check_node_time_themself(MembershipContext* c, const std::vector<TimeRelationRefNodePtr>& themself_vec,
+ ReferenceNodePtr node, ConfigurationPtr conf)
{
Event* min_a = NULL;
Event* max_b = NULL;
if(themself_vec.size() > 1)
{
- mem->print_report(RS_ERROR, L"Error: more time intervals between top and bottom of one reference node");
+ c->get_mem()->print_report(RS_ERROR, L"Error: more time intervals between top and bottom of one reference node");
return false;
}
- min_a = get_min_event(conf);
- max_b = get_max_event(node, conf);
+ min_a = get_min_event(c, conf);
+ max_b = get_max_event(c, node, conf);
if(min_a == NULL || max_b == NULL)
{
if(min_a == NULL)
- mem->print_report(RS_ERROR, stringize() << L"Error: not decidable which event is the minimal one of the "
+ c->get_mem()->print_report(RS_ERROR, stringize() << L"Error: not decidable which event is the minimal one of the "
<< node->get_msc()->get_label() << L" node");
else
- mem->print_report(RS_ERROR, stringize() << "Error: not decidable which event is the maximal one of the "
+ c->get_mem()->print_report(RS_ERROR, stringize() << "Error: not decidable which event is the maximal one of the "
<< node->get_msc()->get_label() << " node");
return false;
@@ -1991,14 +1747,14 @@
if(relation == NULL)
{
- mem->print_report(RS_ERROR, L"Error: Unexpected program's behaviour");
+ c->get_mem()->print_report(RS_ERROR, L"Error: Unexpected program's behaviour");
return false;
}
MscTimeIntervalSetD result, hmsc_inter, bmsc_inter;
hmsc_inter = relation->get_interval_set();
- bmsc_inter = time_matrix->operator()(min_a, max_b);
+ bmsc_inter = c->get_time_matrix()->operator()(min_a, max_b);
result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter);
@@ -2007,14 +1763,14 @@
else
if(result != bmsc_inter)
{
-mem->print_report(RS_ERROR, L"Warning: the HMSC interval do not cover whole bMSC interval");
+c->get_mem()->print_report(RS_ERROR, L"Warning: the HMSC interval do not cover whole bMSC interval");
return false;
}
return true;
}
-Event* get_min_event(ConfigurationPtr conf)
+Event* get_min_event(MembershipContext* c, ConfigurationPtr conf)
{
std::set<PositionPtr> positions = conf->get_positions();
std::set<PositionPtr>::iterator it;
@@ -2028,7 +1784,6 @@
if(events.size() == 0)
continue;
- std::map<CoregionAreaPtr, CoregionOrderingPtr>::iterator cor_ordering_it;
if(events.size() > 1)
{
@@ -2036,15 +1791,15 @@
if(cor == NULL)
{
- mem->print_report(RS_ERROR, L"Error: unexpected behaviour 406");
+ c->get_mem()->print_report(RS_ERROR, L"Error: unexpected behaviour 406");
return NULL;
}
- cor_ordering_it = coregion_ordering.find(cor);
+ CoregionOrderingPtr cor_ordering = c->find_coregion_ordering(cor);
- if(cor_ordering_it != coregion_ordering.end())
+ if(cor_ordering != NULL)
{
- pos_min.push_back(cor_ordering_it->second->getOrdering().front().get());
+ pos_min.push_back(cor_ordering->getOrdering().front().get());
}
}
else
@@ -2058,12 +1813,12 @@
//try to eliminate pos_min to one event
for(unsigned int i = 0; i < pos_min.size(); i++)
{
- switch (compare_absolut_position((*min.begin()), pos_min[i]))
+ switch (compare_absolut_position(c, (*min.begin()), pos_min[i]))
{
case 0: min.insert(pos_min[i]); break;
case 1: break;
- case 2: update_minimum_set(min, pos_min[i]); break;
- default: mem->print_report(RS_ERROR, L"Error: unexpected behaviour 407");
+ case 2: update_minimum_set(c, min, pos_min[i]); break;
+ default: c->get_mem()->print_report(RS_ERROR, L"Error: unexpected behaviour 407");
}
}
@@ -2073,13 +1828,13 @@
return *(min.begin());
}
-Event* get_max_event(ReferenceNodePtr node, ConfigurationPtr conf)
+Event* get_max_event(MembershipContext* c, ReferenceNodePtr node, ConfigurationPtr conf)
{
std::set<PositionPtr> positions = conf->get_positions();
std::set<PositionPtr>::iterator it;
std::map<std::wstring, std::vector<int> > node_last_events;
- node_last_events = get_node_last_events(node);
+ node_last_events = get_node_last_events(c, node);
//vector of posible events
std::vector<Event*> pos_max;
@@ -2107,7 +1862,7 @@
Event* temp;
for(unsigned int i = 0; i < node_events.size(); i++)
{
- temp = find_event_on_instance_by_id(e->get_instance()->get_label(), node_events[i], s_e);
+ temp = find_event_on_instance_by_id(c, e->get_instance()->get_label(), node_events[i], s_e);
if(temp == NULL)
continue;
@@ -2123,12 +1878,12 @@
//try to eliminate pos_min to one event
for(unsigned int i = 0; i < pos_max.size(); i++)
{
- switch (compare_absolut_position(pos_max[i], (*max.begin())))
+ switch (compare_absolut_position(c, pos_max[i], (*max.begin())))
{
case 0: max.insert(pos_max[i]); break;
case 1: break;
- case 2: update_maximum_set(max, pos_max[i]); break;
- default: std::cerr << "Error: unexpected behaviour 408" << std::endl;
+ case 2: update_maximum_set(c, max, pos_max[i]); break;
+ default: throw std::runtime_error("Unexpected behaviour");
}
}
@@ -2138,19 +1893,19 @@
return *(max.begin());
}
-void update_maximum_set(std::set<Event*>& max, Event* new_element)
+void update_maximum_set(MembershipContext* c, std::set<Event*>& max, Event* new_element)
{
std::set<Event*> to_delete;
std::set<Event*>::iterator it;
for(it = max.begin(); it != max.end(); it++)
{
- switch (compare_absolut_position(new_element, *it))
+ switch (compare_absolut_position(c, new_element, *it))
{
case 0: break;
case 1: break;
case 2: to_delete.insert(*it); break;
- default: std::cerr << "Error: unexpected behaviour 408" << std::endl;
+ default: throw std::runtime_error("Unexpected behaviour");
}
}
@@ -2162,19 +1917,19 @@
max.insert(new_element);
}
-void update_minimum_set(std::set<Event*>& min, Event* new_element)
+void update_minimum_set(MembershipContext* c, std::set<Event*>& min, Event* new_element)
{
std::set<Event*> to_delete;
std::set<Event*>::iterator it;
for(it = min.begin(); it != min.end(); it++)
{
- switch (compare_absolut_position(*it, new_element))
+ switch (compare_absolut_position(c, *it, new_element))
{
case 0: break;
case 1: break;
case 2: to_delete.insert(*it); break;
- default: std::cerr << "Error: unexpected behaviour 408" << std::endl;
+ default: throw std::runtime_error("Unexpected behaviour");
}
}
@@ -2194,9 +1949,9 @@
* 2 - the second is before the first
* 3 - error
*/
-int compare_absolut_position(Event* first, Event* second)
+int compare_absolut_position(MembershipContext* c, Event* first, Event* second)
{
- MscTimeIntervalSetD inter = time_matrix->operator()(first, second);
+ MscTimeIntervalSetD inter = c->get_time_matrix()->operator()(first, second);
const IntervalList intervals = inter.get_set();
bool positive = false;
@@ -2237,14 +1992,14 @@
return 3;
}
-std::map<std::wstring, std::vector<int> > get_node_last_events(ReferenceNodePtr node)
+std::map<std::wstring, std::vector<int> > get_node_last_events(MembershipContext* c, ReferenceNodePtr node)
{
MscPtr msc = node->get_msc();
BMscPtr bmsc = boost::dynamic_pointer_cast<BMsc>(msc);
if(bmsc == NULL)
- mem->print_report(RS_ERROR, L"Error: Unexpected behaviur 35");
+ c->get_mem()->print_report(RS_ERROR, L"Error: Unexpected behaviur 35");
InstancePtrList instances = bmsc->get_instances();
InstancePtrList::iterator inst_it;
@@ -2265,7 +2020,7 @@
{
start = strict->get_first();
std::vector<int> identifications;
- Event* e = get_last_instance_event(start.get());
+ Event* e = get_last_instance_event(c, start.get());
if(e == NULL)
continue;
@@ -2287,18 +2042,17 @@
if(cor != NULL)
{
start = cor->get_minimal_events().front();
- std::map<CoregionAreaPtr, CoregionOrderingPtr>::iterator cor_order_it;
- cor_order_it = coregion_ordering.find(cor);
+ CoregionOrderingPtr cor_order = c->find_coregion_ordering(cor);
- if(cor_order_it == coregion_ordering.end())
+ if(cor_order == NULL)
{
- mem->print_report(RS_ERROR, L"Error: unexpected behaviour");
+ c->get_mem()->print_report(RS_ERROR, L"Error: unexpected behaviour");
return node_last_events;
}
- start = cor_order_it->second->getOrdering().front();
+ start = cor_order->getOrdering().front();
std::vector<int> identifications;
- Event* e = get_last_instance_event(start.get());
+ Event* e = get_last_instance_event(c, start.get());
if(e == NULL)
continue;
@@ -2318,7 +2072,7 @@
return node_last_events;
}
-Event* get_last_instance_event(Event* start)
+Event* get_last_instance_event(MembershipContext* c, Event* start)
{
if(start == NULL)
@@ -2353,14 +2107,10 @@
return str->get_last().get();
if(cor != NULL)
{
- std::map<CoregionAreaPtr, CoregionOrderingPtr>::iterator cor_ord_it;
-
- cor_ord_it = coregion_ordering.find(cor);
+ CoregionOrderingPtr cor_ord = c->find_coregion_ordering(cor);
- if(cor_ord_it != coregion_ordering.end())
- {
- return cor_ord_it->second->getOrdering().back().get();
- }
+ if(cor_ord != NULL)
+ return cor_ord->getOrdering().back().get();
else
return NULL;
}
@@ -2368,14 +2118,6 @@
return NULL;
}
-void remove_events_attributes(std::vector<Event*> vec)
-{
- std::vector<Event*>::iterator it;
-
- for(it = vec.begin(); it != vec.end(); it++)
- (*it)->remove_attribute<int>("identification");
-}
-
BMscIntervalSetMatrix get_bmsc_matrix(BMscPtr bmsc_f)
{
//matrix context inicialization
Modified: trunk/src/membership/membership_alg.h
=========================================================...
[truncated message content] |
