🥮 mooncakes.io

nmea-toolkit

Typed NMEA 0183 parsing, diagnostics, and evidence toolkit

nmea
gnss
gps
parser
diagnostics
moon add jiujitong/nmea-toolkit@0.1.0
Download zip
Author
Version
0.1.0
License
Apache-2.0
Repository
Last updated
9 days ago
Downloads
4
README

#jiujitong/nmea-toolkit

Typed NMEA 0183 parsing and GNSS evidence analysis for MoonBit.

The package supports GGA, RMC, GSA, GSV, VTG, ZDA and GLL records, bounded stream decoding, multipart GSV assembly, explicit-time fix fusion, geographic metrics, tracks, quality findings, batch summaries and deterministic reports.

let record = @nmea.parse_sentence(
  "$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47\r\n",
).unwrap()
guard record is @nmea.GgaRecordValue(gga) else { abort("expected GGA") }
println(gga.satellites())

See README.md and the five packages under examples/ for complete usage.

#
BatchResult

source
pub struct BatchResult[T] {
  item_values : Array[SentenceResult[T]]
} derive(Eq, 
Debug)

#
BatchResult::count

source
fn[T] BatchResult::count(self : BatchResult[T]) -> Int

#
BatchResult::items

source
fn[T] BatchResult::items(self : BatchResult[T]) -> Array[SentenceResult[T]]

#
BatchResult::new

source
fn[T] BatchResult::new(items : Array[SentenceResult[T]]) -> BatchResult[T]

#
BatchSummary

source
pub(all) struct BatchSummary {
  total_value : Int
  successes_value : Int
  failures_value : Int
  formatter_entries_value : Array[StringCountEntry]
  talker_entries_value : Array[StringCountEntry]
  checksum_entries_value : Array[ChecksumCountEntry]
  error_entries_value : Array[StringCountEntry]
} derive(Eq, 
Debug)

#
BatchSummary::checksum_count

source
fn BatchSummary::checksum_count(self : BatchSummary, status : ChecksumStatus) -> Int

#
BatchSummary::checksum_entries

source
fn BatchSummary::checksum_entries(self : BatchSummary) -> Array[ChecksumCountEntry]

#
BatchSummary::error_count

source
fn BatchSummary::error_count(self : BatchSummary, key : String) -> Int

#
BatchSummary::error_entries

source
fn BatchSummary::error_entries(self : BatchSummary) -> Array[StringCountEntry]

#
BatchSummary::failures

source
fn BatchSummary::failures(self : BatchSummary) -> Int

#
BatchSummary::formatter_count

source
fn BatchSummary::formatter_count(self : BatchSummary, key : String) -> Int

#
BatchSummary::formatter_entries

source
fn BatchSummary::formatter_entries(self : BatchSummary) -> Array[StringCountEntry]

#
BatchSummary::successes

source
fn BatchSummary::successes(self : BatchSummary) -> Int

#
BatchSummary::talker_count

source
fn BatchSummary::talker_count(self : BatchSummary, key : String) -> Int

#
BatchSummary::talker_entries

source
fn BatchSummary::talker_entries(self : BatchSummary) -> Array[StringCountEntry]

#
BatchSummary::total

source
fn BatchSummary::total(self : BatchSummary) -> Int

#
BoundingBox

source
pub(all) struct BoundingBox {
  minimum_latitude_value : Double
  maximum_latitude_value : Double
  minimum_longitude_value : Double
  maximum_longitude_value : Double
} derive(Eq, 
Debug)

#
BoundingBox::maximum_latitude

source
fn BoundingBox::maximum_latitude(self : BoundingBox) -> Double

#
BoundingBox::maximum_longitude

source
fn BoundingBox::maximum_longitude(self : BoundingBox) -> Double

#
BoundingBox::minimum_latitude

source
fn BoundingBox::minimum_latitude(self : BoundingBox) -> Double

#
BoundingBox::minimum_longitude

source
fn BoundingBox::minimum_longitude(self : BoundingBox) -> Double

#
BoundingBox::new

source
fn BoundingBox::new(minimum_latitude : Double, maximum_latitude : Double, minimum_longitude : Double, maximum_longitude : Double) -> Result[BoundingBox, NmeaError]

#
ChecksumCountEntry

source
pub(all) struct ChecksumCountEntry {
  status_value : ChecksumStatus
  count_value : Int
} derive(Eq, 
Debug)

#
ChecksumCountEntry::count

source
fn ChecksumCountEntry::count(self : ChecksumCountEntry) -> Int

#
ChecksumCountEntry::status

source

#
ChecksumStatus

source
pub(all) enum ChecksumStatus {
  PresentValid
  PresentInvalid
  MissingChecksum
  NotChecked
} derive(Eq, 
Debug)

#
Coordinate

source
pub(all) struct Coordinate {
  axis_value : CoordinateAxis
  degrees_value : Double
  wire_value : ExactDecimal
  hemisphere_value : UInt16
} derive(Eq, 
Debug)

#
Coordinate::axis

source

#
Coordinate::degrees

source
fn Coordinate::degrees(self : Coordinate) -> Double

#
Coordinate::hemisphere

source
fn Coordinate::hemisphere(self : Coordinate) -> UInt16

#
Coordinate::wire

source
fn Coordinate::wire(self : Coordinate) -> ExactDecimal

#
CoordinateAxis

source
pub(all) enum CoordinateAxis {
  Latitude
  Longitude
} derive(Eq, 
Debug)

#
Diagnostic

source
pub(all) struct Diagnostic {
  code : String
  severity : Severity
  message : String
  source : SourceRef
} derive(Eq, 
Debug)

#
Diagnostic::code

source
fn Diagnostic::code(self : Diagnostic) -> String

