Overview  Package  Class   Use  Tree  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    

Uses of Class
com.google.common.annotations.Beta

Packages that use Beta
com.google.common.annotations Common annotation types. 
com.google.common.base Basic utility libraries and interfaces. 
com.google.common.collect This package contains generic collection interfaces and implementations, and other utilities for working with collections. 
com.google.common.io This package contains utility methods and classes for working with Java I/O, for example input streams, output streams, readers, writers, and files. 
com.google.common.net This package contains utility methods and classes for working with net addresses (numeric IP and domain names). 
com.google.common.util.concurrent Concurrency utilities. 
 

Uses of Beta in com.google.common.annotations
 

Classes in com.google.common.annotations with annotations of type Beta
 interface Beta
          Signifies that a public API (public class, method or field) is subject to incompatible changes, or even removal, in a future release.
 

Uses of Beta in com.google.common.base
 

Classes in com.google.common.base with annotations of type Beta
 class CharMatcher
          Determines a true or false value for any Java char value, just as Predicate does for any Object.
 class Enums
          Utility methods for working with Enum instances.
 interface Equivalence<T>
          A strategy for determining whether two instances are considered equivalent.
 class Equivalences
          Contains static factory methods for creating Equivalence instances.
 interface Ticker
          A time source; returns a time value representing the number of nanoseconds elapsed since some fixed but arbitrary point in time.
 

Fields in com.google.common.base with annotations of type Beta
static int Ascii.MAX
          The maximum value of an ASCII character.
static int Ascii.MIN
          The minimum value of an ASCII character.
 

Methods in com.google.common.base with annotations of type Beta
static List<Throwable> Throwables.getCausalChain(Throwable throwable)
          Gets a Throwable cause chain as a list.
 Splitter Splitter.limit(int limit)
          Returns a splitter that behaves equivalently to this splitter but stops splitting after it reaches the limit.
static
<T> Function<Supplier<T>,T>
Suppliers.supplierFunction()
          Returns a function that accepts a supplier and returns the result of invoking Supplier.get() on that supplier.
static Exception Throwables.throwCause(Exception exception, boolean combineStackTraces)
          Rethrows the cause exception of a given throwable, discarding the original throwable.
 

Uses of Beta in com.google.common.collect
 

Classes in com.google.common.collect with annotations of type Beta
 class AbstractLinkedIterator<T>
          This class provides a skeletal implementation of the Iterator interface for sequences whose next element can always be derived from the previous element.
 interface Constraint<E>
          A constraint that an element must satisfy in order to be added to a collection.
 class Constraints
          Factories and utilities pertaining to the Constraint interface.
 class EvictionListeners
          A collection of common eviction listeners.
 class ForwardingTable<R,C,V>
          A table which forwards all its method calls to another table.
 class GenericMapMaker<K0,V0>
          A class exactly like MapMaker, except restricted in the types of maps it can build.
 class HashBasedTable<R,C,V>
          Implementation of Table using hash tables.
 interface Interner<E>
          Provides equivalent behavior to String.intern() for other immutable types.
 class Interners
          Contains static methods pertaining to instances of Interner.
 interface MapConstraint<K,V>
          A constraint on the keys and values that may be added to a Map or Multimap.
 class MapConstraints
          Factory and utilities pertaining to the MapConstraint interface.
 interface MapEvictionListener<K,V>
          An object that can receive a notification when an entry is evicted from a map.
static interface Maps.EntryTransformer<K,V1,V2>
          A transformation of the value of a key-value pair, using both key and value as inputs.
 class MinMaxPriorityQueue<E>
          A double-ended priority queue, which provides constant-time access to both its least element and its greatest element, as determined by the queue's specified comparator.
static class MinMaxPriorityQueue.Builder<B>
          The builder class used in creation of min-max priority queues.
 interface RowSortedTable<R,C,V>
          Interface that extends Table and whose rows are sorted.
 interface SortedMapDifference<K,V>
          An object representing the differences between two sorted maps.
 class SortedMaps
          Static utility methods pertaining to SortedMap instances.
 interface Table<R,C,V>
          A collection that associates an ordered pair of keys, called a row key and a column key, with a single value.
