Struct gremlin_client::process::traversal::GraphTraversal

pub struct GraphTraversal<S, E: FromGValue, T: Terminator<E>> { /* fields omitted */ }

Methods

impl<S, E: FromGValue, T: Terminator<E>> GraphTraversal<S, E, T>

pub fn new(terminator: T, builder: TraversalBuilder) -> GraphTraversal<S, E, T>

pub fn bytecode(&self) -> &Bytecode

pub fn has_label<L>(self, labels: L) -> Self where
    L: Into<Labels>, 

pub fn add_v<A>(self, label: A) -> GraphTraversal<Vertex, Vertex, T> where
    A: Into<Labels>,
    T: Terminator<Vertex>, 

pub fn property<A>(self, key: &str, value: A) -> Self where
    A: Into<GValue>, 

pub fn property_many<A>(self, values: Vec<(String, A)>) -> Self where
    A: Into<GValue>, 

pub fn has<A>(self, step: A) -> Self where
    A: IntoHasStep, 

pub fn has_many<A>(self, steps: Vec<A>) -> Self where
    A: IntoHasStep, 

pub fn has_not<A>(self, key: A) -> Self where
    A: Into<String>, 

pub fn as_<A>(self, alias: A) -> Self where
    A: Into<String>, 

pub fn add_e<A>(self, label: A) -> GraphTraversal<S, Edge, T> where
    A: Into<String>,
    T: Terminator<Edge>, 

pub fn out<A>(self, labels: A) -> GraphTraversal<S, Vertex, T> where
    A: Into<Labels>,
    T: Terminator<Vertex>, 

pub fn out_e<A>(self, labels: A) -> GraphTraversal<S, Edge, T> where
    A: Into<Labels>,
    T: Terminator<Edge>, 

pub fn out_v(self) -> GraphTraversal<S, Vertex, T> where
    T: Terminator<Vertex>, 

pub fn in_<A>(self, labels: A) -> GraphTraversal<S, Vertex, T> where
    A: Into<Labels>,
    T: Terminator<Vertex>, 

pub fn in_e<A>(self, labels: A) -> GraphTraversal<S, Edge, T> where
    A: Into<Labels>,
    T: Terminator<Edge>, 

pub fn in_v(self) -> GraphTraversal<S, Vertex, T> where
    T: Terminator<Vertex>, 

pub fn label(self) -> GraphTraversal<S, String, T> where
    T: Terminator<String>, 

pub fn to_list(&self) -> T::List

pub fn next(&self) -> T::Next

pub fn has_next(&self) -> T::HasNext

pub fn iter(&self) -> T::Iter

pub fn from<A>(self, target: A) -> Self where
    A: IntoFromStep, 

pub fn to<A>(self, target: A) -> Self where
    A: IntoToStep, 

pub fn properties<L>(self, labels: L) -> GraphTraversal<S, GProperty, T> where
    L: Into<Labels>,
    T: Terminator<GProperty>, 

pub fn property_map<L>(self, labels: L) -> GraphTraversal<S, Map, T> where
    L: Into<Labels>,
    T: Terminator<Map>, 

pub fn values<L>(self, labels: L) -> GraphTraversal<S, GValue, T> where
    L: Into<Labels>,
    T: Terminator<GValue>, 

pub fn value_map<L>(self, labels: L) -> GraphTraversal<S, Map, T> where
    L: Into<Labels>,
    T: Terminator<Map>, 

pub fn count(self) -> GraphTraversal<S, i64, T> where
    T: Terminator<i64>, 

pub fn group_count(self) -> GraphTraversal<S, Map, T> where
    T: Terminator<Map>, 

pub fn group_count_as<A>(self, key: A) -> GraphTraversal<S, E, T> where
    T: Terminator<Map>,
    A: Into<String>, 

pub fn group(self) -> GraphTraversal<S, Map, T> where
    T: Terminator<Map>, 

pub fn group_as<A>(self, key: A) -> GraphTraversal<S, E, T> where
    T: Terminator<Map>,
    A: Into<String>, 

pub fn by<A>(self, step: A) -> Self where
    A: IntoByStep, 

pub fn select<A>(self, step: A) -> GraphTraversal<S, GValue, T> where
    A: IntoSelectStep,
    T: Terminator<GValue>, 

pub fn fold(self) -> GraphTraversal<S, List, T> where
    T: Terminator<List>, 

pub fn unfold(self) -> Self

pub fn path(self) -> GraphTraversal<S, Path, T> where
    T: Terminator<Path>, 

pub fn limit<A>(self, limit: A) -> Self where
    A: Into<LimitStep>, 

pub fn dedup<A>(self, dedup: A) -> Self where
    A: Into<DedupStep>, 

pub fn sum<A>(self, scope: A) -> GraphTraversal<S, GValue, T> where
    A: Into<Scope>,
    T: Terminator<GValue>, 

pub fn max<A>(self, scope: A) -> GraphTraversal<S, GValue, T> where
    A: Into<Scope>,
    T: Terminator<GValue>, 

pub fn mean<A>(self, scope: A) -> GraphTraversal<S, GValue, T> where
    A: Into<Scope>,
    T: Terminator<GValue>, 

pub fn min<A>(self, scope: A) -> GraphTraversal<S, GValue, T> where
    A: Into<Scope>,
    T: Terminator<GValue>, 

pub fn is<A>(self, val: A) -> Self where
    A: IntoPredicate, 

pub fn where_<A>(self, step: A) -> Self where
    A: IntoWhereStep, 

pub fn not<A>(self, step: A) -> Self where
    A: IntoNotStep, 

pub fn order<A>(self, scope: A) -> Self where
    A: Into<Scope>, 

pub fn match_<A>(self, step: A) -> GraphTraversal<S, Map, T> where
    A: IntoMatchStep,
    T: Terminator<Map>, 

pub fn drop(self) -> Self

pub fn or<A>(self, step: A) -> Self where
    A: IntoOrStep, 

pub fn map<A>(self, step: A) -> Self where
    A: IntoByStep, 

pub fn project<A>(self, step: A) -> GraphTraversal<S, GValue, T> where
    A: IntoSelectStep,
    T: Terminator<GValue>, 

pub fn v<VT>(self, ids: VT) -> Self where
    VT: Into<GIDs>, 

pub fn repeat<A>(self, step: A) -> Self where
    A: IntoRepeatStep, 

pub fn until<A>(self, step: A) -> Self where
    A: IntoUntilStep, 

pub fn simple_path(self) -> Self

pub fn sample(self, step: i32) -> Self

pub fn loops<A>(self, step: A) -> Self where
    A: Into<LoopsStep>, 

pub fn local<A>(self, step: A) -> Self where
    A: IntoLocalStep, 

Trait Implementations

impl<S: Clone, E: Clone + FromGValue, T: Clone + Terminator<E>> Clone for GraphTraversal<S, E, T>

fn clone(&self) -> GraphTraversal<S, E, T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.