      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124

    /// The type of a property name table.
    ///
    /// A property name table is a sequence of sorted tuples, where the first
    /// value in each tuple is a normalized property name and the second value of
    /// each tuple is the corresponding canonical property name.
    pub type PropertyTable = &'static [(&'static str, &'static str)];

    /// Find the canonical property name for the given normalized property name.
    ///
    /// If no such property exists, then `None` is returned.
    ///
    /// The normalized property name must have been normalized according to
    /// UAX44 LM3, which can be done using `symbolic_name_normalize`.
    pub fn canonical_property_name(
        property_table: PropertyTable,
        normalized_property_name: &str,
    ) -> Option<&'static str> {
        property_table
            .binary_search_by_key(&normalized_property_name, |&(n, _)| n)
            .ok()
            .map(|i| property_table[i].1)
    }

    /// Type of a property value table.
    ///
    /// A property value table maps property names to a mapping of property values,
    /// where the mapping of property values is represented by a sequence of
    /// tuples. The first element of each tuple is a normalized property value
    /// while the second element of each tuple is the corresponding canonical
    /// property value.
    ///
    /// Note that a property value table only includes values for properties that
    /// are catalogs, enumerations or binary properties. Properties that have
    /// string values (such as case or decomposition mappings), numeric values
    /// or are miscellaneous are not represented in this table.
    pub type PropertyValueTable = &'static [(&'static str, PropertyValues)];

    /// A mapping of property values for a specific property.
    ///
    /// The first element of each tuple is a normalized property value while the
    /// second element of each tuple is the corresponding canonical property
    /// value.
    pub type PropertyValues = &'static [(&'static str, &'static str)];

    /// Find the set of possible property values for a given property.
    ///
    /// The set returned is a mapping expressed as a sorted list of tuples.
    /// The first element of each tuple is a normalized property value while the
    /// second element of each tuple is the corresponding canonical property
    /// value.
    ///
    /// If no such property exists, then `None` is returned.
    ///
    /// The given property name must be in its canonical form, which can be
    /// found using `canonical_property_name`.
    pub fn property_values(
        property_value_table: PropertyValueTable,
        canonical_property_name: &str,
    ) -> Option<PropertyValues> {
        property_value_table
            .binary_search_by_key(&canonical_property_name, |&(n, _)| n)
            .ok()
            .map(|i| property_value_table[i].1)
    }

    /// Find the canonical property value for the given normalized property
    /// value.
    ///
    /// The given property values should correspond to the values for the property
    /// under question, which can be found using `property_values`.
    ///
    /// If no such property value exists, then `None` is returned.
    ///
    /// The normalized property value must have been normalized according to
    /// UAX44 LM3, which can be done using `symbolic_name_normalize`.
    pub fn canonical_property_value(
        property_values: PropertyValues,
        normalized_property_value: &str,
    ) -> Option<&'static str> {
        // This is cute. The types line up, so why not?
        canonical_property_name(property_values, normalized_property_value)
    }

    #[cfg(test)]
    mod tests {
        use unicode_tables::property_names::PROPERTY_NAMES;
        use unicode_tables::property_values::PROPERTY_VALUES;

        use super::{
            canonical_property_name, property_values, canonical_property_value,
        };

        #[test]
        fn canonical_property_name_1() {
            assert_eq!(
                canonical_property_name(PROPERTY_NAMES, "gc"),
                Some("General_Category"));
            assert_eq!(
                canonical_property_name(PROPERTY_NAMES, "generalcategory"),
                Some("General_Category"));
            assert_eq!(
                canonical_property_name(PROPERTY_NAMES, "g c"),
                None);
        }

        #[test]
        fn property_values_1() {
            assert_eq!(
                property_values(PROPERTY_VALUES, "White_Space"),
                Some(&[
                    ("f", "No"), ("false", "No"), ("n", "No"), ("no", "No"),
                    ("t", "Yes"), ("true", "Yes"), ("y", "Yes"), ("yes", "Yes"),
                ][..]));
        }

        #[test]
        fn canonical_property_value_1() {
            let values = property_values(PROPERTY_VALUES, "White_Space").unwrap();
            assert_eq!(canonical_property_value(values, "false"), Some("No"));
            assert_eq!(canonical_property_value(values, "t"), Some("Yes"));
            assert_eq!(canonical_property_value(values, "F"), None);
        }
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)