static interface Table.Cell<R,C,V>
          Row key / column key / value triplet corresponding to a mapping in a table.
 class Tables
          Provides static methods that involve a Table.
 class TreeBasedTable<R,C,V>
          Implementation of Table whose row keys and column keys are ordered by their natural ordering or by supplied comparators.
 class UnmodifiableListIterator<E>
          A list iterator that does not support UnmodifiableIterator.remove(), UnmodifiableListIterator.add(E), or UnmodifiableListIterator.set(E).
 

Methods in com.google.common.collect with annotations of type Beta
static List<Character> Lists.charactersOf(CharSequence sequence)
          Returns a view of the specified CharSequence as a List<Character>, viewing sequence as a sequence of Unicode code units.
static ImmutableList<Character> Lists.charactersOf(String string)
          Returns a view of the specified string as an immutable list of Character values.
static
<E> ConcurrentHashMultiset<E>
ConcurrentHashMultiset.create(GenericMapMaker<? super E,? super Number> mapMaker)
          Creates a new, empty ConcurrentHashMultiset using mapMaker to construct the internal backing map.
<K,V> GenericMapMaker<K,V>
MapMaker.evictionListener(MapEvictionListener<K,V> listener)
          Specifies a listener instance, which all maps built using this MapMaker will notify each time an entry is evicted.
abstract  GenericMapMaker<K0,V0> GenericMapMaker.expireAfterAccess(long duration, TimeUnit unit)
          See MapMaker.expireAfterAccess(long, java.util.concurrent.TimeUnit).
 MapMaker MapMaker.expireAfterAccess(long duration, TimeUnit unit)
          Specifies that each entry should be automatically removed from the map once a fixed duration has passed since the entry's last read or write access.
abstract  GenericMapMaker<K0,V0> GenericMapMaker.expireAfterWrite(long duration, TimeUnit unit)
          See MapMaker.expireAfterWrite(long, java.util.concurrent.TimeUnit).
 MapMaker MapMaker.expireAfterWrite(long duration, TimeUnit unit)
          Specifies that each entry should be automatically removed from the map once a fixed duration has passed since the entry's creation or replacement.
<E extends T>
List<E>
Ordering.greatestOf(Iterable<E> iterable, int k)
          Returns the k greatest elements of the given iterable according to this ordering, in order from greatest to least.
<E extends T>
List<E>
Ordering.leastOf(Iterable<E> iterable, int k)
          Returns the k least elements of the given iterable according to this ordering, in order from least to greatest.
abstract  GenericMapMaker<K0,V0> GenericMapMaker.maximumSize(int maximumSize)
          See MapMaker.maximumSize.
 MapMaker MapMaker.maximumSize(int size)
          Specifies the maximum number of entries the map may contain.
 ImmutableMultimap.Builder<K,V> ImmutableMultimap.Builder.orderKeysBy(Comparator<? super K> keyComparator)
          Specifies the ordering of the generated multimap's keys.
 ImmutableSetMultimap.Builder<K,V> ImmutableSetMultimap.Builder.orderKeysBy(Comparator<? super K> keyComparator)
          Specifies the ordering of the generated multimap's keys.
 ImmutableListMultimap.Builder<K,V> ImmutableListMultimap.Builder.orderKeysBy(Comparator<? super K> keyComparator)
          Specifies the ordering of the generated multimap's keys.
 ImmutableMultimap.Builder<K,V> ImmutableMultimap.Builder.orderValuesBy(Comparator<? super V> valueComparator)
          Specifies the ordering of the generated multimap's values for each key.
 ImmutableSetMultimap.Builder<K,V> ImmutableSetMultimap.Builder.orderValuesBy(Comparator<? super V> valueComparator)
          Specifies the ordering of the generated multimap's values for each key.
 ImmutableListMultimap.Builder<K,V> ImmutableListMultimap.Builder.orderValuesBy(Comparator<? super V> valueComparator)
          Specifies the ordering of the generated multimap's values for each key.
static
<T> int
Iterators.skip(Iterator<T> iterator, int numberToSkip)
          Calls next() on iterator, either numberToSkip times or until hasNext() returns false, whichever comes first.