#
Diagnostic::message

source
fn Diagnostic::message(self : Diagnostic) -> String

#
Diagnostic::new

source
fn Diagnostic::new(code : NmeaErrorCode, severity : Severity, message : String, source : SourceRef) -> Diagnostic

#
Diagnostic::severity

source
fn Diagnostic::severity(self : Diagnostic) -> Severity

#
Diagnostic::source

source
fn Diagnostic::source(self : Diagnostic) -> SourceRef

#
ExactDecimal

source
pub(all) struct ExactDecimal {
  coefficient_value : Int64
  scale_value : Int
  negative_zero_value : Bool
} derive(Eq, 
Debug)

A bounded decimal that preserves the coefficient and number of fractional digits.

#
ExactDecimal::coefficient

source
fn ExactDecimal::coefficient(self : ExactDecimal) -> Int64

#
ExactDecimal::compare

source
fn ExactDecimal::compare(self : ExactDecimal, other : ExactDecimal) -> Int

#
ExactDecimal::is_negative_zero

source
fn ExactDecimal::is_negative_zero(self : ExactDecimal) -> Bool

#
ExactDecimal::parse

source
fn ExactDecimal::parse(text : String, max_scale? : Int) -> Result[ExactDecimal, NmeaError]

Parses a base-10 decimal without accepting exponent notation.

#
ExactDecimal::scale

source
fn ExactDecimal::scale(self : ExactDecimal) -> Int

#
ExactDecimal::to_double

source
fn ExactDecimal::to_double(self : ExactDecimal) -> Double

#
ExactDecimal::to_string

source
fn ExactDecimal::to_string(self : ExactDecimal) -> String

#
FieldCursor

source
pub(all) struct FieldCursor {
  fields_value : Array[String]
  record_index_value : Int
} derive(
Debug)

#
FieldCursor::decimal

source
fn FieldCursor::decimal(self : FieldCursor, index : Int, max_scale? : Int) -> Result[ExactDecimal, NmeaError]

#
FieldCursor::integer

source
fn FieldCursor::integer(self : FieldCursor, index : Int, min? : Int, max? : Int) -> Result[Int, NmeaError]

#
FieldCursor::length

source
fn FieldCursor::length(self : FieldCursor) -> Int

#
FieldCursor::new

source
fn FieldCursor::new(fields : Array[String], record_index? : Int) -> FieldCursor

#
FieldCursor::optional

source
fn FieldCursor::optional(self : FieldCursor, index : Int) -> Result[String?, NmeaError]

#
FieldCursor::record_index

source
fn FieldCursor::record_index(self : FieldCursor) -> Int

#
FieldCursor::required

source
fn FieldCursor::required(self : FieldCursor, index : Int) -> Result[String, NmeaError]

#
FieldProvenance

source
pub(all) struct FieldProvenance {
  field_value : String
  source_value : FusionSource
  record_index_value : Int
} derive(Eq, 
Debug)

#
FieldProvenance::field

source
fn FieldProvenance::field(self : FieldProvenance) -> String

#
FieldProvenance::record_index

source
fn FieldProvenance::record_index(self : FieldProvenance) -> Int

#
FieldProvenance::source

source

#
FixFusion

source
pub struct FixFusion {
  groups_value : Array[FusionGroup]
}

#
FixFusion::add_gga

source
fn FixFusion::add_gga(self : FixFusion, record : GgaRecord, record_index~ : Int, date? : UtcDate?) -> Unit

#
FixFusion::add_rmc

source
fn FixFusion::add_rmc(self : FixFusion, record : RmcRecord, record_index~ : Int) -> Unit

#
FixFusion::add_vtg

source
fn FixFusion::add_vtg(self : FixFusion, record : VtgRecord, time : UtcTime, record_index~ : Int, date? : UtcDate?) -> Unit

#
FixFusion::finish

source
fn FixFusion::finish(self : FixFusion) -> Array[FusedFix]

#
FixFusion::new

source
fn FixFusion::new() -> FixFusion

#
FrameLimits

source
pub(all) struct FrameLimits {
  max_sentence_bytes : Int
  max_fields : Int
  max_field_bytes : Int
} derive(Eq, 
Debug)

#
FrameLimits::standard

source
fn FrameLimits::standard() -> FrameLimits

#
FusedFix

source
pub(all) struct FusedFix {
  time_value : UtcTime
  date_value : UtcDate?
  latitude_value : Double?
  longitude_value : Double?
  altitude_value : ExactDecimal?
  quality_value : GgaFixQuality?
  satellites_value : Int?
  speed_knots_value : ExactDecimal?
  course_value : ExactDecimal?
  usable_value : Bool
  provenance_value : Array[FieldProvenance]
  diagnostics_value : Array[Diagnostic]
  source_record_indexes_value : Array[Int]
} derive(Eq, 
Debug)

#
FusedFix::altitude

source
fn FusedFix::altitude(self : FusedFix) -> ExactDecimal?

#
FusedFix::course

source
fn FusedFix::course(self : FusedFix) -> ExactDecimal?

#
FusedFix::date

source
fn FusedFix::date(self : FusedFix) -> UtcDate?

#
FusedFix::diagnostics

source
fn FusedFix::diagnostics(self : FusedFix) -> Array[Diagnostic]

#
FusedFix::latitude

source
fn FusedFix::latitude(self : FusedFix) -> Double?

#
FusedFix::longitude

source
fn FusedFix::longitude(self : FusedFix) -> Double?

#
FusedFix::provenance

source
fn FusedFix::provenance(self : FusedFix) -> Array[FieldProvenance]

#
FusedFix::quality

source
fn FusedFix::quality(self : FusedFix) -> GgaFixQuality?

#
FusedFix::satellites

