pub mod boundary;
pub mod domain;
pub mod error;
pub mod float;
pub mod hex;
pub mod packed;
pub mod reader;
pub mod repr;
pub mod signed_integer;
pub mod source;
// pub mod text;
pub mod types;
pub mod writer;

pub use domain::*;
pub use packed::PackedReader;
pub use packed::PackedWriter;
pub use packed::annotated_from_bytes;
pub use packed::annotated_iovalue_from_bytes;
pub use packed::from_bytes;
pub use packed::iovalue_from_bytes;
pub use reader::Reader;
pub use repr::Annotations;
pub use repr::Atom;
pub use repr::Bytes;
pub use repr::Embedded;
pub use repr::IOValue;
pub use repr::Map;
pub use repr::NoValue;
pub use repr::Record;
pub use repr::Set;
pub use repr::Symbol;
pub use repr::Value;
pub use repr::owned;
pub use repr::value;
pub use signed_integer::SignedInteger;
pub use source::BinarySource;
pub use source::BytesBinarySource;
pub use source::IOBinarySource;
// pub use text::TextReader;
// pub use text::TextWriter;
// pub use text::annotated_from_str;
// pub use text::annotated_iovalue_from_str;
// pub use text::from_str;
// pub use text::iovalue_from_str;
pub use types::AtomClass;
pub use types::CompoundClass;
pub use types::ValueClass;
pub use writer::Writer;

#[cfg(test)]
mod demo {
    use crate::*;

    fn getit<'a>(d: &'a dyn Value<NoValue>, k: &str) -> Option<&'a dyn Value<NoValue>> {
        d.get(&k)
    }

    #[test] fn a() {
        let l = Symbol::new("label");
        let r = Record::new(owned::<NoValue, _>(l.clone()), vec![owned(1), owned(2), owned(3)]);
        let r2 = Record::new(owned::<NoValue, _>(l), vec![owned(1), owned(2), owned(4)]);

        let mut v: Map<Box<dyn Value<NoValue>>, String> = Map::new();
        v.insert(Box::new("abc"), "def".to_owned());
        v.insert(Box::new(123), "xyz".to_owned());
        v.insert(Box::new(vec![1, 2, 3]), "www".to_owned());
        v.insert(Box::new(r2), "bbb".to_owned());
        v.insert(Box::new(r), "aaa".to_owned());
        let w: &dyn Value<NoValue> = &v;
        println!("GETw abc {:?}", w.get(&"abc"));
        println!("GETw 123 {:?}", w.get(&123));
        println!("GETw qqq {:?}", w.get(&"qqq"));
        println!("GETv abc {:?}", v.get(value(&"abc")));
        println!("GETv 123 {:?}", v.get(value(&123)));
        println!("GETv qqq {:?}", v.get(value(&"qqq")));
        for (kk, vv) in w.entries() {
            println!("{:?} {:?} ==> {:?} {:?}", kk.value_class(), kk, vv.value_class(), vv);
        }

        // {
        //     use std::io::BufRead;
        //     for line in std::io::stdin().lock().lines() {
        //         let line = line.unwrap();
        //         let val = w.get(&line);
        //         println!("{:?} ==> {:?} == {:?}", line, val, getit(&v, &line));
        //     }
        // }
    }
}