StartPos

azalea_entity::metadata

Struct StartPos 

Source 
pub struct StartPos(pub BlockPos);
Expand description

A metadata field for FallingBlock.

Tuple Fields§

§0: BlockPos

Methods from Deref<Target = BlockPos>§

Source

pub const ZERO: BlockPos

Source

pub fn length_squared(&self) -> i32

Get the distance of this vector to the origin by doing x^2 + y^2 + z^2.

Source

pub fn horizontal_distance_squared(&self) -> i32

Source

pub fn down(&self, y: i32) -> BlockPos

Return a new instance of this position with the y coordinate decreased by the given number.

Examples found in repository?
azalea/examples/testbot/commands/movement.rs (line 86)
16pub fn register(commands: &mut CommandDispatcher<Mutex<CommandSource>>) {
17    commands.register(
18        literal("goto")
19            .executes(|ctx: &Ctx| {
20                let mut source = ctx.source.lock();
21                println!("got goto");
22                // look for the sender
23                let Some(entity) = source.entity() else {
24                    source.reply("I can't see you!");
25                    return 0;
26                };
27                let Some(position) = source.bot.get_entity_component::<Position>(entity) else {
28                    source.reply("I can't see you!");
29                    return 0;
30                };
31                source.reply("ok");
32                source
33                    .bot
34                    .start_goto(BlockPosGoal(BlockPos::from(position)));
35                1
36            })
37            .then(literal("xz").then(argument("x", integer()).then(
38                argument("z", integer()).executes(|ctx: &Ctx| {
39                    let source = ctx.source.lock();
40                    let x = get_integer(ctx, "x").unwrap();
41                    let z = get_integer(ctx, "z").unwrap();
42                    println!("goto xz {x} {z}");
43                    source.reply("ok");
44                    source.bot.start_goto(XZGoal { x, z });
45                    1
46                }),
47            )))
48            .then(literal("radius").then(argument("radius", float()).then(
49                argument("x", integer()).then(argument("y", integer()).then(
50                    argument("z", integer()).executes(|ctx: &Ctx| {
51                        let source = ctx.source.lock();
52                        let radius = get_float(ctx, "radius").unwrap();
53                        let x = get_integer(ctx, "x").unwrap();
54                        let y = get_integer(ctx, "y").unwrap();
55                        let z = get_integer(ctx, "z").unwrap();
56                        println!("goto radius {radius}, position: {x} {y} {z}");
57                        source.reply("ok");
58                        source.bot.start_goto(RadiusGoal {
59                            pos: BlockPos::new(x, y, z).center(),
60                            radius,
61                        });
62                        1
63                    }),
64                )),
65            )))
66            .then(argument("x", integer()).then(argument("y", integer()).then(
67                argument("z", integer()).executes(|ctx: &Ctx| {
68                    let source = ctx.source.lock();
69                    let x = get_integer(ctx, "x").unwrap();
70                    let y = get_integer(ctx, "y").unwrap();
71                    let z = get_integer(ctx, "z").unwrap();
72                    println!("goto xyz {x} {y} {z}");
73                    source.reply("ok");
74                    source.bot.start_goto(BlockPosGoal(BlockPos::new(x, y, z)));
75                    1
76                }),
77            ))),
78    );
79
80    commands.register(literal("down").executes(|ctx: &Ctx| {
81        let source = ctx.source.clone();
82        tokio::spawn(async move {
83            let bot = source.lock().bot.clone();
84            let position = BlockPos::from(bot.position());
85            source.lock().reply("mining...");
86            bot.mine(position.down(1)).await;
87            source.lock().reply("done");
88        });
89        1
90    }));
91
92    commands.register(
93        literal("look")
94            .executes(|ctx: &Ctx| {
95                // look for the sender
96                let mut source = ctx.source.lock();
97                let Some(entity) = source.entity() else {
98                    source.reply("I can't see you!");
99                    return 0;
100                };
101                let Some(position) = source.bot.get_entity_component::<Position>(entity) else {
102                    source.reply("I can't see you!");
103                    return 0;
104                };
105                let eye_height = source
106                    .bot
107                    .get_entity_component::<EntityDimensions>(entity)
108                    .map(|h| h.eye_height)
109                    .unwrap_or_default();
110                source.bot.look_at(position.up(eye_height as f64));
111                1
112            })
113            .then(argument("x", integer()).then(argument("y", integer()).then(
114                argument("z", integer()).executes(|ctx: &Ctx| {
115                    let pos = BlockPos::new(
116                        get_integer(ctx, "x").unwrap(),
117                        get_integer(ctx, "y").unwrap(),
118                        get_integer(ctx, "z").unwrap(),
119                    );
120                    println!("{pos:?}");
121                    let source = ctx.source.lock();
122                    source.bot.look_at(pos.center());
123                    1
124                }),
125            ))),
126    );
127
128    commands.register(
129        literal("walk").then(argument("seconds", float()).executes(|ctx: &Ctx| {
130            let mut seconds = get_float(ctx, "seconds").unwrap();
131            let source = ctx.source.lock();
132            let bot = source.bot.clone();
133
134            if seconds < 0. {
135                bot.walk(WalkDirection::Backward);
136                seconds = -seconds;
137            } else {
138                bot.walk(WalkDirection::Forward);
139            }
140
141            tokio::spawn(async move {
142                tokio::time::sleep(Duration::from_secs_f32(seconds)).await;
143                bot.walk(WalkDirection::None);
144            });
145            source.reply(format!("ok, walking for {seconds} seconds"));
146            1
147        })),
148    );
149    commands.register(
150        literal("sprint").then(argument("seconds", float()).executes(|ctx: &Ctx| {
151            let seconds = get_float(ctx, "seconds").unwrap();
152            let source = ctx.source.lock();
153            let bot = source.bot.clone();
154            bot.sprint(SprintDirection::Forward);
155            tokio::spawn(async move {
156                tokio::time::sleep(Duration::from_secs_f32(seconds)).await;
157                bot.walk(WalkDirection::None);
158            });
159            source.reply(format!("ok, sprinting for {seconds} seconds"));
160            1
161        })),
162    );
163
164    commands.register(literal("north").executes(|ctx: &Ctx| {
165        let source = ctx.source.lock();
166        source.bot.set_direction(180., 0.);
167        source.reply("ok");
168        1
169    }));
170    commands.register(literal("south").executes(|ctx: &Ctx| {
171        let source = ctx.source.lock();
172        source.bot.set_direction(0., 0.);
173        source.reply("ok");
174        1
175    }));
176    commands.register(literal("east").executes(|ctx: &Ctx| {
177        let source = ctx.source.lock();
178        source.bot.set_direction(-90., 0.);
179        source.reply("ok");
180        1
181    }));
182    commands.register(literal("west").executes(|ctx: &Ctx| {
183        let source = ctx.source.lock();
184        source.bot.set_direction(90., 0.);
185        source.reply("ok");
186        1
187    }));
188    commands.register(
189        literal("jump")
190            .executes(|ctx: &Ctx| {
191                let source = ctx.source.lock();
192                source.bot.jump();
193                source.reply("ok");
194                1
195            })
196            .then(argument("enabled", bool()).executes(|ctx: &Ctx| {
197                let jumping = get_bool(ctx, "enabled").unwrap();
198                let source = ctx.source.lock();
199                source.bot.set_jumping(jumping);
200                1
201            })),
202    );
203
204    let sneak = |ctx: &Ctx| {
205        let source = ctx.source.lock();
206        source.bot.set_crouching(!source.bot.crouching());
207        source.reply("ok");
208        1
209    };
210    let sneak_enabled = argument("enabled", bool()).executes(|ctx: &Ctx| {
211        let sneaking = get_bool(ctx, "enabled").unwrap();
212        let source = ctx.source.lock();
213        source.bot.set_crouching(sneaking);
214        1
215    });
216    commands.register(literal("sneak").executes(sneak).then(sneak_enabled.clone()));
217    commands.register(literal("crouch").executes(sneak).then(sneak_enabled));
218
219    commands.register(literal("stop").executes(|ctx: &Ctx| {
220        let source = ctx.source.lock();
221        source.bot.stop_pathfinding();
222        source.reply("ok");
223        *source.state.task.lock() = BotTask::None;
224        1
225    }));
226}
Source

