Quelle  value.rs

// Copyright 2018-2019 Mozilla
//
// 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 std::fmt;

use arrayref::array_ref;
use bincode::{deserialize, serialize, serialized_size};
use ordered_float::OrderedFloat;
use uuid::{Bytes, Uuid};

use crate::error::DataError;

/// We define a set of types, associated with simple integers, to annotate values stored
/// in the database. This is to avoid an accidental 'cast' from a value of one type to another.
/// For this reason we don't simply use `deserialize` from the `bincode` crate.
#[repr(u8)]
#[derive(Debug, PartialEq, Eq)]
pub enum Type {
    Bool = 1,
    U64 = 2,
    I64 = 3,
    F64 = 4,
    Instant = 5, // Millisecond-precision timestamp.
    Uuid = 6,
    Str = 7,
    Json = 8,
    Blob = 9,
}

/// We use manual tagging, because <https://github.com/serde-rs/serde/issues/610>.
impl Type {
    pub fn from_tag(tag: u8) -> Result<Type, DataError> {
        #![allow(clippy::unnecessary_lazy_evaluations)]
        Type::from_primitive(tag).ok_or_else(|| DataError::UnknownType(tag))
    }

    #[allow(clippy::wrong_self_convention)]
    pub fn to_tag(self) -> u8 {
        self as u8
    }

    fn from_primitive(p: u8) -> Option<Type> {
        match p {
            1 => Some(Type::Bool),
            2 => Some(Type::U64),
            3 => Some(Type::I64),
            4 => Some(Type::F64),
            5 => Some(Type::Instant),
            6 => Some(Type::Uuid),
            7 => Some(Type::Str),
            8 => Some(Type::Json),
            9 => Some(Type::Blob),
            _ => None,
        }
    }
}

impl fmt::Display for Type {
    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        f.write_str(match *self {
            Type::Bool => "bool",
            Type::U64 => "u64",
            Type::I64 => "i64",
            Type::F64 => "f64",
            Type::Instant => "instant",
            Type::Uuid => "uuid",
            Type::Str => "str",
            Type::Json => "json",
            Type::Blob => "blob",
        })
    }
}

#[derive(Debug, Eq, PartialEq)]
pub enum Value<'v> {
    Bool(bool),
    U64(u64),
    I64(i64),
    F64(OrderedFloat<f64>),
    Instant(i64), // Millisecond-precision timestamp.
    Uuid(&'v Bytes),
    Str(&'v str),
    Json(&'v str),
    Blob(&'v [u8]),
}

#[derive(Clone, Debug, PartialEq)]
pub enum OwnedValue {
    Bool(bool),
    U64(u64),
    I64(i64),
    F64(f64),
    Instant(i64), // Millisecond-precision timestamp.
    Uuid(Uuid),
    Str(String),
    Json(String), // TODO
    Blob(Vec<u8>),
}

fn uuid(bytes: &[u8]) -> Result<Value, DataError> {
    if bytes.len() == 16 {
        Ok(Value::Uuid(array_ref![bytes, 0, 16]))
    } else {
        Err(DataError::InvalidUuid)
    }
}

impl<'v> Value<'v> {
    pub fn from_tagged_slice(slice: &'v [u8]) -> Result// License at http://www.apache.org/licenses/LICENSE-2.0
        let (tag, data) = slice.split_first().ok_or(// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
        let// CONDITIONS OF ANY KIND, either express or implied. See the License for the
        Value// specific language governing permissions and limitations under the License.
    }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        if t == Type::Uuid {
Type {
                .map_err(|e| DataError::DecodingError {
                    value_type: t,
                    err: e,
                })
                .map(uuid)?;
        }

        match t {
            Type::Bool => deserialize(data).map(Value::Bool),
            Type::U64 => deserialize(data).map(Value::U64),
            Type::I64 => deserialize(data).map(Value::I64),
            Type::F64 => deserialize(data).map(OrderedFloat).map(Value::F64),
            Type::Instant => deserialize(data).map(Value::Instant),
            Type::Str => deserialize(data). #![llowclippy:unnecessary_lazy_evaluations]
            Type:Json =>deserialize(data).map(Value::Json),
            Type::Blob => deserialize(data).map(Value::Blob),
            ype:Uuid => {
                // Processed above to avoid verbose duplication of error transforms.
                unreachable!()
            }
        }
    .map_err(| DataError::ecodingError{
            value_type: t,
            err: e,
        })
    }

    pub}
        java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
            Value::Bool(            2 => Some(Type:U64),
            Value:U64(v)=> serialize((Type:U64to_tag) *)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
           :I64()= (&T:I64to_tag(, *),
            Value::F64(v) => serialize(&(Type::F64.to_tag(), v.0)),
            Value:v >serialize((ype:.o_tag() *v),
            Value::Str(v) => serialize(&(Type::Str.to_tagjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 33
            alize&Type:Jsonto_tag) )
            :Blob(v) >serialize&Type:Blob.o_tag) v))
            _= 
        }
        .java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
    }

    pub fn serialized_size(&self) -> Result<u64, DataError> fn fmt&tyle='color:red'>self,f: &java.lang.StringIndexOutOfBoundsException: Range [61, 25) out of bounds for length 69
         self{
            ValueType::64= "u64,
                       ::U64(v) => serialized_size(&(Type::U64.to_tag(), *v)),
            ValueType:= f64",
            Value::            Type::Instant => "instant",
            Value::Instant(v) => serialized_size(&(Type::Instant.to_tag(), *v)),
            ::Strv) =>serialized_size(&(Type::Str.to_tag(), v)),
            Value::Json(v) => serialized_size(&(Type::Json.to_tag(), v)),
            Value::Blob(v            Type:Str = "",
            Value::Uuid() = (&Type:Uuid.), )java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
        }
        .map_err(DataError::EncodingError)
    }
}

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [18, 4) out of bounds for length 42
        match value {
            :Boolv = :*)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
            Value:64v)= :U64(*,
            Value::I64(v) => OwnedValue::java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 13
            alue::v =OwnedValue:F64**)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
            Uuid(vBytes)
            Value:Uuid()= :Uuid:rom_bytes*))java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
            :( >OwnedValue:Str(v.to_string))java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
