0cb7a4062a
This commit moves the libserialize crate (and will force the hand of the rustc-serialize crate) to not require the `old_orphan_check` feature gate as well as using associated types wherever possible. Concretely, the following changes were made: * The error type of `Encoder` and `Decoder` is now an associated type, meaning that these traits have no type parameters. * The `Encoder` and `Decoder` type parameters on the `Encodable` and `Decodable` traits have moved to the corresponding method of the trait. This movement alleviates the dependency on `old_orphan_check` but implies that implementations can no longer be specialized for the type of encoder/decoder being implemented. Due to the trait definitions changing, this is a: [breaking-change]
118 lines
3.0 KiB
Rust
118 lines
3.0 KiB
Rust
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
use std::default::Default;
|
|
use std::fmt;
|
|
use std::iter::FromIterator;
|
|
use std::ops::Deref;
|
|
use std::vec;
|
|
use serialize::{Encodable, Decodable, Encoder, Decoder};
|
|
|
|
/// A non-growable owned slice. This is a separate type to allow the
|
|
/// representation to change.
|
|
#[derive(Hash, PartialEq, Eq, PartialOrd, Ord)]
|
|
pub struct OwnedSlice<T> {
|
|
data: Box<[T]>
|
|
}
|
|
|
|
impl<T:fmt::Show> fmt::Show for OwnedSlice<T> {
|
|
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
|
self.data.fmt(fmt)
|
|
}
|
|
}
|
|
|
|
impl<T> OwnedSlice<T> {
|
|
pub fn empty() -> OwnedSlice<T> {
|
|
OwnedSlice { data: box [] }
|
|
}
|
|
|
|
#[inline(never)]
|
|
pub fn from_vec(v: Vec<T>) -> OwnedSlice<T> {
|
|
OwnedSlice { data: v.into_boxed_slice() }
|
|
}
|
|
|
|
#[inline(never)]
|
|
pub fn into_vec(self) -> Vec<T> {
|
|
self.data.into_vec()
|
|
}
|
|
|
|
pub fn as_slice<'a>(&'a self) -> &'a [T] {
|
|
&*self.data
|
|
}
|
|
|
|
pub fn move_iter(self) -> vec::IntoIter<T> {
|
|
self.into_vec().into_iter()
|
|
}
|
|
|
|
pub fn map<U, F: FnMut(&T) -> U>(&self, f: F) -> OwnedSlice<U> {
|
|
self.iter().map(f).collect()
|
|
}
|
|
}
|
|
|
|
impl<T> Deref for OwnedSlice<T> {
|
|
type Target = [T];
|
|
|
|
fn deref(&self) -> &[T] {
|
|
self.as_slice()
|
|
}
|
|
}
|
|
|
|
impl<T> Default for OwnedSlice<T> {
|
|
fn default() -> OwnedSlice<T> {
|
|
OwnedSlice::empty()
|
|
}
|
|
}
|
|
|
|
impl<T: Clone> Clone for OwnedSlice<T> {
|
|
fn clone(&self) -> OwnedSlice<T> {
|
|
OwnedSlice::from_vec(self.as_slice().to_vec())
|
|
}
|
|
}
|
|
|
|
impl<T> FromIterator<T> for OwnedSlice<T> {
|
|
fn from_iter<I: Iterator<Item=T>>(iter: I) -> OwnedSlice<T> {
|
|
OwnedSlice::from_vec(iter.collect())
|
|
}
|
|
}
|
|
|
|
#[cfg(stage0)]
|
|
impl<S: Encoder<E>, T: Encodable<S, E>, E> Encodable<S, E> for OwnedSlice<T> {
|
|
fn encode(&self, s: &mut S) -> Result<(), E> {
|
|
self.as_slice().encode(s)
|
|
}
|
|
}
|
|
|
|
#[cfg(not(stage0))]
|
|
impl<T: Encodable> Encodable for OwnedSlice<T> {
|
|
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
|
|
self.as_slice().encode(s)
|
|
}
|
|
}
|
|
|
|
#[cfg(stage0)]
|
|
impl<D: Decoder<E>, T: Decodable<D, E>, E> Decodable<D, E> for OwnedSlice<T> {
|
|
fn decode(d: &mut D) -> Result<OwnedSlice<T>, E> {
|
|
Ok(OwnedSlice::from_vec(match Decodable::decode(d) {
|
|
Ok(t) => t,
|
|
Err(e) => return Err(e)
|
|
}))
|
|
}
|
|
}
|
|
|
|
#[cfg(not(stage0))]
|
|
impl<T: Decodable> Decodable for OwnedSlice<T> {
|
|
fn decode<D: Decoder>(d: &mut D) -> Result<OwnedSlice<T>, D::Error> {
|
|
Ok(OwnedSlice::from_vec(match Decodable::decode(d) {
|
|
Ok(t) => t,
|
|
Err(e) => return Err(e)
|
|
}))
|
|
}
|
|
}
|