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 java.util.Set;
A skeleton implementation of a descending multiset. Only needs forwardMultiset() and entryIterator().

Author(s):
Louis Wasserman
 
 @GwtCompatible(emulated = true)
 abstract class DescendingMultiset<E> extends ForwardingMultiset<E>
     implements SortedMultiset<E> {
   abstract SortedMultiset<E> forwardMultiset();
 
   private transient Comparator<? super E> comparator;
 
   @Override public Comparator<? super E> comparator() {
     Comparator<? super E> result = ;
     if (result == null) {
       return  =
           Ordering.from(forwardMultiset().comparator()).<E>reverse();
     }
     return result;
   }
 
   private transient SortedSet<E> elementSet;
 
   @Override public SortedSet<E> elementSet() {
     SortedSet<E> result = ;
     if (result == null) {
       return  = new SortedMultisets.ElementSet<E>(this);
     }
     return result;
   }
 
   @Override public Entry<E> pollFirstEntry() {
     return forwardMultiset().pollLastEntry();
   }
 
   @Override public Entry<E> pollLastEntry() {
     return forwardMultiset().pollFirstEntry();
   }
 
   @Override public SortedMultiset<E> headMultiset(E toElement,
       BoundType boundType) {
     return forwardMultiset().tailMultiset(toElementboundType)
         .descendingMultiset();
   }
 
   @Override public SortedMultiset<E> subMultiset(E fromElement,
       BoundType fromBoundType, E toElementBoundType toBoundType) {
     return forwardMultiset().subMultiset(toElementtoBoundTypefromElement,
         fromBoundType).descendingMultiset();
   }
 
   @Override public SortedMultiset<E> tailMultiset(E fromElement,
       BoundType boundType) {
     return forwardMultiset().headMultiset(fromElementboundType)
         .descendingMultiset();
   }
 
   @Override protected Multiset<E> delegate() {
     return forwardMultiset();
   }
 
     return forwardMultiset();
   }
 
   @Override public Entry<E> firstEntry() {
     return forwardMultiset().lastEntry();
   }
 
   @Override public Entry<E> lastEntry() {
     return forwardMultiset().firstEntry();
   }
 
  abstract Iterator<Entry<E>> entryIterator();
  private transient Set<Entry<E>> entrySet;
  @Override public Set<Entry<E>> entrySet() {
    Set<Entry<E>> result = ;
    return (result == null) ?  = createEntrySet() : result;
  }
    return new Multisets.EntrySet<E>() {
      @Override Multiset<E> multiset() {
        return DescendingMultiset.this;
      }
      @Override public Iterator<Entry<E>> iterator() {
        return entryIterator();
      }
      @Override public int size() {
        return forwardMultiset().entrySet().size();
      }
    };
  }
  @Override public Iterator<E> iterator() {
    return Multisets.iteratorImpl(this);
  }
  @Override public Object[] toArray() {
    return standardToArray();
  }
  @Override public <T> T[] toArray(T[] array) {
    return standardToArray(array);
  }
  @Override public String toString() {
    return entrySet().toString();
  }
New to GrepCode? Check out our FAQ X