Struct UserPrefixDictionary 

pub struct UserPrefixDictionary {
    pub da: DoubleArrayAhoCorasick<u32>,
    pub vals_data: Data,
    pub words_idx_data: Data,
    pub words_data: Data,
    pub is_system: bool,
}

The user prefix dictionary: a daachorse Aho-Corasick automaton.

The field sequence is byte-for-byte the sequence the pre-v6 PrefixDictionary archived (da, vals_data, words_idx_data, words_data, is_system). rkyv 0.8 archives structurally, without type names, so keeping the sequence is what lets every previously-built user dictionary .bin keep loading. Do not add, remove or reorder fields without bumping the dictionary format version and rebuilding the committed .bin fixtures.

Fields

da: DoubleArrayAhoCorasick<u32>

The Aho-Corasick automaton over surface forms.

vals_data: Data

The values file: WordEntry records back to back.

words_idx_data: Data

Byte offsets into words_data, one u32 per word id.

words_data: Data

Word detail records.

is_system: bool

Always false; retained because the archived field sequence must not change (see the type-level comment).

Implementations

impl UserPrefixDictionary

pub fn decode_val(&self, val: u32) -> (u32, u32)

Decode the (offset, count) pair stored in the double-array value.

The word-id offset lives in the high 24 bits and the per-surface variant count in the low 8 bits (up to 255 variants). The legacy 5-bit encoding was retired in v4.0.0; user .bin files built with v3 must be rebuilt from CSV.

Arguments

• val - The packed automaton value.

Returns

The (offset, count) pair.

pub fn load( da_data: impl Into<Data>, vals_data: impl Into<Data>, words_idx_data: impl Into<Data>, words_data: impl Into<Data>, ) -> LinderaResult<UserPrefixDictionary>

Load a UserPrefixDictionary from raw binary data.

The automaton bytes are always run through daachorse’s validating deserializer: user dictionaries come from the filesystem or from callers, never from this crate’s own build pipeline, so there is no trusted path.

Arguments

• da_data - Serialized automaton bytes.
• vals_data - Values data bytes.
• words_idx_data - Word index data bytes.
• words_data - Words data bytes.

Returns

A UserPrefixDictionary, or an error if deserialization fails.

Trait Implementations

impl Archive for UserPrefixDictionary

where DoubleArrayArchiver: ArchiveWith<DoubleArrayAhoCorasick<u32>>, Data: Archive, bool: Archive,

type Archived = ArchivedUserPrefixDictionary

The archived representation of this type.

type Resolver = UserPrefixDictionaryResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Clone for UserPrefixDictionary

fn clone(&self) -> UserPrefixDictionary

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for UserPrefixDictionary

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<UserPrefixDictionary, __D> for Archived<UserPrefixDictionary>

where DoubleArrayArchiver: ArchiveWith<DoubleArrayAhoCorasick<u32>> + DeserializeWith<<DoubleArrayArchiver as ArchiveWith<DoubleArrayAhoCorasick<u32>>>::Archived, DoubleArrayAhoCorasick<u32>, __D>, Data: Archive, <Data as Archive>::Archived: Deserialize<Data, __D>, bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<UserPrefixDictionary, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Serialize for UserPrefixDictionary

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<__S: Fallible + ?Sized> Serialize<__S> for UserPrefixDictionary

where DoubleArrayArchiver: SerializeWith<DoubleArrayAhoCorasick<u32>, __S>, Data: Serialize<__S>, bool: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.