mod color {
    #[allow(non_camel_case_types)]
    pub struct pdf_color(PdfColor);

    impl pdf_color {
        pub fn new() -> Self {
            Self(BLACK)
        }
        pub fn from(color: &PdfColor) -> Self {
            if let Ok(color) = color.clone().check() {
                pdf_color(color)
            } else {
                Self::new()
            }
        }
        pub fn set_from(&mut self, color: &PdfColor) {
            if let Ok(color) = color.clone().check() {
                *self = pdf_color(color);
            }
        }
        pub const unsafe fn from_unchecked(color: PdfColor) -> Self {
            Self(color)
        }
    }

    #[derive(Clone)]
    pub enum PdfColor {
        Gray(f64),
        Spot(String, f64),
        Rgb(f64,f64,f64),
        Cmyk(f64,f64,f64,f64),
    }

    macro_rules! warn(
        ($($arg:tt)*) => {
            println!($($arg)*);
        };
    );

    impl PdfColor {
        pub fn check(self) -> Result<Self, ()> {
            use PdfColor::*;
            match self {
                Gray(g) => {
                    if g < 0. || g > 1. {
                        warn!("Invalid color value specified: gray={}", g);
                        return Err(());
                    }
                },
                Spot(_, c) => {
                    if c < 0. || c > 1. {
                        warn!("Invalid color value specified: grade={}", c);
                        return Err(());
                    }
                },
                Rgb(r,g,b) => {
                    if r < 0. || r > 1. {
                        warn!("Invalid color value specified: red={}", r);
                        return Err(());
                    }
                    if g < 0. || g > 1. {
                        warn!("Invalid color value specified: green={}", g);
                        return Err(());
                    }
                    if b < 0. || b > 1. {
                        warn!("Invalid color value specified: blue={}", b);
                        return Err(());
                    }
                },
                Cmyk(c,m,y,k) => {
                    if c < 0. || c > 1. {
                        warn!("Invalid color value specified: cyan={}", c);
                        return Err(());
                    }
                    if m < 0. || m > 1. {
                        warn!("Invalid color value specified: magenta={}", m);
                        return Err(());
                    }
                    if y < 0. || y > 1. {
                        warn!("Invalid color value specified: yellow={}", y);
                        return Err(());
                    }
                    if k < 0. || k > 1. {
                        warn!("Invalid color value specified: black={}", k);
                        return Err(());
                    }
                }
            }
            Ok(self)
        }
        pub fn spot(name: &str, c: f64) -> Self {
            PdfColor::Spot(String::from(name), c)
        }
    }

        // Predefined colors
    const BLACK: PdfColor = PdfColor::Gray(0.);
}

fn main() {
    use color::{pdf_color, PdfColor};
    let mut _a = pdf_color::new();
    //a = pdf_color(PdfColor::Rgb(0.5, 12.1, 0.4)); //error::private field

    _a.set_from(&PdfColor::Rgb(0.5, 12.1, 0.4));
    unsafe {
        let _b = pdf_color::from_unchecked(PdfColor::Rgb(0.5, 12.1, 0.4));
    }
}