public static <T> TreeMultiset<T> getPailContents(Pail<T> pail) {
   TreeMultiset contains = TreeMultiset.create();
   for (T obj : pail) {
     contains.add(obj);
   }
   return contains;
 }
  /** Test a TreeMultiset with a comparator that can return 0 when comparing unequal values. */
  public void testDegenerateComparator() throws Exception {
    TreeMultiset<String> ms = TreeMultiset.create(DEGENERATE_COMPARATOR);

    ms.add("foo");
    ms.add("a");
    ms.add("bar");
    ms.add("b");
    ms.add("c");

    assertEquals(2, ms.count("bar"));
    assertEquals(3, ms.count("b"));

    Multiset<String> ms2 = TreeMultiset.create(DEGENERATE_COMPARATOR);

    ms2.add("cat", 2);
    ms2.add("x", 3);

    assertEquals(ms, ms2);
    assertEquals(ms2, ms);

    SortedSet<String> elementSet = ms.elementSet();
    assertEquals("a", elementSet.first());
    assertEquals("foo", elementSet.last());
    assertEquals(DEGENERATE_COMPARATOR, elementSet.comparator());
  }
 public static <T> void assertPailContents(Pail<T> pail, T... objects) {
   TreeMultiset contains = getPailContents(pail);
   TreeMultiset other = TreeMultiset.create();
   for (T obj : objects) {
     other.add(obj);
   }
   Assert.assertEquals(failureString(other, contains), other, contains);
 }
 /**
  * Returns a collection of multiset entries representing the counts of the distinct elements, in
  * sorted order. Does not check for null.
  */
 public static <E> Collection<Multiset.Entry<E>> sortedCounts(
     Comparator<? super E> comparator, Iterable<E> elements) {
   if (elements instanceof Multiset) {
     Multiset<E> multiset = (Multiset<E>) elements;
     if (hasSameComparator(comparator, elements)) {
       return multiset.entrySet();
     }
     List<Multiset.Entry<E>> entries = Lists.newArrayList(multiset.entrySet());
     Collections.sort(
         entries,
         Ordering.from(comparator)
             .onResultOf(
                 new Function<Multiset.Entry<E>, E>() {
                   @Override
                   public E apply(Entry<E> entry) {
                     return entry.getElement();
                   }
                 }));
     return entries;
   } else if (elements instanceof Set) { // known distinct
     Collection<E> sortedElements;
     if (hasSameComparator(comparator, elements)) {
       sortedElements = (Collection<E>) elements;
     } else {
       List<E> list = Lists.newArrayList(elements);
       Collections.sort(list, comparator);
       sortedElements = list;
     }
     return singletonEntries(sortedElements);
   } else if (hasSameComparator(comparator, elements)) {
     E current = null;
     int currentCount = 0;
     List<Multiset.Entry<E>> sortedEntries = Lists.newArrayList();
     for (E e : elements) {
       if (currentCount > 0) {
         if (comparator.compare(current, e) == 0) {
           currentCount++;
         } else {
           sortedEntries.add(Multisets.immutableEntry(current, currentCount));
           current = e;
           currentCount = 1;
         }
       } else {
         current = e;
         currentCount = 1;
       }
     }
     if (currentCount > 0) {
       sortedEntries.add(Multisets.immutableEntry(current, currentCount));
     }
     return sortedEntries;
   }
   TreeMultiset<E> multiset = TreeMultiset.create(comparator);
   Iterables.addAll(multiset, elements);
   return multiset.entrySet();
 }
  public static void assertPailContents(Pail pail, List objects) {
    TreeMultiset contains = getPailContents(pail);
    TreeMultiset other = TreeMultiset.create();
    for (Object obj : objects) {
      other.add(obj);
    }
    for (Object o : contains) {}

    Assert.assertEquals(failureString(other, contains), other, contains);
  }
 @Override
 public void addKeepAliveTimeout(SelectableChannel channel, Timeout timeout) {
   logger.debug("added keep-alive timeout: {}", timeout);
   DecoratedTimeout oldTimeout = index.get(channel);
   if (oldTimeout != null) {
     keepAliveTimeouts.remove(oldTimeout);
   }
   DecoratedTimeout decorated = new DecoratedTimeout(channel, timeout);
   keepAliveTimeouts.add(decorated);
   index.put(channel, decorated);
 }
  public void testElementSetSortedSetMethods() {
    TreeMultiset<String> ms = TreeMultiset.create();
    ms.add("c", 1);
    ms.add("a", 3);
    ms.add("b", 2);
    SortedSet<String> elementSet = ms.elementSet();

    assertEquals("a", elementSet.first());
    assertEquals("c", elementSet.last());
    assertEquals(Ordering.natural(), elementSet.comparator());

    ASSERT.that(elementSet.headSet("b")).has().exactly("a").inOrder();
    ASSERT.that(elementSet.tailSet("b")).has().exactly("b", "c").inOrder();
    ASSERT.that(elementSet.subSet("a", "c")).has().exactly("a", "b").inOrder();
  }
 public void testCreate() {
   TreeMultiset<String> multiset = TreeMultiset.create();
   multiset.add("foo", 2);
   multiset.add("bar");
   assertEquals(3, multiset.size());
   assertEquals(2, multiset.count("foo"));
   assertEquals(Ordering.natural(), multiset.comparator());
   assertEquals("[bar, foo x 2]", multiset.toString());
 }
 public void testCreateWithComparator() {
   Multiset<String> multiset = TreeMultiset.create(Collections.reverseOrder());
   multiset.add("foo", 2);
   multiset.add("bar");
   assertEquals(3, multiset.size());
   assertEquals(2, multiset.count("foo"));
   assertEquals("[foo x 2, bar]", multiset.toString());
 }
  public void testToString() {
    Multiset<String> ms = TreeMultiset.create();
    ms.add("a", 3);
    ms.add("c", 1);
    ms.add("b", 2);

    assertEquals("[a x 3, b x 2, c]", ms.toString());
  }
  public void testSubMultisetSize() {
    TreeMultiset<String> ms = TreeMultiset.create();
    ms.add("a", Integer.MAX_VALUE);
    ms.add("b", Integer.MAX_VALUE);
    ms.add("c", 3);

    assertEquals(Integer.MAX_VALUE, ms.count("a"));
    assertEquals(Integer.MAX_VALUE, ms.count("b"));
    assertEquals(3, ms.count("c"));

    assertEquals(Integer.MAX_VALUE, ms.headMultiset("c", CLOSED).size());
    assertEquals(Integer.MAX_VALUE, ms.headMultiset("b", CLOSED).size());
    assertEquals(Integer.MAX_VALUE, ms.headMultiset("a", CLOSED).size());

    assertEquals(3, ms.tailMultiset("c", CLOSED).size());
    assertEquals(Integer.MAX_VALUE, ms.tailMultiset("b", CLOSED).size());
    assertEquals(Integer.MAX_VALUE, ms.tailMultiset("a", CLOSED).size());
  }
 /**
  * Returns an immutable sorted multiset containing the given elements sorted by the given {@code
  * Comparator}. This method iterates over {@code elements} at most once.
  *
  * <p>Despite the method name, this method attempts to avoid actually copying the data when it is
  * safe to do so. The exact circumstances under which a copy will or will not be performed are
  * undocumented and subject to change.
  *
  * @throws NullPointerException if {@code comparator} or any of {@code elements} is null
  */
 public static <E> ImmutableSortedMultiset<E> copyOf(
     Comparator<? super E> comparator, Iterable<? extends E> elements) {
   if (elements instanceof ImmutableSortedMultiset) {
     @SuppressWarnings("unchecked") // immutable collections are always safe for covariant casts
     ImmutableSortedMultiset<E> multiset = (ImmutableSortedMultiset<E>) elements;
     if (comparator.equals(multiset.comparator())) {
       if (multiset.isPartialView()) {
         return copyOfSortedEntries(comparator, multiset.entrySet().asList());
       } else {
         return multiset;
       }
     }
   }
   elements = Lists.newArrayList(elements); // defensive copy
   TreeMultiset<E> sortedCopy = TreeMultiset.create(checkNotNull(comparator));
   Iterables.addAll(sortedCopy, elements);
   return copyOfSortedEntries(comparator, sortedCopy.entrySet());
 }
  @BeforeExperiment
  void setUp() {
    hashMultiset = HashMultiset.create(size);
    linkedHashMultiset = LinkedHashMultiset.create(size);
    treeMultiset = TreeMultiset.create();

    Random random = new Random();

    int sizeRemaining = size;

    // TODO(kevinb): generate better test contents for multisets
    for (int i = 0; sizeRemaining > 0; i++) {
      // The JVM will return interned values for small ints.
      Integer value = random.nextInt(1000) + 128;
      int count = Math.min(random.nextInt(10) + 1, sizeRemaining);
      sizeRemaining -= count;
      hashMultiset.add(value, count);
      linkedHashMultiset.add(value, count);
      treeMultiset.add(value, count);
    }

    // TODO(kevinb): convert to assert once benchmark tests enable asserts by default
    Preconditions.checkState(hashMultiset.size() == size);
  }
  public void testNullAcceptingComparator() throws Exception {
    Comparator<String> comparator = Ordering.<String>natural().nullsFirst();
    TreeMultiset<String> ms = TreeMultiset.create(comparator);

    ms.add("b");
    ms.add(null);
    ms.add("a");
    ms.add("b");
    ms.add(null, 2);

    ASSERT.that(ms).has().exactly(null, null, null, "a", "b", "b").inOrder();
    assertEquals(3, ms.count(null));

    SortedSet<String> elementSet = ms.elementSet();
    assertEquals(null, elementSet.first());
    assertEquals("b", elementSet.last());
    assertEquals(comparator, elementSet.comparator());
  }
  public void testElementSetSubsetRetainAll() {
    TreeMultiset<String> ms = TreeMultiset.create();
    ms.add("a", 1);
    ms.add("b", 3);
    ms.add("c", 2);
    ms.add("d", 1);
    ms.add("e", 3);
    ms.add("f", 2);

    SortedSet<String> elementSet = ms.elementSet();
    ASSERT.that(elementSet).has().exactly("a", "b", "c", "d", "e", "f").inOrder();
    SortedSet<String> subset = elementSet.subSet("b", "f");
    ASSERT.that(subset).has().exactly("b", "c", "d", "e").inOrder();

    assertTrue(subset.retainAll(Arrays.asList("a", "c")));
    ASSERT.that(elementSet).has().exactly("a", "c", "f").inOrder();
    ASSERT.that(subset).has().exactly("c").inOrder();
    assertEquals(5, ms.size());
  }
  public void testElementSetSubsetClear() {
    TreeMultiset<String> ms = TreeMultiset.create();
    ms.add("a", 1);
    ms.add("b", 3);
    ms.add("c", 2);
    ms.add("d", 1);
    ms.add("e", 3);
    ms.add("f", 2);

    SortedSet<String> elementSet = ms.elementSet();
    ASSERT.that(elementSet).has().exactly("a", "b", "c", "d", "e", "f").inOrder();
    SortedSet<String> subset = elementSet.subSet("b", "f");
    ASSERT.that(subset).has().exactly("b", "c", "d", "e").inOrder();

    subset.clear();
    ASSERT.that(elementSet).has().exactly("a", "f").inOrder();
    ASSERT.that(subset).isEmpty();
    assertEquals(3, ms.size());
  }
  private static class LanguageDistributionCounter implements Counter<LanguageDistributionCounter> {

    private final Multiset<String> multiset = TreeMultiset.create();

    @Override
    public void aggregate(LanguageDistributionCounter counter) {
      multiset.addAll(counter.multiset);
    }

    @Override
    public void initialize(CounterInitializationContext context) {
      if (context.getLeaf().getType() == Component.Type.FILE) {
        initializeForFile(context);
      }
      initializeForOtherLeaf(context);
    }

    private void initializeForFile(CounterInitializationContext context) {
      String language = context.getLeaf().getFileAttributes().getLanguageKey();
      Optional<Measure> ncloc = context.getMeasure(CoreMetrics.NCLOC_KEY);
      if (ncloc.isPresent()) {
        multiset.add(language == null ? UNKNOWN_LANGUAGE_KEY : language, ncloc.get().getIntValue());
      }
    }

    private void initializeForOtherLeaf(CounterInitializationContext context) {
      Optional<Measure> measure = context.getMeasure(NCLOC_LANGUAGE_DISTRIBUTION_KEY);
      if (measure.isPresent()) {
        Map<String, Integer> parse =
            KeyValueFormat.parse(
                measure.get().getData(), newStringConverter(), newIntegerConverter());
        for (Map.Entry<String, Integer> entry : parse.entrySet()) {
          multiset.add(entry.getKey(), entry.getValue());
        }
      }
    }
  }
 private long executeKeepAliveTimeouts() {
   // makes a defensive copy to avoid (1) CME (new timeouts are added this iteration) and (2) IO
   // starvation.
   TreeMultiset<DecoratedTimeout> defensive = TreeMultiset.create(keepAliveTimeouts);
   Iterator<DecoratedTimeout> iter = defensive.iterator();
   final long now = System.currentTimeMillis();
   while (iter.hasNext()) {
     DecoratedTimeout candidate = iter.next();
     if (candidate.timeout.getTimeout() > now) {
       break;
     }
     candidate.timeout.getCallback().onCallback();
     index.remove(candidate.channel);
     iter.remove();
     keepAliveTimeouts.remove(candidate);
     logger.debug("Keep-alive timeout triggered: {}", candidate.timeout);
   }
   return keepAliveTimeouts.isEmpty()
       ? Long.MAX_VALUE
       : Math.max(1, keepAliveTimeouts.iterator().next().timeout.getTimeout() - now);
 }
  public void testCustomComparator() throws Exception {
    Comparator<String> comparator =
        new Comparator<String>() {
          @Override
          public int compare(String o1, String o2) {
            return o2.compareTo(o1);
          }
        };
    TreeMultiset<String> ms = TreeMultiset.create(comparator);

    ms.add("b");
    ms.add("c");
    ms.add("a");
    ms.add("b");
    ms.add("d");

    ASSERT.that(ms).has().exactly("d", "c", "b", "b", "a").inOrder();

    SortedSet<String> elementSet = ms.elementSet();
    assertEquals("d", elementSet.first());
    assertEquals("a", elementSet.last());
    assertEquals(comparator, elementSet.comparator());
  }
