add disable filter

core/src/main/java/ru/trader/analysis/FilteredMarket.java

@@ -4,34 +4,61 @@ import ru.trader.core.*;
 
 import java.util.Collection;
 import java.util.NavigableSet;
+import java.util.function.Predicate;
 import java.util.stream.Stream;
 
 public class FilteredMarket {
     private final Market market;
     private final MarketFilter filter;
+    private boolean disableFilter;
 
     public FilteredMarket(Market market, MarketFilter filter) {
         this.market = market;
         this.filter = filter;
     }
 
+    public void disableFilter(boolean disableFilter) {
+        this.disableFilter = disableFilter;
+    }
+
     public Stream<Place> get(){
-        return market.get().stream()
+        Stream<Place> places = market.get().stream();
-                .filter(p -> !filter.isFiltered(p));
+        if (disableFilter){
+            return places;
+        }
+        return places.filter(p -> !filter.isFiltered(p));
     }
 
     public Stream<Vendor> getVendors(){
-        return get().flatMap(p -> p.get().stream())
+        if (disableFilter){
-                .filter(v -> !filter.isFiltered(v));
+            return market.getVendors().stream();
+        }
+        return get().flatMap(p -> p.get().stream()).filter(v -> !filter.isFiltered(v));
+    }
+
+    public Stream<Vendor> getVendors(Place place){
+        Stream<Vendor> vendors = place.get().stream();
+        if (disableFilter){
+            return vendors;
+        }
+        return vendors.filter(v -> !filter.isFiltered(v));
+    }
+
+    private boolean isMarket(Vendor vendor){
+        return vendor.has(SERVICE_TYPE.MARKET) || vendor.has(SERVICE_TYPE.BLACK_MARKET);
+    }
+
+    private boolean isTransit(Vendor vendor){
+        return vendor instanceof TransitVendor;
     }
 
     public Stream<Vendor> getMarkets(boolean withTransit){
-        return get().flatMap(p -> p.get(true).stream())
+        Predicate<Vendor> transitOrMarket = v -> withTransit && isTransit(v) || isMarket(v);
-                .filter(v -> {
+        if (disableFilter){
-                    if (withTransit && v instanceof TransitVendor) return true;
+            return market.getVendors().stream().filter(transitOrMarket);
-                    if (!v.has(SERVICE_TYPE.MARKET) && !v.has(SERVICE_TYPE.BLACK_MARKET)) return false;
+        }
-                    return !filter.isFiltered(v);
+        return get().flatMap(p -> p.get(withTransit).stream())
-                });
+                .filter(transitOrMarket).filter(v -> !filter.isFiltered(v));
     }
 
     public Collection<Item> getItems(){
@@ -53,6 +80,9 @@ public class FilteredMarket {
             res = offers.stream();
         else
             res = offers.descendingSet().stream();
+        if (disableFilter){
+            return res;
+        }
         return res.filter(o -> !filter.isFiltered(o.getVendor(), true));
     }