Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2007 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 java.util.Set;
 
 import  javax.annotation.Nullable;

A multiset which forwards all its method calls to another multiset. Subclasses should override one or more methods to modify the behavior of the backing multiset as desired per the decorator pattern.

Warning: The methods of ForwardingMultiset forward indiscriminately to the methods of the delegate. For example, overriding add(Object, int) alone will not change the behavior of add(Object), which can lead to unexpected behavior. In this case, you should override add(Object) as well, either providing your own implementation, or delegating to the provided standardAdd method.

The standard methods and any collection views they return are not guaranteed to be thread-safe, even when all of the methods that they depend on are thread-safe.

Author(s):
Kevin Bourrillion
Louis Wasserman
Since:
2.0 (imported from Google Collections Library)
 
 public abstract class ForwardingMultiset<E> extends ForwardingCollection<E>
     implements Multiset<E> {

  
Constructor for use by subclasses.
 
   protected ForwardingMultiset() {}
 
   @Override protected abstract Multiset<E> delegate();
 
   @Override
   public int count(Object element) {
     return delegate().count(element);
   }
 
   @Override
   public int add(E elementint occurrences) {
     return delegate().add(elementoccurrences);
   }
 
   @Override
   public int remove(Object elementint occurrences) {
     return delegate().remove(elementoccurrences);
   }
 
   @Override
   public Set<E> elementSet() {
     return delegate().elementSet();
   }
 
   @Override
   public Set<Entry<E>> entrySet() {
     return delegate().entrySet();
   }
 
   @Override public boolean equals(@Nullable Object object) {
     return object == this || delegate().equals(object);
   }
 
   @Override public int hashCode() {
     return delegate().hashCode();
   }
 
   @Override
   public int setCount(E elementint count) {
     return delegate().setCount(elementcount);
   }
 
   @Override
   public boolean setCount(E elementint oldCountint newCount) {
    return delegate().setCount(elementoldCountnewCount);
  }

  
A sensible definition of contains in terms of count. If you override count, you may wish to override contains to forward to this implementation.

Since:
7.0
  @Override protected boolean standardContains(@Nullable Object object) {
    return count(object) > 0;
  }

  
A sensible definition of clear in terms of the iterator method of entrySet. If you override entrySet, you may wish to override clear to forward to this implementation.

Since:
7.0
  @Override protected void standardClear() {
    Iterators.clear(entrySet().iterator());
  }

  
A sensible, albeit inefficient, definition of count in terms of entrySet. If you override entrySet, you may wish to override count to forward to this implementation.

Since:
7.0
  @Beta protected int standardCount(@Nullable Object object) {
    for (Entry<?> entry : this.entrySet()) {
      if (Objects.equal(entry.getElement(), object)) {
        return entry.getCount();
      }
    }
    return 0;
  }

  
A sensible definition of add(Object) in terms of add(Object, int). If you override add(Object, int), you may wish to override add(Object) to forward to this implementation.

Since:
7.0
  protected boolean standardAdd(E element) {
    add(element, 1);
    return true;
  }

  
A sensible definition of addAll(Collection) in terms of add(Object) and add(Object, int). If you override either of these methods, you may wish to override addAll(Collection) to forward to this implementation.

Since:
7.0
  @Beta @Override protected boolean standardAddAll(
      Collection<? extends E> elementsToAdd) {
    return Multisets.addAllImpl(thiselementsToAdd);
  }

  
A sensible definition of remove(Object) in terms of remove(Object, int). If you override remove(Object, int), you may wish to override remove(Object) to forward to this implementation.

Since:
7.0
  @Override protected boolean standardRemove(Object element) {
    return remove(element, 1) > 0;
  }

  
A sensible definition of removeAll in terms of the removeAll method of elementSet. If you override elementSet, you may wish to override removeAll to forward to this implementation.

Since:
7.0
  @Override protected boolean standardRemoveAll(
      Collection<?> elementsToRemove) {
    return Multisets.removeAllImpl(thiselementsToRemove);
  }

  
A sensible definition of retainAll in terms of the retainAll method of elementSet. If you override elementSet, you may wish to override retainAll to forward to this implementation.

Since:
7.0
  @Override protected boolean standardRetainAll(
      Collection<?> elementsToRetain) {
    return Multisets.retainAllImpl(thiselementsToRetain);
  }

  
A sensible definition of setCount(Object, int) in terms of count(Object), add(Object, int), and remove(Object, int). entrySet(). If you override any of these methods, you may wish to override setCount(Object, int) to forward to this implementation.

Since:
7.0
  protected int standardSetCount(E elementint count) {
    return Multisets.setCountImpl(thiselementcount);
  }

  
A sensible definition of setCount(Object, int, int) in terms of count(Object) and setCount(Object, int). If you override either of these methods, you may wish to override setCount(Object, int, int) to forward to this implementation.

Since:
7.0
  protected boolean standardSetCount(E elementint oldCountint newCount) {
    return Multisets.setCountImpl(thiselementoldCountnewCount);
  }

  
A sensible implementation of Multiset.elementSet in terms of the following methods: ForwardingMultiset.clear, ForwardingMultiset.contains, ForwardingMultiset.containsAll, ForwardingMultiset.count, ForwardingMultiset.isEmpty, the Set.size and Set.iterator methods of ForwardingMultiset.entrySet, and ForwardingMultiset.remove(Object, int). In many situations, you may wish to override ForwardingMultiset.elementSet to forward to this implementation or a subclass thereof.

Since:
10.0
  @Beta
  protected class StandardElementSet extends Multisets.ElementSet<E> {
    
Constructor for use by subclasses.
    public StandardElementSet() {}
    @Override
    Multiset<E> multiset() {
      return ForwardingMultiset.this;
    }
  }
  
  
A sensible definition of iterator in terms of entrySet and remove(Object). If you override either of these methods, you may wish to override iterator to forward to this implementation.

Since:
7.0
  protected Iterator<E> standardIterator() {
    return Multisets.iteratorImpl(this);
  }

  
A sensible, albeit inefficient, definition of size in terms of entrySet. If you override entrySet, you may wish to override size to forward to this implementation.

Since:
7.0
  protected int standardSize() {
    return Multisets.sizeImpl(this);
  }

  
A sensible, albeit inefficient, definition of size in terms of entrySet().size() and count. If you override either of these methods, you may wish to override size to forward to this implementation.

Since:
7.0
  protected boolean standardEquals(@Nullable Object object) {
    return Multisets.equalsImpl(thisobject);
  }

  
A sensible definition of hashCode as entrySet().hashCode() . If you override entrySet, you may wish to override hashCode to forward to this implementation.

Since:
7.0
  protected int standardHashCode() {
    return entrySet().hashCode();
  }

  
A sensible definition of toString as entrySet().toString() . If you override entrySet, you may wish to override toString to forward to this implementation.

Since:
7.0
  @Override protected String standardToString() {
    return entrySet().toString();
  }
New to GrepCode? Check out our FAQ X