source
fn FusedFix::satellites(self : FusedFix) -> Int?

#
FusedFix::source_record_indexes

source
fn FusedFix::source_record_indexes(self : FusedFix) -> Array[Int]

#
FusedFix::speed_knots

source
fn FusedFix::speed_knots(self : FusedFix) -> ExactDecimal?

#
FusedFix::time

source
fn FusedFix::time(self : FusedFix) -> UtcTime

#
FusedFix::usable

source
fn FusedFix::usable(self : FusedFix) -> Bool

#
FusionGroup

source
type FusionGroup

#
FusionSource

source
pub(all) enum FusionSource {
  GgaSource
  RmcSource
  VtgSource
} derive(Eq, 
Debug)

#
GgaFixQuality

source
pub(all) enum GgaFixQuality {
  InvalidFix
  GpsFix
  DgpsFix
  PpsFix
  RtkFixed
  RtkFloat
  EstimatedFix
  ManualFix
  SimulationFix
  UnknownFix(Int)
} derive(Eq, 
Debug)

#
GgaRecord

source
pub(all) struct GgaRecord {
  talker_value : String
  time_value : UtcTime
  latitude_value : Coordinate?
  longitude_value : Coordinate?
  quality_value : GgaFixQuality
  satellites_value : Int
  hdop_value : ExactDecimal?
  altitude_value : ExactDecimal?
  geoid_separation_value : ExactDecimal?
  dgps_age_value : ExactDecimal?
  dgps_station_value : String?
} derive(Eq, 
Debug)

#
GgaRecord::altitude

source
fn GgaRecord::altitude(self : GgaRecord) -> ExactDecimal?

#
GgaRecord::encode

source
fn GgaRecord::encode(self : GgaRecord) -> Result[String, NmeaError]

#
GgaRecord::geoid_separation

source
fn GgaRecord::geoid_separation(self : GgaRecord) -> ExactDecimal?

#
GgaRecord::hdop

source
fn GgaRecord::hdop(self : GgaRecord) -> ExactDecimal?

#
GgaRecord::latitude

source
fn GgaRecord::latitude(self : GgaRecord) -> Coordinate?

#
GgaRecord::longitude

source
fn GgaRecord::longitude(self : GgaRecord) -> Coordinate?

#
GgaRecord::quality

source
fn GgaRecord::quality(self : GgaRecord) -> GgaFixQuality

#
GgaRecord::satellites

source
fn GgaRecord::satellites(self : GgaRecord) -> Int

#
GgaRecord::time

source
fn GgaRecord::time(self : GgaRecord) -> UtcTime

#
GllRecord

source
pub(all) struct GllRecord {
  talker_value : String
  latitude_value : Coordinate
  longitude_value : Coordinate
  time_value : UtcTime
  status_value : RmcStatus
  mode_value : String?
} derive(Eq, 
Debug)

#
GllRecord::encode

source
fn GllRecord::encode(self : GllRecord) -> Result[String, NmeaError]

#
GllRecord::latitude

source
fn GllRecord::latitude(self : GllRecord) -> Coordinate

#
GllRecord::longitude

source
fn GllRecord::longitude(self : GllRecord) -> Coordinate

#
GllRecord::mode

source
fn GllRecord::mode(self : GllRecord) -> String?

#
GllRecord::status

source
fn GllRecord::status(self : GllRecord) -> RmcStatus

#
GllRecord::time

source
fn GllRecord::time(self : GllRecord) -> UtcTime

#
GsaFixMode

source
pub(all) enum GsaFixMode {
  NoDimensionalFix
  TwoDimensional
  ThreeDimensional
} derive(Eq, 
Debug)

#
GsaRecord

source
pub(all) struct GsaRecord {
  talker_value : String
  selection_value : GsaSelection
  fix_mode_value : GsaFixMode
  satellite_ids_value : Array[String]
  pdop_value : ExactDecimal?
  hdop_value : ExactDecimal?
  vdop_value : ExactDecimal?
} derive(Eq, 
Debug)

#
GsaRecord::encode

source
fn GsaRecord::encode(self : GsaRecord) -> Result[String, NmeaError]

#
GsaRecord::fix_mode

source
fn GsaRecord::fix_mode(self : GsaRecord) -> GsaFixMode

#
GsaRecord::hdop

source
fn GsaRecord::hdop(self : GsaRecord) -> ExactDecimal?

#
GsaRecord::pdop

source
fn GsaRecord::pdop(self : GsaRecord) -> ExactDecimal?

#
GsaRecord::satellite_ids

source
fn GsaRecord::satellite_ids(self : GsaRecord) -> Array[String]

#
GsaRecord::selection

source
fn GsaRecord::selection(self : GsaRecord) -> GsaSelection

#
GsaRecord::vdop

source
fn GsaRecord::vdop(self : GsaRecord) -> ExactDecimal?

#
GsaSelection

source
pub(all) enum GsaSelection {
  AutomaticSelection
  ManualSelection
} derive(Eq, 
Debug)

#
GsvAssembler

source
pub struct GsvAssembler {
  pending_value : Array[PendingGsvAssembly]
}

#
GsvAssembler::new

source

#
GsvAssembler::pending_count

source
fn GsvAssembler::pending_count(self : GsvAssembler) -> Int

#
GsvAssembler::push

source
fn GsvAssembler::push(self : GsvAssembler, record : GsvRecord, record_index~ : Int) -> Result[GsvAssembly?, NmeaError]

#
GsvAssembly

source
pub(all) struct GsvAssembly {
  talker_value : String
  signal_id_value : String?
  total_messages_value : Int
  total_satellites_value : Int
  observations_value : Array[SatelliteObservation]
  source_record_indexes_value : Array[Int]
} derive(Eq, 
Debug)

