Thread: [Scstudio-commits] SF.net SVN: scstudio:[111] trunk/src

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 111
          http://scstudio.svn.sourceforge.net/scstudio/?rev=111&view=rev
Author:   babicaj
Date:     2008-10-05 18:03:03 +0000 (Sun, 05 Oct 2008)

Log Message:
-----------
Structure of HMsc was customized for graphical representation. Traversers of HMsc was modified in appropriate way. It is more than possible that checkers need to be modified too. Sorry for current compilation problem it will be corrected as soon as possible.

Modified Paths:
--------------
    trunk/src/check/dfs_bmsc_graph_traverser.cpp
    trunk/src/check/dfs_bmsc_graph_traverser.h
    trunk/src/check/dfs_hmsc_traverser.cpp
    trunk/src/check/dfs_hmsc_traverser.h
    trunk/src/check/footprint.cpp
    trunk/src/check/footprint.h
    trunk/src/check/race_checker.cpp
    trunk/src/check/race_checker.h
    trunk/src/data/counted_ptr.h
    trunk/src/data/msc.cpp
    trunk/src/data/msc.h

Added Paths:
-----------
    trunk/src/check/refnode_finder.cpp
    trunk/src/check/refnode_finder.h
    trunk/src/data/msc_visual.h

Modified: trunk/src/check/dfs_bmsc_graph_traverser.cpp
===================================================================

--- trunk/src/check/dfs_bmsc_graph_traverser.cpp	2008-10-04 22:31:47 UTC (rev 110)
+++ trunk/src/check/dfs_bmsc_graph_traverser.cpp	2008-10-05 18:03:03 UTC (rev 111)
@@ -27,67 +27,95 @@
 
 void DFSBMscGraphTraverser::traverse(HMscPtr hmsc)
 {
-  m_colored_nodes.push_back(InnerNodePList());
-  traverse_successors(hmsc->get_start()->get_successors());
+  push_top_attributes();
+  traverse_node(hmsc->get_start().get());
   cleanup_traversing_attributes();
 }
 
-bool DFSBMscGraphTraverser::traverse_node(InnerNode* node)
+bool DFSBMscGraphTraverser::traverse_node(HMscNode* node)
 {
-  Color c = get_color(node);
-  if(c==BLACK) 
+  if(is_processed(node))
   {
-    black_node_found(node);
     return false;
   }
-  if(c==GRAY)
-  {
-    gray_node_found(node);
-    return false;
-  }
   white_node_found(node);
   ReferenceNode* ref_node = dynamic_cast<ReferenceNode*>(node);
   if(ref_node!=NULL)
   {
-    HMscPtr hmsc = ref_node->get_hmsc();
-    if(hmsc.get()!=NULL)
+    return traverse_node(ref_node);
+  }
+  else
+  {
+    bool ending_successors;
+    ConnectionNode* conn_node = dynamic_cast<ConnectionNode*>(node);
+    if(conn_node)
     {
-      m_reached_nodes.push_back(InnerNodePList());
-      //this line ensures (yet another one) that HMsc will be traversed as many times
-      //as it is referenced
-      m_colored_nodes.push_back(InnerNodePList());
-      //node's successors aren't traversed if end node wasn't found in hmsc
-      return traverse_successors(hmsc->get_start()->get_successors()) && 
-        (traverse_successors(node->get_successors()) || ref_node->is_end_node());
-      //this line ensures (yet another one) that HMsc will traversed as many times
-      //as it is referenced
-      cleanup_top_attributes();
-      m_reached_nodes.pop_back();
+      ending_successors = traverse_successors(conn_node);
     }
+    else
+    {
+      StartNode* start_node = dynamic_cast<StartNode*>(node);
+      if(start_node)
+      {
+        ending_successors = traverse_successors(start_node);
+      }
+      else
+      {
+        //node is supposed to be EndNode
+        ending_successors = true;
+      }
+    }
+    node_finished(node);
+    return ending_successors;
   }
-  bool ending_successors = traverse_successors(node->get_successors());
-  node_finished(node);
-  return ending_successors || (ref_node!=NULL && ref_node->is_end_node());
 }
 
