import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
private static QueryBuilder handleConnectiveP(String key, ConnectiveP predicate){
    List<P> predicates = predicate.getPredicates();
    List<QueryBuilder> queries = predicates.stream().map(p -> {
        if (p instanceof ConnectiveP) return handleConnectiveP(key, (ConnectiveP) p);
        Object pValue = p.getValue();
        BiPredicate pBiPredicate = p.getBiPredicate();
        return predicateToQuery(key, pValue, pBiPredicate);
    }).collect(Collectors.toList());

    BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    if (predicate instanceof AndP)
        queries.forEach(boolQueryBuilder::must);
    else if (predicate instanceof OrP)
        queries.forEach(boolQueryBuilder::should);
    else throw new IllegalArgumentException("Connective predicate not supported by unipop");

    return boolQueryBuilder;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
private Condition handleConnectiveP(String key, ConnectiveP predicate) {
    List<P> predicates = predicate.getPredicates();
    List<Condition> queries = predicates.stream().map(p -> {
        if (p instanceof ConnectiveP) return handleConnectiveP(key, (ConnectiveP) p);
        Object pValue = p.getValue();
        BiPredicate pBiPredicate = p.getBiPredicate();
        return predicateToQuery(key, pValue, pBiPredicate);
    }).collect(Collectors.toList());
    Condition condition = queries.get(0);
    if (predicate instanceof AndP){
        for (int i = 1; i < queries.size(); i++) {
            condition = condition.and(queries.get(i));
        }
    }
    else if (predicate instanceof OrP){
        for (int i = 1; i < queries.size(); i++) {
            condition = condition.or(queries.get(i));
        }
    }
    else throw new IllegalArgumentException("Connective predicate not supported by unipop");
    return condition;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
@Override
public <O extends OutputShim> void write(final KryoShim<?, O> kryo, final O output, final P p) {
    output.writeString(p instanceof ConnectiveP ?
            (p instanceof AndP ? "and" : "or") :
            p.getBiPredicate().toString());
    if (p instanceof ConnectiveP || p.getValue() instanceof Collection) {
        output.writeByte((byte) 0);
        final Collection<?> coll = p instanceof ConnectiveP ?
                ((ConnectiveP<?>) p).getPredicates() : (Collection) p.getValue();
        output.writeInt(coll.size());
        coll.forEach(v -> kryo.writeClassAndObject(output, v));
    } else {
        output.writeByte((byte) 1);
        kryo.writeClassAndObject(output, p.getValue());
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
@Override
public void serialize(final P p, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
        throws IOException {
    jsonGenerator.writeStartObject();
    jsonGenerator.writeStringField(GraphSONTokens.PREDICATE,
            p instanceof ConnectiveP ?
                    p instanceof AndP ?
                            GraphSONTokens.AND :
                            GraphSONTokens.OR :
                    p.getBiPredicate().toString());
    if (p instanceof ConnectiveP) {
        jsonGenerator.writeArrayFieldStart(GraphSONTokens.VALUE);
        for (final P<?> predicate : ((ConnectiveP<?>) p).getPredicates()) {
            jsonGenerator.writeObject(predicate);
        }
        jsonGenerator.writeEndArray();
    } else
        jsonGenerator.writeObjectField(GraphSONTokens.VALUE, p.getValue());

    jsonGenerator.writeEndObject();
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
private List<HasContainer> optimizeBetween(ReplacedStep<?, ?> replacedStep, List<HasContainer> hasContainers) {
    List<HasContainer> result = new ArrayList<>();
    for (HasContainer hasContainer : hasContainers) {
        if (hasContainerKeyNotIdOrLabel(hasContainer) && hasContainer.getPredicate() instanceof AndP) {
            AndP<?> andP = (AndP) hasContainer.getPredicate();
            List<? extends P<?>> predicates = andP.getPredicates();
            if (predicates.size() == 2) {
                if (predicates.get(0).getBiPredicate() == Compare.gte && predicates.get(1).getBiPredicate() == Compare.lt) {
                    replacedStep.addHasContainer(hasContainer);
                    result.add(hasContainer);
                }
            }
        }
    }
    return result;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
private List<HasContainer> optimizeInside(ReplacedStep<?, ?> replacedStep, List<HasContainer> hasContainers) {
    List<HasContainer> result = new ArrayList<>();
    for (HasContainer hasContainer : hasContainers) {
        if (hasContainerKeyNotIdOrLabel(hasContainer) && hasContainer.getPredicate() instanceof AndP) {
            AndP<?> andP = (AndP) hasContainer.getPredicate();
            List<? extends P<?>> predicates = andP.getPredicates();
            if (predicates.size() == 2) {
                if (predicates.get(0).getBiPredicate() == Compare.gt && predicates.get(1).getBiPredicate() == Compare.lt) {
                    replacedStep.addHasContainer(hasContainer);
                    result.add(hasContainer);
                }
            }
        }
    }
    return result;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
@Override
public void addHasContainer(final HasContainer hasContainer) {
    if (hasContainer.getPredicate() instanceof AndP) {
        for (final P<?> predicate : ((AndP<?>) hasContainer.getPredicate()).getPredicates()) {
            this.addHasContainer(new HasContainer(hasContainer.getKey(), predicate));
        }
    } else
        this.hasContainers.add(hasContainer);
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
public static HasContainer[] makeHasContainers(final String key, final P<?> predicate) {
    if (predicate instanceof AndP) {
        final List<P<?>> predicates = ((AndP) predicate).getPredicates();
        final HasContainer[] hasContainers = new HasContainer[predicates.size()];
        for (int i = 0; i < predicates.size(); i++) {
            hasContainers[i] = new HasContainer(key, predicates.get(i));
        }
        return hasContainers;
    } else {
        return new HasContainer[]{new HasContainer(key, predicate)};
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
public PredicatesHolder explodeConnective(HasContainer has) {
    if (has.getBiPredicate() instanceof ConnectiveP) {
        List<P> predicates = ((ConnectiveP) has.getBiPredicate()).getPredicates();
        PredicatesHolder.Clause clause = has.getPredicate() instanceof AndP ?
                PredicatesHolder.Clause.And : PredicatesHolder.Clause.Or;
        Set<HasContainer> hasContainers = predicates.stream()
                .map(p -> new HasContainer(has.getKey(), p)).collect(Collectors.toSet());
        return PredicatesHolderFactory.createFromPredicates(clause, hasContainers);
    }
    return PredicatesHolderFactory.predicate(has);
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
@Override
public <I extends InputShim> P read(final KryoShim<I, ?> kryo, final I input, final Class<P> clazz) {
    final String predicate = input.readString();
    final boolean isCollection = input.readByte() == (byte) 0;
    final Object value;
    if (isCollection) {
        value = new ArrayList();
        final int size = input.readInt();
        for (int ix = 0; ix < size; ix++) {
            ((List) value).add(kryo.readClassAndObject(input));
        }
    } else {
        value = kryo.readClassAndObject(input);
    }

    try {
        if (predicate.equals("and") || predicate.equals("or"))
            return predicate.equals("and") ? new AndP((List<P>) value) : new OrP((List<P>) value);
        else if (value instanceof Collection) {
            if (predicate.equals("between"))
                return P.between(((List) value).get(0), ((List) value).get(1));
            else if (predicate.equals("inside"))
                return P.inside(((List) value).get(0), ((List) value).get(1));
            else if (predicate.equals("outside"))
                return P.outside(((List) value).get(0), ((List) value).get(1));
            else if (predicate.equals("within"))
                return P.within((Collection) value);
            else if (predicate.equals("without"))
                return P.without((Collection) value);
            else
                return (P) P.class.getMethod(predicate, Collection.class).invoke(null, (Collection) value);
        } else
            return (P) P.class.getMethod(predicate, Object.class).invoke(null, value);
    } catch (final Exception e) {
        throw new IllegalStateException(e.getMessage(), e);
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
@Override
public void serialize(final P p, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
        throws IOException {
    jsonGenerator.writeStartObject();
    jsonGenerator.writeStringField(GraphSONTokens.PREDICATE,
            p instanceof ConnectiveP ?
                    p instanceof AndP ?
                            GraphSONTokens.AND :
                            GraphSONTokens.OR :
                    p.getBiPredicate().toString());
    if (p instanceof ConnectiveP) {
        jsonGenerator.writeArrayFieldStart(GraphSONTokens.VALUE);
        for (final P<?> predicate : ((ConnectiveP<?>) p).getPredicates()) {
            jsonGenerator.writeObject(predicate);
        }
        jsonGenerator.writeEndArray();
    } else {
        if (p.getValue() instanceof Collection) {
            jsonGenerator.writeArrayFieldStart(GraphSONTokens.VALUE);
            for (final Object object : (Collection) p.getValue()) {
                jsonGenerator.writeObject(object);
            }
            jsonGenerator.writeEndArray();
        } else
            jsonGenerator.writeObjectField(GraphSONTokens.VALUE, p.getValue());
    }
    jsonGenerator.writeEndObject();
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
/**
 * @deprecated As of release 3.2.4. Providers should handle composite {@link P#and} predicates and not rely on splitting.
 */
@Deprecated
public static HasContainer[] makeHasContainers(final String key, final P<?> predicate) {
    if (predicate instanceof AndP) {
        final List<P<?>> predicates = ((AndP) predicate).getPredicates();
        final HasContainer[] hasContainers = new HasContainer[predicates.size()];
        for (int i = 0; i < predicates.size(); i++) {
            hasContainers[i] = new HasContainer(key, predicates.get(i));
        }
        return hasContainers;
    } else {
        return new HasContainer[]{new HasContainer(key, predicate)};
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
@Test
public void shouldComposeCorrectly() {
    assertEquals(P.eq(1), P.eq(1));
    assertEquals(P.eq(1).and(P.eq(2)), new AndP<>(Arrays.asList(P.eq(1), P.eq(2))));
    assertEquals(P.eq(1).and(P.eq(2).and(P.eq(3))), new AndP<>(Arrays.asList(P.eq(1), P.eq(2), P.eq(3))));
    assertEquals(P.eq(1).and(P.eq(2).and(P.eq(3).and(P.eq(4)))), new AndP<>(Arrays.asList(P.eq(1), P.eq(2), P.eq(3), P.eq(4))));
    assertEquals(P.eq(1).or(P.eq(2).or(P.eq(3).or(P.eq(4)))), new OrP<>(Arrays.asList(P.eq(1), P.eq(2), P.eq(3), P.eq(4))));
    assertEquals(P.eq(1).or(P.eq(2).and(P.eq(3).or(P.eq(4)))), new OrP<>(Arrays.asList(P.eq(1), new AndP<>(Arrays.asList(P.eq(2), new OrP<>(Arrays.asList(P.eq(3), P.eq(4))))))));
    assertEquals(P.eq(1).and(P.eq(2).or(P.eq(3).and(P.eq(4)))), new AndP<>(Arrays.asList(P.eq(1), new OrP<>(Arrays.asList(P.eq(2), new AndP<>(Arrays.asList(P.eq(3), P.eq(4))))))));
    assertEquals(P.eq(1).and(P.eq(2).and(P.eq(3).or(P.eq(4)))), new AndP<>(Arrays.asList(P.eq(1), P.eq(2), new OrP<>(Arrays.asList(P.eq(3), P.eq(4))))));
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
@Override
public P<V> and(final Predicate<? super V> predicate) {
    if (!(predicate instanceof P))
        throw new IllegalArgumentException("Only P predicates can be and'd together");
    return new AndP<>(Arrays.asList(this, (P<V>) predicate));
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
public static <V> P<V> inside(final V first, final V second) {
    return new AndP<V>(Arrays.asList(new P(Compare.gt, first), new P(Compare.lt, second)));
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
public static <V> P<V> between(final V first, final V second) {
    return new AndP<V>(Arrays.asList(new P(Compare.gte, first), new P(Compare.lt, second)));
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
public static <V> P<V> inside(final V first, final V second) {
    return new AndP<>(Arrays.asList(new P(DatePredicate.gt, first), new P(DatePredicate.lt, second)));
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; //导入依赖的package包/类
public static <V> P<V> between(final V first, final V second) {
    return new AndP<>(Arrays.asList(new P(DatePredicate.gte, first), new P(DatePredicate.lt, second)));
}