Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2012 The Guava Authors
   *
   * 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
   *
   * 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 com.google.common.collect;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkPositionIndex;
 
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 import  javax.annotation.Nullable;

Implementation of Multimaps.filterKeys(Multimap, Predicate).

Author(s):
Louis Wasserman
 
 class FilteredKeyMultimap<K, V> extends AbstractMultimap<K, V> implements FilteredMultimap<K, V> {
   final Multimap<K, V> unfiltered;
   final Predicate<? super K> keyPredicate;
 
   FilteredKeyMultimap(Multimap<K, V> unfilteredPredicate<? super K> keyPredicate) {
     this. = checkNotNull(unfiltered);
     this. = checkNotNull(keyPredicate);
   }
 
   @Override
   public Multimap<K, V> unfiltered() {
     return ;
   }
 
   @Override
   public Predicate<? super Entry<K, V>> entryPredicate() {
     return Maps.keyPredicateOnEntries();
   }
 
   @Override
   public int size() {
     int size = 0;
     for (Collection<V> collection : asMap().values()) {
       size += collection.size();
     }
     return size;
   }
 
   @Override
   public boolean containsKey(@Nullable Object key) {
     if (.containsKey(key)) {
       @SuppressWarnings("unchecked"// k is equal to a K, if not one itself
       K k = (K) key;
       return .apply(k);
     }
     return false;
   }
 
   @Override
   public Collection<V> removeAll(Object key) {
     return containsKey(key) ? .removeAll(key) : unmodifiableEmptyCollection();
   }
 
     if ( instanceof SetMultimap) {
       return ImmutableSet.of();
     } else {
       return ImmutableList.of();
     }
   }
 
   @Override
   public void clear() {
     keySet().clear();
   }
 
   @Override
   Set<K> createKeySet() {
     return Sets.filter(.keySet(), );
   }
 
  public Collection<V> get(K key) {
    if (.apply(key)) {
      return .get(key);
    } else if ( instanceof SetMultimap) {
      return new AddRejectingSet<K, V>(key);
    } else {
      return new AddRejectingList<K, V>(key);
    }
  }
  static class AddRejectingSet<K, V> extends ForwardingSet<V> {
    final K key;
    AddRejectingSet(K key) {
      this. = key;
    }
    @Override
    public boolean add(V element) {
      throw new IllegalArgumentException("Key does not satisfy predicate: " + );
    }
    @Override
    public boolean addAll(Collection<? extends V> collection) {
      checkNotNull(collection);
      throw new IllegalArgumentException("Key does not satisfy predicate: " + );
    }
    @Override
    protected Set<V> delegate() {
      return Collections.emptySet();
    }
  }
  static class AddRejectingList<K, V> extends ForwardingList<V> {
    final K key;
    AddRejectingList(K key) {
      this. = key;
    }
    @Override
    public boolean add(V v) {
      add(0, v);
      return true;
    }
    @Override
    public boolean addAll(Collection<? extends V> collection) {
      addAll(0, collection);
      return true;
    }
    @Override
    public void add(int index, V element) {
      checkPositionIndex(index, 0);
      throw new IllegalArgumentException("Key does not satisfy predicate: " + );
    }
    @Override
    public boolean addAll(int indexCollection<? extends V> elements) {
      checkNotNull(elements);
      checkPositionIndex(index, 0);
      throw new IllegalArgumentException("Key does not satisfy predicate: " + );
    }
    @Override
    protected List<V> delegate() {
      return Collections.emptyList();
    }
  }
  Iterator<Entry<K, V>> entryIterator() {
    throw new AssertionError("should never be called");
  }
    return new Entries();
  }
  class Entries extends ForwardingCollection<Entry<K, V>> {
    @Override
    protected Collection<Entry<K, V>> delegate() {
      return Collections2.filter(.entries(), entryPredicate());
    }
    @Override
    @SuppressWarnings("unchecked")
    public boolean remove(@Nullable Object o) {
      if (o instanceof Entry) {
        Entry<?, ?> entry = (Entry<?, ?>) o;
        if (.containsKey(entry.getKey())
            // if this holds, then we know entry.getKey() is a K
            && .apply((K) entry.getKey())) {
          return .remove(entry.getKey(), entry.getValue());
        }
      }
      return false;
    }
  }
  
    return new FilteredMultimapValues<K, V>(this);
  }
  Map<K, Collection<V>> createAsMap() {
    return Maps.filterKeys(.asMap(), );
  }
  Multiset<K> createKeys() {
    return Multisets.filter(.keys(), );
  }
New to GrepCode? Check out our FAQ X