Deprecated Services

           /**
            * @return all retained messages which are currently stored
            */
           public Set<RetainedMessage> getRetainedMessages();

           /**
            * @param topic a topic
            * @return retained message for the specific topic, otherwise an Optional
            *         instance with an empty reference
            */
           public Optional<RetainedMessage> getRetainedMessage(String topic);

           /**
            * Removes the retained message from given topic. null values are ignored.
            * If there isn't any retained message on the topic yet, nothing will happen.
            *
            * @param topic from which the message should be removed
            */
           public void remove(String topic);

           /**
            * Removes a given retained message. null values are ignored.
            * If the given retained message doesn't exist, nothing will happen.
            *
            * @param retainedMessage which should be removed
            */
           public void remove(RetainedMessage retainedMessage);

           /**
            * Removes all retained messages from the message store.
            */
           public void clear();

           /**
            * This method adds or replaces a retained message
            *
            * @param retainedMessage which should be added or replaced
            */
           public void addOrReplace(RetainedMessage retainedMessage);

           /**
            * Checks if the retained message is present in the retained message store.
            * Only the topic is of a retained message is considered for this check, QoS and message are ignored.
            *
            * @param retainedMessage to check if it's already in the message store
            * @return true if there's already a message on the topic of the given retained message
            */
           public boolean contains(RetainedMessage retainedMessage);

           /**
            * @return the number of all retained messages
            */
           public int size();

    /**
     * This method returns all subscriptions on this HiveMQ Node as a {@link com.google.common.collect.Multimap} of client identifiers and topics.
     * You won't receive subscriptions of connected
     * clients from other HiveMQ nodes if HiveMQ runs in a cluster.
     * <p/>
     * Please be aware that calling this method on HiveMQ instances with many subscriptions could have
     * negative performance effects.
     * <p/>
     * The returned Multimap is read-only and must not be modified.
     *
     * @return a {@link com.google.common.collect.Multimap} of client identifiers and their topic subscriptions
     */
    @ReadOnly
    Multimap<String, Topic> getLocalSubscriptions();

    /**
     * Returns all MQTT client subscriber identifiers for a given topic, for this HiveMQ instance.
     * MQTT Wildcards are allowed.
     * <p/>
     * Don't pass <code>null</code> as topic. This method is lenient, so
     * it will just return an empty Set.
     * <p/>
     * The returned Set is read-only and must not be modified.
     *
     * @param topic the topic
     * @return client identifiers of all subscribers that subscribed to the topic
     */
    @ReadOnly
    Set<String> getLocalSubscribers(@NotNull String topic);

    /**
     * Returns all topics a client is subscribed to, on this HiveMQ instance.
     * <p/>
     * If the client does not exist, an empty Set is returned.
     * <p/>
     * Don't pass <code>null</code> as clientId. This method is lenient, so
     * it will just return an empty Set.
     * <p/>
     * The returned Set is read-only and must not be modified.
     *
     * @param clientID of the client
     * @return all topics the client subscribed to
     */
    @ReadOnly
    Set<Topic> getLocalTopics(@NotNull String clientID);

    /**
     * This method adds a subscription for a certain client to a certain topic.
     * If HiveMQ is connected to a cluster, the subscription will be broadcast to all other Cluster Nodes.
     * <p/>
     * This method is lenient, so if the clientId or the topic
     * is <code>null</code>, nothing will happen.
     *
     * @param clientID client, which should be subscribed
     * @param topic    topic to which the client should be subscribed
     * @return A {@link com.google.common.util.concurrent.ListenableFuture} object that will succeed,
     * as soon es the subscription was added by all Cluster Nodes.
     */
    ListenableFuture<Void> addSubscription(@NotNull String clientID, @NotNull Topic topic);

    /**
     * This method removes a subscription for a certain client and a certain topic.
     * If HiveMQ is connected to a cluster, the subscription will be removed by other Cluster Nodes as well.
     *
     * @param clientID client, which should get unsubscribed
     * @param topic    topic from which the client should get unsubscribed
     * @return A {@link com.google.common.util.concurrent.ListenableFuture} object that will succeed,
     * as soon es the subscription was removed by all Cluster Nodes.
     */
    ListenableFuture<Void> removeSubscription(@NotNull String clientID, @NotNull String topic);

    /**
     * This method returns all subscriptions this HiveMQ instance and all other nodes in a HiveMQ cluster,
     * as a {@link com.google.common.collect.Multimap} of client identifiers and topics.
     * <p/>
     * Please be aware that calling this method on HiveMQ instances with many subscriptions could have
     * negative performance effects.
     * <p/>
     * The returned Multimap is read-only and must not be modified.
     *
     * @return a {@link com.google.common.collect.Multimap} of client identifiers and their topic subscriptions
     */
    @ReadOnly
    ListenableFuture<Multimap<String, Topic>> getSubscriptions();

    /**
     * Returns all MQTT client subscriber identifiers for a given topic, this HiveMQ instance and all other nodes in a HiveMQ cluster.
     * MQTT Wildcards are allowed.
     * <p/>
     * Don't pass <code>null</code> as topic. This method is lenient, so
     * it will just return an empty Set.
     * <p/>
     * The returned Set is read-only and must not be modified.
     *
     * @param topic the topic
     * @return client identifiers of all subscribers that subscribed to the topic
     */
    @ReadOnly
    ListenableFuture<Set<String>> getSubscribers(@NotNull String topic);

    /**
     * Returns all topics a client is subscribed to, on this HiveMQ instance and all other nodes in a HiveMQ cluster.
     * <p/>
     * If the client does not exist, an empty Set is returned.
     * <p/>
     * Don't pass <code>null</code> as clientId. This method is lenient, so
     * it will just return an empty Set.
     * <p/>
     * The returned Set is read-only and must not be modified.
     *
     * @param clientID of the client
     * @return all topics the client subscribed to
     */
    @ReadOnly
    ListenableFuture<Set<Topic>> getTopics(@NotNull String clientID);

    /**
     * Returns all identifiers of connected clients of this HiveMQ Node. You won't receive client identifiers of connected
     * clients from other HiveMQ nodes if HiveMQ runs in a cluster.
     *

     * If you have many client connections, please not that calling this method frequently could have negative performance
     * effects.
     *
     * @return client identifiers of all connected clients
     */
    Set<string> getLocalConnectedClients();

    /**
     * Returns all disconnected clients which have a persistent MQTT session on this instance of HiveMQ (MQTT clean session=false).
     * </string>

     * Disconnected MQTT clients which don't have a persistent session won't be returned by this method
     *
     * @return all disconnected clients with a persistent MQTT session
     */
    Set<string> getLocalDisconnectedClients();

    /**
     * Check if a client with a given identifier is currently connected to this HiveMQ instance.
     *
     * @param clientId client, which should be checked
     * @return true, if a certain client is currently connected and false otherwise
     */
    boolean isClientConnectedLocal(String clientId);

    /**
     * Returns client information for clients that are connected to this broker instance.
     * </string>

     * If the client isn't connected, you will receive an {@link Optional} with absent data.
     *
     * @param clientId the client identifier of the client
     * @return {@link ClientData} for a specific client.
     */
    Optional<clientdata> getLocalClientDataForClientId(String clientId);

    /**
     * Returns all identifiers of connected clients of this HiveMQ instance and all other nodes in a HiveMQ cluster
     * </clientdata>

     * Calling this method frequently in a clustered environment could have negative performance effects.
     *
     * @return client identifiers of all connected clients
     */
    ListenableFuture<set<string>> getConnectedClients();

    /**
     * Returns all disconnected clients which have a persistent MQTT session on this broker or any other cluster node.
     * </set<string>

     * Disconnected MQTT clients which don't have a persistent session won't be returned by this method
     *
     * @return all disconnected clients with a persistent MQTT session
     */
    ListenableFuture<set<string>> getDisconnectedClients();

    /**
     * Check if a client with a given identifier is currently connected to this HiveMQ broker instance or any other instance in the cluster.
     *
     * @param clientId client, which should be checked
     * @return true, if a certain client is currently connected and false otherwise
     */
    ListenableFuture<boolean> isClientConnected(final String clientId);

    /**
     * Returns additional client information about a given client with a given client identifier.
     * </boolean></set<string>

     * This method will also get client information from other cluster nodes if needed.
     *

     * If the client isn't connected, you will receive an {@link Optional} with absent data.
     *
     * @param clientId the client identifier of the client
     * @return {@link ClientData} for a specific client.
     */
    ListenableFuture<optional<clientdata>> getClientDataForClientId(final String clientId);

    /**
     * Returns a specific HiveMQ metric. If the metric does not exist, this method will return
     * <code>null</code>.
     * <p/>
     * For a list of all available metrics, refer to the {@link com.hivemq.spi.metrics.HiveMQMetrics} constant class.
     *
     * @param metric the metric
     * @param <T>    the metric type
     * @return the metric (if available) or <code>null</code>
     */
    @Nullable
    <T extends Metric> T getHiveMQMetric(HiveMQMetric<T> metric);

    /**
     * Returns the metric registry of HiveMQ.
     *
     * @return the metric registry
     */
    MetricRegistry getMetricRegistry();

