Struct RpField

pub struct RpField<F>
where
    F: Flavor + 'static,
{
    pub required: bool,
    pub safe_ident: Option<String>,
    pub ident: String,
    pub comment: Vec<String>,
    pub ty: F::Type,
    pub field_as: Option<String>,
}

Fields

required: bool

Is the field required.

safe_ident: Option<String>

Mangled identifier, taking target-specific keywords into account.

ident: String

Original identifier used to specify the field.

comment: Vec<String>

Field comments.

ty: F::Type

field_as: Option<String>

Alias of field in JSON.

Implementations

impl<F> RpField<F>

where F: Flavor + 'static,

pub fn new<S: AsRef<str>>(ident: S, ty: F::Type) -> Self

pub fn is_optional(&self) -> bool

pub fn is_required(&self) -> bool

pub fn safe_ident(&self) -> &str

Get the keyword-safe identifier.

This will be the identifier escaped to avoid any target-language keywords.

pub fn with_safe_ident<S: AsRef<str>>(self, safe_ident: S) -> RpField<F>

Change the safe identifier.

pub fn ident(&self) -> &str

Get the original identifier of the field.

pub fn name(&self) -> &str

Get the JSON name of the field, if it differs from ident.

TODO: Return Option, currently returns ident. This is a better indication whether ‘renaming’ should occur.

pub fn ty(&self) -> &F::Type

Get the type of the field.

pub fn display(&self) -> String

Trait Implementations

impl<F> Clone for RpField<F>

where F: Flavor + Clone + 'static, F::Type: Clone,

fn clone(&self) -> RpField<F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F> Debug for RpField<F>

where F: Flavor + Debug + 'static, F::Type: Debug,

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

Formats the value using the given formatter.

impl<F> FlavorField for RpField<F>

where F: Flavor + 'static,

fn is_discriminating(&self) -> bool

Indicates if the field is discriminating in an untagged context.

impl<F> PartialEq for RpField<F>

where F: Flavor + PartialEq + 'static, F::Type: PartialEq,

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

where F: Flavor + 'static, F::Type: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<F, T> Translate<T> for RpField<F>

where F: Flavor + 'static, T: Translator<Source = F>,

fn translate( self, diag: &mut Diagnostics, translator: &T, ) -> Result<RpField<T::Target>>

Translate into different flavor.

type Source = F

type Out = RpField<<T as Translator>::Target>

impl<F> Eq for RpField<F>

where F: Flavor + Eq + 'static, F::Type: Eq,

impl<F> StructuralPartialEq for RpField<F>

where F: Flavor + 'static,