Enum Menu

Source

pub enum Menu {
Show 26 variants
    Player(Player),
    Generic9x1 {
        contents: SlotList<9>,
        player: SlotList<36>,
    },
    Generic9x2 {
        contents: SlotList<18>,
        player: SlotList<36>,
    },
    Generic9x3 {
        contents: SlotList<27>,
        player: SlotList<36>,
    },
    Generic9x4 {
        contents: SlotList<36>,
        player: SlotList<36>,
    },
    Generic9x5 {
        contents: SlotList<45>,
        player: SlotList<36>,
    },
    Generic9x6 {
        contents: SlotList<54>,
        player: SlotList<36>,
    },
    Generic3x3 {
        contents: SlotList<9>,
        player: SlotList<36>,
    },
    Crafter3x3 {
        contents: SlotList<9>,
        player: SlotList<36>,
    },
    Anvil {
        first: ItemStack,
        second: ItemStack,
        result: ItemStack,
        player: SlotList<36>,
    },
    Beacon {
        payment: ItemStack,
        player: SlotList<36>,
    },
    BlastFurnace {
        ingredient: ItemStack,
        fuel: ItemStack,
        result: ItemStack,
        player: SlotList<36>,
    },
    BrewingStand {
        bottles: SlotList<3>,
        ingredient: ItemStack,
        fuel: ItemStack,
        player: SlotList<36>,
    },
    Crafting {
        result: ItemStack,
        grid: SlotList<9>,
        player: SlotList<36>,
    },
    Enchantment {
        item: ItemStack,
        lapis: ItemStack,
        player: SlotList<36>,
    },
    Furnace {
        ingredient: ItemStack,
        fuel: ItemStack,
        result: ItemStack,
        player: SlotList<36>,
    },
    Grindstone {
        input: ItemStack,
        additional: ItemStack,
        result: ItemStack,
        player: SlotList<36>,
    },
    Hopper {
        contents: SlotList<5>,
        player: SlotList<36>,
    },
    Lectern {
        book: ItemStack,
        player: SlotList<36>,
    },
    Loom {
        banner: ItemStack,
        dye: ItemStack,
        pattern: ItemStack,
        result: ItemStack,
        player: SlotList<36>,
    },
    Merchant {
        payments: SlotList<2>,
        result: ItemStack,
        player: SlotList<36>,
    },
    ShulkerBox {
        contents: SlotList<27>,
        player: SlotList<36>,
    },
    Smithing {
        template: ItemStack,
        base: ItemStack,
        additional: ItemStack,
        result: ItemStack,
        player: SlotList<36>,
    },
    Smoker {
        ingredient: ItemStack,
        fuel: ItemStack,
        result: ItemStack,
        player: SlotList<36>,
    },
    CartographyTable {
        map: ItemStack,
        additional: ItemStack,
        result: ItemStack,
        player: SlotList<36>,
    },
    Stonecutter {
        input: ItemStack,
        result: ItemStack,
        player: SlotList<36>,
    },
}

Expand description

A menu, which is a fixed collection of slots.

Variants§

§

Player(Player)

§

Generic9x1

Fields

§contents: SlotList<9>

§player: SlotList<36>

§

Generic9x2

Fields

§contents: SlotList<18>

§player: SlotList<36>

§

Generic9x3

Fields

§contents: SlotList<27>

§player: SlotList<36>

§

Generic9x4

Fields

§contents: SlotList<36>

§player: SlotList<36>

§

Generic9x5

Fields

§contents: SlotList<45>

§player: SlotList<36>

§

Generic9x6

Fields

§contents: SlotList<54>

§player: SlotList<36>

§

Generic3x3

Fields

§contents: SlotList<9>

§player: SlotList<36>

§

Crafter3x3

Fields

§contents: SlotList<9>

§player: SlotList<36>

§

Anvil

Fields

§first: ItemStack

§second: ItemStack

§result: ItemStack

§player: SlotList<36>

§

Beacon

Fields

§payment: ItemStack

