Initial commit

libraries/cbor/src/values.rs

@@ -0,0 +1,268 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use alloc::collections::BTreeMap;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+use core::cmp::Ordering;
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Value {
+    KeyValue(KeyType),
+    Array(Vec<Value>),
+    Map(BTreeMap<KeyType, Value>),
+    // TAG is omitted
+    Simple(SimpleValue),
+}
+
+// The specification recommends to limit the available keys.
+// Currently supported are both integer and string types.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum KeyType {
+    Unsigned(u64),
+    // We only use 63 bits of information here.
+    Negative(i64),
+    ByteString(Vec<u8>),
+    TextString(String),
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum SimpleValue {
+    FalseValue = 20,
+    TrueValue = 21,
+    NullValue = 22,
+    Undefined = 23,
+}
+
+pub struct Constants {}
+
+impl Constants {
+    pub const MAJOR_TYPE_BIT_SHIFT: u8 = 5;
+    pub const ADDITIONAL_INFORMATION_MASK: u8 = 0x1F;
+    pub const ADDITIONAL_INFORMATION_MAX_INT: u8 = 23;
+    pub const ADDITIONAL_INFORMATION_1_BYTE: u8 = 24;
+    pub const ADDITIONAL_INFORMATION_2_BYTES: u8 = 25;
+    pub const ADDITIONAL_INFORMATION_4_BYTES: u8 = 26;
+    pub const ADDITIONAL_INFORMATION_8_BYTES: u8 = 27;
+}
+
+impl Value {
+    pub fn bool_value(b: bool) -> Value {
+        if b {
+            Value::Simple(SimpleValue::TrueValue)
+        } else {
+            Value::Simple(SimpleValue::FalseValue)
+        }
+    }
+
+    pub fn type_label(&self) -> u8 {
+        match self {
+            Value::KeyValue(key) => key.type_label(),
+            Value::Array(_) => 4,
+            Value::Map(_) => 5,
+            Value::Simple(_) => 7,
+        }
+    }
+}
+
+impl KeyType {
+    // For simplicity, this only takes i64. Construct directly for the last bit.
+    pub fn integer(int: i64) -> KeyType {
+        if int >= 0 {
+            KeyType::Unsigned(int as u64)
+        } else {
+            KeyType::Negative(int)
+        }
+    }
+
+    pub fn type_label(&self) -> u8 {
+        match self {
+            KeyType::Unsigned(_) => 0,
+            KeyType::Negative(_) => 1,
+            KeyType::ByteString(_) => 2,
+            KeyType::TextString(_) => 3,
+        }
+    }
+}
+
+impl Ord for KeyType {
+    fn cmp(&self, other: &KeyType) -> Ordering {
+        use super::values::KeyType::{ByteString, Negative, TextString, Unsigned};
+        let self_type_value = self.type_label();
+        let other_type_value = other.type_label();
+        if self_type_value != other_type_value {
+            return self_type_value.cmp(&other_type_value);
+        }
+        match (self, other) {
+            (Unsigned(u1), Unsigned(u2)) => u1.cmp(u2),
+            (Negative(n1), Negative(n2)) => n1.cmp(n2).reverse(),
+            (ByteString(b1), ByteString(b2)) => b1.len().cmp(&b2.len()).then(b1.cmp(b2)),
+            (TextString(t1), TextString(t2)) => t1.len().cmp(&t2.len()).then(t1.cmp(t2)),
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl PartialOrd for KeyType {
+    fn partial_cmp(&self, other: &KeyType) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl SimpleValue {
+    pub fn from_integer(int: u64) -> Option<SimpleValue> {
+        match int {
+            20 => Some(SimpleValue::FalseValue),
+            21 => Some(SimpleValue::TrueValue),
+            22 => Some(SimpleValue::NullValue),
+            23 => Some(SimpleValue::Undefined),
+            _ => None,
+        }
+    }
+}
+
+impl From<u64> for KeyType {
+    fn from(unsigned: u64) -> Self {
+        KeyType::Unsigned(unsigned)
+    }
+}
+
+impl From<i64> for KeyType {
+    fn from(i: i64) -> Self {
+        KeyType::integer(i)
+    }
+}
+
+impl From<i32> for KeyType {
+    fn from(i: i32) -> Self {
+        KeyType::integer(i as i64)
+    }
+}
+
+impl From<Vec<u8>> for KeyType {
+    fn from(bytes: Vec<u8>) -> Self {
+        KeyType::ByteString(bytes)
+    }
+}
+
+impl From<&[u8]> for KeyType {
+    fn from(bytes: &[u8]) -> Self {
+        KeyType::ByteString(bytes.to_vec())
+    }
+}
+
+impl From<String> for KeyType {
+    fn from(text: String) -> Self {
+        KeyType::TextString(text)
+    }
+}
+
+impl From<&str> for KeyType {
+    fn from(text: &str) -> Self {
+        KeyType::TextString(text.to_string())
+    }
+}
+
+impl<T> From<T> for Value
+where
+    KeyType: From<T>,
+{
+    fn from(t: T) -> Self {
+        Value::KeyValue(KeyType::from(t))
+    }
+}
+
+impl From<bool> for Value {
+    fn from(b: bool) -> Self {
+        Value::bool_value(b)
+    }
+}
+
+pub trait IntoCborKey {
+    fn into_cbor_key(self) -> KeyType;
+}
+
+impl<T> IntoCborKey for T
+where
+    KeyType: From<T>,
+{
+    fn into_cbor_key(self) -> KeyType {
+        KeyType::from(self)
+    }
+}
+
+pub trait IntoCborValue {
+    fn into_cbor_value(self) -> Value;
+}
+
+impl<T> IntoCborValue for T
+where
+    Value: From<T>,
+{
+    fn into_cbor_value(self) -> Value {
+        Value::from(self)
+    }
+}
+
+pub trait IntoCborValueOption {
+    fn into_cbor_value_option(self) -> Option<Value>;
+}
+
+impl<T> IntoCborValueOption for T
+where
+    Value: From<T>,
+{
+    fn into_cbor_value_option(self) -> Option<Value> {
+        Some(Value::from(self))
+    }
+}
+
+impl<T> IntoCborValueOption for Option<T>
+where
+    Value: From<T>,
+{
+    fn into_cbor_value_option(self) -> Option<Value> {
+        self.map(Value::from)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_key_type_ordering() {
+        assert!(cbor_key_int!(0) < cbor_key_int!(23));
+        assert!(cbor_key_int!(23) < cbor_key_int!(24));
+        assert!(cbor_key_int!(24) < cbor_key_int!(1000));
+        assert!(cbor_key_int!(1000) < cbor_key_int!(1000000));
+        assert!(cbor_key_int!(1000000) < cbor_key_int!(std::i64::MAX));
+        assert!(cbor_key_int!(std::i64::MAX) < cbor_key_int!(-1));
+        assert!(cbor_key_int!(-1) < cbor_key_int!(-23));
+        assert!(cbor_key_int!(-23) < cbor_key_int!(-24));
+        assert!(cbor_key_int!(-24) < cbor_key_int!(-1000));
+        assert!(cbor_key_int!(-1000) < cbor_key_int!(-1000000));
+        assert!(cbor_key_int!(-1000000) < cbor_key_int!(std::i64::MIN));
+        assert!(cbor_key_int!(std::i64::MIN) < cbor_key_bytes!(vec![]));
+        assert!(cbor_key_bytes!(vec![]) < cbor_key_bytes!(vec![0x00]));
+        assert!(cbor_key_bytes!(vec![0x00]) < cbor_key_bytes!(vec![0x01]));
+        assert!(cbor_key_bytes!(vec![0x01]) < cbor_key_bytes!(vec![0xFF]));
+        assert!(cbor_key_bytes!(vec![0xFF]) < cbor_key_bytes!(vec![0x00, 0x00]));
+        assert!(cbor_key_bytes!(vec![0x00, 0x00]) < cbor_key_text!(""));
+        assert!(cbor_key_text!("") < cbor_key_text!("a"));
+        assert!(cbor_key_text!("a") < cbor_key_text!("b"));
+        assert!(cbor_key_text!("b") < cbor_key_text!("aa"));
+        assert!(cbor_key_int!(1) < cbor_key_bytes!(vec![0x00]));
+        assert!(cbor_key_int!(1) < cbor_key_text!("s"));
+        assert!(cbor_key_int!(-1) < cbor_key_text!("s"));
+    }
+}