scale-value 0.18.2

// Copyright (C) 2022-2023 Parity Technologies (UK) Ltd. (admin@parity.io)
// This file is a part of the scale-value crate.
//
// 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 crate::prelude::*;
use either::Either;

// We use this to represent BitSequence values, so expose it here.
pub use scale_bits::Bits as BitSequence;

/// [`Value`] holds a representation of some value that has been decoded, as well as some arbitrary context.
///
/// Not all SCALE encoded types have an similar-named value; for instance, the values corresponding to
/// sequence, array and composite types can all be represented with [`Composite`]. Only enough information
/// is preserved here to to be able to encode and decode SCALE bytes with a known type to and from [`Value`]s
/// losslessly.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Value<T = ()> {
    /// The shape and associated data for this Value
    pub value: ValueDef<T>,
    /// Some additional arbitrary context that can be associated with a value.
    pub context: T,
}

impl Value<()> {
    /// Construct a named composite type from any type which produces a tuple of keys and values
    /// when iterated over.
    pub fn named_composite<S, Vals>(vals: Vals) -> Self
    where
        S: Into<String>,
        Vals: IntoIterator<Item = (S, Value<()>)>,
    {
        Value { value: ValueDef::Composite(Composite::named(vals)), context: () }
    }
    /// Construct an unnamed composite type from any type which produces values
    /// when iterated over.
    pub fn unnamed_composite<Vals>(vals: Vals) -> Self
    where
        Vals: IntoIterator<Item = Value<()>>,
    {
        Value { value: ValueDef::Composite(Composite::unnamed(vals)), context: () }
    }
    /// Create a new variant value without additional context.
    pub fn variant<S: Into<String>>(name: S, values: Composite<()>) -> Value<()> {
        Value { value: ValueDef::Variant(Variant { name: name.into(), values }), context: () }
    }
    /// Create a new variant value with named fields and without additional context.
    pub fn named_variant<S, F, Vals>(name: S, fields: Vals) -> Value<()>
    where
        S: Into<String>,
        F: Into<String>,
        Vals: IntoIterator<Item = (F, Value<()>)>,
    {
        Value { value: ValueDef::Variant(Variant::named_fields(name, fields)), context: () }
    }
    /// Create a new variant value with tuple-like fields and without additional context.
    pub fn unnamed_variant<S, Vals>(name: S, fields: Vals) -> Value<()>
    where
        S: Into<String>,
        Vals: IntoIterator<Item = Value<()>>,
    {
        Value { value: ValueDef::Variant(Variant::unnamed_fields(name, fields)), context: () }
    }
    /// Create a new bit sequence value without additional context.
    pub fn bit_sequence(bits: BitSequence) -> Value<()> {
        Value { value: ValueDef::BitSequence(bits), context: () }
    }
    /// Create a new primitive value without additional context.
    pub fn primitive(primitive: Primitive) -> Value<()> {
        Value { value: ValueDef::Primitive(primitive), context: () }
    }
    /// Create a new string value without additional context.
    pub fn string<S: Into<String>>(val: S) -> Value<()> {
        Value { value: ValueDef::Primitive(Primitive::String(val.into())), context: () }
    }
    /// Create a new boolean value without additional context.
    pub fn bool(val: bool) -> Value<()> {
        Value { value: ValueDef::Primitive(Primitive::Bool(val)), context: () }
    }
    /// Create a new char without additional context.
    pub fn char(val: char) -> Value<()> {
        Value { value: ValueDef::Primitive(Primitive::Char(val)), context: () }
    }
    /// Create a new unsigned integer without additional context.
    pub fn u128(val: u128) -> Value<()> {
        Value { value: ValueDef::Primitive(Primitive::u128(val)), context: () }
    }
    /// Create a new signed integer without additional context.
    pub fn i128(val: i128) -> Value<()> {
        Value { value: ValueDef::Primitive(Primitive::i128(val)), context: () }
    }
    /// Create a new Value from a set of bytes; useful for converting things like AccountIds.
    pub fn from_bytes(bytes: impl AsRef<[u8]>) -> Value<()> {
        let vals: Vec<_> = bytes.as_ref().iter().map(|&b| Value::u128(b as u128)).collect();
        Value::unnamed_composite(vals)
    }
}

