Struct IndexSpec 

#[non_exhaustive]
pub struct IndexSpec {
    pub name: String,
    pub kind: IndexKind,
    pub key_paths: Vec<String>,
}

A runtime index declaration.

Document::indexes() returns a Vec<IndexSpec>; the catalog reconciler in #57 compares this list against the catalog’s stored crate::catalog::IndexDescriptor rows and declares or drops the difference.

Construction

Prefer the kind-specific constructors over building the struct literal — they enforce the per-kind path-count invariants:

use obj_core::index::IndexSpec;

// Standard / Unique / Each take exactly one field path.
let by_email_unique = IndexSpec::unique("by_email", "email").expect("valid");
let by_status = IndexSpec::standard("by_status", "status").expect("valid");
let by_tag = IndexSpec::each("by_tag", "tags").expect("valid");

// Composite requires two or more.
let by_customer_time = IndexSpec::composite(
    "by_customer_time",
    &["customer_id", "placed_at"],
).expect("valid");

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

name: String

User-visible name. Stable across reopens; the catalog uses it to match a runtime spec against an on-disk descriptor.

kind: IndexKind

Discriminator. See IndexKind.

key_paths: Vec<String>

Field path(s) within the document. Single-element for Standard / Unique / Each; ≥ 2 for Composite.

Implementations

impl IndexSpec

pub fn standard<N: Into<String>, P: Into<String>>( name: N, path: P, ) -> Result<Self>

Construct a IndexKind::Standard spec.

Errors

Returns Error::InvalidArgument if name or path is empty.

pub fn unique<N: Into<String>, P: Into<String>>( name: N, path: P, ) -> Result<Self>

Construct a IndexKind::Unique spec.

Errors

As IndexSpec::standard.

pub fn each<N: Into<String>, P: Into<String>>(name: N, path: P) -> Result<Self>

Construct a IndexKind::Each spec. The indexed field MUST be a sequence-valued field at extract time; if it is not, extract_index_keys (#56) errors with Error::IndexFieldTypeMismatch.

Errors

As IndexSpec::standard.

pub fn composite<N: Into<String>>(name: N, paths: &[&str]) -> Result<Self>

Construct a IndexKind::Composite spec.

Errors

Returns Error::InvalidArgument if name is empty, if paths has fewer than two entries, or if any path is empty.

pub fn from_parts<N: Into<String>>( name: N, kind: IndexKind, key_paths: Vec<String>, ) -> Result<Self>

Construct a spec from its individual parts.

Unlike the kind-specific constructors, this accepts an arbitrary IndexKind plus a key_paths vector and is the general entry point callers reach for when reconstructing a spec from an on-disk crate::catalog::IndexDescriptor (where the kind is data, not a compile-time choice). The result is validated, so a malformed descriptor surfaces as an error rather than a silently-wrong spec.

Errors

Returns Error::InvalidArgument if name is empty, any path is empty, or the path count disagrees with the kind.

pub fn validate(&self) -> Result<()>

Validate the spec’s shape against the per-kind invariants.

Called by every constructor; safe to call again on a round-tripped (postcard-decoded) spec as a defense-in-depth check before the catalog stamps the descriptor.

Errors

• Error::InvalidArgument if name is empty, any path is empty, or the path count disagrees with the kind.

Trait Implementations

impl Clone for IndexSpec

fn clone(&self) -> IndexSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IndexSpec

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IndexSpec

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for IndexSpec

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

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 IndexSpec

impl StructuralPartialEq for IndexSpec