/*! Copyright (c) 2018 Siemens AG. Licensed under the MIT License. */
import { Controller, IoActor, IoNode, IoSource, Uuid } from "..";
import { IoContext } from "../model/io-context";
/**
 * Base IO router class for context-driven routing of IO values.
 *
 * This router implements the base logic of routing. It observes IO nodes that
 * are associated with the router's IO context and manages routes for the IO
 * sources and actors of these nodes.
 *
 * This router implements a basic routing algorithm where all compatible pairs
 * of IO sources and IO actors are associated. An IO source and an IO actor are
 * compatible if both define equal value types in equal data formats. You
 * can define your own custom compatibility check on value types in a subclass
 * by overriding the `areValueTypesCompatible` method.
 *
 * To implement context-specific routing strategies extend this class and
 * implement the abstract protected methods.
 *
 * Note that this router makes its IO context available for discovery (by core
 * type, object type, or object Id) and listens for Update-Complete events on
 * its IO context, triggering `onIoContextChanged` automatically.
 *
 * This base router class requires the following controller options:
 * - `ioContext`: the IO context for which this router is managing routes
 *   (mandatory)
 */
export declare abstract class IoRouter extends Controller {
    private _ioContext;
    private _managedIoNodes;
    private _sourceRoutes;
    onInit(): void;
    onCommunicationManagerStarting(): void;
    onCommunicationManagerStopping(): void;
    /**
     * Gets the IO context of this router.
     */
    get ioContext(): IoContext;
    /**
     * Gets the IO nodes currently managed by this router.
     */
    get managedIoNodes(): Readonly<Map<Uuid, IoNode>>;
    /**
     * Finds a managed IO node that matches the given predicate.
     *
     * Returns undefined if no such IO node exists.
     *
     * @param predicate a function returning true if an IO node matches; false
     * otherwise.
     */
    findManagedIoNode(predicate: (node: IoNode) => boolean): IoNode;
    /**
     * Called by this IO router when its IO context has changed.
     *
     * The base method just advertises the changed IO context object.
     *
     * Overwrite this method in your router subclass to reevaluate all
     * associations between IO sources and IO actors currently held by this
     * router.
     *
     * Ensure to invoke `super.onIoContextChanged` so that the changed IO
     * context is (re)advertised.
     */
    protected onIoContextChanged(): void;
    /**
     * Called by the IO router base implementation when an IO node is being
     * managed.
     *
     * To be implemented by concrete subclasses.
     */
    protected abstract onIoNodeManaged(node: IoNode): any;
    /**
     * Called by the IO router base implementation when currently managed IO
     * nodes are going to be unmanaged.
     *
     * To be implemented by concrete subclasses.
     */
    protected abstract onIoNodesUnmanaged(nodes: IoNode[]): any;
    /**
     * Associates the given IO source and actor by publishing an Associate
     * event.
     *
     * @param source an IO source object
     * @param actor an IO actor object
     * @param updateRate the recommended update rate (in milliseconds)
     */
    protected associate(source: IoSource, actor: IoActor, updateRate: number): void;
    /**
     * Disassociates the given IO source and actor by publishing an Associate
     * event with an undefined route.
     *
     * @param source an IO source object
     * @param actor an IO actor object
     */
    protected disassociate(source: IoSource, actor: IoActor): void;
    /**
     * Checks whether the value types and value data formats of the given IO
     * source and actor match.
     *
     * This is a precondition for associating IO source and actor.
     *
     * The base implementation returns true, if the given source value type is
     * identical to the given actor value type **and** both value data formats
     * (either raw binary or JSON) match; otherwise false.
     *
     * Override this base implementation if you need a custom value type
     * compatibility check in your router.
     *
     * @param source an IO source object
     * @param actor an IO actor object
     */
    protected areValueTypesCompatible(source: IoSource, actor: IoActor): boolean;
    /**
     * Override this method to perform side effects when this router is
     * started.
     *
     * This method does nothing.
     */
    protected onStarted(): void;
    /**
     * Override this method to perform side effects when this router is
     * stopped.
     *
     * This method does nothing.
     *
     * Subclasses should disassociate all current associations in this method.
     */
    protected onStopped(): void;
    private _observeAdvertisedIoNode;
    private _observeDeadvertisedIoNodes;
    private _ioNodeAdvertised;
    private _ioNodesDeadvertised;
    private _discoverIoNodes;
    private _observeDiscoverIoContext;
    private _observeUpdateIoContext;
}