diff --git a/core/src/main/java/ru/trader/core/AbstractItem.java b/core/src/main/java/ru/trader/core/AbstractItem.java new file mode 100644 index 0000000..5484c54 --- /dev/null +++ b/core/src/main/java/ru/trader/core/AbstractItem.java @@ -0,0 +1,45 @@ +package ru.trader.core; + +import org.jetbrains.annotations.NotNull; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Objects; + +public abstract class AbstractItem implements Item { + private final static Logger LOG = LoggerFactory.getLogger(AbstractItem.class); + private AbstractMarket market; + + protected abstract void updateName(String name); + + protected final void setMarket(AbstractMarket market){ + assert this.market == null; + this.market = market; + } + + @Override + public final void setName(String name){ + if (market != null){ + LOG.debug("Change name of item {} to {}", this, name); + market.updateName(this, name); + market.setChange(true); + } else { + updateName(name); + } + } + + @Override + public String toString(){ + return getName(); + } + + @Override + public int compareTo(@NotNull Item other){ + Objects.requireNonNull(other, "Not compare with null"); + if (this == other) return 0; + String name = getName(); + String otherName = other.getName(); + return name != null ? otherName != null ? name.compareTo(otherName) : -1 : 0; + } + +} diff --git a/core/src/main/java/ru/trader/core/AbstractItemStat.java b/core/src/main/java/ru/trader/core/AbstractItemStat.java new file mode 100644 index 0000000..199dbb7 --- /dev/null +++ b/core/src/main/java/ru/trader/core/AbstractItemStat.java @@ -0,0 +1,188 @@ +package ru.trader.core; + +import java.util.Collection; +import java.util.Collections; + +public abstract class AbstractItemStat implements ItemStat { + + protected void updatePrice(AbstractOffer offer, double price){ + offer.updatePrice(price); + } + + @Override + public String toString() { + final StringBuilder sb = new StringBuilder("{"); + sb.append(getItem()); + sb.append(", ").append(getType()); + sb.append(", avg=").append(getAvg()); + sb.append(", best=").append(getBest()); + sb.append(", min=").append(getMin()); + sb.append(", max=").append(getMax()); + + sb.append("}"); + return sb.toString(); + } + + protected Offer getFake() { + return new Offer() { + @Override + public Item getItem() { + return AbstractItemStat.this.getItem(); + } + + @Override + public OFFER_TYPE getType() { + return AbstractItemStat.this.getType(); + } + + @Override + public Vendor getVendor() { + return NONE_VENDOR; + } + + @Override + public double getPrice() { + return Double.NaN; + } + + @Override + public void setPrice(double price) { + throw new UnsupportedOperationException("Is fake offer, change unsupported"); + } + + @Override + public long getCount() { + return 0; + } + + @Override + public void setCount(long count) { + throw new UnsupportedOperationException("Is fake offer, change unsupported"); + } + }; + } + + private static Place FAKE_PLACE = new Place() { + @Override + public String getName() { + return "None"; + } + + @Override + public void setName(String name) { + throw new UnsupportedOperationException("Is fake place, change unsupported"); + } + + @Override + public double getX() { + return 0; + } + + @Override + public double getY() { + return 0; + } + + @Override + public double getZ() { + return 0; + } + + @Override + public void setPosition(double x, double y, double z) { + throw new UnsupportedOperationException("Is fake place, change unsupported"); + } + + @Override + public Collection get() { + return Collections.singleton(NONE_VENDOR); + } + + @Override + public Vendor addVendor(String name) { + throw new UnsupportedOperationException("Is fake place, change unsupported"); + } + + @Override + public void add(Vendor vendor) { + throw new UnsupportedOperationException("Is fake place, change unsupported"); + } + + @Override + public void remove(Vendor vendor) { + throw new UnsupportedOperationException("Is fake place, change unsupported"); + } + }; + + private static Vendor NONE_VENDOR = new Vendor() { + @Override + public String getName() { + return "None"; + } + + @Override + public void setName(String name) { + throw new UnsupportedOperationException("Is fake vendor, change unsupported"); + } + + @Override + public Place getPlace() { + return FAKE_PLACE; + } + + @Override + public double getDistance() { + return 0; + } + + @Override + public void setDistance(double distance) { + throw new UnsupportedOperationException("Is fake vendor, change unsupported"); + } + + @Override + public void add(SERVICE_TYPE service) { + throw new UnsupportedOperationException("Is fake vendor, change unsupported"); + } + + @Override + public void remove(SERVICE_TYPE service) { + throw new UnsupportedOperationException("Is fake vendor, change unsupported"); + } + + @Override + public boolean has(SERVICE_TYPE service) { + return false; + } + + @Override + public Offer addOffer(OFFER_TYPE type, Item item, double price, long count) { + throw new UnsupportedOperationException("Is fake vendor, change unsupported"); + } + + @Override + public void add(Offer offer) { + throw new UnsupportedOperationException("Is fake vendor, change unsupported"); + } + + @Override + public void remove(Offer offer) { + throw new UnsupportedOperationException("Is fake vendor, change unsupported"); + } + + @Override + public Collection get(OFFER_TYPE type) { + return null; + } + + @Override + public Offer get(OFFER_TYPE type, Item item) { + return null; + } + + @Override + public boolean has(OFFER_TYPE type, Item item) { + return false; + } + }; +} diff --git a/core/src/main/java/ru/trader/core/AbstractMarket.java b/core/src/main/java/ru/trader/core/AbstractMarket.java new file mode 100644 index 0000000..a414c87 --- /dev/null +++ b/core/src/main/java/ru/trader/core/AbstractMarket.java @@ -0,0 +1,134 @@ +package ru.trader.core; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public abstract class AbstractMarket implements Market { + private final static Logger LOG = LoggerFactory.getLogger(AbstractMarket.class); + + private boolean change; + + protected abstract Place createPlace(String name, double x, double y, double z); + protected abstract Group createGroup(String name, GROUP_TYPE type); + protected abstract Item createItem(String name, Group group); + protected abstract void addGroup(Group group); + protected abstract void removeGroup(Group group); + protected abstract void addPlace(Place place); + protected abstract void removePlace(Place place); + protected abstract void addItem(Item item); + protected abstract void removeItem(Item item); + + @Override + public final void add(Place place){ + LOG.debug("Add place {} to market {}", place, this); + change = true; + if (place instanceof AbstractPlace){ + ((AbstractPlace) place).setMarket(this); + } + addPlace(place); + } + + @Override + public Place addPlace(String name, double x, double y, double z) { + Place place = createPlace(name, x, y, z); + add(place); + return place; + } + + @Override + public final void remove(Place place){ + LOG.debug("Remove place {} from market {}", place, this); + change = true; + removePlace(place); + } + + @Override + public final void add(Group group){ + LOG.debug("Add group {} to market {}", group, this); + change = true; + addGroup(group); + } + + @Override + public Group addGroup(String name, GROUP_TYPE type) { + Group group = createGroup(name, type); + add(group); + return group; + } + + @Override + public void remove(Group group) { + LOG.debug("Remove group {} from market {}", group, this); + change = true; + removeGroup(group); + } + + @Override + public final void add(Item item){ + LOG.debug("Add item {} to market {}", item, this); + change = true; + if (item instanceof AbstractItem){ + ((AbstractItem) item).setMarket(this); + } + addItem(item); + } + + @Override + public Item addItem(String name, Group group) { + Item item = createItem(name, group); + add(item); + return item; + } + + @Override + public final void remove(Item item){ + LOG.debug("Remove item {} from market {}", item, this); + change = true; + removeItem(item); + } + + @Override + public boolean isChange() { + return change; + } + + @Override + public void commit() { + change = false; + } + + protected final void setChange(boolean change) { + this.change = change; + } + + protected void onAdd(Vendor vendor){} + protected void onRemove(Vendor vendor){} + protected void onAdd(Offer offer){} + protected void onRemove(Offer offer){} + + protected void updateName(AbstractPlace place, String name){ + place.updateName(name); + } + + protected void updatePosition(AbstractPlace place, double x, double y, double z){ + place.updatePosition(x, y, z); + } + + protected void updateName(AbstractVendor vendor, String name){ + vendor.updateName(name); + } + + protected void updatePrice(AbstractOffer offer, double price){ + ItemStat itemStat = getStat(offer); + if (itemStat instanceof AbstractItemStat){ + ((AbstractItemStat)itemStat).updatePrice(offer, price); + } + } + + protected void updateName(AbstractItem item, String name){ + item.updateName(name); + } + + +} + diff --git a/core/src/main/java/ru/trader/core/AbstractOffer.java b/core/src/main/java/ru/trader/core/AbstractOffer.java new file mode 100644 index 0000000..2d6bca3 --- /dev/null +++ b/core/src/main/java/ru/trader/core/AbstractOffer.java @@ -0,0 +1,45 @@ +package ru.trader.core; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public abstract class AbstractOffer implements Offer { + private final static Logger LOG = LoggerFactory.getLogger(AbstractOffer.class); + + protected abstract void updatePrice(double price); + protected abstract void updateCount(long count); + + protected AbstractMarket getMarket(){ + Vendor vendor = getVendor(); + if (vendor != null && vendor instanceof AbstractVendor){ + return ((AbstractVendor) vendor).getMarket(); + } + return null; + } + + @Override + public final void setPrice(double price) { + AbstractMarket market = getMarket(); + if (market != null){ + LOG.debug("Change price of offer {} to {}", this, price); + market.updatePrice(this, price); + market.setChange(true); + } else { + updatePrice(price); + } + } + + @Override + public final void setCount(long count) { + AbstractMarket market = getMarket(); + if (market != null){ + LOG.debug("Change count of offer {} to {}", this, count); + updateCount(count); + market.setChange(true); + } else { + updateCount(count); + } + } + + +} diff --git a/core/src/main/java/ru/trader/core/AbstractPlace.java b/core/src/main/java/ru/trader/core/AbstractPlace.java new file mode 100644 index 0000000..ad34487 --- /dev/null +++ b/core/src/main/java/ru/trader/core/AbstractPlace.java @@ -0,0 +1,95 @@ +package ru.trader.core; + +import org.jetbrains.annotations.NotNull; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Objects; + +public abstract class AbstractPlace implements Place, Comparable { + private final static Logger LOG = LoggerFactory.getLogger(AbstractPlace.class); + private AbstractMarket market; + + protected abstract Vendor createVendor(String name); + protected abstract void updateName(String name); + protected abstract void updatePosition(double x, double y, double z); + protected abstract void addVendor(Vendor vendor); + protected abstract void removeVendor(Vendor vendor); + + protected final void setMarket(AbstractMarket market){ + assert this.market == null; + this.market = market; + } + + protected final AbstractMarket getMarket(){ + return market; + } + + @Override + public final void setName(String name){ + if (market != null){ + LOG.debug("Change name of place {} to {}", this, name); + market.updateName(this, name); + market.setChange(true); + } else { + updateName(name); + } + } + + @Override + public final void setPosition(double x, double y, double z) { + if (market != null){ + LOG.debug("Change position of place {} to {},{},{}", this, x, y, z); + market.updatePosition(this, x, y, z); + market.setChange(true); + } else { + updatePosition(x, y, z); + } + } + + @Override + public final void add(Vendor vendor) { + if (market != null){ + LOG.debug("Add vendor {} to place {}", vendor, this); + addVendor(vendor); + market.setChange(true); + market.onAdd(vendor); + } else { + addVendor(vendor); + } + } + + @Override + public Vendor addVendor(String name) { + Vendor vendor = createVendor(name); + add(vendor); + return vendor; + } + + @Override + public final void remove(Vendor vendor) { + if (market != null){ + LOG.debug("Remove vendor {} from place {}", vendor, this); + removeVendor(vendor); + market.setChange(true); + market.onRemove(vendor); + } else { + removeVendor(vendor); + } + } + + @Override + public String toString() { + return getName(); + } + + @Override + public int compareTo(@NotNull Place other) { + Objects.requireNonNull(other, "Not compare with null"); + if (this == other) return 0; + String name = getName(); + String otherName = other.getName(); + return name != null ? otherName != null ? name.compareTo(otherName) : -1 : 0; + } + +} diff --git a/core/src/main/java/ru/trader/core/AbstractVendor.java b/core/src/main/java/ru/trader/core/AbstractVendor.java new file mode 100644 index 0000000..9a5993e --- /dev/null +++ b/core/src/main/java/ru/trader/core/AbstractVendor.java @@ -0,0 +1,110 @@ +package ru.trader.core; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public abstract class AbstractVendor implements Vendor { + private final static Logger LOG = LoggerFactory.getLogger(AbstractVendor.class); + + protected abstract Offer createOffer(OFFER_TYPE type, Item item, double price, long count); + protected abstract void updateName(String name); + protected abstract void updateDistance(double distance); + protected abstract void addService(SERVICE_TYPE service); + protected abstract void removeService(SERVICE_TYPE service); + protected abstract void addOffer(Offer offer); + protected abstract void removeOffer(Offer offer); + + protected AbstractMarket getMarket(){ + Place place = getPlace(); + if (place != null && place instanceof AbstractPlace){ + return ((AbstractPlace) place).getMarket(); + } + return null; + } + + @Override + public final void setName(String name) { + AbstractMarket market = getMarket(); + if (market != null){ + LOG.debug("Change name of vendor {} to {}", this, name); + market.updateName(this, name); + market.setChange(true); + } else { + updateName(name); + } + } + + @Override + public final void setDistance(double distance) { + AbstractMarket market = getMarket(); + if (market != null){ + LOG.debug("Change distance of vendor {} to {}", this, distance); + updateDistance(distance); + market.setChange(true); + } else { + updateDistance(distance); + } + } + + @Override + public final void add(SERVICE_TYPE service) { + AbstractMarket market = getMarket(); + if (market != null){ + LOG.trace("Add service {} to vendor {}", service, this); + addService(service); + market.setChange(true); + } else { + addService(service); + } + } + + @Override + public final void remove(SERVICE_TYPE service) { + AbstractMarket market = getMarket(); + if (market != null){ + LOG.trace("Remove offer {} from vendor {}", service, this); + removeService(service); + market.setChange(true); + } else { + removeService(service); + } + } + + public final void add(Offer offer){ + AbstractMarket market = getMarket(); + if (market != null){ + LOG.trace("Add offer {} to vendor {}", offer, this); + addOffer(offer); + market.setChange(true); + market.onAdd(offer); + } else { + addOffer(offer); + } + } + + @Override + public Offer addOffer(OFFER_TYPE type, Item item, double price, long count) { + Offer offer = createOffer(type, item, price, count); + add(offer); + return offer; + } + + public final void remove(Offer offer){ + assert this.equals(offer.getVendor()); + AbstractMarket market = getMarket(); + if (market != null){ + LOG.trace("Remove offer {} from vendor {}", offer, this); + removeOffer(offer); + market.setChange(true); + market.onRemove(offer); + } else { + removeOffer(offer); + } + } + + @Override + public String toString() { + return getName(); + } + +} diff --git a/core/src/main/java/ru/trader/core/Group.java b/core/src/main/java/ru/trader/core/Group.java index 9d79d5b..f884696 100644 --- a/core/src/main/java/ru/trader/core/Group.java +++ b/core/src/main/java/ru/trader/core/Group.java @@ -1,18 +1,18 @@ package ru.trader.core; -public abstract class Group { - public abstract String getName(); - public abstract GROUP_TYPE getType(); +public interface Group { + public String getName(); + public GROUP_TYPE getType(); - public boolean isMarket(){ + public default boolean isMarket(){ return GROUP_TYPE.MARKET.equals(getType()); } - public boolean isShip(){ + public default boolean isShip(){ return GROUP_TYPE.SHIP.equals(getType()); } - public boolean isOutfit(){ + public default boolean isOutfit(){ return GROUP_TYPE.OUTFIT.equals(getType()); } diff --git a/core/src/main/java/ru/trader/core/Item.java b/core/src/main/java/ru/trader/core/Item.java index ca8d979..ec8f9c4 100644 --- a/core/src/main/java/ru/trader/core/Item.java +++ b/core/src/main/java/ru/trader/core/Item.java @@ -4,21 +4,14 @@ import org.jetbrains.annotations.NotNull; import java.util.Objects; -public abstract class Item implements Comparable { +public interface Item extends Comparable { + String getName(); + void setName(String name); - public abstract String getName(); - protected abstract void setName(String name); - - public abstract Group getGroup(); - public abstract void setGroup(Group group); + Group getGroup(); @Override - public String toString(){ - return getName(); - } - - @Override - public int compareTo(@NotNull Item other){ + default int compareTo(@NotNull Item other){ Objects.requireNonNull(other, "Not compare with null"); if (this == other) return 0; String name = getName(); diff --git a/core/src/main/java/ru/trader/core/ItemStat.java b/core/src/main/java/ru/trader/core/ItemStat.java index 2f8c980..551a94a 100644 --- a/core/src/main/java/ru/trader/core/ItemStat.java +++ b/core/src/main/java/ru/trader/core/ItemStat.java @@ -1,176 +1,17 @@ package ru.trader.core; -import java.util.ArrayList; -import java.util.Collection; import java.util.NavigableSet; -public abstract class ItemStat { +public interface ItemStat { - protected abstract void update(Offer offer, double price); + OFFER_TYPE getType(); + Item getItem(); - public abstract OFFER_TYPE getType(); + Offer getMin(); + double getAvg(); + Offer getMax(); - public abstract Item getItem(); - - public abstract double getAvg(); - - public abstract Offer getBest(); - - public abstract int getOffersCount(); - - public abstract NavigableSet getOffers(); - - public abstract Offer getMin(); - - public abstract Offer getMax(); - - public abstract boolean isEmpty(); - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (!(o instanceof ItemStat)) return false; - - ItemStat itemStat = (ItemStat) o; - return getType() == itemStat.getType() && getItem().equals(itemStat.getItem()); - } - - @Override - public int hashCode() { - int result = getItem().hashCode(); - result = 31 * result + getType().hashCode(); - return result; - } - - @Override - public String toString() { - final StringBuilder sb = new StringBuilder("{"); - sb.append(getItem()); - sb.append(", ").append(getType()); - sb.append(", avg=").append(getAvg()); - sb.append(", best=").append(getBest()); - sb.append(", min=").append(getMin()); - sb.append(", max=").append(getMax()); - - sb.append("}"); - return sb.toString(); - } - - protected Offer getFake() { - return new Offer() { - - @Override - public Item getItem() { - return getItem(); - } - - @Override - public OFFER_TYPE getType() { - return getType(); - } - - @Override - public double getPrice() { - return Double.NaN; - } - - @Override - public Vendor getVendor() { - return NONE_VENDOR; - } - - @Override - public boolean hasType(OFFER_TYPE offerType) { - return false; - } - - @Override - public boolean hasItem(Item item) { - return false; - } - - @Override - protected void setPrice(double price) { - throw new UnsupportedOperationException("Is fake offer, change unsupported"); - } - - @Override - protected void setVendor(Vendor vendor) { - throw new UnsupportedOperationException("Is fake offer, change unsupported"); - } - }; - } - - private static Vendor NONE_VENDOR = new Vendor() { - - @Override - public String getName() { - return "None"; - } - - @Override - protected Collection getOffers() { - return new ArrayList<>(); - } - - @Override - protected Collection getItems(OFFER_TYPE offerType) { - return new ArrayList<>(); - } - - @Override - protected Offer getOffer(OFFER_TYPE offerType, Item item) { - return null; - } - - @Override - protected boolean hasOffer(OFFER_TYPE offerType, Item item) { - return false; - } - - @Override - protected void addOffer(Offer offer) { - throw new UnsupportedOperationException("Is fake vendor, change unsupported"); - } - - @Override - protected void removeOffer(Offer offer) { - throw new UnsupportedOperationException("Is fake vendor, change unsupported"); - } - - @Override - public void setName(String name) { - throw new UnsupportedOperationException("Is fake vendor, change unsupported"); - } - - @Override - public double getX() { - return 0; - } - - @Override - public void setX(double x) { - throw new UnsupportedOperationException("Is fake vendor, change unsupported"); - } - - @Override - public double getY() { - return 0; - } - - @Override - public void setY(double y) { - throw new UnsupportedOperationException("Is fake vendor, change unsupported"); - } - - @Override - public double getZ() { - return 0; - } - - @Override - public void setZ(double z) { - throw new UnsupportedOperationException("Is fake vendor, change unsupported"); - } - }; + Offer getBest(); + NavigableSet getOffers(); + boolean isEmpty(); } diff --git a/core/src/main/java/ru/trader/core/Market.java b/core/src/main/java/ru/trader/core/Market.java index 5993d71..d2c4500 100644 --- a/core/src/main/java/ru/trader/core/Market.java +++ b/core/src/main/java/ru/trader/core/Market.java @@ -2,49 +2,45 @@ package ru.trader.core; import java.util.Collection; - public interface Market { - boolean isChange(); - ItemStat getStat(Offer offer); + void add(Place place); + Place addPlace(String name, double x, double y, double z); + void remove(Place place); - ItemStat getStat(OFFER_TYPE type, Item item); - - ItemStat getStatSell(Item item); - - ItemStat getStatBuy(Item item); - - Collection getSell(Item item); - - Collection getBuy(Item item); - - void add(Vendor vendor); + void add(Group group); + Group addGroup(String name, GROUP_TYPE type); + void remove(Group group); void add(Item item); - - void remove(Vendor vendor); - + Item addItem(String name, Group group); void remove(Item item); - Collection get(); - - void add(Vendor vendor, Offer offer); - - void remove(Vendor vendor, Offer offer); - + Collection get(); + Collection getGroups(); Collection getItems(); + ItemStat getStat(OFFER_TYPE type, Item item); - void addVendors(Collection vendors); + boolean isChange(); + void commit(); - void addItems(Collection items); + default ItemStat getStat(Offer offer){ + return getStat(offer.getType(), offer.getItem()); + } - void updatePrice(Offer offer, double price); + default ItemStat getStatSell(Item item){ + return getStat(OFFER_TYPE.SELL, item); + } - void setChange(boolean change); + default ItemStat getStatBuy(Item item){ + return getStat(OFFER_TYPE.BUY, item); + } - void updateName(Vendor vendor, String name); + default Collection getSell(Item item){ + return getStatSell(item).getOffers(); + } - void updateName(Item item, String name); - - void updatePosition(Vendor vendor, double x, double y, double z); + default Collection getBuy(Item item){ + return getStatBuy(item).getOffers(); + } } diff --git a/core/src/main/java/ru/trader/core/MarketAnalyzer.java b/core/src/main/java/ru/trader/core/MarketAnalyzer.java index 5f0b44b..0fe3526 100644 --- a/core/src/main/java/ru/trader/core/MarketAnalyzer.java +++ b/core/src/main/java/ru/trader/core/MarketAnalyzer.java @@ -27,58 +27,89 @@ public class MarketAnalyzer { public Collection getTop(double balance){ LOG.debug("Get top {}", limit); - Collection vendors = market.get(); + Iterable places = market.get(); List top = new ArrayList<>(limit); - for (Vendor vendor : vendors) { - LOG.trace("Check vendor {}", vendor); - Collection orders = getOrders(vendor, balance, top.isEmpty() ? 0 : top.get(top.size()-1).getProfit()); - TopList.addAllToTop(top, orders, limit, orderComparator); + for (Place place : places) { + LOG.trace("Check place {}", place); + Collection orders = getOrders(place, balance, top.isEmpty() ? 0 : top.get(top.size()-1).getProfit()); + TopList.addAllToTop(top, orders, limit, orderComparator); } return top; } - public Collection getOrders(Vendor vendor, double balance) { - return getOrders(vendor, balance, 0); + public Collection getOrders(Place place, double balance) { + return getOrders(place, balance, 0); } - private Collection getOrders(Vendor vendor, double balance, double lowProfit) { + private Collection getOrders(Place place, double balance, double lowProfit) { List res = new ArrayList<>(20); - Collection vendors = market.get(); - RouteGraph graph = new RouteGraph(vendor, vendors, tank, maxDistance, true, jumps); - for (Offer sell : vendor.getAllSellOffers()) { - long count = Math.min(cargo, (long) Math.floor(balance / sell.getPrice())); - LOG.trace("Sell offer {}, count = {}", sell, count); - if (count == 0) continue; - Iterator buyers = market.getStatBuy(sell.getItem()).getOffers().descendingIterator(); - while (buyers.hasNext()){ - Offer buy = buyers.next(); - if (!graph.isAccessible(buy.getVendor())){ - LOG.trace("Is inaccessible buyer, skip"); - continue; + Collection places = market.get(); + RouteGraph graph = new RouteGraph(place, places, tank, maxDistance, true, jumps); + for (Vendor vendor : place.get()) { + for (Offer sell : vendor.getAllSellOffers()) { + LOG.trace("Sell offer {}", sell); + if (sell.getCount() == 0) continue; + long count = Math.min(sell.getCount(), Math.min(cargo, (long) Math.floor(balance / sell.getPrice()))); + LOG.trace("count = {}", count); + if (count == 0) continue; + Iterator buyers = market.getStatBuy(sell.getItem()).getOffers().descendingIterator(); + while (buyers.hasNext()){ + Offer buy = buyers.next(); + if (!graph.isAccessible(buy.getVendor().getPlace())){ + LOG.trace("Is inaccessible buyer, skip"); + continue; + } + Order order = new Order(sell, buy, count); + LOG.trace("Buy offer {} profit = {}", buy, order.getProfit()); + if (order.getProfit() <= 0 && order.getCount() > 0) break; + if (order.getProfit() < lowProfit && order.getCount() == count) { + LOG.trace("Is low profit, skip"); + break; + } + res.add(order); } - Order order = new Order(sell, buy, count); - LOG.trace("Buy offer {} profit = {}", buy, order.getProfit()); - if (order.getProfit() <= 0 ) break; - if (order.getProfit() < lowProfit) { - LOG.trace("Is low profit, skip"); - break; - } - res.add(order); } } res.sort(orderComparator); return res; } - public Collection getOrders(Vendor from, Vendor to, double balance) { + public Collection getOrders(Place from, Place to, double balance) { Collection res = new ArrayList<>(); RouteGraph graph = new RouteGraph(from, market.get(), tank, maxDistance, true, jumps); if (!graph.isAccessible(to)){ LOG.trace("Is inaccessible buyer"); return res; } + for (Vendor seller : from.get()) { + for (Offer sell : seller.getAllSellOffers()) { + if (sell.getCount() == 0) continue; + long count = Math.min(sell.getCount(), Math.min(cargo, (long) Math.floor(balance / sell.getPrice()))); + LOG.trace("Sell offer {}, count = {}", sell, count); + if (count == 0) continue; + for (Vendor buyer : to.get()) { + Offer buy = buyer.getBuy(sell.getItem()); + if (buy != null){ + Order order = new Order(sell, buy, count); + LOG.trace("Buy offer {} profit = {}", buy, order.getProfit()); + res.add(order); + } + } + } + } + return res; + } + + public Collection getOrders(Vendor from, Vendor to, double balance) { + Collection res = new ArrayList<>(); + RouteGraph graph = new RouteGraph(from.getPlace(), market.get(), tank, maxDistance, true, jumps); + if (!graph.isAccessible(to.getPlace())){ + LOG.trace("Is inaccessible buyer"); + return res; + } for (Offer sell : from.getAllSellOffers()) { - long count = Math.min(cargo, (long) Math.floor(balance / sell.getPrice())); + if (sell.getCount() == 0) continue; + long count = Math.min(sell.getCount(), Math.min(cargo, (long) Math.floor(balance / sell.getPrice()))); LOG.trace("Sell offer {}, count = {}", sell, count); if (count == 0) continue; @@ -92,22 +123,22 @@ public class MarketAnalyzer { return res; } - public Collection> getPaths(Vendor from, Vendor to){ + public Collection> getPaths(Place from, Place to){ RouteGraph graph = new RouteGraph(from, market.get(), tank, maxDistance, true, jumps); return graph.getPathsTo(to); } - public PathRoute getPath(Vendor from, Vendor to){ + public PathRoute getPath(Place from, Place to){ RouteGraph graph = new RouteGraph(from, market.get(), tank, maxDistance, true, jumps); return (PathRoute) graph.getFastPathTo(to); } - public Collection getPaths(Vendor from, double balance){ + public Collection getPaths(Place from, double balance){ RouteSearcher searcher = new RouteSearcher(maxDistance, tank, segmentSize); return searcher.getPaths(from, market.get(), jumps, balance, cargo, limit); } - public Collection getPaths(Vendor from, Vendor to, double balance){ + public Collection getPaths(Place from, Place to, double balance){ RouteSearcher searcher = new RouteSearcher(maxDistance, tank, segmentSize); return searcher.getPaths(from, to, market.get(), jumps, balance, cargo, limit); } @@ -115,9 +146,9 @@ public class MarketAnalyzer { public Collection getTopPaths(double balance){ List top = new ArrayList<>(limit); RouteSearcher searcher = new RouteSearcher(maxDistance, tank, segmentSize); - Collection vendors = market.get(); - for (Vendor vendor : vendors) { - Collection paths = searcher.getPaths(vendor, vendor, vendors, jumps, balance, cargo, 3); + Collection places = market.get(); + for (Place place : places) { + Collection paths = searcher.getPaths(place, place, places, jumps, balance, cargo, 3); TopList.addAllToTop(top, paths, limit, RouteGraph.byProfitComparator); } return top; diff --git a/core/src/main/java/ru/trader/core/MarketSupport.java b/core/src/main/java/ru/trader/core/MarketSupport.java deleted file mode 100644 index 0d557e2..0000000 --- a/core/src/main/java/ru/trader/core/MarketSupport.java +++ /dev/null @@ -1,173 +0,0 @@ -package ru.trader.core; - -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import java.util.*; -import java.util.stream.Collectors; - -public abstract class MarketSupport implements Market { - private final static Logger LOG = LoggerFactory.getLogger(MarketSupport.class); - - protected abstract void addVendor(Vendor vendor); - protected abstract void removeVendor(Vendor vendor); - protected abstract void addItem(Item item); - protected abstract void removeItem(Item item); - protected abstract Collection getVendors(); - protected abstract Collection getItemList(); - - @Override - public abstract ItemStat getStat(OFFER_TYPE offerType, Item item); - - private boolean change; - - @Override - public boolean isChange() { - return change; - } - - protected Collection getVendors(OFFER_TYPE offerType, Item item){ - List offers = getVendors() - .stream() - .filter(vendor -> vendor.hasOffer(offerType, item)) - .collect(Collectors.toList()); - return Collections.unmodifiableCollection(offers); - } - - protected Collection getOffers(OFFER_TYPE offerType, Item item){ - ItemStat entry = getStat(offerType, item); - return entry!=null ? Collections.unmodifiableCollection(entry.getOffers()) : null; - } - - @Override - public final ItemStat getStat(Offer offer){ - return getStat(offer.getType(), offer.getItem()); - } - - @Override - public final ItemStat getStatSell(Item item){ - return getStat(OFFER_TYPE.SELL, item); - } - - @Override - public final ItemStat getStatBuy(Item item){ - return getStat(OFFER_TYPE.BUY, item); - } - - @Override - public final Collection getSell(Item item){ - return getOffers(OFFER_TYPE.SELL,item); - } - - @Override - public final Collection getBuy(Item item){ - return getOffers(OFFER_TYPE.BUY,item); - } - - @Override - public final void add(Vendor vendor){ - LOG.debug("Add vendor {} to market {}", vendor, this); - change = true; - addVendor(vendor); - } - - @Override - public final void add(Item item){ - LOG.debug("Add item {} to market {}", item, this); - change = true; - addItem(item); - } - - @Override - public final void remove(Vendor vendor){ - LOG.debug("Remove vendor {} from market {}", vendor, this); - change = true; - removeVendor(vendor); - } - - @Override - public final void remove(Item item){ - LOG.debug("Remove item {} from market {}", item, this); - change = true; - removeItem(item); - } - - @Override - public final Collection get(){ - return Collections.unmodifiableCollection(getVendors()); - } - - // Execute on add or remove offer - protected void onAdd(Offer offer){} - protected void onRemove(Offer offer){} - - @Override - public final void add(Vendor vendor, Offer offer){ - LOG.debug("Add offer {} to vendor {}", offer, vendor); - change = true; - vendor.add(offer); - onAdd(offer); - } - - @Override - public final void remove(Vendor vendor, Offer offer){ - LOG.debug("Remove offer {} from vendor {}", offer, vendor); - change = true; - vendor.remove(offer); - onRemove(offer); - } - - @Override - public final Collection getItems(){ - return Collections.unmodifiableCollection(getItemList()); - } - - @Override - public void addVendors(Collection vendors) { - change = true; - for (Vendor vendor : vendors) { - add(vendor); - } - } - - @Override - public void addItems(Collection items) { - change = true; - for (Item item : items) { - add(item); - } - } - - @Override - public void updateName(Vendor vendor, String name){ - change = true; - vendor.setName(name); - } - - @Override - public void updatePosition(Vendor vendor, double x, double y, double z){ - change = true; - vendor.setX(x); - vendor.setY(y); - vendor.setZ(z); - } - - @Override - public void updateName(Item item, String name){ - change = true; - item.setName(name); - } - - @Override - public void updatePrice(Offer offer, double price){ - change = true; - getStat(offer).update(offer, price); - } - - @Override - public void setChange(boolean change) { - this.change = change; - } - -} - diff --git a/core/src/main/java/ru/trader/core/Offer.java b/core/src/main/java/ru/trader/core/Offer.java index 7be37e0..6fe5a0f 100644 --- a/core/src/main/java/ru/trader/core/Offer.java +++ b/core/src/main/java/ru/trader/core/Offer.java @@ -1,44 +1,31 @@ package ru.trader.core; import org.jetbrains.annotations.NotNull; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; import java.util.Objects; -public abstract class Offer implements Comparable { - private final static Logger LOG = LoggerFactory.getLogger(Offer.class); +public interface Offer extends Comparable { - public abstract Item getItem(); + Item getItem(); + OFFER_TYPE getType(); + Vendor getVendor(); - public abstract OFFER_TYPE getType(); + double getPrice(); + void setPrice(double price); - public abstract double getPrice(); - protected abstract void setPrice(double price); + long getCount(); + void setCount(long count); - public abstract Vendor getVendor(); - protected abstract void setVendor(Vendor vendor); - - public boolean hasType(OFFER_TYPE offerType) { + default boolean hasType(OFFER_TYPE offerType) { return getType().equals(offerType); } - public boolean hasItem(Item item) { + default boolean hasItem(Item item) { return getItem().equals(item); } - public boolean equalsPrice(Offer offer){ - return equalsType(offer) && getPrice() == offer.getPrice(); - } - - public boolean equalsType(Offer offer){ - return offer != null && - getType().equals(offer.getType()) && - getItem().equals(offer.getItem()); - } - @Override - public int compareTo(@NotNull Offer other) { + default int compareTo(@NotNull Offer other) { Objects.requireNonNull(other, "Not compare with null"); if (this == other) return 0; int cmp = getType().compareTo(other.getType()); @@ -50,26 +37,12 @@ public abstract class Offer implements Comparable { return getItem().compareTo(other.getItem()); } - public String toVString(){ - return String.format("%s (%.0f)", getVendor().getName(), getPrice()); + default String toPString(){ + return String.format("%s (%.0f)", getVendor().getPlace().getName(), getPrice()); } - public String toIString(){ + default String toIString(){ return String.format("%s (%.0f)", getItem().getName(), getPrice()); } - @Override - public String toString() { - final StringBuilder sb = new StringBuilder("{"); - sb.append("").append(getVendor()); - sb.append(", ").append(getItem()); - sb.append(", ").append(getType()); - if (LOG.isTraceEnabled()){ - sb.append(", ").append(getPrice()); - } else { - sb.append(", ").append(getPrice()); - } - sb.append('}'); - return sb.toString(); - } } diff --git a/core/src/main/java/ru/trader/core/Order.java b/core/src/main/java/ru/trader/core/Order.java index ff34ef4..8a5a85d 100644 --- a/core/src/main/java/ru/trader/core/Order.java +++ b/core/src/main/java/ru/trader/core/Order.java @@ -19,7 +19,7 @@ public class Order implements Comparable { public Order(Offer sell, Offer buy, long count) { this.sell = sell; this.buy = buy; - this.count = count; + this.count = Math.min(Math.min(buy.getCount(), sell.getCount()), count); this.profit = (buy.getPrice() - sell.getPrice()) * count; } @@ -32,7 +32,7 @@ public class Order implements Comparable { } public void setCount(long count){ - this.count = count; + this.count = Math.min(Math.min(buy.getCount(), sell.getCount()), count); this.profit = (buy.getPrice() - sell.getPrice()) * count; } @@ -45,7 +45,11 @@ public class Order implements Comparable { } public double getDistance() { - return sell.getVendor().getDistance(buy.getVendor()); + return sell.getVendor().getPlace().getDistance(buy.getVendor().getPlace()) + buy.getVendor().getDistance() * 3.17e-8; + } + + public boolean isBuyer(Place buyer) { + return buy.getVendor().getPlace().equals(buyer); } public boolean isBuyer(Vendor buyer) { diff --git a/core/src/main/java/ru/trader/core/Place.java b/core/src/main/java/ru/trader/core/Place.java new file mode 100644 index 0000000..516cf76 --- /dev/null +++ b/core/src/main/java/ru/trader/core/Place.java @@ -0,0 +1,40 @@ +package ru.trader.core; + +import ru.trader.graph.Connectable; + +import java.util.Collection; + +public interface Place extends Connectable { + + String getName(); + void setName(String name); + + double getX(); + double getY(); + double getZ(); + void setPosition(double x, double y, double z); + + Collection get(); + void add(Vendor vendor); + Vendor addVendor(String name); + void remove(Vendor vendor); + + default boolean isEmpty(){ + return get().isEmpty(); + } + + @Override + default boolean canRefill() { + return !isEmpty(); + } + + @Override + default double getDistance(Place other){ + return getDistance(other.getX(), other.getY(), other.getZ()); + } + + default double getDistance(double x, double y, double z){ + return Math.sqrt(Math.pow(x - getX(), 2) + Math.pow(y - getY(), 2) + Math.pow(z - getZ(), 2)); + } + +} diff --git a/core/src/main/java/ru/trader/core/Route.java b/core/src/main/java/ru/trader/core/Route.java deleted file mode 100644 index 50e450c..0000000 --- a/core/src/main/java/ru/trader/core/Route.java +++ /dev/null @@ -1,25 +0,0 @@ -package ru.trader.core; - -import ru.trader.graph.Path; - -import java.util.LinkedList; - -public class Route { - private double profit; - private double distance; - private final LinkedList orders = new LinkedList<>(); - - public Route() { - profit = 0; - distance = 0; - } - - public void add(Order order){ - orders.add(order); - profit += order.getProfit(); - distance += order.getDistance(); - } - - - -} diff --git a/core/src/main/java/ru/trader/core/SERVICE_TYPE.java b/core/src/main/java/ru/trader/core/SERVICE_TYPE.java new file mode 100644 index 0000000..c3c548d --- /dev/null +++ b/core/src/main/java/ru/trader/core/SERVICE_TYPE.java @@ -0,0 +1,5 @@ +package ru.trader.core; + +public enum SERVICE_TYPE { + MARKET, BLACK_MARKET, REPAIR, MUNITION, OUTFIT, SHIPYARD +} diff --git a/core/src/main/java/ru/trader/core/Vendor.java b/core/src/main/java/ru/trader/core/Vendor.java index 2bd6861..97c4099 100644 --- a/core/src/main/java/ru/trader/core/Vendor.java +++ b/core/src/main/java/ru/trader/core/Vendor.java @@ -1,123 +1,65 @@ package ru.trader.core; import org.jetbrains.annotations.NotNull; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import ru.trader.graph.Connectable; import java.util.Collection; -import java.util.Collections; -import java.util.List; import java.util.Objects; -import java.util.stream.Collectors; -public abstract class Vendor implements Comparable, Connectable { - private final static Logger LOG = LoggerFactory.getLogger(Vendor.class); +public interface Vendor extends Comparable { - public abstract String getName(); - public abstract void setName(String name); + String getName(); + void setName(String name); - public abstract double getX(); - public abstract void setX(double x); + Place getPlace(); - public abstract double getY(); - public abstract void setY(double y); + double getDistance(); + void setDistance(double distance); - public abstract double getZ(); - public abstract void setZ(double z); + void add(SERVICE_TYPE service); + void remove(SERVICE_TYPE service); + boolean has(SERVICE_TYPE service); + void add(Offer offer); + Offer addOffer(OFFER_TYPE type, Item item, double price, long count); + void remove(Offer offer); - protected abstract Collection getOffers(); - protected abstract Collection getItems(OFFER_TYPE offerType); - protected abstract Offer getOffer(OFFER_TYPE offerType, Item item); - protected abstract boolean hasOffer(OFFER_TYPE offerType, Item item); - protected abstract void addOffer(Offer offer); - protected abstract void removeOffer(Offer offer); + Collection get(OFFER_TYPE type); + Offer get(OFFER_TYPE type, Item item); + boolean has(OFFER_TYPE type, Item item); - protected Collection getOffers(OFFER_TYPE offerType){ - List offers = getOffers() - .stream() - .filter(offer -> offer.hasType(offerType)) - .sorted() - .collect(Collectors.toList()); - return Collections.unmodifiableCollection(offers); + default Collection getAllSellOffers(){ + return get(OFFER_TYPE.SELL); } - public final Collection getAllOffers(){ - return Collections.unmodifiableCollection(getOffers()); + default Collection getAllBuyOffers(){ + return get(OFFER_TYPE.BUY); } - public final Collection getAllSellOffers(){ - return Collections.unmodifiableCollection(getOffers(OFFER_TYPE.SELL)); + default Offer getSell(Item item){ + return get(OFFER_TYPE.SELL, item); } - public final Collection getAllBuyOffers(){ - return Collections.unmodifiableCollection(getOffers(OFFER_TYPE.BUY)); + default Offer getBuy(Item item){ + return get(OFFER_TYPE.BUY, item); } - public final Offer getSell(Item item){ - return getOffer(OFFER_TYPE.SELL, item); + default boolean hasSell(Item item){ + return has(OFFER_TYPE.SELL, item); } - public final Offer getBuy(Item item){ - return getOffer(OFFER_TYPE.BUY, item); + default boolean hasBuy(Item item){ + return has(OFFER_TYPE.BUY, item); } - public final boolean hasSell(Item item){ - return hasOffer(OFFER_TYPE.SELL, item); - } - - public final boolean hasBuy(Item item){ - return hasOffer(OFFER_TYPE.BUY, item); - } - - public final void add(Offer offer){ - LOG.trace("Add offer {} to vendor {}", offer, this); - offer.setVendor(this); - addOffer(offer); - } - - public final void remove(Offer offer){ - LOG.trace("Remove offer {} from vendor {}", offer, this); - assert this.equals(offer.getVendor()); - removeOffer(offer); - } - - public final Collection getSellItems() { - return getItems(OFFER_TYPE.SELL); - } - - public final Collection getBuyItems() { - return getItems(OFFER_TYPE.BUY); - } @Override - public String toString() { - return getName(); - } - - @Override - public int compareTo(@NotNull Vendor other) { + default int compareTo(@NotNull Vendor other) { Objects.requireNonNull(other, "Not compare with null"); if (this == other) return 0; + int cmp = Double.compare(getDistance(), other.getDistance()); + if (cmp!=0) return cmp; String name = getName(); String otherName = other.getName(); return name != null ? otherName != null ? name.compareTo(otherName) : -1 : 0; } - - @Override - public double getDistance(Vendor other){ - return getDistance(other.getX(), other.getY(), other.getZ()); - } - - @Override - public boolean canRefill() { - return !getAllSellOffers().isEmpty() || !getAllBuyOffers().isEmpty(); - } - - public double getDistance(double x, double y, double z){ - return Math.sqrt(Math.pow(x - getX(), 2) + Math.pow(y - getY(), 2) + Math.pow(z - getZ(), 2)); - } - - } diff --git a/core/src/main/java/ru/trader/graph/PathRoute.java b/core/src/main/java/ru/trader/graph/PathRoute.java index f457da7..d785bc1 100644 --- a/core/src/main/java/ru/trader/graph/PathRoute.java +++ b/core/src/main/java/ru/trader/graph/PathRoute.java @@ -4,11 +4,12 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import ru.trader.core.Offer; import ru.trader.core.Order; +import ru.trader.core.Place; import ru.trader.core.Vendor; import java.util.*; -public class PathRoute extends Path { +public class PathRoute extends Path { private final static Logger LOG = LoggerFactory.getLogger(PathRoute.class); private final ArrayList orders = new ArrayList<>(); @@ -20,21 +21,21 @@ public class PathRoute extends Path { private PathRoute tail; public final static Order TRANSIT = null; - public PathRoute(Vertex source) { + public PathRoute(Vertex source) { this(source, false); } - public static PathRoute buildAvg(Vertex source){ + public static PathRoute buildAvg(Vertex source){ return new PathRoute(source, true); } - private PathRoute(Vertex source, boolean byAvg) { + private PathRoute(Vertex source, boolean byAvg) { super(source); this.byAvg = byAvg; } - private PathRoute(PathRoute head, Vertex vertex, boolean refill) { + private PathRoute(PathRoute head, Vertex vertex, boolean refill) { super(head, vertex, refill); assert head.tail == null; head.tail = this; @@ -44,7 +45,7 @@ public class PathRoute extends Path { } @Override - public Path connectTo(Vertex vertex, boolean refill) { + public Path connectTo(Vertex vertex, boolean refill) { LOG.trace("Connect path {} to {}", this, vertex); return new PathRoute(this.getCopy(), vertex, refill); } @@ -126,13 +127,27 @@ public class PathRoute extends Path { orders.clear(); orders.add(TRANSIT); LOG.trace("Fill orders of path {}", this); - Vendor seller = getPrevious().get(); - for (Offer sell : seller.getAllSellOffers()) { - PathRoute p = this; - while (p != null) { - Offer buy = p.get().getBuy(sell.getItem()); - if (buy != null) addOrder(new Order(sell, buy)); - p = p.getNext(); + Place placeSeller = getPrevious().get(); + for (Vendor seller : placeSeller.get()) { + for (Offer sell : seller.getAllSellOffers()) { + PathRoute p = this; + while (p != null) { + Place placeBuyer = p.get(); + Order best = null; + for (Vendor buyer : placeBuyer.get()) { + Offer buy = buyer.getBuy(sell.getItem()); + if (buy != null){ + Order order = new Order(sell, buy); + if (best == null || best.compareTo(order) < 0){ + best = order; + } + } + } + if (best != null){ + addOrder(best); + } + p = p.getNext(); + } } } } @@ -210,7 +225,7 @@ public class PathRoute extends Path { PathRoute p = getPrevious(); balance = p.balance; if (!p.isRoot()) { - Vendor buyer = p.get(); + Place buyer = p.get(); while (!p.isRoot()){ for (Order order : p.orders) { if (order == TRANSIT) continue; @@ -252,7 +267,7 @@ public class PathRoute extends Path { public double getProfit(Order order){ if (order == TRANSIT) return getTransitProfit(); - if (isPathFrom(order.getBuyer())) return order.getProfit() + profit; + if (isPathFrom(order.getBuyer().getPlace())) return order.getProfit() + profit; return hasNext() ? getNext().getProfit(order) : order.getProfit(); } @@ -325,7 +340,7 @@ public class PathRoute extends Path { while (p.hasNext()){ p = p.getNext(); // lands for sell - if (order != null && p.isPathFrom(order.getBuyer())){ + if (order != null && p.isPathFrom(order.getBuyer().getPlace())){ LOG.trace("{} is lands for sell by order {}", p, order); return res + p.getLandsCount() + 1; } else { @@ -388,15 +403,15 @@ public class PathRoute extends Path { public PathRoute dropTo(Vendor vendor){ PathRoute p = getCopy(true).getEnd(); - while (!p.isRoot() && !p.get().equals(vendor)){ + while (!p.isRoot() && !p.get().equals(vendor.getPlace())){ p = p.getPrevious(); } p.tail = null; return p; } - public static PathRoute toPathRoute(Vendor... items){ - Vendor t = items[0]; + public static PathRoute toPathRoute(Place... items){ + Place t = items[0]; PathRoute path = new PathRoute(new Vertex<>(t)); for (int i = 1; i < items.length; i++) { t = items[i]; diff --git a/core/src/main/java/ru/trader/graph/RouteGraph.java b/core/src/main/java/ru/trader/graph/RouteGraph.java index 26e9cb2..0171be4 100644 --- a/core/src/main/java/ru/trader/graph/RouteGraph.java +++ b/core/src/main/java/ru/trader/graph/RouteGraph.java @@ -1,10 +1,10 @@ package ru.trader.graph; -import ru.trader.core.Vendor; +import ru.trader.core.Place; import java.util.*; -public class RouteGraph extends Graph { +public class RouteGraph extends Graph { private double balance; private int cargo; @@ -28,11 +28,11 @@ public class RouteGraph extends Graph { return byProfitComparator.compare(p1, p2); }; - public RouteGraph(Vendor start, Collection set, double stock, double maxDistance, boolean withRefill, int maxDeep) { + public RouteGraph(Place start, Collection set, double stock, double maxDistance, boolean withRefill, int maxDeep) { this(start, set, stock, maxDistance, withRefill, maxDeep, false); } - public RouteGraph(Vendor start, Collection set, double stock, double maxDistance, boolean withRefill, int maxDeep, boolean groupRes) { + public RouteGraph(Place start, Collection set, double stock, double maxDistance, boolean withRefill, int maxDeep, boolean groupRes) { super(start, set, stock, maxDistance, withRefill, maxDeep, groupRes ? PathRoute::buildAvg : PathRoute::new); if (groupRes){ this.groupRes = maxDeep > minJumps; @@ -48,7 +48,7 @@ public class RouteGraph extends Graph { } @Override - protected TopList> newTopList(int count) { + protected TopList> newTopList(int count) { int groupSize = 0; if (groupRes && getMinJumps() > 1){ groupSize = Math.floorDiv(count, root.getLevel()); @@ -56,7 +56,7 @@ public class RouteGraph extends Graph { return new TopRoutes(count, groupSize); } - private class TopRoutes extends TopList> { + private class TopRoutes extends TopList> { private final int groupSize; public TopRoutes(int limit, int groupSize) { @@ -65,7 +65,7 @@ public class RouteGraph extends Graph { } @Override - public boolean add(Path entry) { + public boolean add(Path entry) { if (comparator != null){ ((PathRoute)entry).sort(balance, cargo); } diff --git a/core/src/main/java/ru/trader/graph/RouteSearcher.java b/core/src/main/java/ru/trader/graph/RouteSearcher.java index d81be8e..219b393 100644 --- a/core/src/main/java/ru/trader/graph/RouteSearcher.java +++ b/core/src/main/java/ru/trader/graph/RouteSearcher.java @@ -3,7 +3,7 @@ package ru.trader.graph; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import ru.trader.core.Vendor; +import ru.trader.core.Place; import java.util.ArrayList; import java.util.Collection; @@ -29,27 +29,27 @@ public class RouteSearcher { this.segmentSize = segmentSize; } - public List getPaths(Vendor from, Vendor to, Collection vendors, int jumps, double balance, int cargo, int limit){ - return POOL.invoke(new SegmentSearcher(from, to, vendors, jumps, balance, cargo, limit)); + public List getPaths(Place from, Place to, Collection places, int jumps, double balance, int cargo, int limit){ + return POOL.invoke(new SegmentSearcher(from, to, places, jumps, balance, cargo, limit)); } - public List getPaths(Vendor from, Collection vendors, int jumps, double balance, int cargo, int limit){ - return POOL.invoke(new SegmentSearcher(from, null, vendors, jumps, balance, cargo, limit)); + public List getPaths(Place from, Collection places, int jumps, double balance, int cargo, int limit){ + return POOL.invoke(new SegmentSearcher(from, null, places, jumps, balance, cargo, limit)); } public class SegmentSearcher extends RecursiveTask> { - protected final Vendor source; - protected final Vendor target; - protected final Collection vendors; + protected final Place source; + protected final Place target; + protected final Collection places; protected final int jumps; protected final double balance; protected final int cargo; protected int limit; - public SegmentSearcher(Vendor source, Vendor target, Collection vendors, int jumps, double balance, int cargo, int limit) { + public SegmentSearcher(Place source, Place target, Collection places, int jumps, double balance, int cargo, int limit) { this.source = source; this.target = target; - this.vendors = vendors; + this.places = places; this.jumps = jumps; this.balance = balance; this.cargo = cargo; @@ -59,7 +59,7 @@ public class RouteSearcher { @Override protected List compute() { LOG.trace("Start search route to {} from {}, jumps {}", source, target, jumps); - RouteGraph sGraph = new RouteGraph(source, vendors, stock, maxDistance, true, jumps, true); + RouteGraph sGraph = new RouteGraph(source, places, stock, maxDistance, true, jumps, true); int jumpsToAll = sGraph.getMinJumps(); LOG.trace("Segment jumps {}", jumpsToAll); sGraph.setCargo(cargo); @@ -67,18 +67,18 @@ public class RouteSearcher { List res = new ArrayList<>(limit); if (jumps <= jumpsToAll){ LOG.trace("Is last segment"); - List> paths; + List> paths; if (target == null){ paths = sGraph.getPaths(limit); } else { paths = sGraph.getPathsTo(target, limit); } - for (Path path : paths) { + for (Path path : paths) { res.add((PathRoute) path); } } else { LOG.trace("Split to segments"); - List> paths = sGraph.getPaths(getPathsOnSegmentCount(sGraph), jumpsToAll-1).getList(); + List> paths = sGraph.getPaths(getPathsOnSegmentCount(sGraph), jumpsToAll-1).getList(); int i = 0; ArrayList subTasks = new ArrayList<>(THRESHOLD); while (i < paths.size()) { @@ -86,7 +86,7 @@ public class RouteSearcher { for (int taskIndex = 0; taskIndex < THRESHOLD && i+taskIndex < paths.size(); taskIndex++) { PathRoute path = (PathRoute) paths.get(i+taskIndex); double newBalance = balance + path.getRoot().getProfit(); - SegmentSearcher task = new SegmentSearcher(path.get(), target, vendors, jumps - path.getLength(), newBalance, cargo, 1); + SegmentSearcher task = new SegmentSearcher(path.get(), target, places, jumps - path.getLength(), newBalance, cargo, 1); task.fork(); subTasks.add(task); } diff --git a/core/src/main/java/ru/trader/store/simple/MarketDocHandler.java b/core/src/main/java/ru/trader/store/simple/MarketDocHandler.java index 6fcf982..4474d9e 100644 --- a/core/src/main/java/ru/trader/store/simple/MarketDocHandler.java +++ b/core/src/main/java/ru/trader/store/simple/MarketDocHandler.java @@ -16,7 +16,7 @@ public class MarketDocHandler extends DefaultHandler { protected final static String MARKET = "market"; protected final static String ITEM_LIST = "items"; protected final static String ITEM = "item"; - protected final static String VENDOR_LIST = "vendors"; + protected final static String VENDOR_LIST = "places"; protected final static String VENDOR = "vendor"; protected final static String OFFER = "offer"; protected final static String GROUP = "group"; @@ -30,8 +30,9 @@ public class MarketDocHandler extends DefaultHandler { protected final static String Y_ATTR = "y"; protected final static String Z_ATTR = "z"; - protected Market world; + protected SimpleMarket world; protected Vendor curVendor; + protected Place curSystem; protected Group curGroup; protected final HashMap items = new HashMap<>(); @@ -57,7 +58,7 @@ public class MarketDocHandler extends DefaultHandler { @Override public void endElement(String uri, String localName, String qName) throws SAXException { switch (qName){ - case VENDOR: world.add(curVendor); + case VENDOR: curVendor = null; curSystem = null; break; case GROUP: curGroup = null; break; @@ -66,7 +67,7 @@ public class MarketDocHandler extends DefaultHandler { @Override public void endDocument() throws SAXException { - world.setChange(false); + world.commit(); } protected void parseVendor(Attributes attributes) throws SAXException { @@ -103,26 +104,24 @@ public class MarketDocHandler extends DefaultHandler { } protected void onOffer(OFFER_TYPE offerType, Item item, double price){ - Offer offer = new SimpleOffer(offerType, item, price); - curVendor.add(offer); + if (curVendor == null){ + curVendor = curSystem.addVendor("STATION OF "+curSystem.getName()); + curVendor.add(SERVICE_TYPE.MARKET); + } + curVendor.addOffer(offerType, item, price, 1000); } protected void onVendor(String name, double x, double y, double z){ - curVendor = new SimpleVendor(name); - curVendor.setX(x); - curVendor.setY(y); - curVendor.setZ(z); + curSystem = world.addPlace(name, x, y, z); } protected void onItem(String name, String id) { - Item item = new SimpleItem(name); - item.setGroup(curGroup); - world.add(item); + Item item = world.addItem(name, curGroup); items.put(id, item); } protected void onGroup(String name, GROUP_TYPE type) { - curGroup = new SimpleGroup(name, type); + curGroup = world.addGroup(name, type); } public Market getWorld(){ diff --git a/core/src/main/java/ru/trader/store/simple/MarketStreamWriter.java b/core/src/main/java/ru/trader/store/simple/MarketStreamWriter.java index 2b18188..0fd15c2 100644 --- a/core/src/main/java/ru/trader/store/simple/MarketStreamWriter.java +++ b/core/src/main/java/ru/trader/store/simple/MarketStreamWriter.java @@ -42,7 +42,7 @@ public class MarketStreamWriter { protected void writeMarket() throws XMLStreamException { out.writeStartElement(MarketDocHandler.MARKET); writeItems(); - writeVendors(market.get()); + writeVendors(); out.writeEndElement(); } @@ -68,10 +68,12 @@ public class MarketStreamWriter { out.writeAttribute(MarketDocHandler.ID_ATTR, id); } - protected void writeVendors(Collection vendors) throws XMLStreamException { + protected void writeVendors() throws XMLStreamException { out.writeStartElement(MarketDocHandler.VENDOR_LIST); - for (Vendor vendor : vendors) { - writeVendor(vendor); + for (Place place : market.get()) { + for (Vendor vendor : place.get()) { + writeVendor(vendor); + } } out.writeEndElement(); } @@ -79,11 +81,14 @@ public class MarketStreamWriter { protected void writeVendor(Vendor vendor) throws XMLStreamException { out.writeStartElement(MarketDocHandler.VENDOR); out.writeAttribute(MarketDocHandler.NAME_ATTR, vendor.getName()); - out.writeAttribute(MarketDocHandler.X_ATTR, String.valueOf(vendor.getX())); - out.writeAttribute(MarketDocHandler.Y_ATTR, String.valueOf(vendor.getY())); - out.writeAttribute(MarketDocHandler.Z_ATTR, String.valueOf(vendor.getZ())); - - for (Offer offer : vendor.getAllOffers()) { + Place place = vendor.getPlace(); + out.writeAttribute(MarketDocHandler.X_ATTR, String.valueOf(place.getX())); + out.writeAttribute(MarketDocHandler.Y_ATTR, String.valueOf(place.getY())); + out.writeAttribute(MarketDocHandler.Z_ATTR, String.valueOf(place.getZ())); + for (Offer offer : vendor.getAllSellOffers()) { + writeOffer(offer); + } + for (Offer offer : vendor.getAllBuyOffers()) { writeOffer(offer); } out.writeEndElement(); diff --git a/core/src/main/java/ru/trader/store/simple/SimpleGroup.java b/core/src/main/java/ru/trader/store/simple/SimpleGroup.java index 374ab54..10d685c 100644 --- a/core/src/main/java/ru/trader/store/simple/SimpleGroup.java +++ b/core/src/main/java/ru/trader/store/simple/SimpleGroup.java @@ -3,7 +3,7 @@ package ru.trader.store.simple; import ru.trader.core.GROUP_TYPE; import ru.trader.core.Group; -public class SimpleGroup extends Group { +public class SimpleGroup implements Group { private final String name; private final GROUP_TYPE type; diff --git a/core/src/main/java/ru/trader/store/simple/SimpleItem.java b/core/src/main/java/ru/trader/store/simple/SimpleItem.java index f1075df..edf810c 100644 --- a/core/src/main/java/ru/trader/store/simple/SimpleItem.java +++ b/core/src/main/java/ru/trader/store/simple/SimpleItem.java @@ -1,9 +1,9 @@ package ru.trader.store.simple; +import ru.trader.core.AbstractItem; import ru.trader.core.Group; -import ru.trader.core.Item; -public class SimpleItem extends Item { +public class SimpleItem extends AbstractItem { private String name; private Group group; @@ -11,13 +11,18 @@ public class SimpleItem extends Item { this.name = name; } + public SimpleItem(String name, Group group) { + this.name = name; + setGroup(group); + } + @Override public String getName() { return name; } @Override - protected void setName(String name) { + public void updateName(String name) { this.name = name; } @@ -26,8 +31,7 @@ public class SimpleItem extends Item { return group; } - @Override - public void setGroup(Group group) { + protected void setGroup(Group group) { this.group = group; } } diff --git a/core/src/main/java/ru/trader/store/simple/SimpleItemStat.java b/core/src/main/java/ru/trader/store/simple/SimpleItemStat.java index 1ecbfca..90da4cf 100644 --- a/core/src/main/java/ru/trader/store/simple/SimpleItemStat.java +++ b/core/src/main/java/ru/trader/store/simple/SimpleItemStat.java @@ -2,15 +2,12 @@ package ru.trader.store.simple; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import ru.trader.core.Item; -import ru.trader.core.ItemStat; -import ru.trader.core.OFFER_TYPE; -import ru.trader.core.Offer; +import ru.trader.core.*; import java.util.*; import java.util.concurrent.ConcurrentSkipListSet; -public class SimpleItemStat extends ItemStat { +public class SimpleItemStat extends AbstractItemStat { private final static Logger LOG = LoggerFactory.getLogger(SimpleItemStat.class); private final Item item; @@ -55,12 +52,14 @@ public class SimpleItemStat extends ItemStat { } @Override - protected synchronized void update(Offer offer, double price){ + protected synchronized void updatePrice(AbstractOffer offer, double price) { LOG.trace("Update offer {} from item stat {}", offer, this); assert offer.hasType(type) && offer.hasItem(item) && offers.contains(offer); double oldPrice = offer.getPrice(); offers.remove(offer); - ((SimpleOffer)offer).setPrice(price); + + super.updatePrice(offer, price); + offers.add(offer); sum += price - oldPrice; avg = sum / offers.size(); @@ -77,33 +76,17 @@ public class SimpleItemStat extends ItemStat { return item; } - @Override - public synchronized double getAvg(){ - return avg; - } - - @Override - public synchronized Offer getBest() { - if (offers.isEmpty()) return getFake(); - return type.getOrder() > 0 ? offers.first() : offers.last(); - } - - @Override - public synchronized int getOffersCount(){ - return offers.size(); - } - - @Override - public synchronized NavigableSet getOffers() { - return Collections.unmodifiableNavigableSet(offers); - } - @Override public synchronized Offer getMin() { if (offers.isEmpty()) return getFake(); return offers.first(); } + @Override + public synchronized double getAvg(){ + return avg; + } + @Override public synchronized Offer getMax() { if (offers.isEmpty()) return getFake(); @@ -111,10 +94,38 @@ public class SimpleItemStat extends ItemStat { } @Override - public synchronized boolean isEmpty(){ + public synchronized Offer getBest() { + if (offers.isEmpty()) return getFake(); + return type.getOrder() > 0 ? offers.first() : offers.last(); + } + + @Override + public synchronized NavigableSet getOffers() { + return Collections.unmodifiableNavigableSet(offers); + } + + @Override + public synchronized boolean isEmpty() { return offers.isEmpty(); } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof SimpleItemStat)) return false; + + SimpleItemStat itemStat = (SimpleItemStat) o; + return type == itemStat.type && item.equals(itemStat.item); + } + + @Override + public int hashCode() { + int result = item.hashCode(); + result = 31 * result + type.hashCode(); + return result; + } + @Override public String toString() { final StringBuilder sb = new StringBuilder("{"); diff --git a/core/src/main/java/ru/trader/store/simple/SimpleMarket.java b/core/src/main/java/ru/trader/store/simple/SimpleMarket.java index 9af5095..2461997 100644 --- a/core/src/main/java/ru/trader/store/simple/SimpleMarket.java +++ b/core/src/main/java/ru/trader/store/simple/SimpleMarket.java @@ -1,13 +1,17 @@ package ru.trader.store.simple; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import ru.trader.core.*; import java.util.*; -import java.util.stream.Collectors; -public class SimpleMarket extends MarketSupport { - protected Set vendors; +public class SimpleMarket extends AbstractMarket { + private final static Logger LOG = LoggerFactory.getLogger(SimpleMarket.class); + + protected Set systems; protected List items; + protected List groups; //caching private final Map sellItems = new HashMap<>(); @@ -18,8 +22,9 @@ public class SimpleMarket extends MarketSupport { } protected void init() { - vendors = new TreeSet<>(); + systems = new TreeSet<>(); items = new ArrayList<>(); + groups = new ArrayList<>(); } private Map getItemCache(OFFER_TYPE offerType){ @@ -46,14 +51,89 @@ public class SimpleMarket extends MarketSupport { SimpleItemStat entry = cache.get(item); if (entry!=null){ entry.remove(offer); - if (entry.getOffersCount()==0) + if (entry.isEmpty()) cache.remove(item); } } @Override - public void addVendor(Vendor vendor) { - vendors.add(vendor); + protected Place createPlace(String name, double x, double y, double z) { + return new SimplePlace(name, x, y, z); + } + + @Override + protected Group createGroup(String name, GROUP_TYPE type) { + return new SimpleGroup(name, type); + } + + @Override + protected Item createItem(String name, Group group) { + return new SimpleItem(name, group); + } + + @Override + protected void addPlace(Place place) { + systems.add(place); + for (Vendor vendor : place.get()) { + onAdd(vendor); + } + } + + @Override + protected void removePlace(Place place) { + systems.remove(place); + for (Vendor vendor : place.get()) { + onRemove(vendor); + } + } + + @Override + protected void addGroup(Group group) { + groups.add(group); + } + + @Override + protected void removeGroup(Group group) { + groups.remove(group); + } + + @Override + protected void addItem(Item item) { + items.add(item); + } + + @Override + protected void removeItem(Item item) { + items.remove(item); + sellItems.remove(item); + buyItems.remove(item); + } + + @Override + public Collection get() { + return systems; + } + + @Override + public Collection getGroups() { + return groups; + } + + @Override + public Collection getItems() { + return items; + + } + + @Override + public ItemStat getStat(OFFER_TYPE offerType, Item item) { + ItemStat entry = getItemCache(offerType).get(item); + return entry != null ? entry : new SimpleItemStat(item, offerType); + } + + @Override + protected void onAdd(Vendor vendor) { + LOG.trace("Cached on add vendor {}", vendor); Collection offers = vendor.getAllSellOffers(); for (Offer offer : offers) { put(sellItems, offer); @@ -65,8 +145,8 @@ public class SimpleMarket extends MarketSupport { } @Override - public void removeVendor(Vendor vendor) { - vendors.remove(vendor); + protected void onRemove(Vendor vendor) { + LOG.trace("Remove cache of vendor {}", vendor); Collection offers = vendor.getAllSellOffers(); for (Offer offer : offers) { remove(sellItems, offer); @@ -77,63 +157,24 @@ public class SimpleMarket extends MarketSupport { } } - @Override - protected void addItem(Item item) { - if (!items.contains(item)) - items.add(item); - } - - @Override - protected void removeItem(Item item) { - items.remove(item); - sellItems.remove(item); - buyItems.remove(item); - } - - @Override - protected Collection getVendors() { - return vendors; - } - - @Override - protected Collection getVendors(OFFER_TYPE offerType, Item item) { - List result = null; - ItemStat entry = getItemCache(offerType).get(item); - if (entry!=null){ - result = entry.getOffers() - .stream() - .map(Offer::getVendor) - .collect(Collectors.toList()); - } - - return result!=null ? Collections.unmodifiableCollection(result) : null; - } - - @Override - public ItemStat getStat(OFFER_TYPE offerType, Item item) { - ItemStat entry = getItemCache(offerType).get(item); - return entry != null ? entry : new SimpleItemStat(item, offerType); - } - - @Override - protected Collection getItemList() { - return items; - - } - @Override protected void onAdd(Offer offer) { + LOG.trace("Cached on add offer {}", offer); put(getItemCache(offer.getType()), offer); } @Override protected void onRemove(Offer offer) { + LOG.trace("Remove cache of offer {}", offer); remove(getItemCache(offer.getType()), offer); } @Override - public void addItems(Collection items) { - this.items.addAll(items); + protected void updateName(AbstractPlace place, String name) { + LOG.trace("Replace system {} on change name", place); + systems.remove(place); + super.updateName(place, name); + systems.add(place); } } diff --git a/core/src/main/java/ru/trader/store/simple/SimpleOffer.java b/core/src/main/java/ru/trader/store/simple/SimpleOffer.java index 3b174eb..9906d4f 100644 --- a/core/src/main/java/ru/trader/store/simple/SimpleOffer.java +++ b/core/src/main/java/ru/trader/store/simple/SimpleOffer.java @@ -2,23 +2,22 @@ package ru.trader.store.simple; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import ru.trader.core.Item; -import ru.trader.core.OFFER_TYPE; -import ru.trader.core.Offer; -import ru.trader.core.Vendor; +import ru.trader.core.*; -public class SimpleOffer extends Offer { +public class SimpleOffer extends AbstractOffer { private final static Logger LOG = LoggerFactory.getLogger(SimpleOffer.class); private Vendor vendor; private final Item item; private final OFFER_TYPE type; private volatile double price; + private volatile long count; - public SimpleOffer(OFFER_TYPE type, Item item, double price) { + public SimpleOffer(OFFER_TYPE type, Item item, double price, long count) { this.item = item; this.type = type; - setPrice(price); + this.price = price; + this.count = count; } @Override @@ -31,25 +30,35 @@ public class SimpleOffer extends Offer { return type; } + @Override + public Vendor getVendor() { + return vendor; + } + + protected void setVendor(Vendor vendor) { + assert this.vendor == null; + LOG.trace("Set vendor {} to offer {}", vendor, this); + this.vendor = vendor; + } + @Override public double getPrice() { return price; } @Override - protected void setPrice(double price) { + protected void updatePrice(double price) { this.price = price; } @Override - public Vendor getVendor() { - return vendor; + public long getCount() { + return count; } @Override - protected void setVendor(Vendor vendor) { - LOG.trace("Set vendor {} to item {}", vendor, this); - this.vendor = vendor; + public void updateCount(long count) { + this.count = count; } } diff --git a/core/src/main/java/ru/trader/store/simple/SimplePlace.java b/core/src/main/java/ru/trader/store/simple/SimplePlace.java new file mode 100644 index 0000000..f2e2a71 --- /dev/null +++ b/core/src/main/java/ru/trader/store/simple/SimplePlace.java @@ -0,0 +1,88 @@ +package ru.trader.store.simple; + +import ru.trader.core.AbstractPlace; +import ru.trader.core.Vendor; + +import java.util.Collection; +import java.util.List; +import java.util.concurrent.CopyOnWriteArrayList; + +public class SimplePlace extends AbstractPlace { + private String name; + private final List vendors; + + private double x; + private double y; + private double z; + + public SimplePlace(String name) { + this.name = name; + this.vendors = new CopyOnWriteArrayList<>(); + } + + public SimplePlace(String name, double x, double y, double z) { + this(name); + setPosition(x, y, z); + } + + public SimplePlace(String name, double x, double y, double z, Vendor vendor) { + this(name,x,y,z); + vendors.add(vendor); + } + + @Override + protected Vendor createVendor(String name) { + return new SimpleVendor(name); + } + + @Override + public String getName() { + return name; + } + + @Override + public double getX() { + return x; + } + + @Override + public double getY() { + return y; + } + + @Override + public double getZ() { + return z; + } + + @Override + public Collection get() { + return vendors; + } + + @Override + protected void updateName(String name) { + this.name = name; + } + + @Override + protected void updatePosition(double x, double y, double z) { + this.x = x; + this.y = y; + this.z = z; + } + + @Override + protected void addVendor(Vendor vendor) { + if (vendor instanceof SimpleVendor){ + ((SimpleVendor) vendor).setPlace(this); + } + vendors.add(vendor); + } + + @Override + protected void removeVendor(Vendor vendor) { + vendors.remove(vendor); + } + +} diff --git a/core/src/main/java/ru/trader/store/simple/SimpleVendor.java b/core/src/main/java/ru/trader/store/simple/SimpleVendor.java index d926d47..fc9b453 100644 --- a/core/src/main/java/ru/trader/store/simple/SimpleVendor.java +++ b/core/src/main/java/ru/trader/store/simple/SimpleVendor.java @@ -1,18 +1,15 @@ package ru.trader.store.simple; -import ru.trader.core.Item; -import ru.trader.core.OFFER_TYPE; -import ru.trader.core.Offer; -import ru.trader.core.Vendor; +import ru.trader.core.*; import java.util.*; import java.util.concurrent.ConcurrentHashMap; -public class SimpleVendor extends Vendor { +public class SimpleVendor extends AbstractVendor { private String name; - private double x; - private double y; - private double z; + private Place place; + private double distance; + private EnumSet services = EnumSet.noneOf(SERVICE_TYPE.class); protected Map sell; protected Map buy; @@ -26,53 +23,68 @@ public class SimpleVendor extends Vendor { initOffers(); } + public SimpleVendor(String name, double x, double y, double z) { + this(name); + place = new SimplePlace(name, x, y, z, this); + } + protected void initOffers(){ sell = new ConcurrentHashMap<>(20, 0.9f, 2); buy = new ConcurrentHashMap<>(20, 0.9f, 2); } + @Override + protected Offer createOffer(OFFER_TYPE type, Item item, double price, long count) { + return new SimpleOffer(type, item, price, count); + } + @Override public String getName() { return name; } @Override - public void setName(String name) { + protected void updateName(String name) { this.name = name; } @Override - public double getX() { - return x; + public Place getPlace() { + return place; + } + + protected void setPlace(Place place){ + assert this.place == null; + this.place = place; } @Override - public void setX(double x) { - this.x = x; + public double getDistance() { + return distance; } @Override - public double getY() { - return y; + public void updateDistance(double distance) { + this.distance = distance; } @Override - public void setY(double y) { - this.y = y; + public void addService(SERVICE_TYPE service) { + services.add(service); } @Override - public double getZ() { - return z; + public void removeService(SERVICE_TYPE service) { + services.remove(service); } @Override - public void setZ(double z) { - this.z = z; + public boolean has(SERVICE_TYPE service) { + return services.contains(service); } @Override - protected Collection getOffers(OFFER_TYPE offerType) { + public Collection get(OFFER_TYPE offerType) { switch (offerType) { case SELL: return sell.values(); case BUY: return buy.values(); @@ -81,23 +93,7 @@ public class SimpleVendor extends Vendor { } @Override - protected Collection getOffers() { - ArrayList offers = new ArrayList<>(sell.values()); - offers.addAll(buy.values()); - return offers; - } - - @Override - protected Collection getItems(OFFER_TYPE offerType) { - switch (offerType) { - case SELL: return sell.keySet(); - case BUY: return buy.keySet(); - } - throw new IllegalArgumentException("Wrong offer type: "+offerType); - } - - @Override - protected Offer getOffer(OFFER_TYPE offerType, Item item) { + public Offer get(OFFER_TYPE offerType, Item item) { switch (offerType) { case SELL: return sell.get(item); case BUY: return buy.get(item); @@ -106,7 +102,7 @@ public class SimpleVendor extends Vendor { } @Override - protected boolean hasOffer(OFFER_TYPE offerType, Item item) { + public boolean has(OFFER_TYPE offerType, Item item) { switch (offerType) { case SELL: return sell.containsKey(item); case BUY: return buy.containsKey(item); @@ -116,6 +112,9 @@ public class SimpleVendor extends Vendor { @Override protected void addOffer(Offer offer) { + if (offer instanceof SimpleOffer){ + ((SimpleOffer) offer).setVendor(this); + } switch (offer.getType()) { case SELL: sell.put(offer.getItem(), offer); break; diff --git a/core/src/main/resources/store/trader.xsd b/core/src/main/resources/store/trader.xsd index 3a12be1..6fe76e6 100644 --- a/core/src/main/resources/store/trader.xsd +++ b/core/src/main/resources/store/trader.xsd @@ -6,7 +6,7 @@ - + diff --git a/core/src/test/java/ru/trader/core/MarketAnalyzerTest.java b/core/src/test/java/ru/trader/core/MarketAnalyzerTest.java index e3d2eea..79d16f7 100644 --- a/core/src/test/java/ru/trader/core/MarketAnalyzerTest.java +++ b/core/src/test/java/ru/trader/core/MarketAnalyzerTest.java @@ -8,10 +8,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import ru.trader.TestUtil; import ru.trader.graph.Path; -import ru.trader.store.simple.SimpleItem; -import ru.trader.store.simple.SimpleMarket; -import ru.trader.store.simple.SimpleOffer; -import ru.trader.store.simple.SimpleVendor; +import ru.trader.store.simple.*; import java.util.Collection; @@ -19,47 +16,43 @@ public class MarketAnalyzerTest extends Assert { private final static Logger LOG = LoggerFactory.getLogger(MarketAnalyzerTest.class); private static Market market = new SimpleMarket(); - private static Vendor v1; - private static Vendor v2; - private static Vendor v3; - private static Vendor v4; - private static Vendor v5; - private static Vendor v6; - private static Vendor v7; - private static Vendor v8; - private static Vendor v9; - private static Vendor v10; - private static Vendor v11; + private static Place v1; + private static Place v2; + private static Place v3; + private static Place v4; + private static Place v5; + private static Place v6; + private static Place v7; + private static Place v8; + private static Place v9; + private static Place v10; + private static Place v11; private static Item ITEM1 = new SimpleItem("ITEM1"); private static Item ITEM2 = new SimpleItem("ITEM2"); private static Item ITEM3 = new SimpleItem("ITEM3"); + private void add(Place place, Offer offer){ + if (place.isEmpty()){ + place.add(new SimpleVendor()); + } + Vendor vendor = place.get().iterator().next(); + vendor.add(offer); + } + @Before public void setUp() throws Exception { - v1 = new SimpleVendor("v1_x0y0z0"); - v2 = new SimpleVendor("v2_x1y0z0"); - v3 = new SimpleVendor("v3_x0y1z0"); - v4 = new SimpleVendor("v4_x0y0z1"); - v5 = new SimpleVendor("v5_x1y1z0"); + v1 = new SimplePlace("v1_x0y0z0",0,0,0); + v2 = new SimplePlace("v2_x1y0z0",1,0,0); + v3 = new SimplePlace("v3_x0y1z0",0,1,0); + v4 = new SimplePlace("v4_x0y0z1",0,0,1); + v5 = new SimplePlace("v5_x1y1z0",1,1,0); - v6 = new SimpleVendor("v6_x110y100z100"); - v7 = new SimpleVendor("v7_x115y100z100"); - v8 = new SimpleVendor("v8_x105y105z100"); - v9 = new SimpleVendor("v9_x100y115z100"); - v10 = new SimpleVendor("v10_x100y100z100"); - v11 = new SimpleVendor("v11_x105y105z105"); - - v1.setX(0); v1.setY(0); v1.setZ(0); - v2.setX(1); v2.setY(0); v2.setZ(0); - v3.setX(0); v3.setY(1); v3.setZ(0); - v4.setX(0); v4.setY(0); v4.setZ(1); - v5.setX(1); v5.setY(1); v5.setZ(0); - v6.setX(110); v6.setY(100); v6.setZ(100); - v7.setX(115); v7.setY(100); v7.setZ(100); - v8.setX(105); v8.setY(105); v8.setZ(100); - v9.setX(100); v9.setY(115); v9.setZ(100); - v10.setX(100); v10.setY(100); v10.setZ(100); - v11.setX(105); v11.setY(105); v11.setZ(105); + v6 = new SimplePlace("v6_x110y100z100",110,100,100); + v7 = new SimplePlace("v7_x115y100z100",115,100,100); + v8 = new SimplePlace("v8_x105y105z100",105,105,100); + v9 = new SimplePlace("v9_x100y115z100",100,115,100); + v10 = new SimplePlace("v10_x100y100z100",100,100,100); + v11 = new SimplePlace("v11_x105y105z105",105,105,105); market.add(v1); market.add(v2); @@ -73,19 +66,19 @@ public class MarketAnalyzerTest extends Assert { market.add(v10); market.add(v11); - market.add(v6, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100)); - market.add(v7, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100)); - market.add(v9, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100)); - market.add(v10, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100)); - market.add(v6, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 50)); - market.add(v7, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 120)); - market.add(v9, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200)); - market.add(v10, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 150)); - market.add(v9, new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 100)); - market.add(v6, new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 140)); - market.add(v7, new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 154)); - market.add(v10, new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 140)); - market.add(v11, new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 500)); + add(v6, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1)); + add(v7, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1)); + add(v9, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1)); + add(v10, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1)); + add(v6, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 50, 1)); + add(v7, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 120, 1)); + add(v9, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, 1)); + add(v10, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 150, 1)); + add(v9, new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 100, 1)); + add(v6, new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 140, 1)); + add(v7, new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 154, 1)); + add(v10, new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 140, 1)); + add(v11, new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 500, 1)); } @@ -96,7 +89,7 @@ public class MarketAnalyzerTest extends Assert { MarketAnalyzer analyzer = new MarketAnalyzer(market); analyzer.setJumps(5);analyzer.setMaxDistance(1);analyzer.setTank(1); - Collection> paths = analyzer.getPaths(v1, v2); + Collection> paths = analyzer.getPaths(v1, v2); TestUtil.assertCollectionEquals(paths, Path.toPath(v1, v2)); paths = analyzer.getPaths(v1, v3); @@ -121,7 +114,7 @@ public class MarketAnalyzerTest extends Assert { MarketAnalyzer analyzer = new MarketAnalyzer(market); analyzer.setJumps(5);analyzer.setMaxDistance(1);analyzer.setTank(2); - Collection> paths = analyzer.getPaths(v1, v2); + Collection> paths = analyzer.getPaths(v1, v2); TestUtil.assertCollectionContainAll(paths, Path.toPath(v1, v2)); paths = analyzer.getPaths(v1, v3); @@ -147,7 +140,7 @@ public class MarketAnalyzerTest extends Assert { MarketAnalyzer analyzer = new MarketAnalyzer(market); analyzer.setJumps(2);analyzer.setMaxDistance(10);analyzer.setTank(15); - Collection> paths = analyzer.getPaths(v10, v6); + Collection> paths = analyzer.getPaths(v10, v6); TestUtil.assertCollectionContainAll(paths, Path.toPath(v10, v6), Path.toPath(v10, v11, v6), Path.toPath(v10, v8, v6)); @@ -163,7 +156,7 @@ public class MarketAnalyzerTest extends Assert { MarketAnalyzer analyzer = new MarketAnalyzer(market); analyzer.setJumps(3);analyzer.setMaxDistance(10);analyzer.setTank(15); - Collection> paths = analyzer.getPaths(v10, v6); + Collection> paths = analyzer.getPaths(v10, v6); TestUtil.assertCollectionContainAll(paths, Path.toPath(v10, v6), Path.toPath(v10, v11, v6), Path.toPath(v10, v11, v10, v6), Path.toPath(v10, v8, v6), Path.toPath(v10, v8, v10, v6), Path.toPath(v10, v8, v11, v6)); diff --git a/core/src/test/java/ru/trader/core/MarketAnalyzerTest2.java b/core/src/test/java/ru/trader/core/MarketAnalyzerTest2.java index ecee148..9ccfd29 100644 --- a/core/src/test/java/ru/trader/core/MarketAnalyzerTest2.java +++ b/core/src/test/java/ru/trader/core/MarketAnalyzerTest2.java @@ -26,10 +26,10 @@ public class MarketAnalyzerTest2 extends Assert { // Balance: 6000000, cargo: 440, tank: 40, distance: 13.4, jumps: 6 // Ithaca (Palladium to LHS 3262) -> Morgor -> LHS 3006 -> LHS 3262 (Consumer Technology to Ithaca) -> LHS 3006 -> Morgor -> Ithaca // Profit: 981200, avg: 490600, distance: 67.5, lands: 2 - Vendor ithaca = market.get().stream().filter((v)->v.getName().equals("Ithaca")).findFirst().get(); - Vendor morgor = market.get().stream().filter((v)->v.getName().equals("Morgor")).findFirst().get(); - Vendor lhs3006 = market.get().stream().filter((v)->v.getName().equals("LHS 3006")).findFirst().get(); - Vendor lhs3262 = market.get().stream().filter((v)->v.getName().equals("LHS 3262")).findFirst().get(); + Place ithaca = market.get().stream().filter((v)->v.getName().equals("Ithaca")).findFirst().get(); + Place morgor = market.get().stream().filter((v)->v.getName().equals("Morgor")).findFirst().get(); + Place lhs3006 = market.get().stream().filter((v)->v.getName().equals("LHS 3006")).findFirst().get(); + Place lhs3262 = market.get().stream().filter((v)->v.getName().equals("LHS 3262")).findFirst().get(); analyzer.setCargo(440);analyzer.setTank(40);analyzer.setMaxDistance(13.4);analyzer.setJumps(6); Collection paths = analyzer.getPaths(ithaca, ithaca, 6000000); PathRoute expect = PathRoute.toPathRoute(ithaca, morgor, lhs3006, lhs3262, lhs3006, morgor, ithaca); diff --git a/core/src/test/java/ru/trader/core/MarketTest1.java b/core/src/test/java/ru/trader/core/MarketTest1.java index 8942634..6987ef7 100644 --- a/core/src/test/java/ru/trader/core/MarketTest1.java +++ b/core/src/test/java/ru/trader/core/MarketTest1.java @@ -17,57 +17,57 @@ public class MarketTest1 extends Assert { private final static Item ITEM2 = new SimpleItem("Item2"); private final static Item ITEM3 = new SimpleItem("Item3"); - private final static Offer bestSellOffer1 = new SimpleOffer(OFFER_TYPE.SELL,ITEM1,10); - private final static Offer bestSellOffer2 = new SimpleOffer(OFFER_TYPE.SELL,ITEM2,15); - private final static Offer bestSellOffer3 = new SimpleOffer(OFFER_TYPE.SELL,ITEM3,20); + private final Offer bestSellOffer1 = new SimpleOffer(OFFER_TYPE.SELL,ITEM1,10,1); + private final Offer bestSellOffer2 = new SimpleOffer(OFFER_TYPE.SELL,ITEM2,15,1); + private final Offer bestSellOffer3 = new SimpleOffer(OFFER_TYPE.SELL,ITEM3,20,1); - private final static Offer bestBuyOffer1 = new SimpleOffer(OFFER_TYPE.BUY,ITEM1,100); - private final static Offer bestBuyOffer2 = new SimpleOffer(OFFER_TYPE.BUY,ITEM2,200); - private final static Offer bestBuyOffer3 = new SimpleOffer(OFFER_TYPE.BUY,ITEM3,100); - private final static Offer bestBuyOffer4 = new SimpleOffer(OFFER_TYPE.BUY,ITEM2,150); + private final Offer bestBuyOffer1 = new SimpleOffer(OFFER_TYPE.BUY,ITEM1,100,1); + private final Offer bestBuyOffer2 = new SimpleOffer(OFFER_TYPE.BUY,ITEM2,200,1); + private final Offer bestBuyOffer3 = new SimpleOffer(OFFER_TYPE.BUY,ITEM3,100,1); + private final Offer bestBuyOffer4 = new SimpleOffer(OFFER_TYPE.BUY,ITEM2,150,1); - private final static Vendor sellVendor1 = new SimpleVendor(); - private final static Vendor sellVendor2 = new SimpleVendor(); - private final static Vendor sellVendor3 = new SimpleVendor(); - private final static Vendor sellVendor4 = new SimpleVendor(); - private final static Vendor buyVendor1 = new SimpleVendor(); - private final static Vendor buyVendor2 = new SimpleVendor(); - private final static Vendor buyVendor3 = new SimpleVendor(); - private final static Vendor buyVendor4 = new SimpleVendor(); + private final Vendor sellVendor1 = new SimpleVendor("",0,0,0); + private final Vendor sellVendor2 = new SimpleVendor("",0,0,0); + private final Vendor sellVendor3 = new SimpleVendor("",0,0,0); + private final Vendor sellVendor4 = new SimpleVendor("",0,0,0); + private final Vendor buyVendor1 = new SimpleVendor("",0,0,0); + private final Vendor buyVendor2 = new SimpleVendor("",0,0,0); + private final Vendor buyVendor3 = new SimpleVendor("",0,0,0); + private final Vendor buyVendor4 = new SimpleVendor("",0,0,0); private Market market; @Before public void fillMarket(){ sellVendor1.add(bestSellOffer1); - sellVendor1.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM2,100)); - sellVendor2.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM3,200)); + sellVendor1.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM2,100,1)); + sellVendor2.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM3,200,1)); sellVendor2.add(bestSellOffer2); - sellVendor3.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM1,300)); - sellVendor3.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM2,300)); + sellVendor3.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM1,300,1)); + sellVendor3.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM2,300,1)); sellVendor3.add(bestSellOffer3); - sellVendor4.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM2,150)); + sellVendor4.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM2,150,1)); - buyVendor1.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM2,50)); + buyVendor1.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM2,50,1)); buyVendor1.add(bestBuyOffer1); - buyVendor2.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM1,40)); + buyVendor2.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM1,40,1)); buyVendor2.add(bestBuyOffer2); - buyVendor2.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM3,50)); + buyVendor2.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM3,50,1)); buyVendor3.add(bestBuyOffer3); - buyVendor3.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM2,20)); - buyVendor4.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM1,80)); + buyVendor3.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM2,20,1)); + buyVendor4.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM1,80,1)); buyVendor4.add(bestBuyOffer4); market = new SimpleMarket(); - market.add(sellVendor1); - market.add(sellVendor2); - market.add(sellVendor3); - market.add(sellVendor4); - market.add(buyVendor1); - market.add(buyVendor2); - market.add(buyVendor3); - market.add(buyVendor4); + market.add(sellVendor1.getPlace()); + market.add(sellVendor2.getPlace()); + market.add(sellVendor3.getPlace()); + market.add(sellVendor4.getPlace()); + market.add(buyVendor1.getPlace()); + market.add(buyVendor2.getPlace()); + market.add(buyVendor3.getPlace()); + market.add(buyVendor4.getPlace()); } @Test diff --git a/core/src/test/java/ru/trader/core/VendorTest.java b/core/src/test/java/ru/trader/core/VendorTest.java index 9c3cbed..9c54d5f 100644 --- a/core/src/test/java/ru/trader/core/VendorTest.java +++ b/core/src/test/java/ru/trader/core/VendorTest.java @@ -15,8 +15,8 @@ public class VendorTest extends Assert { private final static Item ITEM1 = new SimpleItem("Item1"); private final static Item ITEM2 = new SimpleItem("Item2"); - private final static Offer SELL_OFFER = new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 10); - private final static Offer BUY_OFFER = new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 10); + private final Offer SELL_OFFER = new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 10, 1); + private final Offer BUY_OFFER = new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 10, 1); private Vendor sellVendor; private Vendor buyVendor; diff --git a/core/src/test/java/ru/trader/core/VendorTest2.java b/core/src/test/java/ru/trader/core/VendorTest2.java index 3e0e98d..2fcf409 100644 --- a/core/src/test/java/ru/trader/core/VendorTest2.java +++ b/core/src/test/java/ru/trader/core/VendorTest2.java @@ -18,15 +18,15 @@ public class VendorTest2 extends Assert { private final static Item ITEM1 = new SimpleItem("Item1"); private final static Item ITEM2 = new SimpleItem("Item2"); private final static Item ITEM3 = new SimpleItem("Item3"); - private final static Offer SELL_OFFER1 = new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 10); - private final static Offer SELL_OFFER2 = new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 10); - private final static Offer SELL_OFFER3 = new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 10); - private final static Offer DUBLE_SELL_OFFER1 = new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100); + private final Offer SELL_OFFER1 = new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 10, 1); + private final Offer SELL_OFFER2 = new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 10, 1); + private final Offer SELL_OFFER3 = new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 10, 1); + private final Offer DUBLE_SELL_OFFER1 = new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1); - private final static Offer BUY_OFFER1 = new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 100); - private final static Offer BUY_OFFER2 = new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 10); - private final static Offer BUY_OFFER3 = new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 10); - private final static Offer DUBLE_BUY_OFFER1 = new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 10); + private final Offer BUY_OFFER1 = new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 100, 1); + private final Offer BUY_OFFER2 = new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 10, 1); + private final Offer BUY_OFFER3 = new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 10, 1); + private final Offer DUBLE_BUY_OFFER1 = new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 10, 1); private Vendor sellVendor; diff --git a/core/src/test/java/ru/trader/graph/PathRouteTest.java b/core/src/test/java/ru/trader/graph/PathRouteTest.java index 7fdda14..cd6d5e2 100644 --- a/core/src/test/java/ru/trader/graph/PathRouteTest.java +++ b/core/src/test/java/ru/trader/graph/PathRouteTest.java @@ -26,18 +26,18 @@ public class PathRouteTest extends Assert { private PathRoute initTest1(){ LOG.info("Init test 1"); - v1 = new SimpleVendor("v1"); - v2 = new SimpleVendor("v2"); + v1 = new SimpleVendor("v1",0,0,0); + v2 = new SimpleVendor("v2",0,0,0); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100)); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200)); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300)); - v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 300)); - v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 350)); - v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 400)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, 1)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, 1)); + v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 300, 1)); + v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 350, 1)); + v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 400, 1)); - PathRoute res = new PathRoute(new Vertex<>(v1)); - res = (PathRoute) res.connectTo(new Vertex<>(v2), false); + PathRoute res = new PathRoute(new Vertex<>(v1.getPlace())); + res = (PathRoute) res.connectTo(new Vertex<>(v2.getPlace()), false); res.finish(); res.sort(10000, 5); return res.getRoot(); @@ -66,20 +66,20 @@ public class PathRouteTest extends Assert { private PathRoute initTest2(){ LOG.info("Init test 2"); - v1 = new SimpleVendor("v1"); - v2 = new SimpleVendor("v2"); - v3 = new SimpleVendor("v3"); + v1 = new SimpleVendor("v1",0,0,0); + v2 = new SimpleVendor("v2",0,0,0); + v3 = new SimpleVendor("v3",0,0,0); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100)); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300)); - v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200)); - v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 300)); - v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 350)); - v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 400)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, 1)); + v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, 1)); + v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 300, 1)); + v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 350, 1)); + v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 400, 1)); - PathRoute res = new PathRoute(new Vertex<>(v1)); - res = (PathRoute) res.connectTo(new Vertex<>(v2), false); - res = (PathRoute) res.connectTo(new Vertex<>(v3), false); + PathRoute res = new PathRoute(new Vertex<>(v1.getPlace())); + res = (PathRoute) res.connectTo(new Vertex<>(v2.getPlace()), false); + res = (PathRoute) res.connectTo(new Vertex<>(v3.getPlace()), false); res.finish(); res.sort(10000, 5); return res.getRoot(); @@ -113,26 +113,26 @@ public class PathRouteTest extends Assert { private PathRoute initTest3(){ LOG.info("Init test 3"); - v1 = new SimpleVendor("v1"); - v2 = new SimpleVendor("v2"); - v3 = new SimpleVendor("v3"); - v4 = new SimpleVendor("v4"); + v1 = new SimpleVendor("v1",0,0,0); + v2 = new SimpleVendor("v2",0,0,0); + v3 = new SimpleVendor("v3",0,0,0); + v4 = new SimpleVendor("v4",0,0,0); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100)); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200)); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300)); - v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150)); - v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320)); - v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, 1)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, 1)); + v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150, 1)); + v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320, 1)); + v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390, 1)); - v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225)); - v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200)); - v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450)); + v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225, 1)); + v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, 1)); + v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450, 1)); - PathRoute res = new PathRoute(new Vertex<>(v1)); - res = (PathRoute) res.connectTo(new Vertex<>(v2), false); - res = (PathRoute) res.connectTo(new Vertex<>(v3), false); - res = (PathRoute) res.connectTo(new Vertex<>(v4), false); + PathRoute res = new PathRoute(new Vertex<>(v1.getPlace())); + res = (PathRoute) res.connectTo(new Vertex<>(v2.getPlace()), false); + res = (PathRoute) res.connectTo(new Vertex<>(v3.getPlace()), false); + res = (PathRoute) res.connectTo(new Vertex<>(v4.getPlace()), false); res.finish(); res.sort(10000, 5); return res.getRoot(); @@ -176,28 +176,28 @@ public class PathRouteTest extends Assert { private PathRoute initTest4(){ LOG.info("Init test 4"); - v1 = new SimpleVendor("v1"); - v2 = new SimpleVendor("v2"); - v3 = new SimpleVendor("v3"); - v4 = new SimpleVendor("v4"); - v5 = new SimpleVendor("v5"); + v1 = new SimpleVendor("v1",0,0,0); + v2 = new SimpleVendor("v2",0,0,0); + v3 = new SimpleVendor("v3",0,0,0); + v4 = new SimpleVendor("v4",0,0,0); + v5 = new SimpleVendor("v5",0,0,0); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 410)); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200)); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300)); - v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 270)); - v4.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 300)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 410, 1)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, 1)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, 1)); + v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 270, 1)); + v4.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 300, 1)); - v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 470)); - v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 300)); - v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 370)); - v5.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 400)); + v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 470, 1)); + v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 300, 1)); + v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 370, 1)); + v5.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 400, 1)); - PathRoute res = new PathRoute(new Vertex<>(v1)); - res = (PathRoute) res.connectTo(new Vertex<>(v2), false); - res = (PathRoute) res.connectTo(new Vertex<>(v3), false); - res = (PathRoute) res.connectTo(new Vertex<>(v4), false); - res = (PathRoute) res.connectTo(new Vertex<>(v5), false); + PathRoute res = new PathRoute(new Vertex<>(v1.getPlace())); + res = (PathRoute) res.connectTo(new Vertex<>(v2.getPlace()), false); + res = (PathRoute) res.connectTo(new Vertex<>(v3.getPlace()), false); + res = (PathRoute) res.connectTo(new Vertex<>(v4.getPlace()), false); + res = (PathRoute) res.connectTo(new Vertex<>(v5.getPlace()), false); res.finish(); res.sort(10000, 5); return res.getRoot(); @@ -249,26 +249,26 @@ public class PathRouteTest extends Assert { private PathRoute initTest5(){ LOG.info("Init test 5"); - v1 = new SimpleVendor("v1"); - v2 = new SimpleVendor("v2"); - v3 = new SimpleVendor("v3"); - v4 = new SimpleVendor("v4"); + v1 = new SimpleVendor("v1",0,0,0); + v2 = new SimpleVendor("v2",0,0,0); + v3 = new SimpleVendor("v3",0,0,0); + v4 = new SimpleVendor("v4",0,0,0); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100)); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200)); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300)); - v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150)); - v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320)); - v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, 1)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, 1)); + v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150, 1)); + v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320, 1)); + v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390, 1)); - v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225)); - v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200)); - v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450)); + v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225, 1)); + v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, 1)); + v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450, 1)); - PathRoute res = new PathRoute(new Vertex<>(v1)); - res = (PathRoute) res.connectTo(new Vertex<>(v2), false); - res = (PathRoute) res.connectTo(new Vertex<>(v3), false); - res = (PathRoute) res.connectTo(new Vertex<>(v4), false); + PathRoute res = new PathRoute(new Vertex<>(v1.getPlace())); + res = (PathRoute) res.connectTo(new Vertex<>(v2.getPlace()), false); + res = (PathRoute) res.connectTo(new Vertex<>(v3.getPlace()), false); + res = (PathRoute) res.connectTo(new Vertex<>(v4.getPlace()), false); res.finish(); res.sort(500, 5); return res.getRoot(); @@ -314,19 +314,19 @@ public class PathRouteTest extends Assert { private PathRoute initTest6A(){ LOG.info("Init test 6A"); - v1 = new SimpleVendor("v1"); - v2 = new SimpleVendor("v2"); + v1 = new SimpleVendor("v1",0,0,0); + v2 = new SimpleVendor("v2",0,0,0); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100)); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200)); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300)); - v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150)); - v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, 1)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, 1)); + v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150, 1)); + v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320, 1)); - v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225)); + v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225, 1)); - PathRoute res = new PathRoute(new Vertex<>(v1)); - res = (PathRoute) res.connectTo(new Vertex<>(v2), false); + PathRoute res = new PathRoute(new Vertex<>(v1.getPlace())); + res = (PathRoute) res.connectTo(new Vertex<>(v2.getPlace()), false); res.finish(); res.sort(500, 5); return res.getRoot(); @@ -334,17 +334,17 @@ public class PathRouteTest extends Assert { private PathRoute initTest6B(){ LOG.info("Init test 6B"); - v3 = new SimpleVendor("v3"); - v4 = new SimpleVendor("v4"); + v3 = new SimpleVendor("v3",0,0,0); + v4 = new SimpleVendor("v4",0,0,0); - v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390)); + v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390, 1)); - v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200)); - v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450)); + v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, 1)); + v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450, 1)); - PathRoute res = new PathRoute(new Vertex<>(v2)); - res = (PathRoute) res.connectTo(new Vertex<>(v3), false); - res = (PathRoute) res.connectTo(new Vertex<>(v4), false); + PathRoute res = new PathRoute(new Vertex<>(v2.getPlace())); + res = (PathRoute) res.connectTo(new Vertex<>(v3.getPlace()), false); + res = (PathRoute) res.connectTo(new Vertex<>(v4.getPlace()), false); res.finish(); res.sort(500, 5); return res.getRoot(); diff --git a/core/src/test/java/ru/trader/graph/RouteGraphTest.java b/core/src/test/java/ru/trader/graph/RouteGraphTest.java index 513b61b..1036030 100644 --- a/core/src/test/java/ru/trader/graph/RouteGraphTest.java +++ b/core/src/test/java/ru/trader/graph/RouteGraphTest.java @@ -5,10 +5,7 @@ import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import ru.trader.core.*; -import ru.trader.store.simple.SimpleItem; -import ru.trader.store.simple.SimpleMarket; -import ru.trader.store.simple.SimpleOffer; -import ru.trader.store.simple.SimpleVendor; +import ru.trader.store.simple.*; import java.util.ArrayList; @@ -22,36 +19,47 @@ public class RouteGraphTest extends Assert { private static Vendor v2; private static Vendor v3; private static Vendor v4; + private static Place p1; + private static Place p2; + private static Place p3; + private static Place p4; + static { + p1 = new SimplePlace("v1"); + p2 = new SimplePlace("v2"); + p3 = new SimplePlace("v3"); + p4 = new SimplePlace("v4"); + v1 = new SimpleVendor("v1"); v2 = new SimpleVendor("v2"); v3 = new SimpleVendor("v3"); v4 = new SimpleVendor("v4"); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100)); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200)); - v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300)); - v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150)); - v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320)); - v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, 1)); + v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, 1)); + v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150, 1)); + v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320, 1)); + v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390, 1)); - v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225)); - v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200)); - v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450)); + v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225, 1)); + v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, 1)); + v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450, 1)); - market.add(v1);market.add(v2);market.add(v3);market.add(v4); + p1.add(v1);p2.add(v2);p3.add(v3);p4.add(v4); + market.add(p1);market.add(p2);market.add(p3);market.add(p4); } @Test public void testRoutes() throws Exception { - RouteGraph graph = new RouteGraph(v1, market.get(), 1, 1, true, 4); + RouteGraph graph = new RouteGraph(p1, market.get(), 1, 1, true, 4); graph.setBalance(500); graph.setCargo(5); //Profit: 150 180 200 230 670 620 950 890 620 950 1015 1180 890 950 930 //Landings: 1 2 3 4 4 2 3 3 2 3 4 4 3 3 4 //Prof: 150 90 66.66 57.5 167.5 310 316.66 296.66 310 316.66 253.75 295 296.66 316.66 232.5 - ArrayList> routes = (ArrayList>) graph.getPathsTo(v4, 5); + ArrayList> routes = (ArrayList>) graph.getPathsTo(p4, 5); assertEquals(5, routes.size()); PathRoute path = (PathRoute) routes.get(0).getRoot(); diff --git a/core/src/test/java/ru/trader/graph/RouteSearcherTest.java b/core/src/test/java/ru/trader/graph/RouteSearcherTest.java index 0bcc13e..7e63e65 100644 --- a/core/src/test/java/ru/trader/graph/RouteSearcherTest.java +++ b/core/src/test/java/ru/trader/graph/RouteSearcherTest.java @@ -4,6 +4,7 @@ import org.junit.Assert; import org.junit.Before; import org.junit.Test; import ru.trader.core.Market; +import ru.trader.core.Place; import ru.trader.core.Vendor; import ru.trader.store.simple.Store; @@ -24,7 +25,7 @@ public class RouteSearcherTest extends Assert { // Balance: 6000000, cargo: 440, tank: 40, distance: 13.4, jumps: 6 // Ithaca (Palladium to LHS 3262) -> Morgor -> LHS 3006 -> LHS 3262 (Consumer Technology to Ithaca) -> LHS 3006 -> Morgor -> Ithaca // Profit: 981200, avg: 490600, distance: 67.5, lands: 2 - Vendor ithaca = market.get().stream().filter((v)->v.getName().equals("Ithaca")).findFirst().get(); + Place ithaca = market.get().stream().filter((v)->v.getName().equals("Ithaca")).findFirst().get(); RouteSearcher searcher = new RouteSearcher(13.4, 40); RouteGraph graph = new RouteGraph(ithaca, market.get(), 40, 13.4, true, 6); @@ -32,7 +33,7 @@ public class RouteSearcherTest extends Assert { graph.setBalance(6000000); - List> epaths = graph.getPathsTo(ithaca, 10); + List> epaths = graph.getPathsTo(ithaca, 10); PathRoute expect = epaths.stream().map(p -> (PathRoute) p).findFirst().get(); List apaths = searcher.getPaths(ithaca, ithaca, market.get(), 6, 6000000, 440, 10); @@ -46,15 +47,15 @@ public class RouteSearcherTest extends Assert { // Balance: 6000000, cargo: 440, tank: 40, distance: 13.6, jumps: 6 // Ithaca (Palladium to LHS 3262) -> Morgor -> LHS 3006 -> LHS 3262 (Consumer Technology to Ithaca) -> LHS 3006 -> Morgor -> Ithaca // Profit: 981200, avg: 490600, distance: 67.5, lands: 2 - Vendor ithaca = market.get().stream().filter((v)->v.getName().equals("Ithaca")).findFirst().get(); - Vendor lhs3262 = market.get().stream().filter((v)->v.getName().equals("LHS 3262")).findFirst().get(); + Place ithaca = market.get().stream().filter((v)->v.getName().equals("Ithaca")).findFirst().get(); + Place lhs3262 = market.get().stream().filter((v)->v.getName().equals("LHS 3262")).findFirst().get(); RouteSearcher searcher = new RouteSearcher(13.6, 40); RouteGraph graph = new RouteGraph(ithaca, market.get(), 40, 13.6, true, 6); graph.setCargo(440); graph.setBalance(6000000); - List> epaths = graph.getPathsTo(ithaca, 10); + List> epaths = graph.getPathsTo(ithaca, 10); PathRoute expect = epaths.stream().map(p -> (PathRoute) p).findFirst().get(); List apaths = searcher.getPaths(ithaca, ithaca, market.get(), 6, 6000000, 440, 10); diff --git a/core/src/test/java/ru/trader/store/simple/ItemStatTest.java b/core/src/test/java/ru/trader/store/simple/ItemStatTest.java index 9538bc8..b4fc347 100644 --- a/core/src/test/java/ru/trader/store/simple/ItemStatTest.java +++ b/core/src/test/java/ru/trader/store/simple/ItemStatTest.java @@ -20,15 +20,15 @@ public class ItemStatTest extends Assert { @Before public void fill(){ - itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 10)); - itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 20)); - itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 30)); - itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 40)); + itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 10, 1)); + itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 20, 1)); + itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 30, 1)); + itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 40, 1)); - itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 100)); - itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200)); - itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 300)); - itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 400)); + itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 100, 1)); + itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, 1)); + itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 300, 1)); + itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 400, 1)); } diff --git a/core/src/test/resources/test.xml b/core/src/test/resources/test.xml index 691b0a6..34bc240 100644 --- a/core/src/test/resources/test.xml +++ b/core/src/test/resources/test.xml @@ -8,12 +8,12 @@ - + - + \ No newline at end of file diff --git a/core/src/test/resources/world.xml b/core/src/test/resources/world.xml index 2a2e4a1..0698c23 100644 --- a/core/src/test/resources/world.xml +++ b/core/src/test/resources/world.xml @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/utils/src/main/java/ru/trader/store/XSSFImporter.java b/utils/src/main/java/ru/trader/store/XSSFImporter.java index 2b25608..d522d6e 100644 --- a/utils/src/main/java/ru/trader/store/XSSFImporter.java +++ b/utils/src/main/java/ru/trader/store/XSSFImporter.java @@ -57,7 +57,9 @@ public class XSSFImporter { XMLReader saxParser = XMLReaderFactory.createXMLReader(); saxParser.setContentHandler(getHandler()); saxParser.parse(getInputSource()); - market.addVendors(vendors); + for (Vendor vendor : vendors) { + market.add(vendor.getPlace()); + } } finally { if (pkg!=null) { try { pkg.close();} catch (IOException e) {LOG.warn("Error on close pkg",e);} @@ -113,7 +115,7 @@ public class XSSFImporter { market.add(item); } else { LOG.trace("add offer"); - Offer offer = new SimpleOffer(cell.column % 2 == 0? OFFER_TYPE.BUY : OFFER_TYPE.SELL, item, Double.valueOf(formattedValue)); + Offer offer = new SimpleOffer(cell.column % 2 == 0? OFFER_TYPE.BUY : OFFER_TYPE.SELL, item, Double.valueOf(formattedValue), 1000); vendors.get(cell.column/2 -1).add(offer); } }