Example #20
0
 private void recomputeMultiset() {
   this.distinctElements =
       1 + TreeMultiset.distinctElements(left) + TreeMultiset.distinctElements(right);
   this.totalCount = elemCount + totalCount(left) + totalCount(right);
 }
Example #21
0
 /** Create an empty sample. */
 public Sample() {
   this.list = TreeMultiset.create();
 }
Example #22
0
 /**
  * Returns a collection of multiset entries representing the counts of the distinct elements, in
  * sorted order. Does not check for null.
  */
 public static <E> Collection<Multiset.Entry<E>> sortedCounts(
     Comparator<? super E> comparator, Iterator<E> elements) {
   TreeMultiset<E> multiset = TreeMultiset.create(comparator);
   Iterators.addAll(multiset, elements);
   return multiset.entrySet();
 }
Example #23
0
  public String handleCase2(InputData in) {

    /**
     * The idea is we put the levels in 2 sets.
     *
     * <p>One is ordered by least set 2 star prereq first ; breaking ties by higher 1 star.
     *
     * <p>TODO why 1 star sort?
     */
    Ordering<Level> set2Ordering =
        Ordering.from(
            new Comparator<Level>() {

              @Override
              public int compare(Level o1, Level o2) {
                return ComparisonChain.start()
                    .compare(o1.twoStarPrereq, o2.twoStarPrereq)
                    .compare(o2.oneStarPrereq, o1.oneStarPrereq)
                    .result();
              }
            });

    TreeMultiset<Level> set2star = TreeMultiset.create(set2Ordering);

    /**
     * If we need to play a 1 star, play the one with the highest 2 star req. This is because we may
     * be able to play a lower 2 star req in 1 round later on.
     */
    TreeMultiset<Level> set1star =
        TreeMultiset.create(
            new Comparator<Level>() {

              @Override
              public int compare(Level o1, Level o2) {
                return ComparisonChain.start()
                    .compare(o1.oneStarPrereq, o2.oneStarPrereq)
                    .compare(o2.twoStarPrereq, o1.twoStarPrereq)
                    .result();
              }
            });

    set1star.addAll(in.levels);
    set2star.addAll(in.levels);

    int score = 0;
    int count = 0;

    while (!set2star.isEmpty()) {

      Level nextSet2 = set2star.firstEntry().getElement();

      if (nextSet2.twoStarPrereq <= score) {
        ++count;

        if (set1star.contains(nextSet2)) {
          score++;
          set1star.remove(nextSet2);
        }

        set2star.remove(nextSet2);
        score++;

        continue;
      }

      List<Level> set1Choices =
          new ArrayList<>(set1star.headMultiset(new Level(score, 0), BoundType.CLOSED));

      Collections.sort(set1Choices, set2Ordering);

      if (nextSet2.twoStarPrereq > score) {

        // Need to take from set1 with the highest possible round 2 score
        if (set1Choices.isEmpty()) {
          return String.format("Case #%d: Too Bad", in.testCase);
        }

        ++count;
        score += 1;

        Level round1 = set1Choices.remove(set1Choices.size() - 1);
        set1star.remove(round1);
        continue;
      }
    }

    // in.levelMin.subList()

    return String.format("Case #%d: %s", in.testCase, count);
  }
 public void testCreateFromIterable() {
   Multiset<String> multiset = TreeMultiset.create(Arrays.asList("foo", "bar", "foo"));
   assertEquals(3, multiset.size());
   assertEquals(2, multiset.count("foo"));
   assertEquals("[bar, foo x 2]", multiset.toString());
 }
