com.paritytrading.foundation.ASCII Java Examples

public Open(OrderEntry orderEntry, long instrument, long bidPrice, long bidSize,
        long askPrice, long askSize) {
    super(orderEntry);

    this.enterBuyOrder = new POE.EnterOrder();

    ASCII.putLeft(this.enterBuyOrder.orderId, orderId.next());
    this.enterBuyOrder.side       = POE.BUY;
    this.enterBuyOrder.instrument = instrument;
    this.enterBuyOrder.quantity   = bidSize;
    this.enterBuyOrder.price      = bidPrice;

    this.enterSellOrder = new POE.EnterOrder();

    ASCII.putLeft(this.enterSellOrder.orderId, orderId.next());
    this.enterSellOrder.side       = POE.SELL;
    this.enterSellOrder.instrument = instrument;
    this.enterSellOrder.quantity   = askSize;
    this.enterSellOrder.price      = askPrice;
}
 

@Test
public void loginRequest() throws Exception {
    ASCII.putLeft(loginRequest.loginName, "foo");
    ASCII.putLeft(loginRequest.password, "bar");
    loginRequest.marketDataUnsubscribe = ITCH.TRUE;
    ASCII.putLongRight(loginRequest.reserved, 0);

    client.login(loginRequest);

    while (serverEvents.collect().size() != 1)
        server.receive();

    assertEquals(asList(new LoginRequest(
                    "foo                                     ",
                    "bar                                     ",
                    ITCH.TRUE, 0)),
            serverEvents.collect());
}
 

static TerminalClient open(InetSocketAddress address, String username,
        String password, Instruments instruments) throws IOException {
    Events events = new Events();

    OrderEntry orderEntry = OrderEntry.open(address, events);

    SoupBinTCP.LoginRequest loginRequest = new SoupBinTCP.LoginRequest();

    ASCII.putLeft(loginRequest.username, username);
    ASCII.putLeft(loginRequest.password, password);
    ASCII.putRight(loginRequest.requestedSession, "");
    ASCII.putLongRight(loginRequest.requestedSequenceNumber, 0);

    orderEntry.getTransport().login(loginRequest);

    return new TerminalClient(events, orderEntry, instruments);
}
 

public void reset() {
    ASCII.putLongRight(lengthOfMessage, 0);
    ASCII.putLongRight(numberOfItems, 0);

    lengthOfMessagePosition = -1;
    numberOfCurrencyPairsPosition = -1;
    numberOfPricesPosition = -1;
    numberOfOrdersPosition = -1;

    currencyPairs = 0;
    prices        = 0;
    orders        = 0;

    ASCII.putLeft(currencyPair, " ");
    buyOrSellIndicator = ' ';
    ASCII.putLeft(price, " ");
}
 

@Override
public void execute(TerminalClient client, Scanner arguments) throws IOException {
    try {
        double quantity   = arguments.nextDouble();
        long   instrument = ASCII.packLong(arguments.next());
        double price      = arguments.nextDouble();

        if (arguments.hasNext())
            throw new IllegalArgumentException();

        Instrument config = client.getInstruments().get(instrument);
        if (config == null)
            throw new IllegalArgumentException();

        execute(client, Math.round(quantity * config.getSizeFactor()), instrument, Math.round(price * config.getPriceFactor()));
    } catch (NoSuchElementException e) {
        throw new IllegalArgumentException();
    }
}
 

@Override
public void logon(FIXConnection connection, FIXMessage message) throws IOException {
    FIXValue username = message.valueOf(Username);
    FIXValue password = message.valueOf(Password);

    if (requiredTagMissing(message, username, "Username(553)"))
        return;

    if (requiredTagMissing(message, password, "Password(554)"))
        return;

    fix.updateCompID(message);

    ASCII.putLeft(loginRequest.username, username.asString());
    ASCII.putLeft(loginRequest.password, password.asString());
    ASCII.putRight(loginRequest.requestedSession, "");
    ASCII.putLongRight(loginRequest.requestedSequenceNumber, 0);

    orderEntry.login(loginRequest);
}
 

