Enum RepeatedRepr 

#[non_exhaustive]
pub enum RepeatedRepr {
    Vec,
    Custom(String),
}

The owned Rust collection a proto repeated field maps to in generated owned structs.

The default is Vec (Vec<T>). Custom substitutes any collection that satisfies the buffa::ProtoList<T> bound — for example a crate-local newtype wrapping a SmallVec-backed inline collection. Unlike the scalar string/bytes knobs the custom collection wraps the element type, so its path is a template containing a * placeholder where the element type is substituted (e.g. "::my_crate::SmallList<*>").

Because buffa::ProtoList is buffa-owned, a foreign collection cannot implement it directly (orphan rule) — the template must always name a crate-local newtype, mirroring the ProtoString newtype expectation.

Select a representation through buffa_build’s repeated_type_custom builder method. The wire format is identical regardless of the collection; view types keep borrowing &[T].

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Vec

::buffa::alloc::vec::Vec<T> — the default. Keeps the Vec-specialized fast paths (in-place push/reserve/clear, native Arbitrary) instead of the generic ProtoList ones, so generated output for the default is byte-identical to a build without the knob.

Custom(String)

A custom collection named by a Rust type-path template with a * placeholder for the element type (e.g. "::my_crate::SmallList<*>"). The named type must satisfy buffa::ProtoList<T> and be a crate-local newtype (a foreign collection cannot implement the buffa-owned ProtoList).

Limitations

• The template must contain at least one *; the element type is substituted for every * before the result is parsed as a Rust type. A template that omits * surfaces as CodeGenError::MissingListPlaceholder, and one whose substitution does not parse as CodeGenError::InvalidTypePath, at generation (.compile()) time.
• A custom collection always needs a crate-local newtype — this is not limited to the reflection path. The generated decode and clear code require Field: ProtoList, so even a binary-only build cannot use a foreign collection directly.
• Under reflection / vtable the newtype must implement buffa_descriptor’s ReflectList (a Vec-backed newtype can delegate to the inner Vec<T>: ReflectList). Under JSON it must implement serde::Serialize / Deserialize; under the arbitrary feature, arbitrary::Arbitrary (derivable on a newtype).
• A repeated <self-type> field becomes Collection<Self>, so the collection must be heap-backed; an inline collection (SmallVec<[Self; N]>) would be infinitely sized and fail to compile.

Trait Implementations

impl Clone for RepeatedRepr

fn clone(&self) -> RepeatedRepr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RepeatedRepr

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

Formats the value using the given formatter.

impl Default for RepeatedRepr

fn default() -> RepeatedRepr

Returns the “default value” for a type.

impl Eq for RepeatedRepr

impl PartialEq for RepeatedRepr

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