public class JMXDebuggableTimeoutManager implements TimeoutManager, TimeoutManagerMXBean {

  private final Logger logger = LoggerFactory.getLogger(JMXDebuggableTimeoutManager.class);

  private final TreeSet<Timeout> timeouts = Sets.newTreeSet(new TimeoutComparator());
  private final TreeMultiset<DecoratedTimeout> keepAliveTimeouts = TreeMultiset.create();
  private final Map<SelectableChannel, DecoratedTimeout> index = Maps.newHashMap();
  private static final AtomicInteger sequence = new AtomicInteger(1);

  public JMXDebuggableTimeoutManager() { // instance initialization block
    MXBeanUtil.registerMXBean(
        this, "TimeoutManager", this.getClass().getSimpleName() + "-" + sequence.incrementAndGet());
  }

  @Override
  public void addKeepAliveTimeout(SelectableChannel channel, Timeout timeout) {
    logger.debug("added keep-alive timeout: {}", timeout);
    DecoratedTimeout oldTimeout = index.get(channel);
    if (oldTimeout != null) {
      keepAliveTimeouts.remove(oldTimeout);
    }
    DecoratedTimeout decorated = new DecoratedTimeout(channel, timeout);
    keepAliveTimeouts.add(decorated);
    index.put(channel, decorated);
  }