pub fn up(&self, y: i32) -> BlockPos

Return a new instance of this position with the y coordinate increased by the given number.

Source

pub fn north(&self, z: i32) -> BlockPos

Return a new instance of this position with the z coordinate subtracted by the given number.

Source

pub fn east(&self, x: i32) -> BlockPos

Return a new instance of this position with the x coordinate increased by the given number.

Source

pub fn south(&self, z: i32) -> BlockPos

Return a new instance of this position with the z coordinate increased by the given number.

Source

pub fn west(&self, x: i32) -> BlockPos

Return a new instance of this position with the x coordinate subtracted by the given number.

Source

pub fn dot(&self, other: BlockPos) -> i32

Source

pub fn min(&self, other: BlockPos) -> BlockPos

Make a new position with the lower coordinates for each axis.

Source

pub fn max(&self, other: BlockPos) -> BlockPos

Make a new position with the higher coordinates for each axis.

Source

pub fn xz(&self) -> BlockPos

Replace the Y with 0.

Source

pub fn with_x(&self, x: i32) -> BlockPos

Source

pub fn with_y(&self, y: i32) -> BlockPos

Source

pub fn with_z(&self, z: i32) -> BlockPos

Source

pub fn center(&self) -> Vec3

Get the absolute center of a block position by adding 0.5 to each coordinate.