impl Value<()> {
    /// Create a new value with no associated context.
    pub fn without_context(value: ValueDef<()>) -> Value<()> {
        Value { value, context: () }
    }
}

impl<T> Value<T> {
    /// Create a new value with some associated context.
    pub fn with_context(value: ValueDef<T>, context: T) -> Value<T> {
        Value { value, context }
    }
    /// Remove the context.
    pub fn remove_context(self) -> Value<()> {
        self.map_context(|_| ())
    }
    /// Map the context to some different type.
    pub fn map_context<F, U>(self, mut f: F) -> Value<U>
    where
        F: Clone + FnMut(T) -> U,
    {
        Value { context: f(self.context), value: self.value.map_context(f) }
    }
    /// If the value is a boolean value, return it.
    pub fn as_bool(&self) -> Option<bool> {
        match &self.value {
            ValueDef::Primitive(p) => p.as_bool(),
            _ => None,
        }
    }
    /// If the value is a char, return it.
    pub fn as_char(&self) -> Option<char> {
        match &self.value {
            ValueDef::Primitive(p) => p.as_char(),
            _ => None,
        }
    }
    /// If the value is a u128, return it.
    pub fn as_u128(&self) -> Option<u128> {
        match &self.value {
            ValueDef::Primitive(p) => p.as_u128(),
            _ => None,
        }
    }
    /// If the value is an i128, return it.
    pub fn as_i128(&self) -> Option<i128> {
        match &self.value {
            ValueDef::Primitive(p) => p.as_i128(),
            _ => None,
        }
    }
    /// If the value is a string, return it.
    pub fn as_str(&self) -> Option<&str> {
        match &self.value {
            ValueDef::Primitive(p) => p.as_str(),
            _ => None,
        }
    }
}

/// The underlying shape of a given value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ValueDef<T> {
    /// A named or unnamed struct-like, array-like or tuple-like set of values.
    Composite(Composite<T>),
    /// An enum variant.
    Variant(Variant<T>),
    /// A sequence of bits.
    BitSequence(BitSequence),
    /// Any of the primitive values we can have.
    Primitive(Primitive),
}

impl<T> ValueDef<T> {
    /// Map the context to some different type.
    pub fn map_context<F, U>(self, f: F) -> ValueDef<U>
    where
        F: Clone + FnMut(T) -> U,
    {
        match self {
            ValueDef::Composite(val) => ValueDef::Composite(val.map_context(f)),
            ValueDef::Variant(val) => ValueDef::Variant(val.map_context(f)),
            ValueDef::BitSequence(val) => ValueDef::BitSequence(val),
            ValueDef::Primitive(val) => ValueDef::Primitive(val),
        }
    }
}

impl<T> From<BitSequence> for ValueDef<T> {
    fn from(val: BitSequence) -> Self {
        ValueDef::BitSequence(val)
    }
}

impl From<BitSequence> for Value<()> {
    fn from(val: BitSequence) -> Self {
        Value::without_context(val.into())
    }
}

/// A named or unnamed struct-like, array-like or tuple-like set of values.
/// This is used to represent a range of composite values on their own, or
/// as values for a specific [`Variant`].
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Composite<T> {
    /// Eg `{ foo: 2, bar: false }`
    Named(Vec<(String, Value<T>)>),
    /// Eg `(2, false)`
    Unnamed(Vec<Value<T>>),
}

impl<T> Composite<T> {
    /// Construct a named composite type from any type which produces a tuple of keys and values
    /// when iterated over.
    pub fn named<S: Into<String>, Vals: IntoIterator<Item = (S, Value<T>)>>(vals: Vals) -> Self {
        Composite::Named(vals.into_iter().map(|(n, v)| (n.into(), v)).collect())
    }
    /// Construct an unnamed composite type from any type which produces values
    /// when iterated over.
    pub fn unnamed<Vals: IntoIterator<Item = Value<T>>>(vals: Vals) -> Self {
        Composite::Unnamed(vals.into_iter().collect())
    }
    /// Return the number of values stored in this composite type.
    pub fn len(&self) -> usize {
        match self {
            Composite::Named(values) => values.len(),
            Composite::Unnamed(values) => values.len(),
        }
    }

