Enum ros_message::DataType

pub enum DataType {
    Bool,
    I8(I8Variant),
    I16,
    I32,
    I64,
    U8(U8Variant),
    U16,
    U32,
    U64,
    F32,
    F64,
    String,
    Time,
    Duration,
    LocalMessage(String),
    GlobalMessage(MessagePath),
}

Enumerates all data types possible in a ROS message.

Variants

Bool

Represents bool.

I8(I8Variant)

Represents int8 or byte.

Variants are grouped to hint at the fact that they should be treated like the same type by most code. The key exception being matching messages for validating MD5 sums and message descriptors.

I16

Represents int16.

I32

Represents int32.

I64

Represents int64.

U8(U8Variant)

Represents uint8 or char.

Variants are grouped to hint at the fact that they should be treated like the same type by most code. The key exception being matching messages for validating MD5 sums and message descriptors.

U16

Represents uint16.

U32

Represents uint32.

U64

Represents uint64.

F32

Represents float32.

F64

Represents float64.

String

Represents string.

Time

Represents time.

Duration

Represents duration.

LocalMessage(String)

Represents messages from same package.

When a message in package foo has a field of message type foo/Bar, it can just reference the field as Bar, and would put in this variant.

GlobalMessage(MessagePath)

Represents messages from any package.

When a message has a field of message type foo/Bar, it can reference the field as foo/Bar, and would put in this variant.

Implementations

impl DataType

pub fn parse(datatype: &str) -> Result<Self>

Parses the data type from the type provided in a ROS msg.

Examples

assert_eq!(DataType::parse("int16")?, DataType::I16);
assert_eq!(DataType::parse("float64")?, DataType::F64);
assert_eq!(DataType::parse("byte")?, DataType::I8(I8Variant::Byte));
assert_eq!(
    DataType::parse("Header")?,
    DataType::GlobalMessage("std_msgs/Header".try_into()?),
);
assert_eq!(
    DataType::parse("Position")?,
    DataType::LocalMessage("Position".into()),
);
assert_eq!(
    DataType::parse("geometry_msgs/Position")?,
    DataType::GlobalMessage("geometry_msgs/Position".try_into()?),
);
assert!(DataType::parse("00bad_package/Name").is_err());
assert!(DataType::parse("a/bad/type").is_err());

pub fn is_builtin(&self) -> bool

Returns true if the type is a built in type, rather than another message.

Examples

assert!(DataType::parse("int16")?.is_builtin());
assert!(DataType::parse("float64")?.is_builtin());
assert!(DataType::parse("byte")?.is_builtin());
assert!(!DataType::parse("Header")?.is_builtin());
assert!(!DataType::parse("Position")?.is_builtin());
assert!(!DataType::parse("geometry_msgs/Position")?.is_builtin());

pub fn md5_str<'a>( &self, package: &str, hashes: &'a HashMap<MessagePath, String>, ) -> Result<&'a str>

Returns the representation of the data type when constructing the MD5 sum.

For built in types, it is the same as the data type name.

For message types, it is that message’s MD5 sum, which is passed in via the hashes argument.

The package argument should be the package that the current message is in, to resolve global paths of local message dependencies.

Errors

An error will be returned if a message we depend upon is missing.

Examples

let mut hashes = HashMap::new();
hashes.insert("foo/Header".try_into()?, "wrong_header".into());
hashes.insert("std_msgs/Header".try_into()?, "123".into());
hashes.insert("geometry_msgs/Position".try_into()?, "345".into());
hashes.insert("foo/Position".try_into()?, "678".into());

assert_eq!(DataType::parse("int16")?.md5_str("foo", &hashes)?, "int16");
assert_eq!(DataType::parse("float64")?.md5_str("foo", &hashes)?, "float64");
assert_eq!(DataType::parse("byte")?.md5_str("foo", &hashes)?, "byte");
assert_eq!(DataType::parse("Header")?.md5_str("foo", &hashes)?, "123");
assert_eq!(DataType::parse("Position")?.md5_str("foo", &hashes)?, "678");
assert_eq!(DataType::parse("geometry_msgs/Position")?.md5_str("foo", &hashes)?, "345");
assert!(DataType::parse("other_msgs/Position")?.md5_str("foo", &hashes).is_err());

Trait Implementations

impl Clone for DataType

fn clone(&self) -> DataType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DataType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DataType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DataType

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

Formats the value using the given formatter.

impl From<DataType> for String

fn from(src: DataType) -> String

Converts to this type from the input type.

impl Hash for DataType

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 DataType

fn eq(&self, other: &DataType) -> 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 DataType

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for DataType

type Error = Error

The type returned in the event of a conversion error.

fn try_from(src: &str) -> Result<Self>

Performs the conversion.

impl Eq for DataType

impl StructuralPartialEq for DataType