Examples found in repository?
azalea/examples/steal.rs (line 69)
42async fn steal(bot: Client, state: State) -> anyhow::Result<()> {
43    {
44        let mut is_stealing = state.is_stealing.lock();
45        if *is_stealing {
46            bot.chat("Already stealing");
47            return Ok(());
48        }
49        *is_stealing = true;
50    }
51
52    state.checked_chests.lock().clear();
53
54    loop {
55        let chest_block = bot
56            .world()
57            .read()
58            .find_blocks(bot.position(), &BlockKind::Chest.into())
59            .find(
60                // find the closest chest that hasn't been checked
61                |block_pos| !state.checked_chests.lock().contains(block_pos),
62            );
63        let Some(chest_block) = chest_block else {
64            break;
65        };
66
67        state.checked_chests.lock().push(chest_block);
68
69        bot.goto(RadiusGoal::new(chest_block.center(), 3.)).await;
70
71        let Some(chest) = bot.open_container_at(chest_block).await else {
72            println!("Couldn't open chest at {chest_block:?}");
73            continue;
74        };
75
76        println!("Getting contents of chest at {chest_block:?}");
77        for (index, slot) in chest.contents().unwrap_or_default().iter().enumerate() {
78            println!("Checking slot {index}: {slot:?}");
79            let ItemStack::Present(item) = slot else {
80                continue;
81            };
82            if item.kind == ItemKind::Diamond {
83                println!("clicking slot ^");
84                chest.click(QuickMoveClick::Left { slot: index as u16 });
85            }
86        }
87    }
88
89    bot.chat("Done");
90
91    *state.is_stealing.lock() = false;
92
93    Ok(())
94}
More examples
Hide additional examples
azalea/examples/testbot/commands/movement.rs (line 59)
16pub fn register(commands: &mut CommandDispatcher<Mutex<CommandSource>>) {
17    commands.register(
18        literal("goto")
19            .executes(|ctx: &Ctx| {
20                let mut source = ctx.source.lock();
21                println!("got goto");
22                // look for the sender
23                let Some(entity) = source.entity() else {
24                    source.reply("I can't see you!");
25                    return 0;
26                };
27                let Some(position) = source.bot.get_entity_component::<Position>(entity) else {
28                    source.reply("I can't see you!");
29                    return 0;
30                };
31                source.reply("ok");
32                source
33                    .bot
34                    .start_goto(BlockPosGoal(BlockPos::from(position)));
35                1
36            })
37            .then(literal("xz").then(argument("x", integer()).then(
38                argument("z", integer()).executes(|ctx: &Ctx| {
39                    let source = ctx.source.lock();
40                    let x = get_integer(ctx, "x").unwrap();
41                    let z = get_integer(ctx, "z").unwrap();
42                    println!("goto xz {x} {z}");
43                    source.reply("ok");
44                    source.bot.start_goto(XZGoal { x, z });
45                    1
46                }),
47            )))
48            .then(literal("radius").then(argument("radius", float()).then(
49                argument("x", integer()).then(argument("y", integer()).then(
50                    argument("z", integer()).executes(|ctx: &Ctx| {
51                        let source = ctx.source.lock();
52                        let radius = get_float(ctx, "radius").unwrap();
53                        let x = get_integer(ctx, "x").unwrap();
54                        let y = get_integer(ctx, "y").unwrap();
55                        let z = get_integer(ctx, "z").unwrap();
56                        println!("goto radius {radius}, position: {x} {y} {z}");
57                        source.reply("ok");
58                        source.bot.start_goto(RadiusGoal {
59                            pos: BlockPos::new(x, y, z).center(),
60                            radius,
61                        });
62                        1
63                    }),
64                )),
65            )))
66            .then(argument("x", integer()).then(argument("y", integer()).then(
67                argument("z", integer()).executes(|ctx: &Ctx| {
68                    let source = ctx.source.lock();
69                    let x = get_integer(ctx, "x").unwrap();
70                    let y = get_integer(ctx, "y").unwrap();
71                    let z = get_integer(ctx, "z").unwrap();
72                    println!("goto xyz {x} {y} {z}");
73                    source.reply("ok");
74                    source.bot.start_goto(BlockPosGoal(BlockPos::new(x, y, z)));
75                    1
76                }),
77            ))),
78    );
79
80    commands.register(literal("down").executes(|ctx: &Ctx| {
81        let source = ctx.source.clone();
82        tokio::spawn(async move {
83            let bot = source.lock().bot.clone();
84            let position = BlockPos::from(bot.position());
85            source.lock().reply("mining...");
86            bot.mine(position.down(1)).await;
87            source.lock().reply("done");
88        });
89        1
90    }));
91
92    commands.register(
93        literal("look")
94            .executes(|ctx: &Ctx| {
95                // look for the sender
96                let mut source = ctx.source.lock();
97                let Some(entity) = source.entity() else {
98                    source.reply("I can't see you!");
99                    return 0;
100                };
101                let Some(position) = source.bot.get_entity_component::<Position>(entity) else {
102                    source.reply("I can't see you!");
103                    return 0;
104                };
105                let eye_height = source
106                    .bot
107                    .get_entity_component::<EntityDimensions>(entity)
108                    .map(|h| h.eye_height)
109                    .unwrap_or_default();
110                source.bot.look_at(position.up(eye_height as f64));
111                1
112            })
113            .then(argument("x", integer()).then(argument("y", integer()).then(
114                argument("z", integer()).executes(|ctx: &Ctx| {
115                    let pos = BlockPos::new(
116                        get_integer(ctx, "x").unwrap(),
117                        get_integer(ctx, "y").unwrap(),
118                        get_integer(ctx, "z").unwrap(),
119                    );
120                    println!("{pos:?}");
121                    let source = ctx.source.lock();
122                    source.bot.look_at(pos.center());
123                    1
124                }),
125            ))),
126    );
127
128    commands.register(
129        literal("walk").then(argument("seconds", float()).executes(|ctx: &Ctx| {
130            let mut seconds = get_float(ctx, "seconds").unwrap();
131            let source = ctx.source.lock();
132            let bot = source.bot.clone();
133
134            if seconds < 0. {
135                bot.walk(WalkDirection::Backward);
136                seconds = -seconds;
137            } else {
138                bot.walk(WalkDirection::Forward);
139            }
140
141            tokio::spawn(async move {
142                tokio::time::sleep(Duration::from_secs_f32(seconds)).await;
143                bot.walk(WalkDirection::None);
144            });
145            source.reply(format!("ok, walking for {seconds} seconds"));
146            1
147        })),
148    );
149    commands.register(
150        literal("sprint").then(argument("seconds", float()).executes(|ctx: &Ctx| {
151            let seconds = get_float(ctx, "seconds").unwrap();
152            let source = ctx.source.lock();
153            let bot = source.bot.clone();
154            bot.sprint(SprintDirection::Forward);
155            tokio::spawn(async move {
156                tokio::time::sleep(Duration::from_secs_f32(seconds)).await;
157                bot.walk(WalkDirection::None);
158            });
159            source.reply(format!("ok, sprinting for {seconds} seconds"));
160            1
161        })),
162    );
163
164    commands.register(literal("north").executes(|ctx: &Ctx| {
165        let source = ctx.source.lock();
166        source.bot.set_direction(180., 0.);
167        source.reply("ok");
168        1
169    }));
170    commands.register(literal("south").executes(|ctx: &Ctx| {
171        let source = ctx.source.lock();
172        source.bot.set_direction(0., 0.);
173        source.reply("ok");
174        1
175    }));
176    commands.register(literal("east").executes(|ctx: &Ctx| {
177        let source = ctx.source.lock();
178        source.bot.set_direction(-90., 0.);
179        source.reply("ok");
180        1
181    }));
182    commands.register(literal("west").executes(|ctx: &Ctx| {
183        let source = ctx.source.lock();
184        source.bot.set_direction(90., 0.);
185        source.reply("ok");
186        1
187    }));
188    commands.register(
189        literal("jump")
190            .executes(|ctx: &Ctx| {
191                let source = ctx.source.lock();
192                source.bot.jump();
193                source.reply("ok");
194                1
195            })
196            .then(argument("enabled", bool()).executes(|ctx: &Ctx| {
197                let jumping = get_bool(ctx, "enabled").unwrap();
198                let source = ctx.source.lock();
199                source.bot.set_jumping(jumping);
200                1
201            })),
202    );
203
204    let sneak = |ctx: &Ctx| {
205        let source = ctx.source.lock();
206        source.bot.set_crouching(!source.bot.crouching());
207        source.reply("ok");
208        1
209    };
210    let sneak_enabled = argument("enabled", bool()).executes(|ctx: &Ctx| {
211        let sneaking = get_bool(ctx, "enabled").unwrap();
212        let source = ctx.source.lock();
213        source.bot.set_crouching(sneaking);
214        1
215    });
216    commands.register(literal("sneak").executes(sneak).then(sneak_enabled.clone()));
217    commands.register(literal("crouch").executes(sneak).then(sneak_enabled));
218
219    commands.register(literal("stop").executes(|ctx: &Ctx| {
220        let source = ctx.source.lock();
221        source.bot.stop_pathfinding();
222        source.reply("ok");
223        *source.state.task.lock() = BotTask::None;
224        1
225    }));
226}
Source

