#![doc = include_str!("../README.md")]
#![no_std]
include!(concat!(env!("OUT_DIR"), "/tables.rs"));
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Uuid16 {
pub uuid: u16,
pub kind: UuidKind,
pub name: &'static str,
pub id: &'static str,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum UuidKind {
Service,
Characteristic,
Descriptor,
Declaration,
Unit,
Member,
Sdo,
ServiceClass,
Protocol,
ObjectType,
BrowseGroup,
MeshProfile,
}
impl UuidKind {
pub const ALL: [UuidKind; 12] = [
UuidKind::Service,
UuidKind::Characteristic,
UuidKind::Descriptor,
UuidKind::Declaration,
UuidKind::Unit,
UuidKind::Member,
UuidKind::Sdo,
UuidKind::ServiceClass,
UuidKind::Protocol,
UuidKind::ObjectType,
UuidKind::BrowseGroup,
UuidKind::MeshProfile,
];
fn table(self) -> &'static [(u16, &'static str, &'static str)] {
match self {
UuidKind::Service => SERVICES,
UuidKind::Characteristic => CHARACTERISTICS,
UuidKind::Descriptor => DESCRIPTORS,
UuidKind::Declaration => DECLARATIONS,
UuidKind::Unit => UNITS,
UuidKind::Member => MEMBERS,
UuidKind::Sdo => SDOS,
UuidKind::ServiceClass => SERVICE_CLASSES,
UuidKind::Protocol => PROTOCOLS,
UuidKind::ObjectType => OBJECT_TYPES,
UuidKind::BrowseGroup => BROWSE_GROUPS,
UuidKind::MeshProfile => MESH_PROFILES,
}
}
pub fn as_str(self) -> &'static str {
match self {
UuidKind::Service => "service",
UuidKind::Characteristic => "characteristic",
UuidKind::Descriptor => "descriptor",
UuidKind::Declaration => "declaration",
UuidKind::Unit => "unit",
UuidKind::Member => "member",
UuidKind::Sdo => "sdo",
UuidKind::ServiceClass => "service_class",
UuidKind::Protocol => "protocol",
UuidKind::ObjectType => "object_type",
UuidKind::BrowseGroup => "browse_group",
UuidKind::MeshProfile => "mesh_profile",
}
}
}
fn find<T: Copy>(table: &'static [(u16, T)], key: u16) -> Option<T> {
table
.binary_search_by_key(&key, |e| e.0)
.ok()
.map(|i| table[i].1)
}
pub fn uuid16_of(kind: UuidKind, uuid: u16) -> Option<Uuid16> {
let table = kind.table();
table
.binary_search_by_key(&uuid, |e| e.0)
.ok()
.map(|i| Uuid16 {
uuid,
kind,
name: table[i].1,
id: table[i].2,
})
}
pub fn uuid16(uuid: u16) -> Option<Uuid16> {
UuidKind::ALL.iter().find_map(|k| uuid16_of(*k, uuid))
}
pub fn service(uuid: u16) -> Option<Uuid16> {
uuid16_of(UuidKind::Service, uuid)
}
pub fn characteristic(uuid: u16) -> Option<Uuid16> {
uuid16_of(UuidKind::Characteristic, uuid)
}
pub fn descriptor(uuid: u16) -> Option<Uuid16> {
uuid16_of(UuidKind::Descriptor, uuid)
}
pub fn unit(uuid: u16) -> Option<Uuid16> {
uuid16_of(UuidKind::Unit, uuid)
}
pub fn member(uuid: u16) -> Option<Uuid16> {
uuid16_of(UuidKind::Member, uuid)
}
pub fn company(id: u16) -> Option<&'static str> {
find(COMPANIES, id)
}
pub fn ad_type(value: u8) -> Option<&'static str> {
find(AD_TYPES, u16::from(value))
}
pub fn uri_scheme(code: u16) -> Option<&'static str> {
find(URI_SCHEMES, code)
}
pub fn core_version(value: u8) -> Option<&'static str> {
find(CORE_VERSIONS, u16::from(value))
}
pub fn psm(value: u16) -> Option<&'static str> {
find(PSMS, value)
}
pub fn format_type(value: u8) -> Option<(&'static str, &'static str)> {
let key = u16::from(value);
FORMAT_TYPES
.binary_search_by_key(&key, |e| e.0)
.ok()
.map(|i| (FORMAT_TYPES[i].1, FORMAT_TYPES[i].2))
}
pub fn mesh_opcode(opcode: u32) -> Option<&'static str> {
MESH_OPCODES
.binary_search_by_key(&opcode, |e| e.0)
.ok()
.map(|i| MESH_OPCODES[i].1)
}
pub fn mesh_model(id: u16) -> Option<&'static str> {
find(MESH_MODELS, id)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Appearance {
pub value: u16,
pub category: Option<&'static str>,
pub subcategory: Option<&'static str>,
}
pub fn appearance(value: u16) -> Appearance {
Appearance {
value,
category: find(APPEARANCE_CATEGORIES, value >> 6),
subcategory: find(APPEARANCE_SUBCATEGORIES, value),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn tables_are_sorted_and_found() {
for kind in UuidKind::ALL {
let t = kind.table();
assert!(t.windows(2).all(|w| w[0].0 < w[1].0), "{kind:?}");
}
assert!(COMPANIES.len() > 3000);
assert_eq!(company(0x0000), Some("Ericsson AB"));
assert_eq!(
service(0x180f).unwrap().id,
"org.bluetooth.service.battery_service"
);
assert_eq!(characteristic(0x2a19).unwrap().name, "Battery Level");
assert_eq!(
descriptor(0x2902).unwrap().name,
"Client Characteristic Configuration"
);
assert_eq!(member(0xfeaa).unwrap().name, "Google LLC");
assert_eq!(ad_type(0xff), Some("Manufacturer Specific Data"));
assert_eq!(ad_type(0x01), Some("Flags"));
assert_eq!(uri_scheme(0x0017), Some("https:"));
assert!(core_version(0x0d).unwrap().contains("5.4"));
assert_eq!(psm(0x0001), Some("SDP"));
assert_eq!(format_type(0x06).unwrap().0, "uint16");
let a = appearance(0x00c1);
assert_eq!(a.category, Some("Watch"));
assert_eq!(a.subcategory, Some("Sports Watch"));
assert_eq!(uuid16(0x2a19).unwrap().kind, UuidKind::Characteristic);
assert_eq!(mesh_opcode(0x8201), Some("Generic OnOff Get"));
assert_eq!(mesh_opcode(0x00), Some("Config AppKey Add"));
assert_eq!(mesh_model(0x0000), Some("Configuration Server"));
assert_eq!(mesh_model(0x1000), Some("Generic OnOff Server"));
}
}