use ros_message::Time

Cargo.toml

@@ -21,6 +21,8 @@ regex = "1.5.4"
 ros_message = "0.1.0"
 smallvec = "1.6.1"
 thiserror = "1.0.28"
+smol_str = { version = "0.1.17", default-features = false }
+indexmap = "1.7.0"
 
 [dev-dependencies]
 color-eyre = "0.5.11"

src/chunk.rs

@@ -4,9 +4,10 @@ use eyre::bail;
 
 use crate::{
     error,
-    parse::{Header, Op, Time},
+    parse::{Header, Op},
     reader::BagReader,
     Error, Result,
+    Time
 };
 
 #[derive(Clone, Copy, Debug)]

src/index.rs

@@ -6,9 +6,9 @@ use nom::{number::streaming::le_u32, sequence::tuple, Parser};
 
 use crate::{
     error,
-    parse::{self, Header, Op, Time},
+    parse::{self, header::fields::parse_time, Header, Op},
     reader::BagReader,
-    Result,
+    Result, Time,
 };
 
 #[derive(Debug)]
@@ -188,7 +188,7 @@ pub struct IndexEntry {
 
 impl IndexEntry {
     pub fn parse(input: parse::Input) -> parse::IResult<Self> {
-        tuple((Time::parse, le_u32))
+        tuple((parse_time, le_u32))
             .map(|(time, offset)| IndexEntry { time, offset })
             .parse(input)
     }

src/layout.rs

@@ -0,0 +1,58 @@
+use ros_message::I8Variant;
+
+use crate::SmallStr;
+
+#[derive(Clone, Debug)]
+pub enum FieldType {
+    /// Represents `bool`.
+    Bool,
+    /// Represents `int8` or `byte`.
+    I8(I8Variant),
+    /// Represents `int16`.
+    I16,
+    /// Represents `int32`.
+    I32,
+    /// Represents `int64`.
+    I64,
+    /// Represents `uint8` or `char`.
+    U8(I8Variant),
+    /// Represents `uint16`.
+    U16,
+    /// Represents `uint32`.
+    U32,
+    /// Represents `uint64`.
+    U64,
+    /// Represents `float32`.
+    F32,
+    /// Represents `float64`.
+    F64,
+    /// Represents `string`.
+    String,
+    /// Represents `time`.
+    Time,
+    /// Represents `duration`.
+    Duration,
+    // Another messgage type.
+    Message(MessageLayoutRef),
+}
+
+#[derive(Clone, Debug)]
+pub struct FieldLayout {
+    pub typ: FieldType,
+    pub name: SmallStr,
+    pub multiplicity: Multiplicity,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Multiplicity {
+	Unit,
+	Fixed(usize),
+	Dynamic,
+}
+
+#[derive(Clone, Debug)]
+pub struct MessageLayout {
+    fields: Vec<FieldLayout>,
+}
+
+pub type MessageLayoutRef = std::sync::Arc<MessageLayout>;

src/lib.rs

@@ -2,10 +2,16 @@ pub mod bag;
 pub mod chunk;
 mod error;
 pub mod index;
+pub mod info;
+pub mod layout;
 pub mod message;
 pub mod parse;
 pub mod reader;
-pub mod info;
 
-pub use error::{Error, Result};
+pub use ros_message::Time;
+use smol_str::SmolStr;
+
 pub use bag::Bag;
+pub use error::{Error, Result};
+
+pub type SmallStr = SmolStr;

src/parse.rs

@@ -3,7 +3,7 @@ pub mod header;
 mod version;
 
 pub use error::{Error, ErrorKind};
-pub use header::{Header, Op, Time};
+pub use header::{Header, Op};
 pub use version::Version;
 
 pub type Input<'a> = &'a [u8];

src/parse/header.rs

@@ -12,14 +12,14 @@ use nom::{
 use smallvec::SmallVec;
 
 use super::{IResult, Input};
-use crate::Result;
+use crate::{Result, Time};
 
 mod error;
-mod fields;
+pub mod fields;
 
 pub use self::{
     error::{FieldDataError, MissingFieldError},
-    fields::{Op, Time},
+    fields::Op,
 };
 
 #[derive(Clone, Debug)]
@@ -95,7 +95,7 @@ impl Header {
     }
 
     pub fn read_time(&self, field: &[u8]) -> Result<Time> {
-        self.read_u64(field).map(Time::from_packed)
+        self.find_field(field).and_then(fields::read_time)
     }
 
     pub fn read_u32(&self, field: &[u8]) -> Result<u32> {

src/parse/header/fields.rs

@@ -4,6 +4,7 @@ use nom::{
     Parser,
 };
 use num_enum::TryFromPrimitive;
+use ros_message::Time;
 
 use crate::parse::IResult;
 
@@ -29,29 +30,21 @@ impl Op {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+fn time_from_packed(packed: u64) -> Time {
-pub struct Time {
-    pub sec: u32,
-    pub nsec: u32,
-}
-
-impl Time {
-    pub fn from_packed(packed: u64) -> Time {
     Time {
         sec: packed as u32,
         nsec: (packed >> 32) as u32,
     }
 }
 
-    pub fn parse(input: Input) -> IResult<Self> {
+pub fn parse_time(input: Input) -> IResult<Time> {
-        le_u64.map(Time::from_packed).parse(input)
+    le_u64.map(time_from_packed).parse(input)
 }
 
-    pub fn read(input: Input) -> Result<Self> {
+pub fn read_time(input: Input) -> Result<Time> {
-        let (_, x) = Self::parse(input).map_err(FieldDataError::from)?;
+    let (_, x) = parse_time(input).map_err(FieldDataError::from)?;
     Ok(x)
 }
-}
 
 pub fn read_u32(input: Input) -> Result<u32> {
     let (_, x) = all_consuming(le_u32)