diff --git a/README.md b/README.md index 037118a..ee589c6 100644 --- a/README.md +++ b/README.md @@ -21,6 +21,7 @@ This will: 4. Generate C# bindings (`generated/cs_lcm_msgs/`) 5. Generate Java bindings (`generated/java_lcm_msgs/`) 6. Generate Typescript bindings (`generated/ts_lcm_msgs/`) +7. Generate Rust bindings (`generated/rust_lcm_msgs/`) ## Directory Structure diff --git a/generate.sh b/generate.sh index b827ffb..79fa57e 100755 --- a/generate.sh +++ b/generate.sh @@ -41,3 +41,9 @@ deno run --allow-read --allow-write "$SCRIPT_DIR/tools/ts/gen/mod.ts" -q -o "$SC rm -rf "$SCRIPT_DIR/tools/ts/msgs/generated" cp -r "$SCRIPT_DIR/generated/ts_lcm_msgs" "$SCRIPT_DIR/tools/ts/msgs/generated" echo -e "\033[32mLCM -> TypeScript done\033[0m" + +# Generate Rust bindings +rm -rf "$SCRIPT_DIR/generated/rust_lcm_msgs" +python3 "$SCRIPT_DIR/tools/rust/lcm_rust_gen.py" "$SCRIPT_DIR/lcm_types" -o "$SCRIPT_DIR/generated/rust_lcm_msgs" +(cd "$SCRIPT_DIR/generated/rust_lcm_msgs" && cargo check --quiet) +echo -e "\033[32mLCM -> Rust done\033[0m" diff --git a/generated/rust_lcm_msgs/.gitignore b/generated/rust_lcm_msgs/.gitignore new file mode 100644 index 0000000..ea8c4bf --- /dev/null +++ b/generated/rust_lcm_msgs/.gitignore @@ -0,0 +1 @@ +/target diff --git a/generated/rust_lcm_msgs/Cargo.lock b/generated/rust_lcm_msgs/Cargo.lock new file mode 100644 index 0000000..91810df --- /dev/null +++ b/generated/rust_lcm_msgs/Cargo.lock @@ -0,0 +1,16 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "lcm-msgs" +version = "0.1.0" +dependencies = [ + "byteorder", +] diff --git a/generated/rust_lcm_msgs/Cargo.toml b/generated/rust_lcm_msgs/Cargo.toml new file mode 100644 index 0000000..4e32e1b --- /dev/null +++ b/generated/rust_lcm_msgs/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "lcm-msgs" +version = "0.1.0" +edition = "2021" +description = "Auto-generated LCM message types for Rust" + +[dependencies] +byteorder = "1" diff --git a/generated/rust_lcm_msgs/src/actionlib_msgs/goal_id.rs b/generated/rust_lcm_msgs/src/actionlib_msgs/goal_id.rs new file mode 100644 index 0000000..37ea4dd --- /dev/null +++ b/generated/rust_lcm_msgs/src/actionlib_msgs/goal_id.rs @@ -0,0 +1,86 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct GoalID { + pub stamp: crate::std_msgs::Time, + pub id: std::string::String, +} + +impl GoalID { + pub const HASH: i64 = 0xEF36683EF0767E95u64 as i64; + pub const NAME: &str = "actionlib_msgs.GoalID"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Time::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.stamp.encode_one(buf)?; + { + let bytes = self.id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let stamp = crate::std_msgs::Time::decode_one(buf)?; + let id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + stamp, + id, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.stamp.encoded_size(); + size += 4 + self.id.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/actionlib_msgs/goal_status.rs b/generated/rust_lcm_msgs/src/actionlib_msgs/goal_status.rs new file mode 100644 index 0000000..353fd25 --- /dev/null +++ b/generated/rust_lcm_msgs/src/actionlib_msgs/goal_status.rs @@ -0,0 +1,102 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct GoalStatus { + pub goal_id: crate::actionlib_msgs::GoalID, + pub status: u8, + pub text: std::string::String, +} + +impl GoalStatus { + pub const HASH: i64 = 0xC0B4E95FEBDCD994u64 as i64; + pub const NAME: &str = "actionlib_msgs.GoalStatus"; + + pub const PENDING: i8 = 0; + pub const ACTIVE: i8 = 1; + pub const PREEMPTED: i8 = 2; + pub const SUCCEEDED: i8 = 3; + pub const ABORTED: i8 = 4; + pub const REJECTED: i8 = 5; + pub const PREEMPTING: i8 = 6; + pub const RECALLING: i8 = 7; + pub const RECALLED: i8 = 8; + pub const LOST: i8 = 9; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::actionlib_msgs::GoalID::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.goal_id.encode_one(buf)?; + buf.write_u8(self.status)?; + { + let bytes = self.text.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let goal_id = crate::actionlib_msgs::GoalID::decode_one(buf)?; + let status = buf.read_u8()?; + let text = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + goal_id, + status, + text, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.goal_id.encoded_size(); + size += 1; + size += 4 + self.text.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/actionlib_msgs/goal_status_array.rs b/generated/rust_lcm_msgs/src/actionlib_msgs/goal_status_array.rs new file mode 100644 index 0000000..bd2dbd0 --- /dev/null +++ b/generated/rust_lcm_msgs/src/actionlib_msgs/goal_status_array.rs @@ -0,0 +1,90 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct GoalStatusArray { + pub header: crate::std_msgs::Header, + pub status_list: Vec, +} + +impl GoalStatusArray { + pub const HASH: i64 = 0x0F5C35B2E7EED0FAu64 as i64; + pub const NAME: &str = "actionlib_msgs.GoalStatusArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::actionlib_msgs::GoalStatus::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.status_list.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.status_list.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let status_list_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let status_list = { + let mut v = Vec::with_capacity(status_list_length); + for _ in 0..status_list_length { + let _elem_0 = crate::actionlib_msgs::GoalStatus::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + status_list, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + for v0 in self.status_list.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/actionlib_msgs/mod.rs b/generated/rust_lcm_msgs/src/actionlib_msgs/mod.rs new file mode 100644 index 0000000..3942757 --- /dev/null +++ b/generated/rust_lcm_msgs/src/actionlib_msgs/mod.rs @@ -0,0 +1,10 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +mod goal_id; +pub use goal_id::GoalID; + +mod goal_status; +pub use goal_status::GoalStatus; + +mod goal_status_array; +pub use goal_status_array::GoalStatusArray; diff --git a/generated/rust_lcm_msgs/src/builtin_interfaces/duration.rs b/generated/rust_lcm_msgs/src/builtin_interfaces/duration.rs new file mode 100644 index 0000000..68306ab --- /dev/null +++ b/generated/rust_lcm_msgs/src/builtin_interfaces/duration.rs @@ -0,0 +1,74 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Duration { + pub sec: i32, + pub nanosec: i32, +} + +impl Duration { + pub const HASH: i64 = 0x263F39EFA2A9AF63u64 as i64; + pub const NAME: &str = "builtin_interfaces.Duration"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.sec)?; + buf.write_i32::(self.nanosec)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let sec = buf.read_i32::()?; + let nanosec = buf.read_i32::()?; + Ok(Self { + sec, + nanosec, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/builtin_interfaces/mod.rs b/generated/rust_lcm_msgs/src/builtin_interfaces/mod.rs new file mode 100644 index 0000000..45c2657 --- /dev/null +++ b/generated/rust_lcm_msgs/src/builtin_interfaces/mod.rs @@ -0,0 +1,7 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +mod duration; +pub use duration::Duration; + +mod time; +pub use time::Time; diff --git a/generated/rust_lcm_msgs/src/builtin_interfaces/time.rs b/generated/rust_lcm_msgs/src/builtin_interfaces/time.rs new file mode 100644 index 0000000..40231d6 --- /dev/null +++ b/generated/rust_lcm_msgs/src/builtin_interfaces/time.rs @@ -0,0 +1,74 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Time { + pub sec: i32, + pub nanosec: i32, +} + +impl Time { + pub const HASH: i64 = 0x263F39EFA2A9AF63u64 as i64; + pub const NAME: &str = "builtin_interfaces.Time"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.sec)?; + buf.write_i32::(self.nanosec)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let sec = buf.read_i32::()?; + let nanosec = buf.read_i32::()?; + Ok(Self { + sec, + nanosec, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/diagnostic_msgs/diagnostic_array.rs b/generated/rust_lcm_msgs/src/diagnostic_msgs/diagnostic_array.rs new file mode 100644 index 0000000..bef7195 --- /dev/null +++ b/generated/rust_lcm_msgs/src/diagnostic_msgs/diagnostic_array.rs @@ -0,0 +1,90 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct DiagnosticArray { + pub header: crate::std_msgs::Header, + pub status: Vec, +} + +impl DiagnosticArray { + pub const HASH: i64 = 0x0163C308C500B94Du64 as i64; + pub const NAME: &str = "diagnostic_msgs.DiagnosticArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::diagnostic_msgs::DiagnosticStatus::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.status.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.status.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let status_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let status = { + let mut v = Vec::with_capacity(status_length); + for _ in 0..status_length { + let _elem_0 = crate::diagnostic_msgs::DiagnosticStatus::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + status, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + for v0 in self.status.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/diagnostic_msgs/diagnostic_status.rs b/generated/rust_lcm_msgs/src/diagnostic_msgs/diagnostic_status.rs new file mode 100644 index 0000000..d3bb3de --- /dev/null +++ b/generated/rust_lcm_msgs/src/diagnostic_msgs/diagnostic_status.rs @@ -0,0 +1,142 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct DiagnosticStatus { + pub level: i8, + pub name: std::string::String, + pub message: std::string::String, + pub hardware_id: std::string::String, + pub values: Vec, +} + +impl DiagnosticStatus { + pub const HASH: i64 = 0x3E3FB00C69778DFBu64 as i64; + pub const NAME: &str = "diagnostic_msgs.DiagnosticStatus"; + + pub const OK: i8 = 0; + pub const WARN: i8 = 1; + pub const ERROR: i8 = 2; + pub const STALE: i8 = 3; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::diagnostic_msgs::KeyValue::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.values.len() as i32)?; + buf.write_i8(self.level)?; + { + let bytes = self.name.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.message.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.hardware_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + for v0 in self.values.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let values_length = buf.read_i32::()? as usize; + let level = buf.read_i8()?; + let name = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let message = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let hardware_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let values = { + let mut v = Vec::with_capacity(values_length); + for _ in 0..values_length { + let _elem_0 = crate::diagnostic_msgs::KeyValue::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + level, + name, + message, + hardware_id, + values, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 1; + size += 4 + self.name.len() + 1; + size += 4 + self.message.len() + 1; + size += 4 + self.hardware_id.len() + 1; + for v0 in self.values.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/diagnostic_msgs/key_value.rs b/generated/rust_lcm_msgs/src/diagnostic_msgs/key_value.rs new file mode 100644 index 0000000..762181d --- /dev/null +++ b/generated/rust_lcm_msgs/src/diagnostic_msgs/key_value.rs @@ -0,0 +1,96 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct KeyValue { + pub key: std::string::String, + pub value: std::string::String, +} + +impl KeyValue { + pub const HASH: i64 = 0x97574015D52EEDDEu64 as i64; + pub const NAME: &str = "diagnostic_msgs.KeyValue"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + { + let bytes = self.key.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.value.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let key = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let value = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + key, + value, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4 + self.key.len() + 1; + size += 4 + self.value.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/diagnostic_msgs/mod.rs b/generated/rust_lcm_msgs/src/diagnostic_msgs/mod.rs new file mode 100644 index 0000000..04f4016 --- /dev/null +++ b/generated/rust_lcm_msgs/src/diagnostic_msgs/mod.rs @@ -0,0 +1,10 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +mod diagnostic_array; +pub use diagnostic_array::DiagnosticArray; + +mod diagnostic_status; +pub use diagnostic_status::DiagnosticStatus; + +mod key_value; +pub use key_value::KeyValue; diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/arrow_primitive.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/arrow_primitive.rs new file mode 100644 index 0000000..6bc5e03 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/arrow_primitive.rs @@ -0,0 +1,96 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct ArrowPrimitive { + pub pose: crate::geometry_msgs::Pose, + pub shaft_length: f64, + pub shaft_diameter: f64, + pub head_length: f64, + pub head_diameter: f64, + pub color: crate::foxglove_msgs::Color, +} + +impl ArrowPrimitive { + pub const HASH: i64 = 0xB1F9D32968E60FBBu64 as i64; + pub const NAME: &str = "foxglove_msgs.ArrowPrimitive"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.pose.encode_one(buf)?; + buf.write_f64::(self.shaft_length)?; + buf.write_f64::(self.shaft_diameter)?; + buf.write_f64::(self.head_length)?; + buf.write_f64::(self.head_diameter)?; + self.color.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let shaft_length = buf.read_f64::()?; + let shaft_diameter = buf.read_f64::()?; + let head_length = buf.read_f64::()?; + let head_diameter = buf.read_f64::()?; + let color = crate::foxglove_msgs::Color::decode_one(buf)?; + Ok(Self { + pose, + shaft_length, + shaft_diameter, + head_length, + head_diameter, + color, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.pose.encoded_size(); + size += 8; + size += 8; + size += 8; + size += 8; + size += self.color.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/camera_calibration.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/camera_calibration.rs new file mode 100644 index 0000000..33eaabe --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/camera_calibration.rs @@ -0,0 +1,168 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct CameraCalibration { + pub timestamp: crate::builtin_interfaces::Time, + pub frame_id: std::string::String, + pub width: i32, + pub height: i32, + pub distortion_model: std::string::String, + pub d: Vec, + pub k: [f64; 9], + pub r: [f64; 9], + pub p: [f64; 12], +} + +impl CameraCalibration { + pub const HASH: i64 = 0x89C275083A857CE2u64 as i64; + pub const NAME: &str = "foxglove_msgs.CameraCalibration"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.d.len() as i32)?; + self.timestamp.encode_one(buf)?; + { + let bytes = self.frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_i32::(self.width)?; + buf.write_i32::(self.height)?; + { + let bytes = self.distortion_model.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + for v0 in self.d.iter() { + buf.write_f64::(*v0)?; + } + for v0 in self.k.iter() { + buf.write_f64::(*v0)?; + } + for v0 in self.r.iter() { + buf.write_f64::(*v0)?; + } + for v0 in self.p.iter() { + buf.write_f64::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let d_length = buf.read_i32::()? as usize; + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let width = buf.read_i32::()?; + let height = buf.read_i32::()?; + let distortion_model = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let d = { + let mut v = Vec::with_capacity(d_length); + for _ in 0..d_length { + let _elem_0 = buf.read_f64::()?; + v.push(_elem_0); + } + v + }; + let k = { + let mut _arr_0 = [0.0f64; 9]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + let r = { + let mut _arr_0 = [0.0f64; 9]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + let p = { + let mut _arr_0 = [0.0f64; 12]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + Ok(Self { + timestamp, + frame_id, + width, + height, + distortion_model, + d, + k, + r, + p, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.timestamp.encoded_size(); + size += 4 + self.frame_id.len() + 1; + size += 4; + size += 4; + size += 4 + self.distortion_model.len() + 1; + size += self.d.len() * 8; + size += self.k.len() * 8; + size += self.r.len() * 8; + size += self.p.len() * 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/circle_annotation.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/circle_annotation.rs new file mode 100644 index 0000000..68a1d76 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/circle_annotation.rs @@ -0,0 +1,98 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct CircleAnnotation { + pub timestamp: crate::builtin_interfaces::Time, + pub position: crate::foxglove_msgs::Point2, + pub diameter: f64, + pub thickness: f64, + pub fill_color: crate::foxglove_msgs::Color, + pub outline_color: crate::foxglove_msgs::Color, +} + +impl CircleAnnotation { + pub const HASH: i64 = 0x5A3219098258887Cu64 as i64; + pub const NAME: &str = "foxglove_msgs.CircleAnnotation"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Point2::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.timestamp.encode_one(buf)?; + self.position.encode_one(buf)?; + buf.write_f64::(self.diameter)?; + buf.write_f64::(self.thickness)?; + self.fill_color.encode_one(buf)?; + self.outline_color.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let position = crate::foxglove_msgs::Point2::decode_one(buf)?; + let diameter = buf.read_f64::()?; + let thickness = buf.read_f64::()?; + let fill_color = crate::foxglove_msgs::Color::decode_one(buf)?; + let outline_color = crate::foxglove_msgs::Color::decode_one(buf)?; + Ok(Self { + timestamp, + position, + diameter, + thickness, + fill_color, + outline_color, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.timestamp.encoded_size(); + size += self.position.encoded_size(); + size += 8; + size += 8; + size += self.fill_color.encoded_size(); + size += self.outline_color.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/color.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/color.rs new file mode 100644 index 0000000..eec9406 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/color.rs @@ -0,0 +1,84 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Color { + pub r: f64, + pub g: f64, + pub b: f64, + pub a: f64, +} + +impl Color { + pub const HASH: i64 = 0x998136169753C441u64 as i64; + pub const NAME: &str = "foxglove_msgs.Color"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_f64::(self.r)?; + buf.write_f64::(self.g)?; + buf.write_f64::(self.b)?; + buf.write_f64::(self.a)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let r = buf.read_f64::()?; + let g = buf.read_f64::()?; + let b = buf.read_f64::()?; + let a = buf.read_f64::()?; + Ok(Self { + r, + g, + b, + a, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 8; + size += 8; + size += 8; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/compressed_image.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/compressed_image.rs new file mode 100644 index 0000000..e5b3b12 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/compressed_image.rs @@ -0,0 +1,114 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct CompressedImage { + pub timestamp: crate::builtin_interfaces::Time, + pub frame_id: std::string::String, + pub data: Vec, + pub format: std::string::String, +} + +impl CompressedImage { + pub const HASH: i64 = 0x448D6658328C5EBCu64 as i64; + pub const NAME: &str = "foxglove_msgs.CompressedImage"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.timestamp.encode_one(buf)?; + { + let bytes = self.frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_all(&self.data)?; + { + let bytes = self.format.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let data = { + let mut v = vec![0u8; data_length]; + buf.read_exact(&mut v)?; + v + }; + let format = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + timestamp, + frame_id, + data, + format, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.timestamp.encoded_size(); + size += 4 + self.frame_id.len() + 1; + size += self.data.len(); + size += 4 + self.format.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/compressed_video.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/compressed_video.rs new file mode 100644 index 0000000..e24c39e --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/compressed_video.rs @@ -0,0 +1,114 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct CompressedVideo { + pub timestamp: crate::builtin_interfaces::Time, + pub frame_id: std::string::String, + pub data: Vec, + pub format: std::string::String, +} + +impl CompressedVideo { + pub const HASH: i64 = 0x448D6658328C5EBCu64 as i64; + pub const NAME: &str = "foxglove_msgs.CompressedVideo"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.timestamp.encode_one(buf)?; + { + let bytes = self.frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_all(&self.data)?; + { + let bytes = self.format.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let data = { + let mut v = vec![0u8; data_length]; + buf.read_exact(&mut v)?; + v + }; + let format = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + timestamp, + frame_id, + data, + format, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.timestamp.encoded_size(); + size += 4 + self.frame_id.len() + 1; + size += self.data.len(); + size += 4 + self.format.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/cube_primitive.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/cube_primitive.rs new file mode 100644 index 0000000..7929189 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/cube_primitive.rs @@ -0,0 +1,82 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct CubePrimitive { + pub pose: crate::geometry_msgs::Pose, + pub size: crate::geometry_msgs::Vector3, + pub color: crate::foxglove_msgs::Color, +} + +impl CubePrimitive { + pub const HASH: i64 = 0xE7E8912EA6542887u64 as i64; + pub const NAME: &str = "foxglove_msgs.CubePrimitive"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.pose.encode_one(buf)?; + self.size.encode_one(buf)?; + self.color.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let size = crate::geometry_msgs::Vector3::decode_one(buf)?; + let color = crate::foxglove_msgs::Color::decode_one(buf)?; + Ok(Self { + pose, + size, + color, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.pose.encoded_size(); + size += self.size.encoded_size(); + size += self.color.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/cylinder_primitive.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/cylinder_primitive.rs new file mode 100644 index 0000000..8d0f566 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/cylinder_primitive.rs @@ -0,0 +1,92 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct CylinderPrimitive { + pub pose: crate::geometry_msgs::Pose, + pub size: crate::geometry_msgs::Vector3, + pub bottom_scale: f64, + pub top_scale: f64, + pub color: crate::foxglove_msgs::Color, +} + +impl CylinderPrimitive { + pub const HASH: i64 = 0xA52103034BFE0BACu64 as i64; + pub const NAME: &str = "foxglove_msgs.CylinderPrimitive"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.pose.encode_one(buf)?; + self.size.encode_one(buf)?; + buf.write_f64::(self.bottom_scale)?; + buf.write_f64::(self.top_scale)?; + self.color.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let size = crate::geometry_msgs::Vector3::decode_one(buf)?; + let bottom_scale = buf.read_f64::()?; + let top_scale = buf.read_f64::()?; + let color = crate::foxglove_msgs::Color::decode_one(buf)?; + Ok(Self { + pose, + size, + bottom_scale, + top_scale, + color, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.pose.encoded_size(); + size += self.size.encoded_size(); + size += 8; + size += 8; + size += self.color.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/frame_transform.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/frame_transform.rs new file mode 100644 index 0000000..1391e62 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/frame_transform.rs @@ -0,0 +1,114 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct FrameTransform { + pub timestamp: crate::builtin_interfaces::Time, + pub parent_frame_id: std::string::String, + pub child_frame_id: std::string::String, + pub translation: crate::geometry_msgs::Vector3, + pub rotation: crate::geometry_msgs::Quaternion, +} + +impl FrameTransform { + pub const HASH: i64 = 0x16CB223D6329D1F0u64 as i64; + pub const NAME: &str = "foxglove_msgs.FrameTransform"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Quaternion::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.timestamp.encode_one(buf)?; + { + let bytes = self.parent_frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.child_frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + self.translation.encode_one(buf)?; + self.rotation.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let parent_frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let child_frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let translation = crate::geometry_msgs::Vector3::decode_one(buf)?; + let rotation = crate::geometry_msgs::Quaternion::decode_one(buf)?; + Ok(Self { + timestamp, + parent_frame_id, + child_frame_id, + translation, + rotation, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.timestamp.encoded_size(); + size += 4 + self.parent_frame_id.len() + 1; + size += 4 + self.child_frame_id.len() + 1; + size += self.translation.encoded_size(); + size += self.rotation.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/frame_transforms.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/frame_transforms.rs new file mode 100644 index 0000000..24bb15f --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/frame_transforms.rs @@ -0,0 +1,84 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct FrameTransforms { + pub transforms: Vec, +} + +impl FrameTransforms { + pub const HASH: i64 = 0x37BC5CBCE50A5CE2u64 as i64; + pub const NAME: &str = "foxglove_msgs.FrameTransforms"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::FrameTransform::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.transforms.len() as i32)?; + for v0 in self.transforms.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let transforms_length = buf.read_i32::()? as usize; + let transforms = { + let mut v = Vec::with_capacity(transforms_length); + for _ in 0..transforms_length { + let _elem_0 = crate::foxglove_msgs::FrameTransform::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + transforms, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + for v0 in self.transforms.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/geo_json.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/geo_json.rs new file mode 100644 index 0000000..595b3bd --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/geo_json.rs @@ -0,0 +1,80 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct GeoJSON { + pub geojson: std::string::String, +} + +impl GeoJSON { + pub const HASH: i64 = 0x15423F51794B2EBCu64 as i64; + pub const NAME: &str = "foxglove_msgs.GeoJSON"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + { + let bytes = self.geojson.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let geojson = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + geojson, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4 + self.geojson.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/grid.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/grid.rs new file mode 100644 index 0000000..453c702 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/grid.rs @@ -0,0 +1,145 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Grid { + pub timestamp: crate::builtin_interfaces::Time, + pub frame_id: std::string::String, + pub pose: crate::geometry_msgs::Pose, + pub column_count: i32, + pub cell_size: crate::foxglove_msgs::Vector2, + pub row_stride: i32, + pub cell_stride: i32, + pub fields: Vec, + pub data: Vec, +} + +impl Grid { + pub const HASH: i64 = 0x91F7114ED51A5321u64 as i64; + pub const NAME: &str = "foxglove_msgs.Grid"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Vector2::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::PackedElementField::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.fields.len() as i32)?; + buf.write_i32::(self.data.len() as i32)?; + self.timestamp.encode_one(buf)?; + { + let bytes = self.frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + self.pose.encode_one(buf)?; + buf.write_i32::(self.column_count)?; + self.cell_size.encode_one(buf)?; + buf.write_i32::(self.row_stride)?; + buf.write_i32::(self.cell_stride)?; + for v0 in self.fields.iter() { + v0.encode_one(buf)?; + } + buf.write_all(&self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let fields_length = buf.read_i32::()? as usize; + let data_length = buf.read_i32::()? as usize; + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let column_count = buf.read_i32::()?; + let cell_size = crate::foxglove_msgs::Vector2::decode_one(buf)?; + let row_stride = buf.read_i32::()?; + let cell_stride = buf.read_i32::()?; + let fields = { + let mut v = Vec::with_capacity(fields_length); + for _ in 0..fields_length { + let _elem_0 = crate::foxglove_msgs::PackedElementField::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let data = { + let mut v = vec![0u8; data_length]; + buf.read_exact(&mut v)?; + v + }; + Ok(Self { + timestamp, + frame_id, + pose, + column_count, + cell_size, + row_stride, + cell_stride, + fields, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += self.timestamp.encoded_size(); + size += 4 + self.frame_id.len() + 1; + size += self.pose.encoded_size(); + size += 4; + size += self.cell_size.encoded_size(); + size += 4; + size += 4; + for v0 in self.fields.iter() { + size += v0.encoded_size(); + } + size += self.data.len(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/image_annotations.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/image_annotations.rs new file mode 100644 index 0000000..fdd5bfb --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/image_annotations.rs @@ -0,0 +1,124 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct ImageAnnotations { + pub circles: Vec, + pub points: Vec, + pub texts: Vec, +} + +impl ImageAnnotations { + pub const HASH: i64 = 0x8B3A52C632C59B07u64 as i64; + pub const NAME: &str = "foxglove_msgs.ImageAnnotations"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::CircleAnnotation::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::PointsAnnotation::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::TextAnnotation::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.circles.len() as i32)?; + buf.write_i32::(self.points.len() as i32)?; + buf.write_i32::(self.texts.len() as i32)?; + for v0 in self.circles.iter() { + v0.encode_one(buf)?; + } + for v0 in self.points.iter() { + v0.encode_one(buf)?; + } + for v0 in self.texts.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let circles_length = buf.read_i32::()? as usize; + let points_length = buf.read_i32::()? as usize; + let texts_length = buf.read_i32::()? as usize; + let circles = { + let mut v = Vec::with_capacity(circles_length); + for _ in 0..circles_length { + let _elem_0 = crate::foxglove_msgs::CircleAnnotation::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let points = { + let mut v = Vec::with_capacity(points_length); + for _ in 0..points_length { + let _elem_0 = crate::foxglove_msgs::PointsAnnotation::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let texts = { + let mut v = Vec::with_capacity(texts_length); + for _ in 0..texts_length { + let _elem_0 = crate::foxglove_msgs::TextAnnotation::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + circles, + points, + texts, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += 4; + for v0 in self.circles.iter() { + size += v0.encoded_size(); + } + for v0 in self.points.iter() { + size += v0.encoded_size(); + } + for v0 in self.texts.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/key_value_pair.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/key_value_pair.rs new file mode 100644 index 0000000..e11245b --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/key_value_pair.rs @@ -0,0 +1,96 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct KeyValuePair { + pub key: std::string::String, + pub value: std::string::String, +} + +impl KeyValuePair { + pub const HASH: i64 = 0x97574015D52EEDDEu64 as i64; + pub const NAME: &str = "foxglove_msgs.KeyValuePair"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + { + let bytes = self.key.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.value.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let key = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let value = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + key, + value, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4 + self.key.len() + 1; + size += 4 + self.value.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/laser_scan.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/laser_scan.rs new file mode 100644 index 0000000..a83725a --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/laser_scan.rs @@ -0,0 +1,136 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct LaserScan { + pub timestamp: crate::builtin_interfaces::Time, + pub frame_id: std::string::String, + pub pose: crate::geometry_msgs::Pose, + pub start_angle: f64, + pub end_angle: f64, + pub ranges: Vec, + pub intensities: Vec, +} + +impl LaserScan { + pub const HASH: i64 = 0x22E7C769BA6A90C2u64 as i64; + pub const NAME: &str = "foxglove_msgs.LaserScan"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.ranges.len() as i32)?; + buf.write_i32::(self.intensities.len() as i32)?; + self.timestamp.encode_one(buf)?; + { + let bytes = self.frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + self.pose.encode_one(buf)?; + buf.write_f64::(self.start_angle)?; + buf.write_f64::(self.end_angle)?; + for v0 in self.ranges.iter() { + buf.write_f64::(*v0)?; + } + for v0 in self.intensities.iter() { + buf.write_f64::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let ranges_length = buf.read_i32::()? as usize; + let intensities_length = buf.read_i32::()? as usize; + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let start_angle = buf.read_f64::()?; + let end_angle = buf.read_f64::()?; + let ranges = { + let mut v = Vec::with_capacity(ranges_length); + for _ in 0..ranges_length { + let _elem_0 = buf.read_f64::()?; + v.push(_elem_0); + } + v + }; + let intensities = { + let mut v = Vec::with_capacity(intensities_length); + for _ in 0..intensities_length { + let _elem_0 = buf.read_f64::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + timestamp, + frame_id, + pose, + start_angle, + end_angle, + ranges, + intensities, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += self.timestamp.encoded_size(); + size += 4 + self.frame_id.len() + 1; + size += self.pose.encoded_size(); + size += 8; + size += 8; + size += self.ranges.len() * 8; + size += self.intensities.len() * 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/line_primitive.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/line_primitive.rs new file mode 100644 index 0000000..20feb7e --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/line_primitive.rs @@ -0,0 +1,152 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct LinePrimitive { + pub r#type: u8, + pub pose: crate::geometry_msgs::Pose, + pub thickness: f64, + pub scale_invariant: bool, + pub points: Vec, + pub color: crate::foxglove_msgs::Color, + pub colors: Vec, + pub indices: Vec, +} + +impl LinePrimitive { + pub const HASH: i64 = 0x3B39F8EB653B3CD3u64 as i64; + pub const NAME: &str = "foxglove_msgs.LinePrimitive"; + + pub const LINE_STRIP: i8 = 0; + pub const LINE_LOOP: i8 = 1; + pub const LINE_LIST: i8 = 2; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Point::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.points.len() as i32)?; + buf.write_i32::(self.colors.len() as i32)?; + buf.write_i32::(self.indices.len() as i32)?; + buf.write_u8(self.r#type)?; + self.pose.encode_one(buf)?; + buf.write_f64::(self.thickness)?; + buf.write_i8(if self.scale_invariant { 1 } else { 0 })?; + for v0 in self.points.iter() { + v0.encode_one(buf)?; + } + self.color.encode_one(buf)?; + for v0 in self.colors.iter() { + v0.encode_one(buf)?; + } + for v0 in self.indices.iter() { + buf.write_i32::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let points_length = buf.read_i32::()? as usize; + let colors_length = buf.read_i32::()? as usize; + let indices_length = buf.read_i32::()? as usize; + let r#type = buf.read_u8()?; + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let thickness = buf.read_f64::()?; + let scale_invariant = buf.read_i8()? != 0; + let points = { + let mut v = Vec::with_capacity(points_length); + for _ in 0..points_length { + let _elem_0 = crate::geometry_msgs::Point::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let color = crate::foxglove_msgs::Color::decode_one(buf)?; + let colors = { + let mut v = Vec::with_capacity(colors_length); + for _ in 0..colors_length { + let _elem_0 = crate::foxglove_msgs::Color::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let indices = { + let mut v = Vec::with_capacity(indices_length); + for _ in 0..indices_length { + let _elem_0 = buf.read_i32::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + r#type, + pose, + thickness, + scale_invariant, + points, + color, + colors, + indices, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += 4; + size += 1; + size += self.pose.encoded_size(); + size += 8; + size += 1; + for v0 in self.points.iter() { + size += v0.encoded_size(); + } + size += self.color.encoded_size(); + for v0 in self.colors.iter() { + size += v0.encoded_size(); + } + size += self.indices.len() * 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/location_fix.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/location_fix.rs new file mode 100644 index 0000000..76076a7 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/location_fix.rs @@ -0,0 +1,124 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct LocationFix { + pub timestamp: crate::builtin_interfaces::Time, + pub frame_id: std::string::String, + pub latitude: f64, + pub longitude: f64, + pub altitude: f64, + pub position_covariance: [f64; 9], + pub position_covariance_type: u8, +} + +impl LocationFix { + pub const HASH: i64 = 0xC7C172F7D2332F54u64 as i64; + pub const NAME: &str = "foxglove_msgs.LocationFix"; + + pub const UNKNOWN: i8 = 0; + pub const APPROXIMATED: i8 = 1; + pub const DIAGONAL_KNOWN: i8 = 2; + pub const KNOWN: i8 = 3; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.timestamp.encode_one(buf)?; + { + let bytes = self.frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_f64::(self.latitude)?; + buf.write_f64::(self.longitude)?; + buf.write_f64::(self.altitude)?; + for v0 in self.position_covariance.iter() { + buf.write_f64::(*v0)?; + } + buf.write_u8(self.position_covariance_type)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let latitude = buf.read_f64::()?; + let longitude = buf.read_f64::()?; + let altitude = buf.read_f64::()?; + let position_covariance = { + let mut _arr_0 = [0.0f64; 9]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + let position_covariance_type = buf.read_u8()?; + Ok(Self { + timestamp, + frame_id, + latitude, + longitude, + altitude, + position_covariance, + position_covariance_type, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.timestamp.encoded_size(); + size += 4 + self.frame_id.len() + 1; + size += 8; + size += 8; + size += 8; + size += self.position_covariance.len() * 8; + size += 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/log.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/log.rs new file mode 100644 index 0000000..d5b8113 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/log.rs @@ -0,0 +1,135 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Log { + pub timestamp: crate::builtin_interfaces::Time, + pub level: u8, + pub message: std::string::String, + pub name: std::string::String, + pub file: std::string::String, + pub line: i32, +} + +impl Log { + pub const HASH: i64 = 0x623DAE456E90A1C7u64 as i64; + pub const NAME: &str = "foxglove_msgs.Log"; + + pub const UNKNOWN: i8 = 0; + pub const DEBUG: i8 = 1; + pub const INFO: i8 = 2; + pub const WARNING: i8 = 3; + pub const ERROR: i8 = 4; + pub const FATAL: i8 = 5; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.timestamp.encode_one(buf)?; + buf.write_u8(self.level)?; + { + let bytes = self.message.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.name.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.file.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_i32::(self.line)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let level = buf.read_u8()?; + let message = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let name = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let file = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let line = buf.read_i32::()?; + Ok(Self { + timestamp, + level, + message, + name, + file, + line, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.timestamp.encoded_size(); + size += 1; + size += 4 + self.message.len() + 1; + size += 4 + self.name.len() + 1; + size += 4 + self.file.len() + 1; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/mod.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/mod.rs new file mode 100644 index 0000000..d67ed4b --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/mod.rs @@ -0,0 +1,106 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +mod arrow_primitive; +pub use arrow_primitive::ArrowPrimitive; + +mod camera_calibration; +pub use camera_calibration::CameraCalibration; + +mod circle_annotation; +pub use circle_annotation::CircleAnnotation; + +mod color; +pub use color::Color; + +mod compressed_image; +pub use compressed_image::CompressedImage; + +mod compressed_video; +pub use compressed_video::CompressedVideo; + +mod cube_primitive; +pub use cube_primitive::CubePrimitive; + +mod cylinder_primitive; +pub use cylinder_primitive::CylinderPrimitive; + +mod frame_transform; +pub use frame_transform::FrameTransform; + +mod frame_transforms; +pub use frame_transforms::FrameTransforms; + +mod geo_json; +pub use geo_json::GeoJSON; + +mod grid; +pub use grid::Grid; + +mod image_annotations; +pub use image_annotations::ImageAnnotations; + +mod key_value_pair; +pub use key_value_pair::KeyValuePair; + +mod laser_scan; +pub use laser_scan::LaserScan; + +mod line_primitive; +pub use line_primitive::LinePrimitive; + +mod location_fix; +pub use location_fix::LocationFix; + +mod log; +pub use log::Log; + +mod model_primitive; +pub use model_primitive::ModelPrimitive; + +mod packed_element_field; +pub use packed_element_field::PackedElementField; + +mod point2; +pub use point2::Point2; + +mod point_cloud; +pub use point_cloud::PointCloud; + +mod points_annotation; +pub use points_annotation::PointsAnnotation; + +mod pose_in_frame; +pub use pose_in_frame::PoseInFrame; + +mod poses_in_frame; +pub use poses_in_frame::PosesInFrame; + +mod raw_audio; +pub use raw_audio::RawAudio; + +mod raw_image; +pub use raw_image::RawImage; + +mod scene_entity; +pub use scene_entity::SceneEntity; + +mod scene_entity_deletion; +pub use scene_entity_deletion::SceneEntityDeletion; + +mod scene_update; +pub use scene_update::SceneUpdate; + +mod sphere_primitive; +pub use sphere_primitive::SpherePrimitive; + +mod text_annotation; +pub use text_annotation::TextAnnotation; + +mod text_primitive; +pub use text_primitive::TextPrimitive; + +mod triangle_list_primitive; +pub use triangle_list_primitive::TriangleListPrimitive; + +mod vector2; +pub use vector2::Vector2; diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/model_primitive.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/model_primitive.rs new file mode 100644 index 0000000..046f4fd --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/model_primitive.rs @@ -0,0 +1,131 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct ModelPrimitive { + pub pose: crate::geometry_msgs::Pose, + pub scale: crate::geometry_msgs::Vector3, + pub color: crate::foxglove_msgs::Color, + pub override_color: bool, + pub url: std::string::String, + pub media_type: std::string::String, + pub data: Vec, +} + +impl ModelPrimitive { + pub const HASH: i64 = 0x23CD41BA898FA1FAu64 as i64; + pub const NAME: &str = "foxglove_msgs.ModelPrimitive"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.pose.encode_one(buf)?; + self.scale.encode_one(buf)?; + self.color.encode_one(buf)?; + buf.write_i8(if self.override_color { 1 } else { 0 })?; + { + let bytes = self.url.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.media_type.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_all(&self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let scale = crate::geometry_msgs::Vector3::decode_one(buf)?; + let color = crate::foxglove_msgs::Color::decode_one(buf)?; + let override_color = buf.read_i8()? != 0; + let url = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let media_type = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let data = { + let mut v = vec![0u8; data_length]; + buf.read_exact(&mut v)?; + v + }; + Ok(Self { + pose, + scale, + color, + override_color, + url, + media_type, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.pose.encoded_size(); + size += self.scale.encoded_size(); + size += self.color.encoded_size(); + size += 1; + size += 4 + self.url.len() + 1; + size += 4 + self.media_type.len() + 1; + size += self.data.len(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/packed_element_field.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/packed_element_field.rs new file mode 100644 index 0000000..fdbe23b --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/packed_element_field.rs @@ -0,0 +1,100 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct PackedElementField { + pub name: std::string::String, + pub offset: i32, + pub r#type: u8, +} + +impl PackedElementField { + pub const HASH: i64 = 0x47C85BA0FAFA16B8u64 as i64; + pub const NAME: &str = "foxglove_msgs.PackedElementField"; + + pub const UNKNOWN: i8 = 0; + pub const UINT8: i8 = 1; + pub const INT8: i8 = 2; + pub const UINT16: i8 = 3; + pub const INT16: i8 = 4; + pub const UINT32: i8 = 5; + pub const INT32: i8 = 6; + pub const FLOAT32: i8 = 7; + pub const FLOAT64: i8 = 8; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + { + let bytes = self.name.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_i32::(self.offset)?; + buf.write_u8(self.r#type)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let name = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let offset = buf.read_i32::()?; + let r#type = buf.read_u8()?; + Ok(Self { + name, + offset, + r#type, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4 + self.name.len() + 1; + size += 4; + size += 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/point2.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/point2.rs new file mode 100644 index 0000000..bc29bb6 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/point2.rs @@ -0,0 +1,74 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Point2 { + pub x: f64, + pub y: f64, +} + +impl Point2 { + pub const HASH: i64 = 0xD259512E30B44885u64 as i64; + pub const NAME: &str = "foxglove_msgs.Point2"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_f64::(self.x)?; + buf.write_f64::(self.y)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let x = buf.read_f64::()?; + let y = buf.read_f64::()?; + Ok(Self { + x, + y, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 8; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/point_cloud.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/point_cloud.rs new file mode 100644 index 0000000..5f31b7e --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/point_cloud.rs @@ -0,0 +1,129 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct PointCloud { + pub timestamp: crate::builtin_interfaces::Time, + pub frame_id: std::string::String, + pub pose: crate::geometry_msgs::Pose, + pub point_stride: i32, + pub fields: Vec, + pub data: Vec, +} + +impl PointCloud { + pub const HASH: i64 = 0x4F3713AA9B8DC878u64 as i64; + pub const NAME: &str = "foxglove_msgs.PointCloud"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::PackedElementField::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.fields.len() as i32)?; + buf.write_i32::(self.data.len() as i32)?; + self.timestamp.encode_one(buf)?; + { + let bytes = self.frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + self.pose.encode_one(buf)?; + buf.write_i32::(self.point_stride)?; + for v0 in self.fields.iter() { + v0.encode_one(buf)?; + } + buf.write_all(&self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let fields_length = buf.read_i32::()? as usize; + let data_length = buf.read_i32::()? as usize; + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let point_stride = buf.read_i32::()?; + let fields = { + let mut v = Vec::with_capacity(fields_length); + for _ in 0..fields_length { + let _elem_0 = crate::foxglove_msgs::PackedElementField::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let data = { + let mut v = vec![0u8; data_length]; + buf.read_exact(&mut v)?; + v + }; + Ok(Self { + timestamp, + frame_id, + pose, + point_stride, + fields, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += self.timestamp.encoded_size(); + size += 4 + self.frame_id.len() + 1; + size += self.pose.encoded_size(); + size += 4; + for v0 in self.fields.iter() { + size += v0.encoded_size(); + } + size += self.data.len(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/points_annotation.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/points_annotation.rs new file mode 100644 index 0000000..7056fa7 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/points_annotation.rs @@ -0,0 +1,138 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct PointsAnnotation { + pub timestamp: crate::builtin_interfaces::Time, + pub r#type: u8, + pub points: Vec, + pub outline_color: crate::foxglove_msgs::Color, + pub outline_colors: Vec, + pub fill_color: crate::foxglove_msgs::Color, + pub thickness: f64, +} + +impl PointsAnnotation { + pub const HASH: i64 = 0x97465363CC7C2A18u64 as i64; + pub const NAME: &str = "foxglove_msgs.PointsAnnotation"; + + pub const UNKNOWN: i8 = 0; + pub const POINTS: i8 = 1; + pub const LINE_LOOP: i8 = 2; + pub const LINE_STRIP: i8 = 3; + pub const LINE_LIST: i8 = 4; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Point2::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.points.len() as i32)?; + buf.write_i32::(self.outline_colors.len() as i32)?; + self.timestamp.encode_one(buf)?; + buf.write_u8(self.r#type)?; + for v0 in self.points.iter() { + v0.encode_one(buf)?; + } + self.outline_color.encode_one(buf)?; + for v0 in self.outline_colors.iter() { + v0.encode_one(buf)?; + } + self.fill_color.encode_one(buf)?; + buf.write_f64::(self.thickness)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let points_length = buf.read_i32::()? as usize; + let outline_colors_length = buf.read_i32::()? as usize; + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let r#type = buf.read_u8()?; + let points = { + let mut v = Vec::with_capacity(points_length); + for _ in 0..points_length { + let _elem_0 = crate::foxglove_msgs::Point2::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let outline_color = crate::foxglove_msgs::Color::decode_one(buf)?; + let outline_colors = { + let mut v = Vec::with_capacity(outline_colors_length); + for _ in 0..outline_colors_length { + let _elem_0 = crate::foxglove_msgs::Color::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let fill_color = crate::foxglove_msgs::Color::decode_one(buf)?; + let thickness = buf.read_f64::()?; + Ok(Self { + timestamp, + r#type, + points, + outline_color, + outline_colors, + fill_color, + thickness, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += self.timestamp.encoded_size(); + size += 1; + for v0 in self.points.iter() { + size += v0.encoded_size(); + } + size += self.outline_color.encoded_size(); + for v0 in self.outline_colors.iter() { + size += v0.encoded_size(); + } + size += self.fill_color.encoded_size(); + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/pose_in_frame.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/pose_in_frame.rs new file mode 100644 index 0000000..da4fcd6 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/pose_in_frame.rs @@ -0,0 +1,92 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct PoseInFrame { + pub timestamp: crate::builtin_interfaces::Time, + pub frame_id: std::string::String, + pub pose: crate::geometry_msgs::Pose, +} + +impl PoseInFrame { + pub const HASH: i64 = 0x84C6EF3A0A4C5CD6u64 as i64; + pub const NAME: &str = "foxglove_msgs.PoseInFrame"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.timestamp.encode_one(buf)?; + { + let bytes = self.frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + self.pose.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + Ok(Self { + timestamp, + frame_id, + pose, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.timestamp.encoded_size(); + size += 4 + self.frame_id.len() + 1; + size += self.pose.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/poses_in_frame.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/poses_in_frame.rs new file mode 100644 index 0000000..26d7351 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/poses_in_frame.rs @@ -0,0 +1,106 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct PosesInFrame { + pub timestamp: crate::builtin_interfaces::Time, + pub frame_id: std::string::String, + pub poses: Vec, +} + +impl PosesInFrame { + pub const HASH: i64 = 0x65F6CEE7D8076F4Bu64 as i64; + pub const NAME: &str = "foxglove_msgs.PosesInFrame"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.poses.len() as i32)?; + self.timestamp.encode_one(buf)?; + { + let bytes = self.frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + for v0 in self.poses.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let poses_length = buf.read_i32::()? as usize; + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let poses = { + let mut v = Vec::with_capacity(poses_length); + for _ in 0..poses_length { + let _elem_0 = crate::geometry_msgs::Pose::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + timestamp, + frame_id, + poses, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.timestamp.encoded_size(); + size += 4 + self.frame_id.len() + 1; + for v0 in self.poses.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/raw_audio.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/raw_audio.rs new file mode 100644 index 0000000..98c2c75 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/raw_audio.rs @@ -0,0 +1,108 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct RawAudio { + pub timestamp: crate::builtin_interfaces::Time, + pub data: Vec, + pub format: std::string::String, + pub sample_rate: i32, + pub number_of_channels: i32, +} + +impl RawAudio { + pub const HASH: i64 = 0xC7F2A980CD122F7Du64 as i64; + pub const NAME: &str = "foxglove_msgs.RawAudio"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.timestamp.encode_one(buf)?; + buf.write_all(&self.data)?; + { + let bytes = self.format.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_i32::(self.sample_rate)?; + buf.write_i32::(self.number_of_channels)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let data = { + let mut v = vec![0u8; data_length]; + buf.read_exact(&mut v)?; + v + }; + let format = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let sample_rate = buf.read_i32::()?; + let number_of_channels = buf.read_i32::()?; + Ok(Self { + timestamp, + data, + format, + sample_rate, + number_of_channels, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.timestamp.encoded_size(); + size += self.data.len(); + size += 4 + self.format.len() + 1; + size += 4; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/raw_image.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/raw_image.rs new file mode 100644 index 0000000..7faf76f --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/raw_image.rs @@ -0,0 +1,129 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct RawImage { + pub timestamp: crate::builtin_interfaces::Time, + pub frame_id: std::string::String, + pub width: i32, + pub height: i32, + pub encoding: std::string::String, + pub step: i32, + pub data: Vec, +} + +impl RawImage { + pub const HASH: i64 = 0x8DC0DA8AA491BB39u64 as i64; + pub const NAME: &str = "foxglove_msgs.RawImage"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.timestamp.encode_one(buf)?; + { + let bytes = self.frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_i32::(self.width)?; + buf.write_i32::(self.height)?; + { + let bytes = self.encoding.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_i32::(self.step)?; + buf.write_all(&self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let width = buf.read_i32::()?; + let height = buf.read_i32::()?; + let encoding = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let step = buf.read_i32::()?; + let data = { + let mut v = vec![0u8; data_length]; + buf.read_exact(&mut v)?; + v + }; + Ok(Self { + timestamp, + frame_id, + width, + height, + encoding, + step, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.timestamp.encoded_size(); + size += 4 + self.frame_id.len() + 1; + size += 4; + size += 4; + size += 4 + self.encoding.len() + 1; + size += 4; + size += self.data.len(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/scene_entity.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/scene_entity.rs new file mode 100644 index 0000000..3b0a11f --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/scene_entity.rs @@ -0,0 +1,293 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct SceneEntity { + pub timestamp: crate::builtin_interfaces::Time, + pub frame_id: std::string::String, + pub id: std::string::String, + pub lifetime: crate::builtin_interfaces::Duration, + pub frame_locked: bool, + pub metadata: Vec, + pub arrows: Vec, + pub cubes: Vec, + pub spheres: Vec, + pub cylinders: Vec, + pub lines: Vec, + pub triangles: Vec, + pub texts: Vec, + pub models: Vec, +} + +impl SceneEntity { + pub const HASH: i64 = 0xE143D679579F0AB0u64 as i64; + pub const NAME: &str = "foxglove_msgs.SceneEntity"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Duration::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::KeyValuePair::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::ArrowPrimitive::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::CubePrimitive::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::SpherePrimitive::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::CylinderPrimitive::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::LinePrimitive::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::TriangleListPrimitive::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::TextPrimitive::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::ModelPrimitive::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.metadata.len() as i32)?; + buf.write_i32::(self.arrows.len() as i32)?; + buf.write_i32::(self.cubes.len() as i32)?; + buf.write_i32::(self.spheres.len() as i32)?; + buf.write_i32::(self.cylinders.len() as i32)?; + buf.write_i32::(self.lines.len() as i32)?; + buf.write_i32::(self.triangles.len() as i32)?; + buf.write_i32::(self.texts.len() as i32)?; + buf.write_i32::(self.models.len() as i32)?; + self.timestamp.encode_one(buf)?; + { + let bytes = self.frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + self.lifetime.encode_one(buf)?; + buf.write_i8(if self.frame_locked { 1 } else { 0 })?; + for v0 in self.metadata.iter() { + v0.encode_one(buf)?; + } + for v0 in self.arrows.iter() { + v0.encode_one(buf)?; + } + for v0 in self.cubes.iter() { + v0.encode_one(buf)?; + } + for v0 in self.spheres.iter() { + v0.encode_one(buf)?; + } + for v0 in self.cylinders.iter() { + v0.encode_one(buf)?; + } + for v0 in self.lines.iter() { + v0.encode_one(buf)?; + } + for v0 in self.triangles.iter() { + v0.encode_one(buf)?; + } + for v0 in self.texts.iter() { + v0.encode_one(buf)?; + } + for v0 in self.models.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let metadata_length = buf.read_i32::()? as usize; + let arrows_length = buf.read_i32::()? as usize; + let cubes_length = buf.read_i32::()? as usize; + let spheres_length = buf.read_i32::()? as usize; + let cylinders_length = buf.read_i32::()? as usize; + let lines_length = buf.read_i32::()? as usize; + let triangles_length = buf.read_i32::()? as usize; + let texts_length = buf.read_i32::()? as usize; + let models_length = buf.read_i32::()? as usize; + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let lifetime = crate::builtin_interfaces::Duration::decode_one(buf)?; + let frame_locked = buf.read_i8()? != 0; + let metadata = { + let mut v = Vec::with_capacity(metadata_length); + for _ in 0..metadata_length { + let _elem_0 = crate::foxglove_msgs::KeyValuePair::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let arrows = { + let mut v = Vec::with_capacity(arrows_length); + for _ in 0..arrows_length { + let _elem_0 = crate::foxglove_msgs::ArrowPrimitive::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let cubes = { + let mut v = Vec::with_capacity(cubes_length); + for _ in 0..cubes_length { + let _elem_0 = crate::foxglove_msgs::CubePrimitive::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let spheres = { + let mut v = Vec::with_capacity(spheres_length); + for _ in 0..spheres_length { + let _elem_0 = crate::foxglove_msgs::SpherePrimitive::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let cylinders = { + let mut v = Vec::with_capacity(cylinders_length); + for _ in 0..cylinders_length { + let _elem_0 = crate::foxglove_msgs::CylinderPrimitive::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let lines = { + let mut v = Vec::with_capacity(lines_length); + for _ in 0..lines_length { + let _elem_0 = crate::foxglove_msgs::LinePrimitive::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let triangles = { + let mut v = Vec::with_capacity(triangles_length); + for _ in 0..triangles_length { + let _elem_0 = crate::foxglove_msgs::TriangleListPrimitive::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let texts = { + let mut v = Vec::with_capacity(texts_length); + for _ in 0..texts_length { + let _elem_0 = crate::foxglove_msgs::TextPrimitive::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let models = { + let mut v = Vec::with_capacity(models_length); + for _ in 0..models_length { + let _elem_0 = crate::foxglove_msgs::ModelPrimitive::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + timestamp, + frame_id, + id, + lifetime, + frame_locked, + metadata, + arrows, + cubes, + spheres, + cylinders, + lines, + triangles, + texts, + models, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += 4; + size += 4; + size += 4; + size += 4; + size += 4; + size += 4; + size += 4; + size += self.timestamp.encoded_size(); + size += 4 + self.frame_id.len() + 1; + size += 4 + self.id.len() + 1; + size += self.lifetime.encoded_size(); + size += 1; + for v0 in self.metadata.iter() { + size += v0.encoded_size(); + } + for v0 in self.arrows.iter() { + size += v0.encoded_size(); + } + for v0 in self.cubes.iter() { + size += v0.encoded_size(); + } + for v0 in self.spheres.iter() { + size += v0.encoded_size(); + } + for v0 in self.cylinders.iter() { + size += v0.encoded_size(); + } + for v0 in self.lines.iter() { + size += v0.encoded_size(); + } + for v0 in self.triangles.iter() { + size += v0.encoded_size(); + } + for v0 in self.texts.iter() { + size += v0.encoded_size(); + } + for v0 in self.models.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/scene_entity_deletion.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/scene_entity_deletion.rs new file mode 100644 index 0000000..b72d969 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/scene_entity_deletion.rs @@ -0,0 +1,94 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct SceneEntityDeletion { + pub timestamp: crate::builtin_interfaces::Time, + pub r#type: u8, + pub id: std::string::String, +} + +impl SceneEntityDeletion { + pub const HASH: i64 = 0xA6B01FA4694DA548u64 as i64; + pub const NAME: &str = "foxglove_msgs.SceneEntityDeletion"; + + pub const MATCHING_ID: i8 = 0; + pub const ALL: i8 = 1; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.timestamp.encode_one(buf)?; + buf.write_u8(self.r#type)?; + { + let bytes = self.id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let r#type = buf.read_u8()?; + let id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + timestamp, + r#type, + id, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.timestamp.encoded_size(); + size += 1; + size += 4 + self.id.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/scene_update.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/scene_update.rs new file mode 100644 index 0000000..8e50124 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/scene_update.rs @@ -0,0 +1,104 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct SceneUpdate { + pub deletions: Vec, + pub entities: Vec, +} + +impl SceneUpdate { + pub const HASH: i64 = 0x8F9D4EE9E2A92D31u64 as i64; + pub const NAME: &str = "foxglove_msgs.SceneUpdate"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::SceneEntityDeletion::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::SceneEntity::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.deletions.len() as i32)?; + buf.write_i32::(self.entities.len() as i32)?; + for v0 in self.deletions.iter() { + v0.encode_one(buf)?; + } + for v0 in self.entities.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let deletions_length = buf.read_i32::()? as usize; + let entities_length = buf.read_i32::()? as usize; + let deletions = { + let mut v = Vec::with_capacity(deletions_length); + for _ in 0..deletions_length { + let _elem_0 = crate::foxglove_msgs::SceneEntityDeletion::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let entities = { + let mut v = Vec::with_capacity(entities_length); + for _ in 0..entities_length { + let _elem_0 = crate::foxglove_msgs::SceneEntity::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + deletions, + entities, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + for v0 in self.deletions.iter() { + size += v0.encoded_size(); + } + for v0 in self.entities.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/sphere_primitive.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/sphere_primitive.rs new file mode 100644 index 0000000..4001e33 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/sphere_primitive.rs @@ -0,0 +1,82 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct SpherePrimitive { + pub pose: crate::geometry_msgs::Pose, + pub size: crate::geometry_msgs::Vector3, + pub color: crate::foxglove_msgs::Color, +} + +impl SpherePrimitive { + pub const HASH: i64 = 0xE7E8912EA6542887u64 as i64; + pub const NAME: &str = "foxglove_msgs.SpherePrimitive"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.pose.encode_one(buf)?; + self.size.encode_one(buf)?; + self.color.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let size = crate::geometry_msgs::Vector3::decode_one(buf)?; + let color = crate::foxglove_msgs::Color::decode_one(buf)?; + Ok(Self { + pose, + size, + color, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.pose.encoded_size(); + size += self.size.encoded_size(); + size += self.color.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/text_annotation.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/text_annotation.rs new file mode 100644 index 0000000..1ee814a --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/text_annotation.rs @@ -0,0 +1,109 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct TextAnnotation { + pub timestamp: crate::builtin_interfaces::Time, + pub position: crate::foxglove_msgs::Point2, + pub text: std::string::String, + pub font_size: f64, + pub text_color: crate::foxglove_msgs::Color, + pub background_color: crate::foxglove_msgs::Color, +} + +impl TextAnnotation { + pub const HASH: i64 = 0x1354AF1F564701E9u64 as i64; + pub const NAME: &str = "foxglove_msgs.TextAnnotation"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::builtin_interfaces::Time::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Point2::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.timestamp.encode_one(buf)?; + self.position.encode_one(buf)?; + { + let bytes = self.text.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_f64::(self.font_size)?; + self.text_color.encode_one(buf)?; + self.background_color.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let timestamp = crate::builtin_interfaces::Time::decode_one(buf)?; + let position = crate::foxglove_msgs::Point2::decode_one(buf)?; + let text = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let font_size = buf.read_f64::()?; + let text_color = crate::foxglove_msgs::Color::decode_one(buf)?; + let background_color = crate::foxglove_msgs::Color::decode_one(buf)?; + Ok(Self { + timestamp, + position, + text, + font_size, + text_color, + background_color, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.timestamp.encoded_size(); + size += self.position.encoded_size(); + size += 4 + self.text.len() + 1; + size += 8; + size += self.text_color.encoded_size(); + size += self.background_color.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/text_primitive.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/text_primitive.rs new file mode 100644 index 0000000..6b7de8b --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/text_primitive.rs @@ -0,0 +1,107 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct TextPrimitive { + pub pose: crate::geometry_msgs::Pose, + pub billboard: bool, + pub font_size: f64, + pub scale_invariant: bool, + pub color: crate::foxglove_msgs::Color, + pub text: std::string::String, +} + +impl TextPrimitive { + pub const HASH: i64 = 0x3A761DCF4AC0E7C2u64 as i64; + pub const NAME: &str = "foxglove_msgs.TextPrimitive"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.pose.encode_one(buf)?; + buf.write_i8(if self.billboard { 1 } else { 0 })?; + buf.write_f64::(self.font_size)?; + buf.write_i8(if self.scale_invariant { 1 } else { 0 })?; + self.color.encode_one(buf)?; + { + let bytes = self.text.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let billboard = buf.read_i8()? != 0; + let font_size = buf.read_f64::()?; + let scale_invariant = buf.read_i8()? != 0; + let color = crate::foxglove_msgs::Color::decode_one(buf)?; + let text = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + pose, + billboard, + font_size, + scale_invariant, + color, + text, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.pose.encoded_size(); + size += 1; + size += 8; + size += 1; + size += self.color.encoded_size(); + size += 4 + self.text.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/triangle_list_primitive.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/triangle_list_primitive.rs new file mode 100644 index 0000000..b14b579 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/triangle_list_primitive.rs @@ -0,0 +1,133 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct TriangleListPrimitive { + pub pose: crate::geometry_msgs::Pose, + pub points: Vec, + pub color: crate::foxglove_msgs::Color, + pub colors: Vec, + pub indices: Vec, +} + +impl TriangleListPrimitive { + pub const HASH: i64 = 0xCF3047947917A6CCu64 as i64; + pub const NAME: &str = "foxglove_msgs.TriangleListPrimitive"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Point::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::foxglove_msgs::Color::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.points.len() as i32)?; + buf.write_i32::(self.colors.len() as i32)?; + buf.write_i32::(self.indices.len() as i32)?; + self.pose.encode_one(buf)?; + for v0 in self.points.iter() { + v0.encode_one(buf)?; + } + self.color.encode_one(buf)?; + for v0 in self.colors.iter() { + v0.encode_one(buf)?; + } + for v0 in self.indices.iter() { + buf.write_i32::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let points_length = buf.read_i32::()? as usize; + let colors_length = buf.read_i32::()? as usize; + let indices_length = buf.read_i32::()? as usize; + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let points = { + let mut v = Vec::with_capacity(points_length); + for _ in 0..points_length { + let _elem_0 = crate::geometry_msgs::Point::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let color = crate::foxglove_msgs::Color::decode_one(buf)?; + let colors = { + let mut v = Vec::with_capacity(colors_length); + for _ in 0..colors_length { + let _elem_0 = crate::foxglove_msgs::Color::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let indices = { + let mut v = Vec::with_capacity(indices_length); + for _ in 0..indices_length { + let _elem_0 = buf.read_i32::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + pose, + points, + color, + colors, + indices, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += 4; + size += self.pose.encoded_size(); + for v0 in self.points.iter() { + size += v0.encoded_size(); + } + size += self.color.encoded_size(); + for v0 in self.colors.iter() { + size += v0.encoded_size(); + } + size += self.indices.len() * 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/foxglove_msgs/vector2.rs b/generated/rust_lcm_msgs/src/foxglove_msgs/vector2.rs new file mode 100644 index 0000000..34d7b64 --- /dev/null +++ b/generated/rust_lcm_msgs/src/foxglove_msgs/vector2.rs @@ -0,0 +1,74 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Vector2 { + pub x: f64, + pub y: f64, +} + +impl Vector2 { + pub const HASH: i64 = 0xD259512E30B44885u64 as i64; + pub const NAME: &str = "foxglove_msgs.Vector2"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_f64::(self.x)?; + buf.write_f64::(self.y)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let x = buf.read_f64::()?; + let y = buf.read_f64::()?; + Ok(Self { + x, + y, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 8; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/accel.rs b/generated/rust_lcm_msgs/src/geometry_msgs/accel.rs new file mode 100644 index 0000000..4a302a8 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/accel.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Accel { + pub linear: crate::geometry_msgs::Vector3, + pub angular: crate::geometry_msgs::Vector3, +} + +impl Accel { + pub const HASH: i64 = 0x3A4144772922ADD7u64 as i64; + pub const NAME: &str = "geometry_msgs.Accel"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.linear.encode_one(buf)?; + self.angular.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let linear = crate::geometry_msgs::Vector3::decode_one(buf)?; + let angular = crate::geometry_msgs::Vector3::decode_one(buf)?; + Ok(Self { + linear, + angular, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.linear.encoded_size(); + size += self.angular.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/accel_stamped.rs b/generated/rust_lcm_msgs/src/geometry_msgs/accel_stamped.rs new file mode 100644 index 0000000..d2742ea --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/accel_stamped.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct AccelStamped { + pub header: crate::std_msgs::Header, + pub accel: crate::geometry_msgs::Accel, +} + +impl AccelStamped { + pub const HASH: i64 = 0xF012322E268930C2u64 as i64; + pub const NAME: &str = "geometry_msgs.AccelStamped"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Accel::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.accel.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let accel = crate::geometry_msgs::Accel::decode_one(buf)?; + Ok(Self { + header, + accel, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.accel.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/accel_with_covariance.rs b/generated/rust_lcm_msgs/src/geometry_msgs/accel_with_covariance.rs new file mode 100644 index 0000000..7d79b10 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/accel_with_covariance.rs @@ -0,0 +1,92 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, PartialEq)] +pub struct AccelWithCovariance { + pub accel: crate::geometry_msgs::Accel, + pub covariance: [f64; 36], +} + +impl Default for AccelWithCovariance { + fn default() -> Self { + Self { + accel: crate::geometry_msgs::Accel::default(), + covariance: [0f64; 36], + } + } +} + +impl AccelWithCovariance { + pub const HASH: i64 = 0x545F576DFE97951Du64 as i64; + pub const NAME: &str = "geometry_msgs.AccelWithCovariance"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Accel::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.accel.encode_one(buf)?; + for v0 in self.covariance.iter() { + buf.write_f64::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let accel = crate::geometry_msgs::Accel::decode_one(buf)?; + let covariance = { + let mut _arr_0 = [0.0f64; 36]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + Ok(Self { + accel, + covariance, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.accel.encoded_size(); + size += self.covariance.len() * 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/accel_with_covariance_stamped.rs b/generated/rust_lcm_msgs/src/geometry_msgs/accel_with_covariance_stamped.rs new file mode 100644 index 0000000..f37861b --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/accel_with_covariance_stamped.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct AccelWithCovarianceStamped { + pub header: crate::std_msgs::Header, + pub accel: crate::geometry_msgs::AccelWithCovariance, +} + +impl AccelWithCovarianceStamped { + pub const HASH: i64 = 0xF012322E268930C2u64 as i64; + pub const NAME: &str = "geometry_msgs.AccelWithCovarianceStamped"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::AccelWithCovariance::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.accel.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let accel = crate::geometry_msgs::AccelWithCovariance::decode_one(buf)?; + Ok(Self { + header, + accel, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.accel.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/inertia.rs b/generated/rust_lcm_msgs/src/geometry_msgs/inertia.rs new file mode 100644 index 0000000..4fbf73b --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/inertia.rs @@ -0,0 +1,105 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Inertia { + pub m: f64, + pub com: crate::geometry_msgs::Vector3, + pub ixx: f64, + pub ixy: f64, + pub ixz: f64, + pub iyy: f64, + pub iyz: f64, + pub izz: f64, +} + +impl Inertia { + pub const HASH: i64 = 0xBEAA1A2A4C70B2E0u64 as i64; + pub const NAME: &str = "geometry_msgs.Inertia"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_f64::(self.m)?; + self.com.encode_one(buf)?; + buf.write_f64::(self.ixx)?; + buf.write_f64::(self.ixy)?; + buf.write_f64::(self.ixz)?; + buf.write_f64::(self.iyy)?; + buf.write_f64::(self.iyz)?; + buf.write_f64::(self.izz)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let m = buf.read_f64::()?; + let com = crate::geometry_msgs::Vector3::decode_one(buf)?; + let ixx = buf.read_f64::()?; + let ixy = buf.read_f64::()?; + let ixz = buf.read_f64::()?; + let iyy = buf.read_f64::()?; + let iyz = buf.read_f64::()?; + let izz = buf.read_f64::()?; + Ok(Self { + m, + com, + ixx, + ixy, + ixz, + iyy, + iyz, + izz, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 8; + size += self.com.encoded_size(); + size += 8; + size += 8; + size += 8; + size += 8; + size += 8; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/inertia_stamped.rs b/generated/rust_lcm_msgs/src/geometry_msgs/inertia_stamped.rs new file mode 100644 index 0000000..1621974 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/inertia_stamped.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct InertiaStamped { + pub header: crate::std_msgs::Header, + pub inertia: crate::geometry_msgs::Inertia, +} + +impl InertiaStamped { + pub const HASH: i64 = 0x3A39287C292ABED7u64 as i64; + pub const NAME: &str = "geometry_msgs.InertiaStamped"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Inertia::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.inertia.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let inertia = crate::geometry_msgs::Inertia::decode_one(buf)?; + Ok(Self { + header, + inertia, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.inertia.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/mod.rs b/generated/rust_lcm_msgs/src/geometry_msgs/mod.rs new file mode 100644 index 0000000..323641c --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/mod.rs @@ -0,0 +1,88 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +mod accel; +pub use accel::Accel; + +mod accel_stamped; +pub use accel_stamped::AccelStamped; + +mod accel_with_covariance; +pub use accel_with_covariance::AccelWithCovariance; + +mod accel_with_covariance_stamped; +pub use accel_with_covariance_stamped::AccelWithCovarianceStamped; + +mod inertia; +pub use inertia::Inertia; + +mod inertia_stamped; +pub use inertia_stamped::InertiaStamped; + +mod point; +pub use point::Point; + +mod point32; +pub use point32::Point32; + +mod point_stamped; +pub use point_stamped::PointStamped; + +mod polygon; +pub use polygon::Polygon; + +mod polygon_stamped; +pub use polygon_stamped::PolygonStamped; + +mod pose; +pub use pose::Pose; + +mod pose2_d; +pub use pose2_d::Pose2D; + +mod pose_array; +pub use pose_array::PoseArray; + +mod pose_stamped; +pub use pose_stamped::PoseStamped; + +mod pose_with_covariance; +pub use pose_with_covariance::PoseWithCovariance; + +mod pose_with_covariance_stamped; +pub use pose_with_covariance_stamped::PoseWithCovarianceStamped; + +mod quaternion; +pub use quaternion::Quaternion; + +mod quaternion_stamped; +pub use quaternion_stamped::QuaternionStamped; + +mod transform; +pub use transform::Transform; + +mod transform_stamped; +pub use transform_stamped::TransformStamped; + +mod twist; +pub use twist::Twist; + +mod twist_stamped; +pub use twist_stamped::TwistStamped; + +mod twist_with_covariance; +pub use twist_with_covariance::TwistWithCovariance; + +mod twist_with_covariance_stamped; +pub use twist_with_covariance_stamped::TwistWithCovarianceStamped; + +mod vector3; +pub use vector3::Vector3; + +mod vector3_stamped; +pub use vector3_stamped::Vector3Stamped; + +mod wrench; +pub use wrench::Wrench; + +mod wrench_stamped; +pub use wrench_stamped::WrenchStamped; diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/point.rs b/generated/rust_lcm_msgs/src/geometry_msgs/point.rs new file mode 100644 index 0000000..a9602bc --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/point.rs @@ -0,0 +1,79 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Point { + pub x: f64, + pub y: f64, + pub z: f64, +} + +impl Point { + pub const HASH: i64 = 0x573F2FDD2F76508Fu64 as i64; + pub const NAME: &str = "geometry_msgs.Point"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_f64::(self.x)?; + buf.write_f64::(self.y)?; + buf.write_f64::(self.z)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let x = buf.read_f64::()?; + let y = buf.read_f64::()?; + let z = buf.read_f64::()?; + Ok(Self { + x, + y, + z, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 8; + size += 8; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/point32.rs b/generated/rust_lcm_msgs/src/geometry_msgs/point32.rs new file mode 100644 index 0000000..b446383 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/point32.rs @@ -0,0 +1,79 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Point32 { + pub x: f32, + pub y: f32, + pub z: f32, +} + +impl Point32 { + pub const HASH: i64 = 0x2A14F112C253AC0Cu64 as i64; + pub const NAME: &str = "geometry_msgs.Point32"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_f32::(self.x)?; + buf.write_f32::(self.y)?; + buf.write_f32::(self.z)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let x = buf.read_f32::()?; + let y = buf.read_f32::()?; + let z = buf.read_f32::()?; + Ok(Self { + x, + y, + z, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/point_stamped.rs b/generated/rust_lcm_msgs/src/geometry_msgs/point_stamped.rs new file mode 100644 index 0000000..c7b1ee4 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/point_stamped.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct PointStamped { + pub header: crate::std_msgs::Header, + pub point: crate::geometry_msgs::Point, +} + +impl PointStamped { + pub const HASH: i64 = 0xF012413A2C8028C2u64 as i64; + pub const NAME: &str = "geometry_msgs.PointStamped"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Point::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.point.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let point = crate::geometry_msgs::Point::decode_one(buf)?; + Ok(Self { + header, + point, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.point.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/polygon.rs b/generated/rust_lcm_msgs/src/geometry_msgs/polygon.rs new file mode 100644 index 0000000..a75a931 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/polygon.rs @@ -0,0 +1,84 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Polygon { + pub points: Vec, +} + +impl Polygon { + pub const HASH: i64 = 0x5634733B354407E8u64 as i64; + pub const NAME: &str = "geometry_msgs.Polygon"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Point32::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.points.len() as i32)?; + for v0 in self.points.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let points_length = buf.read_i32::()? as usize; + let points = { + let mut v = Vec::with_capacity(points_length); + for _ in 0..points_length { + let _elem_0 = crate::geometry_msgs::Point32::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + points, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + for v0 in self.points.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/polygon_stamped.rs b/generated/rust_lcm_msgs/src/geometry_msgs/polygon_stamped.rs new file mode 100644 index 0000000..a248d1c --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/polygon_stamped.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct PolygonStamped { + pub header: crate::std_msgs::Header, + pub polygon: crate::geometry_msgs::Polygon, +} + +impl PolygonStamped { + pub const HASH: i64 = 0x413A2F753630B1D7u64 as i64; + pub const NAME: &str = "geometry_msgs.PolygonStamped"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Polygon::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.polygon.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let polygon = crate::geometry_msgs::Polygon::decode_one(buf)?; + Ok(Self { + header, + polygon, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.polygon.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/pose.rs b/generated/rust_lcm_msgs/src/geometry_msgs/pose.rs new file mode 100644 index 0000000..ece8eec --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/pose.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Pose { + pub position: crate::geometry_msgs::Point, + pub orientation: crate::geometry_msgs::Quaternion, +} + +impl Pose { + pub const HASH: i64 = 0x2D70DD60BD541272u64 as i64; + pub const NAME: &str = "geometry_msgs.Pose"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Point::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Quaternion::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.position.encode_one(buf)?; + self.orientation.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let position = crate::geometry_msgs::Point::decode_one(buf)?; + let orientation = crate::geometry_msgs::Quaternion::decode_one(buf)?; + Ok(Self { + position, + orientation, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.position.encoded_size(); + size += self.orientation.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/pose2_d.rs b/generated/rust_lcm_msgs/src/geometry_msgs/pose2_d.rs new file mode 100644 index 0000000..811a454 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/pose2_d.rs @@ -0,0 +1,79 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Pose2D { + pub x: f64, + pub y: f64, + pub theta: f64, +} + +impl Pose2D { + pub const HASH: i64 = 0x7491C1074C104593u64 as i64; + pub const NAME: &str = "geometry_msgs.Pose2D"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_f64::(self.x)?; + buf.write_f64::(self.y)?; + buf.write_f64::(self.theta)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let x = buf.read_f64::()?; + let y = buf.read_f64::()?; + let theta = buf.read_f64::()?; + Ok(Self { + x, + y, + theta, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 8; + size += 8; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/pose_array.rs b/generated/rust_lcm_msgs/src/geometry_msgs/pose_array.rs new file mode 100644 index 0000000..e35c6d7 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/pose_array.rs @@ -0,0 +1,90 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct PoseArray { + pub header: crate::std_msgs::Header, + pub poses: Vec, +} + +impl PoseArray { + pub const HASH: i64 = 0xC779B6ACC503055Au64 as i64; + pub const NAME: &str = "geometry_msgs.PoseArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.poses.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.poses.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let poses_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let poses = { + let mut v = Vec::with_capacity(poses_length); + for _ in 0..poses_length { + let _elem_0 = crate::geometry_msgs::Pose::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + poses, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + for v0 in self.poses.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/pose_stamped.rs b/generated/rust_lcm_msgs/src/geometry_msgs/pose_stamped.rs new file mode 100644 index 0000000..bc272aa --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/pose_stamped.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct PoseStamped { + pub header: crate::std_msgs::Header, + pub pose: crate::geometry_msgs::Pose, +} + +impl PoseStamped { + pub const HASH: i64 = 0xE10FEEBEC5C97663u64 as i64; + pub const NAME: &str = "geometry_msgs.PoseStamped"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.pose.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + Ok(Self { + header, + pose, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.pose.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/pose_with_covariance.rs b/generated/rust_lcm_msgs/src/geometry_msgs/pose_with_covariance.rs new file mode 100644 index 0000000..ff15880 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/pose_with_covariance.rs @@ -0,0 +1,92 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, PartialEq)] +pub struct PoseWithCovariance { + pub pose: crate::geometry_msgs::Pose, + pub covariance: [f64; 36], +} + +impl Default for PoseWithCovariance { + fn default() -> Self { + Self { + pose: crate::geometry_msgs::Pose::default(), + covariance: [0f64; 36], + } + } +} + +impl PoseWithCovariance { + pub const HASH: i64 = 0x42DBDFAA69371237u64 as i64; + pub const NAME: &str = "geometry_msgs.PoseWithCovariance"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.pose.encode_one(buf)?; + for v0 in self.covariance.iter() { + buf.write_f64::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let covariance = { + let mut _arr_0 = [0.0f64; 36]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + Ok(Self { + pose, + covariance, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.pose.encoded_size(); + size += self.covariance.len() * 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/pose_with_covariance_stamped.rs b/generated/rust_lcm_msgs/src/geometry_msgs/pose_with_covariance_stamped.rs new file mode 100644 index 0000000..0871d53 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/pose_with_covariance_stamped.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct PoseWithCovarianceStamped { + pub header: crate::std_msgs::Header, + pub pose: crate::geometry_msgs::PoseWithCovariance, +} + +impl PoseWithCovarianceStamped { + pub const HASH: i64 = 0xE10FEEBEC5C97663u64 as i64; + pub const NAME: &str = "geometry_msgs.PoseWithCovarianceStamped"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::PoseWithCovariance::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.pose.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let pose = crate::geometry_msgs::PoseWithCovariance::decode_one(buf)?; + Ok(Self { + header, + pose, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.pose.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/quaternion.rs b/generated/rust_lcm_msgs/src/geometry_msgs/quaternion.rs new file mode 100644 index 0000000..4c31b4f --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/quaternion.rs @@ -0,0 +1,84 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Quaternion { + pub x: f64, + pub y: f64, + pub z: f64, + pub w: f64, +} + +impl Quaternion { + pub const HASH: i64 = 0x9B1DEE9DFC8C0515u64 as i64; + pub const NAME: &str = "geometry_msgs.Quaternion"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_f64::(self.x)?; + buf.write_f64::(self.y)?; + buf.write_f64::(self.z)?; + buf.write_f64::(self.w)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let x = buf.read_f64::()?; + let y = buf.read_f64::()?; + let z = buf.read_f64::()?; + let w = buf.read_f64::()?; + Ok(Self { + x, + y, + z, + w, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 8; + size += 8; + size += 8; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/quaternion_stamped.rs b/generated/rust_lcm_msgs/src/geometry_msgs/quaternion_stamped.rs new file mode 100644 index 0000000..2f5aefa --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/quaternion_stamped.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct QuaternionStamped { + pub header: crate::std_msgs::Header, + pub quaternion: crate::geometry_msgs::Quaternion, +} + +impl QuaternionStamped { + pub const HASH: i64 = 0x7A3833B23AF3EE48u64 as i64; + pub const NAME: &str = "geometry_msgs.QuaternionStamped"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Quaternion::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.quaternion.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let quaternion = crate::geometry_msgs::Quaternion::decode_one(buf)?; + Ok(Self { + header, + quaternion, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.quaternion.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/transform.rs b/generated/rust_lcm_msgs/src/geometry_msgs/transform.rs new file mode 100644 index 0000000..6b94bbf --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/transform.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Transform { + pub translation: crate::geometry_msgs::Vector3, + pub rotation: crate::geometry_msgs::Quaternion, +} + +impl Transform { + pub const HASH: i64 = 0x1275BD1CCBDAF47Fu64 as i64; + pub const NAME: &str = "geometry_msgs.Transform"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Quaternion::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.translation.encode_one(buf)?; + self.rotation.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let translation = crate::geometry_msgs::Vector3::decode_one(buf)?; + let rotation = crate::geometry_msgs::Quaternion::decode_one(buf)?; + Ok(Self { + translation, + rotation, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.translation.encoded_size(); + size += self.rotation.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/transform_stamped.rs b/generated/rust_lcm_msgs/src/geometry_msgs/transform_stamped.rs new file mode 100644 index 0000000..90d02b8 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/transform_stamped.rs @@ -0,0 +1,92 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct TransformStamped { + pub header: crate::std_msgs::Header, + pub child_frame_id: std::string::String, + pub transform: crate::geometry_msgs::Transform, +} + +impl TransformStamped { + pub const HASH: i64 = 0xF694F4A6D8779002u64 as i64; + pub const NAME: &str = "geometry_msgs.TransformStamped"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Transform::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + { + let bytes = self.child_frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + self.transform.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let child_frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let transform = crate::geometry_msgs::Transform::decode_one(buf)?; + Ok(Self { + header, + child_frame_id, + transform, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += 4 + self.child_frame_id.len() + 1; + size += self.transform.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/twist.rs b/generated/rust_lcm_msgs/src/geometry_msgs/twist.rs new file mode 100644 index 0000000..b008bf5 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/twist.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Twist { + pub linear: crate::geometry_msgs::Vector3, + pub angular: crate::geometry_msgs::Vector3, +} + +impl Twist { + pub const HASH: i64 = 0x3A4144772922ADD7u64 as i64; + pub const NAME: &str = "geometry_msgs.Twist"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.linear.encode_one(buf)?; + self.angular.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let linear = crate::geometry_msgs::Vector3::decode_one(buf)?; + let angular = crate::geometry_msgs::Vector3::decode_one(buf)?; + Ok(Self { + linear, + angular, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.linear.encoded_size(); + size += self.angular.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/twist_stamped.rs b/generated/rust_lcm_msgs/src/geometry_msgs/twist_stamped.rs new file mode 100644 index 0000000..8714c81 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/twist_stamped.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct TwistStamped { + pub header: crate::std_msgs::Header, + pub twist: crate::geometry_msgs::Twist, +} + +impl TwistStamped { + pub const HASH: i64 = 0xF01245422C7B28C2u64 as i64; + pub const NAME: &str = "geometry_msgs.TwistStamped"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Twist::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.twist.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let twist = crate::geometry_msgs::Twist::decode_one(buf)?; + Ok(Self { + header, + twist, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.twist.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/twist_with_covariance.rs b/generated/rust_lcm_msgs/src/geometry_msgs/twist_with_covariance.rs new file mode 100644 index 0000000..9462ff7 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/twist_with_covariance.rs @@ -0,0 +1,92 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, PartialEq)] +pub struct TwistWithCovariance { + pub twist: crate::geometry_msgs::Twist, + pub covariance: [f64; 36], +} + +impl Default for TwistWithCovariance { + fn default() -> Self { + Self { + twist: crate::geometry_msgs::Twist::default(), + covariance: [0f64; 36], + } + } +} + +impl TwistWithCovariance { + pub const HASH: i64 = 0xABA0A9D55E98DA5Du64 as i64; + pub const NAME: &str = "geometry_msgs.TwistWithCovariance"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Twist::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.twist.encode_one(buf)?; + for v0 in self.covariance.iter() { + buf.write_f64::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let twist = crate::geometry_msgs::Twist::decode_one(buf)?; + let covariance = { + let mut _arr_0 = [0.0f64; 36]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + Ok(Self { + twist, + covariance, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.twist.encoded_size(); + size += self.covariance.len() * 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/twist_with_covariance_stamped.rs b/generated/rust_lcm_msgs/src/geometry_msgs/twist_with_covariance_stamped.rs new file mode 100644 index 0000000..d874922 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/twist_with_covariance_stamped.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct TwistWithCovarianceStamped { + pub header: crate::std_msgs::Header, + pub twist: crate::geometry_msgs::TwistWithCovariance, +} + +impl TwistWithCovarianceStamped { + pub const HASH: i64 = 0xF01245422C7B28C2u64 as i64; + pub const NAME: &str = "geometry_msgs.TwistWithCovarianceStamped"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::TwistWithCovariance::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.twist.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let twist = crate::geometry_msgs::TwistWithCovariance::decode_one(buf)?; + Ok(Self { + header, + twist, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.twist.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/vector3.rs b/generated/rust_lcm_msgs/src/geometry_msgs/vector3.rs new file mode 100644 index 0000000..0079e0d --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/vector3.rs @@ -0,0 +1,79 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Vector3 { + pub x: f64, + pub y: f64, + pub z: f64, +} + +impl Vector3 { + pub const HASH: i64 = 0x573F2FDD2F76508Fu64 as i64; + pub const NAME: &str = "geometry_msgs.Vector3"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_f64::(self.x)?; + buf.write_f64::(self.y)?; + buf.write_f64::(self.z)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let x = buf.read_f64::()?; + let y = buf.read_f64::()?; + let z = buf.read_f64::()?; + Ok(Self { + x, + y, + z, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 8; + size += 8; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/vector3_stamped.rs b/generated/rust_lcm_msgs/src/geometry_msgs/vector3_stamped.rs new file mode 100644 index 0000000..57a5fc9 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/vector3_stamped.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Vector3Stamped { + pub header: crate::std_msgs::Header, + pub vector: crate::geometry_msgs::Vector3, +} + +impl Vector3Stamped { + pub const HASH: i64 = 0xECB8CFD985D1CBE0u64 as i64; + pub const NAME: &str = "geometry_msgs.Vector3Stamped"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.vector.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let vector = crate::geometry_msgs::Vector3::decode_one(buf)?; + Ok(Self { + header, + vector, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.vector.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/wrench.rs b/generated/rust_lcm_msgs/src/geometry_msgs/wrench.rs new file mode 100644 index 0000000..6cef451 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/wrench.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Wrench { + pub force: crate::geometry_msgs::Vector3, + pub torque: crate::geometry_msgs::Vector3, +} + +impl Wrench { + pub const HASH: i64 = 0x0980C3AEA984C9A6u64 as i64; + pub const NAME: &str = "geometry_msgs.Wrench"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.force.encode_one(buf)?; + self.torque.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let force = crate::geometry_msgs::Vector3::decode_one(buf)?; + let torque = crate::geometry_msgs::Vector3::decode_one(buf)?; + Ok(Self { + force, + torque, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.force.encoded_size(); + size += self.torque.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/geometry_msgs/wrench_stamped.rs b/generated/rust_lcm_msgs/src/geometry_msgs/wrench_stamped.rs new file mode 100644 index 0000000..50f9158 --- /dev/null +++ b/generated/rust_lcm_msgs/src/geometry_msgs/wrench_stamped.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct WrenchStamped { + pub header: crate::std_msgs::Header, + pub wrench: crate::geometry_msgs::Wrench, +} + +impl WrenchStamped { + pub const HASH: i64 = 0xECB7C2D77FC5D5E0u64 as i64; + pub const NAME: &str = "geometry_msgs.WrenchStamped"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Wrench::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.wrench.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let wrench = crate::geometry_msgs::Wrench::decode_one(buf)?; + Ok(Self { + header, + wrench, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.wrench.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/lib.rs b/generated/rust_lcm_msgs/src/lib.rs new file mode 100644 index 0000000..4ab6ab2 --- /dev/null +++ b/generated/rust_lcm_msgs/src/lib.rs @@ -0,0 +1,17 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. +#![allow(non_snake_case)] + +pub mod actionlib_msgs; +pub mod builtin_interfaces; +pub mod diagnostic_msgs; +pub mod foxglove_msgs; +pub mod geometry_msgs; +pub mod nav_msgs; +pub mod sensor_msgs; +pub mod shape_msgs; +pub mod std_msgs; +pub mod stereo_msgs; +pub mod tf2_msgs; +pub mod trajectory_msgs; +pub mod vision_msgs; +pub mod visualization_msgs; diff --git a/generated/rust_lcm_msgs/src/nav_msgs/grid_cells.rs b/generated/rust_lcm_msgs/src/nav_msgs/grid_cells.rs new file mode 100644 index 0000000..2d7f4b2 --- /dev/null +++ b/generated/rust_lcm_msgs/src/nav_msgs/grid_cells.rs @@ -0,0 +1,100 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct GridCells { + pub header: crate::std_msgs::Header, + pub cell_width: f32, + pub cell_height: f32, + pub cells: Vec, +} + +impl GridCells { + pub const HASH: i64 = 0xB855326533062750u64 as i64; + pub const NAME: &str = "nav_msgs.GridCells"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Point::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.cells.len() as i32)?; + self.header.encode_one(buf)?; + buf.write_f32::(self.cell_width)?; + buf.write_f32::(self.cell_height)?; + for v0 in self.cells.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let cells_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let cell_width = buf.read_f32::()?; + let cell_height = buf.read_f32::()?; + let cells = { + let mut v = Vec::with_capacity(cells_length); + for _ in 0..cells_length { + let _elem_0 = crate::geometry_msgs::Point::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + cell_width, + cell_height, + cells, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + size += 4; + size += 4; + for v0 in self.cells.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/nav_msgs/map_meta_data.rs b/generated/rust_lcm_msgs/src/nav_msgs/map_meta_data.rs new file mode 100644 index 0000000..ae6770d --- /dev/null +++ b/generated/rust_lcm_msgs/src/nav_msgs/map_meta_data.rs @@ -0,0 +1,91 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct MapMetaData { + pub map_load_time: crate::std_msgs::Time, + pub resolution: f32, + pub width: i32, + pub height: i32, + pub origin: crate::geometry_msgs::Pose, +} + +impl MapMetaData { + pub const HASH: i64 = 0x3245F3CDB468BA93u64 as i64; + pub const NAME: &str = "nav_msgs.MapMetaData"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Time::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.map_load_time.encode_one(buf)?; + buf.write_f32::(self.resolution)?; + buf.write_i32::(self.width)?; + buf.write_i32::(self.height)?; + self.origin.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let map_load_time = crate::std_msgs::Time::decode_one(buf)?; + let resolution = buf.read_f32::()?; + let width = buf.read_i32::()?; + let height = buf.read_i32::()?; + let origin = crate::geometry_msgs::Pose::decode_one(buf)?; + Ok(Self { + map_load_time, + resolution, + width, + height, + origin, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.map_load_time.encoded_size(); + size += 4; + size += 4; + size += 4; + size += self.origin.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/nav_msgs/mod.rs b/generated/rust_lcm_msgs/src/nav_msgs/mod.rs new file mode 100644 index 0000000..178a15c --- /dev/null +++ b/generated/rust_lcm_msgs/src/nav_msgs/mod.rs @@ -0,0 +1,16 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +mod grid_cells; +pub use grid_cells::GridCells; + +mod map_meta_data; +pub use map_meta_data::MapMetaData; + +mod occupancy_grid; +pub use occupancy_grid::OccupancyGrid; + +mod odometry; +pub use odometry::Odometry; + +mod path; +pub use path::Path; diff --git a/generated/rust_lcm_msgs/src/nav_msgs/occupancy_grid.rs b/generated/rust_lcm_msgs/src/nav_msgs/occupancy_grid.rs new file mode 100644 index 0000000..6aaedaa --- /dev/null +++ b/generated/rust_lcm_msgs/src/nav_msgs/occupancy_grid.rs @@ -0,0 +1,93 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct OccupancyGrid { + pub header: crate::std_msgs::Header, + pub info: crate::nav_msgs::MapMetaData, + pub data: Vec, +} + +impl OccupancyGrid { + pub const HASH: i64 = 0x9E67F3F149308D87u64 as i64; + pub const NAME: &str = "nav_msgs.OccupancyGrid"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::nav_msgs::MapMetaData::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.header.encode_one(buf)?; + self.info.encode_one(buf)?; + for v0 in self.data.iter() { + buf.write_i8(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let info = crate::nav_msgs::MapMetaData::decode_one(buf)?; + let data = { + let mut v = Vec::with_capacity(data_length); + for _ in 0..data_length { + let _elem_0 = buf.read_i8()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + info, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + size += self.info.encoded_size(); + size += self.data.len() * 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/nav_msgs/odometry.rs b/generated/rust_lcm_msgs/src/nav_msgs/odometry.rs new file mode 100644 index 0000000..f7f8ca8 --- /dev/null +++ b/generated/rust_lcm_msgs/src/nav_msgs/odometry.rs @@ -0,0 +1,98 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Odometry { + pub header: crate::std_msgs::Header, + pub child_frame_id: std::string::String, + pub pose: crate::geometry_msgs::PoseWithCovariance, + pub twist: crate::geometry_msgs::TwistWithCovariance, +} + +impl Odometry { + pub const HASH: i64 = 0x97F82279756D9D18u64 as i64; + pub const NAME: &str = "nav_msgs.Odometry"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::PoseWithCovariance::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::TwistWithCovariance::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + { + let bytes = self.child_frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + self.pose.encode_one(buf)?; + self.twist.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let child_frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let pose = crate::geometry_msgs::PoseWithCovariance::decode_one(buf)?; + let twist = crate::geometry_msgs::TwistWithCovariance::decode_one(buf)?; + Ok(Self { + header, + child_frame_id, + pose, + twist, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += 4 + self.child_frame_id.len() + 1; + size += self.pose.encoded_size(); + size += self.twist.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/nav_msgs/path.rs b/generated/rust_lcm_msgs/src/nav_msgs/path.rs new file mode 100644 index 0000000..0eaef69 --- /dev/null +++ b/generated/rust_lcm_msgs/src/nav_msgs/path.rs @@ -0,0 +1,90 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Path { + pub header: crate::std_msgs::Header, + pub poses: Vec, +} + +impl Path { + pub const HASH: i64 = 0xC779B6ACC503055Au64 as i64; + pub const NAME: &str = "nav_msgs.Path"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::PoseStamped::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.poses.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.poses.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let poses_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let poses = { + let mut v = Vec::with_capacity(poses_length); + for _ in 0..poses_length { + let _elem_0 = crate::geometry_msgs::PoseStamped::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + poses, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + for v0 in self.poses.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/battery_state.rs b/generated/rust_lcm_msgs/src/sensor_msgs/battery_state.rs new file mode 100644 index 0000000..2ffe2a0 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/battery_state.rs @@ -0,0 +1,213 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct BatteryState { + pub header: crate::std_msgs::Header, + pub voltage: f32, + pub temperature: f32, + pub current: f32, + pub charge: f32, + pub capacity: f32, + pub design_capacity: f32, + pub percentage: f32, + pub power_supply_status: u8, + pub power_supply_health: u8, + pub power_supply_technology: u8, + pub present: bool, + pub cell_voltage: Vec, + pub cell_temperature: Vec, + pub location: std::string::String, + pub serial_number: std::string::String, +} + +impl BatteryState { + pub const HASH: i64 = 0x8F419FB94C3B774Du64 as i64; + pub const NAME: &str = "sensor_msgs.BatteryState"; + + pub const POWER_SUPPLY_STATUS_UNKNOWN: i8 = 0; + pub const POWER_SUPPLY_STATUS_CHARGING: i8 = 1; + pub const POWER_SUPPLY_STATUS_DISCHARGING: i8 = 2; + pub const POWER_SUPPLY_STATUS_NOT_CHARGING: i8 = 3; + pub const POWER_SUPPLY_STATUS_FULL: i8 = 4; + pub const POWER_SUPPLY_HEALTH_UNKNOWN: i8 = 0; + pub const POWER_SUPPLY_HEALTH_GOOD: i8 = 1; + pub const POWER_SUPPLY_HEALTH_OVERHEAT: i8 = 2; + pub const POWER_SUPPLY_HEALTH_DEAD: i8 = 3; + pub const POWER_SUPPLY_HEALTH_OVERVOLTAGE: i8 = 4; + pub const POWER_SUPPLY_HEALTH_UNSPEC_FAILURE: i8 = 5; + pub const POWER_SUPPLY_HEALTH_COLD: i8 = 6; + pub const POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE: i8 = 7; + pub const POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE: i8 = 8; + pub const POWER_SUPPLY_TECHNOLOGY_UNKNOWN: i8 = 0; + pub const POWER_SUPPLY_TECHNOLOGY_NIMH: i8 = 1; + pub const POWER_SUPPLY_TECHNOLOGY_LION: i8 = 2; + pub const POWER_SUPPLY_TECHNOLOGY_LIPO: i8 = 3; + pub const POWER_SUPPLY_TECHNOLOGY_LIFE: i8 = 4; + pub const POWER_SUPPLY_TECHNOLOGY_NICD: i8 = 5; + pub const POWER_SUPPLY_TECHNOLOGY_LIMN: i8 = 6; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.cell_voltage.len() as i32)?; + buf.write_i32::(self.cell_temperature.len() as i32)?; + self.header.encode_one(buf)?; + buf.write_f32::(self.voltage)?; + buf.write_f32::(self.temperature)?; + buf.write_f32::(self.current)?; + buf.write_f32::(self.charge)?; + buf.write_f32::(self.capacity)?; + buf.write_f32::(self.design_capacity)?; + buf.write_f32::(self.percentage)?; + buf.write_u8(self.power_supply_status)?; + buf.write_u8(self.power_supply_health)?; + buf.write_u8(self.power_supply_technology)?; + buf.write_i8(if self.present { 1 } else { 0 })?; + for v0 in self.cell_voltage.iter() { + buf.write_f32::(*v0)?; + } + for v0 in self.cell_temperature.iter() { + buf.write_f32::(*v0)?; + } + { + let bytes = self.location.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.serial_number.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let cell_voltage_length = buf.read_i32::()? as usize; + let cell_temperature_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let voltage = buf.read_f32::()?; + let temperature = buf.read_f32::()?; + let current = buf.read_f32::()?; + let charge = buf.read_f32::()?; + let capacity = buf.read_f32::()?; + let design_capacity = buf.read_f32::()?; + let percentage = buf.read_f32::()?; + let power_supply_status = buf.read_u8()?; + let power_supply_health = buf.read_u8()?; + let power_supply_technology = buf.read_u8()?; + let present = buf.read_i8()? != 0; + let cell_voltage = { + let mut v = Vec::with_capacity(cell_voltage_length); + for _ in 0..cell_voltage_length { + let _elem_0 = buf.read_f32::()?; + v.push(_elem_0); + } + v + }; + let cell_temperature = { + let mut v = Vec::with_capacity(cell_temperature_length); + for _ in 0..cell_temperature_length { + let _elem_0 = buf.read_f32::()?; + v.push(_elem_0); + } + v + }; + let location = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let serial_number = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + header, + voltage, + temperature, + current, + charge, + capacity, + design_capacity, + percentage, + power_supply_status, + power_supply_health, + power_supply_technology, + present, + cell_voltage, + cell_temperature, + location, + serial_number, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += self.header.encoded_size(); + size += 4; + size += 4; + size += 4; + size += 4; + size += 4; + size += 4; + size += 4; + size += 1; + size += 1; + size += 1; + size += 1; + size += self.cell_voltage.len() * 4; + size += self.cell_temperature.len() * 4; + size += 4 + self.location.len() + 1; + size += 4 + self.serial_number.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/camera_info.rs b/generated/rust_lcm_msgs/src/sensor_msgs/camera_info.rs new file mode 100644 index 0000000..bae3f00 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/camera_info.rs @@ -0,0 +1,168 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct CameraInfo { + pub header: crate::std_msgs::Header, + pub height: i32, + pub width: i32, + pub distortion_model: std::string::String, + pub D: Vec, + pub K: [f64; 9], + pub R: [f64; 9], + pub P: [f64; 12], + pub binning_x: i32, + pub binning_y: i32, + pub roi: crate::sensor_msgs::RegionOfInterest, +} + +impl CameraInfo { + pub const HASH: i64 = 0xB4EA6258BC6D0702u64 as i64; + pub const NAME: &str = "sensor_msgs.CameraInfo"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::sensor_msgs::RegionOfInterest::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.D.len() as i32)?; + self.header.encode_one(buf)?; + buf.write_i32::(self.height)?; + buf.write_i32::(self.width)?; + { + let bytes = self.distortion_model.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + for v0 in self.D.iter() { + buf.write_f64::(*v0)?; + } + for v0 in self.K.iter() { + buf.write_f64::(*v0)?; + } + for v0 in self.R.iter() { + buf.write_f64::(*v0)?; + } + for v0 in self.P.iter() { + buf.write_f64::(*v0)?; + } + buf.write_i32::(self.binning_x)?; + buf.write_i32::(self.binning_y)?; + self.roi.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let D_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let height = buf.read_i32::()?; + let width = buf.read_i32::()?; + let distortion_model = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let D = { + let mut v = Vec::with_capacity(D_length); + for _ in 0..D_length { + let _elem_0 = buf.read_f64::()?; + v.push(_elem_0); + } + v + }; + let K = { + let mut _arr_0 = [0.0f64; 9]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + let R = { + let mut _arr_0 = [0.0f64; 9]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + let P = { + let mut _arr_0 = [0.0f64; 12]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + let binning_x = buf.read_i32::()?; + let binning_y = buf.read_i32::()?; + let roi = crate::sensor_msgs::RegionOfInterest::decode_one(buf)?; + Ok(Self { + header, + height, + width, + distortion_model, + D, + K, + R, + P, + binning_x, + binning_y, + roi, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + size += 4; + size += 4; + size += 4 + self.distortion_model.len() + 1; + size += self.D.len() * 8; + size += self.K.len() * 8; + size += self.R.len() * 8; + size += self.P.len() * 8; + size += 4; + size += 4; + size += self.roi.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/channel_float32.rs b/generated/rust_lcm_msgs/src/sensor_msgs/channel_float32.rs new file mode 100644 index 0000000..fca35ac --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/channel_float32.rs @@ -0,0 +1,97 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct ChannelFloat32 { + pub name: std::string::String, + pub values: Vec, +} + +impl ChannelFloat32 { + pub const HASH: i64 = 0x8CBE448953EBF073u64 as i64; + pub const NAME: &str = "sensor_msgs.ChannelFloat32"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.values.len() as i32)?; + { + let bytes = self.name.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + for v0 in self.values.iter() { + buf.write_f32::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let values_length = buf.read_i32::()? as usize; + let name = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let values = { + let mut v = Vec::with_capacity(values_length); + for _ in 0..values_length { + let _elem_0 = buf.read_f32::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + name, + values, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4 + self.name.len() + 1; + size += self.values.len() * 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/compressed_image.rs b/generated/rust_lcm_msgs/src/sensor_msgs/compressed_image.rs new file mode 100644 index 0000000..929df4a --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/compressed_image.rs @@ -0,0 +1,98 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct CompressedImage { + pub header: crate::std_msgs::Header, + pub format: std::string::String, + pub data: Vec, +} + +impl CompressedImage { + pub const HASH: i64 = 0xAC8CF79B462311D9u64 as i64; + pub const NAME: &str = "sensor_msgs.CompressedImage"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.header.encode_one(buf)?; + { + let bytes = self.format.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_all(&self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let format = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let data = { + let mut v = vec![0u8; data_length]; + buf.read_exact(&mut v)?; + v + }; + Ok(Self { + header, + format, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + size += 4 + self.format.len() + 1; + size += self.data.len(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/fluid_pressure.rs b/generated/rust_lcm_msgs/src/sensor_msgs/fluid_pressure.rs new file mode 100644 index 0000000..82e8f0e --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/fluid_pressure.rs @@ -0,0 +1,80 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct FluidPressure { + pub header: crate::std_msgs::Header, + pub fluid_pressure: f64, + pub variance: f64, +} + +impl FluidPressure { + pub const HASH: i64 = 0x36B91AF6B8F9D388u64 as i64; + pub const NAME: &str = "sensor_msgs.FluidPressure"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + buf.write_f64::(self.fluid_pressure)?; + buf.write_f64::(self.variance)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let fluid_pressure = buf.read_f64::()?; + let variance = buf.read_f64::()?; + Ok(Self { + header, + fluid_pressure, + variance, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += 8; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/illuminance.rs b/generated/rust_lcm_msgs/src/sensor_msgs/illuminance.rs new file mode 100644 index 0000000..74f9478 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/illuminance.rs @@ -0,0 +1,80 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Illuminance { + pub header: crate::std_msgs::Header, + pub illuminance: f64, + pub variance: f64, +} + +impl Illuminance { + pub const HASH: i64 = 0xDFB4B65CE9B1B524u64 as i64; + pub const NAME: &str = "sensor_msgs.Illuminance"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + buf.write_f64::(self.illuminance)?; + buf.write_f64::(self.variance)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let illuminance = buf.read_f64::()?; + let variance = buf.read_f64::()?; + Ok(Self { + header, + illuminance, + variance, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += 8; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/image.rs b/generated/rust_lcm_msgs/src/sensor_msgs/image.rs new file mode 100644 index 0000000..61d8465 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/image.rs @@ -0,0 +1,118 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Image { + pub header: crate::std_msgs::Header, + pub height: i32, + pub width: i32, + pub encoding: std::string::String, + pub is_bigendian: u8, + pub step: i32, + pub data: Vec, +} + +impl Image { + pub const HASH: i64 = 0x79D36C21D3C16094u64 as i64; + pub const NAME: &str = "sensor_msgs.Image"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.header.encode_one(buf)?; + buf.write_i32::(self.height)?; + buf.write_i32::(self.width)?; + { + let bytes = self.encoding.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_u8(self.is_bigendian)?; + buf.write_i32::(self.step)?; + buf.write_all(&self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let height = buf.read_i32::()?; + let width = buf.read_i32::()?; + let encoding = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let is_bigendian = buf.read_u8()?; + let step = buf.read_i32::()?; + let data = { + let mut v = vec![0u8; data_length]; + buf.read_exact(&mut v)?; + v + }; + Ok(Self { + header, + height, + width, + encoding, + is_bigendian, + step, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + size += 4; + size += 4; + size += 4 + self.encoding.len() + 1; + size += 1; + size += 4; + size += self.data.len(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/imu.rs b/generated/rust_lcm_msgs/src/sensor_msgs/imu.rs new file mode 100644 index 0000000..807e356 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/imu.rs @@ -0,0 +1,127 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Imu { + pub header: crate::std_msgs::Header, + pub orientation: crate::geometry_msgs::Quaternion, + pub orientation_covariance: [f64; 9], + pub angular_velocity: crate::geometry_msgs::Vector3, + pub angular_velocity_covariance: [f64; 9], + pub linear_acceleration: crate::geometry_msgs::Vector3, + pub linear_acceleration_covariance: [f64; 9], +} + +impl Imu { + pub const HASH: i64 = 0x55C1E238541325F6u64 as i64; + pub const NAME: &str = "sensor_msgs.Imu"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Quaternion::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.orientation.encode_one(buf)?; + for v0 in self.orientation_covariance.iter() { + buf.write_f64::(*v0)?; + } + self.angular_velocity.encode_one(buf)?; + for v0 in self.angular_velocity_covariance.iter() { + buf.write_f64::(*v0)?; + } + self.linear_acceleration.encode_one(buf)?; + for v0 in self.linear_acceleration_covariance.iter() { + buf.write_f64::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let orientation = crate::geometry_msgs::Quaternion::decode_one(buf)?; + let orientation_covariance = { + let mut _arr_0 = [0.0f64; 9]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + let angular_velocity = crate::geometry_msgs::Vector3::decode_one(buf)?; + let angular_velocity_covariance = { + let mut _arr_0 = [0.0f64; 9]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + let linear_acceleration = crate::geometry_msgs::Vector3::decode_one(buf)?; + let linear_acceleration_covariance = { + let mut _arr_0 = [0.0f64; 9]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + Ok(Self { + header, + orientation, + orientation_covariance, + angular_velocity, + angular_velocity_covariance, + linear_acceleration, + linear_acceleration_covariance, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.orientation.encoded_size(); + size += self.orientation_covariance.len() * 8; + size += self.angular_velocity.encoded_size(); + size += self.angular_velocity_covariance.len() * 8; + size += self.linear_acceleration.encoded_size(); + size += self.linear_acceleration_covariance.len() * 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/joint_state.rs b/generated/rust_lcm_msgs/src/sensor_msgs/joint_state.rs new file mode 100644 index 0000000..5f3d5df --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/joint_state.rs @@ -0,0 +1,151 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct JointState { + pub header: crate::std_msgs::Header, + pub name: Vec, + pub position: Vec, + pub velocity: Vec, + pub effort: Vec, +} + +impl JointState { + pub const HASH: i64 = 0xB69CC30D0D7668FAu64 as i64; + pub const NAME: &str = "sensor_msgs.JointState"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.name.len() as i32)?; + buf.write_i32::(self.position.len() as i32)?; + buf.write_i32::(self.velocity.len() as i32)?; + buf.write_i32::(self.effort.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.name.iter() { + { + let bytes = v0.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + } + for v0 in self.position.iter() { + buf.write_f64::(*v0)?; + } + for v0 in self.velocity.iter() { + buf.write_f64::(*v0)?; + } + for v0 in self.effort.iter() { + buf.write_f64::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let name_length = buf.read_i32::()? as usize; + let position_length = buf.read_i32::()? as usize; + let velocity_length = buf.read_i32::()? as usize; + let effort_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let name = { + let mut v = Vec::with_capacity(name_length); + for _ in 0..name_length { + let _elem_0 = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + v.push(_elem_0); + } + v + }; + let position = { + let mut v = Vec::with_capacity(position_length); + for _ in 0..position_length { + let _elem_0 = buf.read_f64::()?; + v.push(_elem_0); + } + v + }; + let velocity = { + let mut v = Vec::with_capacity(velocity_length); + for _ in 0..velocity_length { + let _elem_0 = buf.read_f64::()?; + v.push(_elem_0); + } + v + }; + let effort = { + let mut v = Vec::with_capacity(effort_length); + for _ in 0..effort_length { + let _elem_0 = buf.read_f64::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + name, + position, + velocity, + effort, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += 4; + size += 4; + size += self.header.encoded_size(); + for s0 in self.name.iter() { + size += 4 + s0.len() + 1; + } + size += self.position.len() * 8; + size += self.velocity.len() * 8; + size += self.effort.len() * 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/joy.rs b/generated/rust_lcm_msgs/src/sensor_msgs/joy.rs new file mode 100644 index 0000000..09169e1 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/joy.rs @@ -0,0 +1,104 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Joy { + pub header: crate::std_msgs::Header, + pub axes: Vec, + pub buttons: Vec, +} + +impl Joy { + pub const HASH: i64 = 0x209D2C19077A692Fu64 as i64; + pub const NAME: &str = "sensor_msgs.Joy"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.axes.len() as i32)?; + buf.write_i32::(self.buttons.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.axes.iter() { + buf.write_f32::(*v0)?; + } + for v0 in self.buttons.iter() { + buf.write_i32::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let axes_length = buf.read_i32::()? as usize; + let buttons_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let axes = { + let mut v = Vec::with_capacity(axes_length); + for _ in 0..axes_length { + let _elem_0 = buf.read_f32::()?; + v.push(_elem_0); + } + v + }; + let buttons = { + let mut v = Vec::with_capacity(buttons_length); + for _ in 0..buttons_length { + let _elem_0 = buf.read_i32::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + axes, + buttons, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += self.header.encoded_size(); + size += self.axes.len() * 4; + size += self.buttons.len() * 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/joy_feedback.rs b/generated/rust_lcm_msgs/src/sensor_msgs/joy_feedback.rs new file mode 100644 index 0000000..e91b3d3 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/joy_feedback.rs @@ -0,0 +1,83 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct JoyFeedback { + pub r#type: u8, + pub id: u8, + pub intensity: f32, +} + +impl JoyFeedback { + pub const HASH: i64 = 0x244B242F84E14215u64 as i64; + pub const NAME: &str = "sensor_msgs.JoyFeedback"; + + pub const TYPE_LED: i8 = 0; + pub const TYPE_RUMBLE: i8 = 1; + pub const TYPE_BUZZER: i8 = 2; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_u8(self.r#type)?; + buf.write_u8(self.id)?; + buf.write_f32::(self.intensity)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let r#type = buf.read_u8()?; + let id = buf.read_u8()?; + let intensity = buf.read_f32::()?; + Ok(Self { + r#type, + id, + intensity, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 1; + size += 1; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/joy_feedback_array.rs b/generated/rust_lcm_msgs/src/sensor_msgs/joy_feedback_array.rs new file mode 100644 index 0000000..598bb8b --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/joy_feedback_array.rs @@ -0,0 +1,84 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct JoyFeedbackArray { + pub array: Vec, +} + +impl JoyFeedbackArray { + pub const HASH: i64 = 0xDE2A78C20FFEFA04u64 as i64; + pub const NAME: &str = "sensor_msgs.JoyFeedbackArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::sensor_msgs::JoyFeedback::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.array.len() as i32)?; + for v0 in self.array.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let array_length = buf.read_i32::()? as usize; + let array = { + let mut v = Vec::with_capacity(array_length); + for _ in 0..array_length { + let _elem_0 = crate::sensor_msgs::JoyFeedback::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + array, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + for v0 in self.array.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/laser_echo.rs b/generated/rust_lcm_msgs/src/sensor_msgs/laser_echo.rs new file mode 100644 index 0000000..2d523c9 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/laser_echo.rs @@ -0,0 +1,81 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct LaserEcho { + pub echoes: Vec, +} + +impl LaserEcho { + pub const HASH: i64 = 0xC45702116C7D0A2Eu64 as i64; + pub const NAME: &str = "sensor_msgs.LaserEcho"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.echoes.len() as i32)?; + for v0 in self.echoes.iter() { + buf.write_f32::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let echoes_length = buf.read_i32::()? as usize; + let echoes = { + let mut v = Vec::with_capacity(echoes_length); + for _ in 0..echoes_length { + let _elem_0 = buf.read_f32::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + echoes, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.echoes.len() * 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/laser_scan.rs b/generated/rust_lcm_msgs/src/sensor_msgs/laser_scan.rs new file mode 100644 index 0000000..ef4eba5 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/laser_scan.rs @@ -0,0 +1,139 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct LaserScan { + pub header: crate::std_msgs::Header, + pub angle_min: f32, + pub angle_max: f32, + pub angle_increment: f32, + pub time_increment: f32, + pub scan_time: f32, + pub range_min: f32, + pub range_max: f32, + pub ranges: Vec, + pub intensities: Vec, +} + +impl LaserScan { + pub const HASH: i64 = 0x1717A961C492E489u64 as i64; + pub const NAME: &str = "sensor_msgs.LaserScan"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.ranges.len() as i32)?; + buf.write_i32::(self.intensities.len() as i32)?; + self.header.encode_one(buf)?; + buf.write_f32::(self.angle_min)?; + buf.write_f32::(self.angle_max)?; + buf.write_f32::(self.angle_increment)?; + buf.write_f32::(self.time_increment)?; + buf.write_f32::(self.scan_time)?; + buf.write_f32::(self.range_min)?; + buf.write_f32::(self.range_max)?; + for v0 in self.ranges.iter() { + buf.write_f32::(*v0)?; + } + for v0 in self.intensities.iter() { + buf.write_f32::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let ranges_length = buf.read_i32::()? as usize; + let intensities_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let angle_min = buf.read_f32::()?; + let angle_max = buf.read_f32::()?; + let angle_increment = buf.read_f32::()?; + let time_increment = buf.read_f32::()?; + let scan_time = buf.read_f32::()?; + let range_min = buf.read_f32::()?; + let range_max = buf.read_f32::()?; + let ranges = { + let mut v = Vec::with_capacity(ranges_length); + for _ in 0..ranges_length { + let _elem_0 = buf.read_f32::()?; + v.push(_elem_0); + } + v + }; + let intensities = { + let mut v = Vec::with_capacity(intensities_length); + for _ in 0..intensities_length { + let _elem_0 = buf.read_f32::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + angle_min, + angle_max, + angle_increment, + time_increment, + scan_time, + range_min, + range_max, + ranges, + intensities, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += self.header.encoded_size(); + size += 4; + size += 4; + size += 4; + size += 4; + size += 4; + size += 4; + size += 4; + size += self.ranges.len() * 4; + size += self.intensities.len() * 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/magnetic_field.rs b/generated/rust_lcm_msgs/src/sensor_msgs/magnetic_field.rs new file mode 100644 index 0000000..c37c685 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/magnetic_field.rs @@ -0,0 +1,89 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct MagneticField { + pub header: crate::std_msgs::Header, + pub magnetic_field: crate::geometry_msgs::Vector3, + pub magnetic_field_covariance: [f64; 9], +} + +impl MagneticField { + pub const HASH: i64 = 0xBFEB021E4751ED88u64 as i64; + pub const NAME: &str = "sensor_msgs.MagneticField"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.magnetic_field.encode_one(buf)?; + for v0 in self.magnetic_field_covariance.iter() { + buf.write_f64::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let magnetic_field = crate::geometry_msgs::Vector3::decode_one(buf)?; + let magnetic_field_covariance = { + let mut _arr_0 = [0.0f64; 9]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + Ok(Self { + header, + magnetic_field, + magnetic_field_covariance, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.magnetic_field.encoded_size(); + size += self.magnetic_field_covariance.len() * 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/mod.rs b/generated/rust_lcm_msgs/src/sensor_msgs/mod.rs new file mode 100644 index 0000000..3b0d5c8 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/mod.rs @@ -0,0 +1,82 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +mod battery_state; +pub use battery_state::BatteryState; + +mod camera_info; +pub use camera_info::CameraInfo; + +mod channel_float32; +pub use channel_float32::ChannelFloat32; + +mod compressed_image; +pub use compressed_image::CompressedImage; + +mod fluid_pressure; +pub use fluid_pressure::FluidPressure; + +mod illuminance; +pub use illuminance::Illuminance; + +mod image; +pub use image::Image; + +mod imu; +pub use imu::Imu; + +mod joint_state; +pub use joint_state::JointState; + +mod joy; +pub use joy::Joy; + +mod joy_feedback; +pub use joy_feedback::JoyFeedback; + +mod joy_feedback_array; +pub use joy_feedback_array::JoyFeedbackArray; + +mod laser_echo; +pub use laser_echo::LaserEcho; + +mod laser_scan; +pub use laser_scan::LaserScan; + +mod magnetic_field; +pub use magnetic_field::MagneticField; + +mod multi_dof_joint_state; +pub use multi_dof_joint_state::MultiDOFJointState; + +mod multi_echo_laser_scan; +pub use multi_echo_laser_scan::MultiEchoLaserScan; + +mod nav_sat_fix; +pub use nav_sat_fix::NavSatFix; + +mod nav_sat_status; +pub use nav_sat_status::NavSatStatus; + +mod point_cloud; +pub use point_cloud::PointCloud; + +mod point_cloud2; +pub use point_cloud2::PointCloud2; + +mod point_field; +pub use point_field::PointField; + +mod range; +pub use range::Range; + +mod region_of_interest; +pub use region_of_interest::RegionOfInterest; + +mod relative_humidity; +pub use relative_humidity::RelativeHumidity; + +mod temperature; +pub use temperature::Temperature; + +mod time_reference; +pub use time_reference::TimeReference; diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/multi_dof_joint_state.rs b/generated/rust_lcm_msgs/src/sensor_msgs/multi_dof_joint_state.rs new file mode 100644 index 0000000..8cbc8b7 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/multi_dof_joint_state.rs @@ -0,0 +1,160 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct MultiDOFJointState { + pub header: crate::std_msgs::Header, + pub joint_names: Vec, + pub transforms: Vec, + pub twist: Vec, + pub wrench: Vec, +} + +impl MultiDOFJointState { + pub const HASH: i64 = 0x15CA331F6F9F4FBCu64 as i64; + pub const NAME: &str = "sensor_msgs.MultiDOFJointState"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Transform::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Twist::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Wrench::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.joint_names.len() as i32)?; + buf.write_i32::(self.transforms.len() as i32)?; + buf.write_i32::(self.twist.len() as i32)?; + buf.write_i32::(self.wrench.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.joint_names.iter() { + { + let bytes = v0.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + } + for v0 in self.transforms.iter() { + v0.encode_one(buf)?; + } + for v0 in self.twist.iter() { + v0.encode_one(buf)?; + } + for v0 in self.wrench.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let joint_names_length = buf.read_i32::()? as usize; + let transforms_length = buf.read_i32::()? as usize; + let twist_length = buf.read_i32::()? as usize; + let wrench_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let joint_names = { + let mut v = Vec::with_capacity(joint_names_length); + for _ in 0..joint_names_length { + let _elem_0 = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + v.push(_elem_0); + } + v + }; + let transforms = { + let mut v = Vec::with_capacity(transforms_length); + for _ in 0..transforms_length { + let _elem_0 = crate::geometry_msgs::Transform::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let twist = { + let mut v = Vec::with_capacity(twist_length); + for _ in 0..twist_length { + let _elem_0 = crate::geometry_msgs::Twist::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let wrench = { + let mut v = Vec::with_capacity(wrench_length); + for _ in 0..wrench_length { + let _elem_0 = crate::geometry_msgs::Wrench::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + joint_names, + transforms, + twist, + wrench, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += 4; + size += 4; + size += self.header.encoded_size(); + for s0 in self.joint_names.iter() { + size += 4 + s0.len() + 1; + } + for v0 in self.transforms.iter() { + size += v0.encoded_size(); + } + for v0 in self.twist.iter() { + size += v0.encoded_size(); + } + for v0 in self.wrench.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/multi_echo_laser_scan.rs b/generated/rust_lcm_msgs/src/sensor_msgs/multi_echo_laser_scan.rs new file mode 100644 index 0000000..f5a417c --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/multi_echo_laser_scan.rs @@ -0,0 +1,145 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct MultiEchoLaserScan { + pub header: crate::std_msgs::Header, + pub angle_min: f32, + pub angle_max: f32, + pub angle_increment: f32, + pub time_increment: f32, + pub scan_time: f32, + pub range_min: f32, + pub range_max: f32, + pub ranges: Vec, + pub intensities: Vec, +} + +impl MultiEchoLaserScan { + pub const HASH: i64 = 0xF02A6253849D18E2u64 as i64; + pub const NAME: &str = "sensor_msgs.MultiEchoLaserScan"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::sensor_msgs::LaserEcho::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::sensor_msgs::LaserEcho::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.ranges.len() as i32)?; + buf.write_i32::(self.intensities.len() as i32)?; + self.header.encode_one(buf)?; + buf.write_f32::(self.angle_min)?; + buf.write_f32::(self.angle_max)?; + buf.write_f32::(self.angle_increment)?; + buf.write_f32::(self.time_increment)?; + buf.write_f32::(self.scan_time)?; + buf.write_f32::(self.range_min)?; + buf.write_f32::(self.range_max)?; + for v0 in self.ranges.iter() { + v0.encode_one(buf)?; + } + for v0 in self.intensities.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let ranges_length = buf.read_i32::()? as usize; + let intensities_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let angle_min = buf.read_f32::()?; + let angle_max = buf.read_f32::()?; + let angle_increment = buf.read_f32::()?; + let time_increment = buf.read_f32::()?; + let scan_time = buf.read_f32::()?; + let range_min = buf.read_f32::()?; + let range_max = buf.read_f32::()?; + let ranges = { + let mut v = Vec::with_capacity(ranges_length); + for _ in 0..ranges_length { + let _elem_0 = crate::sensor_msgs::LaserEcho::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let intensities = { + let mut v = Vec::with_capacity(intensities_length); + for _ in 0..intensities_length { + let _elem_0 = crate::sensor_msgs::LaserEcho::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + angle_min, + angle_max, + angle_increment, + time_increment, + scan_time, + range_min, + range_max, + ranges, + intensities, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += self.header.encoded_size(); + size += 4; + size += 4; + size += 4; + size += 4; + size += 4; + size += 4; + size += 4; + for v0 in self.ranges.iter() { + size += v0.encoded_size(); + } + for v0 in self.intensities.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/nav_sat_fix.rs b/generated/rust_lcm_msgs/src/sensor_msgs/nav_sat_fix.rs new file mode 100644 index 0000000..639c54a --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/nav_sat_fix.rs @@ -0,0 +1,114 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct NavSatFix { + pub header: crate::std_msgs::Header, + pub status: crate::sensor_msgs::NavSatStatus, + pub latitude: f64, + pub longitude: f64, + pub altitude: f64, + pub position_covariance: [f64; 9], + pub position_covariance_type: u8, +} + +impl NavSatFix { + pub const HASH: i64 = 0x4A84D20526D9067Au64 as i64; + pub const NAME: &str = "sensor_msgs.NavSatFix"; + + pub const COVARIANCE_TYPE_UNKNOWN: i8 = 0; + pub const COVARIANCE_TYPE_APPROXIMATED: i8 = 1; + pub const COVARIANCE_TYPE_DIAGONAL_KNOWN: i8 = 2; + pub const COVARIANCE_TYPE_KNOWN: i8 = 3; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::sensor_msgs::NavSatStatus::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.status.encode_one(buf)?; + buf.write_f64::(self.latitude)?; + buf.write_f64::(self.longitude)?; + buf.write_f64::(self.altitude)?; + for v0 in self.position_covariance.iter() { + buf.write_f64::(*v0)?; + } + buf.write_u8(self.position_covariance_type)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let status = crate::sensor_msgs::NavSatStatus::decode_one(buf)?; + let latitude = buf.read_f64::()?; + let longitude = buf.read_f64::()?; + let altitude = buf.read_f64::()?; + let position_covariance = { + let mut _arr_0 = [0.0f64; 9]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + let position_covariance_type = buf.read_u8()?; + Ok(Self { + header, + status, + latitude, + longitude, + altitude, + position_covariance, + position_covariance_type, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.status.encoded_size(); + size += 8; + size += 8; + size += 8; + size += self.position_covariance.len() * 8; + size += 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/nav_sat_status.rs b/generated/rust_lcm_msgs/src/sensor_msgs/nav_sat_status.rs new file mode 100644 index 0000000..11c645d --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/nav_sat_status.rs @@ -0,0 +1,83 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct NavSatStatus { + pub status: i8, + pub service: i16, +} + +impl NavSatStatus { + pub const HASH: i64 = 0x76B236592075C1DBu64 as i64; + pub const NAME: &str = "sensor_msgs.NavSatStatus"; + + pub const STATUS_NO_FIX: i8 = 1; + pub const STATUS_FIX: i8 = 0; + pub const STATUS_SBAS_FIX: i8 = 1; + pub const STATUS_GBAS_FIX: i8 = 2; + pub const SERVICE_GPS: i16 = 1; + pub const SERVICE_GLONASS: i16 = 2; + pub const SERVICE_COMPASS: i16 = 4; + pub const SERVICE_GALILEO: i16 = 8; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i8(self.status)?; + buf.write_i16::(self.service)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let status = buf.read_i8()?; + let service = buf.read_i16::()?; + Ok(Self { + status, + service, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 1; + size += 2; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/point_cloud.rs b/generated/rust_lcm_msgs/src/sensor_msgs/point_cloud.rs new file mode 100644 index 0000000..e85d838 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/point_cloud.rs @@ -0,0 +1,110 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct PointCloud { + pub header: crate::std_msgs::Header, + pub points: Vec, + pub channels: Vec, +} + +impl PointCloud { + pub const HASH: i64 = 0x3FF7DC99E345164Eu64 as i64; + pub const NAME: &str = "sensor_msgs.PointCloud"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Point32::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::sensor_msgs::ChannelFloat32::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.points.len() as i32)?; + buf.write_i32::(self.channels.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.points.iter() { + v0.encode_one(buf)?; + } + for v0 in self.channels.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let points_length = buf.read_i32::()? as usize; + let channels_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let points = { + let mut v = Vec::with_capacity(points_length); + for _ in 0..points_length { + let _elem_0 = crate::geometry_msgs::Point32::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let channels = { + let mut v = Vec::with_capacity(channels_length); + for _ in 0..channels_length { + let _elem_0 = crate::sensor_msgs::ChannelFloat32::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + points, + channels, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += self.header.encoded_size(); + for v0 in self.points.iter() { + size += v0.encoded_size(); + } + for v0 in self.channels.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/point_cloud2.rs b/generated/rust_lcm_msgs/src/sensor_msgs/point_cloud2.rs new file mode 100644 index 0000000..92eed82 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/point_cloud2.rs @@ -0,0 +1,132 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct PointCloud2 { + pub header: crate::std_msgs::Header, + pub height: i32, + pub width: i32, + pub fields: Vec, + pub is_bigendian: bool, + pub point_step: i32, + pub row_step: i32, + pub data: Vec, + pub is_dense: bool, +} + +impl PointCloud2 { + pub const HASH: i64 = 0xEABE7183C4D74215u64 as i64; + pub const NAME: &str = "sensor_msgs.PointCloud2"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::sensor_msgs::PointField::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.fields.len() as i32)?; + buf.write_i32::(self.data.len() as i32)?; + self.header.encode_one(buf)?; + buf.write_i32::(self.height)?; + buf.write_i32::(self.width)?; + for v0 in self.fields.iter() { + v0.encode_one(buf)?; + } + buf.write_i8(if self.is_bigendian { 1 } else { 0 })?; + buf.write_i32::(self.point_step)?; + buf.write_i32::(self.row_step)?; + buf.write_all(&self.data)?; + buf.write_i8(if self.is_dense { 1 } else { 0 })?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let fields_length = buf.read_i32::()? as usize; + let data_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let height = buf.read_i32::()?; + let width = buf.read_i32::()?; + let fields = { + let mut v = Vec::with_capacity(fields_length); + for _ in 0..fields_length { + let _elem_0 = crate::sensor_msgs::PointField::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let is_bigendian = buf.read_i8()? != 0; + let point_step = buf.read_i32::()?; + let row_step = buf.read_i32::()?; + let data = { + let mut v = vec![0u8; data_length]; + buf.read_exact(&mut v)?; + v + }; + let is_dense = buf.read_i8()? != 0; + Ok(Self { + header, + height, + width, + fields, + is_bigendian, + point_step, + row_step, + data, + is_dense, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += self.header.encoded_size(); + size += 4; + size += 4; + for v0 in self.fields.iter() { + size += v0.encoded_size(); + } + size += 1; + size += 4; + size += 4; + size += self.data.len(); + size += 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/point_field.rs b/generated/rust_lcm_msgs/src/sensor_msgs/point_field.rs new file mode 100644 index 0000000..51583b5 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/point_field.rs @@ -0,0 +1,104 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct PointField { + pub name: std::string::String, + pub offset: i32, + pub datatype: u8, + pub count: i32, +} + +impl PointField { + pub const HASH: i64 = 0x702E0E03F04285D7u64 as i64; + pub const NAME: &str = "sensor_msgs.PointField"; + + pub const INT8: i8 = 1; + pub const UINT8: i8 = 2; + pub const INT16: i8 = 3; + pub const UINT16: i8 = 4; + pub const INT32: i8 = 5; + pub const UINT32: i8 = 6; + pub const FLOAT32: i8 = 7; + pub const FLOAT64: i8 = 8; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + { + let bytes = self.name.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_i32::(self.offset)?; + buf.write_u8(self.datatype)?; + buf.write_i32::(self.count)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let name = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let offset = buf.read_i32::()?; + let datatype = buf.read_u8()?; + let count = buf.read_i32::()?; + Ok(Self { + name, + offset, + datatype, + count, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4 + self.name.len() + 1; + size += 4; + size += 1; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/range.rs b/generated/rust_lcm_msgs/src/sensor_msgs/range.rs new file mode 100644 index 0000000..cbcdc58 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/range.rs @@ -0,0 +1,98 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Range { + pub header: crate::std_msgs::Header, + pub radiation_type: u8, + pub field_of_view: f32, + pub min_range: f32, + pub max_range: f32, + pub range: f32, +} + +impl Range { + pub const HASH: i64 = 0xAAF9249A1465F86Au64 as i64; + pub const NAME: &str = "sensor_msgs.Range"; + + pub const ULTRASOUND: i8 = 0; + pub const INFRARED: i8 = 1; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + buf.write_u8(self.radiation_type)?; + buf.write_f32::(self.field_of_view)?; + buf.write_f32::(self.min_range)?; + buf.write_f32::(self.max_range)?; + buf.write_f32::(self.range)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let radiation_type = buf.read_u8()?; + let field_of_view = buf.read_f32::()?; + let min_range = buf.read_f32::()?; + let max_range = buf.read_f32::()?; + let range = buf.read_f32::()?; + Ok(Self { + header, + radiation_type, + field_of_view, + min_range, + max_range, + range, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += 1; + size += 4; + size += 4; + size += 4; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/region_of_interest.rs b/generated/rust_lcm_msgs/src/sensor_msgs/region_of_interest.rs new file mode 100644 index 0000000..796cd1d --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/region_of_interest.rs @@ -0,0 +1,89 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct RegionOfInterest { + pub x_offset: i32, + pub y_offset: i32, + pub height: i32, + pub width: i32, + pub do_rectify: bool, +} + +impl RegionOfInterest { + pub const HASH: i64 = 0x398A869D05983F0Eu64 as i64; + pub const NAME: &str = "sensor_msgs.RegionOfInterest"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.x_offset)?; + buf.write_i32::(self.y_offset)?; + buf.write_i32::(self.height)?; + buf.write_i32::(self.width)?; + buf.write_i8(if self.do_rectify { 1 } else { 0 })?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let x_offset = buf.read_i32::()?; + let y_offset = buf.read_i32::()?; + let height = buf.read_i32::()?; + let width = buf.read_i32::()?; + let do_rectify = buf.read_i8()? != 0; + Ok(Self { + x_offset, + y_offset, + height, + width, + do_rectify, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += 4; + size += 4; + size += 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/relative_humidity.rs b/generated/rust_lcm_msgs/src/sensor_msgs/relative_humidity.rs new file mode 100644 index 0000000..6077052 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/relative_humidity.rs @@ -0,0 +1,80 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct RelativeHumidity { + pub header: crate::std_msgs::Header, + pub relative_humidity: f64, + pub variance: f64, +} + +impl RelativeHumidity { + pub const HASH: i64 = 0x1DB00395F858F771u64 as i64; + pub const NAME: &str = "sensor_msgs.RelativeHumidity"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + buf.write_f64::(self.relative_humidity)?; + buf.write_f64::(self.variance)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let relative_humidity = buf.read_f64::()?; + let variance = buf.read_f64::()?; + Ok(Self { + header, + relative_humidity, + variance, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += 8; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/temperature.rs b/generated/rust_lcm_msgs/src/sensor_msgs/temperature.rs new file mode 100644 index 0000000..8e44ab0 --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/temperature.rs @@ -0,0 +1,80 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Temperature { + pub header: crate::std_msgs::Header, + pub temperature: f64, + pub variance: f64, +} + +impl Temperature { + pub const HASH: i64 = 0x39CC1DC52D6CA13Du64 as i64; + pub const NAME: &str = "sensor_msgs.Temperature"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + buf.write_f64::(self.temperature)?; + buf.write_f64::(self.variance)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let temperature = buf.read_f64::()?; + let variance = buf.read_f64::()?; + Ok(Self { + header, + temperature, + variance, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += 8; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/sensor_msgs/time_reference.rs b/generated/rust_lcm_msgs/src/sensor_msgs/time_reference.rs new file mode 100644 index 0000000..a21cd6e --- /dev/null +++ b/generated/rust_lcm_msgs/src/sensor_msgs/time_reference.rs @@ -0,0 +1,92 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct TimeReference { + pub header: crate::std_msgs::Header, + pub time_ref: crate::std_msgs::Time, + pub source: std::string::String, +} + +impl TimeReference { + pub const HASH: i64 = 0x1A6B1C8C5ABAE6DBu64 as i64; + pub const NAME: &str = "sensor_msgs.TimeReference"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::std_msgs::Time::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.time_ref.encode_one(buf)?; + { + let bytes = self.source.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let time_ref = crate::std_msgs::Time::decode_one(buf)?; + let source = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + header, + time_ref, + source, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.time_ref.encoded_size(); + size += 4 + self.source.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/shape_msgs/mesh.rs b/generated/rust_lcm_msgs/src/shape_msgs/mesh.rs new file mode 100644 index 0000000..fd53702 --- /dev/null +++ b/generated/rust_lcm_msgs/src/shape_msgs/mesh.rs @@ -0,0 +1,104 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Mesh { + pub triangles: Vec, + pub vertices: Vec, +} + +impl Mesh { + pub const HASH: i64 = 0xDC739FB8D2F81AB9u64 as i64; + pub const NAME: &str = "shape_msgs.Mesh"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::shape_msgs::MeshTriangle::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Point::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.triangles.len() as i32)?; + buf.write_i32::(self.vertices.len() as i32)?; + for v0 in self.triangles.iter() { + v0.encode_one(buf)?; + } + for v0 in self.vertices.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let triangles_length = buf.read_i32::()? as usize; + let vertices_length = buf.read_i32::()? as usize; + let triangles = { + let mut v = Vec::with_capacity(triangles_length); + for _ in 0..triangles_length { + let _elem_0 = crate::shape_msgs::MeshTriangle::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let vertices = { + let mut v = Vec::with_capacity(vertices_length); + for _ in 0..vertices_length { + let _elem_0 = crate::geometry_msgs::Point::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + triangles, + vertices, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + for v0 in self.triangles.iter() { + size += v0.encoded_size(); + } + for v0 in self.vertices.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/shape_msgs/mesh_triangle.rs b/generated/rust_lcm_msgs/src/shape_msgs/mesh_triangle.rs new file mode 100644 index 0000000..f520ba7 --- /dev/null +++ b/generated/rust_lcm_msgs/src/shape_msgs/mesh_triangle.rs @@ -0,0 +1,77 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct MeshTriangle { + pub vertex_indices: [i32; 3], +} + +impl MeshTriangle { + pub const HASH: i64 = 0x2FF7303A4EEA918Du64 as i64; + pub const NAME: &str = "shape_msgs.MeshTriangle"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + for v0 in self.vertex_indices.iter() { + buf.write_i32::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let vertex_indices = { + let mut _arr_0 = [0i32; 3]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_i32::()?; + } + _arr_0 + }; + Ok(Self { + vertex_indices, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.vertex_indices.len() * 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/shape_msgs/mod.rs b/generated/rust_lcm_msgs/src/shape_msgs/mod.rs new file mode 100644 index 0000000..5198623 --- /dev/null +++ b/generated/rust_lcm_msgs/src/shape_msgs/mod.rs @@ -0,0 +1,13 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +mod mesh; +pub use mesh::Mesh; + +mod mesh_triangle; +pub use mesh_triangle::MeshTriangle; + +mod plane; +pub use plane::Plane; + +mod solid_primitive; +pub use solid_primitive::SolidPrimitive; diff --git a/generated/rust_lcm_msgs/src/shape_msgs/plane.rs b/generated/rust_lcm_msgs/src/shape_msgs/plane.rs new file mode 100644 index 0000000..540b42f --- /dev/null +++ b/generated/rust_lcm_msgs/src/shape_msgs/plane.rs @@ -0,0 +1,77 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Plane { + pub coef: [f64; 4], +} + +impl Plane { + pub const HASH: i64 = 0x7E294B30EA2123F2u64 as i64; + pub const NAME: &str = "shape_msgs.Plane"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + for v0 in self.coef.iter() { + buf.write_f64::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let coef = { + let mut _arr_0 = [0.0f64; 4]; + for elem in _arr_0.iter_mut() { + *elem = buf.read_f64::()?; + } + _arr_0 + }; + Ok(Self { + coef, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.coef.len() * 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/shape_msgs/solid_primitive.rs b/generated/rust_lcm_msgs/src/shape_msgs/solid_primitive.rs new file mode 100644 index 0000000..09eb0f3 --- /dev/null +++ b/generated/rust_lcm_msgs/src/shape_msgs/solid_primitive.rs @@ -0,0 +1,99 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct SolidPrimitive { + pub r#type: u8, + pub dimensions: Vec, +} + +impl SolidPrimitive { + pub const HASH: i64 = 0xB8A8E7178CAB07ACu64 as i64; + pub const NAME: &str = "shape_msgs.SolidPrimitive"; + + pub const BOX: i8 = 1; + pub const SPHERE: i8 = 2; + pub const CYLINDER: i8 = 3; + pub const CONE: i8 = 4; + pub const BOX_X: i8 = 0; + pub const BOX_Y: i8 = 1; + pub const BOX_Z: i8 = 2; + pub const SPHERE_RADIUS: i8 = 0; + pub const CYLINDER_HEIGHT: i8 = 0; + pub const CYLINDER_RADIUS: i8 = 1; + pub const CONE_HEIGHT: i8 = 0; + pub const CONE_RADIUS: i8 = 1; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.dimensions.len() as i32)?; + buf.write_u8(self.r#type)?; + for v0 in self.dimensions.iter() { + buf.write_f64::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let dimensions_length = buf.read_i32::()? as usize; + let r#type = buf.read_u8()?; + let dimensions = { + let mut v = Vec::with_capacity(dimensions_length); + for _ in 0..dimensions_length { + let _elem_0 = buf.read_f64::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + r#type, + dimensions, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 1; + size += self.dimensions.len() * 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/bool.rs b/generated/rust_lcm_msgs/src/std_msgs/bool.rs new file mode 100644 index 0000000..414dc26 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/bool.rs @@ -0,0 +1,69 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Bool { + pub data: bool, +} + +impl Bool { + pub const HASH: i64 = 0x0F5F7835284A871Fu64 as i64; + pub const NAME: &str = "std_msgs.Bool"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i8(if self.data { 1 } else { 0 })?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data = buf.read_i8()? != 0; + Ok(Self { + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/byte.rs b/generated/rust_lcm_msgs/src/std_msgs/byte.rs new file mode 100644 index 0000000..af00c84 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/byte.rs @@ -0,0 +1,69 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Byte { + pub data: i8, +} + +impl Byte { + pub const HASH: i64 = 0x90E9A182FEDDA20Au64 as i64; + pub const NAME: &str = "std_msgs.Byte"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i8(self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data = buf.read_i8()?; + Ok(Self { + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/byte_multi_array.rs b/generated/rust_lcm_msgs/src/std_msgs/byte_multi_array.rs new file mode 100644 index 0000000..1027f13 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/byte_multi_array.rs @@ -0,0 +1,87 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct ByteMultiArray { + pub layout: crate::std_msgs::MultiArrayLayout, + pub data: Vec, +} + +impl ByteMultiArray { + pub const HASH: i64 = 0xDCC1940B891BE505u64 as i64; + pub const NAME: &str = "std_msgs.ByteMultiArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::MultiArrayLayout::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.layout.encode_one(buf)?; + for v0 in self.data.iter() { + buf.write_i8(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let layout = crate::std_msgs::MultiArrayLayout::decode_one(buf)?; + let data = { + let mut v = Vec::with_capacity(data_length); + for _ in 0..data_length { + let _elem_0 = buf.read_i8()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + layout, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.layout.encoded_size(); + size += self.data.len() * 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/char.rs b/generated/rust_lcm_msgs/src/std_msgs/char.rs new file mode 100644 index 0000000..4b518ac --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/char.rs @@ -0,0 +1,69 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Char { + pub data: u8, +} + +impl Char { + pub const HASH: i64 = 0x74856D0F697D2DC2u64 as i64; + pub const NAME: &str = "std_msgs.Char"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_u8(self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data = buf.read_u8()?; + Ok(Self { + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/color_rgba.rs b/generated/rust_lcm_msgs/src/std_msgs/color_rgba.rs new file mode 100644 index 0000000..e94aea6 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/color_rgba.rs @@ -0,0 +1,84 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct ColorRGBA { + pub r: f32, + pub g: f32, + pub b: f32, + pub a: f32, +} + +impl ColorRGBA { + pub const HASH: i64 = 0x3719400FC6E3011Au64 as i64; + pub const NAME: &str = "std_msgs.ColorRGBA"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_f32::(self.r)?; + buf.write_f32::(self.g)?; + buf.write_f32::(self.b)?; + buf.write_f32::(self.a)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let r = buf.read_f32::()?; + let g = buf.read_f32::()?; + let b = buf.read_f32::()?; + let a = buf.read_f32::()?; + Ok(Self { + r, + g, + b, + a, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += 4; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/duration.rs b/generated/rust_lcm_msgs/src/std_msgs/duration.rs new file mode 100644 index 0000000..2ee6ea0 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/duration.rs @@ -0,0 +1,74 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Duration { + pub sec: i32, + pub nsec: i32, +} + +impl Duration { + pub const HASH: i64 = 0xDE1D24A3A8ECB648u64 as i64; + pub const NAME: &str = "std_msgs.Duration"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.sec)?; + buf.write_i32::(self.nsec)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let sec = buf.read_i32::()?; + let nsec = buf.read_i32::()?; + Ok(Self { + sec, + nsec, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/empty.rs b/generated/rust_lcm_msgs/src/std_msgs/empty.rs new file mode 100644 index 0000000..f937f61 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/empty.rs @@ -0,0 +1,63 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Empty { +} + +impl Empty { + pub const HASH: i64 = 0x0000000012345678u64 as i64; + pub const NAME: &str = "std_msgs.Empty"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, _buf: &mut W) -> io::Result<()> { + Ok(()) + } + + pub fn decode_one(_buf: &mut R) -> io::Result { + Ok(Self { + }) + } + + pub fn encoded_size(&self) -> usize { + 0 + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/float32.rs b/generated/rust_lcm_msgs/src/std_msgs/float32.rs new file mode 100644 index 0000000..6a45920 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/float32.rs @@ -0,0 +1,69 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Float32 { + pub data: f32, +} + +impl Float32 { + pub const HASH: i64 = 0x856E135C782A36E9u64 as i64; + pub const NAME: &str = "std_msgs.Float32"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_f32::(self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data = buf.read_f32::()?; + Ok(Self { + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/float32_multi_array.rs b/generated/rust_lcm_msgs/src/std_msgs/float32_multi_array.rs new file mode 100644 index 0000000..ee44035 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/float32_multi_array.rs @@ -0,0 +1,87 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Float32MultiArray { + pub layout: crate::std_msgs::MultiArrayLayout, + pub data: Vec, +} + +impl Float32MultiArray { + pub const HASH: i64 = 0x7138323E2B24BE12u64 as i64; + pub const NAME: &str = "std_msgs.Float32MultiArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::MultiArrayLayout::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.layout.encode_one(buf)?; + for v0 in self.data.iter() { + buf.write_f32::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let layout = crate::std_msgs::MultiArrayLayout::decode_one(buf)?; + let data = { + let mut v = Vec::with_capacity(data_length); + for _ in 0..data_length { + let _elem_0 = buf.read_f32::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + layout, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.layout.encoded_size(); + size += self.data.len() * 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/float64.rs b/generated/rust_lcm_msgs/src/std_msgs/float64.rs new file mode 100644 index 0000000..3b9f664 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/float64.rs @@ -0,0 +1,69 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Float64 { + pub data: f64, +} + +impl Float64 { + pub const HASH: i64 = 0x90EEA081D4D0B10Au64 as i64; + pub const NAME: &str = "std_msgs.Float64"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_f64::(self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data = buf.read_f64::()?; + Ok(Self { + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/float64_multi_array.rs b/generated/rust_lcm_msgs/src/std_msgs/float64_multi_array.rs new file mode 100644 index 0000000..3098677 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/float64_multi_array.rs @@ -0,0 +1,87 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Float64MultiArray { + pub layout: crate::std_msgs::MultiArrayLayout, + pub data: Vec, +} + +impl Float64MultiArray { + pub const HASH: i64 = 0x45A3940B9D17E120u64 as i64; + pub const NAME: &str = "std_msgs.Float64MultiArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::MultiArrayLayout::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.layout.encode_one(buf)?; + for v0 in self.data.iter() { + buf.write_f64::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let layout = crate::std_msgs::MultiArrayLayout::decode_one(buf)?; + let data = { + let mut v = Vec::with_capacity(data_length); + for _ in 0..data_length { + let _elem_0 = buf.read_f64::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + layout, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.layout.encoded_size(); + size += self.data.len() * 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/header.rs b/generated/rust_lcm_msgs/src/std_msgs/header.rs new file mode 100644 index 0000000..b42a03f --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/header.rs @@ -0,0 +1,91 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Header { + pub seq: i32, + pub stamp: crate::std_msgs::Time, + pub frame_id: std::string::String, +} + +impl Header { + pub const HASH: i64 = 0xDBB33F5B4C19B8EAu64 as i64; + pub const NAME: &str = "std_msgs.Header"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Time::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.seq)?; + self.stamp.encode_one(buf)?; + { + let bytes = self.frame_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let seq = buf.read_i32::()?; + let stamp = crate::std_msgs::Time::decode_one(buf)?; + let frame_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + seq, + stamp, + frame_id, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.stamp.encoded_size(); + size += 4 + self.frame_id.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/int16.rs b/generated/rust_lcm_msgs/src/std_msgs/int16.rs new file mode 100644 index 0000000..3bf86c0 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/int16.rs @@ -0,0 +1,69 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Int16 { + pub data: i16, +} + +impl Int16 { + pub const HASH: i64 = 0x165E7CF9F948811Fu64 as i64; + pub const NAME: &str = "std_msgs.Int16"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i16::(self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data = buf.read_i16::()?; + Ok(Self { + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 2; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/int16_multi_array.rs b/generated/rust_lcm_msgs/src/std_msgs/int16_multi_array.rs new file mode 100644 index 0000000..dad3fcd --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/int16_multi_array.rs @@ -0,0 +1,87 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Int16MultiArray { + pub layout: crate::std_msgs::MultiArrayLayout, + pub data: Vec, +} + +impl Int16MultiArray { + pub const HASH: i64 = 0xAA51366C8F222C76u64 as i64; + pub const NAME: &str = "std_msgs.Int16MultiArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::MultiArrayLayout::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.layout.encode_one(buf)?; + for v0 in self.data.iter() { + buf.write_i16::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let layout = crate::std_msgs::MultiArrayLayout::decode_one(buf)?; + let data = { + let mut v = Vec::with_capacity(data_length); + for _ in 0..data_length { + let _elem_0 = buf.read_i16::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + layout, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.layout.encoded_size(); + size += self.data.len() * 2; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/int32.rs b/generated/rust_lcm_msgs/src/std_msgs/int32.rs new file mode 100644 index 0000000..7b99bb3 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/int32.rs @@ -0,0 +1,69 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Int32 { + pub data: i32, +} + +impl Int32 { + pub const HASH: i64 = 0x165E7CFBF548811Fu64 as i64; + pub const NAME: &str = "std_msgs.Int32"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data = buf.read_i32::()?; + Ok(Self { + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/int32_multi_array.rs b/generated/rust_lcm_msgs/src/std_msgs/int32_multi_array.rs new file mode 100644 index 0000000..49cfa31 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/int32_multi_array.rs @@ -0,0 +1,87 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Int32MultiArray { + pub layout: crate::std_msgs::MultiArrayLayout, + pub data: Vec, +} + +impl Int32MultiArray { + pub const HASH: i64 = 0xAA51366C8F222486u64 as i64; + pub const NAME: &str = "std_msgs.Int32MultiArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::MultiArrayLayout::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.layout.encode_one(buf)?; + for v0 in self.data.iter() { + buf.write_i32::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let layout = crate::std_msgs::MultiArrayLayout::decode_one(buf)?; + let data = { + let mut v = Vec::with_capacity(data_length); + for _ in 0..data_length { + let _elem_0 = buf.read_i32::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + layout, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.layout.encoded_size(); + size += self.data.len() * 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/int64.rs b/generated/rust_lcm_msgs/src/std_msgs/int64.rs new file mode 100644 index 0000000..601f92b --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/int64.rs @@ -0,0 +1,69 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Int64 { + pub data: i64, +} + +impl Int64 { + pub const HASH: i64 = 0x165E7CFEF748811Fu64 as i64; + pub const NAME: &str = "std_msgs.Int64"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i64::(self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data = buf.read_i64::()?; + Ok(Self { + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/int64_multi_array.rs b/generated/rust_lcm_msgs/src/std_msgs/int64_multi_array.rs new file mode 100644 index 0000000..8abdf2e --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/int64_multi_array.rs @@ -0,0 +1,87 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Int64MultiArray { + pub layout: crate::std_msgs::MultiArrayLayout, + pub data: Vec, +} + +impl Int64MultiArray { + pub const HASH: i64 = 0xAA51366C8F22187Eu64 as i64; + pub const NAME: &str = "std_msgs.Int64MultiArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::MultiArrayLayout::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.layout.encode_one(buf)?; + for v0 in self.data.iter() { + buf.write_i64::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let layout = crate::std_msgs::MultiArrayLayout::decode_one(buf)?; + let data = { + let mut v = Vec::with_capacity(data_length); + for _ in 0..data_length { + let _elem_0 = buf.read_i64::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + layout, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.layout.encoded_size(); + size += self.data.len() * 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/int8.rs b/generated/rust_lcm_msgs/src/std_msgs/int8.rs new file mode 100644 index 0000000..a9f78e1 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/int8.rs @@ -0,0 +1,69 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Int8 { + pub data: i8, +} + +impl Int8 { + pub const HASH: i64 = 0x90E9A182FEDDA20Au64 as i64; + pub const NAME: &str = "std_msgs.Int8"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i8(self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data = buf.read_i8()?; + Ok(Self { + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/int8_multi_array.rs b/generated/rust_lcm_msgs/src/std_msgs/int8_multi_array.rs new file mode 100644 index 0000000..bcad5f7 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/int8_multi_array.rs @@ -0,0 +1,87 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Int8MultiArray { + pub layout: crate::std_msgs::MultiArrayLayout, + pub data: Vec, +} + +impl Int8MultiArray { + pub const HASH: i64 = 0xDCC1940B891BE505u64 as i64; + pub const NAME: &str = "std_msgs.Int8MultiArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::MultiArrayLayout::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.layout.encode_one(buf)?; + for v0 in self.data.iter() { + buf.write_i8(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let layout = crate::std_msgs::MultiArrayLayout::decode_one(buf)?; + let data = { + let mut v = Vec::with_capacity(data_length); + for _ in 0..data_length { + let _elem_0 = buf.read_i8()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + layout, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.layout.encoded_size(); + size += self.data.len() * 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/mod.rs b/generated/rust_lcm_msgs/src/std_msgs/mod.rs new file mode 100644 index 0000000..45adf01 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/mod.rs @@ -0,0 +1,97 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +mod bool; +pub use bool::Bool; + +mod byte; +pub use byte::Byte; + +mod byte_multi_array; +pub use byte_multi_array::ByteMultiArray; + +mod char; +pub use char::Char; + +mod color_rgba; +pub use color_rgba::ColorRGBA; + +mod duration; +pub use duration::Duration; + +mod empty; +pub use empty::Empty; + +mod float32; +pub use float32::Float32; + +mod float32_multi_array; +pub use float32_multi_array::Float32MultiArray; + +mod float64; +pub use float64::Float64; + +mod float64_multi_array; +pub use float64_multi_array::Float64MultiArray; + +mod header; +pub use header::Header; + +mod int16; +pub use int16::Int16; + +mod int16_multi_array; +pub use int16_multi_array::Int16MultiArray; + +mod int32; +pub use int32::Int32; + +mod int32_multi_array; +pub use int32_multi_array::Int32MultiArray; + +mod int64; +pub use int64::Int64; + +mod int64_multi_array; +pub use int64_multi_array::Int64MultiArray; + +mod int8; +pub use int8::Int8; + +mod int8_multi_array; +pub use int8_multi_array::Int8MultiArray; + +mod multi_array_dimension; +pub use multi_array_dimension::MultiArrayDimension; + +mod multi_array_layout; +pub use multi_array_layout::MultiArrayLayout; + +mod string; +pub use string::String; + +mod time; +pub use time::Time; + +mod u_int16; +pub use u_int16::UInt16; + +mod u_int16_multi_array; +pub use u_int16_multi_array::UInt16MultiArray; + +mod u_int32; +pub use u_int32::UInt32; + +mod u_int32_multi_array; +pub use u_int32_multi_array::UInt32MultiArray; + +mod u_int64; +pub use u_int64::UInt64; + +mod u_int64_multi_array; +pub use u_int64_multi_array::UInt64MultiArray; + +mod u_int8; +pub use u_int8::UInt8; + +mod u_int8_multi_array; +pub use u_int8_multi_array::UInt8MultiArray; diff --git a/generated/rust_lcm_msgs/src/std_msgs/multi_array_dimension.rs b/generated/rust_lcm_msgs/src/std_msgs/multi_array_dimension.rs new file mode 100644 index 0000000..f6cf7ca --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/multi_array_dimension.rs @@ -0,0 +1,90 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct MultiArrayDimension { + pub label: std::string::String, + pub size: i32, + pub stride: i32, +} + +impl MultiArrayDimension { + pub const HASH: i64 = 0xCEC1B9E9D868EF97u64 as i64; + pub const NAME: &str = "std_msgs.MultiArrayDimension"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + { + let bytes = self.label.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_i32::(self.size)?; + buf.write_i32::(self.stride)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let label = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let size = buf.read_i32::()?; + let stride = buf.read_i32::()?; + Ok(Self { + label, + size, + stride, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4 + self.label.len() + 1; + size += 4; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/multi_array_layout.rs b/generated/rust_lcm_msgs/src/std_msgs/multi_array_layout.rs new file mode 100644 index 0000000..9ced27c --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/multi_array_layout.rs @@ -0,0 +1,89 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct MultiArrayLayout { + pub dim: Vec, + pub data_offset: i32, +} + +impl MultiArrayLayout { + pub const HASH: i64 = 0x0BF4B5363481D321u64 as i64; + pub const NAME: &str = "std_msgs.MultiArrayLayout"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::MultiArrayDimension::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.dim.len() as i32)?; + for v0 in self.dim.iter() { + v0.encode_one(buf)?; + } + buf.write_i32::(self.data_offset)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let dim_length = buf.read_i32::()? as usize; + let dim = { + let mut v = Vec::with_capacity(dim_length); + for _ in 0..dim_length { + let _elem_0 = crate::std_msgs::MultiArrayDimension::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let data_offset = buf.read_i32::()?; + Ok(Self { + dim, + data_offset, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + for v0 in self.dim.iter() { + size += v0.encoded_size(); + } + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/string.rs b/generated/rust_lcm_msgs/src/std_msgs/string.rs new file mode 100644 index 0000000..b97f84b --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/string.rs @@ -0,0 +1,80 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct String { + pub data: std::string::String, +} + +impl String { + pub const HASH: i64 = 0x90DF9B84CDCEAF0Au64 as i64; + pub const NAME: &str = "std_msgs.String"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + { + let bytes = self.data.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4 + self.data.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/time.rs b/generated/rust_lcm_msgs/src/std_msgs/time.rs new file mode 100644 index 0000000..7842228 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/time.rs @@ -0,0 +1,74 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Time { + pub sec: i32, + pub nsec: i32, +} + +impl Time { + pub const HASH: i64 = 0xDE1D24A3A8ECB648u64 as i64; + pub const NAME: &str = "std_msgs.Time"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.sec)?; + buf.write_i32::(self.nsec)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let sec = buf.read_i32::()?; + let nsec = buf.read_i32::()?; + Ok(Self { + sec, + nsec, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/u_int16.rs b/generated/rust_lcm_msgs/src/std_msgs/u_int16.rs new file mode 100644 index 0000000..6ea388b --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/u_int16.rs @@ -0,0 +1,69 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct UInt16 { + pub data: i16, +} + +impl UInt16 { + pub const HASH: i64 = 0x165E7CF9F948811Fu64 as i64; + pub const NAME: &str = "std_msgs.UInt16"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i16::(self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data = buf.read_i16::()?; + Ok(Self { + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 2; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/u_int16_multi_array.rs b/generated/rust_lcm_msgs/src/std_msgs/u_int16_multi_array.rs new file mode 100644 index 0000000..50c7e32 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/u_int16_multi_array.rs @@ -0,0 +1,87 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct UInt16MultiArray { + pub layout: crate::std_msgs::MultiArrayLayout, + pub data: Vec, +} + +impl UInt16MultiArray { + pub const HASH: i64 = 0xAA51366C8F222C76u64 as i64; + pub const NAME: &str = "std_msgs.UInt16MultiArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::MultiArrayLayout::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.layout.encode_one(buf)?; + for v0 in self.data.iter() { + buf.write_i16::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let layout = crate::std_msgs::MultiArrayLayout::decode_one(buf)?; + let data = { + let mut v = Vec::with_capacity(data_length); + for _ in 0..data_length { + let _elem_0 = buf.read_i16::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + layout, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.layout.encoded_size(); + size += self.data.len() * 2; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/u_int32.rs b/generated/rust_lcm_msgs/src/std_msgs/u_int32.rs new file mode 100644 index 0000000..d08da23 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/u_int32.rs @@ -0,0 +1,69 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct UInt32 { + pub data: i32, +} + +impl UInt32 { + pub const HASH: i64 = 0x165E7CFBF548811Fu64 as i64; + pub const NAME: &str = "std_msgs.UInt32"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data = buf.read_i32::()?; + Ok(Self { + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/u_int32_multi_array.rs b/generated/rust_lcm_msgs/src/std_msgs/u_int32_multi_array.rs new file mode 100644 index 0000000..35e5afd --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/u_int32_multi_array.rs @@ -0,0 +1,87 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct UInt32MultiArray { + pub layout: crate::std_msgs::MultiArrayLayout, + pub data: Vec, +} + +impl UInt32MultiArray { + pub const HASH: i64 = 0xAA51366C8F222486u64 as i64; + pub const NAME: &str = "std_msgs.UInt32MultiArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::MultiArrayLayout::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.layout.encode_one(buf)?; + for v0 in self.data.iter() { + buf.write_i32::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let layout = crate::std_msgs::MultiArrayLayout::decode_one(buf)?; + let data = { + let mut v = Vec::with_capacity(data_length); + for _ in 0..data_length { + let _elem_0 = buf.read_i32::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + layout, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.layout.encoded_size(); + size += self.data.len() * 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/u_int64.rs b/generated/rust_lcm_msgs/src/std_msgs/u_int64.rs new file mode 100644 index 0000000..cdc26ea --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/u_int64.rs @@ -0,0 +1,69 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct UInt64 { + pub data: i64, +} + +impl UInt64 { + pub const HASH: i64 = 0x165E7CFEF748811Fu64 as i64; + pub const NAME: &str = "std_msgs.UInt64"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i64::(self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data = buf.read_i64::()?; + Ok(Self { + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/u_int64_multi_array.rs b/generated/rust_lcm_msgs/src/std_msgs/u_int64_multi_array.rs new file mode 100644 index 0000000..ad2246b --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/u_int64_multi_array.rs @@ -0,0 +1,87 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct UInt64MultiArray { + pub layout: crate::std_msgs::MultiArrayLayout, + pub data: Vec, +} + +impl UInt64MultiArray { + pub const HASH: i64 = 0xAA51366C8F22187Eu64 as i64; + pub const NAME: &str = "std_msgs.UInt64MultiArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::MultiArrayLayout::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.layout.encode_one(buf)?; + for v0 in self.data.iter() { + buf.write_i64::(*v0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let layout = crate::std_msgs::MultiArrayLayout::decode_one(buf)?; + let data = { + let mut v = Vec::with_capacity(data_length); + for _ in 0..data_length { + let _elem_0 = buf.read_i64::()?; + v.push(_elem_0); + } + v + }; + Ok(Self { + layout, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.layout.encoded_size(); + size += self.data.len() * 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/u_int8.rs b/generated/rust_lcm_msgs/src/std_msgs/u_int8.rs new file mode 100644 index 0000000..e9ab8c9 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/u_int8.rs @@ -0,0 +1,69 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct UInt8 { + pub data: u8, +} + +impl UInt8 { + pub const HASH: i64 = 0x74856D0F697D2DC2u64 as i64; + pub const NAME: &str = "std_msgs.UInt8"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_u8(self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data = buf.read_u8()?; + Ok(Self { + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/std_msgs/u_int8_multi_array.rs b/generated/rust_lcm_msgs/src/std_msgs/u_int8_multi_array.rs new file mode 100644 index 0000000..42e10c2 --- /dev/null +++ b/generated/rust_lcm_msgs/src/std_msgs/u_int8_multi_array.rs @@ -0,0 +1,82 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct UInt8MultiArray { + pub layout: crate::std_msgs::MultiArrayLayout, + pub data: Vec, +} + +impl UInt8MultiArray { + pub const HASH: i64 = 0x386AEFA0332516BFu64 as i64; + pub const NAME: &str = "std_msgs.UInt8MultiArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::MultiArrayLayout::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.data.len() as i32)?; + self.layout.encode_one(buf)?; + buf.write_all(&self.data)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let data_length = buf.read_i32::()? as usize; + let layout = crate::std_msgs::MultiArrayLayout::decode_one(buf)?; + let data = { + let mut v = vec![0u8; data_length]; + buf.read_exact(&mut v)?; + v + }; + Ok(Self { + layout, + data, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.layout.encoded_size(); + size += self.data.len(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/stereo_msgs/disparity_image.rs b/generated/rust_lcm_msgs/src/stereo_msgs/disparity_image.rs new file mode 100644 index 0000000..37168ed --- /dev/null +++ b/generated/rust_lcm_msgs/src/stereo_msgs/disparity_image.rs @@ -0,0 +1,107 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct DisparityImage { + pub header: crate::std_msgs::Header, + pub image: crate::sensor_msgs::Image, + pub f: f32, + pub T: f32, + pub valid_window: crate::sensor_msgs::RegionOfInterest, + pub min_disparity: f32, + pub max_disparity: f32, + pub delta_d: f32, +} + +impl DisparityImage { + pub const HASH: i64 = 0xDEB7A557A2B9258Au64 as i64; + pub const NAME: &str = "stereo_msgs.DisparityImage"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::sensor_msgs::Image::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::sensor_msgs::RegionOfInterest::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.image.encode_one(buf)?; + buf.write_f32::(self.f)?; + buf.write_f32::(self.T)?; + self.valid_window.encode_one(buf)?; + buf.write_f32::(self.min_disparity)?; + buf.write_f32::(self.max_disparity)?; + buf.write_f32::(self.delta_d)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let image = crate::sensor_msgs::Image::decode_one(buf)?; + let f = buf.read_f32::()?; + let T = buf.read_f32::()?; + let valid_window = crate::sensor_msgs::RegionOfInterest::decode_one(buf)?; + let min_disparity = buf.read_f32::()?; + let max_disparity = buf.read_f32::()?; + let delta_d = buf.read_f32::()?; + Ok(Self { + header, + image, + f, + T, + valid_window, + min_disparity, + max_disparity, + delta_d, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.image.encoded_size(); + size += 4; + size += 4; + size += self.valid_window.encoded_size(); + size += 4; + size += 4; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/stereo_msgs/mod.rs b/generated/rust_lcm_msgs/src/stereo_msgs/mod.rs new file mode 100644 index 0000000..bcaf357 --- /dev/null +++ b/generated/rust_lcm_msgs/src/stereo_msgs/mod.rs @@ -0,0 +1,4 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +mod disparity_image; +pub use disparity_image::DisparityImage; diff --git a/generated/rust_lcm_msgs/src/tf2_msgs/mod.rs b/generated/rust_lcm_msgs/src/tf2_msgs/mod.rs new file mode 100644 index 0000000..b70a6e5 --- /dev/null +++ b/generated/rust_lcm_msgs/src/tf2_msgs/mod.rs @@ -0,0 +1,7 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +mod tf2_error; +pub use tf2_error::TF2Error; + +mod tf_message; +pub use tf_message::TFMessage; diff --git a/generated/rust_lcm_msgs/src/tf2_msgs/tf2_error.rs b/generated/rust_lcm_msgs/src/tf2_msgs/tf2_error.rs new file mode 100644 index 0000000..574d107 --- /dev/null +++ b/generated/rust_lcm_msgs/src/tf2_msgs/tf2_error.rs @@ -0,0 +1,93 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct TF2Error { + pub error: u8, + pub error_string: std::string::String, +} + +impl TF2Error { + pub const HASH: i64 = 0x1E8FF0D80D02EE55u64 as i64; + pub const NAME: &str = "tf2_msgs.TF2Error"; + + pub const NO_ERROR: i8 = 0; + pub const LOOKUP_ERROR: i8 = 1; + pub const CONNECTIVITY_ERROR: i8 = 2; + pub const EXTRAPOLATION_ERROR: i8 = 3; + pub const INVALID_ARGUMENT_ERROR: i8 = 4; + pub const TIMEOUT_ERROR: i8 = 5; + pub const TRANSFORM_ERROR: i8 = 6; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_u8(self.error)?; + { + let bytes = self.error_string.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let error = buf.read_u8()?; + let error_string = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + error, + error_string, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 1; + size += 4 + self.error_string.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/tf2_msgs/tf_message.rs b/generated/rust_lcm_msgs/src/tf2_msgs/tf_message.rs new file mode 100644 index 0000000..219f924 --- /dev/null +++ b/generated/rust_lcm_msgs/src/tf2_msgs/tf_message.rs @@ -0,0 +1,84 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct TFMessage { + pub transforms: Vec, +} + +impl TFMessage { + pub const HASH: i64 = 0x37BC5CBCE50A5CE2u64 as i64; + pub const NAME: &str = "tf2_msgs.TFMessage"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::TransformStamped::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.transforms.len() as i32)?; + for v0 in self.transforms.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let transforms_length = buf.read_i32::()? as usize; + let transforms = { + let mut v = Vec::with_capacity(transforms_length); + for _ in 0..transforms_length { + let _elem_0 = crate::geometry_msgs::TransformStamped::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + transforms, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + for v0 in self.transforms.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/trajectory_msgs/joint_trajectory.rs b/generated/rust_lcm_msgs/src/trajectory_msgs/joint_trajectory.rs new file mode 100644 index 0000000..d0271f7 --- /dev/null +++ b/generated/rust_lcm_msgs/src/trajectory_msgs/joint_trajectory.rs @@ -0,0 +1,120 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct JointTrajectory { + pub header: crate::std_msgs::Header, + pub joint_names: Vec, + pub points: Vec, +} + +impl JointTrajectory { + pub const HASH: i64 = 0xF09DB31AFE774086u64 as i64; + pub const NAME: &str = "trajectory_msgs.JointTrajectory"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::trajectory_msgs::JointTrajectoryPoint::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.joint_names.len() as i32)?; + buf.write_i32::(self.points.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.joint_names.iter() { + { + let bytes = v0.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + } + for v0 in self.points.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let joint_names_length = buf.read_i32::()? as usize; + let points_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let joint_names = { + let mut v = Vec::with_capacity(joint_names_length); + for _ in 0..joint_names_length { + let _elem_0 = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + v.push(_elem_0); + } + v + }; + let points = { + let mut v = Vec::with_capacity(points_length); + for _ in 0..points_length { + let _elem_0 = crate::trajectory_msgs::JointTrajectoryPoint::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + joint_names, + points, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += self.header.encoded_size(); + for s0 in self.joint_names.iter() { + size += 4 + s0.len() + 1; + } + for v0 in self.points.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/trajectory_msgs/joint_trajectory_point.rs b/generated/rust_lcm_msgs/src/trajectory_msgs/joint_trajectory_point.rs new file mode 100644 index 0000000..c2d2c36 --- /dev/null +++ b/generated/rust_lcm_msgs/src/trajectory_msgs/joint_trajectory_point.rs @@ -0,0 +1,138 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct JointTrajectoryPoint { + pub positions: Vec, + pub velocities: Vec, + pub accelerations: Vec, + pub effort: Vec, + pub time_from_start: crate::std_msgs::Duration, +} + +impl JointTrajectoryPoint { + pub const HASH: i64 = 0x5F17DCAE9DA98292u64 as i64; + pub const NAME: &str = "trajectory_msgs.JointTrajectoryPoint"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Duration::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.positions.len() as i32)?; + buf.write_i32::(self.velocities.len() as i32)?; + buf.write_i32::(self.accelerations.len() as i32)?; + buf.write_i32::(self.effort.len() as i32)?; + for v0 in self.positions.iter() { + buf.write_f64::(*v0)?; + } + for v0 in self.velocities.iter() { + buf.write_f64::(*v0)?; + } + for v0 in self.accelerations.iter() { + buf.write_f64::(*v0)?; + } + for v0 in self.effort.iter() { + buf.write_f64::(*v0)?; + } + self.time_from_start.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let positions_length = buf.read_i32::()? as usize; + let velocities_length = buf.read_i32::()? as usize; + let accelerations_length = buf.read_i32::()? as usize; + let effort_length = buf.read_i32::()? as usize; + let positions = { + let mut v = Vec::with_capacity(positions_length); + for _ in 0..positions_length { + let _elem_0 = buf.read_f64::()?; + v.push(_elem_0); + } + v + }; + let velocities = { + let mut v = Vec::with_capacity(velocities_length); + for _ in 0..velocities_length { + let _elem_0 = buf.read_f64::()?; + v.push(_elem_0); + } + v + }; + let accelerations = { + let mut v = Vec::with_capacity(accelerations_length); + for _ in 0..accelerations_length { + let _elem_0 = buf.read_f64::()?; + v.push(_elem_0); + } + v + }; + let effort = { + let mut v = Vec::with_capacity(effort_length); + for _ in 0..effort_length { + let _elem_0 = buf.read_f64::()?; + v.push(_elem_0); + } + v + }; + let time_from_start = crate::std_msgs::Duration::decode_one(buf)?; + Ok(Self { + positions, + velocities, + accelerations, + effort, + time_from_start, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += 4; + size += 4; + size += self.positions.len() * 8; + size += self.velocities.len() * 8; + size += self.accelerations.len() * 8; + size += self.effort.len() * 8; + size += self.time_from_start.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/trajectory_msgs/mod.rs b/generated/rust_lcm_msgs/src/trajectory_msgs/mod.rs new file mode 100644 index 0000000..b55a7f8 --- /dev/null +++ b/generated/rust_lcm_msgs/src/trajectory_msgs/mod.rs @@ -0,0 +1,13 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +mod joint_trajectory; +pub use joint_trajectory::JointTrajectory; + +mod joint_trajectory_point; +pub use joint_trajectory_point::JointTrajectoryPoint; + +mod multi_dof_joint_trajectory; +pub use multi_dof_joint_trajectory::MultiDOFJointTrajectory; + +mod multi_dof_joint_trajectory_point; +pub use multi_dof_joint_trajectory_point::MultiDOFJointTrajectoryPoint; diff --git a/generated/rust_lcm_msgs/src/trajectory_msgs/multi_dof_joint_trajectory.rs b/generated/rust_lcm_msgs/src/trajectory_msgs/multi_dof_joint_trajectory.rs new file mode 100644 index 0000000..18bea89 --- /dev/null +++ b/generated/rust_lcm_msgs/src/trajectory_msgs/multi_dof_joint_trajectory.rs @@ -0,0 +1,120 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct MultiDOFJointTrajectory { + pub header: crate::std_msgs::Header, + pub joint_names: Vec, + pub points: Vec, +} + +impl MultiDOFJointTrajectory { + pub const HASH: i64 = 0xF09DB31AFE774086u64 as i64; + pub const NAME: &str = "trajectory_msgs.MultiDOFJointTrajectory"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::trajectory_msgs::MultiDOFJointTrajectoryPoint::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.joint_names.len() as i32)?; + buf.write_i32::(self.points.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.joint_names.iter() { + { + let bytes = v0.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + } + for v0 in self.points.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let joint_names_length = buf.read_i32::()? as usize; + let points_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let joint_names = { + let mut v = Vec::with_capacity(joint_names_length); + for _ in 0..joint_names_length { + let _elem_0 = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + v.push(_elem_0); + } + v + }; + let points = { + let mut v = Vec::with_capacity(points_length); + for _ in 0..points_length { + let _elem_0 = crate::trajectory_msgs::MultiDOFJointTrajectoryPoint::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + joint_names, + points, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += self.header.encoded_size(); + for s0 in self.joint_names.iter() { + size += 4 + s0.len() + 1; + } + for v0 in self.points.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/trajectory_msgs/multi_dof_joint_trajectory_point.rs b/generated/rust_lcm_msgs/src/trajectory_msgs/multi_dof_joint_trajectory_point.rs new file mode 100644 index 0000000..0c5951d --- /dev/null +++ b/generated/rust_lcm_msgs/src/trajectory_msgs/multi_dof_joint_trajectory_point.rs @@ -0,0 +1,130 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct MultiDOFJointTrajectoryPoint { + pub transforms: Vec, + pub velocities: Vec, + pub accelerations: Vec, + pub time_from_start: crate::std_msgs::Duration, +} + +impl MultiDOFJointTrajectoryPoint { + pub const HASH: i64 = 0x6AFB214A921F4CFAu64 as i64; + pub const NAME: &str = "trajectory_msgs.MultiDOFJointTrajectoryPoint"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Transform::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Twist::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Twist::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::std_msgs::Duration::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.transforms.len() as i32)?; + buf.write_i32::(self.velocities.len() as i32)?; + buf.write_i32::(self.accelerations.len() as i32)?; + for v0 in self.transforms.iter() { + v0.encode_one(buf)?; + } + for v0 in self.velocities.iter() { + v0.encode_one(buf)?; + } + for v0 in self.accelerations.iter() { + v0.encode_one(buf)?; + } + self.time_from_start.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let transforms_length = buf.read_i32::()? as usize; + let velocities_length = buf.read_i32::()? as usize; + let accelerations_length = buf.read_i32::()? as usize; + let transforms = { + let mut v = Vec::with_capacity(transforms_length); + for _ in 0..transforms_length { + let _elem_0 = crate::geometry_msgs::Transform::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let velocities = { + let mut v = Vec::with_capacity(velocities_length); + for _ in 0..velocities_length { + let _elem_0 = crate::geometry_msgs::Twist::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let accelerations = { + let mut v = Vec::with_capacity(accelerations_length); + for _ in 0..accelerations_length { + let _elem_0 = crate::geometry_msgs::Twist::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let time_from_start = crate::std_msgs::Duration::decode_one(buf)?; + Ok(Self { + transforms, + velocities, + accelerations, + time_from_start, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += 4; + for v0 in self.transforms.iter() { + size += v0.encoded_size(); + } + for v0 in self.velocities.iter() { + size += v0.encoded_size(); + } + for v0 in self.accelerations.iter() { + size += v0.encoded_size(); + } + size += self.time_from_start.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/bounding_box2_d.rs b/generated/rust_lcm_msgs/src/vision_msgs/bounding_box2_d.rs new file mode 100644 index 0000000..50cda56 --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/bounding_box2_d.rs @@ -0,0 +1,80 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct BoundingBox2D { + pub center: crate::vision_msgs::Pose2D, + pub size_x: f64, + pub size_y: f64, +} + +impl BoundingBox2D { + pub const HASH: i64 = 0xE2274AD6240F1C77u64 as i64; + pub const NAME: &str = "vision_msgs.BoundingBox2D"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::vision_msgs::Pose2D::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.center.encode_one(buf)?; + buf.write_f64::(self.size_x)?; + buf.write_f64::(self.size_y)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let center = crate::vision_msgs::Pose2D::decode_one(buf)?; + let size_x = buf.read_f64::()?; + let size_y = buf.read_f64::()?; + Ok(Self { + center, + size_x, + size_y, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.center.encoded_size(); + size += 8; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/bounding_box2_d_array.rs b/generated/rust_lcm_msgs/src/vision_msgs/bounding_box2_d_array.rs new file mode 100644 index 0000000..7a0c6ea --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/bounding_box2_d_array.rs @@ -0,0 +1,90 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct BoundingBox2DArray { + pub header: crate::std_msgs::Header, + pub boxes: Vec, +} + +impl BoundingBox2DArray { + pub const HASH: i64 = 0xB279B6AC710340A2u64 as i64; + pub const NAME: &str = "vision_msgs.BoundingBox2DArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::vision_msgs::BoundingBox2D::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.boxes.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.boxes.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let boxes_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let boxes = { + let mut v = Vec::with_capacity(boxes_length); + for _ in 0..boxes_length { + let _elem_0 = crate::vision_msgs::BoundingBox2D::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + boxes, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + for v0 in self.boxes.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/bounding_box3_d.rs b/generated/rust_lcm_msgs/src/vision_msgs/bounding_box3_d.rs new file mode 100644 index 0000000..c5082f2 --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/bounding_box3_d.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct BoundingBox3D { + pub center: crate::geometry_msgs::Pose, + pub size: crate::geometry_msgs::Vector3, +} + +impl BoundingBox3D { + pub const HASH: i64 = 0xE10FEEC5CBA89663u64 as i64; + pub const NAME: &str = "vision_msgs.BoundingBox3D"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.center.encode_one(buf)?; + self.size.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let center = crate::geometry_msgs::Pose::decode_one(buf)?; + let size = crate::geometry_msgs::Vector3::decode_one(buf)?; + Ok(Self { + center, + size, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.center.encoded_size(); + size += self.size.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/bounding_box3_d_array.rs b/generated/rust_lcm_msgs/src/vision_msgs/bounding_box3_d_array.rs new file mode 100644 index 0000000..4eb4203 --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/bounding_box3_d_array.rs @@ -0,0 +1,90 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct BoundingBox3DArray { + pub header: crate::std_msgs::Header, + pub boxes: Vec, +} + +impl BoundingBox3DArray { + pub const HASH: i64 = 0xB279B6AC710340A2u64 as i64; + pub const NAME: &str = "vision_msgs.BoundingBox3DArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::vision_msgs::BoundingBox3D::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.boxes.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.boxes.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let boxes_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let boxes = { + let mut v = Vec::with_capacity(boxes_length); + for _ in 0..boxes_length { + let _elem_0 = crate::vision_msgs::BoundingBox3D::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + boxes, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + for v0 in self.boxes.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/classification.rs b/generated/rust_lcm_msgs/src/vision_msgs/classification.rs new file mode 100644 index 0000000..c624c6b --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/classification.rs @@ -0,0 +1,90 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Classification { + pub header: crate::std_msgs::Header, + pub results: Vec, +} + +impl Classification { + pub const HASH: i64 = 0x60719354AAE1B22Au64 as i64; + pub const NAME: &str = "vision_msgs.Classification"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::vision_msgs::ObjectHypothesis::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.results.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.results.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let results_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let results = { + let mut v = Vec::with_capacity(results_length); + for _ in 0..results_length { + let _elem_0 = crate::vision_msgs::ObjectHypothesis::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + results, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + for v0 in self.results.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/detection2_d.rs b/generated/rust_lcm_msgs/src/vision_msgs/detection2_d.rs new file mode 100644 index 0000000..565a6bb --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/detection2_d.rs @@ -0,0 +1,112 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Detection2D { + pub header: crate::std_msgs::Header, + pub results: Vec, + pub bbox: crate::vision_msgs::BoundingBox2D, + pub id: std::string::String, +} + +impl Detection2D { + pub const HASH: i64 = 0x7C62020C10A78D22u64 as i64; + pub const NAME: &str = "vision_msgs.Detection2D"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::vision_msgs::ObjectHypothesisWithPose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::vision_msgs::BoundingBox2D::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.results.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.results.iter() { + v0.encode_one(buf)?; + } + self.bbox.encode_one(buf)?; + { + let bytes = self.id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let results_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let results = { + let mut v = Vec::with_capacity(results_length); + for _ in 0..results_length { + let _elem_0 = crate::vision_msgs::ObjectHypothesisWithPose::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let bbox = crate::vision_msgs::BoundingBox2D::decode_one(buf)?; + let id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + header, + results, + bbox, + id, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + for v0 in self.results.iter() { + size += v0.encoded_size(); + } + size += self.bbox.encoded_size(); + size += 4 + self.id.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/detection2_d_array.rs b/generated/rust_lcm_msgs/src/vision_msgs/detection2_d_array.rs new file mode 100644 index 0000000..03c3ddb --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/detection2_d_array.rs @@ -0,0 +1,90 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Detection2DArray { + pub header: crate::std_msgs::Header, + pub detections: Vec, +} + +impl Detection2DArray { + pub const HASH: i64 = 0x85B4A076BA01BE3Cu64 as i64; + pub const NAME: &str = "vision_msgs.Detection2DArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::vision_msgs::Detection2D::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.detections.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.detections.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let detections_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let detections = { + let mut v = Vec::with_capacity(detections_length); + for _ in 0..detections_length { + let _elem_0 = crate::vision_msgs::Detection2D::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + detections, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + for v0 in self.detections.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/detection3_d.rs b/generated/rust_lcm_msgs/src/vision_msgs/detection3_d.rs new file mode 100644 index 0000000..46d2068 --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/detection3_d.rs @@ -0,0 +1,112 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Detection3D { + pub header: crate::std_msgs::Header, + pub results: Vec, + pub bbox: crate::vision_msgs::BoundingBox3D, + pub id: std::string::String, +} + +impl Detection3D { + pub const HASH: i64 = 0x7C62020C10A78D22u64 as i64; + pub const NAME: &str = "vision_msgs.Detection3D"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::vision_msgs::ObjectHypothesisWithPose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::vision_msgs::BoundingBox3D::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.results.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.results.iter() { + v0.encode_one(buf)?; + } + self.bbox.encode_one(buf)?; + { + let bytes = self.id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let results_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let results = { + let mut v = Vec::with_capacity(results_length); + for _ in 0..results_length { + let _elem_0 = crate::vision_msgs::ObjectHypothesisWithPose::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let bbox = crate::vision_msgs::BoundingBox3D::decode_one(buf)?; + let id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + header, + results, + bbox, + id, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + for v0 in self.results.iter() { + size += v0.encoded_size(); + } + size += self.bbox.encoded_size(); + size += 4 + self.id.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/detection3_d_array.rs b/generated/rust_lcm_msgs/src/vision_msgs/detection3_d_array.rs new file mode 100644 index 0000000..5d98c04 --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/detection3_d_array.rs @@ -0,0 +1,90 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Detection3DArray { + pub header: crate::std_msgs::Header, + pub detections: Vec, +} + +impl Detection3DArray { + pub const HASH: i64 = 0x85B4A076BA01BE3Cu64 as i64; + pub const NAME: &str = "vision_msgs.Detection3DArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::vision_msgs::Detection3D::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.detections.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.detections.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let detections_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let detections = { + let mut v = Vec::with_capacity(detections_length); + for _ in 0..detections_length { + let _elem_0 = crate::vision_msgs::Detection3D::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + detections, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + for v0 in self.detections.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/label_info.rs b/generated/rust_lcm_msgs/src/vision_msgs/label_info.rs new file mode 100644 index 0000000..6848544 --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/label_info.rs @@ -0,0 +1,95 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct LabelInfo { + pub header: crate::std_msgs::Header, + pub class_map: Vec, + pub threshold: f32, +} + +impl LabelInfo { + pub const HASH: i64 = 0x73231A5050580A67u64 as i64; + pub const NAME: &str = "vision_msgs.LabelInfo"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::vision_msgs::VisionClass::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.class_map.len() as i32)?; + self.header.encode_one(buf)?; + for v0 in self.class_map.iter() { + v0.encode_one(buf)?; + } + buf.write_f32::(self.threshold)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let class_map_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let class_map = { + let mut v = Vec::with_capacity(class_map_length); + for _ in 0..class_map_length { + let _elem_0 = crate::vision_msgs::VisionClass::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let threshold = buf.read_f32::()?; + Ok(Self { + header, + class_map, + threshold, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += self.header.encoded_size(); + for v0 in self.class_map.iter() { + size += v0.encoded_size(); + } + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/mod.rs b/generated/rust_lcm_msgs/src/vision_msgs/mod.rs new file mode 100644 index 0000000..f2ffe41 --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/mod.rs @@ -0,0 +1,49 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +mod bounding_box2_d; +pub use bounding_box2_d::BoundingBox2D; + +mod bounding_box2_d_array; +pub use bounding_box2_d_array::BoundingBox2DArray; + +mod bounding_box3_d; +pub use bounding_box3_d::BoundingBox3D; + +mod bounding_box3_d_array; +pub use bounding_box3_d_array::BoundingBox3DArray; + +mod classification; +pub use classification::Classification; + +mod detection2_d; +pub use detection2_d::Detection2D; + +mod detection2_d_array; +pub use detection2_d_array::Detection2DArray; + +mod detection3_d; +pub use detection3_d::Detection3D; + +mod detection3_d_array; +pub use detection3_d_array::Detection3DArray; + +mod label_info; +pub use label_info::LabelInfo; + +mod object_hypothesis; +pub use object_hypothesis::ObjectHypothesis; + +mod object_hypothesis_with_pose; +pub use object_hypothesis_with_pose::ObjectHypothesisWithPose; + +mod point2_d; +pub use point2_d::Point2D; + +mod pose2_d; +pub use pose2_d::Pose2D; + +mod vision_class; +pub use vision_class::VisionClass; + +mod vision_info; +pub use vision_info::VisionInfo; diff --git a/generated/rust_lcm_msgs/src/vision_msgs/object_hypothesis.rs b/generated/rust_lcm_msgs/src/vision_msgs/object_hypothesis.rs new file mode 100644 index 0000000..bed7669 --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/object_hypothesis.rs @@ -0,0 +1,85 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct ObjectHypothesis { + pub class_id: std::string::String, + pub score: f64, +} + +impl ObjectHypothesis { + pub const HASH: i64 = 0x38C9ACD543138B22u64 as i64; + pub const NAME: &str = "vision_msgs.ObjectHypothesis"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + { + let bytes = self.class_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_f64::(self.score)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let class_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let score = buf.read_f64::()?; + Ok(Self { + class_id, + score, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4 + self.class_id.len() + 1; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/object_hypothesis_with_pose.rs b/generated/rust_lcm_msgs/src/vision_msgs/object_hypothesis_with_pose.rs new file mode 100644 index 0000000..cbb3687 --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/object_hypothesis_with_pose.rs @@ -0,0 +1,76 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct ObjectHypothesisWithPose { + pub hypothesis: crate::vision_msgs::ObjectHypothesis, + pub pose: crate::geometry_msgs::PoseWithCovariance, +} + +impl ObjectHypothesisWithPose { + pub const HASH: i64 = 0x65E1D44B451E8A8Bu64 as i64; + pub const NAME: &str = "vision_msgs.ObjectHypothesisWithPose"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::vision_msgs::ObjectHypothesis::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::PoseWithCovariance::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.hypothesis.encode_one(buf)?; + self.pose.encode_one(buf)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let hypothesis = crate::vision_msgs::ObjectHypothesis::decode_one(buf)?; + let pose = crate::geometry_msgs::PoseWithCovariance::decode_one(buf)?; + Ok(Self { + hypothesis, + pose, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.hypothesis.encoded_size(); + size += self.pose.encoded_size(); + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/point2_d.rs b/generated/rust_lcm_msgs/src/vision_msgs/point2_d.rs new file mode 100644 index 0000000..271878b --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/point2_d.rs @@ -0,0 +1,74 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Point2D { + pub x: f64, + pub y: f64, +} + +impl Point2D { + pub const HASH: i64 = 0xD259512E30B44885u64 as i64; + pub const NAME: &str = "vision_msgs.Point2D"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_f64::(self.x)?; + buf.write_f64::(self.y)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let x = buf.read_f64::()?; + let y = buf.read_f64::()?; + Ok(Self { + x, + y, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 8; + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/pose2_d.rs b/generated/rust_lcm_msgs/src/vision_msgs/pose2_d.rs new file mode 100644 index 0000000..b86f362 --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/pose2_d.rs @@ -0,0 +1,75 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Pose2D { + pub position: crate::vision_msgs::Point2D, + pub theta: f64, +} + +impl Pose2D { + pub const HASH: i64 = 0x02DA59BF5B18F540u64 as i64; + pub const NAME: &str = "vision_msgs.Pose2D"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::vision_msgs::Point2D::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.position.encode_one(buf)?; + buf.write_f64::(self.theta)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let position = crate::vision_msgs::Point2D::decode_one(buf)?; + let theta = buf.read_f64::()?; + Ok(Self { + position, + theta, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.position.encoded_size(); + size += 8; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/vision_class.rs b/generated/rust_lcm_msgs/src/vision_msgs/vision_class.rs new file mode 100644 index 0000000..7921bd4 --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/vision_class.rs @@ -0,0 +1,85 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct VisionClass { + pub class_id: i16, + pub class_name: std::string::String, +} + +impl VisionClass { + pub const HASH: i64 = 0xDC055C3DD46C2633u64 as i64; + pub const NAME: &str = "vision_msgs.VisionClass"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i16::(self.class_id)?; + { + let bytes = self.class_name.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let class_id = buf.read_i16::()?; + let class_name = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + class_id, + class_name, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 2; + size += 4 + self.class_name.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/vision_msgs/vision_info.rs b/generated/rust_lcm_msgs/src/vision_msgs/vision_info.rs new file mode 100644 index 0000000..34ba786 --- /dev/null +++ b/generated/rust_lcm_msgs/src/vision_msgs/vision_info.rs @@ -0,0 +1,107 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct VisionInfo { + pub header: crate::std_msgs::Header, + pub method: std::string::String, + pub database_location: std::string::String, + pub database_version: i32, +} + +impl VisionInfo { + pub const HASH: i64 = 0x62C1CBFDC2184FBBu64 as i64; + pub const NAME: &str = "vision_msgs.VisionInfo"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + { + let bytes = self.method.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.database_location.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_i32::(self.database_version)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let method = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let database_location = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let database_version = buf.read_i32::()?; + Ok(Self { + header, + method, + database_location, + database_version, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += 4 + self.method.len() + 1; + size += 4 + self.database_location.len() + 1; + size += 4; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/visualization_msgs/image_marker.rs b/generated/rust_lcm_msgs/src/visualization_msgs/image_marker.rs new file mode 100644 index 0000000..052c60b --- /dev/null +++ b/generated/rust_lcm_msgs/src/visualization_msgs/image_marker.rs @@ -0,0 +1,183 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct ImageMarker { + pub header: crate::std_msgs::Header, + pub ns: std::string::String, + pub id: i32, + pub r#type: i32, + pub action: i32, + pub position: crate::geometry_msgs::Point, + pub scale: f32, + pub outline_color: crate::std_msgs::ColorRGBA, + pub filled: u8, + pub fill_color: crate::std_msgs::ColorRGBA, + pub lifetime: crate::std_msgs::Duration, + pub points: Vec, + pub outline_colors: Vec, +} + +impl ImageMarker { + pub const HASH: i64 = 0x3A3EA371B474D924u64 as i64; + pub const NAME: &str = "visualization_msgs.ImageMarker"; + + pub const CIRCLE: i8 = 0; + pub const LINE_STRIP: i8 = 1; + pub const LINE_LIST: i8 = 2; + pub const POLYGON: i8 = 3; + pub const POINTS: i8 = 4; + pub const ADD: i8 = 0; + pub const REMOVE: i8 = 1; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Point::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::std_msgs::ColorRGBA::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::std_msgs::ColorRGBA::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::std_msgs::Duration::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Point::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::std_msgs::ColorRGBA::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.points.len() as i32)?; + buf.write_i32::(self.outline_colors.len() as i32)?; + self.header.encode_one(buf)?; + { + let bytes = self.ns.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_i32::(self.id)?; + buf.write_i32::(self.r#type)?; + buf.write_i32::(self.action)?; + self.position.encode_one(buf)?; + buf.write_f32::(self.scale)?; + self.outline_color.encode_one(buf)?; + buf.write_u8(self.filled)?; + self.fill_color.encode_one(buf)?; + self.lifetime.encode_one(buf)?; + for v0 in self.points.iter() { + v0.encode_one(buf)?; + } + for v0 in self.outline_colors.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let points_length = buf.read_i32::()? as usize; + let outline_colors_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let ns = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let id = buf.read_i32::()?; + let r#type = buf.read_i32::()?; + let action = buf.read_i32::()?; + let position = crate::geometry_msgs::Point::decode_one(buf)?; + let scale = buf.read_f32::()?; + let outline_color = crate::std_msgs::ColorRGBA::decode_one(buf)?; + let filled = buf.read_u8()?; + let fill_color = crate::std_msgs::ColorRGBA::decode_one(buf)?; + let lifetime = crate::std_msgs::Duration::decode_one(buf)?; + let points = { + let mut v = Vec::with_capacity(points_length); + for _ in 0..points_length { + let _elem_0 = crate::geometry_msgs::Point::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let outline_colors = { + let mut v = Vec::with_capacity(outline_colors_length); + for _ in 0..outline_colors_length { + let _elem_0 = crate::std_msgs::ColorRGBA::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + ns, + id, + r#type, + action, + position, + scale, + outline_color, + filled, + fill_color, + lifetime, + points, + outline_colors, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += self.header.encoded_size(); + size += 4 + self.ns.len() + 1; + size += 4; + size += 4; + size += 4; + size += self.position.encoded_size(); + size += 4; + size += self.outline_color.encoded_size(); + size += 1; + size += self.fill_color.encoded_size(); + size += self.lifetime.encoded_size(); + for v0 in self.points.iter() { + size += v0.encoded_size(); + } + for v0 in self.outline_colors.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker.rs b/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker.rs new file mode 100644 index 0000000..0f0f199 --- /dev/null +++ b/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker.rs @@ -0,0 +1,153 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct InteractiveMarker { + pub header: crate::std_msgs::Header, + pub pose: crate::geometry_msgs::Pose, + pub name: std::string::String, + pub description: std::string::String, + pub scale: f32, + pub menu_entries: Vec, + pub controls: Vec, +} + +impl InteractiveMarker { + pub const HASH: i64 = 0xE9ED8E5F9A72545Fu64 as i64; + pub const NAME: &str = "visualization_msgs.InteractiveMarker"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::visualization_msgs::MenuEntry::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::visualization_msgs::InteractiveMarkerControl::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.menu_entries.len() as i32)?; + buf.write_i32::(self.controls.len() as i32)?; + self.header.encode_one(buf)?; + self.pose.encode_one(buf)?; + { + let bytes = self.name.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.description.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_f32::(self.scale)?; + for v0 in self.menu_entries.iter() { + v0.encode_one(buf)?; + } + for v0 in self.controls.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let menu_entries_length = buf.read_i32::()? as usize; + let controls_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let name = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let description = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let scale = buf.read_f32::()?; + let menu_entries = { + let mut v = Vec::with_capacity(menu_entries_length); + for _ in 0..menu_entries_length { + let _elem_0 = crate::visualization_msgs::MenuEntry::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let controls = { + let mut v = Vec::with_capacity(controls_length); + for _ in 0..controls_length { + let _elem_0 = crate::visualization_msgs::InteractiveMarkerControl::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + header, + pose, + name, + description, + scale, + menu_entries, + controls, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += self.header.encoded_size(); + size += self.pose.encoded_size(); + size += 4 + self.name.len() + 1; + size += 4 + self.description.len() + 1; + size += 4; + for v0 in self.menu_entries.iter() { + size += v0.encoded_size(); + } + for v0 in self.controls.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker_control.rs b/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker_control.rs new file mode 100644 index 0000000..b2ec476 --- /dev/null +++ b/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker_control.rs @@ -0,0 +1,156 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct InteractiveMarkerControl { + pub name: std::string::String, + pub orientation: crate::geometry_msgs::Quaternion, + pub orientation_mode: u8, + pub interaction_mode: u8, + pub always_visible: bool, + pub markers: Vec, + pub independent_marker_orientation: bool, + pub description: std::string::String, +} + +impl InteractiveMarkerControl { + pub const HASH: i64 = 0x9E1DB7D7740DA609u64 as i64; + pub const NAME: &str = "visualization_msgs.InteractiveMarkerControl"; + + pub const INHERIT: i8 = 0; + pub const FIXED: i8 = 1; + pub const VIEW_FACING: i8 = 2; + pub const NONE: i8 = 0; + pub const MENU: i8 = 1; + pub const BUTTON: i8 = 2; + pub const MOVE_AXIS: i8 = 3; + pub const MOVE_PLANE: i8 = 4; + pub const ROTATE_AXIS: i8 = 5; + pub const MOVE_ROTATE: i8 = 6; + pub const MOVE_3D: i8 = 7; + pub const ROTATE_3D: i8 = 8; + pub const MOVE_ROTATE_3D: i8 = 9; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Quaternion::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::visualization_msgs::Marker::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.markers.len() as i32)?; + { + let bytes = self.name.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + self.orientation.encode_one(buf)?; + buf.write_u8(self.orientation_mode)?; + buf.write_u8(self.interaction_mode)?; + buf.write_i8(if self.always_visible { 1 } else { 0 })?; + for v0 in self.markers.iter() { + v0.encode_one(buf)?; + } + buf.write_i8(if self.independent_marker_orientation { 1 } else { 0 })?; + { + let bytes = self.description.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let markers_length = buf.read_i32::()? as usize; + let name = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let orientation = crate::geometry_msgs::Quaternion::decode_one(buf)?; + let orientation_mode = buf.read_u8()?; + let interaction_mode = buf.read_u8()?; + let always_visible = buf.read_i8()? != 0; + let markers = { + let mut v = Vec::with_capacity(markers_length); + for _ in 0..markers_length { + let _elem_0 = crate::visualization_msgs::Marker::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let independent_marker_orientation = buf.read_i8()? != 0; + let description = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + name, + orientation, + orientation_mode, + interaction_mode, + always_visible, + markers, + independent_marker_orientation, + description, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4 + self.name.len() + 1; + size += self.orientation.encoded_size(); + size += 1; + size += 1; + size += 1; + for v0 in self.markers.iter() { + size += v0.encoded_size(); + } + size += 1; + size += 4 + self.description.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker_feedback.rs b/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker_feedback.rs new file mode 100644 index 0000000..698a1de --- /dev/null +++ b/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker_feedback.rs @@ -0,0 +1,152 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct InteractiveMarkerFeedback { + pub header: crate::std_msgs::Header, + pub client_id: std::string::String, + pub marker_name: std::string::String, + pub control_name: std::string::String, + pub event_type: u8, + pub pose: crate::geometry_msgs::Pose, + pub menu_entry_id: i32, + pub mouse_point: crate::geometry_msgs::Point, + pub mouse_point_valid: bool, +} + +impl InteractiveMarkerFeedback { + pub const HASH: i64 = 0xD44E20643FB0D4F7u64 as i64; + pub const NAME: &str = "visualization_msgs.InteractiveMarkerFeedback"; + + pub const KEEP_ALIVE: i8 = 0; + pub const POSE_UPDATE: i8 = 1; + pub const MENU_SELECT: i8 = 2; + pub const BUTTON_CLICK: i8 = 3; + pub const MOUSE_DOWN: i8 = 4; + pub const MOUSE_UP: i8 = 5; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Point::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + { + let bytes = self.client_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.marker_name.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.control_name.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_u8(self.event_type)?; + self.pose.encode_one(buf)?; + buf.write_i32::(self.menu_entry_id)?; + self.mouse_point.encode_one(buf)?; + buf.write_i8(if self.mouse_point_valid { 1 } else { 0 })?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let client_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let marker_name = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let control_name = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let event_type = buf.read_u8()?; + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let menu_entry_id = buf.read_i32::()?; + let mouse_point = crate::geometry_msgs::Point::decode_one(buf)?; + let mouse_point_valid = buf.read_i8()? != 0; + Ok(Self { + header, + client_id, + marker_name, + control_name, + event_type, + pose, + menu_entry_id, + mouse_point, + mouse_point_valid, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += 4 + self.client_id.len() + 1; + size += 4 + self.marker_name.len() + 1; + size += 4 + self.control_name.len() + 1; + size += 1; + size += self.pose.encoded_size(); + size += 4; + size += self.mouse_point.encoded_size(); + size += 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker_init.rs b/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker_init.rs new file mode 100644 index 0000000..71e32bc --- /dev/null +++ b/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker_init.rs @@ -0,0 +1,105 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct InteractiveMarkerInit { + pub server_id: std::string::String, + pub seq_num: i64, + pub markers: Vec, +} + +impl InteractiveMarkerInit { + pub const HASH: i64 = 0x0D2AFAF11CFF61D9u64 as i64; + pub const NAME: &str = "visualization_msgs.InteractiveMarkerInit"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::visualization_msgs::InteractiveMarker::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.markers.len() as i32)?; + { + let bytes = self.server_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_i64::(self.seq_num)?; + for v0 in self.markers.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let markers_length = buf.read_i32::()? as usize; + let server_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let seq_num = buf.read_i64::()?; + let markers = { + let mut v = Vec::with_capacity(markers_length); + for _ in 0..markers_length { + let _elem_0 = crate::visualization_msgs::InteractiveMarker::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + server_id, + seq_num, + markers, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4 + self.server_id.len() + 1; + size += 8; + for v0 in self.markers.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker_pose.rs b/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker_pose.rs new file mode 100644 index 0000000..3cec087 --- /dev/null +++ b/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker_pose.rs @@ -0,0 +1,92 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct InteractiveMarkerPose { + pub header: crate::std_msgs::Header, + pub pose: crate::geometry_msgs::Pose, + pub name: std::string::String, +} + +impl InteractiveMarkerPose { + pub const HASH: i64 = 0x8C873AE70410464Du64 as i64; + pub const NAME: &str = "visualization_msgs.InteractiveMarkerPose"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + self.header.encode_one(buf)?; + self.pose.encode_one(buf)?; + { + let bytes = self.name.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let header = crate::std_msgs::Header::decode_one(buf)?; + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let name = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + Ok(Self { + header, + pose, + name, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += self.header.encoded_size(); + size += self.pose.encoded_size(); + size += 4 + self.name.len() + 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker_update.rs b/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker_update.rs new file mode 100644 index 0000000..40004b8 --- /dev/null +++ b/generated/rust_lcm_msgs/src/visualization_msgs/interactive_marker_update.rs @@ -0,0 +1,163 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct InteractiveMarkerUpdate { + pub server_id: std::string::String, + pub seq_num: i64, + pub r#type: u8, + pub markers: Vec, + pub poses: Vec, + pub erases: Vec, +} + +impl InteractiveMarkerUpdate { + pub const HASH: i64 = 0xF6EEBB4C4A608B4Cu64 as i64; + pub const NAME: &str = "visualization_msgs.InteractiveMarkerUpdate"; + + pub const KEEP_ALIVE: i8 = 0; + pub const UPDATE: i8 = 1; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::visualization_msgs::InteractiveMarker::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::visualization_msgs::InteractiveMarkerPose::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.markers.len() as i32)?; + buf.write_i32::(self.poses.len() as i32)?; + buf.write_i32::(self.erases.len() as i32)?; + { + let bytes = self.server_id.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_i64::(self.seq_num)?; + buf.write_u8(self.r#type)?; + for v0 in self.markers.iter() { + v0.encode_one(buf)?; + } + for v0 in self.poses.iter() { + v0.encode_one(buf)?; + } + for v0 in self.erases.iter() { + { + let bytes = v0.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let markers_length = buf.read_i32::()? as usize; + let poses_length = buf.read_i32::()? as usize; + let erases_length = buf.read_i32::()? as usize; + let server_id = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let seq_num = buf.read_i64::()?; + let r#type = buf.read_u8()?; + let markers = { + let mut v = Vec::with_capacity(markers_length); + for _ in 0..markers_length { + let _elem_0 = crate::visualization_msgs::InteractiveMarker::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let poses = { + let mut v = Vec::with_capacity(poses_length); + for _ in 0..poses_length { + let _elem_0 = crate::visualization_msgs::InteractiveMarkerPose::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let erases = { + let mut v = Vec::with_capacity(erases_length); + for _ in 0..erases_length { + let _elem_0 = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + v.push(_elem_0); + } + v + }; + Ok(Self { + server_id, + seq_num, + r#type, + markers, + poses, + erases, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += 4; + size += 4 + self.server_id.len() + 1; + size += 8; + size += 1; + for v0 in self.markers.iter() { + size += v0.encoded_size(); + } + for v0 in self.poses.iter() { + size += v0.encoded_size(); + } + for s0 in self.erases.iter() { + size += 4 + s0.len() + 1; + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/visualization_msgs/marker.rs b/generated/rust_lcm_msgs/src/visualization_msgs/marker.rs new file mode 100644 index 0000000..4758de4 --- /dev/null +++ b/generated/rust_lcm_msgs/src/visualization_msgs/marker.rs @@ -0,0 +1,224 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Marker { + pub header: crate::std_msgs::Header, + pub ns: std::string::String, + pub id: i32, + pub r#type: i32, + pub action: i32, + pub pose: crate::geometry_msgs::Pose, + pub scale: crate::geometry_msgs::Vector3, + pub color: crate::std_msgs::ColorRGBA, + pub lifetime: crate::std_msgs::Duration, + pub frame_locked: bool, + pub points: Vec, + pub colors: Vec, + pub text: std::string::String, + pub mesh_resource: std::string::String, + pub mesh_use_embedded_materials: bool, +} + +impl Marker { + pub const HASH: i64 = 0x707E24D8BC038BD3u64 as i64; + pub const NAME: &str = "visualization_msgs.Marker"; + + pub const ARROW: i8 = 0; + pub const CUBE: i8 = 1; + pub const SPHERE: i8 = 2; + pub const CYLINDER: i8 = 3; + pub const LINE_STRIP: i8 = 4; + pub const LINE_LIST: i8 = 5; + pub const CUBE_LIST: i8 = 6; + pub const SPHERE_LIST: i8 = 7; + pub const POINTS: i8 = 8; + pub const TEXT_VIEW_FACING: i8 = 9; + pub const MESH_RESOURCE: i8 = 10; + pub const TRIANGLE_LIST: i8 = 11; + pub const ADD: i8 = 0; + pub const MODIFY: i8 = 0; + pub const DELETE: i8 = 2; + pub const DELETEALL: i8 = 3; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::std_msgs::Header::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Pose::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Vector3::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::std_msgs::ColorRGBA::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::std_msgs::Duration::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::geometry_msgs::Point::hash_recursive(parents)); + tmphash = tmphash.wrapping_add(crate::std_msgs::ColorRGBA::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.points.len() as i32)?; + buf.write_i32::(self.colors.len() as i32)?; + self.header.encode_one(buf)?; + { + let bytes = self.ns.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_i32::(self.id)?; + buf.write_i32::(self.r#type)?; + buf.write_i32::(self.action)?; + self.pose.encode_one(buf)?; + self.scale.encode_one(buf)?; + self.color.encode_one(buf)?; + self.lifetime.encode_one(buf)?; + buf.write_i8(if self.frame_locked { 1 } else { 0 })?; + for v0 in self.points.iter() { + v0.encode_one(buf)?; + } + for v0 in self.colors.iter() { + v0.encode_one(buf)?; + } + { + let bytes = self.text.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.mesh_resource.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_i8(if self.mesh_use_embedded_materials { 1 } else { 0 })?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let points_length = buf.read_i32::()? as usize; + let colors_length = buf.read_i32::()? as usize; + let header = crate::std_msgs::Header::decode_one(buf)?; + let ns = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let id = buf.read_i32::()?; + let r#type = buf.read_i32::()?; + let action = buf.read_i32::()?; + let pose = crate::geometry_msgs::Pose::decode_one(buf)?; + let scale = crate::geometry_msgs::Vector3::decode_one(buf)?; + let color = crate::std_msgs::ColorRGBA::decode_one(buf)?; + let lifetime = crate::std_msgs::Duration::decode_one(buf)?; + let frame_locked = buf.read_i8()? != 0; + let points = { + let mut v = Vec::with_capacity(points_length); + for _ in 0..points_length { + let _elem_0 = crate::geometry_msgs::Point::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let colors = { + let mut v = Vec::with_capacity(colors_length); + for _ in 0..colors_length { + let _elem_0 = crate::std_msgs::ColorRGBA::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + let text = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let mesh_resource = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let mesh_use_embedded_materials = buf.read_i8()? != 0; + Ok(Self { + header, + ns, + id, + r#type, + action, + pose, + scale, + color, + lifetime, + frame_locked, + points, + colors, + text, + mesh_resource, + mesh_use_embedded_materials, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += self.header.encoded_size(); + size += 4 + self.ns.len() + 1; + size += 4; + size += 4; + size += 4; + size += self.pose.encoded_size(); + size += self.scale.encoded_size(); + size += self.color.encoded_size(); + size += self.lifetime.encoded_size(); + size += 1; + for v0 in self.points.iter() { + size += v0.encoded_size(); + } + for v0 in self.colors.iter() { + size += v0.encoded_size(); + } + size += 4 + self.text.len() + 1; + size += 4 + self.mesh_resource.len() + 1; + size += 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/visualization_msgs/marker_array.rs b/generated/rust_lcm_msgs/src/visualization_msgs/marker_array.rs new file mode 100644 index 0000000..ad65637 --- /dev/null +++ b/generated/rust_lcm_msgs/src/visualization_msgs/marker_array.rs @@ -0,0 +1,84 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct MarkerArray { + pub markers: Vec, +} + +impl MarkerArray { + pub const HASH: i64 = 0xD9E3851DAD1E0D9Eu64 as i64; + pub const NAME: &str = "visualization_msgs.MarkerArray"; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let mut tmphash = self_hash as u64; + tmphash = tmphash.wrapping_add(crate::visualization_msgs::Marker::hash_recursive(parents)); + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.markers.len() as i32)?; + for v0 in self.markers.iter() { + v0.encode_one(buf)?; + } + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let markers_length = buf.read_i32::()? as usize; + let markers = { + let mut v = Vec::with_capacity(markers_length); + for _ in 0..markers_length { + let _elem_0 = crate::visualization_msgs::Marker::decode_one(buf)?; + v.push(_elem_0); + } + v + }; + Ok(Self { + markers, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + for v0 in self.markers.iter() { + size += v0.encoded_size(); + } + size + } + +} diff --git a/generated/rust_lcm_msgs/src/visualization_msgs/menu_entry.rs b/generated/rust_lcm_msgs/src/visualization_msgs/menu_entry.rs new file mode 100644 index 0000000..31abff4 --- /dev/null +++ b/generated/rust_lcm_msgs/src/visualization_msgs/menu_entry.rs @@ -0,0 +1,115 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; +use std::io::{self, Read, Write, Cursor}; +use std::sync::OnceLock; + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct MenuEntry { + pub id: i32, + pub parent_id: i32, + pub title: std::string::String, + pub command: std::string::String, + pub command_type: u8, +} + +impl MenuEntry { + pub const HASH: i64 = 0x667B2D15EF03E972u64 as i64; + pub const NAME: &str = "visualization_msgs.MenuEntry"; + + pub const FEEDBACK: i8 = 0; + pub const ROSRUN: i8 = 1; + pub const ROSLAUNCH: i8 = 2; + + fn packed_fingerprint() -> u64 { + static CACHE: OnceLock = OnceLock::new(); + *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new())) + } + + pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 { + let self_hash = Self::HASH as u64; + if parents.contains(&self_hash) { + return 0; + } + parents.push(self_hash); + let tmphash = self_hash as u64; + parents.pop(); + // rotate left by 1 + tmphash << 1 | tmphash >> 63 + } + + pub fn encode(&self) -> Vec { + let mut buf = Vec::with_capacity(8 + self.encoded_size()); + buf.write_u64::(Self::packed_fingerprint()).unwrap(); + self.encode_one(&mut buf).unwrap(); + buf + } + + pub fn decode(data: &[u8]) -> io::Result { + let mut cursor = Cursor::new(data); + let hash = cursor.read_u64::()?; + let expected = Self::packed_fingerprint(); + if hash != expected { + return Err(io::Error::new(io::ErrorKind::InvalidData, + format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash))); + } + Self::decode_one(&mut cursor) + } + + pub fn encode_one(&self, buf: &mut W) -> io::Result<()> { + buf.write_i32::(self.id)?; + buf.write_i32::(self.parent_id)?; + { + let bytes = self.title.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + { + let bytes = self.command.as_bytes(); + buf.write_u32::((bytes.len() + 1) as u32)?; + buf.write_all(bytes)?; + buf.write_u8(0)?; + } + buf.write_u8(self.command_type)?; + Ok(()) + } + + pub fn decode_one(buf: &mut R) -> io::Result { + let id = buf.read_i32::()?; + let parent_id = buf.read_i32::()?; + let title = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let command = { + let len = buf.read_u32::()? as usize; + let mut bytes = vec![0u8; len]; + buf.read_exact(&mut bytes)?; + std::string::String::from_utf8(bytes[..len - 1].to_vec()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))? + }; + let command_type = buf.read_u8()?; + Ok(Self { + id, + parent_id, + title, + command, + command_type, + }) + } + + pub fn encoded_size(&self) -> usize { + let mut size = 0usize; + size += 4; + size += 4; + size += 4 + self.title.len() + 1; + size += 4 + self.command.len() + 1; + size += 1; + size + } + +} diff --git a/generated/rust_lcm_msgs/src/visualization_msgs/mod.rs b/generated/rust_lcm_msgs/src/visualization_msgs/mod.rs new file mode 100644 index 0000000..0f891fb --- /dev/null +++ b/generated/rust_lcm_msgs/src/visualization_msgs/mod.rs @@ -0,0 +1,31 @@ +// Auto-generated by lcm-rust-gen. DO NOT EDIT. + +mod image_marker; +pub use image_marker::ImageMarker; + +mod interactive_marker; +pub use interactive_marker::InteractiveMarker; + +mod interactive_marker_control; +pub use interactive_marker_control::InteractiveMarkerControl; + +mod interactive_marker_feedback; +pub use interactive_marker_feedback::InteractiveMarkerFeedback; + +mod interactive_marker_init; +pub use interactive_marker_init::InteractiveMarkerInit; + +mod interactive_marker_pose; +pub use interactive_marker_pose::InteractiveMarkerPose; + +mod interactive_marker_update; +pub use interactive_marker_update::InteractiveMarkerUpdate; + +mod marker; +pub use marker::Marker; + +mod marker_array; +pub use marker_array::MarkerArray; + +mod menu_entry; +pub use menu_entry::MenuEntry; diff --git a/generated/rust_lcm_msgs/tests/round_trip.rs b/generated/rust_lcm_msgs/tests/round_trip.rs new file mode 100644 index 0000000..7634b94 --- /dev/null +++ b/generated/rust_lcm_msgs/tests/round_trip.rs @@ -0,0 +1,80 @@ +//! Round-trip encode/decode tests for generated LCM types. + +use lcm_msgs::geometry_msgs::{Point, Vector3, Pose, Quaternion, PoseWithCovariance}; +use lcm_msgs::std_msgs::Header; +use lcm_msgs::sensor_msgs::Imu; + +#[test] +fn vector3_round_trip() { + let original = Vector3 { x: 1.5, y: -2.0, z: 3.14 }; + let encoded = original.encode(); + let decoded = Vector3::decode(&encoded).unwrap(); + assert_eq!(original, decoded); +} + +#[test] +fn pose_round_trip() { + let original = Pose { + position: Point { x: 1.0, y: 2.0, z: 3.0 }, + orientation: Quaternion { x: 0.0, y: 0.0, z: 0.0, w: 1.0 }, + }; + let encoded = original.encode(); + let decoded = Pose::decode(&encoded).unwrap(); + assert_eq!(original, decoded); +} + +#[test] +fn header_with_string_round_trip() { + let original = Header { + seq: 42, + stamp: lcm_msgs::std_msgs::Time { sec: 1234, nsec: 5678 }, + frame_id: "base_link".to_string(), + }; + let encoded = original.encode(); + let decoded = Header::decode(&encoded).unwrap(); + assert_eq!(original, decoded); +} + +#[test] +fn imu_with_fixed_arrays_round_trip() { + let mut original = Imu::default(); + original.linear_acceleration = Vector3 { x: 0.0, y: 0.0, z: 9.81 }; + original.orientation = Quaternion { x: 0.0, y: 0.0, z: 0.0, w: 1.0 }; + // Set some covariance values + original.orientation_covariance[0] = 0.01; + original.orientation_covariance[4] = 0.01; + original.orientation_covariance[8] = 0.01; + let encoded = original.encode(); + let decoded = Imu::decode(&encoded).unwrap(); + assert_eq!(original, decoded); +} + +#[test] +fn pose_with_covariance_manual_default_round_trip() { + let mut original = PoseWithCovariance::default(); + original.pose = Pose { + position: Point { x: 10.0, y: 20.0, z: 30.0 }, + orientation: Quaternion { x: 0.0, y: 0.0, z: 0.707, w: 0.707 }, + }; + original.covariance[0] = 1.0; + original.covariance[35] = 1.0; + let encoded = original.encode(); + let decoded = PoseWithCovariance::decode(&encoded).unwrap(); + assert_eq!(original, decoded); +} + +#[test] +fn default_values_round_trip() { + // Ensure default-constructed types survive round-trip + let original = Vector3::default(); + let decoded = Vector3::decode(&original.encode()).unwrap(); + assert_eq!(original, decoded); +} + +#[test] +fn hash_mismatch_returns_error() { + let encoded = Vector3 { x: 1.0, y: 2.0, z: 3.0 }.encode(); + // Try to decode as Pose (different hash) — should fail + let result = Pose::decode(&encoded); + assert!(result.is_err()); +} diff --git a/generated/rust_lcm_msgs/tests/roundtrip.rs b/generated/rust_lcm_msgs/tests/roundtrip.rs new file mode 100644 index 0000000..017e068 --- /dev/null +++ b/generated/rust_lcm_msgs/tests/roundtrip.rs @@ -0,0 +1,145 @@ +use lcm_msgs::geometry_msgs::{Point, Pose, PoseStamped, Quaternion, Twist, Vector3}; +use lcm_msgs::std_msgs::{Header, Time}; + +#[test] +fn test_vector3_encode_decode_roundtrip() { + let v = Vector3 { + x: 1.5, + y: 2.5, + z: 3.5, + }; + let encoded = v.encode(); + let decoded = Vector3::decode(&encoded).unwrap(); + assert_eq!(decoded.x.to_bits(), v.x.to_bits()); + assert_eq!(decoded.y.to_bits(), v.y.to_bits()); + assert_eq!(decoded.z.to_bits(), v.z.to_bits()); +} + +#[test] +fn test_twist_encode_decode_roundtrip() { + let t = Twist { + linear: Vector3 { + x: 1.0, + y: 2.0, + z: 3.0, + }, + angular: Vector3 { + x: 0.1, + y: 0.2, + z: 0.3, + }, + }; + let encoded = t.encode(); + let decoded = Twist::decode(&encoded).unwrap(); + assert_eq!(decoded.linear.x.to_bits(), t.linear.x.to_bits()); + assert_eq!(decoded.linear.y.to_bits(), t.linear.y.to_bits()); + assert_eq!(decoded.linear.z.to_bits(), t.linear.z.to_bits()); + assert_eq!(decoded.angular.x.to_bits(), t.angular.x.to_bits()); + assert_eq!(decoded.angular.y.to_bits(), t.angular.y.to_bits()); + assert_eq!(decoded.angular.z.to_bits(), t.angular.z.to_bits()); +} + +#[test] +fn test_pose_stamped_roundtrip() { + let ps = PoseStamped { + header: Header { + seq: 42, + stamp: Time { sec: 100, nsec: 500 }, + frame_id: "map".into(), + }, + pose: Pose { + position: Point { + x: 1.0, + y: 2.0, + z: 3.0, + }, + orientation: Quaternion { + x: 0.0, + y: 0.0, + z: 0.0, + w: 1.0, + }, + }, + }; + let encoded = ps.encode(); + let decoded = PoseStamped::decode(&encoded).unwrap(); + assert_eq!(decoded.header.seq, 42); + assert_eq!(decoded.header.stamp.sec, 100); + assert_eq!(decoded.header.stamp.nsec, 500); + assert_eq!(decoded.header.frame_id, "map"); + assert_eq!(decoded.pose.position.x.to_bits(), 1.0f64.to_bits()); + assert_eq!(decoded.pose.position.y.to_bits(), 2.0f64.to_bits()); + assert_eq!(decoded.pose.position.z.to_bits(), 3.0f64.to_bits()); + assert_eq!(decoded.pose.orientation.x.to_bits(), 0.0f64.to_bits()); + assert_eq!(decoded.pose.orientation.y.to_bits(), 0.0f64.to_bits()); + assert_eq!(decoded.pose.orientation.z.to_bits(), 0.0f64.to_bits()); + assert_eq!(decoded.pose.orientation.w.to_bits(), 1.0f64.to_bits()); +} + +#[test] +fn test_vector3_hash_consistent() { + let v = Vector3 { + x: 1.5, + y: 2.5, + z: 3.5, + }; + let enc1 = v.encode(); + let enc2 = v.encode(); + assert_eq!(&enc1[..8], &enc2[..8]); +} + +#[test] +fn test_decode_corrupted_hash_fails() { + let v = Vector3 { + x: 1.5, + y: 2.5, + z: 3.5, + }; + let mut encoded = v.encode(); + encoded[0] ^= 0xFF; // flip first byte of fingerprint + assert!(Vector3::decode(&encoded).is_err()); +} + +#[test] +fn test_vector3_known_binary_layout() { + let v = Vector3 { + x: 1.5, + y: 2.5, + z: 3.5, + }; + let encoded = v.encode(); + + // Total: 8-byte fingerprint + 3x8-byte f64 = 32 bytes + assert_eq!(encoded.len(), 32); + + // Fingerprint: 0xAE7E5FBA5EECA11E in big-endian + assert_eq!(&encoded[..8], &0xAE7E5FBA5EECA11Eu64.to_be_bytes()); + + // x=1.5 as f64 BE = 0x3FF8000000000000 + assert_eq!(&encoded[8..16], &0x3FF8000000000000u64.to_be_bytes()); + + // y=2.5 as f64 BE = 0x4004000000000000 + assert_eq!(&encoded[16..24], &0x4004000000000000u64.to_be_bytes()); + + // z=3.5 as f64 BE = 0x400C000000000000 + assert_eq!(&encoded[24..32], &0x400C000000000000u64.to_be_bytes()); +} + +#[test] +fn test_twist_known_fingerprint() { + let t = Twist { + linear: Vector3 { + x: 0.0, + y: 0.0, + z: 0.0, + }, + angular: Vector3 { + x: 0.0, + y: 0.0, + z: 0.0, + }, + }; + let encoded = t.encode(); + // Twist fingerprint: 0x2E7C07D7CDF7E027 in big-endian + assert_eq!(&encoded[..8], &0x2E7C07D7CDF7E027u64.to_be_bytes()); +} diff --git a/tools/rust/lcm/.gitignore b/tools/rust/lcm/.gitignore new file mode 100644 index 0000000..b83d222 --- /dev/null +++ b/tools/rust/lcm/.gitignore @@ -0,0 +1 @@ +/target/ diff --git a/tools/rust/lcm/Cargo.lock b/tools/rust/lcm/Cargo.lock new file mode 100644 index 0000000..c83bd01 --- /dev/null +++ b/tools/rust/lcm/Cargo.lock @@ -0,0 +1,223 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "dimos-lcm" +version = "0.1.0" +dependencies = [ + "byteorder", + "lcm-msgs", + "socket2 0.5.10", + "tokio", +] + +[[package]] +name = "lcm-msgs" +version = "0.1.0" +dependencies = [ + "byteorder", +] + +[[package]] +name = "libc" +version = "0.2.185" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52ff2c0fe9bc6cb6b14a0592c2ff4fa9ceb83eea9db979b0487cd054946a2b8f" + +[[package]] +name = "mio" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1" +dependencies = [ + "libc", + "wasi", + "windows-sys 0.61.2", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "socket2" +version = "0.5.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678" +dependencies = [ + "libc", + "windows-sys 0.52.0", +] + +[[package]] +name = "socket2" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "syn" +version = "2.0.117" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "tokio" +version = "1.51.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f66bf9585cda4b724d3e78ab34b73fb2bbaba9011b9bfdf69dc836382ea13b8c" +dependencies = [ + "libc", + "mio", + "pin-project-lite", + "socket2 0.6.3", + "tokio-macros", + "windows-sys 0.61.2", +] + +[[package]] +name = "tokio-macros" +version = "2.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" diff --git a/tools/rust/lcm/Cargo.toml b/tools/rust/lcm/Cargo.toml new file mode 100644 index 0000000..51a7ce8 --- /dev/null +++ b/tools/rust/lcm/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "dimos-lcm" +version = "0.1.0" +edition = "2021" +description = "Pure Rust LCM (Lightweight Communications and Marshalling) transport" +license = "Apache-2.0" + +[dependencies] +byteorder = "1" +socket2 = { version = "0.5", features = ["all"] } +tokio = { version = "1.51.1", features = ["net", "rt-multi-thread", "macros", "time"] } + +[dev-dependencies] +lcm-msgs = { path = "../../../generated/rust_lcm_msgs" } diff --git a/tools/rust/lcm/README.md b/tools/rust/lcm/README.md new file mode 100644 index 0000000..a3c02c2 --- /dev/null +++ b/tools/rust/lcm/README.md @@ -0,0 +1,64 @@ +# dimos-lcm (Rust) + +Pure Rust LCM (Lightweight Communications and Marshalling) transport. No system LCM library required. + +## Installation + +```toml +[dependencies] +dimos-lcm = { git = "https://github.com/dimensionalOS/dimos-lcm.git" } +lcm-msgs = { git = "https://github.com/dimensionalOS/dimos-lcm.git" } +tokio = { version = "1", features = ["full"] } +``` + +## Quick Start + +```rust +use dimos_lcm::Lcm; +use lcm_msgs::geometry_msgs::Vector3; + +#[tokio::main] +async fn main() { + let mut lcm = Lcm::new().await.unwrap(); + + // Publish + let vec = Vector3 { x: 1.0, y: 2.0, z: 3.0 }; + lcm.publish("/vector#geometry_msgs.Vector3", &vec.encode()).await.unwrap(); + + // Receive + let msg = lcm.recv().await.unwrap(); + let vec = Vector3::decode(&msg.data).unwrap(); + println!("{}: x={} y={} z={}", msg.channel, vec.x, vec.y, vec.z); +} +``` + +## API Reference + +#### `Lcm::new() -> io::Result` + +Creates a new LCM transport using default multicast settings (`239.255.76.67:7667`). + +#### `lcm.publish(channel: &str, data: &[u8]) -> io::Result<()>` + +Publishes raw bytes to a channel. Messages larger than a single UDP datagram are automatically fragmented. + +#### `lcm.recv() -> io::Result` + +Waits for the next message and returns it. Reassembles fragmented messages automatically. + +### `ReceivedMessage` + +```rust +pub struct ReceivedMessage { + pub channel: String, + pub data: Vec, +} +``` + +## Examples + +```bash +# In two terminals: +cargo run --example publisher +cargo run --example subscriber +``` \ No newline at end of file diff --git a/tools/rust/lcm/examples/publisher.rs b/tools/rust/lcm/examples/publisher.rs new file mode 100644 index 0000000..341459f --- /dev/null +++ b/tools/rust/lcm/examples/publisher.rs @@ -0,0 +1,40 @@ +// Simple LCM Publisher Example +// Publishes Vector3 messages at 10 Hz + +use dimos_lcm::Lcm; +use lcm_msgs::geometry_msgs::Vector3; +use tokio::time::{sleep, Duration, Instant}; + +const TOPIC: &str = "/vector#geometry_msgs.Vector3"; + +#[tokio::main] +async fn main() { + let lcm = Lcm::new().await.expect("Failed to create Lcm"); + + println!("Publishing Vector3 on {TOPIC}"); + println!("Press Ctrl+C to stop\n"); + + let mut t: f64 = 0.0; + let mut last = Instant::now(); + + loop { + let vec = Vector3 { + x: t.sin() * 5.0, + y: t.cos() * 5.0, + z: t, + }; + + let interval = last.elapsed(); + last = Instant::now(); + + lcm.publish(TOPIC, &vec.encode()).await.unwrap(); + + println!( + "Published: x={:.2} y={:.2} z={:.2} (interval {:.1}ms)", + vec.x, vec.y, vec.z, interval.as_secs_f64() * 1000.0 + ); + + t += 0.1; + sleep(Duration::from_millis(100)).await; + } +} diff --git a/tools/rust/lcm/examples/subscriber.rs b/tools/rust/lcm/examples/subscriber.rs new file mode 100644 index 0000000..e584ce7 --- /dev/null +++ b/tools/rust/lcm/examples/subscriber.rs @@ -0,0 +1,38 @@ +// Simple LCM Subscriber Example +// Receives Vector3 messages + +use dimos_lcm::Lcm; +use lcm_msgs::geometry_msgs::Vector3; +use std::time::Instant; + +const TOPIC: &str = "/vector#geometry_msgs.Vector3"; + +#[tokio::main] +async fn main() { + let mut lcm = Lcm::new().await.expect("Failed to create Lcm"); + + println!("Listening for Vector3 on {TOPIC}"); + println!("Press Ctrl+C to stop\n"); + + let mut last = Instant::now(); + + loop { + match lcm.recv().await { + Ok(msg) if msg.channel == TOPIC => { + match Vector3::decode(&msg.data) { + Ok(vec) => { + let interval = last.elapsed(); + println!( + "Received: x={:.2} y={:.2} z={:.2} (interval {:.1}ms)", + vec.x, vec.y, vec.z, interval.as_secs_f64() * 1000.0 + ); + last = Instant::now(); + } + Err(e) => eprintln!("Decode error: {e}"), + } + } + Ok(_) => {} + Err(e) => eprintln!("Recv error: {e}"), + } + } +} diff --git a/tools/rust/lcm/src/lib.rs b/tools/rust/lcm/src/lib.rs new file mode 100644 index 0000000..cfe8015 --- /dev/null +++ b/tools/rust/lcm/src/lib.rs @@ -0,0 +1,27 @@ +//! Pure Rust LCM (Lightweight Communications and Marshalling) transport. +//! +//! Provides UDP multicast publish/subscribe for LCM messages. +//! No system LCM library required. +//! +//! # Example +//! +//! ```no_run +//! use dimos_lcm::Lcm; +//! +//! #[tokio::main] +//! async fn main() { +//! let mut lcm = Lcm::new().await.unwrap(); +//! +//! // Publish +//! let data = vec![1, 2, 3]; +//! lcm.publish("EXAMPLE", &data).await.unwrap(); +//! +//! // Receive +//! let msg = lcm.recv().await.unwrap(); +//! println!("{}: {} bytes", msg.channel, msg.data.len()); +//! } +//! ``` + +mod transport; + +pub use transport::{Lcm, LcmOptions, ReceivedMessage}; diff --git a/tools/rust/lcm/src/transport.rs b/tools/rust/lcm/src/transport.rs new file mode 100644 index 0000000..ef74aa9 --- /dev/null +++ b/tools/rust/lcm/src/transport.rs @@ -0,0 +1,362 @@ +use byteorder::{BigEndian, ByteOrder}; +use socket2::{Domain, Protocol, Socket, Type}; +use tokio::net::UdpSocket; +use std::collections::HashMap; +use std::io; +use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4}; +use std::sync::Mutex; +use std::sync::atomic::{AtomicU32, Ordering}; + +const MAGIC_SHORT: u32 = 0x4c433032; // "LC02" +const MAGIC_LONG: u32 = 0x4c433033; // "LC03" +const SHORT_HEADER_SIZE: usize = 8; +const FRAGMENT_HEADER_SIZE: usize = 20; +const MAX_DATAGRAM_SIZE: usize = 65507; + +/// Default LCM multicast group address. +pub const DEFAULT_MULTICAST_GROUP: Ipv4Addr = Ipv4Addr::new(239, 255, 76, 67); +/// Default LCM multicast port. +pub const DEFAULT_PORT: u16 = 7667; + +static SEQ: AtomicU32 = AtomicU32::new(0); + + +struct FragmentBuffer { + channel: String, + num_fragments: u16, + received: u16, + data: Vec, +} + +/// Configuration for an LCM transport instance. +#[derive(Debug, Clone)] +pub struct LcmOptions { + /// Multicast group address (default: 239.255.76.67). + pub multicast_group: Ipv4Addr, + /// UDP port (default: 7667). + pub port: u16, + /// Multicast TTL (default: 1). + pub ttl: u32, + /// Network interface to bind to (default: any). + pub interface: Ipv4Addr, +} + +impl Default for LcmOptions { + fn default() -> Self { + Self { + multicast_group: DEFAULT_MULTICAST_GROUP, + port: DEFAULT_PORT, + ttl: 1, + interface: Ipv4Addr::UNSPECIFIED, + } + } +} + +/// A received LCM message. +#[derive(Debug, Clone)] +pub struct ReceivedMessage { + /// Channel name. + pub channel: String, + /// Encoded message payload. + pub data: Vec, +} + +/// Returns the first and subsequent payload sizes, and the number of fragments +fn fragment_params(msg_size: usize, channel_len: usize) -> (usize, usize, usize) { + let first_payload_size = MAX_DATAGRAM_SIZE - FRAGMENT_HEADER_SIZE - channel_len - 1; + let subsequent_payload_size = MAX_DATAGRAM_SIZE - FRAGMENT_HEADER_SIZE; + let num_fragments = if msg_size <= first_payload_size { + 1 + } else { + 1 + msg_size.saturating_sub(first_payload_size).div_ceil(subsequent_payload_size) + }; + (first_payload_size, subsequent_payload_size, num_fragments) +} + +/// Pure Rust LCM UDP multicast transport. +pub struct Lcm { + socket: UdpSocket, + multicast_addr: SocketAddrV4, + reassembly: Mutex>, +} + +impl Lcm { + /// Create a new LCM transport with default options. + pub async fn new() -> io::Result { + Self::with_options(LcmOptions::default()).await + } + + /// Create a new LCM transport with custom options. + pub async fn with_options(opts: LcmOptions) -> io::Result { + let s2 = Socket::new(Domain::IPV4, Type::DGRAM, Some(Protocol::UDP))?; + s2.set_reuse_address(true)?; + #[cfg(not(target_os = "windows"))] + s2.set_reuse_port(true)?; + + let bind_addr = SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, opts.port); + s2.bind(&bind_addr.into())?; + + let std_socket: std::net::UdpSocket = s2.into(); + std_socket.set_nonblocking(true)?; + let socket = UdpSocket::from_std(std_socket)?; + + socket.join_multicast_v4(opts.multicast_group, opts.interface)?; + socket.set_multicast_ttl_v4(opts.ttl)?; + + Ok(Self { + socket, + multicast_addr: SocketAddrV4::new(opts.multicast_group, opts.port), + reassembly: Mutex::new(HashMap::new()), + }) + } + + /// Publish encoded message data on the given channel. + pub async fn publish(&self, channel: &str, data: &[u8]) -> io::Result<()> { + let channel_bytes = channel.as_bytes(); + let total = SHORT_HEADER_SIZE + channel_bytes.len() + 1 + data.len(); + let seqno = SEQ.fetch_add(1, Ordering::Relaxed); + + if total > MAX_DATAGRAM_SIZE { + self.publish_fragmented(channel_bytes, data, seqno).await + } else { + self.publish_small(channel_bytes, data, seqno).await + } + } + + async fn publish_small(&self, channel_bytes: &[u8], data: &[u8], seqno: u32) -> io::Result<()> { + let total = SHORT_HEADER_SIZE + channel_bytes.len() + 1 + data.len(); + let mut buf = vec![0u8; total]; + + BigEndian::write_u32(&mut buf[0..4], MAGIC_SHORT); + BigEndian::write_u32(&mut buf[4..8], seqno); + + buf[SHORT_HEADER_SIZE..SHORT_HEADER_SIZE + channel_bytes.len()] + .copy_from_slice(channel_bytes); + // null terminator already 0 from vec![0u8; ..] + let payload_start = SHORT_HEADER_SIZE + channel_bytes.len() + 1; + buf[payload_start..].copy_from_slice(data); + + self.socket.send_to(&buf, self.multicast_addr).await?; + Ok(()) + } + + async fn publish_fragmented(&self, channel_bytes: &[u8], data: &[u8], seqno: u32) -> io::Result<()> { + let msg_size = data.len(); + let (first_payload_size, subsequent_payload_size, num_fragments) = + fragment_params(msg_size, channel_bytes.len()); + + let mut payload_offset = 0; + + for fragment_no in 0..num_fragments { + let is_first = fragment_no == 0; + let channel_size = if is_first { channel_bytes.len() + 1 } else { 0 }; + let max_payload = if is_first { first_payload_size } else { subsequent_payload_size }; + let payload_len = (msg_size - payload_offset).min(max_payload); + + let datagram_size = FRAGMENT_HEADER_SIZE + channel_size + payload_len; + let mut buf = vec![0u8; datagram_size]; + + BigEndian::write_u32(&mut buf[0..4], MAGIC_LONG); + BigEndian::write_u32(&mut buf[4..8], seqno); + BigEndian::write_u32(&mut buf[8..12], msg_size as u32); + BigEndian::write_u32(&mut buf[12..16], payload_offset as u32); + BigEndian::write_u16(&mut buf[16..18], fragment_no as u16); + BigEndian::write_u16(&mut buf[18..20], num_fragments as u16); + + let mut offset = FRAGMENT_HEADER_SIZE; + + if is_first { + buf[offset..offset + channel_bytes.len()].copy_from_slice(channel_bytes); + // null terminator already 0 + offset += channel_bytes.len() + 1; + } + + buf[offset..offset + payload_len] + .copy_from_slice(&data[payload_offset..payload_offset + payload_len]); + + self.socket.send_to(&buf, self.multicast_addr).await?; + payload_offset += payload_len; + } + + Ok(()) + } + + /// Receive one LCM message asynchronously. + /// + /// Waits until a complete message arrives, reassembling fragments if necessary. + pub async fn recv(&self) -> io::Result { + let mut buf = vec![0u8; MAX_DATAGRAM_SIZE]; + loop { + let (n, sender) = self.socket.recv_from(&mut buf).await?; + let pkt = &buf[..n]; + + if pkt.len() < 4 { continue; } + let magic = BigEndian::read_u32(&pkt[0..4]); + + if magic == MAGIC_SHORT { + if let Some(msg) = Self::decode_small(pkt)? { + return Ok(msg); + } + } else if magic == MAGIC_LONG { + if let Some(msg) = self.process_fragment(sender, pkt)? { + return Ok(msg); + } + } + // Unknown magic or incomplete fragment — wait for the next datagram + } + } + + fn process_fragment(&self, sender: SocketAddr, buf: &[u8]) -> io::Result> { + if buf.len() < FRAGMENT_HEADER_SIZE { + return Ok(None); + } + + let seqno = BigEndian::read_u32(&buf[4..8]); + let total_size = BigEndian::read_u32(&buf[8..12]) as usize; + let fragment_offset = BigEndian::read_u32(&buf[12..16]) as usize; + let fragment_no = BigEndian::read_u16(&buf[16..18]); + let num_fragments = BigEndian::read_u16(&buf[18..20]); + + let mut offset = FRAGMENT_HEADER_SIZE; + + // First fragment carries the channel name + let channel = if fragment_no == 0 { + let channel_end = match buf[offset..].iter().position(|&b| b == 0) { + Some(pos) => offset + pos, + None => return Ok(None), + }; + let ch = String::from_utf8_lossy(&buf[offset..channel_end]).into_owned(); + offset = channel_end + 1; + Some(ch) + } else { + None + }; + + let payload = &buf[offset..]; + + let key = (sender, seqno); + + let mut reassembly = self.reassembly.lock().unwrap(); + let entry = reassembly.entry(key).or_insert_with(|| FragmentBuffer { + channel: channel.clone().unwrap_or_default(), + num_fragments, + received: 0, + data: vec![0u8; total_size], + }); + + // First fragment also sets the channel name on an existing entry + if let Some(ch) = channel { + entry.channel = ch; + } + + let end = (fragment_offset + payload.len()).min(total_size); + entry.data[fragment_offset..end].copy_from_slice(&payload[..end - fragment_offset]); + entry.received += 1; + + if entry.received == entry.num_fragments { + let complete = reassembly.remove(&key).unwrap(); + return Ok(Some(ReceivedMessage { + channel: complete.channel, + data: complete.data, + })); + } + + Ok(None) + } + + fn decode_small(buf: &[u8]) -> io::Result> { + if buf.len() < SHORT_HEADER_SIZE || BigEndian::read_u32(&buf[0..4]) != MAGIC_SHORT { + return Ok(None); + } + let channel_start = SHORT_HEADER_SIZE; + let channel_end = match buf[channel_start..].iter().position(|&b| b == 0) { + Some(pos) => channel_start + pos, + None => return Ok(None), + }; + let channel = String::from_utf8_lossy(&buf[channel_start..channel_end]).into_owned(); + let data = buf[channel_end + 1..].to_vec(); + Ok(Some(ReceivedMessage { channel, data })) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + const TEST_CHANNEL_LEN: usize = 13; // "/test_channel" + const FIRST_PAYLOAD: usize = MAX_DATAGRAM_SIZE - FRAGMENT_HEADER_SIZE - TEST_CHANNEL_LEN - 1; + const SUBSEQUENT_PAYLOAD: usize = MAX_DATAGRAM_SIZE - FRAGMENT_HEADER_SIZE; + + #[test] + fn fragment_count_fits_in_one() { + let (_, _, n) = fragment_params(FIRST_PAYLOAD, TEST_CHANNEL_LEN); + assert_eq!(n, 1); + } + + #[test] + fn fragment_count_spills_into_two() { + let (_, _, n) = fragment_params(FIRST_PAYLOAD + 1, TEST_CHANNEL_LEN); + assert_eq!(n, 2); + } + + #[test] + fn fragment_count_spills_into_three() { + let (_, _, n) = fragment_params(FIRST_PAYLOAD + SUBSEQUENT_PAYLOAD + 1, TEST_CHANNEL_LEN); + assert_eq!(n, 3); + } + + #[test] + fn fragment_count_one_mb() { + let (_, _, n) = fragment_params(1024 * 1024, TEST_CHANNEL_LEN); + assert_eq!(n, 17); + } + + fn make_small_packet(channel: &[u8], payload: &[u8]) -> Vec { + let mut buf = vec![0u8; SHORT_HEADER_SIZE + channel.len() + 1 + payload.len()]; + BigEndian::write_u32(&mut buf[0..4], MAGIC_SHORT); + BigEndian::write_u32(&mut buf[4..8], 0); + buf[SHORT_HEADER_SIZE..SHORT_HEADER_SIZE + channel.len()].copy_from_slice(channel); + buf[SHORT_HEADER_SIZE + channel.len() + 1..].copy_from_slice(payload); + buf + } + + #[test] + fn decode_small_known_good() { + let buf = make_small_packet(b"CHAN", &[1, 2, 3]); + let msg = Lcm::decode_small(&buf).unwrap().unwrap(); + assert_eq!(msg.channel, "CHAN"); + assert_eq!(msg.data, [1u8, 2, 3]); + } + + #[test] + fn decode_small_empty_payload() { + let buf = make_small_packet(b"CHAN", &[]); + let msg = Lcm::decode_small(&buf).unwrap().unwrap(); + assert_eq!(msg.channel, "CHAN"); + assert!(msg.data.is_empty()); + } + + #[test] + fn decode_small_wrong_magic() { + let mut buf = make_small_packet(b"CHAN", &[1, 2, 3]); + BigEndian::write_u32(&mut buf[0..4], 0xDEADBEEF); + assert!(Lcm::decode_small(&buf).unwrap().is_none()); + } + + #[test] + fn decode_small_truncated() { + // Shorter than SHORT_HEADER_SIZE + let buf = vec![0x4C, 0x43, 0x30, 0x32, 0x00]; + assert!(Lcm::decode_small(&buf).unwrap().is_none()); + } + + #[test] + fn decode_small_missing_null_terminator() { + // Valid header but channel bytes have no null terminator + let mut buf = vec![0u8; SHORT_HEADER_SIZE + 4]; + BigEndian::write_u32(&mut buf[0..4], MAGIC_SHORT); + BigEndian::write_u32(&mut buf[4..8], 0); + buf[SHORT_HEADER_SIZE..SHORT_HEADER_SIZE + 4].copy_from_slice(b"CHAN"); + assert!(Lcm::decode_small(&buf).unwrap().is_none()); + } +} diff --git a/tools/rust/lcm/tests/loopback.rs b/tools/rust/lcm/tests/loopback.rs new file mode 100644 index 0000000..081b0d8 --- /dev/null +++ b/tools/rust/lcm/tests/loopback.rs @@ -0,0 +1,136 @@ +use dimos_lcm::Lcm; +use tokio::time::Duration; + +const TIMEOUT: Duration = Duration::from_secs(2); + +async fn recv_channel(receiver: &mut Lcm, channel: &str) -> Vec { + loop { + let msg = receiver.recv().await.unwrap(); + if msg.channel == channel { + return msg.data; + } + } +} + +#[tokio::test] +async fn test_small_message_round_trip() { + let sender = Lcm::new().await.unwrap(); + let mut receiver = Lcm::new().await.unwrap(); + let payload = b"hello lcm transport".to_vec(); + let expected = payload.clone(); + + tokio::spawn(async move { + tokio::time::sleep(Duration::from_millis(10)).await; + sender.publish("SMALL_TRIP", &payload).await.unwrap(); + }); + + tokio::time::timeout(TIMEOUT, async { + assert_eq!(recv_channel(&mut receiver, "SMALL_TRIP").await, expected); + }) + .await + .expect("timed out waiting for SMALL_TRIP"); +} + +#[tokio::test] +async fn test_binary_payload_round_trip() { + let sender = Lcm::new().await.unwrap(); + let mut receiver = Lcm::new().await.unwrap(); + let payload: Vec = (0u8..=255).collect(); + let expected = payload.clone(); + + tokio::spawn(async move { + tokio::time::sleep(Duration::from_millis(10)).await; + sender.publish("BIN_TRIP", &payload).await.unwrap(); + }); + + tokio::time::timeout(TIMEOUT, async { + assert_eq!(recv_channel(&mut receiver, "BIN_TRIP").await, expected); + }) + .await + .expect("timed out waiting for BIN_TRIP"); +} + +#[tokio::test] +async fn test_publish_raw_bytes_and_receive() { + let sender = Lcm::new().await.unwrap(); + let mut receiver = Lcm::new().await.unwrap(); + + let raw = vec![0xDE, 0xAD, 0xBE, 0xEF, 0x01, 0x02, 0x03]; + let expected = raw.clone(); + + tokio::spawn(async move { + tokio::time::sleep(Duration::from_millis(10)).await; + sender.publish("RAW_TEST", &raw).await.unwrap(); + }); + + tokio::time::timeout(TIMEOUT, async { + assert_eq!(recv_channel(&mut receiver, "RAW_TEST").await, expected); + }) + .await + .expect("timed out waiting for RAW_TEST"); +} + +#[tokio::test] +async fn test_empty_payload_round_trip() { + let sender = Lcm::new().await.unwrap(); + let mut receiver = Lcm::new().await.unwrap(); + + tokio::spawn(async move { + tokio::time::sleep(Duration::from_millis(10)).await; + sender.publish("EMPTY_TEST", &[]).await.unwrap(); + }); + + tokio::time::timeout(TIMEOUT, async { + assert!(recv_channel(&mut receiver, "EMPTY_TEST").await.is_empty()); + }) + .await + .expect("timed out waiting for EMPTY_TEST"); +} + +#[tokio::test] +async fn test_multiple_sequential_messages() { + let sender = Lcm::new().await.unwrap(); + let mut receiver = Lcm::new().await.unwrap(); + + tokio::spawn(async move { + tokio::time::sleep(Duration::from_millis(10)).await; + for i in 0u8..5 { + sender.publish("MULTI_TEST", &[i]).await.unwrap(); + } + }); + + tokio::time::timeout(TIMEOUT, async { + let mut received = Vec::new(); + while received.len() < 5 { + let msg = receiver.recv().await.unwrap(); + if msg.channel == "MULTI_TEST" { + received.push(msg.data[0]); + } + } + assert_eq!(received, vec![0, 1, 2, 3, 4]); + }) + .await + .expect("timed out waiting for MULTI_TEST"); +} + +#[tokio::test] +async fn test_publish_and_receive_large_message() { + let sender = Lcm::new().await.unwrap(); + let mut receiver = Lcm::new().await.unwrap(); + + let large_message = vec![0x2Au8; 1024 * 1024]; + let expected = large_message.clone(); + + let handle = tokio::spawn(async move { + tokio::time::sleep(Duration::from_millis(10)).await; + sender.publish("LARGE_TEST", &large_message).await.unwrap(); + }); + + tokio::time::timeout(TIMEOUT, async { + assert_eq!(recv_channel(&mut receiver, "LARGE_TEST").await, expected); + }) + .await + .expect("timed out waiting for LARGE_TEST"); + + handle.await.unwrap(); +} diff --git a/tools/rust/lcm_rust_gen.py b/tools/rust/lcm_rust_gen.py new file mode 100644 index 0000000..0de15aa --- /dev/null +++ b/tools/rust/lcm_rust_gen.py @@ -0,0 +1,981 @@ +#!/usr/bin/env python3 +"""LCM Rust Code Generator. + +Parses .lcm files and generates Rust structs with encode/decode/hash +matching the LCM wire format used by the TypeScript and Python generators. +""" + +import argparse +import ctypes +import os +import re +import sys +from dataclasses import dataclass, field +from pathlib import Path + + +# ── AST ────────────────────────────────────────────────────────────────────── + +@dataclass +class LcmDimension: + size: str + is_constant: bool # True if numeric literal + + +@dataclass +class LcmMember: + type: str + name: str + dimensions: list[LcmDimension] = field(default_factory=list) + + +@dataclass +class LcmConstant: + type: str + name: str + value: str + + +@dataclass +class LcmStruct: + package: str + name: str + members: list[LcmMember] = field(default_factory=list) + constants: list[LcmConstant] = field(default_factory=list) + hash: int = 0 + + @property + def full_name(self): + return f"{self.package}.{self.name}" if self.package else self.name + + +@dataclass +class LcmFile: + package: str + structs: list[LcmStruct] = field(default_factory=list) + + +# ── Tokenizer ──────────────────────────────────────────────────────────────── + +TOKEN_RE = re.compile( + r'//[^\n]*|/\*[\s\S]*?\*\/|"[^"]*"|\'[^\']*\'|' + r'[a-zA-Z_][a-zA-Z0-9_]*|0x[0-9a-fA-F]+|' + r'[0-9]+\.?[0-9]*(?:[eE][+-]?[0-9]+)?|' + r'[{}\[\];,=.]' +) + + +class Tokenizer: + def __init__(self, source: str): + self.tokens: list[str] = [] + self.pos = 0 + for m in TOKEN_RE.finditer(source): + tok = m.group() + if tok.startswith("//") or tok.startswith("/*"): + continue + self.tokens.append(tok) + + def peek(self, offset=0): + idx = self.pos + offset + return self.tokens[idx] if idx < len(self.tokens) else None + + def next(self): + tok = self.tokens[self.pos] + self.pos += 1 + return tok + + def expect(self, expected): + tok = self.next() + if tok != expected: + raise SyntaxError(f"Expected '{expected}', got '{tok}'") + + def has_more(self): + return self.pos < len(self.tokens) + + +# ── Parser ─────────────────────────────────────────────────────────────────── + +def parse_qualified_name(tok: Tokenizer) -> str: + name = tok.next() + while tok.peek() == ".": + tok.next() + name += "." + tok.next() + return name + + +def parse_member(tok: Tokenizer) -> LcmMember: + type_name = parse_qualified_name(tok) + name = tok.next() + dims = [] + while tok.peek() == "[": + tok.next() + size = tok.next() + tok.expect("]") + dims.append(LcmDimension(size=size, is_constant=size.isdigit())) + tok.expect(";") + return LcmMember(type=type_name, name=name, dimensions=dims) + + +def parse_constants(tok: Tokenizer) -> list[LcmConstant]: + ctype = tok.next() + constants = [] + while True: + name = tok.next() + tok.expect("=") + value = tok.next() + if value == "-": + value = "-" + tok.next() + constants.append(LcmConstant(type=ctype, name=name, value=value)) + if tok.peek() != ",": + break + tok.next() + tok.expect(";") + return constants + + +def parse_struct(tok: Tokenizer, package: str) -> LcmStruct: + name = tok.next() + tok.expect("{") + members = [] + constants = [] + while tok.peek() != "}": + if tok.peek() == "const": + tok.next() + constants.extend(parse_constants(tok)) + else: + members.append(parse_member(tok)) + tok.expect("}") + return LcmStruct(package=package, name=name, members=members, constants=constants) + + +def parse_file(path: str) -> LcmFile: + source = Path(path).read_text() + tok = Tokenizer(source) + package = "" + structs = [] + while tok.has_more(): + token = tok.next() + if token == "package": + package = tok.next() + tok.expect(";") + elif token == "struct": + structs.append(parse_struct(tok, package)) + elif token == "enum": + # No enums in current LCM files, skip + parse_struct(tok, package) + else: + raise SyntaxError(f"Unexpected token: {token}") + + for s in structs: + s.hash = compute_struct_hash(s) + + return LcmFile(package=package, structs=structs) + + +# ── Hash Algorithm ─────────────────────────────────────────────────────────── +# Must match parser.ts lines 58-116 using signed i64 arithmetic. + +LCM_PRIMITIVES = { + "int8_t", "int16_t", "int32_t", "int64_t", + "float", "double", "string", "boolean", "byte", +} + + +def is_primitive(t: str) -> bool: + return t in LCM_PRIMITIVES + + +def hash_update(v: int, c: int) -> int: + """hash_update: v = ((v << 8) ^ (v >> 55)) + c + Using signed i64 arithmetic (arithmetic right shift).""" + # Work in signed i64 via ctypes + v = ctypes.c_int64(v).value + left = (v << 8) & 0xFFFFFFFFFFFFFFFF + # Arithmetic right shift (Python >> on signed int is arithmetic) + right = ctypes.c_int64(v).value >> 55 + result = ((left ^ right) + c) & 0xFFFFFFFFFFFFFFFF + return result + + +def hash_string_update(v: int, s: str) -> int: + v = hash_update(v, len(s)) + for ch in s: + v = hash_update(v, ord(ch)) + return v + + +def compute_struct_hash(struct: LcmStruct) -> int: + v = 0x12345678 + for member in struct.members: + v = hash_string_update(v, member.name) + if is_primitive(member.type): + v = hash_string_update(v, member.type) + ndim = len(member.dimensions) + v = hash_update(v, ndim) + for dim in member.dimensions: + mode = 0 if dim.is_constant else 1 + v = hash_update(v, mode) + v = hash_string_update(v, dim.size) + return v + + +# ── Rust Code Generation ──────────────────────────────────────────────────── + +RUST_KEYWORDS = { + "as", "async", "await", "break", "const", "continue", "crate", "dyn", + "else", "enum", "extern", "false", "fn", "for", "if", "impl", "in", + "let", "loop", "match", "mod", "move", "mut", "pub", "ref", "return", + "self", "Self", "static", "struct", "super", "trait", "true", "type", + "unsafe", "use", "where", "while", "yield", "box", +} + + +def rust_field_name(name: str) -> str: + """Escape Rust keywords with r# prefix.""" + if name in RUST_KEYWORDS: + return f"r#{name}" + return name + + +def to_snake_case(name: str) -> str: + """Convert CamelCase to snake_case.""" + s1 = re.sub(r'([A-Z]+)([A-Z][a-z])', r'\1_\2', name) + s2 = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', s1) + return s2.lower() + + +def rust_type(lcm_type: str) -> str: + """Map LCM primitive type to Rust type.""" + mapping = { + "int8_t": "i8", + "int16_t": "i16", + "int32_t": "i32", + "int64_t": "i64", + "float": "f32", + "double": "f64", + "string": "std::string::String", + "boolean": "bool", + "byte": "u8", + } + return mapping.get(lcm_type, lcm_type) + + +def rust_const_type(lcm_type: str) -> str: + """Map LCM type to Rust type for constants.""" + mapping = { + "int8_t": "i8", + "int16_t": "i16", + "int32_t": "i32", + "int64_t": "i64", + "float": "f32", + "double": "f64", + "byte": "u8", + } + return mapping.get(lcm_type, lcm_type) + + +def primitive_size(lcm_type: str) -> int: + sizes = { + "int8_t": 1, "byte": 1, "boolean": 1, + "int16_t": 2, + "int32_t": 4, "float": 4, + "int64_t": 8, "double": 8, + } + return sizes.get(lcm_type, 0) + + +def struct_ref_type(member_type: str, current_pkg: str) -> str: + """Generate fully qualified Rust type path for a struct reference.""" + if "." in member_type: + pkg, name = member_type.rsplit(".", 1) + return f"crate::{pkg}::{name}" + else: + # Same package + return f"crate::{current_pkg}::{member_type}" + + +def member_rust_type(member: LcmMember, current_pkg: str) -> str: + """Get the full Rust type for a member including dimensions.""" + if is_primitive(member.type): + base = rust_type(member.type) + else: + base = struct_ref_type(member.type, current_pkg) + + if not member.dimensions: + return base + + # Build type from innermost outward + result = base + for dim in reversed(member.dimensions): + if dim.is_constant: + result = f"[{result}; {dim.size}]" + else: + result = f"Vec<{result}>" + return result + + +def find_length_fields(struct: LcmStruct) -> set[str]: + """Find member names that serve as length fields for variable-length arrays. + These should be suppressed from the Rust struct.""" + length_fields = set() + for member in struct.members: + for dim in member.dimensions: + if not dim.is_constant: + length_fields.add(dim.size) + return length_fields + + +def needs_manual_default(struct: LcmStruct, length_fields: set[str]) -> bool: + """Check if struct needs a manual Default impl (arrays > 32 elements).""" + for member in struct.members: + if member.name in length_fields: + continue + for dim in member.dimensions: + if dim.is_constant and int(dim.size) > 32: + return True + return False + + +# ── Code Generation Functions ──────────────────────────────────────────────── + +def gen_struct(struct: LcmStruct, all_structs: dict[str, LcmStruct]) -> str: + """Generate complete Rust code for one LCM struct.""" + lines = [] + length_fields = find_length_fields(struct) + manual_default = needs_manual_default(struct, length_fields) + + # Collect non-primitive dependencies for use statements + deps = set() + for member in struct.members: + if not is_primitive(member.type) and member.name not in length_fields: + deps.add(struct_ref_type(member.type, struct.package)) + + lines.append("// Auto-generated by lcm-rust-gen. DO NOT EDIT.") + lines.append("") + lines.append("use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};") + lines.append("use std::io::{self, Read, Write, Cursor};") + lines.append("use std::sync::OnceLock;") + lines.append("") + + # Derive list + if manual_default: + derives = "#[derive(Debug, Clone, PartialEq)]" + else: + derives = "#[derive(Debug, Clone, Default, PartialEq)]" + + lines.append(derives) + lines.append(f"pub struct {struct.name} {{") + + # Constants as associated consts go in impl, members as fields + for member in struct.members: + if member.name in length_fields: + continue + field_type = member_rust_type(member, struct.package) + fname = rust_field_name(member.name) + lines.append(f" pub {fname}: {field_type},") + lines.append("}") + lines.append("") + + # Manual Default impl if needed + if manual_default: + lines.append(f"impl Default for {struct.name} {{") + lines.append(" fn default() -> Self {") + lines.append(" Self {") + for member in struct.members: + if member.name in length_fields: + continue + fname = rust_field_name(member.name) + default_val = gen_default_value(member, struct.package) + lines.append(f" {fname}: {default_val},") + lines.append(" }") + lines.append(" }") + lines.append("}") + lines.append("") + + # impl block + lines.append(f"impl {struct.name} {{") + + # Base hash constant + lines.append(f" pub const HASH: i64 = 0x{struct.hash:016X}u64 as i64;") + lines.append(f' pub const NAME: &str = "{struct.full_name}";') + lines.append("") + + # Constants + for const in struct.constants: + ct = rust_const_type(const.type) + val = const.value + cname = const.name + lines.append(f" pub const {cname}: {ct} = {val};") + if struct.constants: + lines.append("") + + # Fingerprint cache + lines.append(" fn packed_fingerprint() -> u64 {") + lines.append(" static CACHE: OnceLock = OnceLock::new();") + lines.append(f" *CACHE.get_or_init(|| Self::hash_recursive(&mut Vec::new()))") + lines.append(" }") + lines.append("") + + # hash_recursive + gen_hash_recursive(lines, struct, all_structs) + + # encode + gen_encode(lines, struct, length_fields) + + # decode + gen_decode(lines, struct, length_fields, all_structs) + + # encode_one / decode_one + gen_encode_one(lines, struct, length_fields, all_structs) + gen_decode_one(lines, struct, length_fields, all_structs) + + # encoded_size + gen_encoded_size(lines, struct, length_fields, all_structs) + + lines.append("}") + lines.append("") + return "\n".join(lines) + + +def gen_default_value(member: LcmMember, current_pkg: str) -> str: + """Generate default value for a member.""" + if not member.dimensions: + if is_primitive(member.type): + if member.type == "string": + return "std::string::String::new()" + elif member.type == "boolean": + return "false" + else: + return f"0{rust_type(member.type).replace('u8', '')}" if member.type == "byte" else "0" + else: + ref_type = struct_ref_type(member.type, current_pkg) + return f"{ref_type}::default()" + + # Check for variable-length (Vec) + has_variable = any(not d.is_constant for d in member.dimensions) + if has_variable: + return "Vec::new()" + + # Fixed-size array + return gen_fixed_array_default(member, current_pkg, 0) + + +def gen_fixed_array_default(member: LcmMember, current_pkg: str, dim_idx: int) -> str: + if dim_idx >= len(member.dimensions): + if is_primitive(member.type): + if member.type == "string": + return "std::string::String::new()" + elif member.type == "boolean": + return "false" + else: + t = rust_type(member.type) + return f"0{t}" if t != "u8" else "0u8" + else: + ref_type = struct_ref_type(member.type, current_pkg) + return f"{ref_type}::default()" + + dim = member.dimensions[dim_idx] + size = int(dim.size) + inner = gen_fixed_array_default(member, current_pkg, dim_idx + 1) + + if size > 32: + # Can't use [val; N] for non-Copy types, but primitives are Copy + return f"[{inner}; {size}]" + else: + return f"[{inner}; {size}]" + + +def gen_hash_recursive(lines: list[str], struct: LcmStruct, all_structs: dict[str, LcmStruct]): + """Generate _get_hash_recursive equivalent.""" + length_fields = find_length_fields(struct) + + # Collect nested (non-primitive) types used in members + nested_types = [] + for member in struct.members: + if member.name in length_fields: + continue + if not is_primitive(member.type): + nested_types.append(struct_ref_type(member.type, struct.package)) + + lines.append(" pub(crate) fn hash_recursive(parents: &mut Vec) -> u64 {") + lines.append(" let self_hash = Self::HASH as u64;") + lines.append(" if parents.contains(&self_hash) {") + lines.append(" return 0;") + lines.append(" }") + lines.append(" parents.push(self_hash);") + + if nested_types: + lines.append(" let mut tmphash = self_hash as u64;") + for nt in nested_types: + lines.append(f" tmphash = tmphash.wrapping_add({nt}::hash_recursive(parents));") + else: + lines.append(" let tmphash = self_hash as u64;") + + lines.append(" parents.pop();") + lines.append(" // rotate left by 1") + lines.append(" tmphash << 1 | tmphash >> 63") + lines.append(" }") + lines.append("") + + +def gen_encode(lines: list[str], struct: LcmStruct, length_fields: set[str]): + lines.append(" pub fn encode(&self) -> Vec {") + lines.append(" let mut buf = Vec::with_capacity(8 + self.encoded_size());") + lines.append(" buf.write_u64::(Self::packed_fingerprint()).unwrap();") + lines.append(" self.encode_one(&mut buf).unwrap();") + lines.append(" buf") + lines.append(" }") + lines.append("") + + +def gen_decode(lines: list[str], struct: LcmStruct, length_fields: set[str], + all_structs: dict[str, LcmStruct]): + lines.append(" pub fn decode(data: &[u8]) -> io::Result {") + lines.append(" let mut cursor = Cursor::new(data);") + lines.append(" let hash = cursor.read_u64::()?;") + lines.append(" let expected = Self::packed_fingerprint();") + lines.append(" if hash != expected {") + lines.append(' return Err(io::Error::new(io::ErrorKind::InvalidData,') + lines.append(' format!("Hash mismatch: expected {:016x}, got {:016x}", expected, hash)));') + lines.append(" }") + lines.append(" Self::decode_one(&mut cursor)") + lines.append(" }") + lines.append("") + + +def gen_encode_one(lines: list[str], struct: LcmStruct, length_fields: set[str], + all_structs: dict[str, LcmStruct]): + real_members = [m for m in struct.members if m.name not in length_fields] + has_members = bool(struct.members) + buf_name = "buf" if has_members else "_buf" + lines.append(f" pub fn encode_one(&self, {buf_name}: &mut W) -> io::Result<()> {{") + for member in struct.members: + if member.name in length_fields: + # Write the length from the corresponding Vec + vec_member = find_vec_for_length(struct, member.name) + if vec_member: + fname = rust_field_name(vec_member.name) + lines.append(f" buf.write_i32::(self.{fname}.len() as i32)?;") + continue + gen_encode_member(lines, member, struct.package, "self.", 2) + lines.append(" Ok(())") + lines.append(" }") + lines.append("") + + +def find_vec_for_length(struct: LcmStruct, length_field_name: str) -> LcmMember | None: + """Find the member whose variable-length dimension references this length field.""" + for member in struct.members: + for dim in member.dimensions: + if not dim.is_constant and dim.size == length_field_name: + return member + return None + + +def gen_encode_member(lines: list[str], member: LcmMember, pkg: str, prefix: str, indent: int): + """Generate encode code for a single member.""" + ind = " " * indent + fname = rust_field_name(member.name) + accessor = f"{prefix}{fname}" + + if not member.dimensions: + # Scalar + gen_encode_primitive(lines, member.type, accessor, pkg, indent) + else: + gen_encode_array(lines, member, pkg, accessor, indent, 0) + + +def gen_encode_primitive(lines: list[str], lcm_type: str, source: str, pkg: str, indent: int): + ind = " " * indent + if lcm_type == "int8_t": + lines.append(f"{ind}buf.write_i8({source})?;") + elif lcm_type == "byte": + lines.append(f"{ind}buf.write_u8({source})?;") + elif lcm_type == "boolean": + lines.append(f"{ind}buf.write_i8(if {source} {{ 1 }} else {{ 0 }})?;") + elif lcm_type == "int16_t": + lines.append(f"{ind}buf.write_i16::({source})?;") + elif lcm_type == "int32_t": + lines.append(f"{ind}buf.write_i32::({source})?;") + elif lcm_type == "int64_t": + lines.append(f"{ind}buf.write_i64::({source})?;") + elif lcm_type == "float": + lines.append(f"{ind}buf.write_f32::({source})?;") + elif lcm_type == "double": + lines.append(f"{ind}buf.write_f64::({source})?;") + elif lcm_type == "string": + lines.append(f"{ind}{{") + lines.append(f"{ind} let bytes = {source}.as_bytes();") + lines.append(f"{ind} buf.write_u32::((bytes.len() + 1) as u32)?;") + lines.append(f"{ind} buf.write_all(bytes)?;") + lines.append(f"{ind} buf.write_u8(0)?;") + lines.append(f"{ind}}}") + else: + # Nested struct + lines.append(f"{ind}{source}.encode_one(buf)?;") + + +def gen_encode_array(lines: list[str], member: LcmMember, pkg: str, + source: str, indent: int, dim_idx: int): + ind = " " * indent + dim = member.dimensions[dim_idx] + is_last = dim_idx == len(member.dimensions) - 1 + loop_var = f"v{dim_idx}" + + if member.type == "byte" and is_last: + # Byte array — write all at once + if dim.is_constant: + lines.append(f"{ind}buf.write_all(&{source})?;") + else: + lines.append(f"{ind}buf.write_all(&{source})?;") + return + + lines.append(f"{ind}for {loop_var} in {source}.iter() {{") + if is_last: + # Use *v to deref + deref = f"*{loop_var}" + if is_primitive(member.type) and member.type != "string": + gen_encode_primitive(lines, member.type, deref, pkg, indent + 1) + elif member.type == "string": + gen_encode_primitive(lines, member.type, loop_var, pkg, indent + 1) + else: + gen_encode_primitive(lines, member.type, loop_var, pkg, indent + 1) + else: + gen_encode_array(lines, member, pkg, loop_var, indent + 1, dim_idx + 1) + lines.append(f"{ind}}}") + + +def gen_decode_one(lines: list[str], struct: LcmStruct, length_fields: set[str], + all_structs: dict[str, LcmStruct]): + has_members = bool(struct.members) + buf_name = "buf" if has_members else "_buf" + lines.append(f" pub fn decode_one({buf_name}: &mut R) -> io::Result {{") + + # First, read length fields into local vars + # We need to handle the order correctly — members are in wire order + for member in struct.members: + if member.name in length_fields: + lines.append(f" let {member.name} = buf.read_i32::()? as usize;") + else: + fname = rust_field_name(member.name) + gen_decode_member(lines, member, struct.package, fname, 2, length_fields) + + # Construct result + lines.append(f" Ok(Self {{") + for member in struct.members: + if member.name in length_fields: + continue + fname = rust_field_name(member.name) + lines.append(f" {fname},") + lines.append(f" }})") + lines.append(" }") + lines.append("") + + +def gen_decode_member(lines: list[str], member: LcmMember, pkg: str, var_name: str, + indent: int, length_fields: set[str]): + ind = " " * indent + + if not member.dimensions: + gen_decode_primitive(lines, member.type, var_name, pkg, indent) + else: + gen_decode_array(lines, member, pkg, var_name, indent, 0, length_fields) + + +def gen_decode_primitive(lines: list[str], lcm_type: str, var_name: str, pkg: str, indent: int): + ind = " " * indent + if lcm_type == "int8_t": + lines.append(f"{ind}let {var_name} = buf.read_i8()?;") + elif lcm_type == "byte": + lines.append(f"{ind}let {var_name} = buf.read_u8()?;") + elif lcm_type == "boolean": + lines.append(f"{ind}let {var_name} = buf.read_i8()? != 0;") + elif lcm_type == "int16_t": + lines.append(f"{ind}let {var_name} = buf.read_i16::()?;") + elif lcm_type == "int32_t": + lines.append(f"{ind}let {var_name} = buf.read_i32::()?;") + elif lcm_type == "int64_t": + lines.append(f"{ind}let {var_name} = buf.read_i64::()?;") + elif lcm_type == "float": + lines.append(f"{ind}let {var_name} = buf.read_f32::()?;") + elif lcm_type == "double": + lines.append(f"{ind}let {var_name} = buf.read_f64::()?;") + elif lcm_type == "string": + lines.append(f"{ind}let {var_name} = {{") + lines.append(f"{ind} let len = buf.read_u32::()? as usize;") + lines.append(f"{ind} let mut bytes = vec![0u8; len];") + lines.append(f"{ind} buf.read_exact(&mut bytes)?;") + lines.append(f"{ind} std::string::String::from_utf8(bytes[..len - 1].to_vec())") + lines.append(f"{ind} .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?") + lines.append(f"{ind}}};") + else: + # Nested struct + ref_type = struct_ref_type(lcm_type, pkg) + lines.append(f"{ind}let {var_name} = {ref_type}::decode_one(buf)?;") + + +def gen_decode_array(lines: list[str], member: LcmMember, pkg: str, var_name: str, + indent: int, dim_idx: int, length_fields: set[str]): + ind = " " * indent + dim = member.dimensions[dim_idx] + is_last = dim_idx == len(member.dimensions) - 1 + + if dim.is_constant: + size = dim.size + else: + size = dim.size # This is the name of the length field (local variable) + + if member.type == "byte" and is_last: + # Byte array — read all at once + if dim.is_constant: + lines.append(f"{ind}let {var_name} = {{") + lines.append(f"{ind} let mut arr = [0u8; {size}];") + lines.append(f"{ind} buf.read_exact(&mut arr)?;") + lines.append(f"{ind} arr") + lines.append(f"{ind}}};") + else: + lines.append(f"{ind}let {var_name} = {{") + lines.append(f"{ind} let mut v = vec![0u8; {size}];") + lines.append(f"{ind} buf.read_exact(&mut v)?;") + lines.append(f"{ind} v") + lines.append(f"{ind}}};") + return + + if dim.is_constant: + # Fixed-size array — use array initialization + int_size = int(size) + lines.append(f"{ind}let {var_name} = {{") + inner_var = f"_arr_{dim_idx}" + + if is_last and is_primitive(member.type) and member.type != "string": + # Read each element for fixed-size primitive array + rt = rust_type(member.type) + lines.append(f"{ind} let mut {inner_var} = [{gen_primitive_zero(member.type)}; {size}];") + lines.append(f"{ind} for elem in {inner_var}.iter_mut() {{") + gen_decode_primitive_assign(lines, member.type, "elem", indent + 2) + lines.append(f"{ind} }}") + lines.append(f"{ind} {inner_var}") + elif is_last: + # Non-primitive or string array + lines.append(f"{ind} let mut {inner_var} = Vec::with_capacity({size});") + lines.append(f"{ind} for _ in 0..{size} {{") + elem_var = f"_elem_{dim_idx}" + gen_decode_primitive(lines, member.type, elem_var, pkg, indent + 2) + lines.append(f"{ind} {inner_var}.push({elem_var});") + lines.append(f"{ind} }}") + # Convert Vec to array — use try_into for correctness + lines.append(f"{ind} <[_; {size}]>::try_from({inner_var}).unwrap()") + else: + # Multi-dimensional — recurse + lines.append(f"{ind} let mut {inner_var} = Vec::with_capacity({size});") + lines.append(f"{ind} for _ in 0..{size} {{") + elem_var = f"_elem_{dim_idx}" + gen_decode_array(lines, member, pkg, elem_var, indent + 2, dim_idx + 1, length_fields) + lines.append(f"{ind} {inner_var}.push({elem_var});") + lines.append(f"{ind} }}") + lines.append(f"{ind} <[_; {size}]>::try_from({inner_var}).unwrap()") + lines.append(f"{ind}}};") + else: + # Variable-size — Vec + lines.append(f"{ind}let {var_name} = {{") + lines.append(f"{ind} let mut v = Vec::with_capacity({size});") + lines.append(f"{ind} for _ in 0..{size} {{") + if is_last: + elem_var = f"_elem_{dim_idx}" + gen_decode_primitive(lines, member.type, elem_var, pkg, indent + 2) + lines.append(f"{ind} v.push({elem_var});") + else: + elem_var = f"_elem_{dim_idx}" + gen_decode_array(lines, member, pkg, elem_var, indent + 2, dim_idx + 1, length_fields) + lines.append(f"{ind} v.push({elem_var});") + lines.append(f"{ind} }}") + lines.append(f"{ind} v") + lines.append(f"{ind}}};") + + +def gen_decode_primitive_assign(lines: list[str], lcm_type: str, target: str, indent: int): + """Decode a primitive and assign to an existing mutable variable.""" + ind = " " * indent + if lcm_type == "int8_t": + lines.append(f"{ind}*{target} = buf.read_i8()?;") + elif lcm_type == "byte": + lines.append(f"{ind}*{target} = buf.read_u8()?;") + elif lcm_type == "boolean": + lines.append(f"{ind}*{target} = buf.read_i8()? != 0;") + elif lcm_type == "int16_t": + lines.append(f"{ind}*{target} = buf.read_i16::()?;") + elif lcm_type == "int32_t": + lines.append(f"{ind}*{target} = buf.read_i32::()?;") + elif lcm_type == "int64_t": + lines.append(f"{ind}*{target} = buf.read_i64::()?;") + elif lcm_type == "float": + lines.append(f"{ind}*{target} = buf.read_f32::()?;") + elif lcm_type == "double": + lines.append(f"{ind}*{target} = buf.read_f64::()?;") + + +def gen_primitive_zero(lcm_type: str) -> str: + mapping = { + "int8_t": "0i8", "int16_t": "0i16", "int32_t": "0i32", + "int64_t": "0i64", "float": "0.0f32", "double": "0.0f64", + "byte": "0u8", "boolean": "false", + } + return mapping.get(lcm_type, "Default::default()") + + +def gen_encoded_size(lines: list[str], struct: LcmStruct, length_fields: set[str], + all_structs: dict[str, LcmStruct]): + lines.append(" pub fn encoded_size(&self) -> usize {") + has_members = bool(struct.members) + if has_members: + lines.append(" let mut size = 0usize;") + + for member in struct.members: + if member.name in length_fields: + # Length field itself is i32 = 4 bytes + lines.append(" size += 4;") + continue + gen_encoded_size_member(lines, member, struct.package, "self.", 2) + + if has_members: + lines.append(" size") + else: + lines.append(" 0") + lines.append(" }") + lines.append("") + + +def gen_encoded_size_member(lines: list[str], member: LcmMember, pkg: str, prefix: str, indent: int): + ind = " " * indent + fname = rust_field_name(member.name) + accessor = f"{prefix}{fname}" + + if not member.dimensions: + if is_primitive(member.type): + if member.type == "string": + lines.append(f"{ind}size += 4 + {accessor}.len() + 1;") + else: + lines.append(f"{ind}size += {primitive_size(member.type)};") + else: + lines.append(f"{ind}size += {accessor}.encoded_size();") + else: + gen_encoded_size_array(lines, member, pkg, accessor, indent, 0) + + +def gen_encoded_size_array(lines: list[str], member: LcmMember, pkg: str, + source: str, indent: int, dim_idx: int): + ind = " " * indent + dim = member.dimensions[dim_idx] + is_last = dim_idx == len(member.dimensions) - 1 + + if is_last: + if is_primitive(member.type): + if member.type == "string": + loop_var = f"s{dim_idx}" + lines.append(f"{ind}for {loop_var} in {source}.iter() {{") + lines.append(f"{ind} size += 4 + {loop_var}.len() + 1;") + lines.append(f"{ind}}}") + elif member.type == "byte": + lines.append(f"{ind}size += {source}.len();") + else: + lines.append(f"{ind}size += {source}.len() * {primitive_size(member.type)};") + else: + loop_var = f"v{dim_idx}" + lines.append(f"{ind}for {loop_var} in {source}.iter() {{") + lines.append(f"{ind} size += {loop_var}.encoded_size();") + lines.append(f"{ind}}}") + else: + loop_var = f"v{dim_idx}" + lines.append(f"{ind}for {loop_var} in {source}.iter() {{") + gen_encoded_size_array(lines, member, pkg, loop_var, indent + 1, dim_idx + 1) + lines.append(f"{ind}}}") + + +# ── Crate Generation ───────────────────────────────────────────────────────── + +def generate_crate(lcm_dir: str, out_dir: str): + """Parse all .lcm files and generate a complete Rust crate.""" + lcm_files = sorted(Path(lcm_dir).glob("*.lcm")) + if not lcm_files: + print(f"No .lcm files found in {lcm_dir}", file=sys.stderr) + sys.exit(1) + + # Parse all files + parsed: list[LcmFile] = [] + all_structs: dict[str, LcmStruct] = {} + for path in lcm_files: + f = parse_file(str(path)) + parsed.append(f) + for s in f.structs: + all_structs[s.full_name] = s + + # Group by package + packages: dict[str, list[LcmStruct]] = {} + for f in parsed: + for s in f.structs: + packages.setdefault(s.package, []).append(s) + + # Create output structure + src_dir = Path(out_dir) / "src" + src_dir.mkdir(parents=True, exist_ok=True) + + # Generate Cargo.toml + cargo_toml = Path(out_dir) / "Cargo.toml" + cargo_toml.write_text( + '[package]\n' + 'name = "lcm-msgs"\n' + 'version = "0.1.0"\n' + 'edition = "2021"\n' + 'description = "Auto-generated LCM message types for Rust"\n' + '\n' + '[dependencies]\n' + 'byteorder = "1"\n' + ) + + # Generate per-package modules + for pkg, structs in sorted(packages.items()): + pkg_dir = src_dir / pkg + pkg_dir.mkdir(parents=True, exist_ok=True) + + # Generate each struct file + type_names = [] + for s in sorted(structs, key=lambda s: s.name): + snake_name = to_snake_case(s.name) + type_names.append((snake_name, s.name)) + file_path = pkg_dir / f"{snake_name}.rs" + code = gen_struct(s, all_structs) + file_path.write_text(code) + + # Generate package mod.rs + mod_lines = ["// Auto-generated by lcm-rust-gen. DO NOT EDIT.", ""] + for snake_name, struct_name in sorted(type_names): + mod_lines.append(f"mod {snake_name};") + mod_lines.append(f"pub use {snake_name}::{struct_name};") + mod_lines.append("") + (pkg_dir / "mod.rs").write_text("\n".join(mod_lines)) + + # Generate src/lib.rs + lib_lines = [ + "// Auto-generated by lcm-rust-gen. DO NOT EDIT.", + "#![allow(non_snake_case)]", + "", + ] + for pkg in sorted(packages.keys()): + lib_lines.append(f"pub mod {pkg};") + lib_lines.append("") + (src_dir / "lib.rs").write_text("\n".join(lib_lines)) + + print(f"Generated {sum(len(v) for v in packages.values())} types " + f"in {len(packages)} packages") + + +def main(): + parser = argparse.ArgumentParser(description="LCM Rust Code Generator") + parser.add_argument("lcm_dir", help="Directory containing .lcm files") + parser.add_argument("-o", "--output", required=True, help="Output crate directory") + args = parser.parse_args() + generate_crate(args.lcm_dir, args.output) + + +if __name__ == "__main__": + main()