-bool DFSBMscGraphTraverser::traverse_successors(const InnerNodePSet& successors)
+bool DFSBMscGraphTraverser::traverse_node(ReferenceNode* ref_node)
 {
+  HMscPtr hmsc = ref_node->get_hmsc();
+  bool inner = true;
+  if(hmsc.get()!=NULL)
+  {
+    //this line ensures (yet another one) that HMsc will be traversed as many times
+    //as it is referenced
+    push_top_attributes();
+    //node's successors aren't traversed if end node wasn't found in hmsc
+    inner = traverse_successors(hmsc->get_start().get());
+    //this line ensures (yet another one) that HMsc will traversed as many times
+    //as it is referenced
+    cleanup_top_attributes();
+  }
+  return inner && traverse_successors(ref_node);
+}
+
+bool DFSBMscGraphTraverser::traverse_successors(PredecessorNode* predecessor)
+{
   bool end_found = false;
-  InnerNodePSet::const_iterator successor;
-  for(successor=successors.begin();successor!=successors.end();successor++)
+  NodeRelationPtrSet::const_iterator relation;
+  for(relation=predecessor->get_successors().begin();
+    relation!=predecessor->get_successors().end();relation++)
   {
-    end_found = traverse_node(*successor) || end_found;
+    const NodeRelationPtr& rel = *relation;
+    m_reached_nodes.back().push_back(rel);
+    end_found = traverse_node((HMscNode*)rel->get_successor()) || end_found;
   }
   return end_found;
 }
 
-void DFSBMscGraphTraverser::cleanup_top_attributes()
+bool DFSBMscGraphTraverser::is_processed(HMscNode* node)
 {
-  InnerNodePList& top = m_colored_nodes.back();
-  InnerNodePList::iterator event;
-  for(event=top.begin();event!=top.end();event++)
-    (*event)->remove_attribute<Color>(m_color_attribute);
-  m_colored_nodes.pop_back();
+  Color c = get_color(node);
+  if(c==BLACK) 
+  {
+    black_node_found(node);
+    return true;
+  }
+  if(c==GRAY)
+  {
+    gray_node_found(node);
+    return true;
+  }
+  return false;
 }
 
 void DFSBMscGraphTraverser::cleanup_traversing_attributes()
@@ -96,16 +124,10 @@
   {
     cleanup_top_attributes();
   }
-  while(!m_reached_nodes.empty())
-  {
-    m_reached_nodes.pop_back();
-  }
-
 }
 
-void DFSBMscGraphTraverser::white_node_found(InnerNode* n)
+void DFSBMscGraphTraverser::white_node_found(HMscNode* n)
 {
-  m_reached_nodes.back().push_back(n);
   WhiteNodeFoundListenerPList::iterator l;
   for(l=m_white_node_found_listeners.begin();l!=m_white_node_found_listeners.end();l++)
     (*l)->on_white_node_found(n);
@@ -113,21 +135,23 @@
   m_colored_nodes.back().push_back(n);
 }
 
-void DFSBMscGraphTraverser::gray_node_found(InnerNode* n)
+void DFSBMscGraphTraverser::gray_node_found(HMscNode* n)
 {
   GrayNodeFoundListenerPList::iterator l;
   for(l=m_gray_node_found_listeners.begin();l!=m_gray_node_found_listeners.end();l++)
     (*l)->on_gray_node_found(n);
+  m_reached_nodes.back().pop_back();
 }
 
-void DFSBMscGraphTraverser::black_node_found(InnerNode* n)
+void DFSBMscGraphTraverser::black_node_found(HMscNode* n)
 {
   BlackNodeFoundListenerPList::iterator l;
   for(l=m_black_node_found_listeners.begin();l!=m_black_node_found_listeners.end();l++)
     (*l)->on_black_node_found(n);
+  m_reached_nodes.back().pop_back();
 }
 
-void DFSBMscGraphTraverser::node_finished(InnerNode* n)
+void DFSBMscGraphTraverser::node_finished(HMscNode* n)
 {
   NodeFinishedListenerPList::iterator l;
   for(l=m_node_finished_listeners.begin();l!=m_node_finished_listeners.end();l++)
@@ -136,3 +160,19 @@
   set_color(n,BLACK);
 }
 