protected  boolean ForwardingList.standardAdd(E element)
          A sensible default implementation of ForwardingCollection.add(Object), in terms of ForwardingList.add(int, Object).
protected  boolean ForwardingMultiset.standardAdd(E element)
          A sensible definition of ForwardingCollection.add(Object) in terms of ForwardingMultiset.add(Object, int).
protected  boolean ForwardingCollection.standardAddAll(Collection<? extends E> collection)
          A sensible definition of ForwardingCollection.addAll(java.util.Collection) in terms of ForwardingCollection.add(E).
protected  boolean ForwardingMultiset.standardAddAll(Collection<? extends E> elementsToAdd)
          A sensible definition of ForwardingCollection.addAll(Collection) in terms of ForwardingCollection.add(Object) and ForwardingMultiset.add(Object, int).
protected  boolean ForwardingList.standardAddAll(int index, Iterable<? extends E> elements)
          A sensible default implementation of ForwardingList.addAll(int, Collection), in terms of the add method of ForwardingList.listIterator(int).
protected  void ForwardingMap.standardClear()
          A sensible definition of ForwardingMap.clear() in terms of the iterator method of ForwardingMap.entrySet().
protected  void ForwardingCollection.standardClear()
          A sensible definition of ForwardingCollection.clear() in terms of ForwardingCollection.iterator(), using the iterator's remove method.
protected  void ForwardingMultiset.standardClear()
          A sensible definition of ForwardingCollection.clear() in terms of the iterator method of ForwardingMultiset.entrySet().
protected  boolean ForwardingSortedSet.standardContains(Object object)
          A sensible definition of ForwardingCollection.contains(java.lang.Object) in terms of the first() method of ForwardingSortedSet.tailSet(E).
protected  boolean ForwardingCollection.standardContains(Object object)
          A sensible definition of ForwardingCollection.contains(java.lang.Object) in terms of ForwardingCollection.iterator().
protected  boolean ForwardingMultiset.standardContains(Object object)
          A sensible definition of ForwardingCollection.contains(java.lang.Object) in terms of ForwardingMultiset.count(java.lang.Object).
protected  boolean ForwardingCollection.standardContainsAll(Collection<?> collection)
          A sensible definition of ForwardingCollection.containsAll(java.util.Collection) in terms of ForwardingCollection.contains(java.lang.Object) .
protected  boolean ForwardingSortedMap.standardContainsKey(Object key)
          A sensible definition of ForwardingMap.containsKey(java.lang.Object) in terms of the firstKey() method of ForwardingSortedMap.tailMap(K).
protected  boolean ForwardingMap.standardContainsKey(Object key)
          A sensible, albeit inefficient, definition of ForwardingMap.containsKey(java.lang.Object) in terms of the iterator method of ForwardingMap.entrySet().
protected  boolean ForwardingMap.standardContainsValue(Object value)
          A sensible definition of ForwardingMap.containsValue(java.lang.Object) in terms of the iterator method of ForwardingMap.entrySet().
protected  int ForwardingMultiset.standardCount(Object object)
          A sensible, albeit inefficient, definition of ForwardingMultiset.count(java.lang.Object) in terms of ForwardingMultiset.entrySet().
protected  Set<E> ForwardingMultiset.standardElementSet()
          A sensible definition of ForwardingMultiset.elementSet() in terms of the following methods: ForwardingCollection.clear(), ForwardingCollection.contains(java.lang.Object), ForwardingCollection.containsAll(java.util.Collection), ForwardingMultiset.count(java.lang.Object), ForwardingCollection.isEmpty(), the size() and iterator() methods of ForwardingMultiset.entrySet(), and ForwardingMultiset.remove(Object, int).
protected  Set<Map.Entry<K,V>> ForwardingMap.standardEntrySet(Supplier<Iterator<Map.Entry<K,V>>> entryIteratorSupplier)
          A sensible definition of ForwardingMap.entrySet() in terms of the specified Supplier, which is used to generate iterators over the entry set, and in terms of the following methods: ForwardingMap.clear(), ForwardingMap.containsKey(java.lang.Object), ForwardingMap.get(java.lang.Object), ForwardingMap.isEmpty(), ForwardingMap.remove(java.lang.Object), and ForwardingMap.size().