  @Override
  public void addTimeout(Timeout timeout) {
    logger.debug("added generic timeout: {}", timeout);
    timeouts.add(timeout);
  }

  @Override
  public boolean hasKeepAliveTimeout(SelectableChannel channel) {
    return index.containsKey(channel);
  }

  @Override
  public long execute() {
    return Math.min(executeKeepAliveTimeouts(), executeTimeouts());
  }

  private long executeKeepAliveTimeouts() {
    // makes a defensive copy to avoid (1) CME (new timeouts are added this iteration) and (2) IO
    // starvation.
    TreeMultiset<DecoratedTimeout> defensive = TreeMultiset.create(keepAliveTimeouts);
    Iterator<DecoratedTimeout> iter = defensive.iterator();
    final long now = System.currentTimeMillis();
    while (iter.hasNext()) {
      DecoratedTimeout candidate = iter.next();
      if (candidate.timeout.getTimeout() > now) {
        break;
      }
      candidate.timeout.getCallback().onCallback();
      index.remove(candidate.channel);
      iter.remove();
      keepAliveTimeouts.remove(candidate);
      logger.debug("Keep-alive timeout triggered: {}", candidate.timeout);
    }
    return keepAliveTimeouts.isEmpty()
        ? Long.MAX_VALUE
        : Math.max(1, keepAliveTimeouts.iterator().next().timeout.getTimeout() - now);
  }

