#![feature(associated_type_defaults)]

extern crate self as lyra_ecs;

#[allow(unused_imports)]
pub(crate) mod lyra_engine {
    pub(crate) mod ecs {
        pub use super::super::*;
    }
}

use std::ops::BitOr;

mod archetype;
pub use archetype::*;

mod entity;
pub use entity::*;

mod world;
pub use world::*;

mod command;
pub use command::*;

mod bundle;
pub use bundle::*;

mod component;
pub use component::*;

pub mod query;
//pub use query::*;

pub mod relation;
pub use relation::Relation;

mod component_info;
pub use component_info::*;

mod resource;
pub use resource::*;

pub mod system;
//pub use system::*;

mod tick;
pub use tick::*;

/// Implements Component for glam math types
#[cfg(feature = "math")]
pub mod math;

pub use lyra_ecs_derive::*;

pub use atomic_refcell::AtomicRef;
pub use atomic_refcell::AtomicRefMut;

#[cfg(test)]
mod tests;

#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub enum Access {
    None,
    Read,
    Write,
}

impl BitOr for Access {
    type Output = Access;

    fn bitor(self, rhs: Self) -> Self::Output {
        if self == Access::Write || rhs == Access::Write {
            Access::Write
        } else if self == Access::Read || rhs == Access::Read {
            Access::Read
        } else {
            Access::None
        }
    }
}