zlo 0.1.0

use serde;
use serde::Serialize;

use super::Error;
use super::Result;
use super::SizeLimit;

use std::io::Write;
use std::mem::size_of_val;

/// An Serializer that encodes values directly into a Writer.
///
/// This struct should not be used often.
/// For most cases, prefer the `encode_into` function.
///
/// *NOTE: After `Serializer` has done its job, `finish()` **MUST** be called
/// manually.  Serializer does **NOT** do anything on its own on drop!*
#[must_use]
pub struct Serializer<W> {
    writer: W,
    store: u8,
    shift: u8,
}

impl<W: Write> Serializer<W> {
    /// Creates a new Serializer with the given `Write`r.
    ///
    /// *NOTE: After `Serializer` has done its job, `finish()` **MUST** be
    /// called manually.  Serializer does **NOT** do anything on its own on
    /// drop!*
    pub fn new(w: W) -> Self {
        Self {
            writer: w,
            store: 0,
            shift: 0,
        }
    }

    // #[must_use]
    /// Must be called when Serializer has done its job.
    pub fn finish(mut self) -> ::std::result::Result<(), (Self, Error)> {
        if self.shift > 0 {
            match self.writer.write_all(&[self.store]) {
                Ok(()) => Ok(()),
                Err(e) => Err((self, e.into())),
            }
        } else {
            Ok(())
        }
    }

    #[inline(always)]
    fn write_bit(&mut self, v: bool) -> Result<()> {
        let s = self.store | ((v as u8) << self.shift);
        if self.shift >= 7 {
            // WARN: Only modify self if write succeeds!
            self.writer.write_all(&[s]).map_err(Error::from)?;
            self.store = 0;
            self.shift = 0;
        } else {
            self.store = s;
            self.shift += 1;
        }
        Ok(())
    }

    #[inline(always)]
    fn write_byte(&mut self, v: u8) -> Result<()> {
        // NOTE: This method must be equivalent to calling write_bit 8 times.
        // WARN: Only modify self if write succeeds!
        let m = (1_u8 << self.shift).wrapping_sub(1);
        let w = (v << self.shift) | (self.store & m);
        match self.writer.write_all(&[w]) {
            Ok(()) => Ok(self.store = if self.shift > 0 {
                v >> (8 - self.shift)
            } else {
                0
            }),
            Err(e) => Err(e.into()),
        }
    }
}

macro_rules! ser_uint {
    ($func:ident, $ty:ty) => {
        fn $func(self, v: $ty) -> Result<()> {
            if v > 0 {
                self.write_bit(true)?;
                let h = size_of_val(&v);
                for x in 0 .. h {
                    self.write_byte((v >> x * 8) as u8)?;

                    // If there are more to be written, signal so, unless it is
                    // a final byte where we will halt regardless.
                    if x != h - 1 {
                        let w = v >> (x + 1) * 8 > 0;
                        self.write_bit(w)?;
                        if !w { break }
                    }
                }
                Ok(())
            } else {
                self.write_bit(false)
            }
        }
    }
}

impl<'a, W: Write> serde::Serializer for &'a mut Serializer<W> {
    type Ok = ();
    type Error = Error;
    type SerializeSeq = Compound<'a, W>;
    type SerializeTuple = Compound<'a, W>;
    type SerializeTupleStruct = Compound<'a, W>;
    type SerializeTupleVariant = Compound<'a, W>;
    type SerializeMap = Compound<'a, W>;
    type SerializeStruct = Compound<'a, W>;
    type SerializeStructVariant = Compound<'a, W>;

    fn serialize_unit(self) -> Result<()> {
        Ok(())
    }

    fn serialize_unit_struct(self, _: &'static str) -> Result<()> {
        Ok(())
    }

    fn serialize_bool(self, v: bool) -> Result<()> {
        self.write_bit(v)
    }

    ser_uint!(serialize_u8, u8);
    ser_uint!(serialize_u16, u16);
    ser_uint!(serialize_u32, u32);
    ser_uint!(serialize_u64, u64);

    fn serialize_i8(self, v: i8) -> Result<()> {
        // No point in zigzag-coding anyway.
        self.serialize_u8(v as u8)
    }

    fn serialize_i16(self, v: i16) -> Result<()> {
        self.serialize_u16(encode_zigzag_16(v))
    }

    fn serialize_i32(self, v: i32) -> Result<()> {
        self.serialize_u32(encode_zigzag_32(v))
    }

    fn serialize_i64(self, v: i64) -> Result<()> {
        self.serialize_u64(encode_zigzag_64(v))
    }