  private long executeTimeouts() {
    // makes a defensive copy to avoid (1) CME (new timeouts are added this iteration) and (2) IO
    // starvation.
    TreeSet<Timeout> defensive = new TreeSet<Timeout>(timeouts); /*Sets.newTreeSet(timeouts);*/
    Iterator<Timeout> iter = defensive.iterator();
    final long now = System.currentTimeMillis();
    while (iter.hasNext()) {
      Timeout candidate = iter.next();
      if (candidate.getTimeout() > now) {
        break;
      }
      candidate.getCallback().onCallback();
      iter.remove();
      timeouts.remove(candidate);
      logger.debug("Timeout triggered: {}", candidate);
    }
    return timeouts.isEmpty()
        ? Long.MAX_VALUE
        : Math.max(1, timeouts.iterator().next().getTimeout() - now);
  }

  // implements TimoutMXBean
  @Override
  public int getNumberOfKeepAliveTimeouts() {
    return index.size();
  }

  @Override
  public int getNumberOfTimeouts() {
    return keepAliveTimeouts.size() + timeouts.size();
  }

  private class DecoratedTimeout implements Comparable<DecoratedTimeout> {

    public final SelectableChannel channel;
    public final Timeout timeout;

    public DecoratedTimeout(SelectableChannel channel, Timeout timeout) {
      this.channel = channel;
      this.timeout = timeout;
    }

