preserves/implementations/rust/preserves/src/value/packed/constants.rs

use std::convert::{TryFrom, From};
use std::io;

#[derive(Debug, PartialEq, Eq)]
pub enum Tag {
    False,
    True,
    Float,
    SignedInteger,
    String,
    ByteString,
    Symbol,
    Record,
    Sequence,
    Set,
    Dictionary,
    Embedded,
    Annotation,
}

#[derive(Debug, PartialEq, Eq)]
pub struct InvalidTag(u8);

impl From<InvalidTag> for io::Error {
    fn from(v: InvalidTag) -> Self {
        io::Error::new(io::ErrorKind::InvalidData, format!("Invalid Preserves tag {}", v.0))
    }
}

impl From<InvalidTag> for crate::error::Error {
    fn from(v: InvalidTag) -> Self {
        crate::error::Error::Io(v.into())
    }
}

impl TryFrom<u8> for Tag {
    type Error = InvalidTag;
    fn try_from(v: u8) -> Result<Self, Self::Error> {
        match v {
            0xa0 => Ok(Self::False),
            0xa1 => Ok(Self::True),
            0xa2 => Ok(Self::Float),
            0xa3 => Ok(Self::SignedInteger),
            0xa4 => Ok(Self::String),
            0xa5 => Ok(Self::ByteString),
            0xa6 => Ok(Self::Symbol),
            0xa7 => Ok(Self::Record),
            0xa8 => Ok(Self::Sequence),
            0xa9 => Ok(Self::Set),
            0xaa => Ok(Self::Dictionary),
            0xab => Ok(Self::Embedded),
            0xbf => Ok(Self::Annotation),
            _ => Err(InvalidTag(v))
        }
    }
}

impl From<Tag> for u8 {
    fn from(v: Tag) -> Self {
        match v {
            Tag::False => 0xa0,
            Tag::True => 0xa1,
            Tag::Float => 0xa2,
            Tag::SignedInteger => 0xa3,
            Tag::String => 0xa4,
            Tag::ByteString => 0xa5,
            Tag::Symbol => 0xa6,
            Tag::Record => 0xa7,
            Tag::Sequence => 0xa8,
            Tag::Set => 0xa9,
            Tag::Dictionary => 0xaa,
            Tag::Embedded => 0xab,
            Tag::Annotation => 0xbf,
        }
    }
}