pub fn center_bottom(&self) -> Vec3

Get the center of the bottom of a block position by adding 0.5 to the x and z coordinates.

Source

pub fn to_vec3_floored(&self) -> Vec3

Convert the block position into a Vec3 without centering it.

Source

pub fn length_manhattan(&self) -> u32

Get the distance of this vector from the origin by doing x + y + z.

Source

pub fn length(&self) -> f64

Get the distance (as an f64) of this BlockPos to the origin by doing sqrt(x^2 + y^2 + z^2).

Trait Implementations§

Source§

impl Clone for StartPos

Source§

fn clone(&self) -> StartPos

Returns a duplicate of the value. Read more
1.0.0§

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

Performs copy-assignment from source. Read more
Source§

impl Component for StartPos
where Self: Send + Sync + 'static,

Source§

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

A constant indicating the storage type used for this component.
Source§

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have [Component<Mutability = Mutable>], while immutable components will instead have [Component<Mutability = Immutable>]. Read more
Source§

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components. Read more
Source§

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component. Read more
§

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add [ComponentHook] for this [Component] if one is defined.
§

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert [ComponentHook] for this [Component] if one is defined.
§

fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_replace [ComponentHook] for this [Component] if one is defined.
§

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove [ComponentHook] for this [Component] if one is defined.
§

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn [ComponentHook] for this [Component] if one is defined.
§

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)
where E: EntityMapper,

