Enum ContextFeature

pub enum ContextFeature {
    None,
    IsMath,
    IsMatrix,
    IsCases,
    IsFigure,
    IsTable,
    IsItemize,
    IsEnumerate,
}

A feature that specifies how to process the content of an environment.

Variants

None

No special feature

IsMath

Parse content like math environments

IsMatrix

Parse content like mat arguments

IsCases

Parse content like cases

IsFigure

Parse content like figure

IsTable

Parse content like table

IsItemize

Parse content like itemize

IsEnumerate

Parse content like enumerate

Trait Implementations

impl Archive for ContextFeature

type Archived = ArchivedContextFeature

The archived representation of this type.

type Resolver = ContextFeatureResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: <ContextFeature as Archive>::Resolver, out: *mut <ContextFeature as Archive>::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for ContextFeature

fn clone(&self) -> ContextFeature

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ContextFeature

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ContextFeature

fn deserialize<__D>( __deserializer: __D, ) -> Result<ContextFeature, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D> Deserialize<ContextFeature, __D> for <ContextFeature as Archive>::Archived

where __D: Fallible + ?Sized,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<ContextFeature, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<__S> Serialize<__S> for ContextFeature

where __S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut __S, ) -> Result<<ContextFeature as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Serialize for ContextFeature

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.