§player: SlotList<36>

§

BlastFurnace

Fields

§ingredient: ItemStack

§fuel: ItemStack

§result: ItemStack

§player: SlotList<36>

§

BrewingStand

Fields

§bottles: SlotList<3>

§ingredient: ItemStack

§fuel: ItemStack

§player: SlotList<36>

§

Crafting

Fields

§result: ItemStack

§grid: SlotList<9>

§player: SlotList<36>

§

Enchantment

Fields

§item: ItemStack

§lapis: ItemStack

§player: SlotList<36>

§

Furnace

Fields

§ingredient: ItemStack

§fuel: ItemStack

§result: ItemStack

§player: SlotList<36>

§

Grindstone

Fields

§input: ItemStack

§additional: ItemStack

§result: ItemStack

§player: SlotList<36>

§

Hopper

Fields

§contents: SlotList<5>

§player: SlotList<36>

§

Lectern

Fields

§book: ItemStack

§player: SlotList<36>

§

Loom

Fields

§banner: ItemStack

§dye: ItemStack

§pattern: ItemStack

§result: ItemStack

§player: SlotList<36>

§

Merchant

Fields

§payments: SlotList<2>

§result: ItemStack

§player: SlotList<36>

§

ShulkerBox

Fields

§contents: SlotList<27>

§player: SlotList<36>

§

Smithing

Fields

§template: ItemStack

§base: ItemStack

§additional: ItemStack

§result: ItemStack

§player: SlotList<36>

§

Smoker

Fields

§ingredient: ItemStack

§fuel: ItemStack

§result: ItemStack

§player: SlotList<36>

§

CartographyTable

Fields

§map: ItemStack

§additional: ItemStack

§result: ItemStack

§player: SlotList<36>

§

Stonecutter

Fields

§input: ItemStack

§result: ItemStack

§player: SlotList<36>

Implementations§

Source

pub fn quick_move_stack(&mut self, slot_index: usize) -> ItemStack

Shift-click a slot in this menu.

Keep in mind that this doesn’t send any packets to the server, it just mutates this specific Menu.

Source

pub fn may_place( &self, _target_slot_index: usize, _item: &ItemStackData, ) -> bool

Whether the given item could be placed in this menu.

TODO: right now this always returns true

Source

pub fn may_pickup(&self, _source_slot_index: usize) -> bool

Whether the item in the given slot could be clicked and picked up.

TODO: right now this always returns true

Source

pub fn allow_modification(&self, target_slot_index: usize) -> bool

Whether the item in the slot can be picked up and placed.

Source

pub fn max_stack_size(&self, _target_slot_index: usize) -> i32

Get the maximum number of items that can be placed in this slot.

Source

pub fn as_player(&self) -> &Player

Get the Player from this Menu.

§Panics

Will panic if the menu isn’t Menu::Player.

Source

pub fn try_as_player(&self) -> Option<&Player>

Get the Player from this Menu, or returns None if the menu isn’t a player menu.

Source

pub fn as_player_mut(&mut self) -> &mut Player

Same as Menu::as_player, but returns a mutable reference to the Player.

§Panics

Will panic if the menu isn’t Menu::Player.

Source

pub fn try_as_player_mut(&mut self) -> Option<&mut Player>

Same as Menu::try_as_player, but returns a mutable reference to the Player.

Source

pub fn slot_mut(&mut self, i: usize) -> Option<&mut ItemStack>

Get a mutable reference to the ItemStack at the given protocol index.

If you’re trying to get an item in a menu without caring about protocol indexes, you should just match it and index the ItemStack you get.

Use Menu::slot if you don’t need a mutable reference to the slot.

§Errors

Returns None if the index is out of bounds.

Source

pub fn slot(&self, i: usize) -> Option<&ItemStack>

Get a reference to the ItemStack at the given protocol index.

If you’re trying to get an item in a menu without caring about protocol indexes, you should just match it and index the ItemStack you get.

Use Menu::slot_mut if you need a mutable reference to the slot.

§Errors

