DXFeedSubscription (dxFeed API 3.319)

java.lang.Object
- com.dxfeed.api.DXFeedSubscription<E>

Type Parameters:

E - the type of events.

All Implemented Interfaces:

ObservableSubscription<E>, Serializable, AutoCloseable

Direct Known Subclasses:

DXFeedTimeSeriesSubscription
```
public class DXFeedSubscription<E>
extends Object
implements Serializable, ObservableSubscription<E>, AutoCloseable
```
Subscription for a set of symbols and event types.
Symbols and event types
Symbols are represented by objects, simple keys are represented by String objects, complex ones use specialized object as described in the corresponding event types. However, every symbol has a unique string representation that can be used. Each event is represented by a concrete instance of event class. Event type is represented by a class literal. For example,
- "SPY" is a symbol for SPDR S&P 500 ETF,
- Quote.class is an event type for a best market quote.
Events can be represented by any classes that annotated by an inheritable annotation EventType. Common types of market events extend MarketEvent class and reside in com.dxfeed.event.market package.
The set of subscribed symbols and the set of subscribed event types are maintained separately. The subscription is considered to be interested in the cross-product of these sets. That is, subscription is interested in any event whose type is in the set of subscribed event types and whose symbol is in the set of subscribed symbols.
The set of event types is specified when subscription is created and cannot be changed afterward. The set of symbols can be modified with setSymbols, addSymbols, removeSymbols, and clear methods. Each of xxxSymbols method exists in two version. One version accepts a Collection of symbols and it recommended for bulk modifications of symbol set. The other version accepts varargs arrays of symbols and is provided as a convenience method to set/add/remove one or few symbols.
Symbols in a set are compared using their equals method. All symbol objects must properly support hashCode method. A set of symbols cannot contain two equal symbols. If a symbol that is added to a set of symbols is equal to the other one, then the old symbol is removed from the set and the new symbol instance is retained. However, the ObservableSubscriptionChangeListener (see below) in this case is notified on the change of subscription only when new symbol object implements FilteredSubscriptionSymbol marker interface.
Special symbol types and restrictions
A single object WildcardSymbol.ALL represents subscription to all possible symbols and have the effect of subscribing to all of them. See WildcardSymbol for more details. It is always represented by a separate class (instead of a usual String) in order to avoid potential resource consumption problems that may stem from an accidental subscription via wildcard. All string symbols that start with WildcardSymbol.RESERVED_PREFIX ("*") are reserved for the same reason. Subscription to the corresponding string does not have any effect (no events will be received). Thus, it is safe to add user-specified strings to the subscription via addSymbols method without any prior validation of the user input.
NOTE: Wildcard subscription can create extremely high network and CPU load for certain kinds of high-frequency events like quotes. It requires a special arrangement on the side of upstream data provider and is disabled by default in upstream feed configuration. Make that sure you have adequate resources and understand the impact before using it. It can be used for low-frequency events only (like Forex quotes), because each instance of DXFeedSubscription processes events in a single thread and there is no provision to load-balance wildcard subscription amongst multiple threads. Contact your data provider for the corresponding configuration arrangement if needed.
A special class of TimeSeriesSubscriptionSymbol symbols is used internally to represent a subscription to time-series of events. Two instances of TimeSeriesSubscriptionSymbol objects are equal when their underlying symbols are equal, thus only one, most recently added, instance of TimeSeriesSubscriptionSymbol will be kept in the set of subscribed symbols.
It is recommended to use DXFeedTimeSeriesSubscription convenience class for time-series subscriptions.
Candle events use CandleSymbol class to represent the complex structure of the candle symbol and its attributes. However, both String and CandleSymbol objects can be used in subscription. The corresponding strings will be converted to CandleSymbol using its valueOf method. Do not mix String and CandleSymbol subscription in a single DXFeedSubscription instance.
Subscription listeners
This class keeps a list of DXFeedEventListener instances that are notified on any events. Event listeners are added with addEventListener method. Event listeners must be installed before changing the set of subscribed symbols. When the set of subscribed symbols changes all registered event listeners receive update on the last events for all newly added symbols.
This class keeps a set of ObservableSubscriptionChangeListener instances that are notified on any change in subscription. These listeners are installed by DXFeed to keep track of the subscription state and communicate subscription upstream to data providers.
Detached and attached subscriptions
Subscription that is created via constructor is detached. It is not attached to any feed and thus it does not actually receive any events. Detached subscription still maintains a set of symbols and a list of event listeners. Detached subscription can be attached to any feed with DXFeed.attachSubscription method.
Subscription that is created via DXFeed.createSubscription is attached to the corresponding feed. The feed tracks all changes in subscription by installing ObservableSubscriptionChangeListener and invokes processEvents for all received events. Subscription can be detached from the feed with DXFeed.detachSubscription method.
Subscription can be attached to multiple feeds at the same time. In this case it receives events from all feeds but there is no way distinguish which feed the corresponding event came from.
Resource management and closed subscriptions
Attached subscription is a potential memory leak. If the pointer to attached subscription is lost, then there is no way to detach this subscription from the feed and the subscription will not be reclaimed by the garbage collector as long as the corresponding feed is still used. Detached subscriptions can be reclaimed by the garbage collector, but detaching subscription requires knowing the pointer to the feed at the place of the call, which is not always convenient.
The convenient way to detach subscription from the feed is to call its close method. Closed subscription becomes permanently detached from all feeds, removes all its listeners and is guaranteed to be reclaimable by the garbage collector as soon as all external references to it are cleared.
The other way is to close an associated feed. This cannot be done via a DXFeed instance, but it can be done indirectly by closing the associated endpoint.
Serialization
This class's serialized state includes only serializable listeners. ObservableSubscriptionChangeListener that is installed by DXFeed when this subscription is attached is not serializable. Thus, freshly deserialized instance of this class will be detached. It has to be attached to the feed after deserialization in order for it to start receiving events.
Threads and locks
This class is thread-safe and can be used concurrently from multiple threads without external synchronization.
Installed DXFeedEventListener instances are invoked from a separate thread via the executor. Default executor for all subscriptions is configured with DXEndpoint.executor method. Each subscription can individually override its executor with setExecutor method.
Event listeners are invoked in a serial manner with respect to a given DXFeedSubscription instance. That is, next event notification will not be performed until DXFeedEventListener.eventsReceived method for the previous notification completes. It guarantees that the order of events in a given instance of DXFeedSubscription is preserved.
This requirement on ordering limits concurrency of event processing. Effectively, each subscription can use at most one CPU core to process its events. If there is a need to simultaneously process events on a large number of symbols and this event processing is so resource-consuming, that one CPU core is not enough to process all events in real-time, then it is advised to split symbols between multiple DXFeedSubscription instances. If event processing is mostly CPU-bound, then the good rule of thumb is to have as many DXFeedSubscription instances as there are CPU cores in the system.
However, multiple tasks can get submitted to the executor at the same time. In the current implementation, at most two tasks are submitted at any time if DXFEED_AGGREGATION_PERIOD_PROPERTY is used. One task for immediate processing of data snapshots via Executor.execute method and another task for delayed processing of data updates via ScheduledExecutorService.schedule method if the executor implements ScheduledExecutorService interface. At most one task is submitted at any time if this property is not used.
Installed ObservableSubscriptionChangeListener instances are notified on symbol set changes while holding the lock on this subscription and in the same thread that changed the set of subscribed symbols in this subscription.
Custom executor can be used by backend applications that do not need to immediately retrieve a collection of events, but want to poll for new events at a later time, for example, from inside of a servlet request. The following code pattern is suggested in this case to initialize subscription's executor:
```
 ConcurrentLinkedQueue<Runnable> taskQueue = new ConcurrentLinkedQueue<>();
 subscription.setExecutor(new Executor() {
     public void execute(Runnable task) {
         taskQueue.add(task);
     }
 });
 subscription.addEventListener(...);
 
```
When there is a time to poll for new events, the following code can be used:
```
 Runnable task;
 while ((task = taskQueue.poll()) != null)
     task.run();
 
```
and event listener's eventsReceived method will be invoked in this thread from inside of task.run() invocation.
This approach has a clear advantage with LastingEvent types. If the above polling code is delayed or is executed only periodically, then incoming events have a chance to get conflated and listener will receive only on the most recent event updates for processing.
See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description
`DXFeedSubscription(Class<? extends E>... eventTypes)` Creates detached subscription for the given list of event types.
`DXFeedSubscription(Class<? extends E> eventType)` Creates detached subscription for a single event type.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addChangeListener(ObservableSubscriptionChangeListener listener)` Adds subscription change listener.
`void`	`addEventListener(DXFeedEventListener<E> listener)` Adds listener for events.
`void`	`addSymbols(Collection<?> symbols)` Adds the specified collection of symbols to the set of subscribed symbols.
`void`	`addSymbols(Object... symbols)` Adds the specified array of symbols to the set of subscribed symbols.
`void`	`addSymbols(Object symbol)` Adds the specified symbol to the set of subscribed symbols.
`void`	`attach(DXFeed feed)` Attaches subscription to the specified feed.
`void`	`clear()` Clears the set of subscribed symbols.
`void`	`close()` Closes this subscription and makes it permanently detached.
`boolean`	`containsEventType(Class<?> eventType)` Returns `true` if this subscription contains the corresponding event type.
`protected Object`	`decorateSymbol(Object symbol)` Decorates the specified symbol after it was received from the `DXFeedSubscription` client code before it goes to installed `ObservableSubscriptionChangeListener` instances.
`void`	`detach(DXFeed feed)` Detaches subscription from the specified feed.
`Set<?>`	`getDecoratedSymbols()` Returns a set of decorated symbols (depending on the actual implementation class of `DXFeedSubscription`).
`Set<Class<? extends E>>`	`getEventTypes()` Returns a set of subscribed event types.
`Executor`	`getExecutor()` Returns executor for processing event notifications on this subscription.
`Set<?>`	`getSymbols()` Returns a set of subscribed symbols.
`boolean`	`isClosed()` Returns `true` if this subscription is closed.
`void`	`removeChangeListener(ObservableSubscriptionChangeListener listener)` Removes subscription change listener.
`void`	`removeEventListener(DXFeedEventListener<E> listener)` Removes listener for events.
`void`	`removeSymbols(Collection<?> symbols)` Removes the specified collection of symbols from the set of subscribed symbols.
`void`	`removeSymbols(Object... symbols)` Removes the specified array of symbols from the set of subscribed symbols.
`void`	`setExecutor(Executor executor)` Changes executor for processing event notifications on this subscription.
`void`	`setSymbols(Collection<?> symbols)` Changes the set of subscribed symbols so that it contains just the symbols from the specified collection.
`void`	`setSymbols(Object... symbols)` Changes the set of subscribed symbols so that it contains just the symbols from the specified array.
`protected boolean`	`shallNotifyOnSymbolUpdate(Object symbol, Object oldSymbol)` Compares newly added symbol with the old one that was present before for the purpose of notifying `installed` `ObservableSubscriptionChangeListener` about the change.
`protected Object`	`undecorateSymbol(Object symbol)` Undoes the decoration of the specified symbol doing the reverse operation to `decorateSymbol(Object)`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DXFeedSubscription
```
public DXFeedSubscription(Class<? extends E> eventType)
```
    Creates detached subscription for a single event type.
    
    Parameters:
    
    eventType - the event type.
    
    Throws:
    
    NullPointerException - if event type is null.
  - DXFeedSubscription
```
@SafeVarargs
public DXFeedSubscription(Class<? extends E>... eventTypes)
```
    Creates detached subscription for the given list of event types.
    
    Parameters:
    
    eventTypes - the list of event types.
    
    Throws:
    
    IllegalArgumentException - if the list of event types is empty.
    
    NullPointerException - if any event type is null.
- Method Detail
  - attach
```
public void attach(DXFeed feed)
```
    Attaches subscription to the specified feed.
    
    Parameters:
    
    feed - feed to attach to.
  - detach
```
public void detach(DXFeed feed)
```
    Detaches subscription from the specified feed.
    
    Parameters:
    
    feed - feed to detach from.
  - isClosed
```
public boolean isClosed()
```
    Returns true if this subscription is closed.
    
    Specified by:
    
    isClosed in interface ObservableSubscription<E>
    
    See Also:
    
    close()
  - close
```
public void close()
```
    Closes this subscription and makes it permanently detached. This method notifies all installed ObservableSubscriptionChangeListener instances by invoking subscriptionClosed while holding the lock for this subscription. This method clears lists of all installed event listeners and subscription change listeners and makes sure that no more listeners can be added.
    This method ensures that subscription can be safely garbage-collected when all outside references to it are lost.
    
    Specified by:
    
    close in interface AutoCloseable
  - getEventTypes
```
public Set<Class<? extends E>> getEventTypes()
```
    Returns a set of subscribed event types. The resulting set cannot be modified.
    
    Specified by:
    
    getEventTypes in interface ObservableSubscription<E>
  - containsEventType
```
public boolean containsEventType(Class<?> eventType)
```
    Returns true if this subscription contains the corresponding event type.
    
    Specified by:
    
    containsEventType in interface ObservableSubscription<E>
    
    See Also:
    
    getEventTypes()
  - clear
```
public void clear()
```
    Clears the set of subscribed symbols. This implementation calls
```
setSymbols(Collections.EMPTY_LIST)
```
  - getSymbols
```
public Set<?> getSymbols()
```
    Returns a set of subscribed symbols. The resulting set cannot be modified. The contents of the resulting set are undefined if the set of symbols is changed after invocation of this method, but the resulting set is safe for concurrent reads from any threads. The resulting set maybe either a snapshot of the set of the subscribed symbols at the time of invocation or a weakly consistent view of the set.
  - getDecoratedSymbols
```
public Set<?> getDecoratedSymbols()
```
    Returns a set of decorated symbols (depending on the actual implementation class of DXFeedSubscription).
    The resulting set cannot be modified. The contents of the resulting set are undefined if the set of symbols is changed after invocation of this method, but the resulting set is safe for concurrent reads from any threads. The resulting set maybe either a snapshot of the set of the subscribed symbols at the time of invocation or a weakly consistent view of the set.
  - setSymbols
```
public void setSymbols(Collection<?> symbols)
```
    Changes the set of subscribed symbols so that it contains just the symbols from the specified collection. To conveniently set subscription for just one or few symbols you can use setSymbols(Object... symbols) method. All registered event listeners will receive update on the last events for all newly added symbols.
    Implementation notes
    This method notifies all installed ObservableSubscriptionChangeListener instances of any resulting changes in the set of subscribed symbols while holding the lock for this subscription.
    This implementation decorates symbols via protected decorateSymbol(Object) method, that can be overridden in subclasses of DXFeedSubscription. Installed ObservableSubscriptionChangeListener instances receive decorated symbols.
    
    Parameters:
    
    symbols - the collection of symbols.
  - setSymbols
```
public void setSymbols(Object... symbols)
```
    Changes the set of subscribed symbols so that it contains just the symbols from the specified array. This is a convenience method to set subscription to one or few symbols at a time. When setting subscription to multiple symbols at once it is preferable to use setSymbols(Collection<?> symbols) method. All registered event listeners will receive update on the last events for all newly added symbols.
    Implementation notes
    This method notifies all installed ObservableSubscriptionChangeListener instances of any resulting changes in the set of subscribed symbols while holding the lock for this subscription.
    This implementation decorates symbols via protected decorateSymbol(Object) method, that can be overridden in subclasses of DXFeedSubscription. Installed ObservableSubscriptionChangeListener instances receive decorated symbols.
    
    Parameters:
    
    symbols - the array of symbols.
  - addSymbols
```
public void addSymbols(Collection<?> symbols)
```
    Adds the specified collection of symbols to the set of subscribed symbols. To conveniently add one or few symbols you can use addSymbols(Object... symbols) method. All registered event listeners will receive update on the last events for all newly added symbols.
    Implementation notes
    This method notifies all installed ObservableSubscriptionChangeListener instances of any resulting changes in the set of subscribed symbols while holding the lock for this subscription.
    This implementation decorates symbols via protected decorateSymbol(Object) method, that can be overridden in subclasses of DXFeedSubscription. Installed ObservableSubscriptionChangeListener instances receive decorated symbols.
    
    Parameters:
    
    symbols - the collection of symbols.
  - addSymbols
```
public void addSymbols(Object... symbols)
```
    Adds the specified array of symbols to the set of subscribed symbols. This is a convenience method to subscribe to one or few symbols at a time. When subscribing to multiple symbols at once it is preferable to use addSymbols(Collection<?> symbols) method. All registered event listeners will receive update on the last events for all newly added symbols.
    Implementation notes
    This method notifies all installed ObservableSubscriptionChangeListener instances of any resulting changes in the set of subscribed symbols while holding the lock for this subscription.
    This implementation decorates symbols via protected decorateSymbol(Object) method that can be overridden in subclasses of DXFeedSubscription. Installed ObservableSubscriptionChangeListener instances receive decorated symbols.
    
    Parameters:
    
    symbols - the array of symbols.
  - addSymbols
```
public void addSymbols(Object symbol)
```
    Adds the specified symbol to the set of subscribed symbols. This is a convenience method to subscribe to one symbol at a time that has a return fast-path for a case when the symbol is already in the set. When subscribing to multiple symbols at once it is preferable to use addSymbols(Collection<?> symbols) method. All registered event listeners will receive update on the last events for all newly added symbols.
    Implementation notes
    This method notifies all installed ObservableSubscriptionChangeListener instances of any resulting changes in the set of subscribed symbols while holding the lock for this subscription.
    This implementation decorates symbols via protected decorateSymbol(Object) method that can be overridden in subclasses of DXFeedSubscription. Installed ObservableSubscriptionChangeListener instances receive decorated symbols.
    
    Parameters:
    
    symbol - the symbol.
  - removeSymbols
```
public void removeSymbols(Collection<?> symbols)
```
    Removes the specified collection of symbols from the set of subscribed symbols. To conveniently remove one or few symbols you can use removeSymbols(Object... symbols) method.
    Implementation notes
    This method notifies all installed ObservableSubscriptionChangeListener instances of any resulting changes in the set of subscribed symbols while holding the lock for this subscription.
    This implementation decorates symbols via protected decorateSymbol(Object) method, that can be overridden in subclasses of DXFeedSubscription. Installed ObservableSubscriptionChangeListener instances receive decorated symbols.
    
    Parameters:
    
    symbols - the collection of symbols.
  - removeSymbols
```
public void removeSymbols(Object... symbols)
```
    Removes the specified array of symbols from the set of subscribed symbols. This is a convenience method to remove one or few symbols at a time. When removing multiple symbols at once it is preferable to use removeSymbols(Collection<?> symbols) method.
    Implementation notes
    This method notifies all installed ObservableSubscriptionChangeListener instances of any resulting changes in the set of subscribed symbols while holding the lock for this subscription.
    This implementation decorates symbols via protected decorateSymbol(Object) method, that can be overridden in subclasses of DXFeedSubscription. Installed ObservableSubscriptionChangeListener instances receive decorated symbols.
    
    Parameters:
    
    symbols - the array of symbols.
  - getExecutor
```
public Executor getExecutor()
```
    Returns executor for processing event notifications on this subscription. See Threads and locks section of this class documentation.
    
    Returns:
    
    executor for processing event notifications on this subscription, or null if default executor of the attached DXFeed is used.
  - setExecutor
```
public void setExecutor(Executor executor)
```
    Changes executor for processing event notifications on this subscription. See Threads and locks section of this class documentation.
    
    Parameters:
    
    executor - executor for processing event notifications on this subscription, or null if default executor of the attached DXFeed is used.
  - addEventListener
```
public void addEventListener(DXFeedEventListener<E> listener)
```
    Adds listener for events. Event lister can be added only when subscription is not producing any events. The subscription must be either empty (its set of symbols is empty) or not attached to any feed (its set of change listeners is empty). This method does nothing if this subscription is closed.
    
    Parameters:
    
    listener - the event listener.
    
    Throws:
    
    NullPointerException - if listener is null.
    
    IllegalStateException - if subscription is attached and is not empty.
  - removeEventListener
```
public void removeEventListener(DXFeedEventListener<E> listener)
```
    Removes listener for events.
    
    Parameters:
    
    listener - the event listener.
    
    Throws:
    
    NullPointerException - if listener is null.
  - addChangeListener
```
public void addChangeListener(ObservableSubscriptionChangeListener listener)
```
    Adds subscription change listener. This method does nothing if the given listener is already installed as subscription change listener for this subscription or if subscription is closed. Otherwise, it installs the corresponding listener and immediately invokes ObservableSubscriptionChangeListener.symbolsAdded(java.util.Set<?>) on the given listener while holding the lock for this subscription. This way the given listener synchronously receives existing subscription state and and is synchronously notified on all changes in subscription afterwards.
    Whenever a symbol in a set of subscribed symbols is replaced by the other symbol that is equal to the old one, the decision on whether to notify installed listeners about the change is based on the result of shallNotifyOnSymbolUpdate method.
    
    Specified by:
    
    addChangeListener in interface ObservableSubscription<E>
    
    Parameters:
    
    listener - the subscription change listener.
    
    Throws:
    
    NullPointerException - if listener is null.
  - removeChangeListener
```
public void removeChangeListener(ObservableSubscriptionChangeListener listener)
```
    Removes subscription change listener. This method does nothing if the given listener was not installed or was already removed as subscription change listener for this subscription. Otherwise it removes the corresponding listener and immediately invokes ObservableSubscriptionChangeListener.subscriptionClosed() on the given listener while holding the lock for this subscription.
    
    Specified by:
    
    removeChangeListener in interface ObservableSubscription<E>
    
    Parameters:
    
    listener - the subscription change listener.
    
    Throws:
    
    NullPointerException - if listener is null.
  - decorateSymbol
```
protected Object decorateSymbol(Object symbol)
```
    Decorates the specified symbol after it was received from the DXFeedSubscription client code before it goes to installed ObservableSubscriptionChangeListener instances. This method can be overridden in subclasses. See DXFeedTimeSeriesSubscription for an example. This implementation throws NullPointerException if symbol is null or returns symbol otherwise.
    
    Parameters:
    
    symbol - the symbol to decorate.
    
    Returns:
    
    decorated symbol
    
    Throws:
    
    NullPointerException - if symbol is null.
  - undecorateSymbol
```
protected Object undecorateSymbol(Object symbol)
```
    Undoes the decoration of the specified symbol doing the reverse operation to decorateSymbol(Object). This method can be overridden in subclasses. See DXFeedTimeSeriesSubscription for an example. This implementation throws NullPointerException if symbol is null or returns symbol otherwise.
    
    Parameters:
    
    symbol - the symbol to undecorate.
    
    Returns:
    
    undecorated symbol
    
    Throws:
    
    NullPointerException - if symbol is null.
  - shallNotifyOnSymbolUpdate
```
protected boolean shallNotifyOnSymbolUpdate(@Nonnull
                                            Object symbol,
                                            @Nullable
                                            Object oldSymbol)
