private String getVertexID( ElementGraph elementGraph, FlowElement flowElement ) { return vertexIDProvider.getVertexName( new Pair<>( elementGraph, flowElement ) ); }
@Override public void prepare( FlowProcess flowProcess, OperationCall<Pair<Long[], Tuple>> operationCall ) { operationCall.setContext( new Pair<Long[], Tuple>( new Long[]{0L}, Tuple.size( 1 ) ) ); }
public static Pair<Double, Integer> getOptimalFalsePositiveRateAndNumHashes(long numBloomBits, long numElems, int minHashes, int maxHashes) { if (maxHashes < minHashes) { throw new IllegalArgumentException("Cannot have max # hashes smaller than min # hashes! " + maxHashes + " vs " + minHashes); } double bestFPRate = getFalsePositiveRate(maxHashes, numBloomBits, numElems); int bestBloomHashes = maxHashes; for (int i = maxHashes - 1; i >= minHashes; i--) { double newFalsePositiveRate = getFalsePositiveRate(i, numBloomBits, numElems); if (newFalsePositiveRate < bestFPRate) { bestFPRate = newFalsePositiveRate; bestBloomHashes = i; } } return new Pair<Double, Integer>(bestFPRate, bestBloomHashes); }
@Override public void prepare( FlowProcess flowProcess, OperationCall<Pair<Double[], Tuple>> operationCall ) { operationCall.setContext( new Pair<Double[], Tuple>( new Double[]{null}, Tuple.size( 1 ) ) ); }
LOG.trace( "next N1: {}, N2: {}", prevN1, prevN2 ); return new Pair<>( prevN1, prevN2 );
@Override public void prepare( FlowProcess flowProcess, OperationCall<NestedBaseFunction.Context> operationCall ) { Map<Fields, Pair<Predicate<?>, Pointer<Node>>> resolvedPointers = new LinkedHashMap<>(); Fields argumentFields = operationCall.getArgumentFields(); for( Map.Entry<Fields, Pointer<Node>> entry : this.pointers.entrySet() ) resolvedPointers.put( argumentFields.select( entry.getKey() ), new Pair<>( defaultValueFilter, entry.getValue() ) ); if( resolvedPointers.isEmpty() ) // use resolved argument fields { NestedPointerCompiler<Node, Result> compiler = getNestedPointerCompiler(); for( Iterator<Fields> iterator = argumentFields.fieldsIterator(); iterator.hasNext(); ) { Fields argument = iterator.next(); Pointer<Node> pointer = compiler.compile( rootPointer + "/" + argument.get( 0 ).toString() ); resolvedPointers.put( argument, new Pair<>( defaultValueFilter, pointer ) ); } } operationCall.setContext( new Context( resolvedPointers, Tuple.size( 1 ) ) ); }
@Override public void prepare( FlowProcess flowProcess, OperationCall<Pair<Matcher, TupleEntry>> operationCall ) { TupleEntry tupleEntry = new TupleEntry( operationCall.getDeclaredFields(), Tuple.size( 1 ) ); operationCall.setContext( new Pair<>( getPattern().matcher( "" ), tupleEntry ) ); }
@Override public void prepare( FlowProcess flowProcess, OperationCall<Pair<Matcher, TupleEntry>> operationCall ) { TupleEntry tupleEntry = new TupleEntry( operationCall.getDeclaredFields(), Tuple.size( 1 ) ); operationCall.setContext( new Pair<>( getPattern().matcher( "" ), tupleEntry ) ); }
private void advance() { if( current == null ) { if( !subGraphIterator.hasNext() ) return; current = subGraphIterator.next(); pathsIterator = null; } if( pathsIterator == null ) { Set<FlowElement> sources = findSources( current, FlowElement.class ); Set<FlowElement> sinks = findSinks( current, FlowElement.class ); if( sources.size() > 1 || sinks.size() > 1 ) throw new IllegalArgumentException( "only supports single source and single sink graphs" ); FlowElement source = getFirst( sources ); FlowElement sink = getFirst( sinks ); pairs.add( new Pair<>( source, sink ) ); List<GraphPath<FlowElement, Scope>> paths = getAllShortestPathsBetween( current, source, sink ); if( longestFirst ) Collections.reverse( paths ); // break off longest paths into own partitions pathsIterator = paths.iterator(); } }
@Override public void prepare( FlowProcess flowProcess, OperationCall<Pair<Matcher, TupleEntry>> operationCall ) { int size; if( groups != null ) size = groups.length; else size = operationCall.getDeclaredFields().size(); // if Fields.UNKNOWN size will be zero // TupleEntry allows us to honor the declared field type information TupleEntry entry = new TupleEntry( operationCall.getDeclaredFields(), Tuple.size( size ) ); operationCall.setContext( new Pair<>( getPattern().matcher( "" ), entry ) ); }
@Override public void prepare( FlowProcess flowProcess, OperationCall<Pair<Pattern, TupleEntry>> operationCall ) { TupleEntry tupleEntry = new TupleEntry( operationCall.getDeclaredFields(), Tuple.size( 1 ) ); operationCall.setContext( new Pair<>( getPattern(), tupleEntry ) ); }
@Override public void prepare( FlowProcess flowProcess, OperationCall<Pair<Pattern, TupleEntry>> operationCall ) { length = operationCall.getDeclaredFields().isUnknown() ? -1 : operationCall.getDeclaredFields().size(); TupleEntry tupleEntry = new TupleEntry( operationCall.getDeclaredFields(), Tuple.size( Math.max( 1, length ) ) ); operationCall.setContext( new Pair<>( getPattern(), tupleEntry ) ); }
return new Pair<>( vertices, excludeEdges );
@Override public void prepare( FlowProcess flowProcess, OperationCall<Pair<SimpleDateFormat, TupleEntry>> operationCall ) { operationCall.setContext( new Pair<>( getDateFormat(), new TupleEntry( operationCall.getDeclaredFields(), Tuple.size( getDeclaredSize() ) ) ) ); }
if( pairs.contains( new Pair<>( source, sink ) ) ) continue;