Maps the entities on this component using the given [EntityMapper]. This is used to remap entities in contexts like scenes and entity cloning. When deriving [Component], this is populated by annotating fields containing entities with #[entities] Read more
Source§

impl Deref for StartPos

Source§

type Target = BlockPos

The resulting type after dereferencing.
Source§

fn deref(&self) -> &Self::Target

Dereferences the value.
Source§

impl DerefMut for StartPos

Source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
Source§

impl PartialEq for StartPos

Source§

fn eq(&self, other: &StartPos) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl StructuralPartialEq for StartPos

Auto Trait Implementations§

Blanket Implementations§

§

impl<T> Any for T
where T: 'static + ?Sized,

§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T> Borrow<T> for T
where T: ?Sized,

§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
§

impl<T> BorrowMut<T> for T
where T: ?Sized,

§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<C> Bundle for C
where C: Component,

§

fn component_ids( components: &mut ComponentsRegistrator<'_>, ids: &mut impl FnMut(ComponentId), )

§

fn get_component_ids( components: &Components, ids: &mut impl FnMut(Option<ComponentId>), )

Gets this [Bundle]’s component ids. This will be None if the component has not been registered.
§

impl<C> BundleFromComponents for C
where C: Component,

§

unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> C
where F: for<'a> FnMut(&'a mut T) -> OwningPtr<'a>,