```
    Compares newly added symbol with the old one that was present before for the purpose of notifying installed ObservableSubscriptionChangeListener about the change. This method returns false if the new symbol shall be considered the same one and no notification is needed. The attached listeners get symbolsAdded notification for all symbols that this method returns true for.
    This implementation compares instances of FilteredSubscriptionSymbol by their reference (this implementation returns true when symbol != oldSymbol), because their equals and hashCode do not take input account their filter part. Notification for all other types of symbols (like String) is optimized away (this implementation returns true only when oldSymbol == null).
    
    Parameters:
    
    symbol - the recently added symbol to this subscription (not null).
    
    oldSymbol - the previous symbol from the set of symbol based on equal/hashCode search in a hash set or null if it did not present before.
    
    Returns:
    
    true if listeners shall be notified on the change in the set of subscribed symbols.

Class DXFeedSubscription<E>

Symbols and event types

Special symbol types and restrictions

Subscription listeners

Detached and attached subscriptions

Resource management and closed subscriptions

Serialization

Threads and locks

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DXFeedSubscription

DXFeedSubscription

Method Detail

attach

detach

isClosed

close

getEventTypes

containsEventType

clear

getSymbols

getDecoratedSymbols

setSymbols

Implementation notes

setSymbols

Implementation notes

addSymbols

Implementation notes

addSymbols

Implementation notes

addSymbols

Implementation notes

removeSymbols

Implementation notes

removeSymbols

Implementation notes

getExecutor

setExecutor

addEventListener

removeEventListener

addChangeListener

removeChangeListener

decorateSymbol

undecorateSymbol

shallNotifyOnSymbolUpdate