@Override
public void orderExecuted(POE.OrderExecuted message) throws IOException {
    long orderEntryId = ASCII.getLong(message.orderId);

    Order order = orders.findByOrderEntryID(orderEntryId);
    if (order == null)
        return;

    Instrument config = instruments.get(order.getSymbol());

    double lastQty = message.quantity / config.getSizeFactor();
    double lastPx  = message.price    / config.getPriceFactor();

    order.orderExecuted(lastQty, lastPx);

    sendOrderExecuted(order, lastQty, lastPx, config);

    if (order.getLeavesQty() == 0) {
        orders.removeByOrderEntryID(orderEntryId);

        if (order.isInPendingStatus())
            sendOrderCancelReject(order);
    }
}
 

@Override
public void orderCanceled(POE.OrderCanceled message) throws IOException {
    long orderEntryId = ASCII.getLong(message.orderId);

    Order order = orders.findByOrderEntryID(orderEntryId);
    if (order == null)
        return;

    Instrument config = instruments.get(order.getSymbol());

    order.orderCanceled(message.canceledQuantity / config.getSizeFactor());

    sendOrderCanceled(order, config);

    if (order.getLeavesQty() == 0)
        orders.removeByOrderEntryID(orderEntryId);
}
 

@Override
public void orderRejected(POE.OrderRejected message) throws IOException {
    long orderEntryId = ASCII.getLong(message.orderId);

    Order order = orders.findByOrderEntryID(orderEntryId);
    if (order == null)
        return;

    switch (message.reason) {
    case POE.ORDER_REJECT_REASON_UNKNOWN_INSTRUMENT:
        sendOrderRejected(order, OrdRejReasonValues.UnknownSymbol);
        break;
    case POE.ORDER_REJECT_REASON_INVALID_PRICE:
        sendOrderRejected(order, OrdRejReasonValues.Other);
        break;
    case POE.ORDER_REJECT_REASON_INVALID_QUANTITY:
        sendOrderRejected(order, OrdRejReasonValues.IncorrectQuantity);
        break;
    default:
        sendOrderRejected(order, OrdRejReasonValues.Other);
        break;
    }

    orders.removeByOrderEntryID(orderEntryId);
}
 

@Test
public void marketDataSubscription() throws Exception {
    ASCII.putLeft(marketDataSubscribeRequest.currencyPair, "FOO/BAR");
    ASCII.putLeft(marketDataUnsubscribeRequest.currencyPair, "FOO/BAR");

    client.request(marketDataSubscribeRequest);
    client.request(marketDataUnsubscribeRequest);

    while (serverEvents.collect().size() != 2)
        server.receive();

    assertEquals(asList(new MarketDataSubscribeRequest("FOO/BAR"),
                new MarketDataUnsubscribeRequest("FOO/BAR")),
            serverEvents.collect());
}
 

@Test
public void loginRejected() throws Exception {
    ASCII.putLeft(loginRejected.reason, "foo");

    server.reject(loginRejected);

    while (clientEvents.collect().size() != 1)
        client.receive();

    assertEquals(asList(new LoginRejected("foo                 ")),
                clientEvents.collect());
}
 

@Test
public void sequencedData() throws Exception {
    ASCII.putLeft(sequencedData.time, "093000250");

    byte[] payload = new byte[] { 'f', 'o', 'o' };

    server.send(sequencedData, ByteBuffer.wrap(payload));

    while (clientEvents.collect().size() != 1)
        client.receive();

    assertEquals(asList(new SequencedData("093000250", payload)),
            clientEvents.collect());
}
 

@Test
public void fullBuffer() throws Exception {
    ASCII.putLeft(sequencedData.time, "093000250");

    byte[] payload = repeat((byte)'A', RX_BUFFER_CAPACITY - 11);

    server.send(sequencedData, ByteBuffer.wrap(payload));

    while (clientEvents.collect().size() != 1)
        client.receive();

    assertEquals(asList(new SequencedData("093000250", payload)),
            clientEvents.collect());
}
 

@Test(expected=ITCHException.class)
public void packetLengthExceedsBufferCapacity() throws Exception {
    ASCII.putLeft(sequencedData.time, "093000250");

    byte[] payload = repeat((byte)'A', RX_BUFFER_CAPACITY - 10);

    server.send(sequencedData, ByteBuffer.wrap(payload));

    while (true)
        client.receive();
}
 

@Test
public void errorNotification() throws Exception {
    ASCII.putLeft(errorNotification.errorExplanation, "foo");

    server.notifyError(errorNotification);

    while (clientEvents.collect().size() != 1)
        client.receive();

    assertEquals(asList(new ErrorNotification(
                    "foo                                               " +
                    "                                                  ")),
            clientEvents.collect());
}
 