#
GsvAssembly::observations

source
fn GsvAssembly::observations(self : GsvAssembly) -> Array[SatelliteObservation]

#
GsvAssembly::signal_id

source
fn GsvAssembly::signal_id(self : GsvAssembly) -> String?

#
GsvAssembly::source_record_indexes

source
fn GsvAssembly::source_record_indexes(self : GsvAssembly) -> Array[Int]

#
GsvAssembly::talker

source
fn GsvAssembly::talker(self : GsvAssembly) -> String

#
GsvAssembly::total_messages

source
fn GsvAssembly::total_messages(self : GsvAssembly) -> Int

#
GsvAssembly::total_satellites

source
fn GsvAssembly::total_satellites(self : GsvAssembly) -> Int

#
GsvRecord

source
pub(all) struct GsvRecord {
  talker_value : String
  total_messages_value : Int
  message_number_value : Int
  total_satellites_value : Int
  observations_value : Array[SatelliteObservation]
  signal_id_value : String?
} derive(Eq, 
Debug)

#
GsvRecord::encode

source
fn GsvRecord::encode(self : GsvRecord) -> Result[String, NmeaError]

#
GsvRecord::message_number

source
fn GsvRecord::message_number(self : GsvRecord) -> Int

#
GsvRecord::observations

source
fn GsvRecord::observations(self : GsvRecord) -> Array[SatelliteObservation]

#
GsvRecord::signal_id

source
fn GsvRecord::signal_id(self : GsvRecord) -> String?

#
GsvRecord::total_messages

source
fn GsvRecord::total_messages(self : GsvRecord) -> Int

#
GsvRecord::total_satellites

source
fn GsvRecord::total_satellites(self : GsvRecord) -> Int

#
NmeaBatch

source
pub(all) struct NmeaBatch {
  items_value : Array[SentenceResult[NmeaRecord]]
  summary_value : BatchSummary
} derive(Eq, 
Debug)

#
NmeaBatch::items

source

#
NmeaBatch::summary

source
fn NmeaBatch::summary(self : NmeaBatch) -> BatchSummary

#
NmeaChecksum

source
pub(all) struct NmeaChecksum {
  value : Int
}

#
NmeaChecksum::calculate

source
fn NmeaChecksum::calculate(payload : String) -> Int

Returns the XOR of all ASCII code units in a sentence payload.

#
NmeaChecksum::hex

source
fn NmeaChecksum::hex(value : Int) -> String

#
NmeaChecksum::verify

source
fn NmeaChecksum::verify(payload : String, expected : String) -> Bool

#
NmeaError

source
pub(all) struct NmeaError {
  diagnostic : Diagnostic
} derive(Eq, 
Debug)

#
NmeaError::code

source
fn NmeaError::code(self : NmeaError) -> String

#
NmeaError::diagnostic

source
fn NmeaError::diagnostic(self : NmeaError) -> Diagnostic

#
NmeaError::from_diagnostic

source
fn NmeaError::from_diagnostic(diagnostic : Diagnostic) -> NmeaError

#
NmeaError::severity

source
fn NmeaError::severity(self : NmeaError) -> Severity

#
NmeaErrorCode

source
pub(all) enum NmeaErrorCode {
  FramingMissingStart
  FramingInvalidPrefix
  FramingMissingChecksumDelimiter
  FramingTooLong
  ChecksumMissing
  ChecksumMalformed
  ChecksumMismatch
  FieldMissing
  FieldEmpty
  FieldInvalidInteger
  FieldInvalidDecimal
  CoordinateInvalid
  DateInvalid
  TimeInvalid
  SentenceUnsupported
  SentenceInvalid
  StreamLimitExceeded
  GsvAssemblyInvalid
  FusionConflict
  GeographicInvalid
  TrackQualityIssue
  IntegrityInvalid
} derive(Eq, 
Debug)

#
NmeaErrorCode::code

source
fn NmeaErrorCode::code(self : NmeaErrorCode) -> String

#
NmeaFrame

source
pub(all) struct NmeaFrame {
  prefix_value : UInt16
  talker_value : String
  formatter_value : String
  fields_value : Array[String]
  checksum_status_value : ChecksumStatus
  checksum_value : Int?
} derive(Eq, 
Debug)

#
NmeaFrame::checksum_status

source
fn NmeaFrame::checksum_status(self : NmeaFrame) -> ChecksumStatus

#
NmeaFrame::encode

source
fn NmeaFrame::encode(self : NmeaFrame) -> String

#
NmeaFrame::fields

source
fn NmeaFrame::fields(self : NmeaFrame) -> Array[String]

#
NmeaFrame::formatter

source
fn NmeaFrame::formatter(self : NmeaFrame) -> String

#
NmeaFrame::new

source
fn NmeaFrame::new(prefix : UInt16, talker : String, formatter : String, fields : Array[String]) -> NmeaFrame

#
NmeaFrame::prefix

source
fn NmeaFrame::prefix(self : NmeaFrame) -> UInt16

#
NmeaFrame::talker

source
fn NmeaFrame::talker(self : NmeaFrame) -> String

#
NmeaRecord

source
pub(all) enum NmeaRecord {
  GgaRecordValue(GgaRecord)
  RmcRecordValue(RmcRecord)
  GsaRecordValue(GsaRecord)
  GsvRecordValue(GsvRecord)
  VtgRecordValue(VtgRecord)
  ZdaRecordValue(ZdaRecord)
  GllRecordValue(GllRecord)
  RawRecordValue(RawRecord)
} derive(Eq, 
Debug)

#
NmeaRecord::encode

source
fn NmeaRecord::encode(self : NmeaRecord) -> Result[String, NmeaError]

#
NmeaRecord::formatter

