tagging release 3.280

Author: dxcity

ReleaseNotes.txt

@@ -1,3 +1,16 @@
+QDS 3.280:
+
+* [QD-1202] dxFeed API: Add AnalyticOrder event
+  - com.dxfeed.event.market.AnalyticOrder is introduced.
+* [QD-1201] [Schedule] Short days robustness
+* [QD-1160] Flaky test: RMIFunctionalityTest.testLargeRequests
+* [QD-1172] Flaky test: RMIFunctionalityTest.testLargeResponses
+* [QD-1175] Flaky test: RMIFunctionalityTest.testLargeRequestCancellations
+* [QD-1195] Publish "shaped" connection codec.
+  - Output throughput limit is specified with 'outLimit' parameter (as a bytes-per-second float number):
+    "shaped[outLimit=100k]+:7000"
+* [QD-1154] Flaky test: SocketRebindTest
+
 QDS 3.279:
 
 * [QD-1182] [Schedule] Add ability to specify schedule for short days

auth/pom.xml

@@ -14,7 +14,7 @@
     <parent>
         <artifactId>QD</artifactId>
         <groupId>com.devexperts.qd</groupId>
-        <version>3.279</version>
+        <version>3.280</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>

dxfeed-api/pom.xml

@@ -14,7 +14,7 @@
 	<parent>
 		<artifactId>QD</artifactId>
 		<groupId>com.devexperts.qd</groupId>
-		<version>3.279</version>
+		<version>3.280</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 	<modelVersion>4.0.0</modelVersion>

dxfeed-api/src/main/java/com/dxfeed/api/DXFeed.java

