Struct DetailedField 

pub struct DetailedField<V, D> { /* private fields */ }

A field with an optional detailed representation

Many feed fields follow the pattern of having a simple value (like a string) and an optional detailed struct with additional metadata. This generic wrapper captures that pattern.

Type Parameters

• V - The simple value type (usually String)
• D - The detailed representation type (e.g., TextConstruct, Person)

Examples

use feedparser_rs::types::generics::DetailedField;

// Simple value only
let title: DetailedField<String, ()> = DetailedField::from_value("My Title".to_string());
assert_eq!(title.value(), "My Title");
assert!(title.detail().is_none());

// With detail
let title = DetailedField::with_detail("My Title".to_string(), "extra info");
assert_eq!(title.detail(), Some(&"extra info"));

Implementations

impl<V, D> DetailedField<V, D>

pub const fn from_value(value: V) -> Self

Create a field with only a simple value

pub const fn with_detail(value: V, detail: D) -> Self

Create a field with both value and detail

pub const fn value(&self) -> &V

Get reference to the simple value

pub const fn value_mut(&mut self) -> &mut V

Get mutable reference to the simple value

pub const fn detail(&self) -> Option<&D>

Get reference to the detail if present

pub const fn detail_mut(&mut self) -> Option<&mut D>

Get mutable reference to the detail if present

pub fn set_detail(&mut self, detail: D)

Set the detail

pub const fn take_detail(&mut self) -> Option<D>

Take the detail, leaving None in its place

pub fn into_parts(self) -> (V, Option<D>)

Convert into a tuple of (value, Option<detail>)

Trait Implementations

impl<V: Clone, D: Clone> Clone for DetailedField<V, D>

fn clone(&self) -> DetailedField<V, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Debug, D: Debug> Debug for DetailedField<V, D>

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

Formats the value using the given formatter.

impl<V: Default, D> Default for DetailedField<V, D>

fn default() -> Self

Returns the “default value” for a type.

impl<V, D> From<(V, D)> for DetailedField<V, D>

fn from((value, detail): (V, D)) -> Self

Converts to this type from the input type.

impl<V, D> From<V> for DetailedField<V, D>

fn from(value: V) -> Self

Converts to this type from the input type.

impl<V: PartialEq, D: PartialEq> PartialEq for DetailedField<V, D>

fn eq(&self, other: &DetailedField<V, D>) -> 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<V: Eq, D: Eq> Eq for DetailedField<V, D>

impl<V, D> StructuralPartialEq for DetailedField<V, D>