Struct miniseed::ms_record

pub struct ms_record(_);

MiniSEED Record

Methods

impl ms_record

fn ptr(&self) -> MSRecord

Get pointer to wrapped MSRecord value

fn null() -> *mut MSRecord

Create a null pointer as a MSRecord

fn read<S>(file: S) -> ms_record where
    S: AsRef<Path>, 

Read a file and return a ms_record

let file = "tests/sample.miniseed";
let rec = ms_record::read(file);
assert_eq!(rec.to_string(), "PN_PPNAF_00_HHZ, 1, D, 512, 206 samples, 100 Hz, 2016-10-30 18:02:58.230 UTC");

fn header(&self) -> fsdh_s

Return the MiniSEED Record FSDH Header, this is typically used internally

let file = "tests/sample.miniseed";
let rec = ms_record::read(file);
let hdr = rec.header();

fn start(&self) -> DateTime<Utc>

Return the start time

let file = "tests/sample.miniseed";
let rec = ms_record::read(file);
assert_eq!(rec.start().to_string(), "2016-10-30 18:02:58.230 UTC");

fn end(&self) -> DateTime<Utc>

Return the end time

let file = "tests/sample.miniseed";
let rec = ms_record::read(file);
assert_eq!(rec.end().to_string(), "2016-10-30 18:03:00.279999 UTC");

fn end1(&self) -> DateTime<Utc>

Return the time of the next sample beyond the record assuming a constant sample rate

let file = "tests/sample.miniseed";
let rec = ms_record::read(file);
assert_eq!(rec.end1().to_string(), "2016-10-30 18:03:00.290 UTC");

fn delta(&self) -> f64

Return the sample rate

let file = "tests/sample.miniseed";
let rec = ms_record::read(file);
assert_eq!(rec.delta(), 0.01);

fn data_type(&self) -> char

Return the data sample type

• c - Character data
• i - i32 data
• f - f32 data
• d - f64 data

let file = "tests/sample.miniseed";
let rec = ms_record::read(file);
assert_eq!(rec.data_type(), 'i');

fn dtype(&self) -> char

Return the data sample type

see data_type()

fn npts(&self) -> usize

Return the number of points or samples

let file = "tests/sample.miniseed";
let rec = ms_record::read(file);
assert_eq!(rec.npts(), 206);

fn time(&self) -> Vec<DateTime<Utc>>

Return the timing of each sample

let file = "tests/sample.miniseed";
let rec = ms_record::read(file);
println!("{:?}", rec.time());

fn data_f64(&self) -> &[f64]

Return the data as f64

use miniseed::ms_record;
let file = "tests/sample.miniseed";
let rec = ms_record::read(file);
assert_eq!(rec.data_f64()[0], 1.0);

fn data_f32(&self) -> &[f32]

Return the data as f32

use miniseed::ms_record;
let file = "tests/sample.miniseed";
let rec = ms_record::read(file);
assert_eq!(rec.data_f32()[0], 4.75878e-12);

fn data_i32(&self) -> &[i32]

Return the data as i32

let file = "tests/sample.miniseed";
let rec = ms_record::read(file);
assert_eq!(rec.data_i32()[0], 339598);

fn min(&self) -> f64

Return the minimum data value

let file = "tests/sample.miniseed";
let rec = ms_record::read(file);
assert_eq!(rec.min(), 333405.0);

fn max(&self) -> f64

Return the maximum data value

let file = "tests/sample.miniseed";
let rec = ms_record::read(file);
assert_eq!(rec.max(), 342105.0);

fn id(&self) -> String

Return the unique record identifier or ID

let file = "tests/sample.miniseed";
let rec = ms_record::read(file);
assert_eq!(rec.id(), "PN_PPNAF_00_HHZ");

fn parse(record: &[u8]) -> ms_record

Parse a SeedLink data buffer and return a ms_record

use std::fs::File;
use std::io::Read;
 
let mut file = File::open("tests/sample.miniseed").unwrap();
let mut buf = vec![];
let _ = file.read_to_end(&mut buf).unwrap();

let rec = ms_record::parse(&buf);
assert_eq!(rec.to_string(), "PN_PPNAF_00_HHZ, 1, D, 512, 206 samples, 100 Hz, 2016-10-30 18:02:58.230 UTC");

fn as_string(&self) -> Option<String>

Trait Implementations

impl Send for ms_record

impl Sync for ms_record

impl Debug for ms_record

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Display for ms_record

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

Formats the value using the given formatter.

impl Drop for ms_record

fn drop(&mut self)

Executes the destructor for this type.