protected  boolean ForwardingMapEntry.standardEquals(Object object)
          A sensible definition of ForwardingMapEntry.equals(Object) in terms of ForwardingMapEntry.getKey() and ForwardingMapEntry.getValue().
protected  boolean ForwardingList.standardEquals(Object object)
          A sensible definition of ForwardingList.equals(Object) in terms of ForwardingCollection.size() and ForwardingCollection.iterator().
protected  boolean ForwardingSet.standardEquals(Object object)
          A sensible definition of ForwardingSet.equals(java.lang.Object) in terms of ForwardingCollection.size() and ForwardingCollection.containsAll(java.util.Collection).
protected  boolean ForwardingMap.standardEquals(Object object)
          A sensible definition of ForwardingMap.equals(java.lang.Object) in terms of the equals method of ForwardingMap.entrySet().
protected  boolean ForwardingMultiset.standardEquals(Object object)
          A sensible, albeit inefficient, definition of ForwardingCollection.size() in terms of entrySet().size() and ForwardingMultiset.count(java.lang.Object).
protected  int ForwardingMapEntry.standardHashCode()
          A sensible definition of ForwardingMapEntry.hashCode() in terms of ForwardingMapEntry.getKey() and ForwardingMapEntry.getValue().
protected  int ForwardingList.standardHashCode()
          A sensible definition of ForwardingList.hashCode() in terms of ForwardingCollection.iterator().
protected  int ForwardingSet.standardHashCode()
          A sensible definition of ForwardingSet.hashCode() in terms of ForwardingCollection.iterator().
protected  int ForwardingMap.standardHashCode()
          A sensible definition of ForwardingMap.hashCode() in terms of the iterator method of ForwardingMap.entrySet().
protected  int ForwardingMultiset.standardHashCode()
          A sensible definition of ForwardingMultiset.hashCode() as entrySet().hashCode() .
protected  int ForwardingList.standardIndexOf(Object element)
          A sensible default implementation of ForwardingList.indexOf(java.lang.Object), in terms of ForwardingList.listIterator().
protected  boolean ForwardingMap.standardIsEmpty()
          A sensible definition of ForwardingMap.isEmpty() in terms of the iterator method of ForwardingMap.entrySet().
protected  boolean ForwardingCollection.standardIsEmpty()
          A sensible definition of ForwardingCollection.isEmpty() as !iterator().hasNext.
protected  Iterator<E> ForwardingList.standardIterator()
          A sensible default implementation of ForwardingCollection.iterator(), in terms of ForwardingList.listIterator().
protected  Iterator<E> ForwardingMultiset.standardIterator()
          A sensible definition of ForwardingCollection.iterator() in terms of ForwardingMultiset.entrySet() and ForwardingCollection.remove(Object).
protected  Set<K> ForwardingMap.standardKeySet()
          A sensible definition of ForwardingMap.keySet() in terms of the following methods: ForwardingMap.clear(), ForwardingMap.containsKey(java.lang.Object), ForwardingMap.isEmpty(), ForwardingMap.remove(java.lang.Object), ForwardingMap.size(), and the iterator method of ForwardingMap.entrySet().
protected  int ForwardingList.standardLastIndexOf(Object element)
          A sensible default implementation of ForwardingList.lastIndexOf(java.lang.Object), in terms of ForwardingList.listIterator(int).
protected  ListIterator<E> ForwardingList.standardListIterator()
          A sensible default implementation of ForwardingList.listIterator(), in terms of ForwardingList.listIterator(int).
protected  ListIterator<E> ForwardingList.standardListIterator(int start)
          A sensible default implementation of ForwardingList.listIterator(int), in terms of ForwardingCollection.size() and ForwardingList.get(int).
protected  boolean ForwardingQueue.standardOffer(E e)
          A sensible definition of ForwardingQueue.offer(E) in terms of ForwardingCollection.add(E).
protected  E ForwardingQueue.standardPeek()
          A sensible definition of ForwardingQueue.peek() in terms of ForwardingQueue.element().
protected  E ForwardingQueue.standardPoll()
          A sensible definition of ForwardingQueue.poll() in terms of ForwardingQueue.remove().