    fn serialize_f32(self, v: f32) -> Result<()> {
        let bits = v.to_bits();
        let sign = (bits >> 31) != 0;
        let exp  = (bits >> 23) as u8;
        let frac = bits & ((1 << 23) - 1);
        self.write_bit(sign)?;
        // If exp fits in just 2 bits, which, if it was zigzag-encoded, is
        // fairly common for gradually changing data such as, say, object
        // positions in a game, write just 2 bits, otherwise write full.
        self.write_bit(exp > 3)?;
        if exp > 3 {
            self.write_byte(exp)?;
        } else {
            self.write_bit((exp & 1) != 0)?;
            self.write_bit((exp & 2) != 0)?;
        }
        // Writing shorter fractions is not as effective as exponents,
        // unfortunately, especially in doubles.
        self.write_bit(frac != 0)?;
        if frac != 0 {
            self.write_byte((frac >> 16) as u8)?;
            self.write_byte((frac >> 8) as u8)?;
            self.write_bit((frac & 0xff) != 0)?;
            if (frac & 0xff) != 0 {
                self.write_byte(frac as u8)?;
            }
        }
        Ok(())
    }

    fn serialize_f64(self, v: f64) -> Result<()> {
        let bits = v.to_bits();
        let sign = (bits >> 63) != 0;
        let exp  = (bits >> 52) as u16 & ((1 << 11) - 1);
        let frac = bits & ((1 << 52) - 1);
        self.write_bit(sign)?;
        self.write_bit(exp > 3)?;
        if exp > 3 {
            self.write_bit((exp & (1 << 8)) != 0)?;
            self.write_bit((exp & (1 << 9)) != 0)?;
            self.write_bit((exp & (1 << 10)) != 0)?;
            self.write_byte(exp as u8)?;
        } else {
            self.write_bit((exp & 1) != 0)?;
            self.write_bit((exp & 2) != 0)?;
        };
        self.write_bit(frac != 0)?;
        if frac != 0 {
            self.write_byte((frac >> 48) as u8)?;
            self.write_byte((frac >> 40) as u8)?;
            self.write_byte((frac >> 32) as u8)?;
            self.write_byte((frac >> 24) as u8)?;
            self.write_bit((frac & 0xffffff) != 0)?;
            if (frac & 0xffffff) != 0 {
                self.write_byte((frac >> 16) as u8)?;
                self.write_byte((frac >> 8) as u8)?;
                self.write_byte((frac >> 0) as u8)?;
            }
        }
        Ok(())
    }

    fn serialize_str(self, v: &str) -> Result<()> {
        self.serialize_u64(v.len() as u64)?;
        for &b in v.as_bytes() {
            self.write_byte(b)?;
        }
        Ok(())
    }

    fn serialize_char(self, c: char) -> Result<()> {
        for &b in encode_utf8(c).as_slice() {
            self.write_byte(b)?;
        }
        Ok(())
    }

    fn serialize_bytes(self, v: &[u8]) -> Result<()> {
        self.serialize_u64(v.len() as u64)?;
        for &b in v {
            self.write_byte(b)?;
        }
        Ok(())
    }

    fn serialize_none(self) -> Result<()> {
        self.write_bit(false)
    }

    fn serialize_some<T: ?Sized>(self, v: &T) -> Result<()>
    where
        T: serde::Serialize,
    {
        self.write_bit(true)?;
        v.serialize(self)
    }

    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
        let len = len.ok_or(Error::SequenceMustHaveLength)?;
        self.serialize_u64(len as u64)?;
        Ok(Compound { ser: self })
    }

    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
        Ok(Compound { ser: self })
    }

    fn serialize_tuple_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleStruct> {
        Ok(Compound { ser: self })
    }

    fn serialize_tuple_variant(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant> {
        self.serialize_u32(variant_index)?;
        Ok(Compound { ser: self })
    }

    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
        let len = len.ok_or(Error::SequenceMustHaveLength)?;
        self.serialize_u64(len as u64)?;
        Ok(Compound { ser: self })
    }

    fn serialize_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStruct> {
        Ok(Compound { ser: self })
    }

    fn serialize_struct_variant(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant> {
        self.serialize_u32(variant_index)?;
        Ok(Compound { ser: self })
    }

    fn serialize_newtype_struct<T: ?Sized>(
        self,
        _name: &'static str,
        value: &T,
    ) -> Result<()>
    where
        T: serde::Serialize,
    {
        value.serialize(self)
    }

    fn serialize_newtype_variant<T: ?Sized>(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
        value: &T,
    ) -> Result<()>
    where
        T: serde::Serialize,
    {
        self.serialize_u32(variant_index)?;
        value.serialize(self)
    }

    fn serialize_unit_variant(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
    ) -> Result<()> {
        self.serialize_u32(variant_index)
    }
}

pub struct SizeChecker<S: SizeLimit> {
    pub size_limit: S,
}

impl<S: SizeLimit> SizeChecker<S> {
    pub fn new(size_limit: S) -> SizeChecker<S> {
        SizeChecker { size_limit: size_limit }
    }

