io.sirix.index.art.KeySet Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of sirix-core Show documentation

SirixDB is a hybrid on-disk and in-memory document oriented, versioned database system. It has a lightweight buffer manager, stores everything in a huge persistent and durable tree and allows efficient reconstruction of every revision. Furthermore, SirixDB implements change tracking, diffing and supports time travel queries.

There is a newer version: 0.11.0

Show newest version

package io.sirix.index.art;

import org.checkerframework.checker.nullness.qual.NonNull;

import java.util.*;

// implementation simply relays/delegates calls to backing map's methods
final class KeySet extends AbstractSet implements NavigableSet {
	private final NavigableMap map;

	KeySet(NavigableMap map) {
		this.map = map;
	}

	// this KeySet can only be created either on ART or on one of it's subMaps
	@Override
	public Iterator iterator() {
		if (map instanceof AdaptiveRadixTree)

			return ((AdaptiveRadixTree) map).keyIterator();
		else
			return ((NavigableSubMap) map).keyIterator();
	}

	// this KeySet can only be created either on ART or on one of it's subMaps
	@Override
	public Iterator descendingIterator() {
		if (map instanceof AdaptiveRadixTree)
			return ((AdaptiveRadixTree) map).descendingKeyIterator();
		else
			return ((NavigableSubMap) map).descendingKeyIterator();
	}

	@Override
	public int size() {
		return map.size();
	}

	@Override
	public boolean isEmpty() {
		return map.isEmpty();
	}

	@Override
	public boolean contains(Object o) {
		return map.containsKey(o);
	}

	@Override
	public void clear() {
		map.clear();
	}

	@Override
	public E lower(E e) {
		return map.lowerKey(e);
	}

	@Override
	public E floor(E e) {
		return map.floorKey(e);
	}

	@Override
	public E ceiling(E e) {
		return map.ceilingKey(e);
	}

	@Override
	public E higher(E e) {
		return map.higherKey(e);
	}

	@Override
	public E first() {
		return map.firstKey();
	}

	@Override
	public E last() {
		return map.lastKey();
	}

	@Override
	public Comparator comparator() {
		return map.comparator();
	}

	@Override
	public E pollFirst() {
		Map.Entry e = map.pollFirstEntry();
		return (e == null) ? null : e.getKey();
	}

	@Override
	public E pollLast() {
		Map.Entry e = map.pollLastEntry();
		return (e == null) ? null : e.getKey();
	}

	@Override
	public boolean remove(Object o) {
		int oldSize = size();
		map.remove(o);
		return size() != oldSize;
	}

	@Override
	public @NonNull NavigableSet subSet(E fromElement, boolean fromInclusive,
			E toElement, boolean toInclusive) {
		return new KeySet<>(map.subMap(fromElement, fromInclusive,
		                               toElement, toInclusive));
	}

	@Override
	public @NonNull NavigableSet headSet(E toElement, boolean inclusive) {
		return new KeySet<>(map.headMap(toElement, inclusive));
	}

	@Override
	public @NonNull NavigableSet tailSet(E fromElement, boolean inclusive) {
		return new KeySet<>(map.tailMap(fromElement, inclusive));
	}

	@Override
	public @NonNull SortedSet subSet(E fromElement, E toElement) {
		return subSet(fromElement, true, toElement, false);
	}

	@Override
	public @NonNull SortedSet headSet(E toElement) {
		return headSet(toElement, false);
	}

	@Override
	public @NonNull SortedSet tailSet(E fromElement) {
		return tailSet(fromElement, true);
	}

	@Override
	public @NonNull NavigableSet descendingSet() {
		return new KeySet<>(map.descendingMap());
	}

	// TODO: implement Spliterator
}