Returns None if the index is out of bounds.

Source

pub const fn len(&self) -> usize

Returns the number of slots in the menu.

Source

pub fn from_kind(kind: MenuKind) -> Menu

Source

pub fn slots(&self) -> Vec<ItemStack>

Return the contents of the menu, including the player’s inventory.

The indexes in this will match up with Menu::slot_mut.

If you don’t want to include the player’s inventory, use Menu::contents instead.

If you only want to include the players inventory, then you can filter by only using the slots in Self::player_slots_range.

Examples found in repository ?

azalea/examples/testbot/commands/debug.rs (line 173)

26pub fn register(commands: &mut CommandDispatcher<Mutex<CommandSource>>) {
27    commands.register(literal("ping").executes(|ctx: &Ctx| {
28        let source = ctx.source.lock();
29        source.reply("pong!");
30        1
31    }));
32    commands.register(
33        literal("say").then(argument("message", greedy_string()).executes(|ctx: &Ctx| {
34            let source = ctx.source.lock();
35            let message = get_string(ctx, "message").unwrap();
36            source.bot.chat(message);
37            1
38        })),
39    );
40
41    commands.register(literal("disconnect").executes(|ctx: &Ctx| {
42        let source = ctx.source.lock();
43        source.bot.disconnect();
44        1
45    }));
46
47    commands.register(literal("whereami").executes(|ctx: &Ctx| {
48        let source = ctx.source.lock();
49        let Some(entity) = source.entity() else {
50            source.reply("You aren't in render distance!");
51            return 0;
52        };
53        let position = entity.position();
54        source.reply(format!(
55            "You are at {}, {}, {}",
56            position.x, position.y, position.z
57        ));
58        1
59    }));
60
61    commands.register(literal("entityid").executes(|ctx: &Ctx| {
62        let source = ctx.source.lock();
63        let Some(entity) = source.entity() else {
64            source.reply("You aren't in render distance!");
65            return 0;
66        };
67        let entity_id = entity.minecraft_id();
68        source.reply(format!(
69            "Your Minecraft ID is {} and your ECS ID is {entity:?}",
70            *entity_id
71        ));
72        1
73    }));
74
75    let whereareyou = |ctx: &Ctx| {
76        let source = ctx.source.lock();
77        let position = source.bot.position();
78        source.reply(format!(
79            "I'm at {}, {}, {}",
80            position.x, position.y, position.z
81        ));
82        1
83    };
84    commands.register(literal("whereareyou").executes(whereareyou));
85    commands.register(literal("pos").executes(whereareyou));
86
87    commands.register(literal("whoareyou").executes(|ctx: &Ctx| {
88        let source = ctx.source.lock();
89        source.reply(format!(
90            "I am {} ({}, {})",
91            source.bot.username(),
92            source.bot.uuid(),
93            source.bot.entity
94        ));
95        1
96    }));
97
98    commands.register(literal("getdirection").executes(|ctx: &Ctx| {
99        let source = ctx.source.lock();
100        let direction = source.bot.direction();
101        source.reply(format!(
102            "I'm looking at {}, {}",
103            direction.y_rot(),
104            direction.x_rot()
105        ));
106        1
107    }));
108
109    commands.register(literal("health").executes(|ctx: &Ctx| {
110        let source = ctx.source.lock();
111
112        let health = source.bot.health();
113        source.reply(format!("I have {health} health"));
114        1
115    }));
116
117    commands.register(literal("lookingat").executes(|ctx: &Ctx| {
118        let source = ctx.source.lock();
119
120        let hit_result = source.bot.hit_result();
121
122        match &hit_result {
123            HitResult::Block(r) => {
124                if r.miss {
125                    source.reply("I'm not looking at anything");
126                    return 0;
127                }
128                let block_pos = r.block_pos;
129                let block = source.bot.world().read().get_block_state(block_pos);
130                source.reply(format!("I'm looking at {block:?} at {block_pos:?}"));
131            }
132            HitResult::Entity(r) => {
133                let entity_kind = **source.bot.entity_component::<EntityKindComponent>(r.entity);
134                source.reply(format!(
135                    "I'm looking at {entity_kind} ({:?}) at {}",
136                    r.entity, r.location
137                ));
138            }
139        }
140
141        1
142    }));
143
144    commands.register(literal("getblock").then(argument("x", integer()).then(
145        argument("y", integer()).then(argument("z", integer()).executes(|ctx: &Ctx| {
146            let source = ctx.source.lock();
147            let x = get_integer(ctx, "x").unwrap();
148            let y = get_integer(ctx, "y").unwrap();
149            let z = get_integer(ctx, "z").unwrap();
150            println!("getblock xyz {x} {y} {z}");
151            let block_pos = BlockPos::new(x, y, z);
152            let block = source.bot.world().read().get_block_state(block_pos);
153            source.reply(format!("BlockKind at {block_pos} is {block:?}"));
154            1
155        })),
156    )));
157    commands.register(literal("getfluid").then(argument("x", integer()).then(
158        argument("y", integer()).then(argument("z", integer()).executes(|ctx: &Ctx| {
159            let source = ctx.source.lock();
160            let x = get_integer(ctx, "x").unwrap();
161            let y = get_integer(ctx, "y").unwrap();
162            let z = get_integer(ctx, "z").unwrap();
163            println!("getfluid xyz {x} {y} {z}");
164            let block_pos = BlockPos::new(x, y, z);
165            let block = source.bot.world().read().get_fluid_state(block_pos);
166            source.reply(format!("Fluid at {block_pos} is {block:?}"));
167            1
168        })),
169    )));
170
171    commands.register(literal("inventory").executes(|ctx: &Ctx| {
172        let source = ctx.source.lock();
173        for item in source.bot.menu().slots() {
174            if item.is_empty() {
175                continue;
176            }
177            println!("{item:?}");
178            for (kind, data) in item.component_patch().iter() {
179                if let Some(data) = data {
180                    println!("- {kind} {data:?}");
181                }
182            }
183        }
184        1
185    }));
186
187    commands.register(literal("pathfinderstate").executes(|ctx: &Ctx| {
188        let source = ctx.source.lock();
189        let pathfinder = source.bot.get_component::<Pathfinder>();
190        let Some(pathfinder) = pathfinder else {
191            source.reply("I don't have the Pathfinder component");
192            return 1;
193        };
194        source.reply(format!(
195            "pathfinder.is_calculating: {}",
196            pathfinder.is_calculating
197        ));
198
199        let executing_path = source.bot.get_component::<ExecutingPath>();
200        let Some(executing_path) = executing_path else {
201            source.reply("I'm not executing a path");
202            return 1;
203        };
204        source.reply(format!(
205            "is_path_partial: {}, path.len: {}, queued_path.len: {}",
206            executing_path.is_path_partial,
207            executing_path.path.len(),
208            if let Some(queued) = &executing_path.queued_path {
209                queued.len().to_string()
210            } else {
211                "n/a".to_owned()
212            },
213        ));
214        1
215    }));
216    commands.register(literal("pathfindermoves").executes(|ctx: &Ctx| {
217        let source = ctx.source.lock();
218
219        let Some(entity) = source.entity() else {
220            source.reply("You aren't in render distance!");
221            return 0;
222        };
223        let position = entity.position();
224        let position = BlockPos::from(position);
225
226        let mut edges = Vec::new();
227        let cached_world = CachedWorld::new(source.bot.world(), position);
228        let mining_cache = MiningCache::new(Some(Menu::Player(inventory::Player::default())));
229        let custom_state = CustomPathfinderStateRef::default();
230
231        azalea::pathfinder::moves::default_move(
232            &mut MovesCtx {
233                edges: &mut edges,
234                world: &cached_world,
235                mining_cache: &mining_cache,
236                custom_state: &custom_state,
237            },
238            RelBlockPos::from_origin(position, position),
239        );
240
241        if edges.is_empty() {
242            source.reply("No possible moves.");
243        } else {
244            source.reply("Moves:");
245            for (i, edge) in edges.iter().enumerate() {
246                source.reply(format!("{}) {edge:?}", i + 1));
247            }
248        }
249
250        1
251    }));
252
253    commands.register(literal("startuseitem").executes(|ctx: &Ctx| {
254        let source = ctx.source.lock();
255        source.bot.start_use_item();
256        source.reply("Ok!");
257        1
258    }));
259    commands.register(literal("maxstacksize").executes(|ctx: &Ctx| {
260        let source = ctx.source.lock();
261        let max_stack_size = source
262            .bot
263            .get_held_item()
264            .get_component::<MaxStackSize>()
265            .map_or(-1, |s| s.count);
266        source.reply(format!("{max_stack_size}"));
267        1
268    }));
269
270    commands.register(literal("dimensions").executes(|ctx: &Ctx| {
271        let source = ctx.source.lock();
272        let bot_dimensions = source.bot.dimensions();
273        source.reply(format!("{bot_dimensions:?}"));
274        1
275    }));
276
277    commands.register(literal("players").executes(|ctx: &Ctx| {
278        let source = ctx.source.lock();
279        let player_entities = source
280            .bot
281            .nearest_entities_by::<(), With<metadata::Player>>(|_: ()| true);
282        let tab_list = source.bot.tab_list();
283        for player_entity in player_entities {
284            let uuid = player_entity.uuid();
285            source.reply(format!(
286                "{} - {} ({:?})",
287                player_entity.id(),
288                tab_list.get(&uuid).map_or("?", |p| p.profile.name.as_str()),
289                uuid
290            ));
291        }
292        1
293    }));
294
295    commands.register(literal("enchants").executes(|ctx: &Ctx| {
296        let source = ctx.source.lock();
297        source.bot.with_registry_holder(|r| {
298            let enchants = &r.enchantment;
299            println!("enchants: {enchants:?}");
300        });
301        1
302    }));
303
304    commands.register(literal("attributes").executes(|ctx: &Ctx| {
305        let source = ctx.source.lock();
306        let attributes = source.bot.attributes();
307        println!("attributes: {attributes:?}");
308        1
309    }));
310
311    commands.register(literal("debugecsleak").executes(|ctx: &Ctx| {
312        let source = ctx.source.lock();
313
314        source.reply("Ok!");
315
316
317
318        source.bot.disconnect();
319
320        let ecs = source.bot.ecs.clone();
321        thread::spawn(move || {
322            thread::sleep(Duration::from_secs(1));
323            // dump the ecs
324
325            let mut ecs = ecs.write();
326
327            let report_path = env::temp_dir().join("azalea-ecs-leak-report.txt");
328            let mut report = File::create(&report_path).unwrap();
329
330            let mut query = ecs.query::<EntityRef>();
331            for entity in query.iter(& ecs) {
332                writeln!(report, "Entity: {}", entity.id()).unwrap();
333                let archetype = entity.archetype();
334                let component_count = archetype.component_count();
335
336                let component_names = archetype
337                    .components()
338                    .iter()
339                    .map(|c| ecs.components().get_info(*c).unwrap().name().to_string())
340                    .collect::<Vec<_>>();
341                writeln!(
342                    report,
343                    "- {component_count} components: {}",
344                    component_names.join(", ")
345                )
346                .unwrap();
347            }
348
349            writeln!(report).unwrap();
350
351
352            for (info, _) in ecs.iter_resources() {
353                let name = info.name().to_string();
354                writeln!(report, "Resource: {name}").unwrap();
355                // writeln!(report, "- Size: {} bytes",
356                // info.layout().size()).unwrap();
357
358                match name.as_ref() {
359                    "azalea_world::container::Worlds" => {
360                        let worlds = ecs.resource::<Worlds>();
361
362                        for (world_name, world) in &worlds.map {
363                            writeln!(report, "- Name: {world_name}").unwrap();
364                            writeln!(report, "- Reference count: {}", world.strong_count())
365                                .unwrap();
366                            if let Some(world) = world.upgrade() {
367                                let world = world.read();
368                                let chunks = &world.chunks;
369                                let chunks = (chunks as &dyn Any).downcast_ref::<WeakChunkStorage>();
370                                if let Some(chunks) = chunks {
371                                    let strong_chunks = chunks
372                                        .map
373                                        .iter()
374                                        .filter(|(_, v)| v.strong_count() > 0)
375                                        .count();
376                                    writeln!(
377                                        report,
378                                        "- Chunks: {} strongly referenced, {} in map",
379                                        strong_chunks,
380                                        chunks.map.len()
381                                    )
382                                    .unwrap();
383                                }
384                                writeln!(
385                                    report,
386                                    "- Entities: {}",
387                                    world.entities_by_chunk.len()
388                                )
389                                .unwrap();
390                            }
391                        }
392                    }
393                    "bevy_ecs::message::Messages<azalea_client::packet::game::ReceivePacketEvent>" => {
394                        let events = ecs.resource::<Messages<game::ReceiveGamePacketEvent>>();
395                        writeln!(report, "- Event count: {}", events.len()).unwrap();
396                    }
397                    "bevy_ecs::message::Messages<azalea_client::chunks::ReceiveChunkEvent>" => {
398                        let events = ecs.resource::<Messages<ReceiveChunkEvent>>();
399                        writeln!(report, "- Event count: {}", events.len()).unwrap();
400                    }
401
402                    _ => {}
403                }
404            }
405
406            println!("\x1b[1mWrote report to {}\x1b[m", report_path.display());
407        });
408
409        1
410    }));
411
412    commands.register(literal("exit").executes(|ctx: &Ctx| {
413        let source = ctx.source.lock();
414        source.reply("bye!");
415
416        source.bot.disconnect();
417
418        let source = ctx.source.clone();
419        thread::spawn(move || {
420            thread::sleep(Duration::from_secs(1));
421
422            source
423                .lock()
424                .bot
425                .ecs
426                .write()
427                .write_message(AppExit::Success);
428        });
429
430        1
431    }));
432}