    fn add(&mut self, size: u64) -> Result<()> {
        self.size_limit.add(size)
    }

    // fn add_value<T>(&mut self, t: T) -> Result<()> {
    //     use std::mem::size_of_val;
    //     self.add_raw(size_of_val(&t) as u64)
    // }
}

impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker<S> {
    type Ok = ();
    type Error = Error;
    type SerializeSeq = SizeCompound<'a, S>;
    type SerializeTuple = SizeCompound<'a, S>;
    type SerializeTupleStruct = SizeCompound<'a, S>;
    type SerializeTupleVariant = SizeCompound<'a, S>;
    type SerializeMap = SizeCompound<'a, S>;
    type SerializeStruct = SizeCompound<'a, S>;
    type SerializeStructVariant = SizeCompound<'a, S>;

    fn serialize_unit(self) -> Result<()> {
        Ok(())
    }

    fn serialize_unit_struct(self, _: &'static str) -> Result<()> {
        Ok(())
    }

    fn serialize_bool(self, _: bool) -> Result<()> {
        self.add(1)
    }

    fn serialize_u8(self, v: u8) -> Result<()> {
        self.add(1 + (v > 0) as u64 * 8)
    }

    fn serialize_u16(self, v: u16) -> Result<()> {
        let z = v.leading_zeros() / 8 * 9;
        self.add(1 + (18 - z) as u64 - (z == 0) as u64)
    }

    fn serialize_u32(self, v: u32) -> Result<()> {
        let z = v.leading_zeros() / 8 * 9;
        self.add(1 + (36 - z) as u64 - (z == 0) as u64)
    }

    fn serialize_u64(self, v: u64) -> Result<()> {
        let z = v.leading_zeros() / 8 * 9;
        self.add(1 + (72 - z) as u64 - (z == 0) as u64)
    }

    fn serialize_i8(self, v: i8) -> Result<()> {
        self.add(1 + (v > 0) as u64 * 8)
    }

    fn serialize_i16(self, v: i16) -> Result<()> {
        encode_zigzag_16(v).serialize(self)
    }

    fn serialize_i32(self, v: i32) -> Result<()> {
        encode_zigzag_32(v).serialize(self)
    }

    fn serialize_i64(self, v: i64) -> Result<()> {
        encode_zigzag_64(v).serialize(self)
    }

    fn serialize_f32(self, v: f32) -> Result<()> {
        let bits = v.to_bits();
        let exp  = (bits >> 23) as u8;
        let frac = bits & ((1 << 23) - 1);
        self.add(3
                 + if exp > 3 { 8 } else { 2 }
                 + if frac != 0 { 1 + 16 + if (frac & 0xff) != 0 { 8 } else { 0 } } else { 0 })
    }

    fn serialize_f64(self, v: f64) -> Result<()> {
        let bits = v.to_bits();
        let exp  = (bits >> 52) as u16 & ((1 << 11) - 1);
        let frac = bits & ((1 << 52) - 1);
        self.add(3
                 + if exp > 3 { 11 } else { 2 }
                 + if frac != 0 { 1 + 32 + if (frac & 0xff) != 0 { 24 } else { 0 } } else { 0 })
    }

    fn serialize_str(self, v: &str) -> Result<()> {
        self.serialize_u64(v.len() as u64)?;
        self.add(v.len() as u64 * 8)
    }

    fn serialize_char(self, c: char) -> Result<()> {
        self.add(encode_utf8(c).as_slice().len() as u64 * 8)
    }

    fn serialize_bytes(self, v: &[u8]) -> Result<()> {
        self.serialize_u64(v.len() as u64)?;
        self.add(v.len() as u64 * 8)
    }

    fn serialize_none(self) -> Result<()> {
        self.serialize_bool(false)
    }

    fn serialize_some<T: ?Sized>(self, v: &T) -> Result<()>
    where
        T: serde::Serialize,
    {
        self.serialize_bool(true)?;
        v.serialize(self)
    }

    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
        let len = len.ok_or(Error::SequenceMustHaveLength)?;
        self.serialize_u64(len as u64)?;
        Ok(SizeCompound { ser: self })
    }

    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
        Ok(SizeCompound { ser: self })
    }

    fn serialize_tuple_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleStruct> {
        Ok(SizeCompound { ser: self })
    }

    fn serialize_tuple_variant(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant> {
        self.serialize_u32(variant_index)?;
        Ok(SizeCompound { ser: self })
    }

    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
        let len = len.ok_or(Error::SequenceMustHaveLength)?;
        self.serialize_u64(len as u64)?;
        Ok(SizeCompound { ser: self })
    }

    fn serialize_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStruct> {
        Ok(SizeCompound { ser: self })
    }

    fn serialize_struct_variant(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant> {
        self.serialize_u32(variant_index)?;
        Ok(SizeCompound { ser: self })
    }

    fn serialize_newtype_struct<V: serde::Serialize + ?Sized>(
        self,
        _name: &'static str,
        v: &V,
    ) -> Result<()> {
        v.serialize(self)
    }

    fn serialize_unit_variant(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
    ) -> Result<()> {
        variant_index.serialize(self)
    }

    fn serialize_newtype_variant<V: serde::Serialize + ?Sized>(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
        value: &V,
    ) -> Result<()> {
        self.serialize_u32(variant_index)?;
        value.serialize(self)
    }
}