@Test
public void instrumentDirectory() throws Exception {
    ASCII.putLongRight(instrumentDirectory.numberOfCurrencyPairs, 3);
    ASCII.putLeft(instrumentDirectory.currencyPair[0], "FOO/BAR");
    ASCII.putLeft(instrumentDirectory.currencyPair[1], "BAR/BAZ");
    ASCII.putLeft(instrumentDirectory.currencyPair[2], "BAZ/FOO");

    server.instrumentDirectory(instrumentDirectory);

    while (clientEvents.collect().size() != 1)
        client.receive();

    assertEquals(asList(new InstrumentDirectory(asList("FOO/BAR", "BAR/BAZ", "BAZ/FOO"))),
            clientEvents.collect());
}
 

private Instrument(String asString, int priceFractionDigits, int sizeFractionDigits) {
    this.asString = asString;
    this.asLong   = ASCII.packLong(asString);

    this.priceFractionDigits = priceFractionDigits;
    this.sizeFractionDigits  = sizeFractionDigits;

    this.priceFactor = POWERS_OF_TEN[priceFractionDigits];
    this.sizeFactor  = POWERS_OF_TEN[sizeFractionDigits];

    setPriceFormat(1, priceFractionDigits);
    setSizeFormat(1, sizeFractionDigits);
}
 

@Test
public void marketSnapshotRequest() throws Exception {
    ASCII.putLeft(marketSnapshotRequest.currencyPair, "FOO/BAR");

    client.request(marketSnapshotRequest);

    while (serverEvents.collect().size() != 1)
        server.receive();

    assertEquals(asList(new MarketSnapshotRequest("FOO/BAR")),
            serverEvents.collect());
}
 

@Test
public void tickerSubscription() throws Exception {
    ASCII.putLeft(tickerSubscribeRequest.currencyPair, "FOO/BAR");
    ASCII.putLeft(tickerUnsubscribeRequest.currencyPair, "FOO/BAR");

    client.request(tickerSubscribeRequest);
    client.request(tickerUnsubscribeRequest);

    while (serverEvents.collect().size() != 2)
        server.receive();

    assertEquals(asList(new TickerSubscribeRequest("FOO/BAR"),
                new TickerUnsubscribeRequest("FOO/BAR")),
            serverEvents.collect());
}
 

@Override
public void loginRequest(ITCHServer session, ITCH.LoginRequest packet) {
    String loginName             = ASCII.get(packet.loginName);
    String password              = ASCII.get(packet.password);
    byte   marketDataUnsubscribe = packet.marketDataUnsubscribe;
    long   reserved              = ASCII.getLong(packet.reserved);

    events.add(new LoginRequest(loginName, password, marketDataUnsubscribe, reserved));
}
 

@Override
    public void stockDirectory(ITCH50.StockDirectory itchMsg) {
//                log.debug("{}", itchMsg);

        symbolDescr.put(itchMsg.stockLocate, new StockDescr(ASCII.unpackLong(itchMsg.stock), itchMsg.etpFlag, itchMsg.etpLeverageFactor));

//        CoreSymbolSpecification symbolSpecification = CoreSymbolSpecification.builder()
//                .symbolId(itchMsg.stockLocate)
//                .type(SymbolType.FUTURES_CONTRACT) // allow margin trade TODO calculate based on ETP
//                .baseCurrency(itchMsg.stockLocate + 10_000)
//                .quoteCurrency(TestConstants.CURRENECY_USD)
//                .takerFee(3)
//                .makerFee(1)
//                .quoteScaleK(2)
//                .baseScaleK(itchMsg.roundLotSize)
//                .marginBuy(itchMsg.etpLeverageFactor + 100L) // TODO price
//                .marginSell(itchMsg.etpLeverageFactor + 100L) // TODO price
//                .build();
//
//        final CompletableFuture<OrderCommand> response = api.submitBinaryCommandAsync(new BatchAddSymbolsCommand(symbolSpecification), itchMsg.stockLocate, Function.identity());
//
//        response.thenAccept(cmdRes -> {
//            if (cmdRes.resultCode != CommandResultCode.SUCCESS) {
//                log.error("symbol add failed: {}", response);
//            }
//            if (ASCII.unpackLong(itchMsg.stock).trim().equals("INTL")) {
//                log.debug("{} {} ls={} mc={} etpF={} etpL={} rlo={}",
//                        ASCII.unpackLong(itchMsg.stock),
//                        itchMsg.stockLocate,
//                        itchMsg.roundLotSize,
//                        (char) itchMsg.marketCategory,
//                        (char) itchMsg.etpFlag,
//                        itchMsg.etpLeverageFactor,
//                        (char) itchMsg.roundLotsOnly);
//            }
//        });
    }
 