@ThreadSafe
public interface SharedSubscriptionService {

    /**
     * Adds shared subscriptions to the SharedSubscriptionService.
     *

     * Although the contract of this method is to disallow null values, this method is lenient.
     * If ``null`` values are passed, these values are ignored.
     *
     * @param sharedSubscriptions the shared subscriptions to add
     */
    void addSharedSubscriptions(@NotNull final String... sharedSubscriptions);

    /**
     * Returns ``true`` if shared subscriptions are available, ``false`` otherwise
     *
     * @return ``true`` if shared subscriptions are available, ``false`` otherwise
     */
    boolean sharedSubscriptionsAvailable();

    /**
     * Removes a shared subscription from the SharedSubscriptionService.
     *

     * Although the contract of this method is to disallow null values, this method is lenient.
     * If a ``null`` value is passed, the value is ignored.
     *
     * @param sharedSubscription the shared subscription to remove
     */
    void removeSharedSubscription(@NotNull final String sharedSubscription);

    /**
     * Returns all shared subscriptions. The returned List is read-only representation
     * of all shared subscriptions
     *
     * @return a read-only List of all shared subscriptions
     */
    @ReadOnly
    List<string> getSharedSubscriptions();

    /**
     * Returns the number of all shared subscriptions.
     *
     * @return the number of all shared subscriptions
     */
    long getSharedSubscriptionsSize();
}