ts-collection/lib/util/treemaputil/NavigableSubMap.d.ts

This is re-write of the java collection classes in typescript. There is some tweak as typescript templates are not as equivalent as Java.

import { AbstractMap } from "../abstractmap";
import { NavigableMap } from "../navigablemap";
import { TreeMap } from "../treemap";
import { TreeMapEntry } from "./TreeMapEntry";
import { MapEntry } from "../map";
import { NavigableSet } from "../navigableset";
import { Set } from "../set";
import { Iterator } from "../iterator";
import { Comparator } from "../comparator";
export declare abstract class NavigableSubMap<K, V> extends AbstractMap<K, V> implements NavigableMap<K, V> {
    protected map: TreeMap<K, V>;
    protected m_FromStart: boolean;
    protected lo: K;
    protected loInclusive: boolean;
    protected m_ToEnd: boolean;
    protected hi: K;
    protected hiInclusive: boolean;
    constructor(map: TreeMap<K, V>, m_FromStart: boolean, lo: K, loInclusive: boolean, m_ToEnd: boolean, hi: K, hiInclusive: boolean);
    abstract comparator(): Comparator<K>;
    readonly modCount: number;
    readonly fromStart: boolean;
    readonly toEnd: boolean;
    tooLow(key: K): boolean;
    tooHigh(key: K): boolean;
    inRange(key: K): boolean;
    inRange(key: K, inclusive: boolean): boolean;
    protected inClosedRange(key: K): boolean;
    absLowest(): TreeMapEntry<K, V>;
    absHighest(): TreeMapEntry<K, V>;
    absCeiling(key: K): TreeMapEntry<K, V>;
    absHigher(key: K): TreeMapEntry<K, V>;
    absFloor(key: K): TreeMapEntry<K, V>;
    absLower(key: K): TreeMapEntry<K, V>;
    absHighFence(): TreeMapEntry<K, V>;
    absLowFence(): TreeMapEntry<K, V>;
    abstract subLowest(): TreeMapEntry<K, V>;
    abstract subHighest(): TreeMapEntry<K, V>;
    abstract subCeiling(key: K): TreeMapEntry<K, V>;
    abstract subHigher(key: K): TreeMapEntry<K, V>;
    abstract subFloor(key: K): TreeMapEntry<K, V>;
    abstract subLower(key: K): TreeMapEntry<K, V>;
    abstract keyIterator(): Iterator<K>;
    abstract descendingKeyIterator(): Iterator<K>;
    isEmpty(): boolean;
    size(): number;
    containsKey(key: K): boolean;
    put(key: K, value: V): V;
    get(key: K): V;
    remove(key: K): V;
    ceilingEntry(key: K): MapEntry<K, V>;
    ceilingKey(key: K): K;
    higherEntry(key: K): MapEntry<K, V>;
    higherKey(key: K): K;
    floorEntry(key: K): MapEntry<K, V>;
    floorKey(key: K): K;
    lowerEntry(key: K): MapEntry<K, V>;
    lowerKey(key: K): K;
    firstKey(): K;
    lastKey(): K;
    firstEntry(): MapEntry<K, V>;
    lastEntry(): MapEntry<K, V>;
    pollFirstEntry(): MapEntry<K, V>;
    pollLastEntry(): MapEntry<K, V>;
    private navigableKeySetView;
    navigableKeySet(): NavigableSet<K>;
    keySet(): Set<K>;
    descendingKeySet(): NavigableSet<K>;
    abstract descendingMap(): NavigableMap<K, V>;
    abstract subMap(fromKey: K, fromInclusive: boolean, toKey: K, toInclusive: boolean): NavigableMap<K, V>;
    abstract subMap(fromKey: K, toKey: K): NavigableMap<K, V>;
    abstract headMap(toKey: K): NavigableMap<K, V>;
    abstract headMap(toKey: K, toInclusive: boolean): NavigableMap<K, V>;
    abstract tailMap(toKey: K): NavigableMap<K, V>;
    abstract tailMap(fromKey: K, fromInclusive: boolean): NavigableMap<K, V>;
}