/rust/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-normalization-0.1.25/src/lookups.rs

Source
// Copyright 2019 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

//! Lookups of unicode properties using minimal perfect hashing.

use crate::perfect_hash::mph_lookup;
use crate::tables::*;

/// Look up the canonical combining class for a codepoint.
///
/// The value returned is as defined in the Unicode Character Database.
pub fn canonical_combining_class(c: char) -> u8 {
    mph_lookup(
        c.into(),
        CANONICAL_COMBINING_CLASS_SALT,
        CANONICAL_COMBINING_CLASS_KV,
        u8_lookup_fk,
        u8_lookup_fv,
        0,
    )
}

pub(crate) fn composition_table(c1: char, c2: char) -> Option<char> {
    if c1 < '\u{10000}' && c2 < '\u{10000}' {
        mph_lookup(
            (c1 as u32) << 16 | (c2 as u32),
            COMPOSITION_TABLE_SALT,
            COMPOSITION_TABLE_KV,
            pair_lookup_fk,
            pair_lookup_fv_opt,
            None,
        )
    } else {
        composition_table_astral(c1, c2)
    }
}

pub(crate) fn canonical_fully_decomposed(c: char) -> Option<&'static [char]> {
    mph_lookup(
        c.into(),
        CANONICAL_DECOMPOSED_SALT,
        CANONICAL_DECOMPOSED_KV,
        pair_lookup_fk,
        pair_lookup_fv_opt,
        None,
    )
    .map(|(start, len)| &CANONICAL_DECOMPOSED_CHARS[start as usize..][..len as usize])
}

pub(crate) fn compatibility_fully_decomposed(c: char) -> Option<&'static [char]> {
    mph_lookup(
        c.into(),
        COMPATIBILITY_DECOMPOSED_SALT,
        COMPATIBILITY_DECOMPOSED_KV,
        pair_lookup_fk,
        pair_lookup_fv_opt,
        None,
    )
    .map(|(start, len)| &COMPATIBILITY_DECOMPOSED_CHARS[start as usize..][..len as usize])
}

pub(crate) fn cjk_compat_variants_fully_decomposed(c: char) -> Option<&'static [char]> {
    mph_lookup(
        c.into(),
        CJK_COMPAT_VARIANTS_DECOMPOSED_SALT,
        CJK_COMPAT_VARIANTS_DECOMPOSED_KV,
        pair_lookup_fk,
        pair_lookup_fv_opt,
        None,
    )
    .map(|(start, len)| &CJK_COMPAT_VARIANTS_DECOMPOSED_CHARS[start as usize..][..len as usize])
}

/// Return whether the given character is a combining mark (`General_Category=Mark`)
pub fn is_combining_mark(c: char) -> bool {
    mph_lookup(
        c.into(),
        COMBINING_MARK_SALT,
        COMBINING_MARK_KV,
        bool_lookup_fk,
        bool_lookup_fv,
        false,
    )
}

pub fn stream_safe_trailing_nonstarters(c: char) -> usize {
    mph_lookup(
        c.into(),
        TRAILING_NONSTARTERS_SALT,
        TRAILING_NONSTARTERS_KV,
        u8_lookup_fk,
        u8_lookup_fv,
        0,
    ) as usize
}

/// Extract the key in a 24 bit key and 8 bit value packed in a u32.
#[inline]
fn u8_lookup_fk(kv: u32) -> u32 {
    kv >> 8
}

/// Extract the value in a 24 bit key and 8 bit value packed in a u32.
#[inline]
fn u8_lookup_fv(kv: u32) -> u8 {
    (kv & 0xff) as u8
}

/// Extract the key for a boolean lookup.
#[inline]
fn bool_lookup_fk(kv: u32) -> u32 {
    kv
}

/// Extract the value for a boolean lookup.
#[inline]
fn bool_lookup_fv(_kv: u32) -> bool {
    true
}

/// Extract the key in a pair.
#[inline]
fn pair_lookup_fk<T>(kv: (u32, T)) -> u32 {
    kv.0
}

/// Extract the value in a pair, returning an option.
#[inline]
fn pair_lookup_fv_opt<T>(kv: (u32, T)) -> Option<T> {
    Some(kv.1)
}

