gremlin_client/process/traversal/
anonymous_traversal_source.rs

1use crate::process::traversal::step::has::HasStep;
2use crate::process::traversal::step::loops::LoopsStep;
3use crate::process::traversal::step::not::NotStep;
4use crate::process::traversal::step::or::OrStep;
5use crate::process::traversal::step::repeat::RepeatStep;
6use crate::process::traversal::step::select::SelectStep;
7use crate::process::traversal::step::until::UntilStep;
8use crate::process::traversal::step::where_step::WhereStep;
9use crate::process::traversal::TraversalBuilder;
10use crate::structure::{Either2, GIDs, IntoPredicate, Labels, T};
11use crate::GValue;
12
13pub struct AnonymousTraversalSource {
14    traversal: TraversalBuilder,
15}
16
17impl AnonymousTraversalSource {
18    pub fn new() -> AnonymousTraversalSource {
19        AnonymousTraversalSource {
20            traversal: TraversalBuilder::default(),
21        }
22    }
23
24    pub fn in_v(&self) -> TraversalBuilder {
25        self.traversal.clone().in_v()
26    }
27
28    pub fn aggregate<A>(&self, alias: A) -> TraversalBuilder
29    where
30        A: Into<String>,
31    {
32        self.traversal.clone().aggregate(alias)
33    }
34
35    pub fn add_v<A>(&self, label: A) -> TraversalBuilder
36    where
37        A: Into<Labels>,
38    {
39        self.traversal.clone().add_v(label)
40    }
41
42    pub fn property<A>(&self, key: Either2<&str, T>, value: A) -> TraversalBuilder
43    where
44        A: Into<GValue>,
45    {
46        self.traversal.clone().property(key, value)
47    }
48
49    pub fn v<T>(&self, ids: T) -> TraversalBuilder
50    where
51        T: Into<GIDs>,
52    {
53        self.traversal.clone().v(ids)
54    }
55
56    pub fn add_e<A>(&self, label: A) -> TraversalBuilder
57    where
58        A: Into<Labels>,
59    {
60        self.traversal.clone().add_e(label)
61    }
62
63    pub fn count(&self) -> TraversalBuilder {
64        self.traversal.clone().count()
65    }
66
67    pub fn out<L>(&self, labels: L) -> TraversalBuilder
68    where
69        L: Into<Labels>,
70    {
71        self.traversal.clone().out(labels)
72    }
73
74    pub fn out_e<L>(&self, labels: L) -> TraversalBuilder
75    where
76        L: Into<Labels>,
77    {
78        self.traversal.clone().out_e(labels)
79    }
80
81    pub fn in_<L>(&self, labels: L) -> TraversalBuilder
82    where
83        L: Into<Labels>,
84    {
85        self.traversal.clone().in_(labels)
86    }
87
88    pub fn in_e<L>(&self, labels: L) -> TraversalBuilder
89    where
90        L: Into<Labels>,
91    {
92        self.traversal.clone().in_e(labels)
93    }
94
95    pub fn both<L>(&self, labels: L) -> TraversalBuilder
96    where
97        L: Into<Labels>,
98    {
99        self.traversal.clone().both(labels)
100    }
101
102    pub fn both_e<L>(&self, labels: L) -> TraversalBuilder
103    where
104        L: Into<Labels>,
105    {
106        self.traversal.clone().both_e(labels)
107    }
108
109    pub fn other(&self) -> TraversalBuilder {
110        self.traversal.clone().other()
111    }
112
113    pub fn other_v(&self) -> TraversalBuilder {
114        self.traversal.clone().other_v()
115    }
116
117    pub fn values<L>(&self, labels: L) -> TraversalBuilder
118    where
119        L: Into<Labels>,
120    {
121        self.traversal.clone().values(labels)
122    }
123    pub fn has_label<L>(&self, labels: L) -> TraversalBuilder
124    where
125        L: Into<Labels>,
126    {
127        self.traversal.clone().has_label(labels)
128    }
129
130    pub fn as_<A>(&self, alias: A) -> TraversalBuilder
131    where
132        A: Into<String>,
133    {
134        self.traversal.clone().as_(alias)
135    }
136
137    pub fn has<A>(&self, step: A) -> TraversalBuilder
138    where
139        A: Into<HasStep>,
140    {
141        self.traversal.clone().has(step)
142    }
143
144    pub fn has_many<A>(&self, steps: Vec<A>) -> TraversalBuilder
145    where
146        A: Into<HasStep>,
147    {
148        self.traversal.clone().has_many(steps)
149    }
150
151    pub fn not<A>(&self, step: A) -> TraversalBuilder
152    where
153        A: Into<NotStep>,
154    {
155        self.traversal.clone().not(step)
156    }
157
158    pub fn loops<A>(&self, step: A) -> TraversalBuilder
159    where
160        A: Into<LoopsStep>,
161    {
162        self.traversal.clone().loops(step)
163    }
164
165    pub fn select<A>(&self, step: A) -> TraversalBuilder
166    where
167        A: Into<SelectStep>,
168    {
169        self.traversal.clone().select(step)
170    }
171
172    pub fn fold(&self) -> TraversalBuilder {
173        self.traversal.clone().fold()
174    }
175
176    pub fn unfold(&self) -> TraversalBuilder {
177        self.traversal.clone().unfold()
178    }
179
180    pub fn out_v(&self) -> TraversalBuilder {
181        self.traversal.clone().out_v()
182    }
183
184    pub fn is<A>(&self, val: A) -> TraversalBuilder
185    where
186        A: IntoPredicate,
187    {
188        self.traversal.clone().is(val)
189    }
190
191    pub fn or<A>(&self, step: A) -> TraversalBuilder
192    where
193        A: Into<OrStep>,
194    {
195        self.traversal.clone().or(step)
196    }
197
198    pub fn where_<A>(&self, step: A) -> TraversalBuilder
199    where
200        A: Into<WhereStep>,
201    {
202        self.traversal.clone().where_(step)
203    }
204
205    pub fn cap(&self, step: &'static str) -> TraversalBuilder {
206        self.traversal.clone().cap(step)
207    }
208
209    pub fn project<A>(&self, step: A) -> TraversalBuilder
210    where
211        A: Into<SelectStep>,
212    {
213        self.traversal.clone().project(step)
214    }
215
216    pub fn constant<A>(&self, value: A) -> TraversalBuilder
217    where
218        A: Into<GValue>,
219    {
220        self.traversal.clone().constant(value)
221    }
222
223    pub fn until<A>(&self, step: A) -> TraversalBuilder
224    where
225        A: Into<UntilStep>,
226    {
227        self.traversal.clone().until(step)
228    }
229
230    pub fn repeat<A>(&self, step: A) -> TraversalBuilder
231    where
232        A: Into<RepeatStep>,
233    {
234        self.traversal.clone().repeat(step)
235    }
236
237    pub fn emit(&self) -> TraversalBuilder {
238        self.traversal.clone().emit()
239    }
240}
241
242impl Default for AnonymousTraversalSource {
243    fn default() -> Self {
244        Self::new()
245    }
246}
gremlin_client/process/traversal/anonymous_traversal_source.rs

gremlin_client/process/traversal/
anonymous_traversal_source.rs
