vrl 0.32.0

Vector Remap Language
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::borrow::Cow;
use std::fmt::{self, Display, Formatter};

use serde::{Deserialize, Serialize};

/// The key type value. This is a simple zero-overhead wrapper set up to make it explicit that
/// object keys are read-only and their underlying type is opaque and may change for efficiency.
#[derive(Clone, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
#[cfg_attr(any(test, feature = "proptest"), derive(proptest_derive::Arbitrary))]
#[serde(transparent)]
pub struct KeyString(String);

impl KeyString {
    /// Convert the key into a boxed slice of bytes (`u8`).
    #[inline]
    #[must_use]
    pub fn into_bytes(self) -> Box<[u8]> {
        self.0.into_bytes().into()
    }

    /// Is this string empty?
    #[inline]
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    /// Get the length of the contained key.
    #[inline]
    #[must_use]
    pub fn len(&self) -> usize {
        self.0.len()
    }

    /// Return a reference to the contained string slice.
    #[inline]
    #[must_use]
    pub fn as_str(&self) -> &str {
        &self.0
    }
}

impl Display for KeyString {
    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
        self.0.fmt(fmt)
    }
}

impl AsRef<str> for KeyString {
    fn as_ref(&self) -> &str {
        &self.0
    }
}

impl std::ops::Deref for KeyString {
    type Target = str;
    fn deref(&self) -> &str {
        &self.0
    }
}

impl std::borrow::Borrow<str> for KeyString {
    fn borrow(&self) -> &str {
        &self.0
    }
}

impl PartialEq<str> for KeyString {
    fn eq(&self, that: &str) -> bool {
        self.0[..].eq(that)
    }
}

impl From<&str> for KeyString {
    fn from(s: &str) -> Self {
        Self(s.into())
    }
}

impl From<String> for KeyString {
    fn from(s: String) -> Self {
        Self(s)
    }
}

impl From<Cow<'_, str>> for KeyString {
    fn from(s: Cow<'_, str>) -> Self {
        Self(s.into())
    }
}

impl From<KeyString> for String {
    fn from(s: KeyString) -> Self {
        s.0
    }
}

#[cfg(any(test, feature = "arbitrary"))]
impl quickcheck::Arbitrary for KeyString {
    fn arbitrary(g: &mut quickcheck::Gen) -> Self {
        String::arbitrary(g).into()
    }

    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
        let s = self.0.clone();
        Box::new(s.shrink().map(Into::into))
    }
}

#[cfg(any(test, feature = "lua"))]
mod lua {
    use mlua::prelude::LuaResult;
    use mlua::{FromLua, IntoLua, Lua, Value as LuaValue};

    use super::KeyString;

    impl FromLua for KeyString {
        fn from_lua(value: LuaValue, lua: &Lua) -> LuaResult<Self> {
            String::from_lua(value, lua).map(Self::from)
        }
    }

    impl IntoLua for KeyString {
        fn into_lua(self, lua: &Lua) -> LuaResult<LuaValue> {
            self.0.into_lua(lua)
        }
    }
}