How to write generic queries?

[bbarker]

I'd like to do something like the following function, but not sure to what extend this is possible or even makes sense (as QueryData is not public):

pub fn get_player_component_system(
    In(player_name): In<impl Into<String>>,
    query: Query<(QueryData, &Name), With<Player>>,
) -> Option<QueryData> {
    let pname = player_name.into();
    query.iter().find_map(|(data, name)| {
        if pname == name.to_string() {
            Some(data)
        } else {
            None
        }
    })
}

This is very similar to a non-generic implementation that does work, for instance:

pub fn get_player_system(
    In(player_name): In<impl Into<String>>,
    query: Query<(Entity, &Name), With<Player>>,
) -> Option<Entity> {
    let pname = player_name.into();
    query.iter().find_map(|(ent, name)| {
        if pname == name.to_string() {
            Some(ent)
        } else {
            None
        }
    })
}

[alice-i-cecile]

QueryData is a public trait :) You need a generic type with a trait bound. Try something like:

pub fn get_player_component_system<Q: QueryData>(
    In(player_name): In<impl Into<String>>,
    query: Query<(&Q, &Name), With<Player>>,
) -> Option<&Q> {
    let pname = player_name.into();
    query.iter().find_map(|(data, name)| {
        if pname == name.to_string() {
            Some(data)
        } else {
            None
        }
    })
}

[bbarker]

Further confirmation I was definitely not at my best yesterday - thanks! Got a bit further thanks to your suggestion:

pub fn get_player_component_system<'ws, 'a, Q>(
    In(player_name): In<impl Into<String>>,
    query: Query<'ws, 'ws, (Q, &'a Name), With<Player>>,
) -> Option<<Q::ReadOnly as WorldQuery>::Item<'ws>>
where
    Q: QueryData,
    <Q::ReadOnly as WorldQuery>::Item<'ws>: Clone,
{
    let pname = player_name.into();
    let res = query.iter().find_map(|(data, name)| {
        if pname == name.to_string() {
            Some(data.clone())
        } else {
            None
        }
    });
    res
}

Haven't been able to figure out the lifetime issue quite yet:

error[E0597]: `query` does not live long enough
   --> src/player.rs:367:15
    |
358 | pub fn get_player_component_system<'ws, 'a, Q>(
    |                                    --- lifetime `'ws` defined here
359 |     In(player_name): In<impl Into<String>>,
360 |     query: Query<'ws, 'ws, (Q, &'a Name), With<Player>>,
    |     ----- binding `query` declared here
...
367 |     let res = query.iter().find_map(|(data, name)| {
    |               ^^^^^-------
    |               |
    |               borrowed value does not live long enough
    |               argument requires that `query` is borrowed for `'ws`
...
375 | }
    |  - `query` dropped here while still borrowed

[bbarker]

@alice-i-cecile I think this is more along the lines of what you are saying:

// /// The item type returned when a [`WorldQuery`] is iterated over
// pub type QueryItem<'w, Q> = <Q as WorldQuery>::Item<'w>;
// /// The read-only variant of the item type returned when a [`QueryData`] is iterated over immutably
// pub type ROQueryItem<'w, D> = QueryItem<'w, <D as QueryData>::ReadOnly>;
pub fn get_player_component_system<'ws, 'a, 'q, Q>(
    In(player_name): In<impl Into<String>>,
    query: Query<'ws, 'ws, (&'q Q, &'a Name), With<Player>>,
) -> Option<Q>
where
    &'q Q: QueryData,
    // ROQueryItem<'ws, &'q Q>: Clone,
{
    let pname = player_name.into();
    let res = query.iter().find_map(|(data, name)| {
        if pname == name.to_string() {
            Some(data)
        } else {
            None
        }
    });
    res
}

But I'm not sure how to go from the ROQueryItem<'ws, &'q Q>: to just a Q - inside of the query iter, rust analyzer reports data has type Q. So maybe this is close but somehow the query isn't being "executed" I suppose?

[MrYeff]

@bbarker have you managed to find a solution to this issue by now? I'm facing the same issue