Enum ReferenceClass 

pub enum ReferenceClass {
    Monograph,
    CollectionComponent,
    SerialComponent,
    Collection,
    Serial,
    LegalCase,
    Statute,
    Treaty,
    Hearing,
    Regulation,
    Brief,
    Classic,
    Patent,
    Dataset,
    Standard,
    Software,
    Event,
    AudioVisual,
    Unknown(String),
}

Typed class discriminator returned by super::InputReference::class.

Variants

Monograph

A monograph, such as a book or report.

CollectionComponent

A component of a larger monographic collection.

SerialComponent

A component of a larger serial publication.

Collection

A collection of works, such as an anthology or proceedings.

Serial

A serial publication, such as a journal or newspaper.

LegalCase

A legal case.

Statute

A statute or legislative act.

Treaty

An international treaty or agreement.

Hearing

A legislative or administrative hearing.

Regulation

An administrative regulation.

Brief

A legal brief or filing.

Classic

A classic work with standard citation forms.

Patent

A patent.

Dataset

A research dataset.

Standard

A technical standard or specification.

Software

Software or source code.

Event

An event such as a conference, performance, or broadcast.

AudioVisual

An audio-visual work.

Unknown(String)

A class string not known by this version.

#[serde(skip)]: an Unknown(...) variant cannot serialize directly through the derived Serialize impl on ReferenceClass. The class string is preserved on the wire via UnknownClassData::class inside the surrounding InputReference, not via this enum standalone.

Implementations

impl ReferenceClass

pub const KNOWN: &'static [&'static str]

Known class names in their wire-format spelling.

Trait Implementations

impl Clone for ReferenceClass

fn clone(&self) -> ReferenceClass

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReferenceClass

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReferenceClass

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for ReferenceClass

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ReferenceClass

fn eq(&self, other: &ReferenceClass) -> 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 Serialize for ReferenceClass

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ReferenceClass

impl StructuralPartialEq for ReferenceClass