ts-api/dist/core/adt/map/AVLMap.d.ts

import { JavaMapEntry } from '../../../java/util/JavaMapEntry';
import { NavigableSet } from '../../../java/util/NavigableSet';
import { JavaSet } from '../../../java/util/JavaSet';
import { NavigableMap } from '../../../java/util/NavigableMap';
import { AVLMapIntervall } from '../../../core/adt/map/AVLMapIntervall';
import { Comparator } from '../../../java/util/Comparator';
import { AVLMapNode } from '../../../core/adt/map/AVLMapNode';
import { SortedMap } from '../../../java/util/SortedMap';
import { Collection } from '../../../java/util/Collection';
import { JavaObject } from '../../../java/lang/JavaObject';
import { JavaMap } from '../../../java/util/JavaMap';
export declare class AVLMap<K, V> extends JavaObject implements NavigableMap<K, V> {
    private readonly _infinityMinus;
    private readonly _infinityPlus;
    private readonly _dummyValue;
    private readonly _sub;
    private readonly _comparator;
    private readonly _comparatorNatural;
    private _root;
    private _allowKeyAlone;
    /**
     * Erzeugt einen leere Map, welche bei den Schlüsselwerten die natürliche Ordnung des {@link Comparable} -
     * Interface nutzt.
     */
    constructor();
    /**
     * Erstellt eine neue leere Map und nutzt dabei die angegeben Ordnung der Schlüssel.
     *
     * @param comparator Die Ordnung für die Schlüssel.
     */
    constructor(comparator: Comparator<K>);
    /**
     * Erstellt eine neue Map mit den Daten aus der angegebenen Map und nutzt dabei die Ordnung dieser Map.
     *
     * @param map Die Map mit den Daten.
     */
    constructor(map: SortedMap<K, V>);
    toString(): String;
    /**
     * Bewirkt, dass das Hinzufügen von Keys ohne Value durch {@link AVLMapSubKeySet} erlaubt ist. Die Keys werden
     * auf einen Dummy-Wert gemapped.
     *
     * @param b Falls TRUE, dürfen KEYs ohne VALUE hinzugefügt werden.
     */
    allowKeyAlone(b: boolean): void;
    equals(o: unknown): boolean;
    hashCode(): number;
    comparator(): Comparator<K>;
    firstKey(): K;
    lastKey(): K;
    keySet(): JavaSet<K>;
    values(): Collection<V>;
    entrySet(): JavaSet<JavaMapEntry<K, V>>;
    size(): number;
    isEmpty(): boolean;
    containsKey(key: unknown): boolean;
    containsValue(value: unknown): boolean;
    get(key: unknown): V | null;
    put(key: K, value: V): V | null;
    remove(key: unknown): V | null;
    putAll(m: JavaMap<K, V>): void;
    clear(): void;
    lowerEntry(key: K): JavaMapEntry<K, V> | null;
    lowerKey(key: K): K | null;
    floorEntry(key: K): JavaMapEntry<K, V> | null;
    floorKey(key: K): K | null;
    ceilingEntry(key: K): JavaMapEntry<K, V> | null;
    ceilingKey(key: K): K | null;
    higherEntry(key: K): JavaMapEntry<K, V> | null;
    higherKey(key: K): K | null;
    firstEntry(): JavaMapEntry<K, V> | null;
    lastEntry(): JavaMapEntry<K, V> | null;
    pollFirstEntry(): JavaMapEntry<K, V> | null;
    pollLastEntry(): JavaMapEntry<K, V> | null;
    descendingMap(): NavigableMap<K, V>;
    navigableKeySet(): NavigableSet<K>;
    descendingKeySet(): NavigableSet<K>;
    subMap(fromKey: K, fromInclusive: boolean, toKey: K, toInclusive: boolean): NavigableMap<K, V>;
    subMap(fromKey: K, toKey: K): SortedMap<K, V>;
    headMap(toKey: K, inclusive: boolean): NavigableMap<K, V>;
    headMap(toKey: K): SortedMap<K, V>;
    tailMap(fromKey: K, inclusive: boolean): NavigableMap<K, V>;
    tailMap(fromKey: K): SortedMap<K, V>;
    bcAddEntryReturnBool(e: JavaMapEntry<K, V>, iv: AVLMapIntervall<K>): boolean;
    bcAddAllEntries(c: Collection<JavaMapEntry<K, V>>, iv: AVLMapIntervall<K>): boolean;
    bcAddEntryReturnOldValueOrNull(key: K, value: V, iv: AVLMapIntervall<K>): V | null;
    bcAddValue(e: V, iv: AVLMapIntervall<K>): boolean;
    bcAddKey(e: K, iv: AVLMapIntervall<K>): boolean;
    bcAddAllKeys(c: Collection<K>, iv: AVLMapIntervall<K>): boolean;
    bcAddAllEntriesOfMap(map: JavaMap<K, V>, iv: AVLMapIntervall<K>): void;
    bcContainsKey(objKey: unknown, iv: AVLMapIntervall<K>): boolean;
    bcContainsAllKeys(c: Collection<unknown>, iv: AVLMapIntervall<K>): boolean;
    bcContainsValue(objValue: unknown, iv: AVLMapIntervall<K>): boolean;
    bcContainsAllValues(col: Collection<unknown>, iv: AVLMapIntervall<K>): boolean;
    bcContainsEntry(o: unknown, iv: AVLMapIntervall<K>): boolean;
    bcContainsAllEntries(c: Collection<unknown>, iv: AVLMapIntervall<K>): boolean;
    bcRemoveKeyReturnBool(o: unknown, iv: AVLMapIntervall<K>): boolean;
    bcRemoveAllKeys(c: Collection<unknown>, iv: AVLMapIntervall<K>): boolean;
    bcRemoveEntry(o: unknown, iv: AVLMapIntervall<K>): boolean;
    bcRemoveAllEntries(c: Collection<unknown>, iv: AVLMapIntervall<K>): boolean;
    bcRemoveKeyReturnOldValueOrNull(obj: unknown, iv: AVLMapIntervall<K>): V | null;
    bcPollFirstEntryOrNull(iv: AVLMapIntervall<K>): JavaMapEntry<K, V> | null;
    bcPollFirstKeyOrNull(iv: AVLMapIntervall<K>): K | null;
    bcPollLastEntryOrNull(iv: AVLMapIntervall<K>): JavaMapEntry<K, V> | null;
    bcPollLastKeyOrNull(iv: AVLMapIntervall<K>): K | null;
    bcIsEmpty(iv: AVLMapIntervall<K>): boolean;
    bcGetComparator(iv: AVLMapIntervall<K>): Comparator<K>;
    bcGetFirstKeyOrException(iv: AVLMapIntervall<K>): K;
    bcGetFirstEntryOrNull(iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    bcGetLastKeyOrException(iv: AVLMapIntervall<K>): K;
    bcGetLastEntryOrNull(iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    bcGetNextEntryOrNull(current: AVLMapNode<K, V>, iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    bcGetPrevEntryOrNull(current: AVLMapNode<K, V>, iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    bcGetSize(iv: AVLMapIntervall<K>): number;
    bcGetValueOfKeyOrNull(objKey: unknown, iv: AVLMapIntervall<K>): V | null;
    bcGetLowerEntryOrNull(key: K, iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    bcGetLowerKeyOrNull(key: K, iv: AVLMapIntervall<K>): K | null;
    bcGetFloorEntryOrNull(key: K, iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    bcGetFloorKeyOrNull(key: K, iv: AVLMapIntervall<K>): K | null;
    bcGetCeilingEntryOrNull(key: K, iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    bcGetCeilingKeyOrNull(key: K, iv: AVLMapIntervall<K>): K | null;
    bcGetHigherEntryOrNull(key: K, iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    bcGetHigherKeyOrNull(key: K, iv: AVLMapIntervall<K>): K | null;
    bcCheckOutOfIntervall(key: K, inc: boolean, iv: AVLMapIntervall<K>): boolean;
    private _keyOrNull;
    private _valEquals;
    private _keyOrExeption;
    private _compare;
    private _isOutOfRange;
    private _nodeFirstOrNull;
    private _nodeLastOrNull;
    private _nodeCeilingOrNull;
    private _nodeHigherOrNull;
    private _nodeFloorOrNull;
    private _nodeLowerOrNull;
    private _nodeNextOrNull;
    private _nodePrevOrNull;
    private _nodeGetOrNull;
    private _nodeIndexOf;
    private _nodeDeepestOrNull;
    private _nodePutRecursive;
    private _nodeCreateLeaf;
    private _nodeRemoveKeyRecursive;
    private _nodeReplaceReferencesFromAwithB;
    private _nodeRemovePrevNext;
    /**
     * Aktualisiert {@code node} und liefert, wenn es zur Rotation kommt, eine neue Sub-Wurzel.
     *
     * @param node Der Knoten, der revalidiert werden soll.
     *
     * @return node, oder die neue Sub-Wurzel, wenn es zur Rotation kam.
     */
    private _nodeRevalidate;
    private _nodeRotateLeft;
    private _nodeRotateRight;
    private _nodeRevalidateHeightAndSize;
    private _nodeGetHeightBalance;
    isTranspiledInstanceOf(name: string): boolean;
}
export declare function cast_de_nrw_schule_svws_core_adt_map_AVLMap<K, V>(obj: unknown): AVLMap<K, V>;