Examples with ArrayBuilder com.cinchapi.common.base.ArrayBuilder used on opensource projects

Example 1 with ArrayBuilder

use of com.cinchapi.common.base.ArrayBuilder in project concourse by cinchapi.

the class Stores method find.

/**
 * Find the records that contain values that are stored for {@code key} and
 * satisfy {@code operator} in relation to the specified {@code values} at
 * {@code timestamp}.
 * <p>
 * If the {@code key} is primitive, the store lookup is usually a simple
 * {@link Store#find(String, Operator, TObject[]) find}. However, if the key
 * is a navigation key, this method will process it by
 * {@link #browse(Store, String) browsing} the destination values and
 * checking the operator validity of each if and only if the {@code store}
 * is an {@link AtomicOperation} or {@link AtomicSupport supports} starting
 * one.
 * </p>
 *
 * @param store
 * @param timestamp
 * @param key
 * @param operator
 * @param values
 * @return the records that satisfy the query
 */
public static Set<Long> find(Store store, long timestamp, String key, Operator operator, TObject... values) {
    for (int i = 0; i < values.length; ++i) {
        TObject value = values[i];
        if (value.getType() == Type.FUNCTION) {
            Function function = (Function) Convert.thriftToJava(value);
            TemporalFunction func = (TemporalFunction) function;
            String method = Calculations.alias(function.operation());
            ArrayBuilder<Object> args = ArrayBuilder.builder();
            method += "Key";
            args.add(function.key());
            if (function instanceof KeyRecordsFunction || function instanceof KeyConditionFunction) {
                method += "Records";
                Collection<Long> records = function instanceof KeyRecordsFunction ? ((KeyRecordsFunction) function).source() : Finder.instance().visit(((KeyConditionFunction) function).source(), store);
                args.add(records);
            } else if (!(function instanceof IndexFunction)) {
                throw new IllegalStateException("Invalid function value");
            }
            method += "Atomic";
            args.add(func.timestamp());
            args.add(store);
            values[i] = Convert.javaToThrift(Reflection.callStatic(Operations.class, method, args.build()));
        }
    }
    if (Keys.isNavigationKey(key)) {
        Map<TObject, Set<Long>> index = timestamp == Time.NONE ? browse(store, key) : browse(store, key, timestamp);
        Set<Long> records = index.entrySet().stream().filter(e -> e.getKey().is(operator, values)).map(e -> e.getValue()).flatMap(Set::stream).collect(Collectors.toCollection(LinkedHashSet::new));
        return records;
    } else if (Keys.isFunctionKey(key)) {
        Set<Long> records = Sets.newLinkedHashSet();
        for (long record : store.getAllRecords()) {
            Set<TObject> aggregate = select(store, key, record, timestamp);
            for (TObject tobject : aggregate) {
                if (tobject.is(operator, values)) {
                    records.add(record);
                    break;
                }
            }
        }
        return records;
    } else {
        return timestamp == Time.NONE ? store.find(key, operator, values) : store.find(timestamp, key, operator, values);
    }
}

Example 2 with ArrayBuilder

use of com.cinchapi.common.base.ArrayBuilder in project concourse by cinchapi.

the class StoreSorter method sort.

@Override
public final Stream<Entry<Long, Map<String, V>>> sort(Map<Long, Map<String, V>> data, @Nullable Long at) {
    ArrayBuilder<Comparator<Entry<Long, Map<String, V>>>> comparators = ArrayBuilder.builder();
    for (OrderComponent component : order.spec()) {
        String key = component.key();
        Timestamp timestamp = component.timestamp();
        Direction direction = component.direction();
        Comparator<Entry<Long, Map<String, V>>> $comparator = (e1, e2) -> {
            long r1 = e1.getKey();
            long r2 = e2.getKey();
            Map<String, V> d1 = e1.getValue();
            Map<String, V> d2 = e2.getValue();
            V v1;
            V v2;
            if (timestamp == null) {
                v1 = d1.get(key);
                if (v1 == null) {
                    v1 = at != null ? lookup(key, r1, at) : lookup(key, r1);
                }
                v2 = d2.get(key);
                if (v2 == null) {
                    v2 = at != null ? lookup(key, r2, at) : lookup(key, r2);
                }
            } else {
                v1 = lookup(key, r1, timestamp.getMicros());
                v2 = lookup(key, r2, timestamp.getMicros());
            }
            if (!Empty.ness().describes(v1) && !Empty.ness().describes(v2)) {
                // end of the sort, regardless of the specified direction
                return direction.coefficient() * compare(v1, v2);
            } else if (!Empty.ness().describes(v1)) {
                return -1;
            } else if (!Empty.ness().describes(v2)) {
                return 1;
            } else {
                return 0;
            }
        };
        comparators.add($comparator);
    }
    comparators.add((e1, e2) -> e1.getKey().compareTo(e2.getKey()));
    Comparator<Entry<Long, Map<String, V>>> comparator = CompoundComparator.of(comparators.build());
    return data.entrySet().stream().sorted(comparator);
}