// This is free and unencumbered software released into the public domain.

// Anyone is free to copy, modify, publish, use, compile, sell, or
// distribute this software, either in source code form or as a compiled
// binary, for any purpose, commercial or non-commercial, and by any
// means.

// In jurisdictions that recognize copyright laws, the author or authors
// of this software dedicate any and all copyright interest in the
// software to the public domain. We make this dedication for the benefit
// of the public at large and to the detriment of our heirs and
// successors. We intend this dedication to be an overt act of
// relinquishment in perpetuity of all present and future rights to this
// software under copyright law.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.

// For more information, please refer to <https://unlicense.org>

#![no_std]

#[macro_export]
macro_rules! match_downcast {
    ( $any:expr, { $( $bind:ident : $ty:ty => $arm:expr ),*, _ => $default:expr } ) => (
        $(
            if $any.is::<$ty>() {
                let $bind = $any.downcast::<$ty>().unwrap();
                $arm
            } else
        )*
        {
            $default
        }
    )
}

#[macro_export]
macro_rules! match_downcast_ref {
    ( $any:expr, { $( $bind:ident : $ty:ty => $arm:expr ),*, _ => $default:expr } ) => (
        $(
            if $any.is::<$ty>() {
                let $bind = $any.downcast_ref::<$ty>().unwrap();
                $arm
            } else
        )*
        {
            $default
        }
    )
}

#[macro_export]
macro_rules! match_downcast_mut {
    ( $any:expr, { $( $bind:ident : $ty:ty => $arm:expr ),*, _ => $default:expr } ) => (
        $(
            if $any.is::<$ty>() {
                let $bind = $any.downcast_mut::<$ty>().unwrap();
                $arm
            } else
        )*
        {
            $default
        }
    )
}

#[cfg(test)]
#[macro_use]
extern crate std;

#[cfg(test)]
mod tests {
    use std::boxed::Box;
    use std::any::Any;

    #[test]
    fn downcast() {
        let boxes = vec![
            Box::new(0_i8) as Box<Any>,
            Box::new(1_u8) as Box<Any>,
            Box::new(2_i16) as Box<Any>,
            Box::new(3_u16) as Box<Any>,
            Box::new(4_i32) as Box<Any>,
            Box::new(5_u32) as Box<Any>,
            Box::new(6_i64) as Box<Any>,
            Box::new(7_u64) as Box<Any>,
            Box::new(8_f32) as Box<Any>,
            Box::new(9_f64) as Box<Any>,
        ];

        boxes
            .into_iter()
            .map(|x| match_downcast!(x, {
                y: i8  => *y as i32,
                y: u8  => *y as i32,
                y: i16 => *y as i32,
                y: u16 => *y as i32,
                y: i32 => *y as i32,
                y: u32 => *y as i32,
                y: i64 => *y as i32,
                y: u64 => *y as i32,
                y: f32 => *y as i32,
                y: f64 => *y as i32,
                _ => panic!()
            }))
            .zip(0 ..)
            .fold((), |_, (x, y)| assert_eq!(x, y));
    }

    #[test]
    fn downcast_ref() {
        let boxes = vec![
            Box::new(0_i8) as Box<Any>,
            Box::new(1_u8) as Box<Any>,
            Box::new(2_i16) as Box<Any>,
            Box::new(3_u16) as Box<Any>,
            Box::new(4_i32) as Box<Any>,
            Box::new(5_u32) as Box<Any>,
            Box::new(6_i64) as Box<Any>,
            Box::new(7_u64) as Box<Any>,
            Box::new(8_f32) as Box<Any>,
            Box::new(9_f64) as Box<Any>,
        ];

        boxes
            .iter()
            .map(|x| match_downcast_ref!(x, {
                y: i8  => *y as i32,
                y: u8  => *y as i32,
                y: i16 => *y as i32,
                y: u16 => *y as i32,
                y: i32 => *y as i32,
                y: u32 => *y as i32,
                y: i64 => *y as i32,
                y: u64 => *y as i32,
                y: f32 => *y as i32,
                y: f64 => *y as i32,
                _ => panic!()
            }))
            .zip(0 ..)
            .fold((), |_, (x, y)| assert_eq!(x, y));
    }

    #[test]
    fn downcast_mut() {
        let mut boxes = vec![
            Box::new(0_i8) as Box<Any>,
            Box::new(1_u8) as Box<Any>,
            Box::new(2_i16) as Box<Any>,
            Box::new(3_u16) as Box<Any>,
            Box::new(4_i32) as Box<Any>,
            Box::new(5_u32) as Box<Any>,
            Box::new(6_i64) as Box<Any>,
            Box::new(7_u64) as Box<Any>,
            Box::new(8_f32) as Box<Any>,
            Box::new(9_f64) as Box<Any>,
        ];

        boxes
            .iter_mut()
            .fold((), |_, x| match_downcast_mut!(x, {
                y: i8  => *y = 42_i8,
                y: u8  => *y = 42_u8,
                y: i16 => *y = 42_i16,
                y: u16 => *y = 42_u16,
                y: i32 => *y = 42_i32,
                y: u32 => *y = 42_u32,
                y: i64 => *y = 42_i64,
                y: u64 => *y = 42_u64,
                y: f32 => *y = 42_f32,
                y: f64 => *y = 42_f64,
                _ => panic!()
            }));

        boxes
            .into_iter()
            .fold((), |_, x| assert_eq!(match_downcast_ref!(x, {
                y: i8  => *y as i32,
                y: u8  => *y as i32,
                y: i16 => *y as i32,
                y: u16 => *y as i32,
                y: i32 => *y as i32,
                y: u32 => *y as i32,
                y: i64 => *y as i32,
                y: u64 => *y as i32,
                y: f32 => *y as i32,
                y: f64 => *y as i32,
                _ => panic!()
            }), 42));
    }
}