// use std::collections::HashMap;
// use std::fmt::{Debug, Display, Formatter};
//
// use crate::infograph::strings::{BoxedString, InlineString};
// use tokio::time::Duration;
// use yaml_rust::Yaml;
//
// #[derive(Clone, PartialEq, Debug)]
// pub enum Node {
//     Empty,
//     Float(f64),
//     Integer(i64),
//     BoxedString(BoxedString),
//     InlineString(InlineString),
//     Boolean(bool),
//     List(Vec<Node>),
//     Object(HashMap<String, Node>),
// }
//
// impl Node {
//     pub fn string(value: impl AsRef<str>) -> Self {
//         let string = value.as_ref();
//         // let length = string.len();
//         // if length <= MAX_STRING_INLINE_LEN {
//         //     let mut data = [0 as u8; MAX_STRING_INLINE_LEN];
//         //     data[0..length].clone_from_slice(&string.as_bytes()[0..length]);
//         //     Node::InlineString(InlineString {
//         //         data,
//         //         size: length as u8,
//         //     })
//         // } else {
//         //     Node::BoxedString(BoxedString {
//         //         data: string.as_bytes().into(),
//         //     })
//         // }
//         Node::BoxedString(BoxedString::from(string))
//     }
//     pub fn object() -> Self {
//         Node::Object(HashMap::new())
//     }
//
//     pub fn from_yaml(yaml: &Yaml) -> Self {
//         match yaml {
//             Yaml::Real(value) => value
//                 .parse::<f64>()
//                 .map(|val| Node::Float(val))
//                 .unwrap_or(Node::Empty),
//             Yaml::Integer(value) => Node::Integer(*value),
//             Yaml::String(value) => Node::string(value),
//             Yaml::Boolean(value) => Node::Boolean(*value),
//             Yaml::Array(value) => {
//                 let mut elements = Vec::new();
//                 for element in value.iter() {
//                     elements.push(Node::from_yaml(element));
//                 }
//
//                 Node::List(elements)
//             }
//             Yaml::Hash(value) => {
//                 let mut elements = HashMap::new();
//                 for element in value.iter() {
//                     if let Some(key) = element.0.as_str().map(|str| str.to_owned()) {
//                         let value = Node::from_yaml(&element.1);
//                         elements.insert(key, value);
//                     }
//                 }
//
//                 Node::Object(elements)
//             }
//             _ => Node::Empty,
//         }
//     }
//
//     pub fn is_empty(&self) -> bool {
//         if let Node::Empty = self {
//             true
//         } else {
//             false
//         }
//     }
//
//     pub fn is_filled(&self) -> bool {
//         self != &Node::Empty
//     }
//
//     pub fn is_float(&self) -> bool {
//         if let Node::Float(_) = self {
//             true
//         } else {
//             false
//         }
//     }
//
//     pub fn as_float(&self) -> Option<f64> {
//         match self {
//             Node::Float(value) => Some(*value),
//             _ => None,
//         }
//     }
//
//     pub fn is_int(&self) -> bool {
//         if let Node::Integer(_) = self {
//             true
//         } else {
//             false
//         }
//     }
//
//     pub fn as_int(&self) -> Option<i64> {
//         match self {
//             Node::Integer(value) => Some(*value),
//             _ => None,
//         }
//     }
//
//     pub fn as_required_int(&self) -> Option<i64> {
//         match self {
//             Node::Integer(value) if *value != 0 => Some(*value),
//             _ => None,
//         }
//     }
//
//     pub fn is_string(&self) -> bool {
//         match self {
//             Node::BoxedString(_) | Node::InlineString(_) => true,
//             _ => false,
//         }
//     }
//
//     pub fn as_str(&self) -> Option<&str> {
//         match self {
//             Node::BoxedString(value) => Some(value.as_ref()),
//             Node::InlineString(value) => Some(value.as_ref()),
//             _ => None,
//         }
//     }
//
//     pub fn as_required_str(&self) -> Option<&str> {
//         match self {
//             Node::BoxedString(value) if !value.is_empty() => Some(value.as_ref()),
//             Node::InlineString(value) if !value.is_empty() => Some(value.as_ref()),
//             _ => None,
//         }
//     }
//
//     pub fn as_size(&self) -> anyhow::Result<usize> {
//         match self {
//             Node::Integer(value) => Ok(*value as usize),
//             Node::BoxedString(value) => crate::fmt::parse_size(value),
//             Node::InlineString(value) => crate::fmt::parse_size(value),
//             _ => Err(anyhow::anyhow!("Expected either a string or a number.")),
//         }
//     }
//
//     pub fn as_required_size(&self) -> anyhow::Result<usize> {
//         match self.as_size() {
//             Ok(value) if value > 0 => Ok(value),
//             Ok(_) => Err(anyhow::anyhow!("Expected a positive size value.")),
//             other => other,
//         }
//     }
//
//     pub fn as_duration(&self) -> anyhow::Result<Duration> {
//         match self {
//             Node::Integer(value) => Ok(Duration::from_millis(*value as u64)),
//             Node::BoxedString(value) => crate::fmt::parse_duration(value),
//             Node::InlineString(value) => crate::fmt::parse_duration(value),
//             _ => Err(anyhow::anyhow!("Expected either a string or a number.")),
//         }
//     }
//
//     pub fn as_required_duration(&self) -> anyhow::Result<Duration> {
//         match self.as_duration() {
//             Ok(value) if value.as_micros() > 0 => Ok(value),
//             Ok(_) => Err(anyhow::anyhow!("Expected a positive duration.")),
//             other => other,
//         }
//     }
//
//     pub fn is_bool(&self) -> bool {
//         if let Node::Boolean(_) = self {
//             true
//         } else {
//             false
//         }
//     }
//
//     pub fn as_bool(&self) -> Option<bool> {
//         match self {
//             Node::Boolean(value) => Some(*value),
//             _ => None,
//         }
//     }
//
//     pub fn is_list(&self) -> bool {
//         if let Node::List(_) = self {
//             true
//         } else {
//             false
//         }
//     }
//
//     pub fn as_list(&self) -> Option<&Vec<Node>> {
//         match self {
//             Node::List(value) => Some(value),
//             _ => None,
//         }
//     }
//
//     pub fn is_object(&self) -> bool {
//         if let Node::Object(_) = self {
//             true
//         } else {
//             false
//         }
//     }
//
//     pub fn as_object(&self) -> Option<&HashMap<String, Node>> {
//         match self {
//             Node::Object(value) => Some(value),
//             _ => None,
//         }
//     }
//
//     pub fn put(&mut self, key: &str, value: Node) -> Option<Node> {
//         if let Node::Object(map) = self {
//             map.insert(key.to_owned(), value)
//         } else {
//             None
//         }
//     }
//
//     pub fn get(&self, key: &str) -> &Node {
//         if let Node::Object(map) = self {
//             if let Some(result) = map.get(key) {
//                 return result;
//             }
//         }
//
//         &Node::Empty
//     }
//
//     pub fn len(&self) -> usize {
//         match self {
//             Node::List(list) => list.len(),
//             Node::Object(map) => map.len(),
//             _ => 0,
//         }
//     }
//
//     pub fn at(&self, index: usize) -> &Node {
//         if let Node::List(list) = self {
//             if let Some(result) = list.get(index) {
//                 return result;
//             }
//         }
//
//         &Node::Empty
//     }
//
//     pub fn query(&self, path: &str) -> &Node {
//         let mut result = self;
//         for part in path.split(".").filter(|part| part.len() > 0) {
//             if let Node::Object(map) = &result {
//                 result = map.get(part).unwrap_or(&Node::Empty);
//             } else {
//                 return &Node::Empty;
//             }
//         }
//
//         result
//     }
//
//     pub fn query_first_filled(&self, first_path: &str, second_path: &str) -> &Node {
//         let result = self.query(first_path);
//         if result.is_filled() {
//             result
//         } else {
//             self.query(second_path)
//         }
//     }
//
//     pub fn or<'a>(&'a self, other: &'a Node) -> &'a Node {
//         if self.is_empty() {
//             other
//         } else {
//             self
//         }
//     }
//
//     pub fn or_get<'a>(&'a self, other: impl Fn() -> &'a Node) -> &'a Node {
//         if self.is_empty() {
//             other()
//         } else {
//             self
//         }
//     }
//
//     pub fn allocated_size(&self) -> usize {
//         match self {
//             Node::BoxedString(str) => 0, //std::mem::size_of::<Box<[u8]>>() + str.data.len(),
//             Node::InlineString(_) => 0,
//             Node::List(list) => {
//                 let vector_size = list.capacity() * std::mem::size_of::<Node>();
//                 let content_size: usize = list.iter().map(|node| node.allocated_size()).sum();
//
//                 vector_size + content_size
//             }
//             Node::Object(map) => {
//                 let entry_size = std::mem::size_of::<String>()
//                     + std::mem::size_of::<*const Node>()
//                     + std::mem::size_of::<*const Node>()
//                     + std::mem::size_of::<*const Node>()
//                     + std::mem::size_of::<*const String>()
//                     + std::mem::size_of::<Node>()
//                     + std::mem::size_of::<u64>();
//                 let map_size = (map.capacity() * 11 / 10).next_power_of_two() * entry_size;
//                 let content_size: usize = map
//                     .iter()
//                     .map(|node| node.0.len() + node.1.allocated_size())
//                     .sum();
//
//                 map_size + content_size
//             }
//             _ => 0,
//         }
//     }
// }