com.groupbyinc.common.apache.commons.collections4.map.AbstractSortedMapDecorator Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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
*
* http://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.apache.commons.collections4.map;
import java.util.Comparator;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import org.apache.commons.collections4.IterableSortedMap;
import org.apache.commons.collections4.OrderedMapIterator;
import org.apache.commons.collections4.iterators.ListIteratorWrapper;
/**
* Provides a base decorator that enables additional functionality to be added
* to a Map via decoration.
*
* Methods are forwarded directly to the decorated map.
*
* This implementation does not perform any special processing with the map views.
* Instead it simply returns the set/collection from the wrapped map. This may be
* undesirable, for example if you are trying to write a validating implementation
* it would provide a loophole around the validation.
* But, you might want that loophole, so this class is kept simple.
*
* @param the type of the keys in the map
* @param the type of the values in the map
* @since 3.0
* @version $Id: AbstractSortedMapDecorator.java 1686855 2015-06-22 13:00:27Z tn $
*/
public abstract class AbstractSortedMapDecorator extends AbstractMapDecorator implements
IterableSortedMap {
/**
* Constructor only used in deserialization, do not use otherwise.
* @since 3.1
*/
protected AbstractSortedMapDecorator() {
super();
}
/**
* Constructor that wraps (not copies).
*
* @param map the map to decorate, must not be null
* @throws NullPointerException if the map is null
*/
public AbstractSortedMapDecorator(final SortedMap map) {
super(map);
}
/**
* Gets the map being decorated.
*
* @return the decorated map
*/
@Override
protected SortedMap decorated() {
return (SortedMap) super.decorated();
}
//-----------------------------------------------------------------------
public Comparator comparator() {
return decorated().comparator();
}
public K firstKey() {
return decorated().firstKey();
}
public K lastKey() {
return decorated().lastKey();
}
public SortedMap subMap(final K fromKey, final K toKey) {
return decorated().subMap(fromKey, toKey);
}
public SortedMap headMap(final K toKey) {
return decorated().headMap(toKey);
}
public SortedMap tailMap(final K fromKey) {
return decorated().tailMap(fromKey);
}
public K previousKey(final K key) {
final SortedMap headMap = headMap(key);
return headMap.isEmpty() ? null : headMap.lastKey();
}
public K nextKey(final K key) {
final Iterator it = tailMap(key).keySet().iterator();
it.next();
return it.hasNext() ? it.next() : null;
}
/**
* {@inheritDoc}
*/
@Override
public OrderedMapIterator mapIterator() {
return new SortedMapIterator(entrySet());
}
/**
* OrderedMapIterator implementation.
*
* @param the key type
* @param the value type
*/
protected static class SortedMapIterator extends EntrySetToMapIteratorAdapter
implements OrderedMapIterator {
/**
* Create a new AbstractSortedMapDecorator.SortedMapIterator.
* @param entrySet the entrySet to iterate
*/
protected SortedMapIterator(final Set> entrySet) {
super(entrySet);
}
/**
* {@inheritDoc}
*/
@Override
public synchronized void reset() {
super.reset();
iterator = new ListIteratorWrapper>(iterator);
}
/**
* {@inheritDoc}
*/
public boolean hasPrevious() {
return ((ListIterator>) iterator).hasPrevious();
}
/**
* {@inheritDoc}
*/
public K previous() {
entry = ((ListIterator>) iterator).previous();
return getKey();
}
}
}