PrefixMap.java

/*
 * Copyright (C) 2018-2021 Niels Basjes
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
package org.wpilib.util.collections;
 
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.PrimitiveIterator;
import java.util.Set;
import java.util.stream.IntStream;

public interface PrefixMap<V> extends Map<String, V> {
  @Override
  int size();

  @Override
  default boolean isEmpty() {
    return size() == 0;
  }

  @Override
  default void putAll(Map<? extends String, ? extends V> prefixesAndValues) {
    prefixesAndValues.forEach(this::put);
  }

  @Override
  V put(String prefix, V value);

  default V remove(String prefix) {
    throw new UnsupportedOperationException(
        "The 'remove(String prefix)' method has not been implemented in "
            + this.getClass().getCanonicalName());
  }
 
  @Override
  default V remove(Object o) {
    if (o instanceof String) {
      return remove((String) o);
    }
    return null;
  }
 
  @Override
  default boolean containsKey(Object o) {
    throw new UnsupportedOperationException(
        "The 'containsKey(Object o)' method has not been implemented in "
            + this.getClass().getCanonicalName());
  }
 
  @Override
  default boolean containsValue(Object o) {
    throw new UnsupportedOperationException(
        "The 'containsValue(Object o)' method has not been implemented in "
            + this.getClass().getCanonicalName());
  }

  V get(String prefix);

  @Override
  default V get(Object prefix) {
    if (prefix instanceof String) {
      return get((String) prefix);
    }
    return null;
  }
 
  @Override
  default Set<String> keySet() {
    throw new UnsupportedOperationException(
        "The 'keySet()' method has not been implemented in " + this.getClass().getCanonicalName());
  }
 
  @Override
  default Collection<V> values() {
    throw new UnsupportedOperationException(
        "The 'values()' method has not been implemented in " + this.getClass().getCanonicalName());
  }

  @Override
  default void clear() {
    throw new UnsupportedOperationException(
        "The 'clear()' method has not been implemented in " + this.getClass().getCanonicalName());
  }

  default boolean containsPrefix(String prefix) {
    return containsPrefix(prefix.codePoints().iterator());
  }

  default boolean containsPrefix(int[] prefix) {
    return containsPrefix(IntStream.of(prefix).iterator());
  }

  boolean containsPrefix(PrimitiveIterator.OfInt prefix);

  default V getShortestMatch(String input) {
    return getShortestMatch(input.codePoints().iterator());
  }

  default V getShortestMatch(int[] input) {
    return getShortestMatch(IntStream.of(input).iterator());
  }

  V getShortestMatch(PrimitiveIterator.OfInt input);

  default V getLongestMatch(String input) {
    return getLongestMatch(input.codePoints().iterator());
  }

  default V getLongestMatch(int[] input) {
    return getLongestMatch(IntStream.of(input).iterator());
  }

  V getLongestMatch(PrimitiveIterator.OfInt input);

  default Iterator<V> getAllMatches(String input) {
    return getAllMatches(input.codePoints().iterator());
  }

  default Iterator<V> getAllMatches(int[] input) {
    return getAllMatches(IntStream.of(input).iterator());
  }

  Iterator<V> getAllMatches(PrimitiveIterator.OfInt input);
}