protected  void ForwardingMap.standardPutAll(Map<? extends K,? extends V> map)
          A sensible definition of ForwardingMap.putAll(Map) in terms of ForwardingMap.put(Object, Object).
protected  V ForwardingSortedMap.standardRemove(Object key)
          A sensible definition of ForwardingMap.remove(java.lang.Object) in terms of the iterator() of the entrySet() of ForwardingSortedMap.tailMap(K).
protected  boolean ForwardingSortedSet.standardRemove(Object object)
          A sensible definition of ForwardingCollection.remove(java.lang.Object) in terms of the iterator() method of ForwardingSortedSet.tailSet(E).
protected  V ForwardingMap.standardRemove(Object key)
          A sensible, albeit inefficient, definition of ForwardingMap.remove(java.lang.Object) in terms of the iterator method of ForwardingMap.entrySet().
protected  boolean ForwardingCollection.standardRemove(Object object)
          A sensible definition of ForwardingCollection.remove(java.lang.Object) in terms of ForwardingCollection.iterator(), using the iterator's remove method.
protected  boolean ForwardingMultiset.standardRemove(Object element)
          A sensible definition of ForwardingCollection.remove(Object) in terms of ForwardingMultiset.remove(Object, int).
protected  boolean ForwardingCollection.standardRemoveAll(Collection<?> collection)
          A sensible definition of ForwardingCollection.removeAll(java.util.Collection) in terms of ForwardingCollection.iterator(), using the iterator's remove method.
protected  boolean ForwardingMultiset.standardRemoveAll(Collection<?> elementsToRemove)
          A sensible definition of ForwardingCollection.removeAll(java.util.Collection) in terms of the removeAll method of ForwardingMultiset.elementSet().
protected  boolean ForwardingCollection.standardRetainAll(Collection<?> collection)
          A sensible definition of ForwardingCollection.retainAll(java.util.Collection) in terms of ForwardingCollection.iterator(), using the iterator's remove method.
protected  boolean ForwardingMultiset.standardRetainAll(Collection<?> elementsToRetain)
          A sensible definition of ForwardingCollection.retainAll(java.util.Collection) in terms of the retainAll method of ForwardingMultiset.elementSet().
protected  int ForwardingMultiset.standardSetCount(E element, int count)
          A sensible definition of ForwardingMultiset.setCount(Object, int) in terms of ForwardingMultiset.count(Object), ForwardingMultiset.add(Object, int), and ForwardingMultiset.remove(Object, int).
protected  boolean ForwardingMultiset.standardSetCount(E element, int oldCount, int newCount)
          A sensible definition of ForwardingMultiset.setCount(Object, int, int) in terms of ForwardingMultiset.count(Object) and ForwardingMultiset.setCount(Object, int).
protected  int ForwardingMultiset.standardSize()
          A sensible, albeit inefficient, definition of ForwardingCollection.size() in terms of ForwardingMultiset.entrySet().
protected  List<E> ForwardingList.standardSubList(int fromIndex, int toIndex)
          A sensible default implementation of ForwardingList.subList(int, int).
protected  SortedMap<K,V> ForwardingSortedMap.standardSubMap(K fromKey, K toKey)
          A sensible default implementation of ForwardingSortedMap.subMap(Object, Object) in terms of ForwardingSortedMap.headMap(Object) and ForwardingSortedMap.tailMap(Object).
protected  SortedSet<E> ForwardingSortedSet.standardSubSet(E fromElement, E toElement)
          A sensible default implementation of ForwardingSortedSet.subSet(Object, Object) in terms of ForwardingSortedSet.headSet(Object) and ForwardingSortedSet.tailSet(Object).
protected  Object[] ForwardingCollection.standardToArray()
          A sensible definition of ForwardingCollection.toArray() in terms of ForwardingCollection.toArray(Object[]).
protected
<T> T[]
ForwardingCollection.standardToArray(T[] array)
          A sensible definition of ForwardingCollection.toArray(Object[]) in terms of ForwardingCollection.size() and ForwardingCollection.iterator().
protected  String ForwardingMapEntry.standardToString()
          A sensible definition of ForwardingObject.toString() in terms of ForwardingMapEntry.getKey() and ForwardingMapEntry.getValue().