source
fn NmeaRecord::formatter(self : NmeaRecord) -> String

#
NmeaRecord::talker

source
fn NmeaRecord::talker(self : NmeaRecord) -> String

#
ParsePolicy

source
pub(all) enum ParsePolicy {
  Strict
  Lenient
} derive(Eq, 
Debug)

#
PendingGsvAssembly

source
type PendingGsvAssembly

#
QualityThresholds

source
pub(all) struct QualityThresholds {
  max_gap_millis_value : Int64
  max_segment_distance_meters_value : Double
  max_speed_mps_value : Double
  max_speed_mismatch_mps_value : Double
  minimum_satellites_value : Int
  minimum_fix_quality_rank_value : Int
} derive(Eq, 
Debug)

#
QualityThresholds::new

source
fn QualityThresholds::new(max_gap_millis? : Int64, max_segment_distance_meters? : Double, max_speed_mps? : Double, max_speed_mismatch_mps? : Double, minimum_satellites? : Int, minimum_fix_quality_rank? : Int) -> Result[QualityThresholds, NmeaError]

#
QualityThresholds::standard

source

#
RawRecord

source
pub(all) struct RawRecord {
  frame_value : NmeaFrame
} derive(Eq, 
Debug)

#
RawRecord::frame

source
fn RawRecord::frame(self : RawRecord) -> NmeaFrame

#
RmcRecord

source
pub(all) struct RmcRecord {
  talker_value : String
  time_value : UtcTime
  status_value : RmcStatus
  latitude_value : Coordinate?
  longitude_value : Coordinate?
  speed_knots_value : ExactDecimal?
  course_value : ExactDecimal?
  date_value : UtcDate
  magnetic_variation_value : ExactDecimal?
  magnetic_direction_value : String?
  mode_value : String?
} derive(Eq, 
Debug)

#
RmcRecord::course

source
fn RmcRecord::course(self : RmcRecord) -> ExactDecimal?

#
RmcRecord::date

source
fn RmcRecord::date(self : RmcRecord) -> UtcDate

#
RmcRecord::encode

source
fn RmcRecord::encode(self : RmcRecord) -> Result[String, NmeaError]

#
RmcRecord::latitude

source
fn RmcRecord::latitude(self : RmcRecord) -> Coordinate?

#
RmcRecord::longitude

source
fn RmcRecord::longitude(self : RmcRecord) -> Coordinate?

#
RmcRecord::magnetic_variation

source
fn RmcRecord::magnetic_variation(self : RmcRecord) -> ExactDecimal?

#
RmcRecord::speed_knots

source
fn RmcRecord::speed_knots(self : RmcRecord) -> ExactDecimal?

#
RmcRecord::status

source
fn RmcRecord::status(self : RmcRecord) -> RmcStatus

#
RmcRecord::time

source
fn RmcRecord::time(self : RmcRecord) -> UtcTime

#
RmcStatus

source
pub(all) enum RmcStatus {
  Active
  Void
} derive(Eq, 
Debug)

#
SatelliteObservation

source
pub(all) struct SatelliteObservation {
  satellite_id_value : String
  elevation_degrees_value : Int?
  azimuth_degrees_value : Int?
  snr_value : Int?
} derive(Eq, 
Debug)

#
SatelliteObservation::azimuth_degrees

source
fn SatelliteObservation::azimuth_degrees(self : SatelliteObservation) -> Int?

#
SatelliteObservation::elevation_degrees

source
fn SatelliteObservation::elevation_degrees(self : SatelliteObservation) -> Int?

#
SatelliteObservation::satellite_id

source
fn SatelliteObservation::satellite_id(self : SatelliteObservation) -> String

#
SatelliteObservation::snr

source

#
SentenceResult

source
pub struct SentenceResult[T] {
  record_index_value : Int
  formatter_value : String?
  checksum_status_value : ChecksumStatus
  value_value : T?
  error_value : NmeaError?
} derive(Eq, 
Debug)

#
SentenceResult::checksum_status

source
fn[T] SentenceResult::checksum_status(self : SentenceResult[T]) -> ChecksumStatus

#
SentenceResult::err

source
fn[T] SentenceResult::err(record_index : Int, checksum_status : ChecksumStatus, error : NmeaError) -> SentenceResult[T]

#
SentenceResult::error

source
fn[T] SentenceResult::error(self : SentenceResult[T]) -> NmeaError?

#
SentenceResult::formatter

source
fn[T] SentenceResult::formatter(self : SentenceResult[T]) -> String?

#
SentenceResult::ok

source
fn[T] SentenceResult::ok(record_index : Int, formatter : String, checksum_status : ChecksumStatus, value? : T?) -> SentenceResult[T]

#
SentenceResult::record_index

source
fn[T] SentenceResult::record_index(self : SentenceResult[T]) -> Int

#
SentenceResult::value

source
fn[T] SentenceResult::value(self : SentenceResult[T]) -> T?

#
Severity

source
pub(all) enum Severity {
  Info
  Warning
  Error
} derive(Eq, 
Debug)

#
SourceRef

source
pub(all) struct SourceRef {
  record_index : Int
  field_index : Int?
  byte_offset : Int?
} derive(Eq, 
Debug)

#
SourceRef::byte

source
fn SourceRef::byte(record_index : Int, byte_offset : Int) -> SourceRef

#
SourceRef::byte_offset

source
fn SourceRef::byte_offset(self : SourceRef) -> Int?

#
SourceRef::field

source
fn SourceRef::field(record_index : Int, field_index : Int, byte_offset? : Int?) -> SourceRef

#
SourceRef::field_index

source
fn SourceRef::field_index(self : SourceRef) -> Int?

#
SourceRef::record_index

