keytree 0.2.4

//! Internal `into()` implementations.

use crate::{Context, KeyTree};
use crate::error::KeyTreeErr;
use std::net::IpAddr;
use std::net::SocketAddr;
use std::path::PathBuf;

// bool

impl<'a> Into<bool> for KeyTree<'a> {
    fn into(mut self) -> bool {
        match self.value() {
            Some(n) => match n.parse::<bool>() {
                Ok(s)   => s,
                Err(_)  => { KeyTreeErr::parse_value(); unreachable!() },
            },
            None => { KeyTreeErr::no_value(); unreachable!() },
        }
    }
}

// f32

impl<'a> Into<f32> for KeyTree<'a> {
    fn into(mut self) -> f32 {
        match self.value() {
            Some(n) => match n.parse::<f32>() {
                Ok(s)   => s,
                Err(_)  => { KeyTreeErr::parse_value(); unreachable!() },
            },
            None => { KeyTreeErr::no_value(); unreachable!() },
        }
    }
}

// u32

impl<'a> Into<u32> for KeyTree<'a> {
    fn into(mut self) -> u32 {
        match self.value() {
            Some(n) => match n.parse::<u32>() {
                Ok(s)   => s,
                Err(_)  => { KeyTreeErr::parse_value(); unreachable!() },
            },
            None => { KeyTreeErr::no_value(); unreachable!() },
        }
    }
}

// usize

impl<'a> Into<usize> for KeyTree<'a> {
    fn into(mut self) -> usize {
        match self.value() {
            Some(n) => match n.parse::<usize>() {
                Ok(s)   => s,
                Err(_)  => { KeyTreeErr::parse_value(); unreachable!() },
            },
            None => { KeyTreeErr::no_value(); unreachable!() },
        }
    }
}

// i64

impl<'a> Into<i64> for KeyTree<'a> {
    fn into(mut self) -> i64 {
        match self.value() {
            Some(n) => match n.parse::<i64>() {
                Ok(s)   => s,
                Err(_)  => { KeyTreeErr::parse_value(); unreachable!() },
            },
            None => { KeyTreeErr::no_value(); unreachable!() },
        }
    }
}

// i8

impl<'a> Into<i8> for KeyTree<'a> {
    fn into(mut self) -> i8 {
        match self.value() {
            Some(n) => match n.parse::<i8>() {
                Ok(s)   => s,
                Err(_)  => { KeyTreeErr::parse_value(); unreachable!() },
            },
            None => { KeyTreeErr::no_value(); unreachable!() },
        }
    }
}

// u16

impl<'a> Into<u16> for KeyTree<'a> {
    fn into(mut self) -> u16 {
        match self.value() {
            Some(n) => match n.parse::<u16>() {
                Ok(s)   => s,
                Err(_)  => { KeyTreeErr::parse_value(); unreachable!() },
            },
            None => { KeyTreeErr::no_value(); unreachable!() },
        }
    }
}

// i16

impl<'a> Into<i16> for KeyTree<'a> {
    fn into(mut self) -> i16 {
        match self.value() {
            Some(n) => match n.parse::<i16>() {
                Ok(s)   => s,
                Err(_)  => { KeyTreeErr::parse_value(); unreachable!() },
            },
            None => { KeyTreeErr::no_value(); unreachable!() },
        }
    }
}

// u64

impl<'a> Into<u64> for KeyTree<'a> {
    fn into(mut self) -> u64 {
        match self.value() {
            Some(n) => match n.parse::<u64>() {
                Ok(s)   => s,
                Err(_)  => { KeyTreeErr::parse_value(); unreachable!() },
            },
            None => { KeyTreeErr::no_value(); unreachable!() },
        }
    }
}

// isize

impl<'a> Into<isize> for KeyTree<'a> {
    fn into(mut self) -> isize {
        match self.value() {
            Some(n) => match n.parse::<isize>() {
                Ok(s)   => s,
                Err(_)  => { KeyTreeErr::parse_value(); unreachable!() },
            },
            None => { KeyTreeErr::no_value(); unreachable!() },
        }
    }
}

// IpAddr

impl<'a> Into<IpAddr> for KeyTree<'a> {
    fn into(mut self) -> IpAddr {
        match self.value() {
            Some(n) => match n.parse::<IpAddr>() {
                Ok(s)   => s,
                Err(_)  => { KeyTreeErr::parse_value(); unreachable!() },
            },
            None => { KeyTreeErr::no_value(); unreachable!() },
        }
    }
}

// SocketAddr

impl<'a> Into<SocketAddr> for KeyTree<'a> {
    fn into(mut self) -> SocketAddr {
        match self.value() {
            Some(n) => match n.parse::<SocketAddr>() {
                Ok(s)   => s,
                Err(_)  => { KeyTreeErr::parse_value(); unreachable!() },
            },
            None => { KeyTreeErr::no_value(); unreachable!() },
        }
    }
}

// PathBuf

impl<'a> Into<PathBuf> for KeyTree<'a> {
    fn into(mut self) -> PathBuf {
        match self.value() {
            Some(n) => match n.parse::<PathBuf>() {
                Ok(s)   => s,
                Err(_)  => { KeyTreeErr::parse_value(); unreachable!() },
            },
            None => { KeyTreeErr::no_value(); unreachable!() },
        }
    }
}

// String

impl<'a> Into<String> for KeyTree<'a> {
    fn into(mut self) -> String {
        self
            .value()
            .map(|val| val.to_string())
            .unwrap_or_else(|| { KeyTreeErr::no_value(); unreachable!() })
    }
}

// Vec

impl<'a, T> Into<Vec<T>> for KeyTree<'a> 
where
    KeyTree<'a>: Into<T>
{
    fn into(self) -> Vec<T> {
        match self.context {
            Context::Iter(_) | Context::Unique(_) => { 
                self
                    .map(|kt| {
                        kt.into()
                    })   
                    .collect()
            },
            Context::EmptyIter(_) => {
                Vec::new()
            }
        }
    }
}