protected  String ForwardingMap.standardToString()
          A sensible definition of ForwardingObject.toString() in terms of the iterator method of ForwardingMap.entrySet().
protected  String ForwardingCollection.standardToString()
          A sensible definition of ForwardingObject.toString() in terms of ForwardingCollection.iterator().
protected  String ForwardingMultiset.standardToString()
          A sensible definition of ForwardingObject.toString() as entrySet().toString() .
protected  Collection<V> ForwardingMap.standardValues()
          A sensible definition of ForwardingMap.values() in terms of the following methods: ForwardingMap.clear(), ForwardingMap.containsValue(java.lang.Object), ForwardingMap.isEmpty(), ForwardingMap.size(), and the iterator method of ForwardingMap.entrySet().
static
<K,V1,V2> ListMultimap<K,V2>
Multimaps.transformEntries(ListMultimap<K,V1> fromMap, Maps.EntryTransformer<? super K,? super V1,V2> transformer)
          Returns a view of a ListMultimap whose values are derived from the original multimap's entries.
static
<K,V1,V2> Map<K,V2>
Maps.transformEntries(Map<K,V1> fromMap, Maps.EntryTransformer<? super K,? super V1,V2> transformer)
          Returns a view of a map whose values are derived from the original map's entries.
static
<K,V1,V2> Multimap<K,V2>
Multimaps.transformEntries(Multimap<K,V1> fromMap, Maps.EntryTransformer<? super K,? super V1,V2> transformer)
          Returns a view of a multimap whose values are derived from the original multimap's entries.
static
<K,V1,V2> ListMultimap<K,V2>
Multimaps.transformValues(ListMultimap<K,V1> fromMultimap, Function<? super V1,V2> function)
          Returns a view of a ListMultimap where each value is transformed by a function.
static
<K,V1,V2> Multimap<K,V2>
Multimaps.transformValues(Multimap<K,V1> fromMultimap, Function<? super V1,V2> function)
          Returns a view of a multimap where each value is transformed by a function.
static
<E> ImmutableSortedSet<E>
ImmutableSortedSet.withExplicitOrder(E firstElement, E... remainingElementsInOrder)
          Deprecated. If the provided elements are already in their natural order, ImmutableSortedSet.of() will produce a set with the same elements in the same order. If the elements are arranged according to another Comparator, use ImmutableSortedSet.orderedBy(Comparator). Otherwise, use ImmutableSet, which maintains insertion order for inputs that are ordered but not sorted. This method is scheduled for deletion in Guava release 10.
static
<E> ImmutableSortedSet<E>
ImmutableSortedSet.withExplicitOrder(List<E> elements)
          Deprecated. If the provided elements are already in their natural order, ImmutableSortedSet.copyOf(Iterable) will produce a set with the same elements in the same order. If the elements are arranged according to another Comparator, use ImmutableSortedSet.orderedBy(Comparator). Otherwise, use ImmutableSet, which maintains insertion order for inputs that are ordered but not sorted. This method is scheduled for deletion in Guava release 10.
 

Uses of Beta in com.google.common.io
 

Classes in com.google.common.io with annotations of type Beta
 interface ByteProcessor<T>
          A callback interface to process bytes from a stream.
 class ByteStreams
          Provides utility methods for working with byte arrays and I/O streams.
 class CharStreams
          Provides utility methods for working with character streams.
 class Closeables
          Utility methods for working with Closeable objects.
 class CountingInputStream
          An InputStream that counts the number of bytes read.
 class CountingOutputStream
          An OutputStream that counts the number of bytes written.
 class FileBackedOutputStream
          An OutputStream that starts buffering to a byte array, but switches to file buffering once the data reaches a configurable size.
 class Files
          Provides utility methods for working with files.
 class Flushables
          Utility methods for working with Flushable objects.
 class LimitInputStream
          An InputStream that limits the number of bytes which can be read.
 interface LineProcessor<T>
          A callback to be used with the streaming readLines methods.
 class LineReader
          A class for reading lines of text.
 class LittleEndianDataInputStream
          An implementation of DataInput that uses little-endian byte ordering for reading short, int, float, double, and long values.
 class LittleEndianDataOutputStream
          An implementation of DataOutput that uses little-endian byte ordering for writing char, short, int, float, double, and long values.
 class NullOutputStream
          Implementation of OutputStream that simply discards written bytes.
 class PatternFilenameFilter
          File name filter that only accepts files matching a regular expression.
 class Resources
          Provides utility methods for working with resources in the classpath.
 