+void DFSBMscGraphTraverser::cleanup_top_attributes()
+{
+  HMscNodePList& top = m_colored_nodes.back();
+  HMscNodePList::iterator event;
+  for(event=top.begin();event!=top.end();event++)
+    (*event)->remove_attribute<Color>(m_color_attribute);
+  m_colored_nodes.pop_back();
+  m_reached_nodes.pop_back();
+}
+  
+void DFSBMscGraphTraverser::push_top_attributes()
+{
+  m_colored_nodes.push_back(HMscNodePList());
+  m_reached_nodes.push_back(NodeRelationPtrList());
+}
+

Modified: trunk/src/check/dfs_bmsc_graph_traverser.h
===================================================================
--- trunk/src/check/dfs_bmsc_graph_traverser.h	2008-10-04 22:31:47 UTC (rev 110)
+++ trunk/src/check/dfs_bmsc_graph_traverser.h	2008-10-05 18:03:03 UTC (rev 111)
@@ -24,11 +24,14 @@
 #include "data/msc.h"
 #include "check/checker.h"
 
-typedef std::list<InnerNode*> InnerNodePList;
-typedef std::list<InnerNodePList> InnerNodePListList;
+typedef std::list<HMscNode*> HMscNodePList;
+typedef std::list<HMscNodePList> HMscNodePListList;
+typedef std::list<NodeRelationPtr> NodeRelationPtrList;
+typedef std::list<NodeRelationPtrList> NodeRelationPtrListList;
 
+
 /**
- * Listener of founded white InnerNode
+ * Listener of founded white HMscNode
  */
 class WhiteNodeFoundListener
 {
@@ -39,11 +42,11 @@
     
   }
   
-  virtual void on_white_node_found(InnerNode* n)=0;
+  virtual void on_white_node_found(HMscNode* n)=0;
 };
 
 /**
- * Listener of founded gray InnerNode
+ * Listener of founded gray HMscNode
  */
 class GrayNodeFoundListener
 {
@@ -54,11 +57,11 @@
     
   }
   
-  virtual void on_gray_node_found(InnerNode* n)=0;
+  virtual void on_gray_node_found(HMscNode* n)=0;
 };
 
 /**
- * Listener of founded black InnerNode
+ * Listener of founded black HMscNode
  */
 class BlackNodeFoundListener
 {
@@ -69,11 +72,11 @@
     
   }
   
-  virtual void on_black_node_found(InnerNode* n)=0;
+  virtual void on_black_node_found(HMscNode* n)=0;
 };
 
 /**
- * Listener of finished InnerNode
+ * Listener of finished HMscNode
  */
 class NodeFinishedListener
 {
@@ -84,11 +87,11 @@
     
   }
   
-  virtual void on_node_finished(InnerNode* node)=0;
+  virtual void on_node_finished(HMscNode* node)=0;
 };
 
 /**
- * Auxiliary listener of founded white InnerNode.
+ * Auxiliary listener of founded white HMscNode.
  *
  * Extend this listener to process only ReferenceNodes during traversing.
  */
@@ -101,7 +104,7 @@
     
   }
   
