hocon-rs 0.2.0

Rust implementation of HOCON
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

use std::{
    cell::RefCell,
    fmt::Display,
    ops::{Deref, DerefMut},
};

use tracing::trace;

use crate::{
    join_format,
    merge::{path::RefPath, value::Value},
};

#[derive(Debug, Clone, PartialEq)]
pub(crate) enum Array {
    Merged(Vec<RefCell<Value>>),
    Unmerged(Vec<RefCell<Value>>),
}

impl Array {
    pub(crate) fn new(values: Vec<RefCell<Value>>) -> Self {
        Array::Unmerged(values)
    }

    pub(crate) fn is_merged(&self) -> bool {
        matches!(self, Array::Merged(_))
    }

    pub(crate) fn from_raw(
        parent: Option<&RefPath>,
        raw: crate::raw::raw_array::RawArray,
    ) -> crate::Result<Self> {
        let mut values = Vec::with_capacity(raw.len());
        for val in raw.into_inner() {
            let val = Value::from_raw(parent, val)?;
            values.push(RefCell::new(val));
        }
        Ok(Self::new(values))
    }

    pub(crate) fn as_merged(&mut self) {
        let array = std::mem::take(self.deref_mut());
        *self = Self::Merged(array);
    }

    pub(crate) fn as_unmerged(&mut self) {
        let array = std::mem::take(self.deref_mut());
        *self = Self::Unmerged(array);
    }

    pub(crate) fn try_become_merged(&mut self) -> bool {
        if self.is_merged() {
            return true;
        }
        let all_merged = self.iter_mut().all(|v| v.get_mut().try_become_merged());
        if all_merged {
            self.as_merged();
            trace!("{} become merged", self);
        }
        all_merged
    }

    pub(crate) fn into_inner(self) -> Vec<RefCell<Value>> {
        match self {
            Array::Merged(array) | Array::Unmerged(array) => array,
        }
    }
}

impl Deref for Array {
    type Target = Vec<RefCell<Value>>;

    fn deref(&self) -> &Self::Target {
        match self {
            Array::Merged(array) | Array::Unmerged(array) => array,
        }
    }
}

impl DerefMut for Array {
    fn deref_mut(&mut self) -> &mut Self::Target {
        match self {
            Array::Merged(array) | Array::Unmerged(array) => array,
        }
    }
}

impl Display for Array {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "[")?;
        join_format(
            self.iter(),
            f,
            |f| write!(f, ", "),
            |f, v| write!(f, "{}", v.borrow()),
        )?;
        write!(f, "]")?;
        Ok(())
    }
}