ap_manual 0.2.0

use std::collections::{hash_map::{Entry,Iter, IterMut}, HashMap};

use serde::{Serialize,Deserialize};

/// Cannonical description of a category
#[derive(Debug,Serialize,Deserialize,PartialEq, Eq,Clone)]
pub struct Category {
    #[serde(default)]
    pub yaml_option: Vec<String>,
    #[serde(default)]
    pub hidden: bool
}
/// Cannonical representation of a collection of categories
#[derive(Debug,Serialize,Deserialize,PartialEq, Eq,Clone,Default)]
pub struct Categories{
    #[serde(flatten)]
    content: HashMap<String,Category>
}

impl Categories{
    /// Construct a new collection of categories
    pub fn new()->Self{
        Categories { content: HashMap::new() }
    }
    /// Add a new category
    pub fn add(&mut self, name: String,c: Category){
        self.content.insert(name, c);
    }
    /// Get a category by name
    pub fn get(&self, name: &str)->Option<&Category>{
        self.content.get(name)
    }
    /// Get a hashmap style entry for the given name
    pub fn entry<'a>(&'a mut self,name: String)->Entry<'a,String,Category>{
        self.content.entry(name)
    }
    /// Iterate over all categories by refrance
    pub fn iter<'a>(&'a self)->Iter<'a,String,Category>{
        self.content.iter()
    }
    /// Mutably iterate over all categories
    pub fn iter_mut<'a>(&'a mut self)->IterMut<'a, String,Category>{
        self.content.iter_mut()
    }
}
impl IntoIterator for Categories{
    type Item = (String,Category);
    type IntoIter = <HashMap<String, Category> as IntoIterator>::IntoIter;
    fn into_iter(self) -> Self::IntoIter {
        self.content.into_iter()
    }
}
impl Categories{
    pub fn with_category(mut self,name: String,c:Category)->Self{
        self.add(name, c);
        self
    }
    pub fn builder()->Self{
        Self::new()
    }
}