Line	Count	Source
1		// Copyright 2019 The Rust Project Developers. See the COPYRIGHT
2		// file at the top-level directory of this distribution and at
3		// http://rust-lang.org/COPYRIGHT.
4		//
5		// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6		// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7		// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8		// option. This file may not be copied, modified, or distributed
9		// except according to those terms.
10
11		//! Lookups of unicode properties using minimal perfect hashing.
12
13		use crate::perfect_hash::mph_lookup;
14		use crate::tables::*;
15
16		/// Look up the canonical combining class for a codepoint.
17		///
18		/// The value returned is as defined in the Unicode Character Database.
19	0	pub fn canonical_combining_class(c: char) -> u8 {
20	0	mph_lookup(
21	0	c.into(),
22	0	CANONICAL_COMBINING_CLASS_SALT,
23	0	CANONICAL_COMBINING_CLASS_KV,
24		u8_lookup_fk,
25		u8_lookup_fv,
26		0,
27		)
28	0	}
29
30	0	pub(crate) fn composition_table(c1: char, c2: char) -> Option<char> {
31	0	if c1 < '\u{10000}' && c2 < '\u{10000}' {
32	0	mph_lookup(
33	0	(c1 as u32) << 16 \| (c2 as u32),
34	0	COMPOSITION_TABLE_SALT,
35	0	COMPOSITION_TABLE_KV,
36		pair_lookup_fk,
37		pair_lookup_fv_opt,
38	0	None,
39		)
40		} else {
41	0	composition_table_astral(c1, c2)
42		}
43	0	}
44
45	0	pub(crate) fn canonical_fully_decomposed(c: char) -> Option<&'static [char]> {
46	0	mph_lookup(
47	0	c.into(),
48	0	CANONICAL_DECOMPOSED_SALT,
49	0	CANONICAL_DECOMPOSED_KV,
50		pair_lookup_fk,
51		pair_lookup_fv_opt,
52	0	None,
53		)
54	0	.map(\|(start, len)\| &CANONICAL_DECOMPOSED_CHARS[start as usize..][..len as usize])
55	0	}
56
57	0	pub(crate) fn compatibility_fully_decomposed(c: char) -> Option<&'static [char]> {
58	0	mph_lookup(
59	0	c.into(),
60	0	COMPATIBILITY_DECOMPOSED_SALT,
61	0	COMPATIBILITY_DECOMPOSED_KV,
62		pair_lookup_fk,
63		pair_lookup_fv_opt,
64	0	None,
65		)
66	0	.map(\|(start, len)\| &COMPATIBILITY_DECOMPOSED_CHARS[start as usize..][..len as usize])
67	0	}
68
69	0	pub(crate) fn cjk_compat_variants_fully_decomposed(c: char) -> Option<&'static [char]> {
70	0	mph_lookup(
71	0	c.into(),
72	0	CJK_COMPAT_VARIANTS_DECOMPOSED_SALT,
73	0	CJK_COMPAT_VARIANTS_DECOMPOSED_KV,
74		pair_lookup_fk,
75		pair_lookup_fv_opt,
76	0	None,
77		)
78	0	.map(\|(start, len)\| &CJK_COMPAT_VARIANTS_DECOMPOSED_CHARS[start as usize..][..len as usize])
79	0	}
80
81		/// Return whether the given character is a combining mark (`General_Category=Mark`)
82	0	pub fn is_combining_mark(c: char) -> bool {
83	0	mph_lookup(
84	0	c.into(),
85	0	COMBINING_MARK_SALT,
86	0	COMBINING_MARK_KV,
87		bool_lookup_fk,
88		bool_lookup_fv,
89		false,
90		)
91	0	}
92
93	0	pub fn stream_safe_trailing_nonstarters(c: char) -> usize {
94	0	mph_lookup(
95	0	c.into(),
96	0	TRAILING_NONSTARTERS_SALT,
97	0	TRAILING_NONSTARTERS_KV,
98	0	u8_lookup_fk,
99	0	u8_lookup_fv,
100	0	0,
101	0	) as usize
102	0	}
103
104		/// Extract the key in a 24 bit key and 8 bit value packed in a u32.
105		#[inline]
106	0	fn u8_lookup_fk(kv: u32) -> u32 {
107	0	kv >> 8
108	0	}
109
110		/// Extract the value in a 24 bit key and 8 bit value packed in a u32.
111		#[inline]
112	0	fn u8_lookup_fv(kv: u32) -> u8 {
113	0	(kv & 0xff) as u8
114	0	}
115
116		/// Extract the key for a boolean lookup.
117		#[inline]
118	0	fn bool_lookup_fk(kv: u32) -> u32 {
119	0	kv
120	0	}
121
122		/// Extract the value for a boolean lookup.
123		#[inline]
124	0	fn bool_lookup_fv(_kv: u32) -> bool {
125	0	true
126	0	}
127
128		/// Extract the key in a pair.
129		#[inline]
130	0	fn pair_lookup_fk<T>(kv: (u32, T)) -> u32 {
131	0	kv.0
132	0	} Unexecuted instantiation: unicode_normalization::lookups::pair_lookup_fk::<(u16, u16)> Unexecuted instantiation: unicode_normalization::lookups::pair_lookup_fk::<char>
133
134		/// Extract the value in a pair, returning an option.
135		#[inline]
136	0	fn pair_lookup_fv_opt<T>(kv: (u32, T)) -> Option<T> {
137	0	Some(kv.1)
138	0	} Unexecuted instantiation: unicode_normalization::lookups::pair_lookup_fv_opt::<(u16, u16)> Unexecuted instantiation: unicode_normalization::lookups::pair_lookup_fv_opt::<char>

Coverage Report

Created: 2025-11-16 07:09