#[doc(hidden)]
pub struct Compound<'a, W: 'a> {
    ser: &'a mut Serializer<W>,
}

impl<'a, W> serde::ser::SerializeSeq for Compound<'a, W>
where
    W: Write,
{
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, W> serde::ser::SerializeTuple for Compound<'a, W>
where
    W: Write,
{
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, W> serde::ser::SerializeTupleStruct for Compound<'a, W>
where
    W: Write,
{
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, W> serde::ser::SerializeTupleVariant for Compound<'a, W>
where
    W: Write,
{
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, W> serde::ser::SerializeMap for Compound<'a, W>
where
    W: Write,
{
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_key<K: ?Sized>(&mut self, value: &K) -> Result<()>
    where
        K: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<()>
    where
        V: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, W> serde::ser::SerializeStruct for Compound<'a, W>
where
    W: Write,
{
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(
        &mut self,
        _key: &'static str,
        value: &T,
    ) -> Result<()>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, W> serde::ser::SerializeStructVariant for Compound<'a, W>
where
    W: Write,
{
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(
        &mut self,
        _key: &'static str,
        value: &T,
    ) -> Result<()>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

#[doc(hidden)]
pub struct SizeCompound<'a, S: SizeLimit + 'a> {
    ser: &'a mut SizeChecker<S>,
}

impl<'a, S: SizeLimit> serde::ser::SerializeSeq for SizeCompound<'a, S> {
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, S: SizeLimit> serde::ser::SerializeTuple for SizeCompound<'a, S> {
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, S: SizeLimit> serde::ser::SerializeTupleStruct
    for SizeCompound<'a, S> {
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, S: SizeLimit> serde::ser::SerializeTupleVariant
    for SizeCompound<'a, S> {
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, S: SizeLimit + 'a> serde::ser::SerializeMap for SizeCompound<'a, S> {
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_key<K: ?Sized>(&mut self, value: &K) -> Result<()>
    where
        K: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<()>
    where
        V: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, S: SizeLimit> serde::ser::SerializeStruct for SizeCompound<'a, S> {
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(
        &mut self,
        _key: &'static str,
        value: &T,
    ) -> Result<()>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, S: SizeLimit> serde::ser::SerializeStructVariant
    for SizeCompound<'a, S> {
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(
        &mut self,
        _key: &'static str,
        value: &T,
    ) -> Result<()>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}


macro_rules! def_enc_zigzag {
    ($func:ident, $in:ty, $out:ty) => {
        fn $func(v: $in) -> $out {
            if v < 0 {
                (v.wrapping_neg() as $out)
                    .wrapping_mul(2)
                    .wrapping_sub(1)
            } else {
                (v as $out).wrapping_mul(2)
            }
        }
    }
}

def_enc_zigzag!(encode_zigzag_16, i16, u16);
def_enc_zigzag!(encode_zigzag_32, i32, u32);
def_enc_zigzag!(encode_zigzag_64, i64, u64);

const TAG_CONT: u8 = 0b1000_0000;
const TAG_TWO_B: u8 = 0b1100_0000;
const TAG_THREE_B: u8 = 0b1110_0000;
const TAG_FOUR_B: u8 = 0b1111_0000;
const MAX_ONE_B: u32 = 0x80;
const MAX_TWO_B: u32 = 0x800;
const MAX_THREE_B: u32 = 0x10000;

fn encode_utf8(c: char) -> EncodeUtf8 {
    let code = c as u32;
    let mut buf = [0; 4];
    let pos = if code < MAX_ONE_B {
        buf[3] = code as u8;
        3
    } else if code < MAX_TWO_B {
        buf[2] = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
        2
    } else if code < MAX_THREE_B {
        buf[1] = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
        buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT;
        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
        1
    } else {
        buf[0] = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
        buf[1] = (code >> 12 & 0x3F) as u8 | TAG_CONT;
        buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT;
        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
        0
    };
    EncodeUtf8 { buf: buf, pos: pos }
}

struct EncodeUtf8 {
    buf: [u8; 4],
    pos: usize,
}

impl EncodeUtf8 {
    fn as_slice(&self) -> &[u8] {
        &self.buf[self.pos..]
    }
}