org.apache.tinkerpop.gremlin.process.traversal

## Class P<V>

- java.lang.Object
- - org.apache.tinkerpop.gremlin.process.traversal.P<V>

- All Implemented Interfaces:
    Serializable, Cloneable, Predicate<V>
  Direct Known Subclasses:
    ConnectiveP, TextP

      public class P<V>
      extends Object
      implements Predicate<V>, Serializable, Cloneable

  Predefined `Predicate` values that can be used with
  Author:
    Marko A. Rodriguez (http://markorodriguez.com), Stephen Mallette (http://stephen.genoprime.com)
  See Also:
    Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected BiPredicate<V,V>` | `biPredicate`
    `protected V` | `originalValue`
    `protected V` | `value`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `P(BiPredicate<V,V> biPredicate, V value)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `P<V>` | `and(Predicate<? super V> predicate)`
    `static <V> P<V>` | `between(V first, V second)` Determines if a value is within (inclusive) of the range of the two specified values.
    `P<V>` | `clone()`
    `static <V> P<V>` | `eq(V value)` Determines if values are equal.
    `boolean` | `equals(Object other)`
    `BiPredicate<V,V>` | `getBiPredicate()`
    `V` | `getOriginalValue()` Gets the original value used at time of construction of the `P`.
    `V` | `getValue()` Gets the current value to be passed to the predicate for testing.
    `static <V> P<V>` | `gt(V value)` Determines if a value is greater than another.
    `static <V> P<V>` | `gte(V value)` Determines if a value is greater than or equal to another.
    `int` | `hashCode()`
    `static <V> P<V>` | `inside(V first, V second)` Determines if a value is within (exclusive) the range of the two specified values.
    `static <V> P<V>` | `lt(V value)` Determines if a value is less than another.
    `static <V> P<V>` | `lte(V value)` Determines if a value is less than or equal to another.
    `P<V>` | `negate()`
    `static <V> P<V>` | `neq(V value)` Determines if values are not equal.
    `static <V> P<V>` | `not(P<V> predicate)` The opposite of the specified `P`.
    `P<V>` | `or(Predicate<? super V> predicate)`
    `static <V> P<V>` | `outside(V first, V second)` Determines if a value is not within (exclusive) of the range of the two specified values.
    `void` | `setValue(V value)`
    `static P` | `test(BiPredicate biPredicate, Object value)` Construct an instance of `P` from a `BiPredicate`.
    `boolean` | `test(V testValue)`
    `String` | `toString()`
    `static <V> P<V>` | `within(Collection<V> value)` Determines if a value is within the specified list of values.
    `static <V> P<V>` | `within(V... values)` Determines if a value is within the specified list of values.
    `static <V> P<V>` | `without(Collection<V> value)` Determines if a value is not within the specified list of values.
    `static <V> P<V>` | `without(V... values)` Determines if a value is not within the specified list of values.

    - ### Methods inherited from class java.lang.Object

      `finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface java.util.function.Predicate

      `isEqual`

- - ### Field Detail

    - #### biPredicate

          protected BiPredicate<V,V> biPredicate

    - #### value

          protected V value

    - #### originalValue

          protected V originalValue

  - ### Constructor Detail

    - #### P

          public P(BiPredicate<V,V> biPredicate,
                   V value)

  - ### Method Detail

    - #### getBiPredicate

          public BiPredicate<V,V> getBiPredicate()

    - #### getOriginalValue

          public V getOriginalValue()

      Gets the original value used at time of construction of the `P`. This value can change its type in some cases.

    - #### getValue

          public V getValue()

      Gets the current value to be passed to the predicate for testing.

    - #### setValue

          public void setValue(V value)

    - #### test

          public boolean test(V testValue)

      Specified by:
        `test` in interface `Predicate<V>`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### equals

          public boolean equals(Object other)

      Overrides:
        `equals` in class `Object`

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### negate

          public P<V> negate()

      Specified by:
        `negate` in interface `Predicate<V>`

    - #### and

          public P<V> and(Predicate<? super V> predicate)

      Specified by:
        `and` in interface `Predicate<V>`

    - #### or

          public P<V> or(Predicate<? super V> predicate)

      Specified by:
        `or` in interface `Predicate<V>`

    - #### clone

          public P<V> clone()

      Overrides:
        `clone` in class `Object`

    - #### eq

          public static <V> P<V> eq(V value)

      Determines if values are equal.
      Since:
        3.0.0-incubating

    - #### neq

          public static <V> P<V> neq(V value)

      Determines if values are not equal.
      Since:
        3.0.0-incubating

    - #### lt

          public static <V> P<V> lt(V value)

      Determines if a value is less than another.
      Since:
        3.0.0-incubating

    - #### lte

          public static <V> P<V> lte(V value)

      Determines if a value is less than or equal to another.
      Since:
        3.0.0-incubating

    - #### gt

          public static <V> P<V> gt(V value)

      Determines if a value is greater than another.
      Since:
        3.0.0-incubating

    - #### gte

          public static <V> P<V> gte(V value)

      Determines if a value is greater than or equal to another.
      Since:
        3.0.0-incubating

    - #### inside

          public static <V> P<V> inside(V first,
                                        V second)

      Determines if a value is within (exclusive) the range of the two specified values.
      Since:
        3.0.0-incubating

    - #### outside

          public static <V> P<V> outside(V first,
                                         V second)

      Determines if a value is not within (exclusive) of the range of the two specified values.
      Since:
        3.0.0-incubating

    - #### between

          public static <V> P<V> between(V first,
                                         V second)

      Determines if a value is within (inclusive) of the range of the two specified values.
      Since:
        3.0.0-incubating

    - #### within

          public static <V> P<V> within(V... values)

      Determines if a value is within the specified list of values. If the array of arguments itself is `null` then the argument is treated as `Object[1]` where that single value is `null`.
      Since:
        3.0.0-incubating

    - #### within

          public static <V> P<V> within(Collection<V> value)

      Determines if a value is within the specified list of values. Calling this with `null` is the same as calling `within(Object[])` using `null`.
      Since:
        3.0.0-incubating

    - #### without

          public static <V> P<V> without(V... values)

      Determines if a value is not within the specified list of values. If the array of arguments itself is `null` then the argument is treated as `Object[1]` where that single value is `null`.
      Since:
        3.0.0-incubating

    - #### without

          public static <V> P<V> without(Collection<V> value)

      Determines if a value is not within the specified list of values. Calling this with `null` is the same as calling `within(Object[])` using `null`.
      Since:
        3.0.0-incubating

    - #### test

          public static P test(BiPredicate biPredicate,
                               Object value)

      Construct an instance of `P` from a `BiPredicate`.
      Since:
        3.0.0-incubating

    - #### not

          public static <V> P<V> not(P<V> predicate)

      The opposite of the specified `P`.
      Since:
        3.0.0-incubating

Copyright © 2013–2022 Apache Software Foundation. All rights reserved.