Source

pub fn contents(&self) -> Vec<ItemStack>

Return the contents of the menu, not including the player’s inventory.

If you want to include the player’s inventory, use Menu::slots instead.

Source

pub fn location_for_slot(&self, i: usize) -> Option<MenuLocation>

Source

pub fn player_slots_range(&self) -> RangeInclusive<usize>

Get the range of slot indexes that contain the player’s inventory.

This may be different for each menu.

Source

pub fn hotbar_slots_range(&self) -> RangeInclusive<usize>

Get the range of slot indexes that contain the player’s hotbar.

This may be different for each menu.

let hotbar_items = &inventory.slots()[inventory.hotbar_slots_range()];

Source

pub fn player_slots_without_hotbar_range(&self) -> RangeInclusive<usize>

Get the range of slot indexes that contain the player’s inventory, not including the hotbar.

This may be different for each menu.

Source

pub fn is_hotbar_slot(&self, i: usize) -> bool

Returns whether the given index would be in the player’s hotbar.

Equivalent to self.hotbar_slots_range().contains(&i).

Trait Implementations§

Source §

fn clone(&self) -> Menu

Returns a duplicate of the value. Read more

1.0.0 · Source§

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

Performs copy-assignment from source. Read more

Source §

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more

Auto Trait Implementations§

Blanket Implementations§

Source §

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

Source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

Source §

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

Source §

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

Source §

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

Source §

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

Mutably borrows from an owned value. Read more

Source §

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

Source §

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> CompatExt for T

§

fn compat(self) -> Compat<T>

Applies the [Compat] adapter by value. Read more

§

fn compat_ref(&self) -> Compat<&T>

Applies the [Compat] adapter by shared reference. Read more

§

fn compat_mut(&mut self) -> Compat<&mut T>

Applies the [Compat] adapter by mutable reference. 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.

Source §