is-tree 0.9.9

//! [![](https://dcbadge.vercel.app/api/server/rzaesS82MT)](https://discord.gg/rzaesS82MT)
//!
//! ### is-tree
//! 
//! Convert everything into a tree structure that supports multi-type visitors for tree iterators and relative access.
//! 
//! ### Fully-featured example
//! 
//! ```rust
//! use is_tree::*;
//! 
//! visitor! {
//!     pub enum Visitors, VisitorsMut {
//!         Root(Library visits [Module]),
//!         Branches(
//!             Module visits [Module, Function],
//!             Function
//!         )
//!     }
//! }
//! 
//! #[derive(Debug, IsTree)]
//! pub struct Library {
//!     #[tree(path_segment)] // Any ToString can go here.
//!     pub name: String,
//!     #[tree(branch)] // If we want only this to be a branch.
//!     pub root_module: Module
//! }
//!
//! #[derive(Debug, Default, IsTree)]
//! #[tree(branches)] // This will make all fields branches.
//! pub struct Module {
//!     #[tree(path_segment)]
//!     pub name: String,
//!     pub modules: Vec<Module>,
//!     pub functions: Vec<Function>
//! }

//! 
//! #[derive(Debug, Default, IsTree)]
//! #[tree(branches)] 
//! pub struct Function {
//!     #[tree(path_segment)]
//!     pub name: String
//! }
//! 
//! impl Library {
//!     pub fn mock() -> Self {
//!         Library {
//!             name: String::from("library"),
//!             root_module: Module {
//!                 name: String::from("math"),
//!                 modules: vec![
//!                     Module {
//!                         name: String::from("geometry"),
//!                         modules: vec![Module { name: String::from("shapes"), .. Default::default() }],
//!                         .. Default::default()
//!                     },
//!                     Module {
//!                         name: String::from("algebra"),
//!                         functions: vec![Function { name: String::from("exponential") }],
//!                         .. Default::default()
//!                     },
//!                 ],
//!                 .. Default::default()
//!             },
//!         }
//!     }
//! }
//! 
//! fn main() {
//!     let mut library = Library::mock();
//!     
//!     // Getting the Module branches of the structure.
//!     library.branches_mut::<&mut Module>().for_each(|module| module.name = module.name.to_uppercase());
//!     library.branches::<&Module>().for_each(|module| println!("{}", module.name));
//! 
//!     // Getting a Module of the structure.
//!     library.get_mut::<&mut Module>("MATH").unwrap().name.push_str("EMATICS");
//!     println!("{}", library.get::<&Module>("MATHEMATICS").unwrap().name);
//! 
//!     // Getting an mutable tree visitor.
//!     let iterator: TreeIterator<VisitorsMut> = TreeIterator::new(&mut library);
//!     iterator.for_each(|mut visitor| {
//!         match &mut visitor {
//!             VisitorsMut::Library(visitor) => visitor.value.name = visitor.value.name.to_lowercase(),
//!             VisitorsMut::Module(visitor) => visitor.value.name = visitor.value.name.to_lowercase(),
//!             VisitorsMut::Function(visitor) => visitor.value.name = visitor.value.name.to_lowercase()
//!         }
//!     });
//! 
//!     // Getting a constant tree visitor.
//!     let iterator: TreeIterator<Visitors> = TreeIterator::new(&library);
//!     iterator.for_each(|visitor| println!("{}", visitor.path_segment()));
//! 
//!     // Getting the root visitor.
//!     let root_visitor = Visitors::from(&library);
//! 
//!      // Root don't have a parent.
//!     assert!(root_visitor.parent().is_none());
//! 
//!     // Root is the root of the structure.
//!     assert_eq!(root_visitor.root().as_library().unwrap().value.name, "library");
//! 
//!     // "self", "super" amd "root" are special path segments.
//!     assert_eq!(root_visitor.relative(vec!["self"]).unwrap().path(), Path::from(vec!["library"]));
//! 
//!     // Accessing Module structure.
//!     assert_eq!(root_visitor.relative(vec!["mathematics"]).unwrap().as_module().unwrap().value.name, "mathematics"); 
//! 
//!     // Using "super".
//!     assert_eq!(root_visitor.relative(vec!["mathematics", "algebra", "super"]).unwrap().as_module().unwrap().value.name, "mathematics"); 
//! 
//!     // Access a Function structure.
//!     assert_eq!(root_visitor.relative(vec!["mathematics", "algebra", "exponential"]).unwrap().as_function().unwrap().value.name, "exponential"); 
//! 
//!     // This is allowed.
//!     assert_eq!(root_visitor.relative(vec!["mathematics", "algebra", "exponential", "root"]).unwrap().as_library().unwrap().value.name, "library"); 
//! 
//!     // Mutably accessing the visitor's parent is unsafe because it allows you to get two mutable references to the same object.
//!     unsafe {
//!         let mut root_visitor = VisitorsMut::from(&mut library);
//! 
//!         assert!(root_visitor.parent_mut().is_none());
//! 
//!         root_visitor.root_mut().as_library_mut().unwrap().value.name = "LIBRARY".into();
//! 
//!         root_visitor.relative_mut(vec!["mathematics"]).unwrap().as_module_mut().unwrap().value.name = "MATHEMATICS".into(); 
//!     }
//! }
//! ```
//! 

pub mod prelude;

pub mod traits;
pub mod path;
pub mod visitor;
pub mod tree_iterator;
pub mod unsafe_;

pub use traits::*;
pub use path::*;
pub use visitor::*;
pub use tree_iterator::*;

pub use is_tree_macro::*;

pub mod visitor_macro;