    /// Is the composite type empty?
    pub fn is_empty(&self) -> bool {
        match self {
            Composite::Named(values) => values.is_empty(),
            Composite::Unnamed(values) => values.is_empty(),
        }
    }

    /// Iterate over the values stored in this composite type.
    pub fn values(&self) -> impl ExactSizeIterator<Item = &Value<T>> {
        match self {
            Composite::Named(values) => Either::Left(values.iter().map(|(_k, v)| v)),
            Composite::Unnamed(values) => Either::Right(values.iter()),
        }
    }

    /// Iterate over the values stored in this composite type.
    pub fn into_values(self) -> impl ExactSizeIterator<Item = Value<T>> {
        match self {
            Composite::Named(values) => Either::Left(values.into_iter().map(|(_k, v)| v)),
            Composite::Unnamed(values) => Either::Right(values.into_iter()),
        }
    }

    /// Map the context to some different type.
    pub fn map_context<F, U>(self, f: F) -> Composite<U>
    where
        F: Clone + FnMut(T) -> U,
    {
        match self {
            Composite::Named(values) => {
                // Note: Optimally I'd pass `&mut f` into each iteration to avoid cloning,
                // but this leads to a type recusion error because F becomes `&mut F`, which can
                // (at type level) recurse here again and become `&mut &mut F` and so on. Since
                // that's no good; just require `Clone` to avoid altering the type.
                let vals =
                    values.into_iter().map(move |(k, v)| (k, v.map_context(f.clone()))).collect();
                Composite::Named(vals)
            }
            Composite::Unnamed(values) => {
                let vals = values.into_iter().map(move |v| v.map_context(f.clone())).collect();
                Composite::Unnamed(vals)
            }
        }
    }
}

impl<V: Into<Value<()>>> From<Vec<V>> for Composite<()> {
    fn from(vals: Vec<V>) -> Self {
        let vals = vals.into_iter().map(|v| v.into()).collect();
        Composite::Unnamed(vals)
    }
}

impl<V: Into<Value<()>>> From<Vec<V>> for ValueDef<()> {
    fn from(vals: Vec<V>) -> Self {
        ValueDef::Composite(vals.into())
    }
}

impl<V: Into<Value<()>>> From<Vec<V>> for Value<()> {
    fn from(vals: Vec<V>) -> Self {
        Value::without_context(vals.into())
    }
}

impl<K: Into<String>, V: Into<Value<()>>> From<Vec<(K, V)>> for Composite<()> {
    fn from(vals: Vec<(K, V)>) -> Self {
        let vals = vals.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        Composite::Named(vals)
    }
}

impl<K: Into<String>, V: Into<Value<()>>> From<Vec<(K, V)>> for ValueDef<()> {
    fn from(vals: Vec<(K, V)>) -> Self {
        ValueDef::Composite(vals.into())
    }
}

impl<K: Into<String>, V: Into<Value<()>>> From<Vec<(K, V)>> for Value<()> {
    fn from(vals: Vec<(K, V)>) -> Self {
        Value::without_context(vals.into())
    }
}

impl<T> From<Composite<T>> for ValueDef<T> {
    fn from(val: Composite<T>) -> Self {
        ValueDef::Composite(val)
    }
}

impl From<Composite<()>> for Value<()> {
    fn from(val: Composite<()>) -> Self {
        Value::without_context(ValueDef::Composite(val))
    }
}

/// This represents the value of a specific variant from an enum, and contains
/// the name of the variant, and the named/unnamed values associated with it.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Variant<T> {
    /// The name of the variant.
    pub name: String,
    /// Values for each of the named or unnamed fields associated with this variant.
    pub values: Composite<T>,
}

impl<T> Variant<T> {
    /// Construct a variant with named fields.
    pub fn named_fields<S, K, Vals>(name: S, fields: Vals) -> Variant<T>
    where
        S: Into<String>,
        K: Into<String>,
        Vals: IntoIterator<Item = (K, Value<T>)>,
    {
        Variant { name: name.into(), values: Composite::named(fields) }
    }
    /// Construct a variant with tuple-like fields.
    pub fn unnamed_fields<S, Vals>(name: S, fields: Vals) -> Variant<T>
    where
        S: Into<String>,
        Vals: IntoIterator<Item = Value<T>>,
    {
        Variant { name: name.into(), values: Composite::unnamed(fields) }
    }
    /// Map the context to some different type.
    pub fn map_context<F, U>(self, f: F) -> Variant<U>
    where
        F: Clone + FnMut(T) -> U,
    {
        Variant { name: self.name, values: self.values.map_context(f) }
    }
}

