Expand path added

core/src/main/java/ru/trader/graph/Path.java

@@ -22,14 +22,9 @@ public class Path<T extends Connectable<T>> {
         return new Path<>(this, vertex, refill);
     }
 
-    public void finish(){
-        finish(target);
-    }
-
-    protected void finish(Vertex<T> target){
+    protected void finish(){
         if (!isRoot()){
-            head.finish(target);
-            if (target != head.target) head.finish();
+            head.finish();
         }
     }
 
@@ -91,11 +86,15 @@ public class Path<T extends Connectable<T>> {
         return target;
     }
 
+    public T get() {
+        return target.getEntry();
+    }
+
     public boolean isRefill(){
         return refill;
     }
 
-    protected Path<T> getHead(){
+    protected Path<T> getPrevious(){
         return head;
     }
 

core/src/main/java/ru/trader/graph/PathRoute.java

@@ -1,5 +1,7 @@
 package ru.trader.graph;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import ru.trader.core.Offer;
 import ru.trader.core.Order;
 import ru.trader.core.Vendor;
@@ -7,50 +9,107 @@ import ru.trader.core.Vendor;
 import java.util.*;
 
 public class PathRoute extends Path<Vendor> {
-    private final ArrayList<Order> orders = new ArrayList<>();
-    private double profit = 0;
-    private int transitIndex = 0;
-    private PathRoute tail;
+    private final static Logger LOG = LoggerFactory.getLogger(PathRoute.class);
 
+    private final ArrayList<Order> orders = new ArrayList<>();
+    private final boolean expand;
+    private double profit = 0;
+    private PathRoute tail;
+    private int ordersCount = 0;
+    public final static Order TRANSIT = null;
+
+    public PathRoute(Vertex<Vendor> source, boolean expand) {
+        super(source);
+        this.expand = expand;
+    }
 
     public PathRoute(Vertex<Vendor> source) {
         super(source);
+        expand = false;
     }
 
     private PathRoute(PathRoute head, Vertex<Vendor> vertex, boolean refill) {
         super(head, vertex, refill);
         assert head.tail == null;
         head.tail = this;
+        expand = head.expand;
+        //transit
+        orders.add(ordersCount++, TRANSIT);
     }
 
     @Override
     public Path<Vendor> connectTo(Vertex<Vendor> vertex, boolean refill) {
+        LOG.trace("Connect path {} to {}", this, vertex);
         return new PathRoute(this.getCopy(), vertex, refill);
     }
 
-    @Override
-    protected void finish(Vertex<Vendor> target) {
-        if (!isRoot()) {
-            if (!contains(target.getEntry())){
-                updateOrders(target.getEntry());
-                getHead().finish(target);
-                if (getHead().getTarget() != target) getHead().finish();
+    public PathRoute getCopy(){
+        PathRoute path = (PathRoute) getRoot();
+        PathRoute res = new PathRoute(path.getTarget());
+        while (path.hasNext()){
+            path = path.getNext();
+            res = new PathRoute(res, path.getTarget(), path.isRefill());
+        }
+        return res;
+    }
+
+    private void addOrder(Order order){
+        LOG.trace("Add order {} to path {}", order, this);
+        orders.add(ordersCount++, order);
+        if (!expand) return;
+        LOG.trace("Expand orders");
+        if (hasNext()){
+            PathRoute next = getNext();
+            LOG.trace("Add {} clone of order", next.ordersCount - 1);
+            for (int i = 1; i < next.ordersCount; i++) {
+                orders.add(ordersCount++, new Order(order.getSell(), order.getBuy()));
+                addTransitsToHead();
             }
+            cloneTailOrders(next.ordersCount);
+        }
+        addTransitsToHead();
+    }
+
+    private void addTransitsToHead(){
+        PathRoute p = getPrevious();
+        while (!p.isRoot()) {
+            LOG.trace("Add transit order to path {}", p);
+            p.orders.add(p.ordersCount++, TRANSIT);
+            p = p.getPrevious();
         }
     }
 
-    private boolean contains(Vendor buyer){
-        for (Order order : orders) {
-            if (order.isBuyer(buyer)) return true;
+    private void cloneTailOrders(int count){
+        if (hasNext()) {
+            PathRoute p = getNext();
+            LOG.trace("Duplicate {} orders of path {}", count, p);
+            for (int i = 0; i < count; i++) {
+                Order o = p.orders.get(i);
+                if (o == TRANSIT) p.orders.add(TRANSIT);
+                else p.orders.add(new Order(o.getSell(), o.getBuy()));
+            }
+            p.cloneTailOrders(count);
         }
-        return false;
     }
 
-    private void updateOrders(Vendor buyer){
-        Vendor seller = getHead().getTarget().getEntry();
+    @Override
+    protected void finish() {
+        if (!isRoot()){
+            fillOrders();
+            getPrevious().finish();
+        }
+    }
+
+    private void fillOrders(){
+        LOG.trace("Fill orders of path {}", this);
+        Vendor seller = getPrevious().get();
         for (Offer sell : seller.getAllSellOffers()) {
-            Offer buy = buyer.getBuy(sell.getItem());
-            if (buy != null) orders.add(new Order(sell, buy));
+            PathRoute p = this;
+            while (p != null) {
+                Offer buy = p.get().getBuy(sell.getItem());
+                if (buy != null) addOrder(new Order(sell, buy));
+                p = p.getNext();
+            }
         }
     }
 
@@ -58,40 +117,37 @@ public class PathRoute extends Path<Vendor> {
         return Collections.unmodifiableList(orders);
     }
 
-    @Override
-    public String toString() {
-        StringBuilder sb = new StringBuilder();
-        for (Order order : orders) {
-            if (sb.length() > 0) sb.append(", ");
-            sb.append(order.getBuy().getItem());
-            sb.append(" (").append(order.getBuyer()).append(") ");
-        }
-        String o = sb.toString();
-        sb = new StringBuilder();
-        if (isRoot()){
-            sb.append(getTarget().getEntry());
-            if (o.length()>0) sb.append(" (").append(o).append(") ");
-        } else {
-            sb.append(getHead().toString());
-            if (isRefill()) sb.append("(R)");
-            if (o.length()>0) sb.append(" (").append(o).append(") ");
-            sb.append(" -> ").append(getTarget().getEntry());
-        }
-        return sb.toString();
-    }
-
     public boolean isEmpty(){
-        return orders.isEmpty();
+        return ordersCount <= 1;
     }
 
-    public PathRoute getCopy(){
-        PathRoute path = (PathRoute) getRoot();
-        PathRoute res = new PathRoute(path.getTarget());
-        while (path.tail != null){
-            res = new PathRoute(res, path.tail.getTarget(), path.tail.isRefill());
-            path = path.tail;
+    @Override
+    protected PathRoute getPrevious() {
+        return (PathRoute) super.getPrevious();
+    }
+
+    public PathRoute getNext() {
+        return tail;
+    }
+
+    public boolean hasNext(){
+        return tail != null;
+    }
+
+    public void resort(double balance, long limit){
+        if (isRoot()) return;
+        for (Order order : orders) {
+            if (order == TRANSIT) continue;
+            order.setMax(balance, limit);
         }
-        return res;
+        orders.sort(this::compareOrders);
+
+        updateProfit();
+        getPrevious().resort(balance, limit);
+    }
+
+    private double getTransitProfit(){
+        return hasNext() ? getNext().getProfit() : 0;
     }
 
     public double getProfit(){
@@ -99,54 +155,22 @@ public class PathRoute extends Path<Vendor> {
     }
 
     public double getProfit(Order order){
+        if (order == TRANSIT) return getTransitProfit();
         if (isPathFrom(order.getBuyer())) return order.getProfit() + profit;
-        return tail != null ? tail.getProfit(order) : order.getProfit();
-    }
-
-    @Override
-    protected PathRoute getHead() {
-        return (PathRoute) super.getHead();
-    }
-
-    public void resort(double balance, long limit){
-        if (isRoot()) return;
-        for (Order order : orders) {
-            order.setMax(balance, limit);
-        }
-        orders.sort(this::compareOrders);
-
-        updateProfit();
-        updateTransitIndex();
-        getHead().resort(balance, limit);
-    }
-
-    private void updateTransitIndex() {
-        transitIndex = orders.size();
-        if (isEmpty()) return;
-        double transitProfit = tail != null ? tail.getProfit() : 0;
-        ListIterator<Order> itr = orders.listIterator(orders.size());
-        while (itr.hasPrevious()){
-            Order o = itr.previous();
-            if (getProfit(o) > transitProfit){
-                return;
-            }
-            transitIndex--;
-        }
+        return hasNext() ? getNext().getProfit(order) : order.getProfit();
     }
 
     private void updateProfit() {
-        if (isEmpty()){
-            profit = tail != null ? tail.getProfit() : 0;
-        } else {
-            Order best = orders.get(0);
-            profit = getProfit(best);
-        }
+        Order best = orders.get(0);
+        if (best == TRANSIT) profit = getTransitProfit();
+            else profit = getProfit(best);
+
     }
 
     private int compareOrders(Order o1, Order o2){
-        if (tail == null || o1.isBuyer(o2.getBuyer())){
-            //reverse
-            return o2.compareTo(o1);
+        if (o1 != TRANSIT && o2 !=  TRANSIT){
+            if (!hasNext() || o1.isBuyer(o2.getBuyer()))
+                return o2.compareTo(o1);
         }
         double profit1 = getProfit(o1);
         double profit2 = getProfit(o2);
@@ -154,11 +178,30 @@ public class PathRoute extends Path<Vendor> {
     }
 
 
-    public PathRoute getTail() {
-        return tail;
+
+    @Override
+         public String toString() {
+        StringBuilder sb = new StringBuilder();
+        int step = !hasNext() || tail.ordersCount == 0 ? 1 : tail.ordersCount;
+        for (int i = 0; i < ordersCount; i += step) {
+            Order order = orders.get(i);
+            if (order == TRANSIT) continue;
+            if (sb.length() > 0) sb.append(", ");
+            sb.append(order.getBuy().getItem());
+            sb.append(" (").append(order.getBuyer()).append(") ");
+        }
+        String o = sb.toString();
+        sb = new StringBuilder();
+        if (isRoot()){
+            sb.append(get());
+            if (o.length()>0) sb.append(" (").append(o).append(") ");
+        } else {
+            sb.append(getPrevious().toString());
+            if (isRefill()) sb.append("(R)");
+            if (o.length()>0) sb.append(" (").append(o).append(") ");
+            sb.append(" -> ").append(get());
+        }
+        return sb.toString();
     }
 
-    public int getTransitIndex() {
-        return transitIndex;
-    }
 }