source
fn SourceRef::record_index(self : SourceRef) -> Int

#
SourceRef::sentence

source
fn SourceRef::sentence(record_index : Int) -> SourceRef

#
StreamDecoder

source
pub struct StreamDecoder {
  policy_value : ParsePolicy
  limits_value : StreamLimits
  buffer_value : Array[Byte]
  record_index_value : Int
  discarding_value : Bool
  skip_lf_value : Bool
}

#
StreamDecoder::buffered_bytes

source
fn StreamDecoder::buffered_bytes(self : StreamDecoder) -> Int

#
StreamDecoder::finish

source

#
StreamDecoder::new

source
fn StreamDecoder::new(policy? : ParsePolicy, limits? : StreamLimits) -> StreamDecoder

#
StreamDecoder::push

source
fn StreamDecoder::push(self : StreamDecoder, chunk : Bytes) -> Array[SentenceResult[NmeaRecord]]

#
StreamLimits

source
pub(all) struct StreamLimits {
  max_buffer_bytes_value : Int
  frame_limits_value : FrameLimits
} derive(Eq, 
Debug)

#
StreamLimits::frame_limits

source
fn StreamLimits::frame_limits(self : StreamLimits) -> FrameLimits

#
StreamLimits::max_buffer_bytes

source
fn StreamLimits::max_buffer_bytes(self : StreamLimits) -> Int

#
StreamLimits::new

source
fn StreamLimits::new(max_buffer_bytes : Int, frame_limits? : FrameLimits) -> Result[StreamLimits, NmeaError]

#
StreamLimits::standard

source
fn StreamLimits::standard() -> StreamLimits

#
StringCountEntry

source
pub(all) struct StringCountEntry {
  key_value : String
  count_value : Int
} derive(Eq, 
Debug)

#
StringCountEntry::count

source
fn StringCountEntry::count(self : StringCountEntry) -> Int

#
StringCountEntry::key

source
fn StringCountEntry::key(self : StringCountEntry) -> String

#
Track

source
pub(all) struct Track {
  points_value : Array[TrackPoint]
  segments_value : Array[TrackSegment]
  summary_value : TrackSummary
} derive(Eq, 
Debug)

#
Track::from_points

source
fn Track::from_points(points : Array[TrackPoint]) -> Result[Track, NmeaError]

#
Track::points

source
fn Track::points(self : Track) -> Array[TrackPoint]

#
Track::segments

source
fn Track::segments(self : Track) -> Array[TrackSegment]

#
Track::summary

source
fn Track::summary(self : Track) -> TrackSummary

#
TrackFilter

source
pub(all) struct TrackFilter {
  start_time_value : UtcDateTime?
  end_time_value : UtcDateTime?
  bounds_value : BoundingBox?
  minimum_fix_quality_rank_value : Int?
  maximum_severity_value : Severity?
} derive(Eq, 
Debug)

#
TrackFilter::new

source
fn TrackFilter::new(start_time? : UtcDateTime?, end_time? : UtcDateTime?, bounds? : BoundingBox?, minimum_fix_quality_rank? : Int?, maximum_severity? : Severity?) -> Result[TrackFilter, NmeaError]

#
TrackFinding

source
pub(all) struct TrackFinding {
  kind_value : TrackFindingKind
  severity_value : Severity
  point_index_value : Int?
  segment_index_value : Int?
  diagnostic_value : Diagnostic
} derive(Eq, 
Debug)

#
TrackFinding::diagnostic

source
fn TrackFinding::diagnostic(self : TrackFinding) -> Diagnostic

#
TrackFinding::kind

source

#
TrackFinding::point_index

source
fn TrackFinding::point_index(self : TrackFinding) -> Int?

#
TrackFinding::segment_index

source
fn TrackFinding::segment_index(self : TrackFinding) -> Int?

#
TrackFinding::severity

source
fn TrackFinding::severity(self : TrackFinding) -> Severity

#
TrackFindingKind

source
pub(all) enum TrackFindingKind {
  NoFixFinding
  LowSatellitesFinding
  LowFixQualityFinding
  NonMonotonicTimeFinding
  LongGapFinding
  CoordinateJumpFinding
  ExcessiveSpeedFinding
  SpeedMismatchFinding
} derive(Eq, 
Debug)

#
TrackPoint

source
pub(all) struct TrackPoint {
  latitude_value : Double
  longitude_value : Double
  altitude_value : ExactDecimal?
  datetime_value : UtcDateTime?
  reported_speed_knots_value : ExactDecimal?
  quality_value : GgaFixQuality?
  satellites_value : Int?
  usable_value : Bool
  source_record_indexes_value : Array[Int]
} derive(Eq, 
Debug)

#
TrackPoint::altitude

source
fn TrackPoint::altitude(self : TrackPoint) -> ExactDecimal?

#
TrackPoint::datetime

source
fn TrackPoint::datetime(self : TrackPoint) -> UtcDateTime?

#
TrackPoint::from_fused

source
fn TrackPoint::from_fused(fix : FusedFix) -> Result[TrackPoint, NmeaError]

#
TrackPoint::latitude

source
fn TrackPoint::latitude(self : TrackPoint) -> Double

#
TrackPoint::longitude

source
fn TrackPoint::longitude(self : TrackPoint) -> Double

#
TrackPoint::new

source
fn TrackPoint::new(latitude : Double, longitude : Double, altitude? : ExactDecimal?, datetime? : UtcDateTime?, reported_speed_knots? : ExactDecimal?, quality? : GgaFixQuality?, satellites? : Int?, usable? : Bool, source_record_indexes? : Array[Int]) -> Result[TrackPoint, NmeaError]

#
TrackPoint::quality

source
fn TrackPoint::quality(self : TrackPoint) -> GgaFixQuality?