-  virtual void on_white_node_found(InnerNode* n){
+  virtual void on_white_node_found(HMscNode* n){
     ReferenceNode* ref = dynamic_cast<ReferenceNode*>(n);
     if(ref!=NULL)
     {
@@ -113,7 +116,7 @@
 };
 
 /**
- * Auxiliary listener of founded gray InnerNode.
+ * Auxiliary listener of founded gray HMscNode.
  *
  * Extend this listener to process only ReferenceNodes during traversing.
  */
@@ -126,7 +129,7 @@
     
   }
   
-  virtual void on_gray_node_found(InnerNode* n){
+  virtual void on_gray_node_found(HMscNode* n){
     ReferenceNode* ref = dynamic_cast<ReferenceNode*>(n);
     if(ref!=NULL)
     {
@@ -138,7 +141,7 @@
 };
 
 /**
- * Auxiliary listener of founded black InnerNode.
+ * Auxiliary listener of founded black HMscNode.
  *
  * Extend this listener to process only ReferenceNodes during traversing.
  */
@@ -151,7 +154,7 @@
     
   }
   
-  virtual void on_black_node_found(InnerNode* n){
+  virtual void on_black_node_found(HMscNode* n){
     ReferenceNode* ref = dynamic_cast<ReferenceNode*>(n);
     if(ref!=NULL)
     {
@@ -163,7 +166,7 @@
 };
 
 /**
- * Auxiliary listener of finished InnerNode.
+ * Auxiliary listener of finished HMscNode.
  *
  * Extend this listener to process only ReferenceNodes during traversing.
  */
@@ -176,7 +179,7 @@
     
   }
   
-  virtual void on_node_finished(InnerNode* n){
+  virtual void on_node_finished(HMscNode* n){
     ReferenceNode* ref = dynamic_cast<ReferenceNode*>(n);
     if(ref!=NULL)
     {
@@ -197,7 +200,7 @@
 typedef std::list<BlackNodeFoundListenerP> BlackNodeFoundListenerPList;
 
 /**
- * Traverses all accessible InnerNodes in HMsc and referenced HMsc in depth 
+ * Traverses all accessible HMscNodes in HMsc and referenced HMsc in depth 
  * first search manner.
  *
  * HMsc is traversed like BMsc-graph (flattened version of HMsc - each 
@@ -205,15 +208,15 @@
  * many times as it is referenced. If ReferenceNode references HMsc, this HMsc 
  * is traversed before successors of referencing node are processed.
  *
- * InnerNodes of HMsc are during traversing in different states - with different 
+ * HMscNodes of HMsc are during traversing in different states - with different 
  * color. WHITE color means that node wasn't traversed before. GRAY nodes
  * are those which have been already traversed and they are just on the stack - 
  * not all successors of these events were processed. BLACK nodes are those 
  * which have been already traversed but aren't yet on the stack - all 
  * successors have been processed.
  *
- * Note that not all InnerNodes must be traversed by this DFSBMscGraphTraverser, 
- * imagine InnerNode B which is accessible only from ReferenceNode A but A's
+ * Note that not all HMscNodes must be traversed by this DFSBMscGraphTraverser, 
+ * imagine HMscNode B which is accessible only from ReferenceNode A but A's
  * HMsc hasn't got any end node.
  *
  * @warning Non-recursive HMsc is expected.
@@ -224,7 +227,7 @@
 public:
   
   /**
-   * To change default name of attribute which holds color of InnerNodes use
+   * To change default name of attribute which holds color of HMscNodes use
    * color_attribute parameter.
    */
   DFSBMscGraphTraverser(const std::string& color_attribute = "msc_graph_traverse_color")
@@ -312,13 +315,13 @@
   }
   
   /**
-   * Returns reached InnerNodes in particular phase of traversing.
+   * Returns reached HMscNodes in particular phase of traversing.
    *
-   * The result corresponds to call stack on particular InnerNodes.
+   * The result corresponds to call stack on particular HMscNodes.
    *
    * Warning: The result is emptied when cleanup_traversing_attributes() is called
    */
-  const InnerNodePListList& get_reached_nodes()
+  const NodeRelationPtrListList& get_reached_nodes()
   {
     return m_reached_nodes;
   }
@@ -328,27 +331,34 @@
   /**
    * Holds nodes with set color attribute
    */
-  InnerNodePListList m_colored_nodes;
+  HMscNodePListList m_colored_nodes;
 
   /**
-   * Holds currently reached InnerNodes.
+   * Holds currently reached HMscNodes.
    */
-  InnerNodePListList m_reached_nodes;
+  NodeRelationPtrListList m_reached_nodes;
   
   /**
    * Cleans up traversing attributes from the top of m_colored_nodes
    */
-  void cleanup_top_attributes();
+  virtual void cleanup_top_attributes();
 
   /**
    * Traverses single node
    */
-  virtual bool traverse_node(InnerNode* node);
+  virtual bool traverse_node(HMscNode* node);
 
   /**
    * Traverses successors
    */
-  virtual bool traverse_successors(const InnerNodePSet& successors);
+  virtual bool traverse_successors(PredecessorNode* predecessor);
+  
+  /**
+   * Returns true iff node is just processed false otherwise
+   */
+  virtual bool is_processed(HMscNode* node);
+  
+  virtual bool traverse_node(ReferenceNode* node);
     
   /**
    * Holds listeners
@@ -381,29 +391,29 @@
   std::string m_color_attribute;
   
   /**
-   * Called when white InnerNode is found.
+   * Called when white HMscNode is found.
    */
-  virtual void white_node_found(InnerNode* n);
+  virtual void white_node_found(HMscNode* n);
   
   /**
-   * Called when gray InnerNode is found.
+   * Called when gray HMscNode is found.
    */
-  virtual void gray_node_found(InnerNode* n);
+  virtual void gray_node_found(HMscNode* n);
   
   /**
-   * Called when black InnerNode is found.
+   * Called when black HMscNode is found.
    */
-  virtual void black_node_found(InnerNode* n);
+  virtual void black_node_found(HMscNode* n);
   
   /**
    * Called when all successors of e are processed.
    */
-  virtual void node_finished(InnerNode* n);
+  virtual void node_finished(HMscNode* n);
   
   /**
    * Sets color attribute of e to c value .
    */
-  void set_color(InnerNode* n, Color c)
+  void set_color(HMscNode* n, Color c)
   {
     n->set_attribute<Color>(m_color_attribute,c);
   }
@@ -413,11 +423,14 @@
    *
    * If attribute isn't set it is set to default value WHITE.
    */
-  Color get_color(InnerNode* n)
+  Color get_color(HMscNode* n)
   {
     return n->get_attribute<Color>(m_color_attribute,WHITE);
   }
   
+  virtual void push_top_attributes();
+  
+  
 };
 
 

Modified: trunk/src/check/dfs_hmsc_traverser.cpp
===================================================================
--- trunk/src/check/dfs_hmsc_traverser.cpp	2008-10-04 22:31:47 UTC (rev 110)
+++ trunk/src/check/dfs_hmsc_traverser.cpp	2008-10-05 18:03:03 UTC (rev 111)
@@ -18,35 +18,25 @@
 
 #include "check/dfs_hmsc_traverser.h"
 
-bool DFSHMscTraverser::traverse_node(InnerNode* node)
+bool DFSHMscTraverser::traverse_node(ReferenceNode* ref_node)
 {
-  Color c = get_color(node);
-  if(c==BLACK) 
+  HMscPtr hmsc = ref_node->get_hmsc();
+  if(hmsc.get()!=NULL)
   {
-    black_node_found(node);
-    return false;
+    m_reached_nodes.push_back(NodeRelationPtrList());
+    traverse_successors(hmsc->get_start().get());
+    m_reached_nodes.pop_back();
+    
   }
-  if(c==GRAY)
+  return traverse_successors(ref_node);
+}
+
+void DFSHMscTraverser::cleanup_traversing_attributes()
+{
+  cleanup_top_attributes();
+  while(!m_reached_nodes.empty())
   {
-    gray_node_found(node);
-    return false;
+    m_reached_nodes.pop_back();
   }
-  white_node_found(node);
-  ReferenceNode* refNode = dynamic_cast<ReferenceNode*>(node);
-  if(refNode!=NULL)
-  {
-    HMscPtr hmsc = refNode->get_hmsc();
-    if(hmsc.get()!=NULL)
-    {
-      m_reached_nodes.push_back(InnerNodePList());
-      //node's successors are traversed in all cases
-      traverse_successors(hmsc->get_start()->get_successors());
-      m_reached_nodes.pop_back();
-    }
-  }
-  traverse_successors(node->get_successors());
-  node_finished(node);
-  //return value is no more needed
-  return true;
 }
 

Modified: trunk/src/check/dfs_hmsc_traverser.h
===================================================================
--- trunk/src/check/dfs_hmsc_traverser.h	2008-10-04 22:31:47 UTC (rev 110)
+++ trunk/src/check/dfs_hmsc_traverser.h	2008-10-05 18:03:03 UTC (rev 111)
@@ -23,11 +23,11 @@
 
 
 /**
- * Traverses all ReferenceNodes in HMsc and referenced HMsc in depth 
+ * Traverses all HMscNodes in HMsc and referenced HMsc in depth 
  * first search manner. I.e. unlike DFSBMscGraphTraverser this traverser doesn't
  * care about presence of EndNodes in referenced HMsc in ReferenceNodes. 
  * Successors of the ReferenceNode are traversed no matter there is EndNode in
- * it's HMsc.
+ * it's HMsc. Moreover each HMsc is traversed only one time.
  *
  * @warning Non-recursive HMsc is expected.
  */
@@ -36,7 +36,7 @@
   
 protected:
   
-  bool traverse_node(InnerNode* node);
+  bool traverse_node(ReferenceNode* node);
   
 public:
   
@@ -47,6 +47,8 @@
     
   }
   
+  void cleanup_traversing_attributes();
+  
 };
 
 

Modified: trunk/src/check/footprint.cpp
===================================================================
--- trunk/src/check/footprint.cpp	2008-10-04 22:31:47 UTC (rev 110)
+++ trunk/src/check/footprint.cpp	2008-10-05 18:03:03 UTC (rev 111)
@@ -1,6 +1,207 @@
-#import "check/footprint.h"
+/*
+ * scstudio - Sequence Chart Studio
+ * http://scstudio.sourceforge.net
+ *
+ *      This library is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU Lesser General Public
+ *      License version 2.1, as published by the Free Software Foundation.
+ *
+ *      This library is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *      Lesser General Public License for more details.
+ *
+ * Copyright (c) 2008 Jindra Babica <ba...@ma...>
+ *
+ * $Id: bmsc_race_checker.cpp 97 2008-06-02 10:40:48Z babicaj $
+ */
 
+#include "check/footprint.h"
+
 bool EDInstancesPtrComparator::operator()(const EDInstancesPtr& a, const EDInstancesPtr& b)
 {
   return a->operator <(*b.get());
-}
\ No newline at end of file
+}
+
+bool FootprintPtrComparator::operator()(const FootprintPtr& a, const FootprintPtr& b)
+{
+  return a->operator <(*b.get());
+}
+
+EventDependentInstances::EventDependentInstances(Event* event,size_t instances_count)
+{
+  m_event = event;
+  m_instances = BoolVector(instances_count,false);
+}
+
+bool EventDependentInstances::operator<(const EventDependentInstances& di) const
+{
+  return compare(di)<0;
+}
+  
+int EventDependentInstances::compare(const EventDependentInstances& di) const
+{
+  if(m_event<di.m_event) return -1;
+  if(di.m_event<m_event) return 1;
+  //compare bool vector as binary number
+  for(int i=0; i<m_instances.size(); i++)
+  {
+    if(m_instances[i]!=di.m_instances[i])
+      return m_instances[i]-di.m_instances[i];
+  }
+  //otherwise this is same as di
+  return 0;
+}
+
+void EventDependentInstances::set_dependent(size_t instance)
+{
+  m_instances[instance] = true;
+}
+
+const BoolVector& EventDependentInstances::get_instances()
+{
+  return m_instances;
+}
+
+Event* EventDependentInstances::get_event()
+{
+  return m_event;
+}
+
+int ExtremeEvents::compare(
+  const EDInstancesPtrSet& first,
+  const EDInstancesPtrSet& second) const
+{
+  EDInstancesPtrSet::const_iterator first_i = first.begin();
+  EDInstancesPtrSet::const_iterator second_i = second.begin();
+  while(first_i!=first.end() && second_i!=second.end())
+  {
+    const EDInstancesPtr first_edis = *first_i;
+    const EDInstancesPtr second_edis = *second_i;
+    int comparision = first_edis->compare(*second_edis.get());
+    if(comparision!=0) return comparision;
+    first_i++;
+    second_i++;
+  }
+  return first.size()-second.size();
+}
+
+ExtremeEvents::ExtremeEvents()
+{
+  
+}
+
+ExtremeEvents::ExtremeEvents(size_t instances_count)
+{
+  m_events_instances = EDInstancesPtrSetVector(instances_count);
+}
+
+bool ExtremeEvents::operator<(const ExtremeEvents& other) const
+{
+  const EDInstancesPtrSetVector& other_events = other.get_events_instances();
+  for(size_t i=0;i<m_events_instances.size();i++)
+  {
+    int comparision = compare(m_events_instances[i],other_events[i]);
+    if(comparision!=0)
+    {
+      return comparision<0;
+    }
+  }
+  //otherwise this is supposed to be same as other
+  return false;
+}
+
+void ExtremeEvents::add_extreme_event(size_t instance, EDInstancesPtr& edis)
+{
+  m_events_instances[instance].insert(edis);
+}
+
+const EDInstancesPtrSetVector& ExtremeEvents::get_events_instances() const
+{
+  return m_events_instances;
+}
+
+
+Footprint::Footprint(StartNode* start, size_t instances_count):ExtremeEvents(instances_count)
+{
+  m_path.push_back(start);
+}
+
+Footprint::Footprint(
+  FootprintPtr previous, 
+  const InnerNodePList& path,
+  const ExtremeEvents& max_events_less,
+  const ExtremeEvents& max_events_greater)
+  :ExtremeEvents(previous->get_events_instances().size())
+{
+  const EDInstancesPtrSetVector& previous_events = previous->get_events_instances();
+  const EDInstancesPtrSetVector& events_less = max_events_less.get_events_instances();
+  const EDInstancesPtrSetVector& events_greater = max_events_greater.get_events_instances();
+
+  m_previous = previous;
+  m_path.insert(m_path.begin(),path.begin(),path.end());
+  size_t instances_count = previous_events.size();
+
+  for(size_t i=0; i<instances_count; i++)
+  {
+    /*
+     * If events_greater[i] contains any EDInstances these will become part
+     * of new Footprint - doesn't care about previous_events[i] 
+     */
+    if(events_greater[i].size()>0)
+    {
+      m_events_instances[i] = events_greater[i];
+    }
+    else if(previous_events[i].size()>0)
+    {
+      /*
+       * Let previous_edi be a EvendDependntInstaces in previous_events[i]. Find
+       * less_edi (EventDependentInstances) from events_less and instance 
+       * index j such that (less_edi.m_instances[j]==true and 
+       * previous_edi.m_instances[j]==true).
+       *
+       * Let new_edi be copied previous_edi (the new_edi will be inserted into
+       * m_events_instances[i]). If there is any less_edi and index j as 
+       * described in previous paragraph then new_edi.m_instances[j]==true.
+       */
+      EDInstancesPtrSet::const_iterator previous_edi;
+      for(previous_edi=previous_events[i].begin();previous_edi!=previous_events[i].end();previous_edi++)
+      {
+        EDInstancesPtr new_edi = new EventDependentInstances(**previous_edi);
+        const BoolVector& previous_edi_instances = (*previous_edi)->get_instances();
+        for(size_t j=0;j<instances_count;j++)
+        {
+          EDInstancesPtrSet::const_iterator less_edi;
+          for(less_edi=events_less[j].begin();less_edi!=events_less[j].end();less_edi++)
+          {
+            const BoolVector& less_edi_instances = (*less_edi)->get_instances();
+            size_t y=0;
+            for(;y<instances_count;y++)
+            {
+              if(previous_edi_instances[y]&&less_edi_instances[y])
+              {
+                break;
+              }
+            }
+            if(y!=instances_count)
+            {
+              break;
+            }
+          }
+          if(less_edi!=events_less[j].end())
+          {
+            new_edi->set_dependent(j);
+            break;
+          }
+        }
+        m_events_instances[i].insert(new_edi);
+      }
+    }
+  }
+}
+
+PredecessorNode* Footprint::get_node()
+{
+  return m_path.back();
+}
+

Modified: trunk/src/check/footprint.h
===================================================================
--- trunk/src/check/footprint.h	2008-10-04 22:31:47 UTC (rev 110)
+++ trunk/src/check/footprint.h	2008-10-05 18:03:03 UTC (rev 111)
@@ -1,3 +1,21 @@
+/*
+ * scstudio - Sequence Chart Studio
+ * http://scstudio.sourceforge.net
+ *
+ *      This library is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU Lesser General Public
+ *      License version 2.1, as published by the Free Software Foundation.
+ *
+ *      This library is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *      Lesser General Public License for more details.
+ *
+ * Copyright (c) 2008 Jindra Babica <ba...@ma...>
+ *
+ * $Id: bmsc_race_checker.cpp 97 2008-06-02 10:40:48Z babicaj $
+ */
+
 #ifndef _FOOTPRINT_H
 #define	_FOOTPRINT_H
 
@@ -3,4 +21,5 @@
 #include <map>
 #include <set>
+#include <list>
 
 #include "data/msc.h"
@@ -13,6 +32,8 @@
 typedef std::vector<bool> BoolVector;
 typedef counted_ptr<EventDependentInstances> EDInstancesPtr;
 typedef counted_ptr<Footprint> FootprintPtr;
+typedef std::list<InnerNode*> InnerNodePList;
+typedef std::list<PredecessorNode*> PredecessorNodePList;
 
 class EDInstancesPtrComparator
 {
@@ -20,10 +41,17 @@
   bool operator()(const EDInstancesPtr& a, const EDInstancesPtr& b);
 };
 
+class FootprintPtrComparator
+{
+public:
+  bool operator()(const FootprintPtr& a, const FootprintPtr& b);
+};
+
 typedef std::set<EDInstancesPtr,EDInstancesPtrComparator> EDInstancesPtrSet;
+typedef std::vector<EDInstancesPtrSet> EDInstancesPtrSetVector;
 
 /**
- * Represents dependent Instances -- contain lesser/grater (depends on chosen semantic) 
+ * Represents dependent Instances -- contain lesser/greater (depends on chosen semantic) 
  * Event then the Event with specified m_event in this class. 
  */
 class EventDependentInstances
@@ -39,8 +67,8 @@
   
   /**
    * Each Instance i must have its own number. For this vector m_instances holds: 
-   * m_instances[i]==true iff i contains any greater/lesser Event than the Event e with 
-   * id == m_event_id. 
+   * m_instances[i]==true iff i contains any greater/lesser Event than the Event 
+   * m_event. 
    */
   BoolVector m_instances;
   
@@ -49,45 +77,25 @@
   /**
    *
    */
-  EventDependentInstances(Event* event,size_t instances_count)
-  {
-    m_event = event;
-    m_instances = BoolVector(instances_count,false);
-  }
+  EventDependentInstances(Event* event,size_t instances_count);
   
   /**
    * Used in std::set as comparision method
    *
    * The di is supposed to have m_instances as large as this one has.
    */
-  bool operator<(const EventDependentInstances& di) const
-  {
-    return compare(di)<0;
-  }
+  bool operator<(const EventDependentInstances& di) const;
   
   /**
    * Returns -1 for this<di, 0 for this==di and 1 for this>di
    */
-  int compare(const EventDependentInstances& di) const
-  {
-    if(m_event<di.m_event) return -1;
-    if(di.m_event<m_event) return 1;
-    //compare bool vector as binary number
-    for(int i=0; i<m_instances.size(); i++)
-    {
-      if(m_instances[i]!=di.m_instances[i])
-        return m_instances[i]-di.m_instances[i];
-    }
-    //otherwise this is same as di
-    return 0;
-  }
+  int compare(const EventDependentInstances& di) const;
   
-  void set_dependent(size_t instance)
-  {
-    m_instances[instance] = true;
-  }
+  void set_dependent(size_t instance);
   
+  const BoolVector& get_instances();
   
+  Event* get_event();
   
 };
 
@@ -100,43 +108,39 @@
    * Holds greater/lesser Instances of Events accessible under id of Event's
    * Instance.
    */
-  EDInstancesPtrSet m_events_instances;
+  EDInstancesPtrSetVector m_events_instances;
   
+  /**
+   * Compares first and second like they would be a strings.
+   * 
+   * Compares element by element, if any less/greater element in first is found
+   * than an element of second at the same position, first is declared to be 
+   * less/greater than second.
+   *
+   * Returns x<0 if first < second, 0 if first == second, x>0 if first > second
+   */
+  int compare(
+    const EDInstancesPtrSet& first,
+    const EDInstancesPtrSet& second) const;
+  
 public:
   
-  ExtremeEvents()
-  {
-  }
+  ExtremeEvents();
   
+  ExtremeEvents(size_t instances_count);
+  
   /**
-   * Compares ExtremeEvents by items.
+   * Compares ExtremeEvents item by item.
+   *
+   * Items are supposed to be separate EDInstancesPtrSets which are elements
+   * of m_events_instances. Empty item i (empty EDInstancesPtrSet) is supposed 
+   * to be less than anything else which is not empty.
    */
-  bool operator<(const ExtremeEvents& extreme) const
-  {
-    EDInstancesPtrSet::const_iterator my_i = m_events_instances.begin();
-    EDInstancesPtrSet::const_iterator extreme_i = extreme.m_events_instances.begin();
-    while(my_i!=m_events_instances.end() && extreme_i!=extreme.m_events_instances.end())
-    {
-      const EDInstancesPtr my_edis = *my_i;
-      const EDInstancesPtr extreme_edis = *extreme_i;
-      int comparision = my_edis->compare(*extreme_edis.get());
-      if(comparision!=0) return comparision<0;
-      my_i++;
-      extreme_i++;
-    }
-    //otherwise this is same as extreme
-    return false;
-  }
+  bool operator<(const ExtremeEvents& other) const;
   
-  void add_extreme_event(EDInstancesPtr& ...
 
[truncated message content]

Thread: [Scstudio-commits] SF.net SVN: scstudio:[111] trunk/src

scstudio-commits