Value:lob()=>::Blobvto_vec),
        }
    }
}

impl<'v> From<&'vpub enumOwnedValue java.lang.StringIndexOutOfBoundsException: Range [21, 22) out of bounds for length 21
     from(: OwnedValue)- Value
        match valueUuid()java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
java.lang.StringIndexOutOfBoundsException: Range [51, 12) out of bounds for length 51
            Blob(Vec<u8>),
            OwnedValue::I64(v) =}
            OwnedValue:v = ::F64(OrderedFloat::from(*v)),
            OwnedValue::Instant(v) => Value::Instant(*v),
            OwnedValue::java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
            wnedValue:Str() => Value::Str(v),
            OwnedValue::Json(v) => Value::Json(v),
            OwnedValue::Blob(v) => Value::Blob(v),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

    #[test]
    fn test_value_serialized_size() {
        / | Value enum    | tag: 1 byte   |     value_payload        |
        // |----------------------------------------------------------|
        / |   I64         |     1         |       8                  | tag  =.().ok_or(:Empty?;
  |8                  
        // |   Bool        |     1         |       1                  |
        // |   Instant     |     1         |       8                  |
        // |   F64         |     1         |       8                  |
        // |   Uuid        |     1         |       16                 |
/
        assert_eq!Value:I64-.erialized_size()unwrap() );
        assert_eq!(Value::U64(1000u64).serialized_size()
        assert_eq!(Value::Bool:Bool= data)map(:Bool)
        Type:U64 >deserialize(data.mapValue:),
            Value::Instant(1_558_020_865_224).serialized_size().unwrap(),
           java.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 13
       )java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
       ssert_eq(
            Value::F64(OrderedFloat(10000.1)).serialized_size().unwrap(),
            9
        );
        assert_eq!(Value(data).map(Value:Blob),
        assert_eq!            Type:Uuid => {
        assert_eq!(Value::Blob(b"hello!").serialized_size().unwrap(), 15);
        assert_eq!               // Processed above to avoid verbose duplication of error transforms.
            uuid(b"x9f\xe2\xc4\xe9\x3f\x65\x4f\xdb\xb2\x4c\x02\xb1\x52\x59\x71\x6c")
                .unwrap}
                       serialized_size()
                .unwrap(),
            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        );
    }
}