#
TrackPoint::reported_speed_knots

source
fn TrackPoint::reported_speed_knots(self : TrackPoint) -> ExactDecimal?

#
TrackPoint::satellites

source
fn TrackPoint::satellites(self : TrackPoint) -> Int?

#
TrackPoint::source_record_indexes

source
fn TrackPoint::source_record_indexes(self : TrackPoint) -> Array[Int]

#
TrackPoint::usable

source
fn TrackPoint::usable(self : TrackPoint) -> Bool

#
TrackQualityReport

source
pub(all) struct TrackQualityReport {
  findings_value : Array[TrackFinding]
} derive(Eq, 
Debug)

#
TrackQualityReport::findings

source

#
TrackSegment

source
pub(all) struct TrackSegment {
  start_index_value : Int
  end_index_value : Int
  distance_meters_value : Double
  bearing_degrees_value : Double
  duration_millis_value : Int64?
  derived_speed_mps_value : Double?
} derive(Eq, 
Debug)

#
TrackSegment::bearing_degrees

source
fn TrackSegment::bearing_degrees(self : TrackSegment) -> Double

#
TrackSegment::derived_speed_mps

source
fn TrackSegment::derived_speed_mps(self : TrackSegment) -> Double?

#
TrackSegment::distance_meters

source
fn TrackSegment::distance_meters(self : TrackSegment) -> Double

#
TrackSegment::duration_millis

source
fn TrackSegment::duration_millis(self : TrackSegment) -> Int64?

#
TrackSegment::end_index

source
fn TrackSegment::end_index(self : TrackSegment) -> Int

#
TrackSegment::start_index

source
fn TrackSegment::start_index(self : TrackSegment) -> Int

#
TrackSummary

source
pub(all) struct TrackSummary {
  point_count_value : Int
  segment_count_value : Int
  total_distance_meters_value : Double
  total_duration_millis_value : Int64?
  bounds_value : BoundingBox?
} derive(Eq, 
Debug)

#
TrackSummary::bounds

source
fn TrackSummary::bounds(self : TrackSummary) -> BoundingBox?

#
TrackSummary::point_count

source
fn TrackSummary::point_count(self : TrackSummary) -> Int

#
TrackSummary::segment_count

source
fn TrackSummary::segment_count(self : TrackSummary) -> Int

#
TrackSummary::total_distance_meters

source
fn TrackSummary::total_distance_meters(self : TrackSummary) -> Double

#
TrackSummary::total_duration_millis

source
fn TrackSummary::total_duration_millis(self : TrackSummary) -> Int64?

#
UtcDate

source
pub(all) struct UtcDate {
  year_value : Int
  month_value : Int
  day_value : Int
} derive(Eq, 
Debug)

#
UtcDate::day

source
fn UtcDate::day(self : UtcDate) -> Int

#
UtcDate::month

source
fn UtcDate::month(self : UtcDate) -> Int

#
UtcDate::new

source
fn UtcDate::new(year : Int, month : Int, day : Int, source : SourceRef) -> Result[UtcDate, NmeaError]

#
UtcDate::parse_rmc

source
fn UtcDate::parse_rmc(text : String, source : SourceRef) -> Result[UtcDate, NmeaError]

#
UtcDate::year

source
fn UtcDate::year(self : UtcDate) -> Int

#
UtcDateTime

source
pub(all) struct UtcDateTime {
  date_value : UtcDate
  time_value : UtcTime
} derive(Eq, 
Debug)

#
UtcDateTime::compare

source
fn UtcDateTime::compare(self : UtcDateTime, other : UtcDateTime) -> Int

#
UtcDateTime::date

source
fn UtcDateTime::date(self : UtcDateTime) -> UtcDate

#
UtcDateTime::millis_since

source
fn UtcDateTime::millis_since(self : UtcDateTime, earlier : UtcDateTime) -> Int64

#
UtcDateTime::new

source
fn UtcDateTime::new(date : UtcDate, time : UtcTime) -> UtcDateTime

#
UtcDateTime::time

source
fn UtcDateTime::time(self : UtcDateTime) -> UtcTime

#
UtcTime

source
pub(all) struct UtcTime {
  hour_value : Int
  minute_value : Int
  second_value : Int
  nanosecond_value : Int
  second_wire_value : ExactDecimal
} derive(Eq, 
Debug)

#
UtcTime::hour

source
fn UtcTime::hour(self : UtcTime) -> Int

#
UtcTime::minute

source
fn UtcTime::minute(self : UtcTime) -> Int

#
UtcTime::nanosecond

source
fn UtcTime::nanosecond(self : UtcTime) -> Int

#
UtcTime::parse

source
fn UtcTime::parse(text : String, source : SourceRef) -> Result[UtcTime, NmeaError]

#
UtcTime::second

source
fn UtcTime::second(self : UtcTime) -> Int

#
UtcTime::to_string

source
fn UtcTime::to_string(self : UtcTime) -> String

#
VtgRecord

source
pub(all) struct VtgRecord {
  talker_value : String
  true_course_value : ExactDecimal?
  magnetic_course_value : ExactDecimal?
  speed_knots_value : ExactDecimal?
  speed_kph_value : ExactDecimal?
  mode_value : String?
} derive(Eq, 
Debug)

#
VtgRecord::encode

source
fn VtgRecord::encode(self : VtgRecord) -> Result[String, NmeaError]

#
VtgRecord::magnetic_course

source
fn VtgRecord::magnetic_course(self : VtgRecord) -> ExactDecimal?

#
VtgRecord::mode

source
fn VtgRecord::mode(self : VtgRecord) -> String?

#
VtgRecord::speed_knots

source
fn VtgRecord::speed_knots(self : VtgRecord) -> ExactDecimal?