@@ -443,8 +443,8 @@ public <E extends LastingEvent<?>> Collection<E> getLastEvents(Collection<E> eve
 	 * <h3>Event source</h3>
 	 *
 	 * Use the {@link IndexedEventSource#DEFAULT DEFAULT} value for {@code source} with events that do not
-	 * have multiple sources (like {@link Series}). For events with multiple sources (like {@link Order}
-	 * and {@link SpreadOrder}), use an even-specific source class (for example, {@link OrderSource}).
+	 * have multiple sources (like {@link Series}). For events with multiple sources (like {@link Order},
+	 * {@link AnalyticOrder}) and {@link SpreadOrder}, use an event-specific source class (for example, {@link OrderSource}).
 	 * This method does not support <em>synthetic</em> sources of orders (orders that are automatically
 	 * generated from {@link Quote} events).
 	 *
@@ -504,8 +504,8 @@ public abstract <E extends IndexedEvent<?>> Promise<List<E>> getIndexedEventsPro
 	 * <h3>Event source</h3>
 	 *
 	 * Use the {@link IndexedEventSource#DEFAULT DEFAULT} value for {@code source} with events that do not
-	 * have multiple sources (like {@link Series}). For events with multiple sources (like {@link Order}
-	 * and {@link SpreadOrder}), use an even-specific source class (for example, {@link OrderSource}).
+	 * have multiple sources (like {@link Series}). For events with multiple sources (like {@link Order},
+	 * {@link AnalyticOrder} and {@link SpreadOrder}), use an event-specific source class (for example, {@link OrderSource}).
 	 * This method does not support <em>synthetic</em> sources of orders (orders that are automatically
 	 * generated from {@link Quote} events).
 	 *

dxfeed-api/src/main/java/com/dxfeed/event/market/AnalyticOrder.java

@@ -0,0 +1,263 @@
+/*
+ * !++
+ * QDS - Quick Data Signalling Library
+ * !-
+ * Copyright (C) 2002 - 2019 Devexperts LLC
+ * !-
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at
+ * http://mozilla.org/MPL/2.0/.
+ * !__
+ */
+package com.dxfeed.event.market;
+
+import com.dxfeed.api.DXFeed;
+import com.dxfeed.api.DXPublisher;
+import com.dxfeed.model.AbstractIndexedEventModel;
+import com.dxfeed.model.IndexedEventModel;
+
+import java.util.Collection;
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlType;
+
+/**
+ * Represents an extension of {@link Order} introducing analytic information, e.g. adding to this order iceberg related
+ * information ({@link #icebergPeakSize}, {@link #icebergHiddenSize}, {@link #icebergExecutedSize}).
+ * The collection of analytic order events of a symbol represents the most recent analytic information
+ * that is available about orders on the market at any given moment of time.
+ *
+ * <p> Analytic order is similar to a regular {@link Order}. In addition this event has few additional properties:
+ * <ul>
+ *     <li>{@link #icebergPeakSize} - the size of the peak, i.e. the visible part of the iceberg,
+ *     						   that is being continually refilled until the order is fully traded or cancelled;
+ *     <li>{@link #icebergHiddenSize} - the prediction of current hidden size of the iceberg, as inferred by the model;
+ *     <li>{@link #icebergExecutedSize} - the executed size of the iceberg order. For {@link IcebergType#SYNTHETIC} type
+ *                             represents total executed size of all orders сomposing current iceberg;
+ *     <li>{@link #getIcebergType()} - type of the iceberg, either native (exchange-managed) or synthetic (managed outside of the exchange).
+ * </ul>
+ *
+ * <p> Like regular orders, analytic order events arrive from
+ * multiple sources for the same market symbol and are distinguished by their
+ * {@link #getIndex index}.
+ * It is unique across all the sources of depth information for the symbol.
+ * The event with {@link #getSizeAsDouble() sizeAsDouble} either {@code 0} or {@link Double#NaN NaN}
+ * is a signal to remove previously received order for the corresponding index.
+ * The method {@link #hasSize() hasSize} is a convenient method to test for size presence.
+ *
+ * <h3>Properties</h3>
+ * <p>
+ * {@code Analytic} event has the following properties:
+ *
+ * <ul>
+ * <li>{@link #getEventSymbol() eventSymbol} - underlying symbol of this event;
+ * <li>{@link #getSource() source} - source of this event;
+ * <li>{@link #getEventFlags() eventFlags} - transactional event flags;
+ * <li>{@link #getIndex() index} - unique per-symbol index of this order;
+ * <li>{@link #getTime() time} - time of this order;
+ * <li>{@link #getTimeNanoPart() timeNanoPart} - microseconds and nanoseconds time part of this order;
+ * <li>{@link #getSequence() sequence} - sequence of this order;
+ * <li>{@link #getPrice() price} - price of this order;
+ * <li>{@link #getSize() size} - size of this order as integer number (rounded toward zero);
+ * <li>{@link #getSizeAsDouble() sizeAsDouble} - size of this order as floating number with fractions;
+ * <li>{@link #getExecutedSize() executedSize} - executed size of this order;
+ * <li>{@link #getCount() count} - number of individual orders in this aggregate order;
+ * <li>{@link #getExchangeCode() exchangeCode} - exchange code of this order;
+ * <li>{@link #getOrderSide() orderSide} - side of this order;
+ * <li>{@link #getScope() scope} - scope of this order;
+ * <li>{@link #getMarketMaker() marketMaker} - market maker or other aggregate identifier of this order;
+ * <li>{@link #getIcebergPeakSize() icebergPeakSize} - iceberg peak size of this analytic order;
+ * <li>{@link #getIcebergHiddenSize() icebergHiddenSize} - iceberg hidden size of this analytic order;
+ * <li>{@link #getIcebergExecutedSize() icebergExecutedSize} - iceberg executed size of this analytic order;
+ * <li>{@link #getIcebergType() icebergType} - iceberg type of this analytic order.
+ * </ul>
+ *
+ * <h3><a name="eventFlagsSection">Event flags, transactions and snapshots</a></h3>
+ * <p>
+ * Analytic order event sources provide a consistent view of the analytic order book. Their updates
+ * may incorporate multiple changes to individual orders that have to be processed at the same time.
+ * The corresponding information is carried in {@link #getEventFlags() eventFlags} property.
+ *
+ * <p> See <a href="OrderBase.html#eventFlagsSection">Event Flags</a> section of {@link OrderBase}
+ * class documentation for details.
+ *
+ * <p>{@link IndexedEventModel} class handles all the snapshot and transaction logic and conveniently represents
+ * a list current of events.
+ * It relies on the code of {@link AbstractIndexedEventModel} to handle this logic.
+ * Use the source code of {@link AbstractIndexedEventModel} for clarification on transactions and snapshot logic.
+ *
+ * <h3>Publishing order books</h3>
+ * <p>
+ * When publishing an order event with {@link DXPublisher#publishEvents(Collection) DXPublisher.publishEvents}
+ * method, least significant 32 bits of order {@link #getIndex() index} must be in a range of from 0 to
+ * {@link Integer#MAX_VALUE} inclusive.
+ * Use {@link #setSource(OrderSource) setSource} method after {@link #setIndex(long) setIndex} to properly
+ * include source identifier into the index.
+ * <p>
+ * A snapshot has to be published in the <em>descending</em> order of {@link #getIndex() index}, starting with
+ * an event with the largest index and marking it with {@link #SNAPSHOT_BEGIN} bit in {@link #getEventFlags() eventFlags},
+ * and finishing the snapshot with an event that has zero 32 least significant bits of index.
+ * {@link #SNAPSHOT_END} bit in {@link #getEventFlags() eventFlags} is optional during publishing.
+ * It will be properly set on receiving end anyway.
+ *
+ * <h3>Limitations</h3>
+ * <p>
+ * This event type cannot be used with {@link DXFeed#getLastEvent DXFeed.getLastEvent} method.
+ *
+ * <h3>Implementation details</h3>
+ * <p>
+ * This event is implemented on top of QDS records {@code AnalyticOrder#<source-id>},
+ * where {@code <source-id>} is up to 4 ASCII characters with a mnemonic for the source like "GLBX".
+ */
+@XmlRootElement(name = "AnalyticOrder")
+@XmlType(propOrder = {"icebergPeakSize", "icebergHiddenSize", "icebergExecutedSize", "icebergType"})
+public class AnalyticOrder extends Order {
+	private static final long serialVersionUID = 0;
+
+	// ========================= private static =========================
+
+	/*
+	 * Analytic flags property has several significant bits that are packed into an integer in the following way:
+	 *      31...2       1    0
+	 * +--------------+-------+-------+
+	 * |              |   IcebergType |
+	 * +--------------+-------+-------+
+	 */
+
+	// TYPE values are taken from Type enum.
+	static final int ICEBERG_TYPE_MASK = 3;
+	static final int ICEBERG_TYPE_SHIFT = 0;
+
+	// ========================= instance =========================
+
+	private double icebergPeakSize = Double.NaN;
+	private double icebergHiddenSize = Double.NaN;
+	private double icebergExecutedSize = Double.NaN;
+	private int icebergFlags;
+
+	/**
+	 * Creates new analytic order with default values.
+	 */
+	public AnalyticOrder() {
+	}
+
+	/**
+	 * Creates new analytic order with the specified event symbol.
+	 *
+	 * @param eventSymbol event symbol.
+	 */
+	public AnalyticOrder(String eventSymbol) {
+		super(eventSymbol);
+	}
+
+	/**
+	 * Returns iceberg peak size of this analytic order.
+	 *
+	 * @return iceberg peak size of this analytic order.
+	 */
+	public double getIcebergPeakSize() {
+		return icebergPeakSize;
+	}
+
+	/**
+	 * Changes iceberg peak size of this analytic order.
+	 *
+	 * @param icebergPeakSize iceberg peak size of this analytic order.
+	 */
+	public void setIcebergPeakSize(double icebergPeakSize) {
+		this.icebergPeakSize = icebergPeakSize;
+	}
+
+	/**
+	 * Returns iceberg hidden size of this analytic order.
+	 *
+	 * @return iceberg hidden size of this analytic order.
+	 */
+	public double getIcebergHiddenSize() {
+		return icebergHiddenSize;
+	}
+
+	/**
+	 * Changes iceberg hidden size of this analytic order.
+	 *
+	 * @param icebergHiddenSize iceberg hidden size of this analytic order.
+	 */
+	public void setIcebergHiddenSize(double icebergHiddenSize) {
+		this.icebergHiddenSize = icebergHiddenSize;
+	}
+
+	/**
+	 * Returns iceberg executed size of this analytic order.
+	 *
+	 * @return iceberg executed size of this analytic order.
+	 */
+
+	public double getIcebergExecutedSize() {
+		return icebergExecutedSize;
+	}
+
+	/**
+	 * Changes iceberg executed size of this analytic order.
+	 *
+	 * @param icebergExecutedSize iceberg executed size of this analytic order.
+	 */
+	public void setIcebergExecutedSize(double icebergExecutedSize) {
+		this.icebergExecutedSize = icebergExecutedSize;
+	}
+
+	/**
+	 * Returns iceberg type of this analytic order.
+	 *
+	 * @return iceberg type of this analytic order.
+	 */
+	public IcebergType getIcebergType() {
+		return IcebergType.valueOf(Util.getBits(icebergFlags, ICEBERG_TYPE_MASK, ICEBERG_TYPE_SHIFT));
+	}
+
+	/**
+	 * Changes iceberg type of this analytic order.
+	 *
+	 * @param icebergType iceberg type of this analytic order.
+	 */
+	public void setIcebergType(IcebergType icebergType) {
+		icebergFlags = Util.setBits(icebergFlags, ICEBERG_TYPE_MASK, ICEBERG_TYPE_SHIFT, icebergType.getCode());
+	}
+
+	/**
+	 * Returns string representation of this analytic order.
+	 *
+	 * @return string representation of this analytic order.
+	 */
+	@Override
+	public String toString() {
+		return "AnalyticOrder{" + baseFieldsToString() +
+			", icebergPeakSize=" + icebergPeakSize +
+			", icebergHiddenSize=" + icebergHiddenSize +
+			", icebergExecutedSize=" + icebergExecutedSize +
+			", icebergType=" + getIcebergType() +
+			"}";
+	}
+
+	// ========================= package private access for delegate =========================
+
+	/**
+	 * Returns implementation-specific flags relevant only for iceberg related part of analytic order.
+	 * <b>Do not use this method directly.</b>
+	 * It may be removed or changed in the future versions.
+	 *
+	 * @return iceberg flags.
+	 */
+	int getIcebergFlags() {
+		return icebergFlags;
+	}
+
+	/**
+	 * Changes implementation-specific flags relevant only for iceberg related part of analytic order.
+	 * <b>Do not use this method directly.</b>
+	 * It may be removed or changed in the future versions.
+	 *
+	 * @param icebergFlags iceberg flags.
+	 */
+	void setIcebergFlags(int icebergFlags) {
+		this.icebergFlags = icebergFlags;
+	}
+}

dxfeed-api/src/main/java/com/dxfeed/event/market/IcebergType.java

@@ -0,0 +1,63 @@
+/*
+ * !++
+ * QDS - Quick Data Signalling Library
+ * !-
+ * Copyright (C) 2002 - 2019 Devexperts LLC
+ * !-
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at
+ * http://mozilla.org/MPL/2.0/.
+ * !__
+ */
+package com.dxfeed.event.market;
+
+/**
+ * Type of an iceberg order.
+ */
+public enum IcebergType {
+
+	/**
+	 * Iceberg type is undefined, unknown or inapplicable.
+	 */
+	UNDEFINED(0),
+
+	/**
+	 * Represents native (exchange-managed) iceberg type.
+	 */
+	NATIVE(1),
+
+	/**
+	 * Represents synthetic (managed outside of the exchange) iceberg type
+	 */
+	SYNTHETIC(2);
+
+	private static final IcebergType[] TYPES = Util.buildEnumArrayByOrdinal(UNDEFINED, 3);
+
+	/**
+	 * Returns iceberg type by integer code bit pattern.
+	 *
+	 * @param code integer code.
+	 * @return iceberg type.
+	 * @throws ArrayIndexOutOfBoundsException if code is invalid.
+	 */
+	public static IcebergType valueOf(int code) {
+		return TYPES[code];
+	}
+
+	private final int code;
+
+	private IcebergType(int code) {
+		this.code = code;
+		if (code != ordinal())
+			throw new IllegalArgumentException("code differs from ordinal");
+	}
+
+	/**
+	 * Returns integer code that is used in flag bits.
+	 *
+	 * @return integer code.
+	 */
+	public int getCode() {
+		return code;
+	}
+}