Uses of Beta in com.google.common.net
 

Classes in com.google.common.net with annotations of type Beta
 class HostSpecifier
          A syntactically valid host specifier, suitable for use in a URI.
 class InetAddresses
          Static utility methods pertaining to InetAddress instances.
static class InetAddresses.TeredoInfo
          A simple data class to encapsulate the information to be found in a Teredo address.
 class InternetDomainName
          An immutable well-formed internet domain name, such as com or foo.co.uk.
 

Uses of Beta in com.google.common.util.concurrent
 

Classes in com.google.common.util.concurrent with annotations of type Beta
 class AbstractCheckedFuture<V,X extends Exception>
          A delegating wrapper around a ListenableFuture that adds support for the AbstractCheckedFuture.checkedGet() and AbstractCheckedFuture.checkedGet(long, TimeUnit) methods.
 class AbstractExecutionThreadService
          Base class for services that can implement AbstractExecutionThreadService.startUp(), AbstractExecutionThreadService.run() and AbstractExecutionThreadService.shutDown() methods.
 class AbstractFuture<V>
          An abstract implementation of the Future interface.
 class AbstractIdleService
          Base class for services that do not need a thread while "running" but may need one during startup and shutdown.
 class AbstractListenableFuture<V>
          An abstract base implementation of the listener support provided by ListenableFuture.
 class AbstractService
          Base class for implementing services that can handle AbstractService.doStart() and AbstractService.doStop() requests, responding to them with AbstractService.notifyStarted() and AbstractService.notifyStopped() callbacks.
 interface CheckedFuture<V,X extends Exception>
          A CheckedFuture is an extension of Future that includes versions of the get methods that can throw a checked exception and allows listeners to be attached to the future.
 class ExecutionList
          A list of (Runnable, Executor) pairs that guarantees that every Runnable that is added using the add method will be executed in its associated Executor after ExecutionList.run() is called.
 class FakeTimeLimiter
          A TimeLimiter implementation which actually does not attempt to limit time at all.
 class ForwardingCheckedFuture<V,X extends Exception>
          A future which forwards all its method calls to another future.
static class ForwardingCheckedFuture.SimpleForwardingCheckedFuture<V,X extends Exception>
          A simplified version of ForwardingCheckedFuture where subclasses can pass in an already constructed CheckedFuture as the delegate.
static class ForwardingFuture.SimpleForwardingFuture<V>
          A simplified version of ForwardingFuture where subclasses can pass in an already constructed Future as the delegate.
 class ForwardingListenableFuture<V>
          A ForwardingListenableFuture.SimpleForwardingListenableFuture which forwards all its method calls to another future.
static class ForwardingListenableFuture.SimpleForwardingListenableFuture<V>
          A simplified version of ForwardingListenableFuture where subclasses can pass in an already constructed ListenableFuture as the delegate.
 class ForwardingService
          A Service that forwards all method calls to another service.
 class Futures
          Static utility methods pertaining to the Future interface.
 interface ListenableFuture<V>
          A Future that accepts completion listeners.
 class ListenableFutureTask<V>
          A FutureTask that also implements the ListenableFuture interface.
 class MoreExecutors
          Factory and utility methods for Executor, ExecutorService, and ThreadFactory.
 interface Service
          An object with an operational state, plus asynchronous Service.start() and Service.stop() lifecycle methods to transfer into and out of this state.
static class Service.State
          The lifecycle states of a service.
 class SettableFuture<V>
          A ListenableFuture whose result may be set by a SettableFuture.set(Object) or SettableFuture.setException(Throwable) call.
 class SimpleTimeLimiter
          A TimeLimiter that runs method calls in the background using an ExecutorService.
 interface TimeLimiter
          Produces proxies that impose a time limit on method calls to the proxied object.
 interface UninterruptibleFuture<V>
          A Future whose get calls cannot be interrupted.
 

Overview  Package  Class   Use  Tree  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES