| /external/guava/src/com/google/common/collect/ |
| NullsFirstOrdering.java | 25 /** An ordering that treats {@code null} as less than all other values. */
27 final class NullsFirstOrdering<T> extends Ordering<T> implements Serializable {
28 final Ordering<? super T> ordering; field in class:NullsFirstOrdering
30 NullsFirstOrdering(Ordering<? super T> ordering) {
31 this.ordering = ordering;
44 return ordering.compare(left, right);
47 @Override public <S extends T> Ordering<S> reverse()
[all...] |
| NullsLastOrdering.java | 25 /** An ordering that treats {@code null} as greater than all other values. */
27 final class NullsLastOrdering<T> extends Ordering<T> implements Serializable {
28 final Ordering<? super T> ordering; field in class:NullsLastOrdering
30 NullsLastOrdering(Ordering<? super T> ordering) {
31 this.ordering = ordering;
44 return ordering.compare(left, right);
47 @Override public <S extends T> Ordering<S> reverse()
[all...] |
| Ordering.java | 39 * if (Ordering.from(comparator).reverse().isOrdered(list)) { ... }}</pre>
42 * Ordering} instance for a pre-existing comparator. You can also skip the
43 * comparator step and extend {@code Ordering} directly: <pre> {@code
45 * Ordering<String> byLengthOrdering = new Ordering<String>() {
53 * are. For example, if {@code ordering} and {@code function} can themselves be
54 * serialized, then {@code ordering.onResultOf(function)} can as well.
61 public abstract class Ordering<T> implements Comparator<T> {
65 * Returns a serializable ordering that uses the natural order of the values.
66 * The ordering throws a {@link NullPointerException} when passed a nul
[all...] |
| ReverseOrdering.java | 26 /** An ordering that uses the reverse of a given order. */
28 final class ReverseOrdering<T> extends Ordering<T> implements Serializable {
29 final Ordering<? super T> forwardOrder;
31 ReverseOrdering(Ordering<? super T> forwardOrder) {
40 @Override public <S extends T> Ordering<S> reverse() {
41 return (Ordering) forwardOrder;
|
| UsingToStringOrdering.java | 23 /** An ordering that uses the reverse of the natural order of the values. */
26 extends Ordering<Object> implements Serializable {
39 return "Ordering.usingToString()";
|
| ByFunctionOrdering.java | 29 * An ordering that orders elements by applying an order to the result of a
34 extends Ordering<F> implements Serializable {
36 final Ordering<T> ordering; field in class:ByFunctionOrdering
39 Function<F, ? extends T> function, Ordering<T> ordering) {
41 this.ordering = checkNotNull(ordering);
45 return ordering.compare(function.apply(left), function.apply(right));
55 && this.ordering.equals(that.ordering)
[all...] |
| LexicographicalOrdering.java | 27 * An ordering which sorts iterables by comparing corresponding elements
32 extends Ordering<Iterable<T>> implements Serializable {
33 final Ordering<? super T> elementOrder;
35 LexicographicalOrdering(Ordering<? super T> elementOrder) {
|
| NaturalOrdering.java | 26 /** An ordering that uses the natural order of the values. */
30 extends Ordering<Comparable> implements Serializable {
45 @Override public <S extends Comparable> Ordering<S> reverse() {
46 return (Ordering) ReverseNaturalOrdering.INSTANCE;
70 return "Ordering.natural()";
|
| ReverseNaturalOrdering.java | 24 /** An ordering that uses the reverse of the natural order of the values. */
28 extends Ordering<Comparable> implements Serializable {
42 @Override public <S extends Comparable> Ordering<S> reverse() {
43 return Ordering.natural();
78 return "Ordering.natural().reverse()";
|
| ImmutableSortedSet.java | 38 * natural sort ordering of their elements. Either way, null elements are not
64 * With natural ordering of elements, the following relation determines whether
89 private static final Comparator NATURAL_ORDER = Ordering.natural();
122 return new RegularImmutableSortedSet<E>(array, Ordering.natural());
127 * their natural ordering. When multiple elements are equivalent according to
135 return ofInternal(Ordering.natural(), e1, e2);
140 * their natural ordering. When multiple elements are equivalent according to
148 return ofInternal(Ordering.natural(), e1, e2, e3);
153 * their natural ordering. When multiple elements are equivalent according to
161 return ofInternal(Ordering.natural(), e1, e2, e3, e4)
[all...] |
| TreeMultimap.java | 37 * their natural ordering or by supplied comparators. In all cases, this
48 * through the keys according to the key comparator ordering or the natural
49 * ordering of the keys. Similarly, {@code get}, {@code removeAll}, and {@code
51 * to the value comparator ordering or the natural ordering of the values. The
53 * iterate across the keys according to the above key ordering, and for each
54 * key they iterate across the values according to the value ordering.
60 * supported. The natural ordering does not support nulls. All optional multimap
77 * Creates an empty {@code TreeMultimap} ordered by the natural ordering of
83 return new TreeMultimap<K, V>(Ordering.natural(), Ordering.natural())
[all...] |
| ImmutableSortedMap.java | 64 private static final Comparator NATURAL_ORDER = Ordering.natural();
95 return new ImmutableSortedMap<K, V>(entries, Ordering.natural());
100 * natural ordering of their keys.
103 * their natural ordering
107 return new Builder<K, V>(Ordering.natural())
113 * natural ordering of their keys.
116 * their natural ordering
120 return new Builder<K, V>(Ordering.natural())
126 * natural ordering of their keys.
129 * their natural ordering
[all...] |
| ComparatorOrdering.java | 29 /** An ordering for a pre-existing {@code comparator}. */
31 final class ComparatorOrdering<T> extends Ordering<T> implements Serializable {
|
| CompoundOrdering.java | 25 /** An ordering that tries several comparators in order. */
27 final class CompoundOrdering<T> extends Ordering<T> implements Serializable {
72 return "Ordering.compound(" + comparators + ")";
|
| ExplicitOrdering.java | 26 /** An ordering that compares objects according to a given order. */
28 final class ExplicitOrdering<T> extends Ordering<T> implements Serializable {
74 return "Ordering.explicit(" + rankMap.keySet() + ")";
|
| /cts/libs/vogar-expect/src/vogar/ |
| AnnotatedOutcome.java | 20 import com.google.common.collect.Ordering;
32 public static Ordering<AnnotatedOutcome> ORDER_BY_NAME = new Ordering<AnnotatedOutcome>() {
|
| /external/llvm/include/llvm/ |
| Instructions.h | 187 /// Returns the ordering effect of this fence.
192 /// Set the ordering constraint on this load. May not be Release or
194 void setOrdering(AtomicOrdering Ordering) {
196 (Ordering << 7));
212 void setAtomic(AtomicOrdering Ordering,
214 setOrdering(Ordering);
307 /// Returns the ordering effect of this store.
312 /// Set the ordering constraint on this store. May not be Acquire or
314 void setOrdering(AtomicOrdering Ordering) {
316 (Ordering << 7))
[all...] |
| /external/llvm/lib/AsmParser/ |
| LLParser.cpp | [all...] |
| LLParser.h | 79 "Ordering not defined for this ValID kind yet");
183 AtomicOrdering &Ordering);
|
| /external/llvm/lib/Bitcode/Reader/ |
| BitcodeReader.cpp | 740 // While horrible, we have no good ordering of types in the bc file. Just
[all...] |
| /external/llvm/include/llvm/CodeGen/ |
| SelectionDAGNodes.h | [all...] |
| SelectionDAG.h | 171 /// SDNodeOrdering - The ordering of the SDNodes. It roughly corresponds to
172 /// the ordering of the original LLVM instructions.
173 SDNodeOrdering *Ordering;
593 AtomicOrdering Ordering,
598 AtomicOrdering Ordering,
605 unsigned Alignment, AtomicOrdering Ordering,
609 AtomicOrdering Ordering,
617 AtomicOrdering Ordering,
621 AtomicOrdering Ordering,
[all...] |
| /external/llvm/lib/VMCore/ |
| Instructions.cpp | [all...] |
| /external/llvm/include/llvm/Support/ |
| IRBuilder.h | 765 FenceInst *CreateFence(AtomicOrdering Ordering,
767 return Insert(new FenceInst(Context, Ordering, SynchScope));
770 AtomicOrdering Ordering,
772 return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, Ordering, SynchScope));
775 AtomicOrdering Ordering,
777 return Insert(new AtomicRMWInst(Op, Ptr, Val, Ordering, SynchScope));
[all...] |
| /external/llvm/lib/CodeGen/SelectionDAG/ |
| SelectionDAG.cpp | 599 // Remove the ordering of this node.
600 Ordering->remove(N);
840 Root(getEntryNode()), Ordering(0) {
842 Ordering = new SDNodeOrdering();
853 delete Ordering;
880 Ordering->clear();
[all...] |
