use std::fmt;
use std::iter::FromIterator;
use std::ops::{Index, IndexMut};
use linked_hash_map::{self, LinkedHashMap};
use serde::{self, Deserialize, Deserializer, Serialize};
use value::Value;
#[derive(Clone, Debug, Default, Eq, Hash, PartialEq, PartialOrd)]
pub struct Mapping {
map: LinkedHashMap<Value, Value>,
}
impl Mapping {
#[inline]
pub fn new() -> Self {
Self::default()
}
#[inline]
pub fn with_capacity(capacity: usize) -> Self {
Mapping {
map: LinkedHashMap::with_capacity(capacity),
}
}
#[inline]
pub fn reserve(&mut self, additional: usize) {
self.map.reserve(additional)
}
#[inline]
pub fn shrink_to_fit(&mut self) {
self.map.shrink_to_fit()
}
#[inline]
pub fn insert(&mut self, k: Value, v: Value) -> Option<Value> {
self.map.insert(k, v)
}
#[inline]
pub fn contains_key(&self, k: &Value) -> bool {
self.map.contains_key(k)
}
#[inline]
pub fn get(&self, k: &Value) -> Option<&Value> {
self.map.get(k)
}
#[inline]
pub fn get_mut(&mut self, k: &Value) -> Option<&mut Value> {
self.map.get_mut(k)
}
#[inline]
pub fn remove(&mut self, k: &Value) -> Option<Value> {
self.map.remove(k)
}
#[inline]
pub fn capacity(&self) -> usize {
self.map.capacity()
}
#[inline]
pub fn len(&self) -> usize {
self.map.len()
}
#[inline]
pub fn is_empty(&self) -> bool {
self.map.is_empty()
}
#[inline]
pub fn clear(&mut self) {
self.map.clear()
}
#[inline]
pub fn iter(&self) -> Iter {
Iter {
iter: self.map.iter(),
}
}
#[inline]
pub fn iter_mut(&mut self) -> IterMut {
IterMut {
iter: self.map.iter_mut(),
}
}
}
impl<'a> Index<&'a Value> for Mapping {
type Output = Value;
#[inline]
fn index(&self, index: &'a Value) -> &Value {
self.map.index(index)
}
}
impl<'a> IndexMut<&'a Value> for Mapping {
#[inline]
fn index_mut(&mut self, index: &'a Value) -> &mut Value {
self.map.index_mut(index)
}
}
impl Extend<(Value, Value)> for Mapping {
#[inline]
fn extend<I: IntoIterator<Item = (Value, Value)>>(&mut self, iter: I) {
self.map.extend(iter);
}
}
impl FromIterator<(Value, Value)> for Mapping {
#[inline]
fn from_iter<I: IntoIterator<Item = (Value, Value)>>(iter: I) -> Self {
Mapping {
map: LinkedHashMap::from_iter(iter),
}
}
}
macro_rules! delegate_iterator {
(($name:ident $($generics:tt)*) => $item:ty) => {
impl $($generics)* Iterator for $name $($generics)* {
type Item = $item;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
self.iter.next()
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
impl $($generics)* ExactSizeIterator for $name $($generics)* {
#[inline]
fn len(&self) -> usize {
self.iter.len()
}
}
}
}
pub struct Iter<'a> {
iter: linked_hash_map::Iter<'a, Value, Value>,
}
delegate_iterator!((Iter<'a>) => (&'a Value, &'a Value));
impl<'a> IntoIterator for &'a Mapping {
type Item = (&'a Value, &'a Value);
type IntoIter = Iter<'a>;
#[inline]
fn into_iter(self) -> Self::IntoIter {
Iter {
iter: self.map.iter(),
}
}
}
pub struct IterMut<'a> {
iter: linked_hash_map::IterMut<'a, Value, Value>,
}
delegate_iterator!((IterMut<'a>) => (&'a Value, &'a mut Value));
impl<'a> IntoIterator for &'a mut Mapping {
type Item = (&'a Value, &'a mut Value);
type IntoIter = IterMut<'a>;
#[inline]
fn into_iter(self) -> Self::IntoIter {
IterMut {
iter: self.map.iter_mut(),
}
}
}
pub struct IntoIter {
iter: linked_hash_map::IntoIter<Value, Value>,
}
delegate_iterator!((IntoIter) => (Value, Value));
impl IntoIterator for Mapping {
type Item = (Value, Value);
type IntoIter = IntoIter;
#[inline]
fn into_iter(self) -> Self::IntoIter {
IntoIter {
iter: self.map.into_iter(),
}
}
}
impl Serialize for Mapping {
#[inline]
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeMap;
let mut map_serializer = serializer.serialize_map(Some(self.len()))?;
for (k, v) in self {
map_serializer.serialize_entry(k, v)?;
}
map_serializer.end()
}
}
impl<'de> Deserialize<'de> for Mapping {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = Mapping;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("a YAML mapping")
}
#[inline]
fn visit_unit<E>(self) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
Ok(Mapping::new())
}
#[inline]
fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut values = Mapping::new();
while let Some((k, v)) = visitor.next_entry()? {
values.insert(k, v);
}
Ok(values)
}
}
deserializer.deserialize_map(Visitor)
}
}