FilteredEntityRef conversions

[coreh]

Objective

Right now, it's a bit cumbersome to write code that simultaneously deals with both FilteredEntityRef/EntityRef or with FilteredEntityMut/EntityMut. This PR aims to make it easier by allowing conversions (both infallible and fallible) between them.

Solution

• Added infallible conversions from unfiltered into filtered entity refs
• Added fallible conversions from filtered into unfiltered entity refs

---

Changelog

• Added the following infallible conversions: (From)
  • EntityRef<'a> → FilteredEntityRef<'a>
  • &'a EntityRef → FilteredEntityRef<'a>
  • EntityMut<'a> → FilteredEntityRef<'a>
  • &'a EntityMut → FilteredEntityRef<'a>
  • EntityWorldMut<'a> → FilteredEntityRef<'a>
  • &'a EntityWorldMut → FilteredEntityRef<'a>
  • EntityMut<'a> → FilteredEntityMut<'a>
  • &'a mut EntityMut → FilteredEntityMut<'a>
  • EntityWorldMut<'a> → FilteredEntityMut<'a>
  • &'a mut EntityWorldMut → FilteredEntityMut<'a>
• Added the following fallible conversions: (TryFrom)
  • FilteredEntityRef<'a> → EntityRef<'a>
  • &'a FilteredEntityRef → EntityRef<'a>
  • FilteredEntityMut<'a> → EntityRef<'a>
  • &'a FilteredEntityMut → EntityRef<'a>
  • FilteredEntityMut<'a> → EntityMut<'a>
  • &'a mut FilteredEntityMut → EntityMut<'a>

[afonsolage]

Does worth it adding an error for this conversion, so users may know why it failed, something like:

pub enum EntityRefAccessError {
    NoReadAll,
    NoWriteAll,
}

impl fmt::Display for EntityRefAccessError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::NoReadAll=> write!(f, "The given FilteredEntityRef has no read access on all entities."),
            Self::NoWriteAll=> write!(f, "The given FilteredEntityRef has no write access on all entities."),
        }
    }
}

impl std::error::Error for IdentifierError {}

[coreh]

Added the error enum, went with slightly different names to match the naming conventions for existing TryFrom errors, and also for variants of this existing error type

[afonsolage]

NIT: AFAIK you don't have to check for read all access, since it's impossible to have write_all access without read_all

Suggested change

	if value.access.has_read_all() && value.access.has_write_all() {
	if value.access.has_write_all() {

[alice-i-cecile]

I'd like to keep this in as a failsafe.

[coreh]

Is this guarantee something that we want to match the semantics of & and &mut in Rust, to keep it straightforward, or is it possible that we might want to have write-only access in the future?

[alice-i-cecile]

I think it's possible that we have write only access to certain data in the future. And more importantly, users can currently do this on their own.