Changeset 969

Timestamp:

10/20/15 11:44:16 (9 years ago)

Author:

bln4

Message:

Added a rule to deal with the combination of daisy chaining and multiple arrows heading into one box.

The issue: with multiple arrows going into the same box we have the possibility of creating infinite loops.

The ideal solution: only follow the second arrow into a box if we can detect that no loop occurs.

The current solution: we only follow the second arrow into a box if that box does not have a exiting arrow.

What this means:
(+) We can have multiple arrows going into a single box safely
(+) Daisy chaining cannot cause a infinite loop
(-) We cannot repeat a daisy chained set of boxes. In other words; if we have a series of boxes connected by arrows; even if they don't form a loop; only one arrow going into the first of the boxes is followed; others are ignored.

File:

• trunk/src/org/expeditee/io/flowlayout/XGroupItem.java (modified) (2 diffs)

trunk/src/org/expeditee/io/flowlayout/XGroupItem.java

@@ -453 +453 @@
                                                 if (xgroup_item != this) {
                                                         
-                                                        if(out_of_flow.contains(xgroup_item)) continue;
+                                                        if(out_of_flow.contains(xgroup_item)) {
+                                                                final Collection<Item> remaining_dots = new ArrayList<Item>(xgroup_item.remaining_item_list);
+                                                                boolean hasExit = false;
+                                                                for(final Item i : remaining_dots) {
+                                                                        final List<Line> lines = i.getLines();
+                                                                        if(lines.size() == 1 && lines.get(0).getStartItem() == i) {
+                                                                                hasExit = true;
+                                                                                break;
+                                                                        }
+                                                                }
+                                                                if(hasExit) continue;
+                                                        }
                                                         
                                                         out_of_flow.add(xgroup_item);
@@ -519 +530 @@
         public void repositionOutOfFlowGroups(XGroupItem toplevel_xgroup)
         {
-                Collection<XGroupItem> out_of_flow = new HashSet<XGroupItem>();
+//              Collection<XGroupItem> out_of_flow = new HashSet<XGroupItem>();
+                Collection<XGroupItem> out_of_flow = new ArrayList<XGroupItem>();
 
                 repositionOutOfFlowGroupsRecursive(toplevel_xgroup,out_of_flow);