Enum InputValue 

pub enum InputValue<S = DefaultScalarValue> {
    Null,
    Scalar(S),
    Enum(String),
    Variable(String),
    List(Vec<Spanning<InputValue<S>>>),
    Object(Vec<(Spanning<String>, Spanning<InputValue<S>>)>),
}

A JSON-like value that can be passed into the query execution, either out-of-band, or in-band as default variable values. These are not constant and might contain variables.

Lists and objects variants are spanned, i.e. they contain a reference to their position in the source file, if available.

Variants

Null

Scalar(S)

Enum(String)

Variable(String)

List(Vec<Spanning<InputValue<S>>>)

Object(Vec<(Spanning<String>, Spanning<InputValue<S>>)>)

Implementations

impl<S> InputValue<S>

pub fn null() -> Self

Construct a null value.

pub fn scalar<T: Into<S>>(v: T) -> Self

Construct a scalar value.

pub fn enum_value<T: AsRef<str>>(s: T) -> Self

Construct an enum value.

pub fn variable<T: AsRef<str>>(v: T) -> Self

Construct a variable value.

pub fn list(l: Vec<Self>) -> Self

Construct a Spanning::unlocated list.

Convenience function to make each InputValue in the input vector not contain any location information. Can be used from ToInputValue implementations, where no source code position information is available.

pub fn parsed_list(l: Vec<Spanning<Self>>) -> Self

Construct a located list.

pub fn object<K>(o: IndexMap<K, Self>) -> Self

where K: AsRef<str> + Eq + Hash,

Construct aa Spanning::unlocated object.

Similarly to InputValue::list it makes each key and value in the given hash map not contain any location information.

pub fn parsed_object(o: Vec<(Spanning<String>, Spanning<Self>)>) -> Self

Construct a located object.

pub fn into_const(self, values: &Variables<S>) -> Option<Self>

where S: Clone,

Resolves all variables of this InputValue to their actual values.

If a variable is not present in the values:

• Returns None in case this is an InputValue::Variable.
• Skips field in case of an InputValue::Object field.
• Replaces with an InputValue::Null in case of an InputValue::List element.

This is done, because for an InputValue::Variable (or an InputValue::Object field) a default value can be used later, if it’s provided. While on contrary, a single InputValue::List element cannot have a default value.

pub fn convert<T: FromInputValue<S>>(&self) -> Result<T, T::Error>

Shorthand form of invoking FromInputValue::from_input_value().

pub fn is_null(&self) -> bool

Does the value represent a null?

pub fn is_variable(&self) -> bool

Does the value represent a variable?

pub fn as_enum_value(&self) -> Option<&str>

View the underlying enum value, if present.

pub fn as_scalar(&self) -> Option<&S>

View the underlying scalar value, if present.

pub fn to_object_value(&self) -> Option<IndexMap<&str, &Self>>

Converts this InputValue to a Spanning::unlocated object value.

This constructs a new IndexMap containing references to the keys and values of self.

pub fn to_list_value(&self) -> Option<Vec<&Self>>

Converts this InputValue to a Spanning::unlocated list value.

This constructs a new Vec containing references to the values of self.

pub fn referenced_variables(&self) -> Vec<&str>

Recursively finds all variables

pub fn unlocated_eq(&self, other: &Self) -> bool

where S: PartialEq,

Compares equality with another `InputValue`` ignoring any source position information.

Trait Implementations

impl<S: Clone> Clone for InputValue<S>

fn clone(&self) -> InputValue<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug> Debug for InputValue<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, S: Deserialize<'de>> Deserialize<'de> for InputValue<S>

fn deserialize<D: Deserializer<'de>>(de: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<S: ScalarValue> Display for InputValue<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S> IntoInputValue<S> for InputValue<S>

fn into_input_value(self) -> Self

Converts this value into an InputValue.

impl<S: PartialEq> PartialEq for InputValue<S>

fn eq(&self, other: &InputValue<S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Serialize> Serialize for InputValue<T>

fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<S> StructuralPartialEq for InputValue<S>