Struct ros_message::Msg

pub struct Msg { /* private fields */ }

A ROS message parsed from a msg file.

Implementations

impl Msg

pub fn new(path: MessagePath, source: &str) -> Result<Msg>

Create a message from a passed in path and source.

Errors

Returns an error if there is an error parsing the message source.

Examples

let message = Msg::new(
    "foo/Bar".try_into()?,
    r#"# a comment that is ignored
    Header header
    uint32 a
    byte[16] b
    geometry_msgs/Point[] point
    uint32 FOO=5
    string SOME_TEXT=this is # some text, don't be fooled by the hash
    "#,
)?;

assert_eq!(message.path(), &"foo/Bar".try_into()?);
assert_eq!(message.fields().len(), 6);

pub fn constants(&self) -> HashMap<String, Value>

Returns a map of all constant fields inside the message, with their values parsed.

Examples

let message = Msg::new(
    "foo/Bar".try_into()?,
    r#"# a comment that is ignored
    Header header
    uint32 a
    byte[16] b
    geometry_msgs/Point[] point
    uint32 FOO=5
    string SOME_TEXT=this is # some text, don't be fooled by the hash
    "#,
)?;

let constants = message.constants();

assert_eq!(constants.len(), 2);
assert_eq!(constants.get("FOO"), Some(&Value::U32(5)));
assert_eq!(
    constants.get("SOME_TEXT"),
    Some(&Value::String("this is # some text, don't be fooled by the hash".into())),
);

pub fn path(&self) -> &MessagePath

Returns the path of the message.

pub fn fields(&self) -> &[FieldInfo]

Returns a slice of all fields.

pub fn source(&self) -> &str

Returns the original source.

pub fn dependencies(&self) -> Vec<MessagePath>

Returns a all message paths that this message directly depends upon.

They are listed in the order that they appear in in the message, and duplicates are allowed.

Indirect dependencies are not included, and if you want an exhaustive list of all dependencies, you have to manually traverse every message being depended upon.

Examples

let message = Msg::new(
    "foo/Bar".try_into()?,
    r#"
    Header header
    geometry_msgs/Point[] point1
    Point[] point2
    foo/Point[] point2_but_with_global_path
    foo/Baz[] baz
    "#,
)?;

let dependencies = message.dependencies();

assert_eq!(dependencies, vec![
    "std_msgs/Header".try_into()?,
    "geometry_msgs/Point".try_into()?,
    "foo/Point".try_into()?,
    "foo/Point".try_into()?,
    "foo/Baz".try_into()?,
]);

pub fn get_md5_representation( &self, hashes: &HashMap<MessagePath, String>, ) -> Result<String>

Returns the full MD5 representation of the message.

This is the string that is sent to the MD5 hasher to digest.

Errors

An error is returned if some dependency is missing in the hashes.

Examples

let message = Msg::new(
    "foo/Bar".try_into()?,
    r#"# a comment that is ignored
    Header header
    uint32 a
    byte[16] b
    geometry_msgs/Point[] point
    Baz baz
    uint32 FOO=5
    string SOME_TEXT=this is # some text, don't be fooled by the hash
    "#,
)?;

let mut hashes = HashMap::new();
hashes.insert("std_msgs/Header".try_into()?, "hash1".into());
hashes.insert("geometry_msgs/Point".try_into()?, "hash2".into());
hashes.insert("foo/Baz".try_into()?, "hash3".into());

let representation = message.get_md5_representation(&hashes)?;

assert_eq!(
    representation,
r#"uint32 FOO=5
string SOME_TEXT=this is # some text, don't be fooled by the hash
hash1 header
uint32 a
byte[16] b
hash2 point
hash3 baz"#);

pub fn has_header(&self) -> bool

Returns true if the message has a header field.

A header field is a unit value named header of type std_msgs/Header. The package can be elided in this special case, no matter the package that the containing message is located in.

Trait Implementations

impl Clone for Msg

fn clone(&self) -> Msg

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Msg

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Msg

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Msg

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Msg

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Msg

fn eq(&self, other: &Msg) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Msg

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Msg

impl StructuralPartialEq for Msg