#
VtgRecord::speed_kph

source
fn VtgRecord::speed_kph(self : VtgRecord) -> ExactDecimal?

#
VtgRecord::true_course

source
fn VtgRecord::true_course(self : VtgRecord) -> ExactDecimal?

#
ZdaRecord

source
pub(all) struct ZdaRecord {
  talker_value : String
  time_value : UtcTime
  date_value : UtcDate
  local_zone_hours_value : Int
  local_zone_minutes_value : Int
} derive(Eq, 
Debug)

#
ZdaRecord::date

source
fn ZdaRecord::date(self : ZdaRecord) -> UtcDate

#
ZdaRecord::encode

source
fn ZdaRecord::encode(self : ZdaRecord) -> Result[String, NmeaError]

#
ZdaRecord::local_zone_hours

source
fn ZdaRecord::local_zone_hours(self : ZdaRecord) -> Int

#
ZdaRecord::local_zone_minutes

source
fn ZdaRecord::local_zone_minutes(self : ZdaRecord) -> Int

#
ZdaRecord::time

source
fn ZdaRecord::time(self : ZdaRecord) -> UtcTime

#
analyze_frame_batch

source
fn analyze_frame_batch(frames : Array[NmeaFrame]) -> NmeaBatch

#
analyze_track_quality

source
fn analyze_track_quality(track : Track, thresholds : QualityThresholds) -> TrackQualityReport

#
coordinate_wire_text

source
fn coordinate_wire_text(value : Coordinate) -> String

Renders the axis-specific degree width used by NMEA degree-minute fields.

#
filter_track

source
fn filter_track(track : Track, filter : TrackFilter, report? : TrackQualityReport?) -> Result[Track, NmeaError]

#
haversine_distance_meters

source
fn haversine_distance_meters(latitude1 : Double, longitude1 : Double, latitude2 : Double, longitude2 : Double) -> Result[Double, NmeaError]

#
initial_bearing_degrees

source
fn initial_bearing_degrees(latitude1 : Double, longitude1 : Double, latitude2 : Double, longitude2 : Double) -> Result[Double, NmeaError]

#
mean_earth_radius_meters

source
let mean_earth_radius_meters : Double

#
parse_batch

source
fn parse_batch(inputs : Array[String], policy? : ParsePolicy, limits? : FrameLimits) -> NmeaBatch

#
parse_frame

source
fn parse_frame(input : String, policy? : ParsePolicy, limits? : FrameLimits) -> Result[NmeaFrame, NmeaError]

Parses one complete caller-provided NMEA frame.

#
parse_gga

source
fn parse_gga(frame : NmeaFrame) -> Result[GgaRecord, NmeaError]

#
parse_gll

source
fn parse_gll(frame : NmeaFrame) -> Result[GllRecord, NmeaError]

#
parse_gsa

source
fn parse_gsa(frame : NmeaFrame) -> Result[GsaRecord, NmeaError]

#
parse_gsv

source
fn parse_gsv(frame : NmeaFrame) -> Result[GsvRecord, NmeaError]

#
parse_latitude

source
fn parse_latitude(value : String, hemisphere : String, source : SourceRef) -> Result[Coordinate, NmeaError]

#
parse_longitude

source
fn parse_longitude(value : String, hemisphere : String, source : SourceRef) -> Result[Coordinate, NmeaError]

#
parse_record

source
fn parse_record(frame : NmeaFrame) -> Result[NmeaRecord, NmeaError]

#
parse_rmc

source
fn parse_rmc(frame : NmeaFrame) -> Result[RmcRecord, NmeaError]

#
parse_sentence

source
fn parse_sentence(input : String, policy? : ParsePolicy, limits? : FrameLimits) -> Result[NmeaRecord, NmeaError]

#
parse_vtg

source
fn parse_vtg(frame : NmeaFrame) -> Result[VtgRecord, NmeaError]

#
parse_zda

source
fn parse_zda(frame : NmeaFrame) -> Result[ZdaRecord, NmeaError]

#
render_batch_json

source
fn render_batch_json(batch : NmeaBatch) -> String

#
render_batch_text

source
fn render_batch_text(batch : NmeaBatch) -> String

#
render_fused_fix_json

source
fn render_fused_fix_json(fix : FusedFix) -> String

#
render_fused_fix_text

source
fn render_fused_fix_text(fix : FusedFix) -> String

#
render_gsv_json

source
fn render_gsv_json(assembly : GsvAssembly) -> String

#
render_gsv_text

source
fn render_gsv_text(assembly : GsvAssembly) -> String

#
render_track_quality_json

source
fn render_track_quality_json(report : TrackQualityReport) -> String

#
render_track_quality_text

source
fn render_track_quality_text(report : TrackQualityReport) -> String

#
speed_meters_per_second

source
fn speed_meters_per_second(distance_meters : Double, elapsed_millis~ : Int64) -> Result[Double, NmeaError]

#
utc_date_rmc_wire

source
fn utc_date_rmc_wire(value : UtcDate) -> String

Renders the compact ddmmyy form used by RMC.

#
utc_time_wire

source
fn utc_time_wire(value : UtcTime) -> String

Renders the compact hhmmss decimal form used by NMEA fields.

#
validate_batch_integrity

source
fn validate_batch_integrity(batch : NmeaBatch) -> Array[Diagnostic]

#
validate_fused_fix_integrity

source
fn validate_fused_fix_integrity(fix : FusedFix) -> Array[Diagnostic]

#
validate_gsv_integrity

source
fn validate_gsv_integrity(assembly : GsvAssembly) -> Array[Diagnostic]

#
validate_track_integrity

source
fn validate_track_integrity(track : Track) -> Array[Diagnostic]

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io