§

impl<T> CloneToUninit for T
where T: Clone,

§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Converts &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Converts &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSend for T
where T: Any + Send,

§

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

impl<C> DynamicBundle for C
where C: Component,

§

type Effect = ()

An operation on the entity that happens after inserting this bundle.
§

unsafe fn get_components( ptr: MovingPtr<'_, C>, func: &mut impl FnMut(StorageType, OwningPtr<'_>), ) -> <C as DynamicBundle>::Effect

Moves the components out of the bundle. Read more
§

unsafe fn apply_effect( _ptr: MovingPtr<'_, MaybeUninit<C>>, _entity: &mut EntityWorldMut<'_>, )

Applies the after-effects of spawning this bundle. Read more
§

impl<T> From<T> for T

§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
§

impl<T, U> Into<U> for T
where U: From<T>,

§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

§

impl<T> IntoResult<T> for T

§

fn into_result(self) -> Result<T, RunSystemError>

Converts this type into the system output type.
§

impl<A> Is for A
where A: Any,

§

fn is<T>() -> bool
where T: Any,

Checks if the current type “is” another type, using a TypeId equality comparison. This is most useful in the context of generic logic. Read more
§

impl<T> PolicyExt for T
where T: ?Sized,

§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] only if self and other return Action::Follow. Read more
§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] if either self or other returns Action::Follow. Read more
§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> TypeData for T
where T: 'static + Send + Sync + Clone,

§

fn clone_type_data(&self) -> Box<dyn TypeData>

Creates a type-erased clone of this value.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

impl<T> ConditionalSend for T
where T: Send,