    @Override
    public int compareTo(DecoratedTimeout that) {
      long diff = timeout.getTimeout() - that.timeout.getTimeout();
      if (diff < 0) {
        return -1;
      } else if (diff > 0) {
        return 1;
      }
      if (channel != null && that.channel != null) {
        return channel.hashCode() - that.channel.hashCode();
      } else if (channel == null && that.channel != null) {
        return -1;
      } else if (channel != null && that.channel == null) {
        return -1;
      } else {
        return 0;
      }
    }
  }

  private class TimeoutComparator implements Comparator<Timeout> {

    @Override
    public int compare(Timeout lhs, Timeout rhs) {
      if (lhs == rhs) {
        return 0;
      }
      long diff = lhs.getTimeout() - rhs.getTimeout();
      if (diff <= 0) {
        return -1;
      }
      return 1; /// else if (diff > 0) {
    }
  }
}
 /**
  * Creates a new builder. The returned builder is equivalent to the builder generated by {@link
  * ImmutableSortedMultiset#orderedBy(Comparator)}.
  */
 public Builder(Comparator<? super E> comparator) {
   super(TreeMultiset.<E>create(checkNotNull(comparator)));
 }
 @Override
 public int getNumberOfTimeouts() {
   return keepAliveTimeouts.size() + timeouts.size();
 }