Struct RecordRef 

pub struct RecordRef<'a> { /* private fields */ }

A wrapper around a non-owning immutable reference to a DBN record. This wrapper allows for mixing of record types and schemas and runtime record polymorphism.

Can hold any type implementing HasRType and acts similar to a &dyn HasRType or &dyn Record but due to the design of DBN records, only a few methods require a dynamic dispatch.

It has the has() method for testing if the contained value is of a particular type, and the inner value can be downcasted to specific record types via the get() method.

Examples

use dbn::{MboMsg, RecordRef, TradeMsg};

let mbo = MboMsg::default();
let rec = RecordRef::from(&mbo);

// This isn't a trade
assert!(!rec.has::<TradeMsg>());
// It's an MBO record
assert!(rec.has::<MboMsg>());

// `get()` can be used in `if let` chains:
if let Some(_trade) = rec.get::<TradeMsg>() {
    panic!("Unexpected record type");
} else if let Some(mbo) = rec.get::<MboMsg>() {
    println!("{mbo:?}");
}

The common record header is directly accessible through the header() method.

Implementations

impl<'a> RecordRef<'a>

pub unsafe fn new(buffer: &'a [u8]) -> Self

Constructs a new reference to the DBN record in buffer.

Safety

buffer should begin with a RecordHeader and contain a type implementing HasRType.

pub unsafe fn unchecked_from_header(header: *const RecordHeader) -> Self

Constructs a new reference to the DBN record.

Safety

header must point to a valid DBN record.

pub fn has<T: HasRType>(&self) -> bool

Returns true if the object points to a record of type T.

Usually paired with get() or get_unchecked().

Only checks the rtype matches that of the type T. It does not check the length.

Use try_get() when working with different versions of a DBN struct.

Examples

use dbn::{OhlcvMsg, RecordRef, Schema, TradeMsg};

let bar = OhlcvMsg::default_for_schema(Schema::Ohlcv1M);
let rec = RecordRef::from(&bar);

// This is a bar
assert!(rec.has::<OhlcvMsg>());
// It's not a trade
assert!(!rec.has::<TradeMsg>());

pub fn get<T: HasRType>(&self) -> Option<&'a T>

Returns a reference to the underlying record of type T or None if it points to another record type.

Note: for safety, this method calls has::<T>(). To avoid a duplicate check, use get_unchecked().

Panics

This function will panic if the rtype indicates it’s of type T but the encoded length of the record is less than the size of T. Use try_get() to more gracefully handle versioned structs and the optional presence of crate::WithTsOut.

Examples

use dbn::{BboMsg, RecordRef, Schema};

let bbo = BboMsg::default_for_schema(Schema::Bbo1S);
let rec = RecordRef::from(&bbo);

if let Some(bbo) = rec.get::<BboMsg>() {
    println!("{bbo:?}");
}

With versioned DBN structs

use dbn::{v1, v2, RecordRef};

// Initialize with version 1 definition
let def = v1::InstrumentDefMsg::default();
let rec = RecordRef::from(&def);
// Try to extract a version 2 definition
let _def = rec.get::<v2::InstrumentDefMsg>();

pub fn try_get<T: HasRType>(&self) -> Result<&'a T>

Like get(), but returns an error if the inner record is not a T or has the correct rtype for T, but insufficient length. Never panics

Errors

This function returns an error if does not hold a T or if its rtype matches T, but its length is too short.

Examples

use dbn::{v1, v2, v3, RecordRef, WithTsOut};

// Initialize with version 1 definition
let def = v1::InstrumentDefMsg::default();
let rec = RecordRef::from(&def);
// Try to extract new versions of definitions
assert!(rec.try_get::<v2::InstrumentDefMsg>().is_err());
assert!(rec.try_get::<v3::InstrumentDefMsg>().is_err());

rec.try_get::<v1::InstrumentDefMsg>().unwrap();

// Also works with data that might have ts_out
assert!(rec.try_get::<WithTsOut<v1::InstrumentDefMsg>>().is_err());

pub fn as_enum(&self) -> Result<RecordRefEnum<'_>>

Returns a native Rust enum with a variant for each record type. This allows for pattern matching.

Errors

This function returns a conversion error if the rtype does not correspond with any known DBN record type.

pub unsafe fn get_unchecked<T: HasRType>(&self) -> &'a T

Returns a reference to the underlying record of type T without checking if this object references a record of type T.

For a safe alternative, see get().

Safety

The caller needs to validate this object points to a T.

Examples

use dbn::{BboMsg, RecordRef, Schema};

let bbo = BboMsg::default_for_schema(Schema::Bbo1S);
let rec = RecordRef::from(&bbo);

if rec.has::<BboMsg>() {
    // SAFETY: checked rtype
    println!("{:?}", unsafe { rec.get_unchecked::<BboMsg>() });
}

Trait Implementations

impl<'a> AsRef<[u8]> for RecordRef<'a>

fn as_ref(&self) -> &'a [u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for RecordRef<'a>

fn clone(&self) -> RecordRef<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RecordRef<'_>

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

Formats the value using the given formatter.

impl<'a, R> From<&'a R> for RecordRef<'a>

where R: HasRType,

fn from(rec: &'a R) -> Self

Constructs a new reference to a DBN record.

impl<'a> From<&'a RecordEnum> for RecordRef<'a>

fn from(rec_enum: &'a RecordEnum) -> Self

Converts to this type from the input type.

impl<'a> From<RecordRef<'a>> for IoSlice<'a>

fn from(rec: RecordRef<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<RecordRefEnum<'a>> for RecordRef<'a>

fn from(rec_enum: RecordRefEnum<'a>) -> Self

Converts to this type from the input type.

impl<'a> Record for RecordRef<'a>

fn header(&self) -> &'a RecordHeader

Returns a reference to the RecordHeader that comes at the beginning of all record types.

fn raw_index_ts(&self) -> u64

Returns the raw primary timestamp for the record.

fn record_size(&self) -> usize

Returns the size of the record in bytes.

fn rtype(&self) -> Result<RType>

Tries to convert the raw record type into an enum which is useful for exhaustive pattern matching.

fn publisher(&self) -> Result<Publisher>

Tries to convert the raw publisher_id into an enum which is useful for exhaustive pattern matching.

fn index_ts(&self) -> Option<OffsetDateTime>

Returns the primary timestamp for the record. Returns None if the primary timestamp contains the sentinel value for a null timestamp.

fn index_date(&self) -> Option<Date>

Returns the primary date for the record; the date component of the primary timestamp (index_ts()). Returns None if the primary timestamp contains the sentinel value for a null timestamp.

impl<'a> TryFrom<RecordRef<'a>> for RecordRefEnum<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(rec_ref: RecordRef<'a>) -> Result<Self, Error>

Performs the conversion.

impl<'a> Copy for RecordRef<'a>

impl Send for RecordRef<'_>

impl Sync for RecordRef<'_>