Struct apollo_compiler::validation::Valid

pub struct Valid<T>(/* private fields */);

Wraps a Schema or ExecutableDocument to mark it as valid.

This is obtained either by running validation with one of:

• Schema::parse_and_validate
• Schema::validate
• ExecutableDocument::parse_and_validate
• ExecutableDocument::validate

… or by explicitly skipping it with Valid::assume_valid.

The schema or document inside Valid<T> is immutable (&mut T is not given out). It can be extracted with into_inner, such as to mutate it then possibly re-validate it.

Implementations

impl<T> Valid<T>

pub fn assume_valid(document: T) -> Self

Construct a Valid document without actually running validation.

The caller takes responsibility to ascertain that the document is known through some other means to be valid. For example, if it was loaded from some external storag where it was only stored after validation.

pub fn into_inner(self) -> T

Extract the schema or document, such as to mutate it then possibly re-validate it.

Trait Implementations

impl<T> AsRef<T> for Valid<T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for Valid<T>

fn clone(&self) -> Valid<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Valid<T>

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

Formats the value using the given formatter.

impl<T> Deref for Valid<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Display> Display for Valid<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Valid<T>

fn eq(&self, other: &Valid<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Eq> Eq for Valid<T>

impl<T> StructuralEq for Valid<T>

impl<T> StructuralPartialEq for Valid<T>