impl<T> From<Variant<T>> for ValueDef<T> {
    fn from(val: Variant<T>) -> Self {
        ValueDef::Variant(val)
    }
}

impl From<Variant<()>> for Value<()> {
    fn from(val: Variant<()>) -> Self {
        Value::without_context(ValueDef::Variant(val))
    }
}

/// A "primitive" value (this includes strings).
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Primitive {
    /// A boolean value.
    Bool(bool),
    /// A single character.
    Char(char),
    /// A string.
    String(String),
    /// A u128 value.
    U128(u128),
    /// An i128 value.
    I128(i128),
    /// An unsigned 256 bit number (internally represented as a 32 byte array).
    U256([u8; 32]),
    /// A signed 256 bit number (internally represented as a 32 byte array).
    I256([u8; 32]),
}

impl Primitive {
    /// Create a new unsigned integer without additional context.
    pub fn u128(val: u128) -> Primitive {
        Primitive::U128(val)
    }
    /// Create a new signed integer without additional context.
    pub fn i128(val: i128) -> Primitive {
        Primitive::I128(val)
    }
    /// If the primitive type is a boolean value, return it.
    pub fn as_bool(&self) -> Option<bool> {
        match self {
            Primitive::Bool(b) => Some(*b),
            _ => None,
        }
    }
    /// If the primitive type is a char, return it.
    pub fn as_char(&self) -> Option<char> {
        match self {
            Primitive::Char(c) => Some(*c),
            _ => None,
        }
    }
    /// If the primitive type is a u128, return it.
    pub fn as_u128(&self) -> Option<u128> {
        match self {
            Primitive::U128(n) => Some(*n),
            _ => None,
        }
    }
    /// If the primitive type is an i128, return it.
    pub fn as_i128(&self) -> Option<i128> {
        match self {
            Primitive::I128(n) => Some(*n),
            _ => None,
        }
    }
    /// If the primitive type is a string, return it.
    pub fn as_str(&self) -> Option<&str> {
        match self {
            Primitive::String(s) => Some(&**s),
            _ => None,
        }
    }
}

impl<T> From<Primitive> for ValueDef<T> {
    fn from(val: Primitive) -> Self {
        ValueDef::Primitive(val)
    }
}

macro_rules! impl_primitive_type {
    ($($variant:ident($ty:ty as $castty:ty),)*) => {$(
        impl From<$ty> for Primitive {
            fn from(val: $ty) -> Self {
                Primitive::$variant(val as $castty)
            }
        }

        impl<T> From<$ty> for ValueDef<T> {
            fn from(val: $ty) -> Self {
                ValueDef::Primitive(val.into())
            }
        }

        impl From<$ty> for Value<()> {
            fn from(val: $ty) -> Self {
                Value::without_context(val.into())
            }
        }
    )*}
}

impl_primitive_type!(
    Bool(bool as bool),
    Char(char as char),
    String(String as String),
    U128(u128 as u128),
    U128(u64 as u128),
    U128(usize as u128),
    U128(u32 as u128),
    U128(u16 as u128),
    U128(u8 as u128),
    I128(i128 as i128),
    I128(i64 as i128),
    I128(isize as i128),
    I128(i32 as i128),
    I128(i16 as i128),
    I128(i8 as i128),
);

// note regarding impl From<AsRef<str>>:
// a nicer generic `impl<K: Into<String>> From<K>` or `impl<K: AsRef<str>> From<K>` verson is not possible because it conflicts with the From<Bits> implementation above.

impl From<&str> for Primitive {
    fn from(val: &str) -> Self {
        Primitive::String(val.to_string())
    }
}

impl<T> From<&str> for ValueDef<T> {
    fn from(val: &str) -> Self {
        ValueDef::Primitive(val.into())
    }
}

impl From<&str> for Value<()> {
    fn from(val: &str) -> Self {
        Value::without_context(val.into())
    }
}