OrderBooks(List<String> instruments, MarketData marketData, MarketReporting marketReporting) {
    this.books  = new Long2ObjectArrayMap<>();
    this.orders = new Long2ObjectOpenHashMap<>();

    EventHandler handler = new EventHandler();

    for (String instrument : instruments)
        books.put(ASCII.packLong(instrument), new OrderBook(handler));

    this.marketData      = marketData;
    this.marketReporting = marketReporting;

    this.nextOrderNumber = 1;
    this.nextMatchNumber = 1;
}
 

public OrderAccepted(POE.OrderAccepted message) {
    this.timestamp   = message.timestamp;
    this.orderId     = ASCII.get(message.orderId);
    this.side        = message.side;
    this.instrument  = message.instrument;
    this.quantity    = message.quantity;
    this.price       = message.price;
    this.orderNumber = message.orderNumber;
}
 

public OrderExecuted(POE.OrderExecuted message) {
    this.timestamp     = message.timestamp;
    this.orderId       = ASCII.get(message.orderId);
    this.quantity      = message.quantity;
    this.price         = message.price;
    this.liquidityFlag = message.liquidityFlag;
    this.matchNumber   = message.matchNumber;
}
 

private void execute(TerminalClient client, long quantity, long instrument, long price) throws IOException {
    String orderId = client.getOrderIdGenerator().next();

    ASCII.putLeft(message.orderId, orderId);
    message.quantity   = quantity;
    message.instrument = instrument;
    message.price      = price;

    client.getOrderEntry().send(message);

    printf("\nOrder ID\n----------------\n%s\n\n", orderId);
}
 

@Override
public void orderAccepted(POE.OrderAccepted message) throws IOException {
    long orderEntryId = ASCII.getLong(message.orderId);

    Order order = orders.findByOrderEntryID(orderEntryId);
    if (order == null)
        return;

    order.orderAccepted(message.orderNumber);

    sendOrderAccepted(order);
}
 

@Override
public void ticker(CboeFXBook.Ticker message) {
    byte   aggressorBuyOrSellIndicator = message.aggressorBuyOrSellIndicator;
    String currencyPair                = ASCII.get(message.currencyPair);
    long   price                       = ASCII.getFixed(message.price, PRICE_DECIMALS);
    long   transactionDate             = ASCII.getLong(message.transactionDate);
    long   transactionTime             = ASCII.getLong(message.transactionTime);

    events.add(new Ticker(aggressorBuyOrSellIndicator, currencyPair,
                price, transactionDate, transactionTime));
}
 

private static MarketData marketData(Config config) throws IOException {
    NetworkInterface multicastInterface = Configs.getNetworkInterface(config, "market-data.multicast-interface");
    InetAddress      multicastGroup     = Configs.getInetAddress(config, "market-data.multicast-group");
    int              multicastPort      = Configs.getPort(config, "market-data.multicast-port");
    InetAddress      requestAddress     = Configs.getInetAddress(config, "market-data.request-address");
    int              requestPort        = Configs.getPort(config, "market-data.request-port");

    String instrument = config.getString("instrument");

    return MarketData.open(multicastInterface,
            new InetSocketAddress(multicastGroup, multicastPort),
            new InetSocketAddress(requestAddress, requestPort),
            ASCII.packLong(instrument));
}
 

private static Open open(Config config) throws IOException {
    double bidPrice = config.getDouble("open.bid.price");
    long   bidSize  = config.getLong("open.bid.size");
    double askPrice = config.getDouble("open.ask.price");
    long   askSize  = config.getLong("open.ask.size");

    String instrument = config.getString("instrument");

    return new Open(orderEntry(config), ASCII.packLong(instrument),
            (long)(bidPrice * PRICE_FACTOR), bidSize,
            (long)(askPrice * PRICE_FACTOR), askSize);
}
 

private void enter(byte side, double price) throws IOException {
    ASCII.putLeft(enterOrder.orderId, orderId.next());
    enterOrder.side  = side;
    enterOrder.price = (long)Math.round(price * 100.0) * 100;

    getOrderEntry().send(enterOrder);
}