use bytes::{BufMut, Bytes, BytesMut};
use num_bigint::BigInt;
use uuid::Uuid;
use std::convert::TryFrom;
use crate::error::{FdbError, FdbResult, TUPLE_TRY_FROM_BYTES};
use crate::tuple::{Null, Tuple, Versionstamp};
#[derive(Clone, PartialEq, Debug)]
pub(crate) enum TupleValue {
NullValue, ByteString(Bytes), UnicodeString(String), NestedTuple(Tuple), NegativeArbitraryPrecisionInteger(BigInt), NegInt8(u64), NegInt7(u64), NegInt6(u64), NegInt5(u64), NegInt4(u32), NegInt3(u32), NegInt2(u16), NegInt1(u8), IntZero, PosInt1(u8), PosInt2(u16), PosInt3(u32), PosInt4(u32), PosInt5(u64), PosInt6(u64), PosInt7(u64), PosInt8(u64), PositiveArbitraryPrecisionInteger(BigInt), IeeeBinaryFloatingPointFloat(f32), IeeeBinaryFloatingPointDouble(f64), FalseValue, TrueValue, Rfc4122Uuid(Uuid), Versionstamp96Bit(Versionstamp), }
impl TryFrom<TupleValue> for BigInt {
type Error = ();
fn try_from(value: TupleValue) -> Result<BigInt, ()> {
i64::try_from(value.clone())
.map(|x| x.into())
.or_else(|_| match value {
TupleValue::NegativeArbitraryPrecisionInteger(ref i) => Ok(i.clone() * -1),
TupleValue::NegInt8(ref i)
if (9223372036854775809..=18446744073709551615).contains(i) =>
{
Ok(Into::<BigInt>::into(*i) * -1)
}
TupleValue::PosInt8(ref i)
if (9223372036854775808..=18446744073709551615).contains(i) =>
{
Ok((*i).into())
}
TupleValue::PositiveArbitraryPrecisionInteger(ref i) => Ok(i.clone()),
_ => Err(()),
})
}
}
impl TryFrom<TupleValue> for Bytes {
type Error = ();
fn try_from(value: TupleValue) -> Result<Bytes, ()> {
match value {
TupleValue::ByteString(b) => Ok(b),
_ => Err(()),
}
}
}
impl TryFrom<TupleValue> for String {
type Error = ();
fn try_from(value: TupleValue) -> Result<String, ()> {
match value {
TupleValue::UnicodeString(s) => Ok(s),
_ => Err(()),
}
}
}
impl TryFrom<TupleValue> for Uuid {
type Error = ();
fn try_from(value: TupleValue) -> Result<Uuid, ()> {
match value {
TupleValue::Rfc4122Uuid(u) => Ok(u),
_ => Err(()),
}
}
}
impl TryFrom<TupleValue> for bool {
type Error = ();
fn try_from(value: TupleValue) -> Result<bool, ()> {
match value {
TupleValue::FalseValue => Ok(false),
TupleValue::TrueValue => Ok(true),
_ => Err(()),
}
}
}
impl TryFrom<TupleValue> for f32 {
type Error = ();
fn try_from(value: TupleValue) -> Result<f32, ()> {
match value {
TupleValue::IeeeBinaryFloatingPointFloat(f) => Ok(f),
_ => Err(()),
}
}
}
impl TryFrom<TupleValue> for f64 {
type Error = ();
fn try_from(value: TupleValue) -> Result<f64, ()> {
match value {
TupleValue::IeeeBinaryFloatingPointDouble(d) => Ok(d),
_ => Err(()),
}
}
}
impl TryFrom<TupleValue> for i16 {
type Error = ();
fn try_from(value: TupleValue) -> Result<i16, ()> {
i8::try_from(value.clone())
.map(|x| x.into())
.or_else(|_| match value {
TupleValue::NegInt2(ref i) if (256..=32768).contains(i) => Ok(
i16::try_from(-Into::<i32>::into(*i)).unwrap(),
),
TupleValue::NegInt1(ref i) if (129..=255).contains(i) => Ok(-Into::<i16>::into(*i)),
TupleValue::PosInt1(ref i) if (128..=255).contains(i) => Ok((*i).into()),
TupleValue::PosInt2(ref i) if (256..=32767).contains(i) => Ok(
i16::try_from(*i).unwrap(),
),
_ => Err(()),
})
}
}
impl TryFrom<TupleValue> for i32 {
type Error = ();
fn try_from(value: TupleValue) -> Result<i32, ()> {
i16::try_from(value.clone())
.map(|x| x.into())
.or_else(|_| match value {
TupleValue::NegInt4(ref i) if (16777216..=2147483648).contains(i) => Ok(
i32::try_from(-Into::<i64>::into(*i)).unwrap(),
),
TupleValue::NegInt3(ref i) if (65536..=16777215).contains(i) => Ok(
i32::try_from(-Into::<i64>::into(*i)).unwrap(),
),
TupleValue::NegInt2(ref i) if (32769..=65535).contains(i) => {
Ok(-Into::<i32>::into(*i))
}
TupleValue::PosInt2(ref i) if (32768..=65535).contains(i) => Ok((*i).into()),
TupleValue::PosInt3(ref i) if (65536..=16777215).contains(i) => Ok(
i32::try_from(*i).unwrap(),
),
TupleValue::PosInt4(ref i) if (16777216..=2147483647).contains(i) => Ok(
i32::try_from(*i).unwrap(),
),
_ => Err(()),
})
}
}
impl TryFrom<TupleValue> for i64 {
type Error = ();
fn try_from(value: TupleValue) -> Result<i64, ()> {
i32::try_from(value.clone())
.map(|x| x.into())
.or_else(|_| match value {
TupleValue::NegInt8(ref i)
if (72057594037927936..=9223372036854775808).contains(i) =>
{
Ok(
i64::try_from(-Into::<i128>::into(*i)).unwrap(),
)
}
TupleValue::NegInt7(ref i) if (281474976710656..=72057594037927935).contains(i) => {
Ok(
i64::try_from(-Into::<i128>::into(*i)).unwrap(),
)
}
TupleValue::NegInt6(ref i) if (1099511627776..=281474976710655).contains(i) => {
Ok(
i64::try_from(-Into::<i128>::into(*i)).unwrap(),
)
}
TupleValue::NegInt5(ref i) if (4294967296..=1099511627775).contains(i) => {
Ok(
i64::try_from(-Into::<i128>::into(*i)).unwrap(),
)
}
TupleValue::NegInt4(ref i) if (2147483649..=4294967295).contains(i) => {
Ok(-Into::<i64>::into(*i))
}
TupleValue::PosInt4(ref i) if (2147483648..=4294967295).contains(i) => {
Ok((*i).into())
}
TupleValue::PosInt5(ref i) if (4294967296..=1099511627775).contains(i) => {
Ok(
i64::try_from(*i).unwrap(),
)
}
TupleValue::PosInt6(ref i) if (1099511627776..=281474976710655).contains(i) => {
Ok(
i64::try_from(*i).unwrap(),
)
}
TupleValue::PosInt7(ref i) if (281474976710656..=72057594037927935).contains(i) => {
Ok(
i64::try_from(*i).unwrap(),
)
}
TupleValue::PosInt8(ref i)
if (72057594037927936..=9223372036854775807).contains(i) =>
{
Ok(
i64::try_from(*i).unwrap(),
)
}
_ => Err(()),
})
}
}
impl TryFrom<TupleValue> for i8 {
type Error = ();
fn try_from(value: TupleValue) -> Result<i8, ()> {
match value {
TupleValue::NegInt1(i) if i <= 128 => {
Ok(
i8::try_from(-Into::<i16>::into(i)).unwrap(),
)
}
TupleValue::IntZero => Ok(0),
TupleValue::PosInt1(i) if i <= 127 => Ok(
i8::try_from(i).unwrap(),
),
_ => Err(()),
}
}
}
impl TryFrom<TupleValue> for Null {
type Error = ();
fn try_from(value: TupleValue) -> Result<Null, ()> {
match value {
TupleValue::NullValue => Ok(Null),
_ => Err(()),
}
}
}
impl TryFrom<TupleValue> for Versionstamp {
type Error = ();
fn try_from(value: TupleValue) -> Result<Versionstamp, ()> {
match value {
TupleValue::Versionstamp96Bit(vs) => Ok(vs),
_ => Err(()),
}
}
}
impl TryFrom<TupleValue> for Tuple {
type Error = ();
fn try_from(value: TupleValue) -> Result<Tuple, ()> {
match value {
TupleValue::NestedTuple(t) => Ok(t),
_ => Err(()),
}
}
}
pub(crate) fn from_bytes(b: Bytes) -> FdbResult<Tuple> {
parser::tuple(b.as_ref())
.map(|(_, t)| t)
.map_err(|_| FdbError::new(TUPLE_TRY_FROM_BYTES))
}
pub(crate) fn to_bytes(t: Tuple) -> Bytes {
let mut res = BytesMut::new();
t.into_elements().into_iter().for_each(|x| {
res.put(match x {
TupleValue::NullValue => serializer::null_value(),
TupleValue::ByteString(b) => serializer::byte_string(b),
TupleValue::UnicodeString(s) => serializer::unicode_string(s),
TupleValue::NestedTuple(t) => serializer::nested_tuple(t),
TupleValue::NegativeArbitraryPrecisionInteger(b) => {
serializer::negative_arbitrary_precision_integer(b)
}
TupleValue::NegInt8(u) => serializer::neg_int_8(u),
TupleValue::NegInt7(u) => serializer::neg_int_7(u),
TupleValue::NegInt6(u) => serializer::neg_int_6(u),
TupleValue::NegInt5(u) => serializer::neg_int_5(u),
TupleValue::NegInt4(u) => serializer::neg_int_4(u),
TupleValue::NegInt3(u) => serializer::neg_int_3(u),
TupleValue::NegInt2(u) => serializer::neg_int_2(u),
TupleValue::NegInt1(u) => serializer::neg_int_1(u),
TupleValue::IntZero => serializer::int_zero(),
TupleValue::PosInt1(u) => serializer::pos_int_1(u),
TupleValue::PosInt2(u) => serializer::pos_int_2(u),
TupleValue::PosInt3(u) => serializer::pos_int_3(u),
TupleValue::PosInt4(u) => serializer::pos_int_4(u),
TupleValue::PosInt5(u) => serializer::pos_int_5(u),
TupleValue::PosInt6(u) => serializer::pos_int_6(u),
TupleValue::PosInt7(u) => serializer::pos_int_7(u),
TupleValue::PosInt8(u) => serializer::pos_int_8(u),
TupleValue::PositiveArbitraryPrecisionInteger(b) => {
serializer::positive_arbitrary_precision_integer(b)
}
TupleValue::IeeeBinaryFloatingPointFloat(f) => {
serializer::ieee_binary_floating_point_float(f)
}
TupleValue::IeeeBinaryFloatingPointDouble(f) => {
serializer::ieee_binary_floating_point_double(f)
}
TupleValue::FalseValue => serializer::false_value(),
TupleValue::TrueValue => serializer::true_value(),
TupleValue::Rfc4122Uuid(u) => serializer::rfc_4122_uuid(u),
TupleValue::Versionstamp96Bit(v) => serializer::versionstamp_96_bit(v),
})
});
res.into()
}
pub(crate) fn find_incomplete_versionstamp(t: Tuple) -> FdbResult<usize> {
versionstamp::query_for_incomplete_versionstamp(t)
}
pub(self) mod utils {
use bytes::{BufMut, Bytes, BytesMut};
use nom::{bytes as nom_bytes, IResult};
pub(crate) fn neg_u8_slice_into_vec(i: &[u8]) -> Vec<u8> {
let mut res = Vec::new();
i.iter().for_each(|x| {
res.push(!(*x));
});
res
}
pub(crate) fn extract_unpacked_bytes(mut i: &[u8]) -> IResult<&[u8], Bytes> {
let mut res_output = BytesMut::new();
let res_input;
loop {
let (i1, o1) = nom_bytes::complete::take_until(&b"\x00"[..])(i)?;
res_output.put(o1);
if i1.len() >= 2 {
if i1[1] == b'\xFF' {
res_output.put(&b"\x00"[..]);
i = &i1[2..];
} else {
res_input = &i1[1..];
return Ok((res_input, res_output.into()));
}
} else {
res_input = &i1[1..];
return Ok((res_input, res_output.into()));
}
}
}
}
pub(self) mod versionstamp {
use crate::error::{
FdbError, FdbResult, TUPLE_PACK_WITH_VERSIONSTAMP_MULTIPLE_FOUND,
TUPLE_PACK_WITH_VERSIONSTAMP_NOT_FOUND,
};
use crate::tuple::Tuple;
use super::{serializer, TupleValue};
#[allow(clippy::enum_variant_names)]
#[derive(Debug, PartialEq)]
enum QueryForIncompleteVersionstamp {
NotFound(usize),
Found(usize),
MultipleFound,
}
pub(crate) fn query_for_incomplete_versionstamp(t: Tuple) -> FdbResult<usize> {
let query_for_incomplete_versionstamp = t
.into_elements()
.into_iter()
.map(|tv| match tv {
TupleValue::NullValue => {
QueryForIncompleteVersionstamp::NotFound(serializer::null_value().len())
}
TupleValue::ByteString(b) => {
QueryForIncompleteVersionstamp::NotFound(serializer::byte_string(b).len())
}
TupleValue::UnicodeString(s) => {
QueryForIncompleteVersionstamp::NotFound(serializer::unicode_string(s).len())
}
TupleValue::NestedTuple(t) => query_for_incomplete_versionstamp_nested_tuple(t),
TupleValue::NegativeArbitraryPrecisionInteger(b) => {
QueryForIncompleteVersionstamp::NotFound(
serializer::negative_arbitrary_precision_integer(b).len(),
)
}
TupleValue::NegInt8(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_8(u).len())
}
TupleValue::NegInt7(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_7(u).len())
}
TupleValue::NegInt6(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_6(u).len())
}
TupleValue::NegInt5(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_5(u).len())
}
TupleValue::NegInt4(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_4(u).len())
}
TupleValue::NegInt3(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_3(u).len())
}
TupleValue::NegInt2(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_2(u).len())
}
TupleValue::NegInt1(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_1(u).len())
}
TupleValue::IntZero => {
QueryForIncompleteVersionstamp::NotFound(serializer::int_zero().len())
}
TupleValue::PosInt1(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_1(u).len())
}
TupleValue::PosInt2(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_2(u).len())
}
TupleValue::PosInt3(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_3(u).len())
}
TupleValue::PosInt4(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_4(u).len())
}
TupleValue::PosInt5(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_5(u).len())
}
TupleValue::PosInt6(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_6(u).len())
}
TupleValue::PosInt7(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_7(u).len())
}
TupleValue::PosInt8(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_8(u).len())
}
TupleValue::PositiveArbitraryPrecisionInteger(b) => {
QueryForIncompleteVersionstamp::NotFound(
serializer::positive_arbitrary_precision_integer(b).len(),
)
}
TupleValue::IeeeBinaryFloatingPointFloat(f) => {
QueryForIncompleteVersionstamp::NotFound(
serializer::ieee_binary_floating_point_float(f).len(),
)
}
TupleValue::IeeeBinaryFloatingPointDouble(f) => {
QueryForIncompleteVersionstamp::NotFound(
serializer::ieee_binary_floating_point_double(f).len(),
)
}
TupleValue::FalseValue => {
QueryForIncompleteVersionstamp::NotFound(serializer::false_value().len())
}
TupleValue::TrueValue => {
QueryForIncompleteVersionstamp::NotFound(serializer::true_value().len())
}
TupleValue::Rfc4122Uuid(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::rfc_4122_uuid(u).len())
}
TupleValue::Versionstamp96Bit(v) => {
if v.is_complete() {
QueryForIncompleteVersionstamp::NotFound(
serializer::versionstamp_96_bit(v).len(),
)
} else {
QueryForIncompleteVersionstamp::Found(1)
}
}
})
.fold(
QueryForIncompleteVersionstamp::NotFound(0),
|acc, x| match acc {
QueryForIncompleteVersionstamp::NotFound(u) => match x {
QueryForIncompleteVersionstamp::NotFound(v) => {
QueryForIncompleteVersionstamp::NotFound(u + v)
}
QueryForIncompleteVersionstamp::Found(v) => {
QueryForIncompleteVersionstamp::Found(u + v)
}
QueryForIncompleteVersionstamp::MultipleFound => {
QueryForIncompleteVersionstamp::MultipleFound
}
},
QueryForIncompleteVersionstamp::Found(u) => match x {
QueryForIncompleteVersionstamp::NotFound(_) => {
QueryForIncompleteVersionstamp::Found(u)
}
QueryForIncompleteVersionstamp::Found(_) => {
QueryForIncompleteVersionstamp::MultipleFound
}
QueryForIncompleteVersionstamp::MultipleFound => {
QueryForIncompleteVersionstamp::MultipleFound
}
},
QueryForIncompleteVersionstamp::MultipleFound => {
QueryForIncompleteVersionstamp::MultipleFound
}
},
);
match query_for_incomplete_versionstamp {
QueryForIncompleteVersionstamp::NotFound(_) => {
Err(FdbError::new(TUPLE_PACK_WITH_VERSIONSTAMP_NOT_FOUND))
}
QueryForIncompleteVersionstamp::Found(u) => Ok(u),
QueryForIncompleteVersionstamp::MultipleFound => {
Err(FdbError::new(TUPLE_PACK_WITH_VERSIONSTAMP_MULTIPLE_FOUND))
}
}
}
fn query_for_incomplete_versionstamp_nested_tuple(t: Tuple) -> QueryForIncompleteVersionstamp {
t.into_elements()
.into_iter()
.map(|tv| {
match tv {
TupleValue::NullValue => QueryForIncompleteVersionstamp::NotFound(
serializer::nested_tuple_null_value().len(),
),
TupleValue::ByteString(b) => {
QueryForIncompleteVersionstamp::NotFound(serializer::byte_string(b).len())
}
TupleValue::UnicodeString(s) => QueryForIncompleteVersionstamp::NotFound(
serializer::unicode_string(s).len(),
),
TupleValue::NestedTuple(t) => query_for_incomplete_versionstamp_nested_tuple(t),
TupleValue::NegativeArbitraryPrecisionInteger(b) => {
QueryForIncompleteVersionstamp::NotFound(
serializer::negative_arbitrary_precision_integer(b).len(),
)
}
TupleValue::NegInt8(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_8(u).len())
}
TupleValue::NegInt7(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_7(u).len())
}
TupleValue::NegInt6(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_6(u).len())
}
TupleValue::NegInt5(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_5(u).len())
}
TupleValue::NegInt4(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_4(u).len())
}
TupleValue::NegInt3(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_3(u).len())
}
TupleValue::NegInt2(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_2(u).len())
}
TupleValue::NegInt1(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::neg_int_1(u).len())
}
TupleValue::IntZero => {
QueryForIncompleteVersionstamp::NotFound(serializer::int_zero().len())
}
TupleValue::PosInt1(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_1(u).len())
}
TupleValue::PosInt2(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_2(u).len())
}
TupleValue::PosInt3(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_3(u).len())
}
TupleValue::PosInt4(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_4(u).len())
}
TupleValue::PosInt5(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_5(u).len())
}
TupleValue::PosInt6(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_6(u).len())
}
TupleValue::PosInt7(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_7(u).len())
}
TupleValue::PosInt8(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::pos_int_8(u).len())
}
TupleValue::PositiveArbitraryPrecisionInteger(b) => {
QueryForIncompleteVersionstamp::NotFound(
serializer::positive_arbitrary_precision_integer(b).len(),
)
}
TupleValue::IeeeBinaryFloatingPointFloat(f) => {
QueryForIncompleteVersionstamp::NotFound(
serializer::ieee_binary_floating_point_float(f).len(),
)
}
TupleValue::IeeeBinaryFloatingPointDouble(f) => {
QueryForIncompleteVersionstamp::NotFound(
serializer::ieee_binary_floating_point_double(f).len(),
)
}
TupleValue::FalseValue => {
QueryForIncompleteVersionstamp::NotFound(serializer::false_value().len())
}
TupleValue::TrueValue => {
QueryForIncompleteVersionstamp::NotFound(serializer::true_value().len())
}
TupleValue::Rfc4122Uuid(u) => {
QueryForIncompleteVersionstamp::NotFound(serializer::rfc_4122_uuid(u).len())
}
TupleValue::Versionstamp96Bit(v) => {
if v.is_complete() {
QueryForIncompleteVersionstamp::NotFound(
serializer::versionstamp_96_bit(v).len(),
)
} else {
QueryForIncompleteVersionstamp::Found(1)
}
}
}
})
.fold(
QueryForIncompleteVersionstamp::NotFound(0),
|acc, x| match acc {
QueryForIncompleteVersionstamp::NotFound(u) => match x {
QueryForIncompleteVersionstamp::NotFound(v) => {
QueryForIncompleteVersionstamp::NotFound(u + v)
}
QueryForIncompleteVersionstamp::Found(v) => {
QueryForIncompleteVersionstamp::Found(u + v)
}
QueryForIncompleteVersionstamp::MultipleFound => {
QueryForIncompleteVersionstamp::MultipleFound
}
},
QueryForIncompleteVersionstamp::Found(u) => match x {
QueryForIncompleteVersionstamp::NotFound(_) => {
QueryForIncompleteVersionstamp::Found(u)
}
QueryForIncompleteVersionstamp::Found(_) => {
QueryForIncompleteVersionstamp::MultipleFound
}
QueryForIncompleteVersionstamp::MultipleFound => {
QueryForIncompleteVersionstamp::MultipleFound
}
},
QueryForIncompleteVersionstamp::MultipleFound => {
QueryForIncompleteVersionstamp::MultipleFound
}
},
)
}
#[cfg(test)]
mod tests {
use crate::error::{
FdbError, TUPLE_PACK_WITH_VERSIONSTAMP_MULTIPLE_FOUND,
TUPLE_PACK_WITH_VERSIONSTAMP_NOT_FOUND,
};
use crate::tuple::{Null, Tuple, Versionstamp};
use super::{
query_for_incomplete_versionstamp, query_for_incomplete_versionstamp_nested_tuple,
QueryForIncompleteVersionstamp,
};
#[test]
fn test_query_for_incomplete_versionstamp() {
assert_eq!(
query_for_incomplete_versionstamp({
let mut t = Tuple::new();
t.push_back::<Null>(Null);
t.push_back::<Versionstamp>(Versionstamp::incomplete(0));
t.push_back::<String>("foo".to_string());
t
}),
Ok(2)
);
assert_eq!(
query_for_incomplete_versionstamp({
let mut t = Tuple::new();
t.push_back::<Null>(Null);
t.push_back::<String>("foo".to_string());
t
}),
Err(FdbError::new(TUPLE_PACK_WITH_VERSIONSTAMP_NOT_FOUND))
);
assert_eq!(
query_for_incomplete_versionstamp({
let mut t = Tuple::new();
t.push_back::<Null>(Null);
t.push_back::<Tuple>({
let mut t1 = Tuple::new();
t1.push_back::<Versionstamp>(Versionstamp::incomplete(1));
t1
});
t.push_back::<String>("foo".to_string());
t.push_back::<Tuple>({
let mut t2 = Tuple::new();
t2.push_back::<Versionstamp>(Versionstamp::incomplete(1));
t2
});
t.push_back::<String>("bar".to_string());
t
}),
Err(FdbError::new(TUPLE_PACK_WITH_VERSIONSTAMP_MULTIPLE_FOUND))
);
}
#[test]
fn test_query_for_incomplete_versionstamp_nested_tuple() {
assert_eq!(
query_for_incomplete_versionstamp_nested_tuple({
let mut t = Tuple::new();
t.push_back::<Null>(Null);
t.push_back::<Versionstamp>(Versionstamp::incomplete(0));
t.push_back::<String>("foo".to_string());
t
}),
QueryForIncompleteVersionstamp::Found(3)
);
assert_eq!(
query_for_incomplete_versionstamp_nested_tuple({
let mut t = Tuple::new();
t.push_back::<Null>(Null);
t.push_back::<String>("foo".to_string());
t
}),
QueryForIncompleteVersionstamp::NotFound(7)
);
assert_eq!(
query_for_incomplete_versionstamp_nested_tuple({
let mut t = Tuple::new();
t.push_back::<Null>(Null);
t.push_back::<Tuple>({
let mut t1 = Tuple::new();
t1.push_back::<Versionstamp>(Versionstamp::incomplete(1));
t1
});
t.push_back::<String>("foo".to_string());
t.push_back::<Tuple>({
let mut t2 = Tuple::new();
t2.push_back::<Versionstamp>(Versionstamp::incomplete(1));
t2
});
t.push_back::<String>("bar".to_string());
t
}),
QueryForIncompleteVersionstamp::MultipleFound
);
}
}
}
pub(self) mod serializer {
use bytes::Bytes;
use bytes::{BufMut, BytesMut};
use num_bigint::BigInt;
use uuid::Uuid;
use std::convert::TryFrom;
use crate::tuple::{Tuple, Versionstamp};
use super::{utils::neg_u8_slice_into_vec, TupleValue};
pub(crate) fn null_value() -> Bytes {
Bytes::from_static(b"\x00")
}
pub(crate) fn nested_tuple_null_value() -> Bytes {
Bytes::from_static(b"\x00\xFF")
}
pub(crate) fn byte_string(b: Bytes) -> Bytes {
let mut res = BytesMut::new();
res.put_u8(b'\x01');
b.into_iter().for_each(|x| {
if x == b'\x00' {
res.put(&b"\x00\xFF"[..]);
} else {
res.put_u8(x);
}
});
res.put_u8(b'\x00');
res.into()
}
pub(crate) fn unicode_string(s: String) -> Bytes {
let mut res = BytesMut::new();
res.put_u8(b'\x02');
s.into_bytes().into_iter().for_each(|x| {
if x == b'\x00' {
res.put(&b"\x00\xFF"[..]);
} else {
res.put_u8(x);
}
});
res.put_u8(b'\x00');
res.into()
}
pub(crate) fn nested_tuple(t: Tuple) -> Bytes {
let mut res = BytesMut::new();
res.put_u8(b'\x05');
t.into_elements().into_iter().for_each(|x| {
res.put(match x {
TupleValue::NullValue => nested_tuple_null_value(),
TupleValue::ByteString(b) => byte_string(b),
TupleValue::UnicodeString(s) => unicode_string(s),
TupleValue::NestedTuple(t) => nested_tuple(t),
TupleValue::NegativeArbitraryPrecisionInteger(b) => {
negative_arbitrary_precision_integer(b)
}
TupleValue::NegInt8(u) => neg_int_8(u),
TupleValue::NegInt7(u) => neg_int_7(u),
TupleValue::NegInt6(u) => neg_int_6(u),
TupleValue::NegInt5(u) => neg_int_5(u),
TupleValue::NegInt4(u) => neg_int_4(u),
TupleValue::NegInt3(u) => neg_int_3(u),
TupleValue::NegInt2(u) => neg_int_2(u),
TupleValue::NegInt1(u) => neg_int_1(u),
TupleValue::IntZero => int_zero(),
TupleValue::PosInt1(u) => pos_int_1(u),
TupleValue::PosInt2(u) => pos_int_2(u),
TupleValue::PosInt3(u) => pos_int_3(u),
TupleValue::PosInt4(u) => pos_int_4(u),
TupleValue::PosInt5(u) => pos_int_5(u),
TupleValue::PosInt6(u) => pos_int_6(u),
TupleValue::PosInt7(u) => pos_int_7(u),
TupleValue::PosInt8(u) => pos_int_8(u),
TupleValue::PositiveArbitraryPrecisionInteger(b) => {
positive_arbitrary_precision_integer(b)
}
TupleValue::IeeeBinaryFloatingPointFloat(f) => ieee_binary_floating_point_float(f),
TupleValue::IeeeBinaryFloatingPointDouble(f) => {
ieee_binary_floating_point_double(f)
}
TupleValue::FalseValue => false_value(),
TupleValue::TrueValue => true_value(),
TupleValue::Rfc4122Uuid(u) => rfc_4122_uuid(u),
TupleValue::Versionstamp96Bit(v) => versionstamp_96_bit(v),
})
});
res.put_u8(b'\x00');
res.into()
}
pub(crate) fn negative_arbitrary_precision_integer(b: BigInt) -> Bytes {
let b: BigInt = b * -1;
let (_, val) = b.to_bytes_be();
let val = Bytes::from(neg_u8_slice_into_vec(val.as_ref()));
let len = (u8::try_from(val.len()).unwrap()) ^ 0xFFu8;
let mut res = BytesMut::new();
res.put_u8(b'\x0B');
res.put_u8(len);
res.put(val);
res.into()
}
pub(crate) fn neg_int_8(u: u64) -> Bytes {
let u = u.to_be_bytes();
let val = Bytes::from(neg_u8_slice_into_vec(&u));
let mut res = BytesMut::new();
res.put_u8(b'\x0C');
res.put(val);
res.into()
}
pub(crate) fn neg_int_7(u: u64) -> Bytes {
let u = u.to_be_bytes();
let val = Bytes::from(neg_u8_slice_into_vec(&u[1..]));
let mut res = BytesMut::new();
res.put_u8(b'\x0D');
res.put(val);
res.into()
}
pub(crate) fn neg_int_6(u: u64) -> Bytes {
let u = u.to_be_bytes();
let val = Bytes::from(neg_u8_slice_into_vec(&u[2..]));
let mut res = BytesMut::new();
res.put_u8(b'\x0E');
res.put(val);
res.into()
}
pub(crate) fn neg_int_5(u: u64) -> Bytes {
let u = u.to_be_bytes();
let val = Bytes::from(neg_u8_slice_into_vec(&u[3..]));
let mut res = BytesMut::new();
res.put_u8(b'\x0F');
res.put(val);
res.into()
}
pub(crate) fn neg_int_4(u: u32) -> Bytes {
let u = u.to_be_bytes();
let val = Bytes::from(neg_u8_slice_into_vec(&u));
let mut res = BytesMut::new();
res.put_u8(b'\x10');
res.put(val);
res.into()
}
pub(crate) fn neg_int_3(u: u32) -> Bytes {
let u = u.to_be_bytes();
let val = Bytes::from(neg_u8_slice_into_vec(&u[1..]));
let mut res = BytesMut::new();
res.put_u8(b'\x11');
res.put(val);
res.into()
}
pub(crate) fn neg_int_2(u: u16) -> Bytes {
let u = u.to_be_bytes();
let val = Bytes::from(neg_u8_slice_into_vec(&u));
let mut res = BytesMut::new();
res.put_u8(b'\x12');
res.put(val);
res.into()
}
pub(crate) fn neg_int_1(u: u8) -> Bytes {
let u = u.to_be_bytes();
let val = Bytes::from(neg_u8_slice_into_vec(&u));
let mut res = BytesMut::new();
res.put_u8(b'\x13');
res.put(val);
res.into()
}
pub(crate) fn int_zero() -> Bytes {
Bytes::from_static(b"\x14")
}
pub(crate) fn pos_int_1(u: u8) -> Bytes {
let val = Bytes::from(u.to_be_bytes().to_vec());
let mut res = BytesMut::new();
res.put_u8(b'\x15');
res.put(val);
res.into()
}
pub(crate) fn pos_int_2(u: u16) -> Bytes {
let val = Bytes::from(u.to_be_bytes().to_vec());
let mut res = BytesMut::new();
res.put_u8(b'\x16');
res.put(val);
res.into()
}
pub(crate) fn pos_int_3(u: u32) -> Bytes {
let val = Bytes::from((&u.to_be_bytes()[1..]).to_vec());
let mut res = BytesMut::new();
res.put_u8(b'\x17');
res.put(val);
res.into()
}
pub(crate) fn pos_int_4(u: u32) -> Bytes {
let val = Bytes::from(u.to_be_bytes().to_vec());
let mut res = BytesMut::new();
res.put_u8(b'\x18');
res.put(val);
res.into()
}
pub(crate) fn pos_int_5(u: u64) -> Bytes {
let val = Bytes::from((&u.to_be_bytes()[3..]).to_vec());
let mut res = BytesMut::new();
res.put_u8(b'\x19');
res.put(val);
res.into()
}
pub(crate) fn pos_int_6(u: u64) -> Bytes {
let val = Bytes::from((&u.to_be_bytes()[2..]).to_vec());
let mut res = BytesMut::new();
res.put_u8(b'\x1A');
res.put(val);
res.into()
}
pub(crate) fn pos_int_7(u: u64) -> Bytes {
let val = Bytes::from((&u.to_be_bytes()[1..]).to_vec());
let mut res = BytesMut::new();
res.put_u8(b'\x1B');
res.put(val);
res.into()
}
pub(crate) fn pos_int_8(u: u64) -> Bytes {
let val = Bytes::from(u.to_be_bytes().to_vec());
let mut res = BytesMut::new();
res.put_u8(b'\x1C');
res.put(val);
res.into()
}
pub(crate) fn positive_arbitrary_precision_integer(b: BigInt) -> Bytes {
let (_, val) = b.to_bytes_be();
let val = Bytes::from(val);
let len = u8::try_from(val.len()).unwrap();
let mut res = BytesMut::new();
res.put_u8(b'\x1D');
res.put_u8(len);
res.put(val);
res.into()
}
pub(crate) fn ieee_binary_floating_point_float(f: f32) -> Bytes {
let x = f.to_be_bytes();
let mut res = Vec::new();
res.put_u8(b'\x20');
if f.is_sign_negative() {
x.iter().for_each(|y| res.push(*y ^ 0xFF));
} else {
res.push(x[0] ^ 0x80);
x[1..].iter().for_each(|y| res.push(*y));
}
Bytes::from(res)
}
pub(crate) fn ieee_binary_floating_point_double(f: f64) -> Bytes {
let x = f.to_be_bytes();
let mut res = Vec::new();
res.put_u8(b'\x21');
if f.is_sign_negative() {
x.iter().for_each(|y| res.push(*y ^ 0xFF));
} else {
res.push(x[0] ^ 0x80);
x[1..].iter().for_each(|y| res.push(*y));
}
Bytes::from(res)
}
pub(crate) fn false_value() -> Bytes {
Bytes::from_static(b"\x26")
}
pub(crate) fn true_value() -> Bytes {
Bytes::from_static(b"\x27")
}
pub(crate) fn rfc_4122_uuid(u: Uuid) -> Bytes {
let mut res = BytesMut::new();
res.put_u8(b'\x30');
res.put(&u.as_bytes()[..]);
res.into()
}
pub(crate) fn versionstamp_96_bit(v: Versionstamp) -> Bytes {
let mut res = BytesMut::new();
res.put_u8(b'\x33');
res.put(v.get_bytes());
res.into()
}
#[cfg(test)]
mod tests {
use bytes::Bytes;
use num_bigint::BigInt;
use uuid::Uuid;
use crate::tuple::{Tuple, Versionstamp};
use super::{
byte_string, false_value, ieee_binary_floating_point_double,
ieee_binary_floating_point_float, int_zero, neg_int_1, neg_int_2, neg_int_3, neg_int_4,
neg_int_5, neg_int_6, neg_int_7, neg_int_8, negative_arbitrary_precision_integer,
nested_tuple, nested_tuple_null_value, null_value, pos_int_1, pos_int_2, pos_int_3,
pos_int_4, pos_int_5, pos_int_6, pos_int_7, pos_int_8,
positive_arbitrary_precision_integer, rfc_4122_uuid, true_value, unicode_string,
versionstamp_96_bit, TupleValue,
};
#[test]
fn test_null_value() {
assert_eq!(null_value(), Bytes::from_static(b"\x00"));
}
#[test]
fn test_nested_tuple_null_value() {
assert_eq!(nested_tuple_null_value(), Bytes::from_static(b"\x00\xFF"));
}
#[test]
fn test_byte_string() {
assert_eq!(
byte_string(Bytes::from_static(b"foo\x00bar")),
Bytes::from_static(b"\x01foo\x00\xFFbar\x00"),
);
assert_eq!(byte_string(Bytes::new()), Bytes::from_static(b"\x01\x00"),);
assert_eq!(
byte_string(Bytes::from_static(b"\x01\x02\x03")),
Bytes::from_static(b"\x01\x01\x02\x03\x00"),
);
assert_eq!(
byte_string(Bytes::from_static(b"\x00\x00\x00\x04")),
Bytes::from_static(b"\x01\x00\xFF\x00\xFF\x00\xFF\x04\x00"),
);
}
#[test]
fn test_unicode_string() {
assert_eq!(
unicode_string("F\u{00d4}O\u{0000}bar".to_string()),
Bytes::from_static(b"\x02F\xC3\x94O\x00\xffbar\x00"),
);
assert_eq!(
unicode_string("".to_string()),
Bytes::from_static(b"\x02\x00"),
);
assert_eq!(
unicode_string("hello".to_string()),
Bytes::from_static(b"\x02hello\x00"),
);
assert_eq!(
unicode_string("中文".to_string()),
Bytes::from_static(b"\x02\xE4\xB8\xAD\xE6\x96\x87\x00"),
);
assert_eq!(
unicode_string("μάθημα".to_string()),
Bytes::from_static(b"\x02\xCE\xBC\xCE\xAC\xCE\xB8\xCE\xB7\xCE\xBC\xCE\xB1\x00"),
);
}
#[test]
fn test_nested_tuple() {
assert_eq!(
nested_tuple(Tuple::from_elements(vec![TupleValue::NullValue])),
Bytes::from_static(b"\x05\x00\xFF\x00")
);
assert_eq!(
nested_tuple(Tuple::from_elements(vec![
TupleValue::NullValue,
TupleValue::UnicodeString("hello".to_string()),
])),
Bytes::from_static(b"\x05\x00\xFF\x02hello\x00\x00")
);
assert_eq!(
nested_tuple(Tuple::from_elements(vec![
TupleValue::NullValue,
TupleValue::UnicodeString("hell\u{0}".to_string()),
])),
Bytes::from_static(b"\x05\x00\xFF\x02hell\x00\xFF\x00\x00")
);
}
#[test]
fn test_negative_arbitrary_precision_integer() {
assert_eq!(
negative_arbitrary_precision_integer(
BigInt::parse_bytes(b"18446744073709551616", 10).unwrap()
),
Bytes::from_static(b"\x0B\xF6\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),
);
}
#[test]
fn test_neg_int_8() {
assert_eq!(
neg_int_8(18446744073709551615),
Bytes::from_static(b"\x0C\x00\x00\x00\x00\x00\x00\x00\x00"),
);
assert_eq!(
neg_int_8(72057594037927936),
Bytes::from_static(b"\x0C\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),
);
assert_eq!(
neg_int_8(9223372036854775809),
Bytes::from_static(b"\x0C\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFE"),
);
assert_eq!(
neg_int_8(9223372036854775808),
Bytes::from_static(b"\x0C\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),
);
}
#[test]
fn test_neg_int_7() {
assert_eq!(
neg_int_7(72057594037927935),
Bytes::from_static(b"\x0D\x00\x00\x00\x00\x00\x00\x00"),
);
assert_eq!(
neg_int_7(281474976710656),
Bytes::from_static(b"\x0D\xFE\xFF\xFF\xFF\xFF\xFF\xFF"),
);
}
#[test]
fn test_neg_int_6() {
assert_eq!(
neg_int_6(281474976710655),
Bytes::from_static(b"\x0E\x00\x00\x00\x00\x00\x00"),
);
assert_eq!(
neg_int_6(1099511627776),
Bytes::from_static(b"\x0E\xFE\xFF\xFF\xFF\xFF\xFF"),
);
}
#[test]
fn test_neg_int_5() {
assert_eq!(
neg_int_5(1099511627775),
Bytes::from_static(b"\x0F\x00\x00\x00\x00\x00"),
);
assert_eq!(
neg_int_5(4294967296),
Bytes::from_static(b"\x0F\xFE\xFF\xFF\xFF\xFF"),
);
}
#[test]
fn test_neg_int_4() {
assert_eq!(
neg_int_4(4294967295),
Bytes::from_static(b"\x10\x00\x00\x00\x00"),
);
assert_eq!(
neg_int_4(16777216),
Bytes::from_static(b"\x10\xFE\xFF\xFF\xFF"),
);
assert_eq!(
neg_int_4(2147483649),
Bytes::from_static(b"\x10\x7F\xFF\xFF\xFE"),
);
assert_eq!(
neg_int_4(2147483648),
Bytes::from_static(b"\x10\x7F\xFF\xFF\xFF"),
);
}
#[test]
fn test_neg_int_3() {
assert_eq!(neg_int_3(16777215), Bytes::from_static(b"\x11\x00\x00\x00"),);
assert_eq!(neg_int_3(65536), Bytes::from_static(b"\x11\xFE\xFF\xFF"),);
}
#[test]
fn test_neg_int_2() {
assert_eq!(neg_int_2(65535), Bytes::from_static(b"\x12\x00\x00"));
assert_eq!(neg_int_2(256), Bytes::from_static(b"\x12\xFE\xFF"));
assert_eq!(neg_int_2(32769), Bytes::from_static(b"\x12\x7F\xFE"));
assert_eq!(neg_int_2(32768), Bytes::from_static(b"\x12\x7F\xFF"));
}
#[test]
fn test_neg_int_1() {
assert_eq!(neg_int_1(255), Bytes::from_static(b"\x13\x00"));
assert_eq!(neg_int_1(1), Bytes::from_static(b"\x13\xFE"));
assert_eq!(neg_int_1(129), Bytes::from_static(b"\x13\x7E"));
assert_eq!(neg_int_1(128), Bytes::from_static(b"\x13\x7F"));
}
#[test]
fn test_int_zero() {
assert_eq!(int_zero(), Bytes::from_static(b"\x14"));
}
#[test]
fn test_pos_int_1() {
assert_eq!(pos_int_1(1), Bytes::from_static(b"\x15\x01"));
assert_eq!(pos_int_1(255), Bytes::from_static(b"\x15\xFF"));
assert_eq!(pos_int_1(127), Bytes::from_static(b"\x15\x7F"));
assert_eq!(pos_int_1(128), Bytes::from_static(b"\x15\x80"));
}
#[test]
fn test_pos_int_2() {
assert_eq!(pos_int_2(256), Bytes::from_static(b"\x16\x01\x00"));
assert_eq!(pos_int_2(65535), Bytes::from_static(b"\x16\xFF\xFF"));
assert_eq!(pos_int_2(32767), Bytes::from_static(b"\x16\x7F\xFF"));
assert_eq!(pos_int_2(32768), Bytes::from_static(b"\x16\x80\x00"));
}
#[test]
fn test_pos_int_3() {
assert_eq!(pos_int_3(65536), Bytes::from_static(b"\x17\x01\x00\x00"));
assert_eq!(pos_int_3(16777215), Bytes::from_static(b"\x17\xFF\xFF\xFF"));
}
#[test]
fn test_pos_int_4() {
assert_eq!(
pos_int_4(16777216),
Bytes::from_static(b"\x18\x01\x00\x00\x00")
);
assert_eq!(
pos_int_4(4294967295),
Bytes::from_static(b"\x18\xFF\xFF\xFF\xFF")
);
assert_eq!(
pos_int_4(2147483647),
Bytes::from_static(b"\x18\x7F\xFF\xFF\xFF")
);
assert_eq!(
pos_int_4(2147483648),
Bytes::from_static(b"\x18\x80\x00\x00\x00")
);
}
#[test]
fn test_pos_int_5() {
assert_eq!(
pos_int_5(4294967296),
Bytes::from_static(b"\x19\x01\x00\x00\x00\x00")
);
assert_eq!(
pos_int_5(1099511627775),
Bytes::from_static(b"\x19\xFF\xFF\xFF\xFF\xFF")
);
}
#[test]
fn test_pos_int_6() {
assert_eq!(
pos_int_6(1099511627776),
Bytes::from_static(b"\x1A\x01\x00\x00\x00\x00\x00")
);
assert_eq!(
pos_int_6(281474976710655),
Bytes::from_static(b"\x1A\xFF\xFF\xFF\xFF\xFF\xFF")
);
}
#[test]
fn test_pos_int_7() {
assert_eq!(
pos_int_7(281474976710656),
Bytes::from_static(b"\x1B\x01\x00\x00\x00\x00\x00\x00")
);
assert_eq!(
pos_int_7(72057594037927935),
Bytes::from_static(b"\x1B\xFF\xFF\xFF\xFF\xFF\xFF\xFF")
);
}
#[test]
fn test_pos_int_8() {
assert_eq!(
pos_int_8(72057594037927936),
Bytes::from_static(b"\x1C\x01\x00\x00\x00\x00\x00\x00\x00")
);
assert_eq!(
pos_int_8(18446744073709551615),
Bytes::from_static(b"\x1C\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF")
);
assert_eq!(
pos_int_8(9223372036854775807),
Bytes::from_static(b"\x1C\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF")
);
assert_eq!(
pos_int_8(9223372036854775808),
Bytes::from_static(b"\x1C\x80\x00\x00\x00\x00\x00\x00\x00")
);
}
#[test]
fn test_positive_arbitrary_precision_integer() {
assert_eq!(
positive_arbitrary_precision_integer(
BigInt::parse_bytes(b"18446744073709551616", 10).unwrap()
),
Bytes::from_static(b"\x1D\x09\x01\x00\x00\x00\x00\x00\x00\x00\x00")
);
}
#[allow(clippy::approx_constant)]
#[test]
fn test_ieee_binary_floating_point_float() {
assert_eq!(
ieee_binary_floating_point_float(3.14f32),
Bytes::from_static(b"\x20\xC0\x48\xF5\xC3")
);
assert_eq!(
ieee_binary_floating_point_float(-3.14f32),
Bytes::from_static(b"\x20\x3F\xB7\x0A\x3C")
);
assert_eq!(
ieee_binary_floating_point_float(0.0f32),
Bytes::from_static(b"\x20\x80\x00\x00\x00")
);
assert_eq!(
ieee_binary_floating_point_float(-0.0f32),
Bytes::from_static(b"\x20\x7F\xFF\xFF\xFF")
);
assert_eq!(
ieee_binary_floating_point_float(f32::INFINITY),
Bytes::from_static(b"\x20\xFF\x80\x00\x00")
);
assert_eq!(
ieee_binary_floating_point_float(f32::NEG_INFINITY),
Bytes::from_static(b"\x20\x00\x7F\xFF\xFF")
);
}
#[allow(clippy::approx_constant)]
#[test]
fn test_ieee_binary_floating_point_double() {
assert_eq!(
ieee_binary_floating_point_double(3.14f64),
Bytes::from_static(b"\x21\xC0\x09\x1E\xB8\x51\xEB\x85\x1F")
);
assert_eq!(
ieee_binary_floating_point_double(-3.14f64),
Bytes::from_static(b"\x21\x3F\xF6\xE1\x47\xAE\x14\x7A\xE0")
);
assert_eq!(
ieee_binary_floating_point_double(0.0f64),
Bytes::from_static(b"\x21\x80\x00\x00\x00\x00\x00\x00\x00")
);
assert_eq!(
ieee_binary_floating_point_double(-0.0f64),
Bytes::from_static(b"\x21\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF")
);
assert_eq!(
ieee_binary_floating_point_double(f64::INFINITY),
Bytes::from_static(b"\x21\xFF\xF0\x00\x00\x00\x00\x00\x00")
);
assert_eq!(
ieee_binary_floating_point_double(f64::NEG_INFINITY),
Bytes::from_static(b"\x21\x00\x0F\xFF\xFF\xFF\xFF\xFF\xFF")
);
}
#[test]
fn test_false_value() {
assert_eq!(false_value(), Bytes::from_static(b"\x26"));
}
#[test]
fn test_true_value() {
assert_eq!(true_value(), Bytes::from_static(b"\x27"));
}
#[test]
fn test_rfc_4122_uuid() {
assert_eq!(
rfc_4122_uuid(Uuid::parse_str("ffffffff-ba5e-ba11-0000-00005ca1ab1e").unwrap()),
Bytes::from_static(
b"\x30\xFF\xFF\xFF\xFF\xBA\x5E\xBA\x11\x00\x00\x00\x00\x5C\xA1\xAB\x1E"
)
);
}
#[test]
fn test_versionstamp_96_bit() {
assert_eq!(
versionstamp_96_bit(Versionstamp::complete(
Bytes::from_static(b"\xAA\xBB\xCC\xDD\xEE\xFF\x00\x01\x02\x03"),
0
)),
Bytes::from_static(b"\x33\xAA\xBB\xCC\xDD\xEE\xFF\x00\x01\x02\x03\x00\x00")
);
assert_eq!(
versionstamp_96_bit(Versionstamp::complete(
Bytes::from_static(b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A"),
657
)),
Bytes::from_static(b"\x33\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x02\x91")
);
}
}
}
pub(self) mod parser {
use bytes::{Buf, Bytes};
use nom::error::{Error, ErrorKind};
use nom::{bytes as nom_bytes, combinator, multi, number, sequence, IResult};
use num_bigint::{BigInt, Sign};
use uuid::Uuid;
use crate::tuple::{Tuple, Versionstamp};
use super::{
utils::{extract_unpacked_bytes, neg_u8_slice_into_vec},
TupleValue,
};
pub(crate) fn tuple(mut i: &[u8]) -> IResult<&[u8], Tuple> {
let mut res = Vec::new();
loop {
match i.len() {
0 => return Ok((i, Tuple::from_elements(res))),
_ => {
let (i1, tv) = match i[0] {
b'\x00' => null_value(i),
b'\x01' => byte_string(i),
b'\x02' => unicode_string(i),
b'\x05' => nested_tuple(i),
b'\x0B' => negative_arbitrary_precision_integer(i),
b'\x0C' => neg_int_8(i),
b'\x0D' => neg_int_7(i),
b'\x0E' => neg_int_6(i),
b'\x0F' => neg_int_5(i),
b'\x10' => neg_int_4(i),
b'\x11' => neg_int_3(i),
b'\x12' => neg_int_2(i),
b'\x13' => neg_int_1(i),
b'\x14' => int_zero(i),
b'\x15' => pos_int_1(i),
b'\x16' => pos_int_2(i),
b'\x17' => pos_int_3(i),
b'\x18' => pos_int_4(i),
b'\x19' => pos_int_5(i),
b'\x1A' => pos_int_6(i),
b'\x1B' => pos_int_7(i),
b'\x1C' => pos_int_8(i),
b'\x1D' => positive_arbitrary_precision_integer(i),
b'\x20' => ieee_binary_floating_point_float(i),
b'\x21' => ieee_binary_floating_point_double(i),
b'\x26' => false_value(i),
b'\x27' => true_value(i),
b'\x30' => rfc_4122_uuid(i),
b'\x33' => versionstamp_96_bit(i),
_ => Err(nom::Err::Error(nom::error::Error::new(
i,
nom::error::ErrorKind::Fail,
))),
}?;
res.push(tv);
i = i1;
}
}
}
}
fn null_value(i: &[u8]) -> IResult<&[u8], TupleValue> {
combinator::map(nom_bytes::complete::tag(&b"\x00"[..]), |_| {
TupleValue::NullValue
})(i)
}
fn nested_tuple_null_value(i: &[u8]) -> IResult<&[u8], TupleValue> {
combinator::map(nom_bytes::complete::tag(&b"\x00\xFF"[..]), |_| {
TupleValue::NullValue
})(i)
}
fn byte_string(i: &[u8]) -> IResult<&[u8], TupleValue> {
let (i1, _) = nom_bytes::complete::tag(&b"\x01"[..])(i)?;
let (res_input, res_output) = extract_unpacked_bytes(i1)?;
Ok((res_input, TupleValue::ByteString(res_output)))
}
fn unicode_string(i: &[u8]) -> IResult<&[u8], TupleValue> {
let (i1, _) = nom_bytes::complete::tag(&b"\x02"[..])(i)?;
let (res_input, res_bytes) = extract_unpacked_bytes(i1)?;
let res_string = String::from_utf8((&res_bytes[..]).to_vec())
.map_err(|_| nom::Err::Error(Error::new(res_input, ErrorKind::Fail)))?;
Ok((res_input, TupleValue::UnicodeString(res_string)))
}
fn nested_tuple(i: &[u8]) -> IResult<&[u8], TupleValue> {
#[derive(Debug)]
enum NestedTuple<'a> {
Value((&'a [u8], TupleValue)),
End(&'a [u8]),
NoParserFound(&'a [u8]),
}
let mut res = Vec::new();
let (mut i1, _) = nom_bytes::complete::tag(&b"\x05"[..])(i)?;
loop {
match i1.len() {
0 => {
return Err(nom::Err::Error(nom::error::Error::new(
i1,
nom::error::ErrorKind::Eof,
)));
}
1 if i1[0] == b'\x00' => {
return Ok((
&i1[1..],
TupleValue::NestedTuple(Tuple::from_elements(res)),
));
}
_ => {
let val = if i1[0..=1] == b"\x00\xFF"[..] {
nested_tuple_null_value(i1).map(NestedTuple::Value)
} else {
match i1[0] {
b'\x00' => Ok(NestedTuple::End(&i1[1..])),
b'\x01' => byte_string(i1).map(NestedTuple::Value),
b'\x02' => unicode_string(i1).map(NestedTuple::Value),
b'\x05' => nested_tuple(i1).map(NestedTuple::Value),
b'\x0B' => {
negative_arbitrary_precision_integer(i1).map(NestedTuple::Value)
}
b'\x0C' => neg_int_8(i1).map(NestedTuple::Value),
b'\x0D' => neg_int_7(i1).map(NestedTuple::Value),
b'\x0E' => neg_int_6(i1).map(NestedTuple::Value),
b'\x0F' => neg_int_5(i1).map(NestedTuple::Value),
b'\x10' => neg_int_4(i1).map(NestedTuple::Value),
b'\x11' => neg_int_3(i1).map(NestedTuple::Value),
b'\x12' => neg_int_2(i1).map(NestedTuple::Value),
b'\x13' => neg_int_1(i1).map(NestedTuple::Value),
b'\x14' => int_zero(i1).map(NestedTuple::Value),
b'\x15' => pos_int_1(i1).map(NestedTuple::Value),
b'\x16' => pos_int_2(i1).map(NestedTuple::Value),
b'\x17' => pos_int_3(i1).map(NestedTuple::Value),
b'\x18' => pos_int_4(i1).map(NestedTuple::Value),
b'\x19' => pos_int_5(i1).map(NestedTuple::Value),
b'\x1A' => pos_int_6(i1).map(NestedTuple::Value),
b'\x1B' => pos_int_7(i1).map(NestedTuple::Value),
b'\x1C' => pos_int_8(i1).map(NestedTuple::Value),
b'\x1D' => {
positive_arbitrary_precision_integer(i1).map(NestedTuple::Value)
}
b'\x20' => ieee_binary_floating_point_float(i1).map(NestedTuple::Value),
b'\x21' => {
ieee_binary_floating_point_double(i1).map(NestedTuple::Value)
}
b'\x26' => false_value(i1).map(NestedTuple::Value),
b'\x27' => true_value(i1).map(NestedTuple::Value),
b'\x30' => rfc_4122_uuid(i1).map(NestedTuple::Value),
b'\x33' => versionstamp_96_bit(i1).map(NestedTuple::Value),
_ => Ok(NestedTuple::NoParserFound(i1)),
}
}?;
match val {
NestedTuple::Value((i2, tv)) => {
res.push(tv);
i1 = i2;
}
NestedTuple::End(i2) => {
return Ok((i2, TupleValue::NestedTuple(Tuple::from_elements(res))));
}
NestedTuple::NoParserFound(i2) => {
return Err(nom::Err::Error(nom::error::Error::new(
i2,
nom::error::ErrorKind::Fail,
)));
}
}
}
}
}
}
fn negative_arbitrary_precision_integer(i: &[u8]) -> IResult<&[u8], TupleValue> {
let (i1, _) = nom_bytes::complete::tag(&b"\x0B"[..])(i)?;
let (i2, o2) = nom_bytes::complete::take(1u8)(i1)?;
let len = o2[0] ^ 0xFFu8;
combinator::map(nom_bytes::complete::take(len), |x: &[u8]| {
TupleValue::NegativeArbitraryPrecisionInteger(BigInt::from_bytes_be(
Sign::Plus,
&neg_u8_slice_into_vec(x)[..],
))
})(i2)
}
fn neg_int_8(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x0C"[..]),
combinator::map(nom_bytes::complete::take(8u8), |x: &[u8]| {
TupleValue::NegInt8((&neg_u8_slice_into_vec(x)[..]).get_u64())
}),
)(i)
}
fn neg_int_7(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x0D"[..]),
combinator::map(nom_bytes::complete::take(7u8), |x: &[u8]| {
let mut val = vec![0xFFu8];
val.extend_from_slice(x);
TupleValue::NegInt7((&neg_u8_slice_into_vec(&val[..])[..]).get_u64())
}),
)(i)
}
fn neg_int_6(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x0E"[..]),
combinator::map(nom_bytes::complete::take(6u8), |x: &[u8]| {
let mut val = vec![0xFFu8, 0xFFu8];
val.extend_from_slice(x);
TupleValue::NegInt6((&neg_u8_slice_into_vec(&val[..])[..]).get_u64())
}),
)(i)
}
fn neg_int_5(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x0F"[..]),
combinator::map(nom_bytes::complete::take(5u8), |x: &[u8]| {
let mut val = vec![0xFFu8, 0xFFu8, 0xFFu8];
val.extend_from_slice(x);
TupleValue::NegInt5((&neg_u8_slice_into_vec(&val[..])[..]).get_u64())
}),
)(i)
}
fn neg_int_4(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x10"[..]),
combinator::map(nom_bytes::complete::take(4u8), |x: &[u8]| {
TupleValue::NegInt4((&neg_u8_slice_into_vec(x)[..]).get_u32())
}),
)(i)
}
fn neg_int_3(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x11"[..]),
combinator::map(nom_bytes::complete::take(3u8), |x: &[u8]| {
let mut val = vec![0xFFu8];
val.extend_from_slice(x);
TupleValue::NegInt3((&neg_u8_slice_into_vec(&val[..])[..]).get_u32())
}),
)(i)
}
fn neg_int_2(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x12"[..]),
combinator::map(nom_bytes::complete::take(2u8), |x: &[u8]| {
TupleValue::NegInt2((&neg_u8_slice_into_vec(x)[..]).get_u16())
}),
)(i)
}
fn neg_int_1(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x13"[..]),
combinator::map(nom_bytes::complete::take(1u8), |x: &[u8]| {
TupleValue::NegInt1((&neg_u8_slice_into_vec(x)[..]).get_u8())
}),
)(i)
}
fn int_zero(i: &[u8]) -> IResult<&[u8], TupleValue> {
combinator::map(nom_bytes::complete::tag(&b"\x14"[..]), |_| {
TupleValue::IntZero
})(i)
}
fn pos_int_1(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x15"[..]),
combinator::map(nom_bytes::complete::take(1u8), |mut x: &[u8]| {
TupleValue::PosInt1(x.get_u8())
}),
)(i)
}
fn pos_int_2(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x16"[..]),
combinator::map(nom_bytes::complete::take(2u8), |mut x: &[u8]| {
TupleValue::PosInt2(x.get_u16())
}),
)(i)
}
fn pos_int_3(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x17"[..]),
combinator::map(nom_bytes::complete::take(3u8), |x: &[u8]| {
let mut val = vec![0u8];
val.extend_from_slice(x);
TupleValue::PosInt3((&val[..]).get_u32())
}),
)(i)
}
fn pos_int_4(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x18"[..]),
combinator::map(nom_bytes::complete::take(4u8), |mut x: &[u8]| {
TupleValue::PosInt4(x.get_u32())
}),
)(i)
}
fn pos_int_5(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x19"[..]),
combinator::map(nom_bytes::complete::take(5u8), |x: &[u8]| {
let mut val = vec![0u8, 0u8, 0u8];
val.extend_from_slice(x);
TupleValue::PosInt5((&val[..]).get_u64())
}),
)(i)
}
fn pos_int_6(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x1A"[..]),
combinator::map(nom_bytes::complete::take(6u8), |x: &[u8]| {
let mut val = vec![0u8, 0u8];
val.extend_from_slice(x);
TupleValue::PosInt6((&val[..]).get_u64())
}),
)(i)
}
fn pos_int_7(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x1B"[..]),
combinator::map(nom_bytes::complete::take(7u8), |x: &[u8]| {
let mut val = vec![0u8];
val.extend_from_slice(x);
TupleValue::PosInt7((&val[..]).get_u64())
}),
)(i)
}
fn pos_int_8(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x1C"[..]),
combinator::map(nom_bytes::complete::take(8u8), |mut x: &[u8]| {
TupleValue::PosInt8(x.get_u64())
}),
)(i)
}
fn positive_arbitrary_precision_integer(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x1D"[..]),
combinator::map(multi::length_data(number::complete::be_u8), |x| {
TupleValue::PositiveArbitraryPrecisionInteger(BigInt::from_bytes_be(Sign::Plus, x))
}),
)(i)
}
fn ieee_binary_floating_point_float(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x20"[..]),
combinator::map(nom_bytes::complete::take(4u8), |x: &[u8]| {
if x[0] & 0x80 == 0x00 {
let mut res = Vec::new();
x.iter().for_each(|y| res.push(*y ^ 0xFF));
TupleValue::IeeeBinaryFloatingPointFloat((&res[..]).get_f32())
} else {
let mut res = vec![(x[0] ^ 0x80)];
x[1..].iter().for_each(|y| res.push(*y));
TupleValue::IeeeBinaryFloatingPointFloat((&res[..]).get_f32())
}
}),
)(i)
}
fn ieee_binary_floating_point_double(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x21"[..]),
combinator::map(nom_bytes::complete::take(8u8), |x: &[u8]| {
if x[0] & 0x80 == 0x00 {
let mut res = Vec::new();
x.iter().for_each(|y| res.push(*y ^ 0xFF));
TupleValue::IeeeBinaryFloatingPointDouble((&res[..]).get_f64())
} else {
let mut res = vec![(x[0] ^ 0x80)];
x[1..].iter().for_each(|y| res.push(*y));
TupleValue::IeeeBinaryFloatingPointDouble((&res[..]).get_f64())
}
}),
)(i)
}
fn false_value(i: &[u8]) -> IResult<&[u8], TupleValue> {
combinator::map(nom_bytes::complete::tag(&b"\x26"[..]), |_| {
TupleValue::FalseValue
})(i)
}
fn true_value(i: &[u8]) -> IResult<&[u8], TupleValue> {
combinator::map(nom_bytes::complete::tag(&b"\x27"[..]), |_| {
TupleValue::TrueValue
})(i)
}
fn rfc_4122_uuid(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x30"[..]),
combinator::map(nom_bytes::complete::take(16u8), |x: &[u8]| {
TupleValue::Rfc4122Uuid(Uuid::from_slice(x).unwrap())
}),
)(i)
}
fn versionstamp_96_bit(i: &[u8]) -> IResult<&[u8], TupleValue> {
sequence::preceded(
nom_bytes::complete::tag(&b"\x33"[..]),
combinator::map(nom_bytes::complete::take(12u8), |x: &[u8]| {
TupleValue::Versionstamp96Bit(Versionstamp::from_bytes(Bytes::from(x.to_vec())))
}),
)(i)
}
#[cfg(test)]
mod tests {
use super::{
byte_string, false_value, ieee_binary_floating_point_double,
ieee_binary_floating_point_float, int_zero, neg_int_1, neg_int_2, neg_int_3, neg_int_4,
neg_int_5, neg_int_6, neg_int_7, neg_int_8, negative_arbitrary_precision_integer,
nested_tuple, nested_tuple_null_value, null_value, pos_int_1, pos_int_2, pos_int_3,
pos_int_4, pos_int_5, pos_int_6, pos_int_7, pos_int_8,
positive_arbitrary_precision_integer, rfc_4122_uuid, true_value, tuple, unicode_string,
versionstamp_96_bit, TupleValue,
};
use crate::tuple::{Null, Tuple, Versionstamp};
use bytes::Bytes;
use nom::error::{Error, ErrorKind};
use num_bigint::BigInt;
use std::num::NonZeroUsize;
use uuid::Uuid;
#[allow(clippy::approx_constant)]
#[test]
fn test_tuple() {
assert_eq!(
tuple(b"\x00moredata"),
Err(nom::Err::Error(nom::error::Error::new(
&b"moredata"[..],
nom::error::ErrorKind::Fail
)))
);
assert_eq!(
tuple(b"no_tuple"),
Err(nom::Err::Error(nom::error::Error::new(
&b"no_tuple"[..],
nom::error::ErrorKind::Fail
)))
);
assert_eq!(tuple(b""), Ok((&b""[..], Tuple::new())));
assert_eq!(
tuple(b"\x14"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<i64>(0);
t
}))
);
assert_eq!(
tuple(b"\x14"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<BigInt>(BigInt::parse_bytes(b"0", 10).unwrap());
t
}))
);
assert_eq!(
tuple(b"\x15\x01"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<i64>(1);
t
}))
);
assert_eq!(
tuple(b"\x15\x01"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<BigInt>(BigInt::parse_bytes(b"1", 10).unwrap());
t
}))
);
assert_eq!(
tuple(b"\x13\xFE"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<i64>(-1);
t
}))
);
assert_eq!(
tuple(b"\x13\xFE"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<BigInt>(BigInt::parse_bytes(b"-1", 10).unwrap());
t
}))
);
assert_eq!(
tuple(b"\x15\xFF"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<i64>(255);
t
}))
);
assert_eq!(
tuple(b"\x15\xFF"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<BigInt>(BigInt::parse_bytes(b"255", 10).unwrap());
t
}))
);
assert_eq!(
tuple(b"\x13\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<i64>(-255);
t
}))
);
assert_eq!(
tuple(b"\x13\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<BigInt>(BigInt::parse_bytes(b"-255", 10).unwrap());
t
}))
);
assert_eq!(
tuple(b"\x16\x01\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<i64>(256);
t
}))
);
assert_eq!(
tuple(b"\x16\x01\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<BigInt>(BigInt::parse_bytes(b"256", 10).unwrap());
t
}))
);
assert_eq!(
tuple(b"\x17\x01\x00\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<i32>(65536);
t
}))
);
assert_eq!(
tuple(b"\x11\xFE\xFF\xFF"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<i32>(-65536);
t
}))
);
assert_eq!(
tuple(b"\x1C\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<i64>(i64::MAX);
t
}))
);
assert_eq!(
tuple(b"\x1C\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<BigInt>(BigInt::parse_bytes(b"9223372036854775807", 10).unwrap());
t
}))
);
assert_eq!(
tuple(b"\x1C\x80\x00\x00\x00\x00\x00\x00\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<BigInt>(BigInt::parse_bytes(b"9223372036854775808", 10).unwrap());
t
}))
);
assert_eq!(
tuple(b"\x1C\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<BigInt>(
BigInt::parse_bytes(b"18446744073709551615", 10).unwrap(),
);
t
}))
);
assert_eq!(
tuple(b"\x1D\x09\x01\x00\x00\x00\x00\x00\x00\x00\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<BigInt>(
BigInt::parse_bytes(b"18446744073709551616", 10).unwrap(),
);
t
}))
);
assert_eq!(
tuple(b"\x10\x00\x00\x00\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<i64>(-4294967295);
t
}))
);
assert_eq!(
tuple(b"\x10\x00\x00\x00\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<BigInt>(BigInt::parse_bytes(b"-4294967295", 10).unwrap());
t
}))
);
assert_eq!(
tuple(b"\x0C\x80\x00\x00\x00\x00\x00\x00\x01"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<i64>(i64::MIN + 2);
t
}))
);
assert_eq!(
tuple(b"\x0C\x80\x00\x00\x00\x00\x00\x00\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<i64>(i64::MIN + 1);
t
}))
);
assert_eq!(
tuple(b"\x0C\x80\x00\x00\x00\x00\x00\x00\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<BigInt>(
BigInt::parse_bytes(b"-9223372036854775808", 10).unwrap() + 1,
);
t
}))
);
assert_eq!(
tuple(b"\x0C\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<i64>(i64::MIN);
t
}))
);
assert_eq!(
tuple(b"\x0C\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<BigInt>(
BigInt::parse_bytes(b"-9223372036854775808", 10).unwrap(),
);
t
}))
);
assert_eq!(
tuple(b"\x0C\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFE"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<BigInt>(
BigInt::parse_bytes(b"-9223372036854775808", 10).unwrap() - 1,
);
t
}))
);
assert_eq!(
tuple(b"\x0C\x00\x00\x00\x00\x00\x00\x00\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<BigInt>(
BigInt::parse_bytes(b"-18446744073709551615", 10).unwrap(),
);
t
}))
);
assert_eq!(
tuple(b"\x20\xC0\x48\xF5\xC3"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<f32>(3.14f32);
t
}))
);
assert_eq!(
tuple(b"\x20\x3F\xB7\x0A\x3C"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<f32>(-3.14f32);
t
}))
);
assert_eq!(
tuple(b"\x21\xC0\x09\x1E\xB8\x51\xEB\x85\x1F"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<f64>(3.14f64);
t
}))
);
assert_eq!(
tuple(b"\x21\x3F\xF6\xE1\x47\xAE\x14\x7A\xE0"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<f64>(-3.14f64);
t
}))
);
assert_eq!(
tuple(b"\x20\x80\x00\x00\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<f32>(0.0f32);
t
}))
);
assert_eq!(
tuple(b"\x20\x7F\xFF\xFF\xFF"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<f32>(-0.0f32);
t
}))
);
assert_eq!(
tuple(b"\x21\x80\x00\x00\x00\x00\x00\x00\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<f64>(0.0f64);
t
}))
);
assert_eq!(
tuple(b"\x21\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<f64>(-0.0f64);
t
}))
);
assert_eq!(
tuple(b"\x20\xFF\x80\x00\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<f32>(f32::INFINITY);
t
}))
);
assert_eq!(
tuple(b"\x20\x00\x7F\xFF\xFF"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<f32>(f32::NEG_INFINITY);
t
}))
);
assert_eq!(
tuple(b"\x21\xFF\xF0\x00\x00\x00\x00\x00\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<f64>(f64::INFINITY);
t
}))
);
assert_eq!(
tuple(b"\x21\x00\x0F\xFF\xFF\xFF\xFF\xFF\xFF"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<f64>(f64::NEG_INFINITY);
t
}))
);
assert_eq!(
tuple(b"\x01\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<Bytes>(Bytes::new());
t
}))
);
assert_eq!(
tuple(b"\x01\x01\x02\x03\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<Bytes>(Bytes::from_static(&b"\x01\x02\x03"[..]));
t
}))
);
assert_eq!(
tuple(b"\x01\x00\xFF\x00\xFF\x00\xFF\x04\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<Bytes>(Bytes::from_static(&b"\x00\x00\x00\x04"[..]));
t
}))
);
assert_eq!(
tuple(b"\x02\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<String>("".to_string());
t
}))
);
assert_eq!(
tuple(b"\x02hello\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<String>("hello".to_string());
t
}))
);
assert_eq!(
tuple(b"\x02\xE4\xB8\xAD\xE6\x96\x87\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<String>("中文".to_string());
t
}))
);
assert_eq!(
tuple(b"\x02\xCE\xBC\xCE\xAC\xCE\xB8\xCE\xB7\xCE\xBC\xCE\xB1\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<String>("μάθημα".to_string());
t
}))
);
assert_eq!(
tuple(b"\x02\xF4\x8F\xBF\xBF\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<String>("\u{10ffff}".to_string());
t
}))
);
assert_eq!(
tuple(b"\x05\x00\xFF\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<Tuple>({
let mut t1 = Tuple::new();
t1.push_back::<Null>(Null);
t1
});
t
}))
);
assert_eq!(
tuple(b"\x05\x00\xFF\x02hello\x00\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<Tuple>({
let mut t1 = Tuple::new();
t1.push_back::<Null>(Null);
t1.push_back::<String>("hello".to_string());
t1
});
t
}))
);
assert_eq!(
tuple(b"\x05\x00\xFF\x02hell\x00\xFF\x00\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<Tuple>({
let mut t1 = Tuple::new();
t1.push_back::<Null>(Null);
t1.push_back::<String>("hell\x00".to_string());
t1
});
t
}))
);
assert_eq!(
tuple(b"\x05\x00\xFF\x00\x02hello\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<Tuple>({
let mut t1 = Tuple::new();
t1.push_back::<Null>(Null);
t1
});
t.push_back::<String>("hello".to_string());
t
}))
);
assert_eq!(
tuple(b"\x05\x00\xFF\x00\x02hello\x00\x01\x01\x00\xFF\x00\x01\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<Tuple>({
let mut t1 = Tuple::new();
t1.push_back::<Null>(Null);
t1
});
t.push_back::<String>("hello".to_string());
t.push_back::<Bytes>(Bytes::from_static(&b"\x01\x00"[..]));
t.push_back::<Bytes>(Bytes::new());
t
}))
);
assert_eq!(
tuple(b"\x30\xFF\xFF\xFF\xFF\xBA\x5E\xBA\x11\x00\x00\x00\x00\x5C\xA1\xAB\x1E"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<Uuid>(
Uuid::parse_str("ffffffff-ba5e-ba11-0000-00005ca1ab1e").unwrap(),
);
t
}))
);
assert_eq!(
tuple(b"\x26"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<bool>(false);
t
}))
);
assert_eq!(
tuple(b"\x27"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<bool>(true);
t
}))
);
assert_eq!(
tuple(b"\x15\x03"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<i8>(3);
t
}))
);
assert_eq!(
tuple(b"\x33\xAA\xBB\xCC\xDD\xEE\xFF\x00\x01\x02\x03\x00\x00"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<Versionstamp>(Versionstamp::complete(
Bytes::from_static(&b"\xAA\xBB\xCC\xDD\xEE\xFF\x00\x01\x02\x03"[..]),
0,
));
t
}))
);
assert_eq!(
tuple(b"\x33\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x02\x91"),
Ok((&b""[..], {
let mut t = Tuple::new();
t.push_back::<Versionstamp>(Versionstamp::complete(
Bytes::from_static(&b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A"[..]),
657,
));
t
}))
);
}
#[test]
fn test_null_value() {
assert_eq!(
null_value(b"\x00moredata"),
Ok((&b"moredata"[..], TupleValue::NullValue))
);
assert_eq!(
null_value(b"no_null_value"),
Err(nom::Err::Error(Error::new(
&b"no_null_value"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::null_value(null_value(b"\x00moredata").unwrap().1),
Ok(())
);
}
#[test]
fn test_nested_tuple_null_value() {
assert_eq!(
nested_tuple_null_value(b"\x00\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::NullValue))
);
assert_eq!(
null_value(b"no_nested_tuple_null_value"),
Err(nom::Err::Error(Error::new(
&b"no_nested_tuple_null_value"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::nested_tuple_null_value(
nested_tuple_null_value(b"\x00\xFFmoredata").unwrap().1
),
Ok(())
);
}
#[test]
fn test_byte_string() {
assert_eq!(
byte_string(b"\x01\x00"),
Ok((&b""[..], TupleValue::ByteString(Bytes::new())))
);
assert_eq!(
byte_string(b"\x01\x00moredata"),
Ok((&b"moredata"[..], TupleValue::ByteString(Bytes::new())))
);
assert_eq!(
byte_string(b"\x01\x01\x02\x03\x00"),
Ok((
&b""[..],
TupleValue::ByteString(Bytes::from_static(b"\x01\x02\x03"))
))
);
assert_eq!(
byte_string(b"\x01\x01\x02\x03\x00moredata"),
Ok((
&b"moredata"[..],
TupleValue::ByteString(Bytes::from_static(b"\x01\x02\x03"))
))
);
assert_eq!(
byte_string(b"\x01\x00\xFF\x00\xFF\x00\xFF\x04\x00"),
Ok((
&b""[..],
TupleValue::ByteString(Bytes::from_static(b"\x00\x00\x00\x04"))
))
);
assert_eq!(
byte_string(b"\x01\x00\xFF\x00\xFF\x00\xFF\x04\x00moredata"),
Ok((
&b"moredata"[..],
TupleValue::ByteString(Bytes::from_static(b"\x00\x00\x00\x04"))
))
);
assert_eq!(
byte_string(b"no_byte_string"),
Err(nom::Err::Error(Error::new(
&b"no_byte_string"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::byte_string(
byte_string(b"\x01\x01\x02\x03\x00moredata").unwrap().1
)
.unwrap(),
Bytes::from_static(b"\x01\x02\x03")
);
}
#[test]
fn test_unicode_string() {
assert_eq!(
unicode_string(b"\x02\x00"),
Ok((&b""[..], TupleValue::UnicodeString("".to_string())))
);
assert_eq!(
unicode_string(b"\x02\x00moredata"),
Ok((&b"moredata"[..], TupleValue::UnicodeString("".to_string())))
);
assert_eq!(
unicode_string(b"\x02hello\x00"),
Ok((&b""[..], TupleValue::UnicodeString("hello".to_string())))
);
assert_eq!(
unicode_string(b"\x02hello\x00moredata"),
Ok((
&b"moredata"[..],
TupleValue::UnicodeString("hello".to_string())
))
);
assert_eq!(
unicode_string(b"\x02\xE4\xB8\xAD\xE6\x96\x87\x00"),
Ok((&b""[..], TupleValue::UnicodeString("中文".to_string())))
);
assert_eq!(
unicode_string(b"\x02\xE4\xB8\xAD\xE6\x96\x87\x00moredata"),
Ok((
&b"moredata"[..],
TupleValue::UnicodeString("中文".to_string())
))
);
assert_eq!(
unicode_string(b"\x02\xCE\xBC\xCE\xAC\xCE\xB8\xCE\xB7\xCE\xBC\xCE\xB1\x00"),
Ok((&b""[..], TupleValue::UnicodeString("μάθημα".to_string())))
);
assert_eq!(
unicode_string(b"\x02\xCE\xBC\xCE\xAC\xCE\xB8\xCE\xB7\xCE\xBC\xCE\xB1\x00moredata"),
Ok((
&b"moredata"[..],
TupleValue::UnicodeString("μάθημα".to_string())
))
);
assert_eq!(
byte_string(b"no_unicode_string"),
Err(nom::Err::Error(Error::new(
&b"no_unicode_string"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::unicode_string(
unicode_string(b"\x02hello\x00moredata").unwrap().1
)
.unwrap(),
"hello".to_string()
);
}
#[test]
fn test_nested_tuple() {
assert_eq!(
nested_tuple(b"\x05\x00\xFF\x00"),
Ok((
&b""[..],
TupleValue::NestedTuple(Tuple::from_elements(vec![TupleValue::NullValue]))
))
);
assert_eq!(
nested_tuple(b"\x05\x00\xFF\x00moredata"),
Ok((
&b"moredata"[..],
TupleValue::NestedTuple(Tuple::from_elements(vec![TupleValue::NullValue]))
))
);
assert_eq!(
nested_tuple(b"\x05\x00\xFF\x02hello\x00\x00"),
Ok((
&b""[..],
TupleValue::NestedTuple(Tuple::from_elements(vec![
TupleValue::NullValue,
TupleValue::UnicodeString("hello".to_string()),
]))
))
);
assert_eq!(
nested_tuple(b"\x05\x00\xFF\x02hello\x00\x00moredata"),
Ok((
&b"moredata"[..],
TupleValue::NestedTuple(Tuple::from_elements(vec![
TupleValue::NullValue,
TupleValue::UnicodeString("hello".to_string()),
]))
))
);
assert_eq!(
nested_tuple(b"\x05\x00\xFF\x02hell\x00\xFF\x00\x00"),
Ok((
&b""[..],
TupleValue::NestedTuple(Tuple::from_elements(vec![
TupleValue::NullValue,
TupleValue::UnicodeString("hell\u{0}".to_string()),
]))
))
);
assert_eq!(
nested_tuple(b"\x05\x00\xFF\x02hell\x00\xFF\x00\x00moredata"),
Ok((
&b"moredata"[..],
TupleValue::NestedTuple(Tuple::from_elements(vec![
TupleValue::NullValue,
TupleValue::UnicodeString("hell\u{0}".to_string()),
]))
))
);
assert_eq!(
nested_tuple(b"\x05\x00\xFF\x34hello\x00\x00"),
Err(nom::Err::Error(nom::error::Error::new(
&b"\x34hello\x00\x00"[..],
nom::error::ErrorKind::Fail
)))
);
assert_eq!(
nested_tuple(b"\x05"),
Err(nom::Err::Error(nom::error::Error::new(
&b""[..],
nom::error::ErrorKind::Eof
)))
);
assert_eq!(
nested_tuple(b"no_nested_tuple"),
Err(nom::Err::Error(Error::new(
&b"no_nested_tuple"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::nested_tuple(
nested_tuple(b"\x05\x00\xFF\x02hell\x00\xFF\x00\x00moredata")
.unwrap()
.1
)
.unwrap(),
Tuple::from_elements(vec![
TupleValue::NullValue,
TupleValue::UnicodeString("hell\u{0}".to_string())
])
);
}
#[test]
fn test_negative_arbitrary_precision_integer() {
assert_eq!(
negative_arbitrary_precision_integer(
b"\x0B\xF6\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFFmoredata"
),
Ok((
&b"moredata"[..],
TupleValue::NegativeArbitraryPrecisionInteger(
BigInt::parse_bytes(b"18446744073709551616", 10).unwrap()
)
))
);
assert_eq!(
positive_arbitrary_precision_integer(b"no_negative_arbitrary_precision_integer"),
Err(nom::Err::Error(Error::new(
&b"no_negative_arbitrary_precision_integer"[..],
ErrorKind::Tag
)))
);
assert_eq!(
negative_arbitrary_precision_integer(b"\x0B\xF6\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),
Err(nom::Err::Error(nom::error::Error::new(
&b"\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF"[..],
nom::error::ErrorKind::Eof
)))
);
assert_eq!(
tuple_extractor::negative_arbitrary_precision_integer(
negative_arbitrary_precision_integer(
b"\x0B\xF6\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFFmoredata"
)
.unwrap()
.1
)
.unwrap(),
BigInt::parse_bytes(b"-18446744073709551616", 10).unwrap()
);
}
#[test]
fn test_neg_int_8() {
assert_eq!(
neg_int_8(b"\x0C\x00\x00\x00\x00\x00\x00\x00\x00moredata"),
Ok((&b"moredata"[..], TupleValue::NegInt8(18446744073709551615)))
);
assert_eq!(
neg_int_8(b"\x0C\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::NegInt8(72057594037927936)))
);
assert_eq!(
neg_int_8(b"no_neg_int_8"),
Err(nom::Err::Error(Error::new(
&b"no_neg_int_8"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::neg_int_8_bigint(
neg_int_8(b"\x0C\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFEmoredata")
.unwrap()
.1
)
.unwrap(),
BigInt::parse_bytes(b"-9223372036854775809", 10).unwrap()
);
assert_eq!(
tuple_extractor::neg_int_8_i64(
neg_int_8(b"\x0C\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFFmoredata")
.unwrap()
.1
)
.unwrap(),
-9223372036854775808i64
);
}
#[test]
fn test_neg_int_7() {
assert_eq!(
neg_int_7(b"\x0D\x00\x00\x00\x00\x00\x00\x00moredata"),
Ok((&b"moredata"[..], TupleValue::NegInt7(72057594037927935)))
);
assert_eq!(
neg_int_7(b"\x0D\xFE\xFF\xFF\xFF\xFF\xFF\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::NegInt7(281474976710656)))
);
assert_eq!(
neg_int_7(b"no_neg_int_7"),
Err(nom::Err::Error(Error::new(
&b"no_neg_int_7"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::neg_int_7_i64(
neg_int_7(b"\x0D\x00\x00\x00\x00\x00\x00\x00moredata")
.unwrap()
.1
)
.unwrap(),
-72057594037927935i64
);
assert_eq!(
tuple_extractor::neg_int_7_i64(
neg_int_7(b"\x0D\xFE\xFF\xFF\xFF\xFF\xFF\xFFmoredata")
.unwrap()
.1
)
.unwrap(),
-281474976710656i64
);
}
#[test]
fn test_neg_int_6() {
assert_eq!(
neg_int_6(b"\x0E\x00\x00\x00\x00\x00\x00moredata"),
Ok((&b"moredata"[..], TupleValue::NegInt6(281474976710655)))
);
assert_eq!(
neg_int_6(b"\x0E\xFE\xFF\xFF\xFF\xFF\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::NegInt6(1099511627776)))
);
assert_eq!(
neg_int_6(b"no_neg_int_6"),
Err(nom::Err::Error(Error::new(
&b"no_neg_int_6"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::neg_int_6_i64(
neg_int_6(b"\x0E\x00\x00\x00\x00\x00\x00moredata")
.unwrap()
.1
)
.unwrap(),
-281474976710655i64
);
assert_eq!(
tuple_extractor::neg_int_6_i64(
neg_int_6(b"\x0E\xFE\xFF\xFF\xFF\xFF\xFFmoredata")
.unwrap()
.1
)
.unwrap(),
-1099511627776i64
);
}
#[test]
fn test_neg_int_5() {
assert_eq!(
neg_int_5(b"\x0F\x00\x00\x00\x00\x00moredata"),
Ok((&b"moredata"[..], TupleValue::NegInt5(1099511627775)))
);
assert_eq!(
neg_int_5(b"\x0F\xFE\xFF\xFF\xFF\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::NegInt5(4294967296)))
);
assert_eq!(
neg_int_5(b"no_neg_int_5"),
Err(nom::Err::Error(Error::new(
&b"no_neg_int_5"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::neg_int_5_i64(
neg_int_5(b"\x0F\x00\x00\x00\x00\x00moredata").unwrap().1
)
.unwrap(),
-1099511627775i64
);
assert_eq!(
tuple_extractor::neg_int_5_i64(
neg_int_5(b"\x0F\xFE\xFF\xFF\xFF\xFFmoredata").unwrap().1
)
.unwrap(),
-4294967296i64
);
}
#[test]
fn test_neg_int_4() {
assert_eq!(
neg_int_4(b"\x10\x00\x00\x00\x00moredata"),
Ok((&b"moredata"[..], TupleValue::NegInt4(4294967295)))
);
assert_eq!(
neg_int_4(b"\x10\xFE\xFF\xFF\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::NegInt4(16777216)))
);
assert_eq!(
neg_int_4(b"no_neg_int_4"),
Err(nom::Err::Error(Error::new(
&b"no_neg_int_4"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::neg_int_4_i64(
neg_int_4(b"\x10\x7F\xFF\xFF\xFEmoredata").unwrap().1
)
.unwrap(),
-2147483649i64
);
assert_eq!(
tuple_extractor::neg_int_4_i32(
neg_int_4(b"\x10\x7F\xFF\xFF\xFFmoredata").unwrap().1
)
.unwrap(),
-2147483648i32
);
}
#[test]
fn test_neg_int_3() {
assert_eq!(
neg_int_3(b"\x11\x00\x00\x00moredata"),
Ok((&b"moredata"[..], TupleValue::NegInt3(16777215)))
);
assert_eq!(
neg_int_3(b"\x11\xFE\xFF\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::NegInt3(65536)))
);
assert_eq!(
neg_int_3(b"no_neg_int_3"),
Err(nom::Err::Error(Error::new(
&b"no_neg_int_3"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::neg_int_3_i32(neg_int_3(b"\x11\x00\x00\x00moredata").unwrap().1)
.unwrap(),
-16777215i32
);
assert_eq!(
tuple_extractor::neg_int_3_i32(neg_int_3(b"\x11\xFE\xFF\xFFmoredata").unwrap().1)
.unwrap(),
-65536i32
);
}
#[test]
fn test_neg_int_2() {
assert_eq!(
neg_int_2(b"\x12\x00\x00moredata"),
Ok((&b"moredata"[..], TupleValue::NegInt2(65535)))
);
assert_eq!(
neg_int_2(b"\x12\xFE\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::NegInt2(256)))
);
assert_eq!(
neg_int_2(b"no_neg_int_2"),
Err(nom::Err::Error(Error::new(
&b"no_neg_int_2"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::neg_int_2_i32(neg_int_2(b"\x12\x7F\xFEmoredata").unwrap().1)
.unwrap(),
-32769i32
);
assert_eq!(
tuple_extractor::neg_int_2_i16(neg_int_2(b"\x12\x7F\xFFmoredata").unwrap().1)
.unwrap(),
-32768i16
);
}
#[test]
fn test_neg_int_1() {
assert_eq!(
neg_int_1(b"\x13\x00moredata"),
Ok((&b"moredata"[..], TupleValue::NegInt1(255)))
);
assert_eq!(
neg_int_1(b"\x13\xFEmoredata"),
Ok((&b"moredata"[..], TupleValue::NegInt1(1)))
);
assert_eq!(
neg_int_1(b"no_neg_int_1"),
Err(nom::Err::Error(Error::new(
&b"no_neg_int_1"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::neg_int_1_i16(neg_int_1(b"\x13\x7Emoredata").unwrap().1).unwrap(),
-129i16
);
assert_eq!(
tuple_extractor::neg_int_1_i8(neg_int_1(b"\x13\x7Fmoredata").unwrap().1).unwrap(),
-128i8
);
}
#[test]
fn test_int_zero() {
assert_eq!(
int_zero(b"\x14moredata"),
Ok((&b"moredata"[..], TupleValue::IntZero))
);
assert_eq!(
int_zero(b"no_int_zero"),
Err(nom::Err::Error(Error::new(
&b"no_int_zero"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::int_zero(int_zero(b"\x14moredata").unwrap().1).unwrap(),
0
);
}
#[test]
fn test_pos_int_1() {
assert_eq!(
pos_int_1(b"\x15\x01moredata"),
Ok((&b"moredata"[..], TupleValue::PosInt1(1)))
);
assert_eq!(
pos_int_1(b"\x15\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::PosInt1(255)))
);
assert_eq!(
pos_int_1(b"no_pos_int_1"),
Err(nom::Err::Error(Error::new(
&b"no_pos_int_1"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::pos_int_1_i8(pos_int_1(b"\x15\x7Fmoredata").unwrap().1).unwrap(),
127i8
);
assert_eq!(
tuple_extractor::pos_int_1_i16(pos_int_1(b"\x15\x80moredata").unwrap().1).unwrap(),
128i16
);
}
#[test]
fn test_pos_int_2() {
assert_eq!(
pos_int_2(b"\x16\x01\x00moredata"),
Ok((&b"moredata"[..], TupleValue::PosInt2(256)))
);
assert_eq!(
pos_int_2(b"\x16\xFF\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::PosInt2(65535)))
);
assert_eq!(
pos_int_2(b"no_pos_int_2"),
Err(nom::Err::Error(Error::new(
&b"no_pos_int_2"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::pos_int_2_i16(pos_int_2(b"\x16\x7F\xFFmoredata").unwrap().1)
.unwrap(),
32767i16
);
assert_eq!(
tuple_extractor::pos_int_2_i32(pos_int_2(b"\x16\x80\x00moredata").unwrap().1)
.unwrap(),
32768i32
);
}
#[test]
fn test_pos_int_3() {
assert_eq!(
pos_int_3(b"\x17\x01\x00\x00moredata"),
Ok((&b"moredata"[..], TupleValue::PosInt3(65536)))
);
assert_eq!(
pos_int_3(b"\x17\xFF\xFF\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::PosInt3(16777215)))
);
assert_eq!(
pos_int_3(b"no_pos_int_3"),
Err(nom::Err::Error(Error::new(
&b"no_pos_int_3"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::pos_int_3_i32(pos_int_3(b"\x17\x01\x00\x00moredata").unwrap().1)
.unwrap(),
65536i32
);
assert_eq!(
tuple_extractor::pos_int_3_i32(pos_int_3(b"\x17\xFF\xFF\xFFmoredata").unwrap().1)
.unwrap(),
16777215i32,
);
}
#[test]
fn test_pos_int_4() {
assert_eq!(
pos_int_4(b"\x18\x01\x00\x00\x00moredata"),
Ok((&b"moredata"[..], TupleValue::PosInt4(16777216)))
);
assert_eq!(
pos_int_4(b"\x18\xFF\xFF\xFF\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::PosInt4(4294967295)))
);
assert_eq!(
pos_int_4(b"no_pos_int_4"),
Err(nom::Err::Error(Error::new(
&b"no_pos_int_4"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::pos_int_4_i32(
pos_int_4(b"\x18\x7F\xFF\xFF\xFFmoredata").unwrap().1
)
.unwrap(),
2147483647i32
);
assert_eq!(
tuple_extractor::pos_int_4_i64(
pos_int_4(b"\x18\x80\x00\x00\x00moredata").unwrap().1
)
.unwrap(),
2147483648i64
);
}
#[test]
fn test_pos_int_5() {
assert_eq!(
pos_int_5(b"\x19\x01\x00\x00\x00\x00moredata"),
Ok((&b"moredata"[..], TupleValue::PosInt5(4294967296)))
);
assert_eq!(
pos_int_5(b"\x19\xFF\xFF\xFF\xFF\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::PosInt5(1099511627775)))
);
assert_eq!(
pos_int_5(b"no_pos_int_5"),
Err(nom::Err::Error(Error::new(
&b"no_pos_int_5"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::pos_int_5_i64(
pos_int_5(b"\x19\x01\x00\x00\x00\x00moredata").unwrap().1
)
.unwrap(),
4294967296i64
);
assert_eq!(
tuple_extractor::pos_int_5_i64(
pos_int_5(b"\x19\xFF\xFF\xFF\xFF\xFFmoredata").unwrap().1
)
.unwrap(),
1099511627775i64
);
}
#[test]
fn test_pos_int_6() {
assert_eq!(
pos_int_6(b"\x1A\x01\x00\x00\x00\x00\x00moredata"),
Ok((&b"moredata"[..], TupleValue::PosInt6(1099511627776)))
);
assert_eq!(
pos_int_6(b"\x1A\xFF\xFF\xFF\xFF\xFF\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::PosInt6(281474976710655)))
);
assert_eq!(
pos_int_6(b"no_pos_int_6"),
Err(nom::Err::Error(Error::new(
&b"no_pos_int_6"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::pos_int_6_i64(
pos_int_6(b"\x1A\x01\x00\x00\x00\x00\x00moredata")
.unwrap()
.1
)
.unwrap(),
1099511627776i64
);
assert_eq!(
tuple_extractor::pos_int_6_i64(
pos_int_6(b"\x1A\xFF\xFF\xFF\xFF\xFF\xFFmoredata")
.unwrap()
.1
)
.unwrap(),
281474976710655i64
);
}
#[test]
fn test_pos_int_7() {
assert_eq!(
pos_int_7(b"\x1B\x01\x00\x00\x00\x00\x00\x00moredata"),
Ok((&b"moredata"[..], TupleValue::PosInt7(281474976710656)))
);
assert_eq!(
pos_int_7(b"\x1B\xFF\xFF\xFF\xFF\xFF\xFF\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::PosInt7(72057594037927935)))
);
assert_eq!(
pos_int_7(b"no_pos_int_7"),
Err(nom::Err::Error(Error::new(
&b"no_pos_int_7"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::pos_int_7_i64(
pos_int_7(b"\x1B\x01\x00\x00\x00\x00\x00\x00moredata")
.unwrap()
.1
)
.unwrap(),
281474976710656i64
);
assert_eq!(
tuple_extractor::pos_int_7_i64(
pos_int_7(b"\x1B\xFF\xFF\xFF\xFF\xFF\xFF\xFFmoredata")
.unwrap()
.1
)
.unwrap(),
72057594037927935i64
);
}
#[test]
fn test_pos_int_8() {
assert_eq!(
pos_int_8(b"\x1C\x01\x00\x00\x00\x00\x00\x00\x00moredata"),
Ok((&b"moredata"[..], TupleValue::PosInt8(72057594037927936)))
);
assert_eq!(
pos_int_8(b"\x1C\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFFmoredata"),
Ok((&b"moredata"[..], TupleValue::PosInt8(18446744073709551615)))
);
assert_eq!(
pos_int_8(b"no_pos_int_8"),
Err(nom::Err::Error(Error::new(
&b"no_pos_int_8"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::pos_int_8_i64(
pos_int_8(b"\x1C\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFFmoredata")
.unwrap()
.1
)
.unwrap(),
9223372036854775807i64
);
assert_eq!(
tuple_extractor::pos_int_8_bigint(
pos_int_8(b"\x1C\x80\x00\x00\x00\x00\x00\x00\x00moredata")
.unwrap()
.1
)
.unwrap(),
BigInt::parse_bytes(b"9223372036854775808", 10).unwrap()
);
}
#[test]
fn test_positive_arbitrary_precision_integer() {
assert_eq!(
positive_arbitrary_precision_integer(
b"\x1D\x09\x01\x00\x00\x00\x00\x00\x00\x00\x00moredata"
),
Ok((
&b"moredata"[..],
TupleValue::PositiveArbitraryPrecisionInteger(
BigInt::parse_bytes(b"18446744073709551616", 10).unwrap()
)
))
);
assert_eq!(
positive_arbitrary_precision_integer(b"no_positive_arbitrary_precision_integer"),
Err(nom::Err::Error(Error::new(
&b"no_positive_arbitrary_precision_integer"[..],
ErrorKind::Tag
)))
);
assert_eq!(
positive_arbitrary_precision_integer(b"\x1D\x09\x01\x00\x00\x00\x00\x00\x00\x00"),
Err(nom::Err::Incomplete(nom::Needed::Size(
NonZeroUsize::new(1).unwrap()
)))
);
assert_eq!(
tuple_extractor::positive_arbitrary_precision_integer(
positive_arbitrary_precision_integer(
b"\x1D\x09\x01\x00\x00\x00\x00\x00\x00\x00\x00moredata"
)
.unwrap()
.1
)
.unwrap(),
BigInt::parse_bytes(b"18446744073709551616", 10).unwrap()
);
}
#[allow(clippy::approx_constant)]
#[test]
fn test_ieee_binary_floating_point_float() {
assert_eq!(
ieee_binary_floating_point_float(b"\x20\xC0\x48\xF5\xC3moredata"),
Ok((
&b"moredata"[..],
TupleValue::IeeeBinaryFloatingPointFloat(3.14f32)
))
);
assert_eq!(
ieee_binary_floating_point_float(b"\x20\x3F\xB7\x0A\x3Cmoredata"),
Ok((
&b"moredata"[..],
TupleValue::IeeeBinaryFloatingPointFloat(-3.14f32)
))
);
assert_eq!(
ieee_binary_floating_point_float(b"\x20\x80\x00\x00\x00moredata"),
Ok((
&b"moredata"[..],
TupleValue::IeeeBinaryFloatingPointFloat(0.0f32)
))
);
assert_eq!(
ieee_binary_floating_point_float(b"\x20\x7F\xFF\xFF\xFFmoredata"),
Ok((
&b"moredata"[..],
TupleValue::IeeeBinaryFloatingPointFloat(-0.0f32)
))
);
assert_eq!(
ieee_binary_floating_point_float(b"\x20\xFF\x80\x00\x00moredata"),
Ok((
&b"moredata"[..],
TupleValue::IeeeBinaryFloatingPointFloat(f32::INFINITY)
))
);
assert_eq!(
ieee_binary_floating_point_float(b"\x20\x00\x7F\xFF\xFFmoredata"),
Ok((
&b"moredata"[..],
TupleValue::IeeeBinaryFloatingPointFloat(f32::NEG_INFINITY)
))
);
assert_eq!(
ieee_binary_floating_point_float(b"no_ieee_binary_floating_point_float"),
Err(nom::Err::Error(Error::new(
&b"no_ieee_binary_floating_point_float"[..],
ErrorKind::Tag
)))
);
assert_eq!(
ieee_binary_floating_point_float(b"\x20\xC0\x48\xF5"),
Err(nom::Err::Error(nom::error::Error::new(
&b"\xC0\x48\xF5"[..],
nom::error::ErrorKind::Eof
)))
);
assert_eq!(
tuple_extractor::ieee_binary_floating_point_float(
ieee_binary_floating_point_float(b"\x20\xC0\x48\xF5\xC3moredata")
.unwrap()
.1
)
.unwrap(),
3.14f32
);
}
#[allow(clippy::approx_constant)]
#[test]
fn test_ieee_binary_floating_point_double() {
assert_eq!(
ieee_binary_floating_point_double(b"\x21\xC0\x09\x1E\xB8\x51\xEB\x85\x1Fmoredata"),
Ok((
&b"moredata"[..],
TupleValue::IeeeBinaryFloatingPointDouble(3.14f64)
))
);
assert_eq!(
ieee_binary_floating_point_double(b"\x21\x3F\xF6\xE1\x47\xAE\x14\x7A\xE0moredata"),
Ok((
&b"moredata"[..],
TupleValue::IeeeBinaryFloatingPointDouble(-3.14f64)
))
);
assert_eq!(
ieee_binary_floating_point_double(b"\x21\x80\x00\x00\x00\x00\x00\x00\x00moredata"),
Ok((
&b"moredata"[..],
TupleValue::IeeeBinaryFloatingPointDouble(0.0f64)
))
);
assert_eq!(
ieee_binary_floating_point_double(b"\x21\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFFmoredata"),
Ok((
&b"moredata"[..],
TupleValue::IeeeBinaryFloatingPointDouble(-0.0f64)
))
);
assert_eq!(
ieee_binary_floating_point_double(b"\x21\xFF\xF0\x00\x00\x00\x00\x00\x00moredata"),
Ok((
&b"moredata"[..],
TupleValue::IeeeBinaryFloatingPointDouble(f64::INFINITY)
))
);
assert_eq!(
ieee_binary_floating_point_double(b"\x21\x00\x0F\xFF\xFF\xFF\xFF\xFF\xFFmoredata"),
Ok((
&b"moredata"[..],
TupleValue::IeeeBinaryFloatingPointDouble(f64::NEG_INFINITY)
))
);
assert_eq!(
ieee_binary_floating_point_double(b"no_ieee_binary_floating_point_double"),
Err(nom::Err::Error(Error::new(
&b"no_ieee_binary_floating_point_double"[..],
ErrorKind::Tag
)))
);
assert_eq!(
ieee_binary_floating_point_double(b"\x21\xC0\x09\x1E\xB8\x51\xEB\x85"),
Err(nom::Err::Error(nom::error::Error::new(
&b"\xC0\x09\x1E\xB8\x51\xEB\x85"[..],
nom::error::ErrorKind::Eof
)))
);
assert_eq!(
tuple_extractor::ieee_binary_floating_point_double(
ieee_binary_floating_point_double(
b"\x21\xC0\x09\x1E\xB8\x51\xEB\x85\x1Fmoredata"
)
.unwrap()
.1
)
.unwrap(),
3.14f64
);
}
#[test]
fn test_false_value() {
assert_eq!(
false_value(b"\x26moredata"),
Ok((&b"moredata"[..], TupleValue::FalseValue))
);
assert_eq!(
false_value(b"no_false_value"),
Err(nom::Err::Error(Error::new(
&b"no_false_value"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::false_value(false_value(b"\x26moredata").unwrap().1),
Ok(false)
);
}
#[test]
fn test_true_value() {
assert_eq!(
true_value(b"\x27moredata"),
Ok((&b"moredata"[..], TupleValue::TrueValue))
);
assert_eq!(
true_value(b"no_true_value"),
Err(nom::Err::Error(Error::new(
&b"no_true_value"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::true_value(true_value(b"\x27moredata").unwrap().1),
Ok(true)
);
}
#[test]
fn test_rfc_4122_uuid() {
assert_eq!(
rfc_4122_uuid(
b"\x30\xFF\xFF\xFF\xFF\xBA\x5E\xBA\x11\x00\x00\x00\x00\x5C\xA1\xAB\x1Emoredata"
),
Ok((
&b"moredata"[..],
TupleValue::Rfc4122Uuid(
Uuid::parse_str("ffffffff-ba5e-ba11-0000-00005ca1ab1e").unwrap()
)
))
);
assert_eq!(
rfc_4122_uuid(b"no_rfc_4122_uuid"),
Err(nom::Err::Error(Error::new(
&b"no_rfc_4122_uuid"[..],
ErrorKind::Tag
)))
);
assert_eq!(
rfc_4122_uuid(b"\x30\xFF\xFF\xFF\xFF\xBA\x5E\xBA\x11\x00\x00\x00\x00\x5C\xA1\xAB"),
Err(nom::Err::Error(nom::error::Error::new(
&b"\xFF\xFF\xFF\xFF\xBA\x5E\xBA\x11\x00\x00\x00\x00\x5C\xA1\xAB"[..],
nom::error::ErrorKind::Eof
)))
);
assert_eq!(
tuple_extractor::rfc_4122_uuid(
rfc_4122_uuid(
b"\x30\xFF\xFF\xFF\xFF\xBA\x5E\xBA\x11\x00\x00\x00\x00\x5C\xA1\xAB\x1Emoredata").unwrap().1
).unwrap(),
Uuid::parse_str("ffffffff-ba5e-ba11-0000-00005ca1ab1e").unwrap()
);
}
#[test]
fn test_versionstamp_96_bit() {
assert_eq!(
versionstamp_96_bit(
b"\x33\xAA\xBB\xCC\xDD\xEE\xFF\x00\x01\x02\x03\x00\x00moredata"
),
Ok((
&b"moredata"[..],
TupleValue::Versionstamp96Bit(Versionstamp::complete(
Bytes::from_static(&b"\xAA\xBB\xCC\xDD\xEE\xFF\x00\x01\x02\x03"[..]),
0
))
))
);
assert_eq!(
versionstamp_96_bit(
b"\x33\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x02\x91moredata"
),
Ok((
&b"moredata"[..],
TupleValue::Versionstamp96Bit(Versionstamp::complete(
Bytes::from_static(&b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A"[..]),
657
))
))
);
assert_eq!(
versionstamp_96_bit(
b"\x33\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x91moredata"
),
Ok((
&b"moredata"[..],
TupleValue::Versionstamp96Bit(Versionstamp::incomplete(657))
))
);
assert_eq!(
versionstamp_96_bit(b"no_versionstamp_96_bit"),
Err(nom::Err::Error(Error::new(
&b"no_versionstamp_96_bit"[..],
ErrorKind::Tag
)))
);
assert_eq!(
tuple_extractor::versionstamp_96_bit(
versionstamp_96_bit(
b"\x33\xAA\xBB\xCC\xDD\xEE\xFF\x00\x01\x02\x03\x00\x00moredata"
)
.unwrap()
.1
)
.unwrap(),
Versionstamp::complete(
Bytes::from_static(b"\xAA\xBB\xCC\xDD\xEE\xFF\x00\x01\x02\x03"),
0
)
);
}
pub(self) mod tuple_extractor {
use super::TupleValue;
use crate::error::{FdbError, FdbResult};
use crate::tuple::{Tuple, Versionstamp};
use bytes::Bytes;
use num_bigint::BigInt;
use std::convert::TryInto;
use uuid::Uuid;
const TUPLE_EXTRACTOR: i32 = 0xFFFF;
fn tuple_extractor_error() -> FdbError {
FdbError::new(TUPLE_EXTRACTOR)
}
pub(crate) fn null_value(tv: TupleValue) -> FdbResult<()> {
if let TupleValue::NullValue = tv {
Ok(())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn nested_tuple_null_value(tv: TupleValue) -> FdbResult<()> {
if let TupleValue::NullValue = tv {
Ok(())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn byte_string(tv: TupleValue) -> FdbResult<Bytes> {
if let TupleValue::ByteString(i) = tv {
Ok(i)
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn unicode_string(tv: TupleValue) -> FdbResult<String> {
if let TupleValue::UnicodeString(i) = tv {
Ok(i)
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn nested_tuple(tv: TupleValue) -> FdbResult<Tuple> {
if let TupleValue::NestedTuple(i) = tv {
Ok(i)
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn negative_arbitrary_precision_integer(
tv: TupleValue,
) -> FdbResult<BigInt> {
if let TupleValue::NegativeArbitraryPrecisionInteger(i) = tv {
Ok(i * -1)
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn neg_int_8_bigint(tv: TupleValue) -> FdbResult<BigInt> {
if let TupleValue::NegInt8(i) = tv {
Ok(Into::<BigInt>::into(i) * -1)
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn neg_int_8_i64(tv: TupleValue) -> FdbResult<i64> {
if let TupleValue::NegInt8(i) = tv {
(-Into::<i128>::into(i))
.try_into()
.map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn neg_int_7_i64(tv: TupleValue) -> FdbResult<i64> {
if let TupleValue::NegInt7(i) = tv {
i.try_into()
.map(|x: i64| -x)
.map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn neg_int_6_i64(tv: TupleValue) -> FdbResult<i64> {
if let TupleValue::NegInt6(i) = tv {
i.try_into()
.map(|x: i64| -x)
.map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn neg_int_5_i64(tv: TupleValue) -> FdbResult<i64> {
if let TupleValue::NegInt5(i) = tv {
i.try_into()
.map(|x: i64| -x)
.map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn neg_int_4_i64(tv: TupleValue) -> FdbResult<i64> {
if let TupleValue::NegInt4(i) = tv {
Ok(-Into::<i64>::into(i))
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn neg_int_4_i32(tv: TupleValue) -> FdbResult<i32> {
if let TupleValue::NegInt4(i) = tv {
(-Into::<i64>::into(i))
.try_into()
.map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn neg_int_3_i32(tv: TupleValue) -> FdbResult<i32> {
if let TupleValue::NegInt3(i) = tv {
i.try_into()
.map(|x: i32| -x)
.map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn neg_int_2_i32(tv: TupleValue) -> FdbResult<i32> {
if let TupleValue::NegInt2(i) = tv {
Ok(-Into::<i32>::into(i))
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn neg_int_2_i16(tv: TupleValue) -> FdbResult<i16> {
if let TupleValue::NegInt2(i) = tv {
(-Into::<i32>::into(i))
.try_into()
.map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn neg_int_1_i16(tv: TupleValue) -> FdbResult<i16> {
if let TupleValue::NegInt1(i) = tv {
Ok(-Into::<i16>::into(i))
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn neg_int_1_i8(tv: TupleValue) -> FdbResult<i8> {
if let TupleValue::NegInt1(i) = tv {
(-Into::<i16>::into(i))
.try_into()
.map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn int_zero(tv: TupleValue) -> FdbResult<i8> {
if let TupleValue::IntZero = tv {
Ok(0)
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn pos_int_1_i8(tv: TupleValue) -> FdbResult<i8> {
if let TupleValue::PosInt1(i) = tv {
i.try_into().map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn pos_int_1_i16(tv: TupleValue) -> FdbResult<i16> {
if let TupleValue::PosInt1(i) = tv {
Ok(i.into())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn pos_int_2_i16(tv: TupleValue) -> FdbResult<i16> {
if let TupleValue::PosInt2(i) = tv {
i.try_into().map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn pos_int_2_i32(tv: TupleValue) -> FdbResult<i32> {
if let TupleValue::PosInt2(i) = tv {
Ok(i.into())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn pos_int_3_i32(tv: TupleValue) -> FdbResult<i32> {
if let TupleValue::PosInt3(i) = tv {
i.try_into().map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn pos_int_4_i32(tv: TupleValue) -> FdbResult<i32> {
if let TupleValue::PosInt4(i) = tv {
i.try_into().map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn pos_int_4_i64(tv: TupleValue) -> FdbResult<i64> {
if let TupleValue::PosInt4(i) = tv {
Ok(i.into())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn pos_int_5_i64(tv: TupleValue) -> FdbResult<i64> {
if let TupleValue::PosInt5(i) = tv {
i.try_into().map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn pos_int_6_i64(tv: TupleValue) -> FdbResult<i64> {
if let TupleValue::PosInt6(i) = tv {
i.try_into().map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn pos_int_7_i64(tv: TupleValue) -> FdbResult<i64> {
if let TupleValue::PosInt7(i) = tv {
i.try_into().map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn pos_int_8_i64(tv: TupleValue) -> FdbResult<i64> {
if let TupleValue::PosInt8(i) = tv {
i.try_into().map_err(|_| tuple_extractor_error())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn pos_int_8_bigint(tv: TupleValue) -> FdbResult<BigInt> {
if let TupleValue::PosInt8(i) = tv {
Ok(i.into())
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn positive_arbitrary_precision_integer(
tv: TupleValue,
) -> FdbResult<BigInt> {
if let TupleValue::PositiveArbitraryPrecisionInteger(i) = tv {
Ok(i)
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn ieee_binary_floating_point_float(tv: TupleValue) -> FdbResult<f32> {
if let TupleValue::IeeeBinaryFloatingPointFloat(i) = tv {
Ok(i)
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn ieee_binary_floating_point_double(tv: TupleValue) -> FdbResult<f64> {
if let TupleValue::IeeeBinaryFloatingPointDouble(i) = tv {
Ok(i)
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn false_value(tv: TupleValue) -> FdbResult<bool> {
if let TupleValue::FalseValue = tv {
Ok(false)
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn true_value(tv: TupleValue) -> FdbResult<bool> {
if let TupleValue::TrueValue = tv {
Ok(true)
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn rfc_4122_uuid(tv: TupleValue) -> FdbResult<Uuid> {
if let TupleValue::Rfc4122Uuid(i) = tv {
Ok(i)
} else {
Err(tuple_extractor_error())
}
}
pub(crate) fn versionstamp_96_bit(tv: TupleValue) -> FdbResult<Versionstamp> {
if let TupleValue::Versionstamp96Bit(i) = tv {
Ok(i)
} else {
Err(tuple_extractor_error())
}
}
}
}
}