Grcov report - cds.rs

1

//! Module to generate or read CCSDS Day Segmented (CDS) timestamps as specified in

2

//! [CCSDS 301.0-B-4](https://public.ccsds.org/Pubs/301x0b4e1.pdf) section 3.3 .

3

//!

4

//! The core data structure to do this is the [CdsTime] struct and the

5

//! [get_dyn_time_provider_from_bytes] function to retrieve correct instances of the

6

//! struct from a bytestream.

7

use crate::private::Sealed;

8

use crate::ByteConversionError;

9

use core::cmp::Ordering;

10

use core::fmt::{Debug, Display, Formatter};

11

use core::ops::{Add, AddAssign};

12

use core::time::Duration;

13

14

use delegate::delegate;

15

16

#[cfg(feature = "std")]

17

use super::StdTimestampError;

18

#[cfg(feature = "std")]

19

use std::error::Error;

20

#[cfg(feature = "std")]

21

use std::time::{SystemTime, SystemTimeError};

22

23

#[cfg(feature = "chrono")]

24

use chrono::Datelike;

25

26

#[cfg(feature = "alloc")]

27

use super::ccsds_time_code_from_p_field;

28

#[cfg(feature = "alloc")]

29

use alloc::boxed::Box;

30

#[cfg(feature = "alloc")]

31

use core::any::Any;

32

33

#[cfg(feature = "serde")]

34

use serde::{Deserialize, Serialize};

35

36

use super::{

37

    ccsds_to_unix_days, unix_to_ccsds_days, CcsdsTimeCode, CcsdsTimeProvider,

38

    DateBeforeCcsdsEpochError, TimeReader, TimeWriter, TimestampError, UnixTime, MS_PER_DAY,

39

    SECONDS_PER_DAY,

40

};

41

42

/// Base value for the preamble field for a time field parser to determine the time field type.

43

pub const P_FIELD_BASE: u8 = (CcsdsTimeCode::Cds as u8) << 4;

44

pub const MIN_CDS_FIELD_LEN: usize = 7;

45

pub const MAX_DAYS_24_BITS: u32 = 2_u32.pow(24) - 1;

46

47

/// Generic trait implemented by token structs to specify the length of day field at type

48

/// level. This trait is only meant to be implemented in this crate and therefore sealed.

49

pub trait ProvidesDaysLength: Sealed + Clone {

50

    type FieldType: Debug

51

        + Copy

52

        + Clone

53

        + PartialEq

54

        + Eq

55

        + TryFrom<i32>

56

        + TryFrom<u32>

57

        + From<u16>

58

        + Into<u32>

59

        + Into<i64>;

60

61

62

/// Type level token to be used as a generic parameter to [CdsTime].

63

#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]

64

pub struct DaysLen16Bits {}

65

66

impl Sealed for DaysLen16Bits {}

67

impl ProvidesDaysLength for DaysLen16Bits {

68

    type FieldType = u16;

69

70

71

/// Type level token to be used as a generic parameter to [CdsTime].

72

#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]

73

pub struct DaysLen24Bits {}

74

impl Sealed for DaysLen24Bits {}

75

impl ProvidesDaysLength for DaysLen24Bits {

76

    type FieldType = u32;

77

78

79

#[derive(Debug, PartialEq, Eq, Copy, Clone)]

80

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

81

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

82

pub enum LengthOfDaySegment {

83

    Short16Bits = 0,

84

    Long24Bits = 1,

85

86

87

#[derive(Debug, Copy, Clone, PartialEq, Eq)]

88

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

89

pub enum SubmillisPrecision {

90

    Absent = 0b00,

91

    Microseconds = 0b01,

92

    Picoseconds = 0b10,

93

    Reserved = 0b11,

94

95

96

#[derive(Debug, PartialEq, Eq, Copy, Clone)]

97

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

98

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

99

pub enum CdsError {

100

    /// CCSDS days value exceeds maximum allowed size or is negative

101

    InvalidCcsdsDays(i64),

102

    /// There are distinct constructors depending on the days field width detected in the preamble

103

    /// field. This error will be returned if there is a missmatch.

104

    InvalidCtorForDaysOfLenInPreamble(LengthOfDaySegment),

105

    DateBeforeCcsdsEpoch(DateBeforeCcsdsEpochError),

106

107

108

impl Display for CdsError {

109

2

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

110

2

        match self {

111

2

            CdsError::InvalidCcsdsDays(days) => {

112

2

                write!(f, "invalid ccsds days {days}")

113

114

            CdsError::InvalidCtorForDaysOfLenInPreamble(length_of_day) => {

115

                write!(

116

f,

117

                    "wrong constructor for length of day {length_of_day:?} detected in preamble",

118

119

120

            CdsError::DateBeforeCcsdsEpoch(e) => write!(f, "date before CCSDS epoch: {e}"),

121

122

2

123

124

125

#[cfg(feature = "std")]

126

impl Error for CdsError {

127

    fn source(&self) -> Option<&(dyn Error + 'static)> {

128

        match self {

129

            CdsError::DateBeforeCcsdsEpoch(e) => Some(e),

130

            _ => None,

131

132

133

134

135

impl From<DateBeforeCcsdsEpochError> for CdsError {

136

4

    fn from(value: DateBeforeCcsdsEpochError) -> Self {

137

4

        Self::DateBeforeCcsdsEpoch(value)

138

4

139

140

141

164

pub fn length_of_day_segment_from_pfield(pfield: u8) -> LengthOfDaySegment {

142

164

    if (pfield >> 2) & 0b1 == 1 {

143

62

        return LengthOfDaySegment::Long24Bits;

144

102

145

102

    LengthOfDaySegment::Short16Bits

146

164

147

148

#[inline]

149

322

pub fn precision_from_pfield(pfield: u8) -> SubmillisPrecision {

150

322

    match pfield & 0b11 {

151

50

        0b01 => SubmillisPrecision::Microseconds,

152

40

        0b10 => SubmillisPrecision::Picoseconds,

153

232

        0b00 => SubmillisPrecision::Absent,

154

        0b11 => SubmillisPrecision::Reserved,

155

        _ => panic!("pfield to SubmillisPrecision failed"),

156

157

322

158

159

/// This object is the abstraction for the CCSDS Day Segmented Time Code (CDS).

160

///

161

/// It has the capability to generate and read timestamps as specified in the CCSDS 301.0-B-4

162

/// section 3.3 . The width of the days field is configured at compile time via the generic

163

/// [ProvidesDaysLength] trait which is implemented by [DaysLen16Bits] and [DaysLen24Bits].

164

///

165

/// If you do not want to perform a forward check of the days length field with

166

/// [length_of_day_segment_from_pfield] and you have [alloc] support, you can also

167

/// use [get_dyn_time_provider_from_bytes] to retrieve the correct instance as a [DynCdsTimeProvider]

168

/// trait object.

169

///

170

/// Custom epochs are not supported yet.

171

/// Furthermore, the preamble field (p-field) is explicitly conveyed.

172

/// That means it will always be present when writing the time stamp to a raw buffer, and it

173

/// must be present when reading a CDS timestamp from a raw buffer.

174

///

175

/// # Example

176

///

177

/// ```

178

/// use core::time::Duration;

179

/// use spacepackets::time::cds::{CdsTime, length_of_day_segment_from_pfield, LengthOfDaySegment};

180

/// use spacepackets::time::{TimeWriter, CcsdsTimeCode, CcsdsTimeProvider};

181

///

182

/// let timestamp_now = CdsTime::now_with_u16_days().unwrap();

183

/// let mut raw_stamp = [0; 7];

184

/// {

185

///     let written = timestamp_now.write_to_bytes(&mut raw_stamp).unwrap();

186

///     assert_eq!((raw_stamp[0] >> 4) & 0b111, CcsdsTimeCode::Cds as u8);

187

///     assert_eq!(written, 7);

188

/// }

189

/// {

190

///     assert_eq!(length_of_day_segment_from_pfield(raw_stamp[0]), LengthOfDaySegment::Short16Bits);

191

///     let read_result = CdsTime::from_bytes_with_u16_days(&raw_stamp);

192

///     assert!(read_result.is_ok());

193

///     let stamp_deserialized = read_result.unwrap();

194

///     assert_eq!(stamp_deserialized.len_as_bytes(), 7);

195

/// }

196

/// // It is possible to add a  Duration offset to a timestamp provider. Add 5 minutes offset here

197

/// let offset = Duration::from_secs(60 * 5);

198

/// let former_unix_seconds = timestamp_now.unix_secs();

199

/// let timestamp_in_5_minutes = timestamp_now + offset;

200

/// assert_eq!(timestamp_in_5_minutes.unix_secs(), former_unix_seconds + 5 * 60);

201

/// ```

202

#[derive(Debug, Copy, Clone, Eq)]

203

2

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

204

pub struct CdsTime<DaysLen: ProvidesDaysLength = DaysLen16Bits> {

205

    pfield: u8,

206

    ccsds_days: DaysLen::FieldType,

207

    ms_of_day: u32,

208

    submillis: u32,

209

    /// This is not strictly necessary but still cached because it significantly simplifies the

210

    /// calculation of [`DateTime<Utc>`].

211

    unix_time: UnixTime,

212

213

214

/// Common properties for all CDS time providers.

215

///

216

/// Also exists to encapsulate properties used by private converters.

217

pub trait CdsCommon {

218

    fn submillis_precision(&self) -> SubmillisPrecision;

219

    fn submillis(&self) -> u32;

220

    fn ms_of_day(&self) -> u32;

221

    fn ccsds_days_as_u32(&self) -> u32;

222

223

224

/// Generic properties for all CDS time providers.

225

pub trait CdsTimestamp: CdsCommon {

226

    fn len_of_day_seg(&self) -> LengthOfDaySegment;

227

228

229

/// Private trait which serves as an abstraction for different converters.

230

trait CdsConverter: CdsCommon {

231

    fn unix_days_seconds(&self) -> i64;

232

233

234

struct ConversionFromUnix {

235

    ccsds_days: u32,

236

    ms_of_day: u32,

237

    submilis_prec: SubmillisPrecision,

238

    submillis: u32,

239

    /// This is a side-product of the calculation of the CCSDS days. It is useful for

240

    /// re-calculating the datetime at a later point and therefore supplied as well.

241

    unix_days_seconds: i64,

242

243

244

impl ConversionFromUnix {

245

42

    fn new(

246

42

        unix_seconds: i64,

247

42

        subsec_nanos: u32,

248

42

        precision: SubmillisPrecision,

249

42

    ) -> Result<Self, DateBeforeCcsdsEpochError> {

250

42

        let (unix_days, secs_of_day) = calc_unix_days_and_secs_of_day(unix_seconds);

251

42

        let ccsds_days = unix_to_ccsds_days(unix_days);

252

42

        if ccsds_days == 0 && (secs_of_day > 0 || subsec_nanos > 0) || ccsds_days < 0 {

253

2

            return Err(DateBeforeCcsdsEpochError(

254

2

                UnixTime::new_checked(unix_seconds, subsec_nanos)

255

2

                    .expect("unix timestamp creation failed"),

256

2

));

257

40

258

40

        let ms_of_day = secs_of_day * 1000 + subsec_nanos / 10_u32.pow(6);

259

260

40

        let submillis = match precision {

261

8

            SubmillisPrecision::Microseconds => (subsec_nanos / 1_000) % 1000,

262

8

            SubmillisPrecision::Picoseconds => (subsec_nanos % 10_u32.pow(6)) * 1000,

263

24

            _ => 0,

264

};

265

40

        Ok(Self {

266

40

            ccsds_days: unix_to_ccsds_days(unix_days) as u32,

267

40

            ms_of_day,

268

40

            unix_days_seconds: unix_days * SECONDS_PER_DAY as i64,

269

40

            submilis_prec: precision,

270

40

            submillis,

271

40

})

272

42

273

274

275

impl CdsCommon for ConversionFromUnix {

276

    #[inline]

277

8

    fn submillis_precision(&self) -> SubmillisPrecision {

278

8

        self.submilis_prec

279

8

280

281

    #[inline]

282

72

    fn ms_of_day(&self) -> u32 {

283

72

        self.ms_of_day

284

72

285

286

    #[inline]

287

40

    fn ccsds_days_as_u32(&self) -> u32 {

288

40

        self.ccsds_days

289

40

290

291

    #[inline]

292

8

    fn submillis(&self) -> u32 {

293

8

        self.submillis

294

8

295

296

297

impl CdsConverter for ConversionFromUnix {

298

    #[inline]

299

36

    fn unix_days_seconds(&self) -> i64 {

300

36

        self.unix_days_seconds

301

36

302

303

/// Helper struct which generates fields for the CDS time provider from a datetime.

304

struct ConversionFromChronoDatetime {

305

    unix_conversion: ConversionFromUnix,

306

    submillis_prec: SubmillisPrecision,

307

    submillis: u32,

308

309

310

impl CdsCommon for ConversionFromChronoDatetime {

311

    #[inline]

312

16

    fn submillis_precision(&self) -> SubmillisPrecision {

313

16

        self.submillis_prec

314

16

315

316

    delegate! {

317

        to self.unix_conversion {

318

            #[inline]

319

32

            fn ms_of_day(&self) -> u32;

320

            #[inline]

321

16

            fn ccsds_days_as_u32(&self) -> u32;

322

323

324

325

    #[inline]

326

16

    fn submillis(&self) -> u32 {

327

16

        self.submillis

328

16

329

330

331

impl CdsConverter for ConversionFromChronoDatetime {

332

    delegate! {to self.unix_conversion {

333

        #[inline]

334

16

        fn unix_days_seconds(&self) -> i64;

335

}}

336

337

338

#[inline]

339

42

fn calc_unix_days_and_secs_of_day(unix_seconds: i64) -> (i64, u32) {

340

42

    let mut secs_of_day = unix_seconds % SECONDS_PER_DAY as i64;

341

42

    let mut unix_days = (unix_seconds - secs_of_day) / SECONDS_PER_DAY as i64;

342

42

    // Imagine the CCSDS epoch time minus 5 seconds: We now have the last day in the year

343

42

    // 1969 (-1 unix days) shortly before midnight (SECONDS_PER_DAY - 5).

344

42

    if secs_of_day < 0 {

345

2

        unix_days -= 1;

346

2

        secs_of_day += SECONDS_PER_DAY as i64

347

40

348

42

    (unix_days, secs_of_day as u32)

349

42

350

351

#[cfg(feature = "chrono")]

352

impl ConversionFromChronoDatetime {

353

10

    fn new(dt: &chrono::DateTime<chrono::Utc>) -> Result<Self, DateBeforeCcsdsEpochError> {

354

10

        Self::new_generic(dt, SubmillisPrecision::Absent)

355

10

356

357

4

    fn new_with_submillis_us_prec(

358

4

        dt: &chrono::DateTime<chrono::Utc>,

359

4

    ) -> Result<Self, DateBeforeCcsdsEpochError> {

360

4

        Self::new_generic(dt, SubmillisPrecision::Microseconds)

361

4

362

363

4

    fn new_with_submillis_ps_prec(

364

4

        dt: &chrono::DateTime<chrono::Utc>,

365

4

    ) -> Result<Self, DateBeforeCcsdsEpochError> {

366

4

        Self::new_generic(dt, SubmillisPrecision::Picoseconds)

367

4

368

369

    #[cfg(feature = "chrono")]

370

18

    fn new_generic(

371

18

        dt: &chrono::DateTime<chrono::Utc>,

372

18

        prec: SubmillisPrecision,

373

18

    ) -> Result<Self, DateBeforeCcsdsEpochError> {

374

18

        // The CDS timestamp does not support timestamps before the CCSDS epoch.

375

18

        if dt.year() < 1958 {

376

2

            return Err(DateBeforeCcsdsEpochError(UnixTime::from(*dt)));

377

16

378

        // The contained values in the conversion should be all positive now

379

16

        let unix_conversion =

380

16

            ConversionFromUnix::new(dt.timestamp(), dt.timestamp_subsec_nanos(), prec)?;

381

16

        let mut submillis = 0;

382

16

        match prec {

383

4

            SubmillisPrecision::Microseconds => {

384

4

                submillis = dt.timestamp_subsec_micros() % 1000;

385

4

386

4

            SubmillisPrecision::Picoseconds => {

387

4

                submillis = (dt.timestamp_subsec_nanos() % 10_u32.pow(6)) * 1000;

388

4

389

8

            _ => (),

390

391

16

        Ok(Self {

392

16

            unix_conversion,

393

16

            submillis_prec: prec,

394

16

            submillis,

395

16

})

396

18

397

398

399

#[cfg(feature = "std")]

400

struct ConversionFromNow {

401

    unix_conversion: ConversionFromUnix,

402

    submillis_prec: SubmillisPrecision,

403

    submillis: u32,

404

405

406

#[cfg(feature = "std")]

407

impl ConversionFromNow {

408

6

    fn new() -> Result<Self, SystemTimeError> {

409

6

        Self::new_generic(SubmillisPrecision::Absent)

410

6

411

412

4

    fn new_with_submillis_us_prec() -> Result<Self, SystemTimeError> {

413

4

        Self::new_generic(SubmillisPrecision::Microseconds)

414

4

415

416

4

    fn new_with_submillis_ps_prec() -> Result<Self, SystemTimeError> {

417

4

        Self::new_generic(SubmillisPrecision::Picoseconds)

418

4

419

420

14

    fn new_generic(prec: SubmillisPrecision) -> Result<Self, SystemTimeError> {

421

14

        let now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)?;

422

14

        let epoch = now.as_secs();

423

14

        // This should always return a value with valid (non-negative) CCSDS days,

424

14

        // so it is okay to unwrap

425

14

        let unix_conversion =

426

14

            ConversionFromUnix::new(epoch as i64, now.subsec_nanos(), prec).unwrap();

427

14

        let mut submillis = 0;

428

14

429

14

        match prec {

430

4

            SubmillisPrecision::Microseconds => {

431

4

                submillis = now.subsec_micros() % 1000;

432

4

433

4

            SubmillisPrecision::Picoseconds => {

434

4

                submillis = (now.subsec_nanos() % 10_u32.pow(6)) * 1000;

435

4

436

6

            _ => (),

437

438

14

        Ok(Self {

439

14

            unix_conversion,

440

14

            submillis_prec: prec,

441

14

            submillis,

442

14

})

443

14

444

445

446

#[cfg(feature = "std")]

447

impl CdsCommon for ConversionFromNow {

448

12

    fn submillis_precision(&self) -> SubmillisPrecision {

449

12

        self.submillis_prec

450

12

451

    delegate! {

452

        to self.unix_conversion {

453

24

            fn ms_of_day(&self) -> u32;

454

12

            fn ccsds_days_as_u32(&self) -> u32;

455

456

457

458

12

    fn submillis(&self) -> u32 {

459

12

        self.submillis

460

12

461

462

463

#[cfg(feature = "std")]

464

impl CdsConverter for ConversionFromNow {

465

12

    delegate! {to self.unix_conversion { fn unix_days_seconds(&self) -> i64; }}

466

467

468

#[cfg(feature = "alloc")]

469

pub trait DynCdsTimeProvider: CcsdsTimeProvider + CdsTimestamp + TimeWriter + Any {}

470

#[cfg(feature = "alloc")]

471

impl DynCdsTimeProvider for CdsTime<DaysLen16Bits> {}

472

#[cfg(feature = "alloc")]

473

impl DynCdsTimeProvider for CdsTime<DaysLen24Bits> {}

474

475

/// This function returns the correct [CdsTime] instance from a raw byte array

476

/// by checking the length of days field. It also checks the CCSDS time code for correctness.

477

///

478

/// # Example

479

///

480

/// ```

481

/// use spacepackets::time::cds::{

482

///     CdsTime, LengthOfDaySegment, get_dyn_time_provider_from_bytes, SubmillisPrecision,

483

/// };

484

/// use spacepackets::time::{TimeWriter, CcsdsTimeCode, CcsdsTimeProvider};

485

///

486

/// let timestamp_now = CdsTime::new_with_u16_days(24, 24);

487

/// let mut raw_stamp = [0; 7];

488

/// {

489

///     let written = timestamp_now.write_to_bytes(&mut raw_stamp).unwrap();

490

///     assert_eq!((raw_stamp[0] >> 4) & 0b111, CcsdsTimeCode::Cds as u8);

491

///     assert_eq!(written, 7);

492

/// }

493

/// {

494

///     let dyn_provider = get_dyn_time_provider_from_bytes(&raw_stamp).unwrap();

495

///     assert_eq!(dyn_provider.len_of_day_seg(), LengthOfDaySegment::Short16Bits);

496

///     assert_eq!(dyn_provider.ccsds_days_as_u32(), 24);

497

///     assert_eq!(dyn_provider.ms_of_day(), 24);

498

///     assert_eq!(dyn_provider.submillis_precision(), SubmillisPrecision::Absent);

499

/// }

500

/// ```

501

#[cfg(feature = "alloc")]

502

4

pub fn get_dyn_time_provider_from_bytes(

503

4

    buf: &[u8],

504

4

) -> Result<Box<dyn DynCdsTimeProvider>, TimestampError> {

505

4

    let time_code = ccsds_time_code_from_p_field(buf[0]);

506

4

    if let Err(e) = time_code {

507

        return Err(TimestampError::InvalidTimeCode {

508

            expected: CcsdsTimeCode::Cds,

509

            found: e,

510

});

511

4

512

4

    let time_code = time_code.unwrap();

513

4

    if time_code != CcsdsTimeCode::Cds {

514

        return Err(TimestampError::InvalidTimeCode {

515

            expected: CcsdsTimeCode::Cds,

516

            found: time_code as u8,

517

});

518

4

519

4

    if length_of_day_segment_from_pfield(buf[0]) == LengthOfDaySegment::Short16Bits {

520

2

        Ok(Box::new(CdsTime::from_bytes_with_u16_days(buf)?))

521

    } else {

522

2

        Ok(Box::new(CdsTime::from_bytes_with_u24_days(buf)?))

523

524

4

525

526

impl<ProvidesDaysLen: ProvidesDaysLength> CdsCommon for CdsTime<ProvidesDaysLen> {

527

304

    fn submillis_precision(&self) -> SubmillisPrecision {

528

304

        precision_from_pfield(self.pfield)

529

304

530

531

32

    fn ms_of_day(&self) -> u32 {

532

32

        self.ms_of_day

533

32

534

535

62

    fn ccsds_days_as_u32(&self) -> u32 {

536

62

        self.ccsds_days.into()

537

62

538

539

72

    fn submillis(&self) -> u32 {

540

72

        self.submillis

541

72

542

543

544

impl<ProvidesDaysLen: ProvidesDaysLength> CdsTime<ProvidesDaysLen> {

545

    /// Please note that a precision value of 0 will be converted to [None] (no precision).

546

46

    pub fn set_submillis(&mut self, prec: SubmillisPrecision, value: u32) -> bool {

547

46

        self.pfield &= !(0b11);

548

46

        if let SubmillisPrecision::Absent = prec {

549

            // self.submillis_precision = prec;

550

6

            self.submillis = 0;

551

6

            return true;

552

40

553

40

        // self.submillis_precision = prec;

554

40

        match prec {

555

            SubmillisPrecision::Microseconds => {

556

24

                if value > u16::MAX as u32 {

557

                    return false;

558

24

559

24

                self.pfield |= SubmillisPrecision::Microseconds as u8;

560

24

                self.submillis = value;

561

562

16

            SubmillisPrecision::Picoseconds => {

563

16

                self.pfield |= SubmillisPrecision::Picoseconds as u8;

564

16

                self.submillis = value;

565

16

566

            _ => (),

567

568

40

        true

569

46

570

571

    pub fn clear_submillis(&mut self) {

572

        self.pfield &= !(0b11);

573

        self.submillis = 0;

574

575

576

8

    pub fn ccsds_days(&self) -> ProvidesDaysLen::FieldType {

577

8

        self.ccsds_days

578

8

579

580

    /// Maps the submillisecond precision to a nanosecond value. This will reduce precision when

581

    /// using picosecond resolution, but significantly simplifies comparison of timestamps.

582

186

    pub fn precision_as_ns(&self) -> Option<u32> {

583

186

        match self.submillis_precision() {

584

12

            SubmillisPrecision::Microseconds => Some(self.submillis * 1000),

585

8

            SubmillisPrecision::Picoseconds => Some(self.submillis / 1000),

586

166

            _ => None,

587

588

186

589

590

34

    fn generic_raw_read_checks(

591

34

        buf: &[u8],

592

34

        days_len: LengthOfDaySegment,

593

34

    ) -> Result<SubmillisPrecision, TimestampError> {

594

34

        if buf.len() < MIN_CDS_FIELD_LEN {

595

12

            return Err(TimestampError::ByteConversion(

596

12

                ByteConversionError::FromSliceTooSmall {

597

12

                    expected: MIN_CDS_FIELD_LEN,

598

12

                    found: buf.len(),

599

12

},

600

12

));

601

22

602

22

        let pfield = buf[0];

603

22

        match CcsdsTimeCode::try_from(pfield >> 4 & 0b111) {

604

20

            Ok(cds_type) => match cds_type {

605

20

                CcsdsTimeCode::Cds => (),

606

                _ => {

607

                    return Err(TimestampError::InvalidTimeCode {

608

                        expected: CcsdsTimeCode::Cds,

609

                        found: cds_type as u8,

610

})

611

612

},

613

            _ => {

614

2

                return Err(TimestampError::InvalidTimeCode {

615

2

                    expected: CcsdsTimeCode::Cds,

616

2

                    found: pfield >> 4 & 0b111,

617

2

});

618

619

};

620

20

        if ((pfield >> 3) & 0b1) == 1 {

621

            return Err(TimestampError::CustomEpochNotSupported);

622

20

623

20

        let days_len_from_pfield = length_of_day_segment_from_pfield(pfield);

624

20

        if days_len_from_pfield != days_len {

625

2

            return Err(CdsError::InvalidCtorForDaysOfLenInPreamble(days_len_from_pfield).into());

626

18

627

18

        let stamp_len = Self::calc_stamp_len(pfield);

628

18

        if buf.len() < stamp_len {

629

            return Err(TimestampError::ByteConversion(

630

                ByteConversionError::FromSliceTooSmall {

631

                    expected: stamp_len,

632

                    found: buf.len(),

633

},

634

));

635

18

636

18

        Ok(precision_from_pfield(pfield))

637

34

638

639

140

    fn calc_stamp_len(pfield: u8) -> usize {

640

140

        let mut init_len = 7;

641

140

        if length_of_day_segment_from_pfield(pfield) == LengthOfDaySegment::Long24Bits {

642

50

            init_len += 1

643

90

644

140

        match pfield & 0b11 {

645

26

            0b01 => {

646

26

                init_len += 2;

647

26

648

20

            0b10 => {

649

20

                init_len += 4;

650

20

651

94

            _ => (),

652

653

140

        init_len

654

140

655

656

154

    fn setup(&mut self, unix_days_seconds: i64, ms_of_day: u32) {

657

154

        self.calc_unix_seconds(unix_days_seconds, ms_of_day);

658

154

659

660

    #[inline]

661

154

    fn calc_unix_seconds(&mut self, mut unix_days_seconds: i64, ms_of_day: u32) {

662

154

        let seconds_of_day = (ms_of_day / 1000) as i64;

663

154

        if unix_days_seconds < 0 {

664

74

            unix_days_seconds -= seconds_of_day;

665

80

        } else {

666

80

            unix_days_seconds += seconds_of_day;

667

80

668

154

        let mut subsec_nanos = (ms_of_day % 1000) * 10_u32.pow(6);

669

154

        if let Some(precision) = self.precision_as_ns() {

670

16

            subsec_nanos += precision;

671

138

672

154

        self.unix_time = UnixTime::new(unix_days_seconds, subsec_nanos);

673

154

674

675

58

    fn length_check(&self, buf: &[u8], len_as_bytes: usize) -> Result<(), TimestampError> {

676

58

        if buf.len() < len_as_bytes {

677

12

            return Err(TimestampError::ByteConversion(

678

12

                ByteConversionError::ToSliceTooSmall {

679

12

                    expected: len_as_bytes,

680

12

                    found: buf.len(),

681

12

},

682

12

));

683

46

684

46

        Ok(())

685

58

686

687

116

    fn generic_new(

688

116

        days_len: LengthOfDaySegment,

689

116

        ccsds_days: ProvidesDaysLen::FieldType,

690

116

        ms_of_day: u32,

691

116

    ) -> Result<Self, CdsError>

692

116

    where

693

116

        i64: From<ProvidesDaysLen::FieldType>,

694

116

695

116

        let mut provider = Self {

696

116

            pfield: Self::generate_p_field(days_len, SubmillisPrecision::Absent),

697

116

            ccsds_days,

698

116

            ms_of_day,

699

116

            unix_time: Default::default(),

700

116

            submillis: 0,

701

116

};

702

116

        let unix_days_seconds = ccsds_to_unix_days(i64::from(ccsds_days)) * SECONDS_PER_DAY as i64;

703

116

        provider.setup(unix_days_seconds, ms_of_day);

704

116

        Ok(provider)

705

116

706

707

    #[cfg(feature = "chrono")]

708

6

    fn from_dt_generic(

709

6

        dt: &chrono::DateTime<chrono::Utc>,

710

6

        days_len: LengthOfDaySegment,

711

6

    ) -> Result<Self, CdsError> {

712

6

        let conv_from_dt = ConversionFromChronoDatetime::new(dt)?;

713

4

        Self::generic_from_conversion(days_len, conv_from_dt)

714

6

715

716

    #[cfg(feature = "chrono")]

717

4

    fn from_dt_generic_us_prec(

718

4

        dt: &chrono::DateTime<chrono::Utc>,

719

4

        days_len: LengthOfDaySegment,

720

4

    ) -> Result<Self, CdsError> {

721

4

        let conv_from_dt = ConversionFromChronoDatetime::new_with_submillis_us_prec(dt)?;

722

4

        Self::generic_from_conversion(days_len, conv_from_dt)

723

4

724

725

    #[cfg(feature = "chrono")]

726

4

    fn from_dt_generic_ps_prec(

727

4

        dt: &chrono::DateTime<chrono::Utc>,

728

4

        days_len: LengthOfDaySegment,

729

4

    ) -> Result<Self, CdsError> {

730

4

        let conv_from_dt = ConversionFromChronoDatetime::new_with_submillis_ps_prec(dt)?;

731

4

        Self::generic_from_conversion(days_len, conv_from_dt)

732

4

733

734

12

    fn from_unix_generic(

735

12

        unix_stamp: &UnixTime,

736

12

        days_len: LengthOfDaySegment,

737

12

        submillis_prec: SubmillisPrecision,

738

12

    ) -> Result<Self, CdsError> {

739

10

        let conv_from_dt =

740

12

            ConversionFromUnix::new(unix_stamp.secs, unix_stamp.subsec_nanos, submillis_prec)?;

741

10

        Self::generic_from_conversion(days_len, conv_from_dt)

742

12

743

744

    #[cfg(feature = "std")]

745

4

    fn now_generic(days_len: LengthOfDaySegment) -> Result<Self, StdTimestampError> {

746

4

        let conversion_from_now = ConversionFromNow::new()?;

747

4

        Self::generic_from_conversion(days_len, conversion_from_now)

748

4

            .map_err(|e| StdTimestampError::Timestamp(TimestampError::from(e)))

749

4

750

751

    #[cfg(feature = "std")]

752

4

    fn now_generic_with_us_prec(days_len: LengthOfDaySegment) -> Result<Self, StdTimestampError> {

753

4

        let conversion_from_now = ConversionFromNow::new_with_submillis_us_prec()?;

754

4

        Self::generic_from_conversion(days_len, conversion_from_now)

755

4

            .map_err(|e| StdTimestampError::Timestamp(TimestampError::from(e)))

756

4

757

758

    #[cfg(feature = "std")]

759

4

    fn from_now_generic_ps_prec(days_len: LengthOfDaySegment) -> Result<Self, StdTimestampError> {

760

4

        let conversion_from_now = ConversionFromNow::new_with_submillis_ps_prec()?;

761

4

        Self::generic_from_conversion(days_len, conversion_from_now)

762

4

            .map_err(|e| StdTimestampError::Timestamp(TimestampError::from(e)))

763

4

764

765

38

    fn generic_from_conversion<C: CdsConverter>(

766

38

        days_len: LengthOfDaySegment,

767

38

        converter: C,

768

38

    ) -> Result<Self, CdsError> {

769

38

        let ccsds_days: ProvidesDaysLen::FieldType = converter

770

38

            .ccsds_days_as_u32()

771

38

            .try_into()

772

38

            .map_err(|_| CdsError::InvalidCcsdsDays(converter.ccsds_days_as_u32().into()))?;

773

36

        let mut provider = Self {

774

36

            pfield: Self::generate_p_field(days_len, converter.submillis_precision()),

775

36

            ccsds_days,

776

36

            ms_of_day: converter.ms_of_day(),

777

36

            unix_time: Default::default(),

778

36

            submillis: converter.submillis(),

779

36

};

780

36

        provider.setup(converter.unix_days_seconds(), converter.ms_of_day());

781

36

        Ok(provider)

782

38

783

784

    #[cfg(feature = "std")]

785

2

    fn generic_conversion_from_now(&self) -> Result<ConversionFromNow, SystemTimeError> {

786

2

        Ok(match self.submillis_precision() {

787

            SubmillisPrecision::Microseconds => ConversionFromNow::new_with_submillis_us_prec()?,

788

            SubmillisPrecision::Picoseconds => ConversionFromNow::new_with_submillis_ps_prec()?,

789

2

            _ => ConversionFromNow::new()?,

790

})

791

2

792

793

152

    fn generate_p_field(day_seg_len: LengthOfDaySegment, submillis_prec: SubmillisPrecision) -> u8 {

794

152

        let mut pfield = P_FIELD_BASE | ((day_seg_len as u8) << 2);

795

152

        match submillis_prec {

796

8

            SubmillisPrecision::Microseconds => pfield |= SubmillisPrecision::Microseconds as u8,

797

8

            SubmillisPrecision::Picoseconds => pfield |= SubmillisPrecision::Picoseconds as u8,

798

            SubmillisPrecision::Reserved => pfield |= SubmillisPrecision::Reserved as u8,

799

136

            _ => (),

800

801

152

        pfield

802

152

803

804

    #[cfg(feature = "std")]

805

2

    pub fn update_from_now(&mut self) -> Result<(), StdTimestampError> {

806

2

        let conversion_from_now = self.generic_conversion_from_now()?;

807

2

        let ccsds_days: ProvidesDaysLen::FieldType = conversion_from_now

808

2

            .unix_conversion

809

2

            .ccsds_days

810

2

            .try_into()

811

2

            .map_err(|_| {

812

                StdTimestampError::Timestamp(

813

                    CdsError::InvalidCcsdsDays(

814

                        conversion_from_now.unix_conversion.ccsds_days as i64,

815

816

                    .into(),

817

818

2

            })?;

819

2

        self.ccsds_days = ccsds_days;

820

2

        self.ms_of_day = conversion_from_now.unix_conversion.ms_of_day;

821

2

        self.setup(

822

2

            conversion_from_now.unix_conversion.unix_days_seconds,

823

2

            conversion_from_now.unix_conversion.ms_of_day,

824

2

);

825

2

        Ok(())

826

2

827

828

829

impl CdsTime<DaysLen24Bits> {

830

    /// Generate a new timestamp provider with the days field width set to 24 bits

831

38

    pub fn new_with_u24_days(ccsds_days: u32, ms_of_day: u32) -> Result<Self, CdsError> {

832

38

        if ccsds_days > MAX_DAYS_24_BITS {

833

2

            return Err(CdsError::InvalidCcsdsDays(ccsds_days.into()));

834

36

835

36

        Self::generic_new(LengthOfDaySegment::Long24Bits, ccsds_days, ms_of_day)

836

38

837

838

    /// Generate a time stamp from the current time using the system clock.

839

    #[cfg(feature = "std")]

840

    pub fn now_with_u24_days() -> Result<Self, StdTimestampError> {

841

        Self::now_generic(LengthOfDaySegment::Long24Bits)

842

843

844

    /// Create a provider from a [`chrono::DateTime<chrono::Utc>`] struct.

845

///

846

    /// ## Errors

847

///

848

    /// This function will return [CdsError::DateBeforeCcsdsEpoch] if the time is before the CCSDS

849

    /// epoch (1958-01-01T00:00:00+00:00) or the CCSDS days value exceeds the allowed bit width

850

    /// (24 bits).

851

    #[cfg(feature = "chrono")]

852

4

    pub fn from_dt_with_u24_days(dt: &chrono::DateTime<chrono::Utc>) -> Result<Self, CdsError> {

853

4

        Self::from_dt_generic(dt, LengthOfDaySegment::Long24Bits)

854

4

855

856

    /// Create a provider from a generic UNIX timestamp (seconds since 1970-01-01T00:00:00+00:00).

857

///

858

    /// ## Errors

859

///

860

    /// This function will return [CdsError::DateBeforeCcsdsEpoch] if the time is before the CCSDS

861

    /// epoch (1958-01-01T00:00:00+00:00) or the CCSDS days value exceeds the allowed bit width

862

    /// (24 bits).

863

2

    pub fn from_unix_time_with_u24_day(

864

2

        unix_stamp: &UnixTime,

865

2

        submillis_prec: SubmillisPrecision,

866

2

    ) -> Result<Self, CdsError> {

867

2

        Self::from_unix_generic(unix_stamp, LengthOfDaySegment::Long24Bits, submillis_prec)

868

2

869

870

    /// Like [Self::from_dt_with_u24_days] but with microsecond sub-millisecond precision.

871

    #[cfg(feature = "chrono")]

872

2

    pub fn from_dt_with_u24_days_us_precision(

873

2

        dt: &chrono::DateTime<chrono::Utc>,

874

2

    ) -> Result<Self, CdsError> {

875

2

        Self::from_dt_generic_us_prec(dt, LengthOfDaySegment::Long24Bits)

876

2

877

878

    /// Like [Self::from_dt_with_u24_days] but with picoseconds sub-millisecond precision.

879

    #[cfg(feature = "chrono")]

880

2

    pub fn from_dt_with_u24_days_ps_precision(

881

2

        dt: &chrono::DateTime<chrono::Utc>,

882

2

    ) -> Result<Self, CdsError> {

883

2

        Self::from_dt_generic_ps_prec(dt, LengthOfDaySegment::Long24Bits)

884

2

885

886

    /// Like [Self::now_with_u24_days] but with microsecond sub-millisecond precision.

887

    #[cfg(feature = "std")]

888

    pub fn now_with_u24_days_us_precision() -> Result<Self, StdTimestampError> {

889

        Self::now_generic_with_us_prec(LengthOfDaySegment::Long24Bits)

890

891

892

    /// Like [Self::now_with_u24_days] but with picoseconds sub-millisecond precision.

893

    #[cfg(feature = "std")]

894

2

    pub fn now_with_u24_days_ps_precision() -> Result<Self, StdTimestampError> {

895

2

        Self::now_generic_with_us_prec(LengthOfDaySegment::Long24Bits)

896

2

897

898

8

    pub fn from_bytes_with_u24_days(buf: &[u8]) -> Result<Self, TimestampError> {

899

8

        let submillis_precision =

900

8

            Self::generic_raw_read_checks(buf, LengthOfDaySegment::Long24Bits)?;

901

8

        let mut temp_buf: [u8; 4] = [0; 4];

902

8

        temp_buf[1..4].copy_from_slice(&buf[1..4]);

903

8

        let cccsds_days: u32 = u32::from_be_bytes(temp_buf);

904

8

        let ms_of_day: u32 = u32::from_be_bytes(buf[4..8].try_into().unwrap());

905

8

        let mut provider = Self::new_with_u24_days(cccsds_days, ms_of_day)?;

906

8

        match submillis_precision {

907

2

            SubmillisPrecision::Microseconds => {

908

2

                provider.set_submillis(

909

2

                    SubmillisPrecision::Microseconds,

910

2

                    u16::from_be_bytes(buf[8..10].try_into().unwrap()) as u32,

911

2

);

912

2

913

2

            SubmillisPrecision::Picoseconds => {

914

2

                provider.set_submillis(

915

2

                    SubmillisPrecision::Picoseconds,

916

2

                    u32::from_be_bytes(buf[8..12].try_into().unwrap()),

917

2

);

918

2

919

4

            _ => (),

920

921

8

        Ok(provider)

922

8

923

924

925

impl CdsTime<DaysLen16Bits> {

926

    /// Generate a new timestamp provider with the days field width set to 16 bits

927

80

    pub fn new_with_u16_days(ccsds_days: u16, ms_of_day: u32) -> Self {

928

80

        // This should never fail, type system ensures CCSDS can not be negative or too large

929

80

        Self::generic_new(LengthOfDaySegment::Short16Bits, ccsds_days, ms_of_day).unwrap()

930

80

931

932

    /// Create a provider from a [`chrono::DateTime<Utc>`] struct.

933

///

934

    /// This function will return a [CdsError::DateBeforeCcsdsEpoch] if the time is before the

935

    /// CCSDS epoch (01-01-1958 00:00:00) or the CCSDS days value exceeds the allowed bit width

936

    /// (16 bits).

937

    #[cfg(feature = "chrono")]

938

2

    pub fn from_dt_with_u16_days(dt: &chrono::DateTime<chrono::Utc>) -> Result<Self, CdsError> {

939

2

        Self::from_dt_generic(dt, LengthOfDaySegment::Short16Bits)

940

2

941

942

    /// Generate a time stamp from the current time using the system clock.

943

    #[cfg(feature = "std")]

944

4

    pub fn now_with_u16_days() -> Result<Self, StdTimestampError> {

945

4

        Self::now_generic(LengthOfDaySegment::Short16Bits)

946

4

947

948

    /// Create a provider from a generic UNIX timestamp (seconds since 1970-01-01T00:00:00+00:00).

949

///

950

    /// ## Errors

951

///

952

    /// This function will return [CdsError::DateBeforeCcsdsEpoch] if the time is before the CCSDS

953

    /// epoch (1958-01-01T00:00:00+00:00) or the CCSDS days value exceeds the allowed bit width

954

    /// (24 bits).

955

10

    pub fn from_unix_time_with_u16_days(

956

10

        unix_stamp: &UnixTime,

957

10

        submillis_prec: SubmillisPrecision,

958

10

    ) -> Result<Self, CdsError> {

959

10

        Self::from_unix_generic(unix_stamp, LengthOfDaySegment::Short16Bits, submillis_prec)

960

10

961

962

    /// Like [Self::from_dt_with_u16_days] but with microsecond sub-millisecond precision.

963

    #[cfg(feature = "chrono")]

964

2

    pub fn from_dt_with_u16_days_us_precision(

965

2

        dt: &chrono::DateTime<chrono::Utc>,

966

2

    ) -> Result<Self, CdsError> {

967

2

        Self::from_dt_generic_us_prec(dt, LengthOfDaySegment::Short16Bits)

968

2

969

970

    /// Like [Self::from_dt_with_u16_days] but with picoseconds sub-millisecond precision.

971

    #[cfg(feature = "chrono")]

972

2

    pub fn from_dt_with_u16_days_ps_precision(

973

2

        dt: &chrono::DateTime<chrono::Utc>,

974

2

    ) -> Result<Self, CdsError> {

975

2

        Self::from_dt_generic_ps_prec(dt, LengthOfDaySegment::Short16Bits)

976

2

977

978

    /// Like [Self::now_with_u16_days] but with microsecond sub-millisecond precision.

979

    #[cfg(feature = "std")]

980

2

    pub fn now_with_u16_days_us_precision() -> Result<Self, StdTimestampError> {

981

2

        Self::now_generic_with_us_prec(LengthOfDaySegment::Short16Bits)

982

2

983

984

    /// Like [Self::now_with_u16_days] but with picosecond sub-millisecond precision.

985

    #[cfg(feature = "std")]

986

4

    pub fn from_now_with_u16_days_ps_precision() -> Result<Self, StdTimestampError> {

987

4

        Self::from_now_generic_ps_prec(LengthOfDaySegment::Short16Bits)

988

4

989

990

26

    pub fn from_bytes_with_u16_days(buf: &[u8]) -> Result<Self, TimestampError> {

991

10

        let submillis_precision =

992

26

            Self::generic_raw_read_checks(buf, LengthOfDaySegment::Short16Bits)?;

993

10

        let ccsds_days: u16 = u16::from_be_bytes(buf[1..3].try_into().unwrap());

994

10

        let ms_of_day: u32 = u32::from_be_bytes(buf[3..7].try_into().unwrap());

995

10

        let mut provider = Self::new_with_u16_days(ccsds_days, ms_of_day);

996

10

        provider.pfield = buf[0];

997

10

998

10

        match submillis_precision {

999

4

            SubmillisPrecision::Microseconds => {

1000

4

                provider.set_submillis(

1001

4

                    SubmillisPrecision::Microseconds,

1002

4

                    u16::from_be_bytes(buf[7..9].try_into().unwrap()) as u32,

1003

4

);

1004

4

1005

2

            SubmillisPrecision::Picoseconds => {

1006

2

                provider.set_submillis(

1007

2

                    SubmillisPrecision::Picoseconds,

1008

2

                    u32::from_be_bytes(buf[7..11].try_into().unwrap()),

1009

2

);

1010

2

1011

4

            _ => (),

1012

1013

10

        Ok(provider)

1014

26

1015

1016

1017

24

fn add_for_max_ccsds_days_val<T: ProvidesDaysLength>(

1018

24

    time_provider: &CdsTime<T>,

1019

24

    max_days_val: u32,

1020

24

    duration: Duration,

1021

24

) -> (u32, u32, u32) {

1022

24

    let mut next_ccsds_days = time_provider.ccsds_days_as_u32();

1023

24

    let mut next_ms_of_day = time_provider.ms_of_day;

1024

24

    // Increment CCSDS days by a certain amount while also accounting for overflow.

1025

26

    let increment_days = |ccsds_days: &mut u32, days_inc: u32| {

1026

26

        let days_addition: u64 = *ccsds_days as u64 + days_inc as u64;

1027

26

        if days_addition > max_days_val as u64 {

1028

            *ccsds_days = (days_addition - max_days_val as u64) as u32;

1029

26

        } else {

1030

26

            *ccsds_days += days_inc;

1031

26

1032

26

};

1033

    // Increment MS of day by a certain amount while also accounting for overflow, where

1034

    // the new value exceeds the MS of a day.

1035

52

    let increment_ms_of_day = |ms_of_day: &mut u32, ms_inc: u32, ccsds_days: &mut u32| {

1036

52

        *ms_of_day += ms_inc;

1037

52

        if *ms_of_day >= MS_PER_DAY {

1038

2

            *ms_of_day -= MS_PER_DAY;

1039

2

            // Re-use existing closure to always amount for overflow.

1040

2

            increment_days(ccsds_days, 1);

1041

50

1042

52

};

1043

24

    let mut submillis = time_provider.submillis();

1044

24

    match time_provider.submillis_precision() {

1045

        SubmillisPrecision::Microseconds => {

1046

6

            let subsec_micros = duration.subsec_micros();

1047

6

            let subsec_millis = subsec_micros / 1000;

1048

6

            let submilli_micros = subsec_micros % 1000;

1049

6

            submillis += submilli_micros;

1050

6

            if submillis >= 1000 {

1051

2

                let carryover_us = submillis - 1000;

1052

2

                increment_ms_of_day(&mut next_ms_of_day, 1, &mut next_ccsds_days);

1053

2

                submillis = carryover_us;

1054

4

1055

6

            increment_ms_of_day(&mut next_ms_of_day, subsec_millis, &mut next_ccsds_days);

1056

1057

        SubmillisPrecision::Picoseconds => {

1058

6

            let subsec_nanos = duration.subsec_nanos();

1059

6

            let subsec_millis = subsec_nanos / 10_u32.pow(6);

1060

6

            // 1 ms as ns is 1e6.

1061

6

            let submilli_nanos = subsec_nanos % 10_u32.pow(6);

1062

6

            // No overflow risk: The maximum value of an u32 is ~4.294e9, and one ms as ps

1063

6

            // is 1e9. The amount ps can now have is always less than 2e9.

1064

6

            submillis += submilli_nanos * 1000;

1065

6

            if submillis >= 10_u32.pow(9) {

1066

2

                let carry_over_ps = submillis - 10_u32.pow(9);

1067

2

                increment_ms_of_day(&mut next_ms_of_day, 1, &mut next_ccsds_days);

1068

2

                submillis = carry_over_ps;

1069

4

1070

6

            increment_ms_of_day(&mut next_ms_of_day, subsec_millis, &mut next_ccsds_days);

1071

1072

12

        _ => {

1073

12

            increment_ms_of_day(

1074

12

                &mut next_ms_of_day,

1075

12

                duration.subsec_millis(),

1076

12

                &mut next_ccsds_days,

1077

12

);

1078

12

1079

1080

    // The subsecond millisecond were already handled.

1081

24

    let full_seconds = duration.as_secs();

1082

24

    let secs_of_day = (full_seconds % SECONDS_PER_DAY as u64) as u32;

1083

24

    let ms_of_day = secs_of_day * 1000;

1084

24

    increment_ms_of_day(&mut next_ms_of_day, ms_of_day, &mut next_ccsds_days);

1085

24

    increment_days(

1086

24

        &mut next_ccsds_days,

1087

24

        (full_seconds as u32 - secs_of_day) / SECONDS_PER_DAY,

1088

24

);

1089

24

    (next_ccsds_days, next_ms_of_day, submillis)

1090

24

1091

1092

impl CdsTimestamp for CdsTime<DaysLen16Bits> {

1093

2

    fn len_of_day_seg(&self) -> LengthOfDaySegment {

1094

2

        LengthOfDaySegment::Short16Bits

1095

2

1096

1097

1098

impl CdsTimestamp for CdsTime<DaysLen24Bits> {

1099

2

    fn len_of_day_seg(&self) -> LengthOfDaySegment {

1100

2

        LengthOfDaySegment::Long24Bits

1101

2

1102

1103

1104

/// Allows adding an duration in form of an offset. Please note that the CCSDS days will rollover

1105

/// when they overflow, because addition needs to be infallible. The user needs to check for a

1106

/// days overflow when this is a possibility and might be a problem.

1107

impl Add<Duration> for CdsTime<DaysLen16Bits> {

1108

    type Output = Self;

1109

1110

2

    fn add(self, duration: Duration) -> Self::Output {

1111

2

        let (next_ccsds_days, next_ms_of_day, precision) =

1112

2

            add_for_max_ccsds_days_val(&self, u16::MAX as u32, duration);

1113

2

        let mut provider = Self::new_with_u16_days(next_ccsds_days as u16, next_ms_of_day);

1114

2

        provider.set_submillis(self.submillis_precision(), precision);

1115

2

        provider

1116

2

1117

1118

1119

impl Add<Duration> for &CdsTime<DaysLen16Bits> {

1120

    type Output = CdsTime<DaysLen16Bits>;

1121

1122

2

    fn add(self, duration: Duration) -> Self::Output {

1123

2

        let (next_ccsds_days, next_ms_of_day, precision) =

1124

2

            add_for_max_ccsds_days_val(self, u16::MAX as u32, duration);

1125

2

        let mut provider = Self::Output::new_with_u16_days(next_ccsds_days as u16, next_ms_of_day);

1126

2

        provider.set_submillis(self.submillis_precision(), precision);

1127

2

        provider

1128

2

1129

1130

1131

/// Allows adding an duration in form of an offset. Please note that the CCSDS days will rollover

1132

/// when they overflow, because addition needs to be infallible. The user needs to check for a

1133

/// days overflow when this is a possibility and might be a problem.

1134

impl Add<Duration> for CdsTime<DaysLen24Bits> {

1135

    type Output = Self;

1136

1137

2

    fn add(self, duration: Duration) -> Self::Output {

1138

2

        let (next_ccsds_days, next_ms_of_day, precision) =

1139

2

            add_for_max_ccsds_days_val(&self, MAX_DAYS_24_BITS, duration);

1140

2

        let mut provider = Self::new_with_u24_days(next_ccsds_days, next_ms_of_day).unwrap();

1141

2

        provider.set_submillis(self.submillis_precision(), precision);

1142

2

        provider

1143

2

1144

1145

1146

impl Add<Duration> for &CdsTime<DaysLen24Bits> {

1147

    type Output = CdsTime<DaysLen24Bits>;

1148

    fn add(self, duration: Duration) -> Self::Output {

1149

        let (next_ccsds_days, next_ms_of_day, precision) =

1150

            add_for_max_ccsds_days_val(self, MAX_DAYS_24_BITS, duration);

1151

        let mut provider =

1152

            Self::Output::new_with_u24_days(next_ccsds_days, next_ms_of_day).unwrap();

1153

        provider.set_submillis(self.submillis_precision(), precision);

1154

        provider

1155

1156

1157

1158

/// Allows adding an duration in form of an offset. Please note that the CCSDS days will rollover

1159

/// when they overflow, because addition needs to be infallible. The user needs to check for a

1160

/// days overflow when this is a possibility and might be a problem.

1161

impl AddAssign<Duration> for CdsTime<DaysLen16Bits> {

1162

16

    fn add_assign(&mut self, duration: Duration) {

1163

16

        let (next_ccsds_days, next_ms_of_day, submillis) =

1164

16

            add_for_max_ccsds_days_val(self, u16::MAX as u32, duration);

1165

16

        self.ccsds_days = next_ccsds_days as u16;

1166

16

        self.ms_of_day = next_ms_of_day;

1167

16

        self.submillis = submillis;

1168

16

1169

1170

1171

/// Allows adding an duration in form of an offset. Please note that the CCSDS days will rollover

1172

/// when they overflow, because addition needs to be infallible. The user needs to check for a

1173

/// days overflow when this is a possibility and might be a problem.

1174

impl AddAssign<Duration> for CdsTime<DaysLen24Bits> {

1175

2

    fn add_assign(&mut self, duration: Duration) {

1176

2

        let (next_ccsds_days, next_ms_of_day, submillis) =

1177

2

            add_for_max_ccsds_days_val(self, MAX_DAYS_24_BITS, duration);

1178

2

        self.ccsds_days = next_ccsds_days;

1179

2

        self.ms_of_day = next_ms_of_day;

1180

2

        self.submillis = submillis;

1181

2

1182

1183

1184

#[cfg(feature = "chrono")]

1185

impl TryFrom<chrono::DateTime<chrono::Utc>> for CdsTime<DaysLen16Bits> {

1186

    type Error = CdsError;

1187

1188

2

    fn try_from(dt: chrono::DateTime<chrono::Utc>) -> Result<Self, Self::Error> {

1189

2

        let conversion = ConversionFromChronoDatetime::new(&dt)?;

1190

2

        Self::generic_from_conversion(LengthOfDaySegment::Short16Bits, conversion)

1191

2

1192

1193

1194

#[cfg(feature = "chrono")]

1195

impl TryFrom<chrono::DateTime<chrono::Utc>> for CdsTime<DaysLen24Bits> {

1196

    type Error = CdsError;

1197

2

    fn try_from(dt: chrono::DateTime<chrono::Utc>) -> Result<Self, Self::Error> {

1198

2

        let conversion = ConversionFromChronoDatetime::new(&dt)?;

1199

2

        Self::generic_from_conversion(LengthOfDaySegment::Long24Bits, conversion)

1200

2

1201

1202

1203

impl<ProvidesDaysLen: ProvidesDaysLength> CcsdsTimeProvider for CdsTime<ProvidesDaysLen> {

1204

122

    fn len_as_bytes(&self) -> usize {

1205

122

        Self::calc_stamp_len(self.pfield)

1206

122

1207

1208

2

    fn p_field(&self) -> (usize, [u8; 2]) {

1209

2

        (1, [self.pfield, 0])

1210

2

1211

1212

6

    fn ccdsd_time_code(&self) -> CcsdsTimeCode {

1213

6

        CcsdsTimeCode::Cds

1214

6

1215

1216

    #[inline]

1217

30

    fn unix_secs(&self) -> i64 {

1218

30

        self.unix_time.secs

1219

30

1220

    #[inline]

1221

40

    fn subsec_nanos(&self) -> u32 {

1222

40

        self.unix_time.subsec_nanos

1223

40

1224

1225

    #[inline]

1226

8

    fn unix_time(&self) -> UnixTime {

1227

8

        self.unix_time

1228

8

1229

1230

1231

impl TimeReader for CdsTime<DaysLen16Bits> {

1232

22

    fn from_bytes(buf: &[u8]) -> Result<Self, TimestampError> {

1233

22

        Self::from_bytes_with_u16_days(buf)

1234

22

1235

1236

1237

impl TimeReader for CdsTime<DaysLen24Bits> {

1238

2

    fn from_bytes(buf: &[u8]) -> Result<Self, TimestampError> {

1239

2

        Self::from_bytes_with_u24_days(buf)

1240

2

1241

1242

1243

impl TimeWriter for CdsTime<DaysLen16Bits> {

1244

42

    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, TimestampError> {

1245

42

        self.length_check(buf, self.len_as_bytes())?;

1246

30

        buf[0] = self.pfield;

1247

30

        buf[1..3].copy_from_slice(self.ccsds_days.to_be_bytes().as_slice());

1248

30

        buf[3..7].copy_from_slice(self.ms_of_day.to_be_bytes().as_slice());

1249

30

        match self.submillis_precision() {

1250

6

            SubmillisPrecision::Microseconds => {

1251

6

                buf[7..9].copy_from_slice((self.submillis() as u16).to_be_bytes().as_slice());

1252

6

1253

4

            SubmillisPrecision::Picoseconds => {

1254

4

                buf[7..11].copy_from_slice(self.submillis().to_be_bytes().as_slice());

1255

4

1256

20

            _ => (),

1257

1258

30

        Ok(self.len_as_bytes())

1259

42

1260

1261

2

    fn len_written(&self) -> usize {

1262

2

        self.len_as_bytes()

1263

2

1264

1265

1266

impl TimeWriter for CdsTime<DaysLen24Bits> {

1267

16

    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, TimestampError> {

1268

16

        self.length_check(buf, self.len_as_bytes())?;

1269

16

        buf[0] = self.pfield;

1270

16

        let be_days = self.ccsds_days.to_be_bytes();

1271

16

        buf[1..4].copy_from_slice(&be_days[1..4]);

1272

16

        buf[4..8].copy_from_slice(self.ms_of_day.to_be_bytes().as_slice());

1273

16

        match self.submillis_precision() {

1274

2

            SubmillisPrecision::Microseconds => {

1275

2

                buf[8..10].copy_from_slice((self.submillis() as u16).to_be_bytes().as_slice());

1276

2

1277

2

            SubmillisPrecision::Picoseconds => {

1278

2

                buf[8..12].copy_from_slice(self.submillis().to_be_bytes().as_slice());

1279

2

1280

12

            _ => (),

1281

1282

16

        Ok(self.len_as_bytes())

1283

16

1284

1285

4

    fn len_written(&self) -> usize {

1286

4

        self.len_as_bytes()

1287

4

1288

1289

1290

impl<DaysLenProvider: ProvidesDaysLength> PartialEq for CdsTime<DaysLenProvider> {

1291

24

    fn eq(&self, other: &Self) -> bool {

1292

24

        if self.ccsds_days == other.ccsds_days

1293

18

            && self.ms_of_day == other.ms_of_day

1294

14

            && self.precision_as_ns().unwrap_or(0) == other.precision_as_ns().unwrap_or(0)

1295

1296

12

            return true;

1297

12

1298

12

        false

1299

24

1300

1301

1302

impl<DaysLenProvider: ProvidesDaysLength> PartialOrd for CdsTime<DaysLenProvider> {

1303

16

    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {

1304

16

        if self == other {

1305

4

            return Some(Ordering::Equal);

1306

12

1307

12

        match self.ccsds_days_as_u32().cmp(&other.ccsds_days_as_u32()) {

1308

            Ordering::Less => return Some(Ordering::Less),

1309

6

            Ordering::Greater => return Some(Ordering::Greater),

1310

6

            _ => (),

1311

6

1312

6

        match self.ms_of_day().cmp(&other.ms_of_day()) {

1313

            Ordering::Less => return Some(Ordering::Less),

1314

4

            Ordering::Greater => return Some(Ordering::Greater),

1315

2

            _ => (),

1316

2

1317

2

        match self

1318

2

            .precision_as_ns()

1319

2

            .unwrap_or(0)

1320

2

            .cmp(&other.precision_as_ns().unwrap_or(0))

1321

1322

            Ordering::Less => return Some(Ordering::Less),

1323

2

            Ordering::Greater => return Some(Ordering::Greater),

1324

            _ => (),

1325

1326

        Some(Ordering::Equal)

1327

16

1328

1329

1330

impl<DaysLenProvider: ProvidesDaysLength + Eq> Ord for CdsTime<DaysLenProvider> {

1331

    fn cmp(&self, other: &Self) -> Ordering {

1332

        PartialOrd::partial_cmp(self, other).unwrap()

1333

1334

1335

1336

impl From<CdsTime<DaysLen16Bits>> for CdsTime<DaysLen24Bits> {

1337

2

    fn from(value: CdsTime<DaysLen16Bits>) -> Self {

1338

2

        // This function only fails if the days value exceeds 24 bits, which is not possible here,

1339

2

        // so it is okay to unwrap.

1340

2

        Self::new_with_u24_days(value.ccsds_days_as_u32(), value.ms_of_day()).unwrap()

1341

2

1342

1343

1344

/// This conversion can fail if the days value exceeds 16 bits.

1345

impl TryFrom<CdsTime<DaysLen24Bits>> for CdsTime<DaysLen16Bits> {

1346

    type Error = CdsError;

1347

2

    fn try_from(value: CdsTime<DaysLen24Bits>) -> Result<Self, CdsError> {

1348

2

        let ccsds_days = value.ccsds_days_as_u32();

1349

2

        if ccsds_days > u16::MAX as u32 {

1350

            return Err(CdsError::InvalidCcsdsDays(ccsds_days as i64));

1351

2

1352

2

        Ok(Self::new_with_u16_days(

1353

2

            ccsds_days as u16,

1354

2

            value.ms_of_day(),

1355

2

))

1356

2

1357

1358

1359

#[cfg(test)]

1360

mod tests {

1361

    use super::*;

1362

    use crate::time::TimestampError::{ByteConversion, InvalidTimeCode};

1363

    use crate::time::{UnixTime, DAYS_CCSDS_TO_UNIX, MS_PER_DAY};

1364

    use crate::ByteConversionError::{FromSliceTooSmall, ToSliceTooSmall};

1365

    use alloc::string::ToString;

1366

    use chrono::{Datelike, NaiveDate, Timelike};

1367

    #[cfg(feature = "serde")]

1368

    use postcard::{from_bytes, to_allocvec};

1369

    use std::format;

1370

1371

    #[test]

1372

2

    fn test_time_stamp_zero_args() {

1373

2

        let time_stamper = CdsTime::new_with_u16_days(0, 0);

1374

2

        let unix_stamp = time_stamper.unix_time();

1375

2

        assert_eq!(

1376

2

            unix_stamp.secs,

1377

2

            (DAYS_CCSDS_TO_UNIX * SECONDS_PER_DAY as i32) as i64

1378

2

);

1379

2

        let subsecond_millis = unix_stamp.subsec_nanos;

1380

2

        assert_eq!(subsecond_millis, 0);

1381

2

        assert_eq!(

1382

2

            time_stamper.submillis_precision(),

1383

2

            SubmillisPrecision::Absent

1384

2

);

1385

2

        assert_eq!(time_stamper.subsec_nanos(), 0);

1386

2

        assert_eq!(time_stamper.ccdsd_time_code(), CcsdsTimeCode::Cds);

1387

2

        assert_eq!(

1388

2

            time_stamper.p_field(),

1389

2

            (1, [(CcsdsTimeCode::Cds as u8) << 4, 0])

1390

2

);

1391

2

        let date_time = time_stamper.chrono_date_time().unwrap();

1392

2

        assert_eq!(date_time.year(), 1958);

1393

2

        assert_eq!(date_time.month(), 1);

1394

2

        assert_eq!(date_time.day(), 1);

1395

2

        assert_eq!(date_time.hour(), 0);

1396

2

        assert_eq!(date_time.minute(), 0);

1397

2

        assert_eq!(date_time.second(), 0);

1398

2

1399

1400

    #[test]

1401

2

    fn test_time_stamp_unix_epoch() {

1402

2

        let time_stamper = CdsTime::new_with_u16_days((-DAYS_CCSDS_TO_UNIX) as u16, 0);

1403

2

        assert_eq!(time_stamper.unix_time().secs, 0);

1404

2

        assert_eq!(

1405

2

            time_stamper.submillis_precision(),

1406

2

            SubmillisPrecision::Absent

1407

2

);

1408

2

        let date_time = time_stamper.chrono_date_time().unwrap();

1409

2

        assert_eq!(date_time.year(), 1970);

1410

2

        assert_eq!(date_time.month(), 1);

1411

2

        assert_eq!(date_time.day(), 1);

1412

2

        assert_eq!(date_time.hour(), 0);

1413

2

        assert_eq!(date_time.minute(), 0);

1414

2

        assert_eq!(date_time.second(), 0);

1415

2

        let time_stamper = CdsTime::new_with_u16_days((-DAYS_CCSDS_TO_UNIX) as u16, 40);

1416

2

        assert_eq!(time_stamper.subsec_nanos(), 40 * 10_u32.pow(6));

1417

2

        assert_eq!(time_stamper.subsec_millis(), 40);

1418

2

        let time_stamper = CdsTime::new_with_u16_days((-DAYS_CCSDS_TO_UNIX) as u16, 1040);

1419

2

        assert_eq!(time_stamper.subsec_nanos(), 40 * 10_u32.pow(6));

1420

2

        assert_eq!(time_stamper.subsec_millis(), 40);

1421

2

1422

1423

    #[test]

1424

2

    fn test_large_days_field_write() {

1425

2

        let time_stamper = CdsTime::new_with_u24_days(0x108020_u32, 0x10203040);

1426

2

        assert!(time_stamper.is_ok());

1427

2

        let time_stamper = time_stamper.unwrap();

1428

2

        assert_eq!(time_stamper.len_as_bytes(), 8);

1429

2

        let mut buf = [0; 16];

1430

2

        let written = time_stamper.write_to_bytes(&mut buf);

1431

2

        assert!(written.is_ok());

1432

2

        let written = written.unwrap();

1433

2

        assert_eq!(written, 8);

1434

2

        assert_eq!(buf[1], 0x10);

1435

2

        assert_eq!(buf[2], 0x80);

1436

2

        assert_eq!(buf[3], 0x20);

1437

2

        let ms = u32::from_be_bytes(buf[4..8].try_into().unwrap());

1438

2

        assert_eq!(ms, 0x10203040);

1439

2

        assert_eq!((buf[0] >> 2) & 0b1, 1);

1440

2

1441

1442

    #[test]

1443

2

    fn test_large_days_field_read() {

1444

2

        let time_stamper = CdsTime::new_with_u24_days(0x108020_u32, 0);

1445

2

        assert!(time_stamper.is_ok());

1446

2

        let time_stamper = time_stamper.unwrap();

1447

2

        let mut buf = [0; 16];

1448

2

        let written = time_stamper.write_to_bytes(&mut buf);

1449

2

        assert!(written.is_ok());

1450

2

        let provider = CdsTime::<DaysLen24Bits>::from_bytes(&buf);

1451

2

        assert!(provider.is_ok());

1452

2

        let provider = provider.unwrap();

1453

2

        assert_eq!(provider.ccsds_days(), 0x108020);

1454

2

        assert_eq!(provider.ms_of_day(), 0);

1455

2

1456

1457

    #[test]

1458

2

    fn test_large_days_field_read_invalid_ctor() {

1459

2

        let time_stamper = CdsTime::new_with_u24_days(0x108020, 0);

1460

2

        assert!(time_stamper.is_ok());

1461

2

        let time_stamper = time_stamper.unwrap();

1462

2

        let mut buf = [0; 16];

1463

2

        let written = time_stamper.write_to_bytes(&mut buf);

1464

2

        assert!(written.is_ok());

1465

2

        let faulty_ctor = CdsTime::<DaysLen16Bits>::from_bytes(&buf);

1466

2

        assert!(faulty_ctor.is_err());

1467

2

        let error = faulty_ctor.unwrap_err();

1468

2

        if let TimestampError::Cds(CdsError::InvalidCtorForDaysOfLenInPreamble(len_of_day)) = error

1469

1470

2

            assert_eq!(len_of_day, LengthOfDaySegment::Long24Bits);

1471

        } else {

1472

            panic!("Wrong error type");

1473

1474

2

1475

1476

    #[test]

1477

2

    fn test_write() {

1478

2

        let mut buf = [0; 16];

1479

2

        let time_stamper_0 = CdsTime::new_with_u16_days(0, 0);

1480

2

        let unix_stamp = time_stamper_0.unix_time();

1481

2

        assert_eq!(

1482

2

            unix_stamp.secs,

1483

2

            (DAYS_CCSDS_TO_UNIX * SECONDS_PER_DAY as i32).into()

1484

2

);

1485

2

        let mut res = time_stamper_0.write_to_bytes(&mut buf);

1486

2

        assert!(res.is_ok());

1487

2

        assert_eq!(buf[0], (CcsdsTimeCode::Cds as u8) << 4);

1488

2

        assert_eq!(

1489

2

            u16::from_be_bytes(buf[1..3].try_into().expect("Byte conversion failed")),

1490

2

1491

2

);

1492

2

        assert_eq!(

1493

2

            u32::from_be_bytes(buf[3..7].try_into().expect("Byte conversion failed")),

1494

2

1495

2

);

1496

2

        let time_stamper_1 = CdsTime::new_with_u16_days(u16::MAX - 1, u32::MAX - 1);

1497

2

        res = time_stamper_1.write_to_bytes(&mut buf);

1498

2

        assert!(res.is_ok());

1499

2

        assert_eq!(buf[0], (CcsdsTimeCode::Cds as u8) << 4);

1500

2

        assert_eq!(

1501

2

            u16::from_be_bytes(buf[1..3].try_into().expect("Byte conversion failed")),

1502

2

            u16::MAX - 1

1503

2

);

1504

2

        assert_eq!(

1505

2

            u32::from_be_bytes(buf[3..7].try_into().expect("Byte conversion failed")),

1506

2

            u32::MAX - 1

1507

2

);

1508

2

1509

1510

    #[test]

1511

2

    fn test_faulty_write_buf_too_small() {

1512

2

        let mut buf = [0; 7];

1513

2

        let time_stamper = CdsTime::new_with_u16_days(u16::MAX - 1, u32::MAX - 1);

1514

14

        for i in 0..6 {

1515

12

            let res = time_stamper.write_to_bytes(&mut buf[0..i]);

1516

12

            assert!(res.is_err());

1517

12

            let error = res.unwrap_err();

1518

12

            match error {

1519

12

                ByteConversion(ToSliceTooSmall { found, expected }) => {

1520

12

                    assert_eq!(found, i);

1521

12

                    assert_eq!(expected, 7);

1522

12

                    assert_eq!(

1523

12

                        error.to_string(),

1524

12

                        format!("time stamp: target slice with size {i} is too small, expected size of at least 7")

1525

12

);

1526

1527

                _ => panic!(

1528

                    "{}",

1529

                    format!("Invalid error {:?} detected", res.unwrap_err())

1530

),

1531

1532

1533

2

1534

1535

    #[test]

1536

2

    fn test_faulty_read_buf_too_small() {

1537

2

        let buf = [0; 7];

1538

14

        for i in 0..6 {

1539

12

            let res = CdsTime::<DaysLen16Bits>::from_bytes(&buf[0..i]);

1540

12

            assert!(res.is_err());

1541

12

            let err = res.unwrap_err();

1542

12

            match err {

1543

12

                ByteConversion(e) => match e {

1544

12

                    FromSliceTooSmall { found, expected } => {

1545

12

                        assert_eq!(found, i);

1546

12

                        assert_eq!(expected, 7);

1547

1548

                    _ => panic!("{}", format!("Invalid error {:?} detected", e)),

1549

},

1550

                _ => {

1551

                    panic!("Unexpected error {:?}", err);

1552

1553

1554

1555

2

1556

1557

    #[test]

1558

2

    fn test_faulty_invalid_pfield() {

1559

2

        let mut buf = [0; 16];

1560

2

        let time_stamper_0 = CdsTime::new_with_u16_days(0, 0);

1561

2

        let res = time_stamper_0.write_to_bytes(&mut buf);

1562

2

        assert!(res.is_ok());

1563

2

        buf[0] = 0;

1564

2

        let res = CdsTime::<DaysLen16Bits>::from_bytes(&buf);

1565

2

        assert!(res.is_err());

1566

2

        let err = res.unwrap_err();

1567

2

        if let InvalidTimeCode { expected, found } = err {

1568

2

            assert_eq!(expected, CcsdsTimeCode::Cds);

1569

2

            assert_eq!(found, 0);

1570

2

            assert_eq!(

1571

2

                err.to_string(),

1572

2

                "invalid raw time code value 0 for time code Cds"

1573

2

);

1574

1575

2

1576

1577

    #[test]

1578

2

    fn test_reading() {

1579

2

        let mut buf = [0; 16];

1580

2

        let time_stamper = CdsTime::new_with_u16_days(u16::MAX - 1, u32::MAX - 1);

1581

2

        let res = time_stamper.write_to_bytes(&mut buf);

1582

2

        assert!(res.is_ok());

1583

2

        assert_eq!(buf[0], (CcsdsTimeCode::Cds as u8) << 4);

1584

2

        assert_eq!(

1585

2

            u16::from_be_bytes(buf[1..3].try_into().expect("Byte conversion failed")),

1586

2

            u16::MAX - 1

1587

2

);

1588

2

        assert_eq!(

1589

2

            u32::from_be_bytes(buf[3..7].try_into().expect("Byte conversion failed")),

1590

2

            u32::MAX - 1

1591

2

);

1592

1593

2

        let read_stamp: CdsTime<DaysLen16Bits> =

1594

2

            CdsTime::from_bytes(&buf).expect("Reading timestamp failed");

1595

2

        assert_eq!(read_stamp.ccsds_days(), u16::MAX - 1);

1596

2

        assert_eq!(read_stamp.ms_of_day(), u32::MAX - 1);

1597

2

1598

1599

10

    fn generic_now_test<T: ProvidesDaysLength>(

1600

10

        timestamp_now: CdsTime<T>,

1601

10

        compare_stamp: chrono::DateTime<chrono::Utc>,

1602

10

) {

1603

10

        let dt = timestamp_now.chrono_date_time().unwrap();

1604

10

        if compare_stamp.year() > dt.year() {

1605

            assert_eq!(compare_stamp.year() - dt.year(), 1);

1606

        } else {

1607

10

            assert_eq!(dt.year(), compare_stamp.year());

1608

1609

10

        generic_dt_property_equality_check(dt.month(), compare_stamp.month(), 1, 12);

1610

10

1611

10

        assert_eq!(dt.day(), compare_stamp.day());

1612

10

        if compare_stamp.day() < dt.day() {

1613

            assert!(dt.day() >= 28);

1614

            assert_eq!(compare_stamp.day(), 1);

1615

10

        } else if compare_stamp.day() > dt.day() {

1616

            assert_eq!(compare_stamp.day() - dt.day(), 1);

1617

        } else {

1618

10

            assert_eq!(compare_stamp.day(), dt.day());

1619

1620

10

        generic_dt_property_equality_check(dt.hour(), compare_stamp.hour(), 0, 23);

1621

10

        generic_dt_property_equality_check(dt.minute(), compare_stamp.minute(), 0, 59);

1622

10

1623

1624

    #[test]

1625

    #[cfg_attr(miri, ignore)]

1626

2

    fn test_time_now() {

1627

2

        let timestamp_now = CdsTime::now_with_u16_days().unwrap();

1628

2

        let compare_stamp = chrono::Utc::now();

1629

2

        generic_now_test(timestamp_now, compare_stamp);

1630

2

1631

1632

    #[test]

1633

    #[cfg_attr(miri, ignore)]

1634

2

    fn test_time_now_us_prec() {

1635

2

        let timestamp_now = CdsTime::now_with_u16_days_us_precision().unwrap();

1636

2

        let compare_stamp = chrono::Utc::now();

1637

2

        generic_now_test(timestamp_now, compare_stamp);

1638

2

1639

1640

    #[test]

1641

    #[cfg_attr(miri, ignore)]

1642

2

    fn test_time_now_ps_prec() {

1643

2

        let timestamp_now = CdsTime::from_now_with_u16_days_ps_precision().unwrap();

1644

2

        let compare_stamp = chrono::Utc::now();

1645

2

        generic_now_test(timestamp_now, compare_stamp);

1646

2

1647

1648

    #[test]

1649

    #[cfg_attr(miri, ignore)]

1650

2

    fn test_time_now_ps_prec_u16_days() {

1651

2

        let timestamp_now = CdsTime::from_now_with_u16_days_ps_precision().unwrap();

1652

2

        let compare_stamp = chrono::Utc::now();

1653

2

        generic_now_test(timestamp_now, compare_stamp);

1654

2

1655

1656

    #[test]

1657

    #[cfg_attr(miri, ignore)]

1658

2

    fn test_time_now_ps_prec_u24_days() {

1659

2

        let timestamp_now = CdsTime::now_with_u24_days_ps_precision().unwrap();

1660

2

        let compare_stamp = chrono::Utc::now();

1661

2

        generic_now_test(timestamp_now, compare_stamp);

1662

2

1663

1664

    #[test]

1665

2

    fn test_submillis_precision_micros() {

1666

2

        let mut time_stamper = CdsTime::new_with_u16_days(0, 0);

1667

2

        time_stamper.set_submillis(SubmillisPrecision::Microseconds, 500);

1668

2

        assert_eq!(

1669

2

            time_stamper.submillis_precision(),

1670

2

            SubmillisPrecision::Microseconds

1671

2

);

1672

2

        assert_eq!(time_stamper.submillis(), 500);

1673

2

        let mut write_buf: [u8; 16] = [0; 16];

1674

2

        let written = time_stamper

1675

2

            .write_to_bytes(&mut write_buf)

1676

2

            .expect("Writing timestamp failed");

1677

2

        assert_eq!(written, 9);

1678

2

        let cross_check: u16 = 500;

1679

2

        assert_eq!(write_buf[7..9], cross_check.to_be_bytes());

1680

2

1681

1682

    #[test]

1683

2

    fn test_submillis_precision_picos() {

1684

2

        let mut time_stamper = CdsTime::new_with_u16_days(0, 0);

1685

2

        time_stamper.set_submillis(SubmillisPrecision::Picoseconds, 5e8 as u32);

1686

2

        assert_eq!(

1687

2

            time_stamper.submillis_precision(),

1688

2

            SubmillisPrecision::Picoseconds

1689

2

);

1690

2

        assert_eq!(time_stamper.submillis(), 5e8 as u32);

1691

2

        let mut write_buf: [u8; 16] = [0; 16];

1692

2

        let written = time_stamper

1693

2

            .write_to_bytes(&mut write_buf)

1694

2

            .expect("Writing timestamp failed");

1695

2

        assert_eq!(written, 11);

1696

2

        let cross_check: u32 = 5e8 as u32;

1697

2

        assert_eq!(write_buf[7..11], cross_check.to_be_bytes());

1698

2

1699

1700

    #[test]

1701

2

    fn read_stamp_with_ps_submillis_precision() {

1702

2

        let mut time_stamper = CdsTime::new_with_u16_days(0, 0);

1703

2

        time_stamper.set_submillis(SubmillisPrecision::Picoseconds, 5e8 as u32);

1704

2

        let mut write_buf: [u8; 16] = [0; 16];

1705

2

        let written = time_stamper

1706

2

            .write_to_bytes(&mut write_buf)

1707

2

            .expect("Writing timestamp failed");

1708

2

        assert_eq!(written, 11);

1709

2

        let stamp_deserialized = CdsTime::<DaysLen16Bits>::from_bytes(&write_buf);

1710

2

        assert!(stamp_deserialized.is_ok());

1711

2

        let stamp_deserialized = stamp_deserialized.unwrap();

1712

2

        assert_eq!(stamp_deserialized.len_as_bytes(), 11);

1713

2

        assert_eq!(

1714

2

            stamp_deserialized.submillis_precision(),

1715

2

            SubmillisPrecision::Picoseconds

1716

2

);

1717

2

        assert_eq!(stamp_deserialized.submillis(), 5e8 as u32);

1718

2

1719

1720

    #[test]

1721

2

    fn read_stamp_with_us_submillis_precision() {

1722

2

        let mut time_stamper = CdsTime::new_with_u16_days(0, 0);

1723

2

        time_stamper.set_submillis(SubmillisPrecision::Microseconds, 500);

1724

2

        let mut write_buf: [u8; 16] = [0; 16];

1725

2

        let written = time_stamper

1726

2

            .write_to_bytes(&mut write_buf)

1727

2

            .expect("Writing timestamp failed");

1728

2

        assert_eq!(written, 9);

1729

2

        let stamp_deserialized = CdsTime::<DaysLen16Bits>::from_bytes(&write_buf);

1730

2

        assert!(stamp_deserialized.is_ok());

1731

2

        let stamp_deserialized = stamp_deserialized.unwrap();

1732

2

        assert_eq!(stamp_deserialized.len_as_bytes(), 9);

1733

2

        assert_eq!(

1734

2

            stamp_deserialized.submillis_precision(),

1735

2

            SubmillisPrecision::Microseconds

1736

2

);

1737

2

        assert_eq!(stamp_deserialized.submillis(), 500);

1738

2

1739

1740

    #[test]

1741

2

    fn read_u24_stamp_with_us_submillis_precision() {

1742

2

        let mut time_stamper = CdsTime::new_with_u24_days(u16::MAX as u32 + 1, 0).unwrap();

1743

2

        time_stamper.set_submillis(SubmillisPrecision::Microseconds, 500);

1744

2

        let mut write_buf: [u8; 16] = [0; 16];

1745

2

        let written = time_stamper

1746

2

            .write_to_bytes(&mut write_buf)

1747

2

            .expect("Writing timestamp failed");

1748

2

        // 1 byte pfield + 3 bytes days + 4 bytes ms of day + 2 bytes us precision

1749

2

        assert_eq!(written, 10);

1750

2

        let stamp_deserialized = CdsTime::from_bytes_with_u24_days(&write_buf);

1751

2

        assert!(stamp_deserialized.is_ok());

1752

2

        let stamp_deserialized = stamp_deserialized.unwrap();

1753

2

        assert_eq!(stamp_deserialized.len_as_bytes(), 10);

1754

2

        assert_eq!(stamp_deserialized.ccsds_days(), u16::MAX as u32 + 1);

1755

2

        assert_eq!(

1756

2

            stamp_deserialized.submillis_precision(),

1757

2

            SubmillisPrecision::Microseconds

1758

2

);

1759

2

        assert_eq!(stamp_deserialized.submillis(), 500);

1760

2

1761

1762

    #[test]

1763

2

    fn read_u24_stamp_with_ps_submillis_precision() {

1764

2

        let mut time_stamper = CdsTime::new_with_u24_days(u16::MAX as u32 + 1, 0).unwrap();

1765

2

        time_stamper.set_submillis(SubmillisPrecision::Picoseconds, 5e8 as u32);

1766

2

        let mut write_buf: [u8; 16] = [0; 16];

1767

2

        let written = time_stamper

1768

2

            .write_to_bytes(&mut write_buf)

1769

2

            .expect("Writing timestamp failed");

1770

2

        // 1 byte pfield + 3 bytes days + 4 bytes ms of day + 4 bytes us precision

1771

2

        assert_eq!(written, 12);

1772

2

        let stamp_deserialized = CdsTime::from_bytes_with_u24_days(&write_buf);

1773

2

        assert!(stamp_deserialized.is_ok());

1774

2

        let stamp_deserialized = stamp_deserialized.unwrap();

1775

2

        assert_eq!(stamp_deserialized.len_as_bytes(), 12);

1776

2

        assert_eq!(stamp_deserialized.ccsds_days(), u16::MAX as u32 + 1);

1777

2

        assert_eq!(

1778

2

            stamp_deserialized.submillis_precision(),

1779

2

            SubmillisPrecision::Picoseconds

1780

2

);

1781

2

        assert_eq!(stamp_deserialized.submillis(), 5e8 as u32);

1782

2

1783

1784

4

    fn generic_dt_case_0_no_prec(subsec_millis: u32) -> chrono::DateTime<chrono::Utc> {

1785

4

        NaiveDate::from_ymd_opt(2023, 1, 14)

1786

4

            .unwrap()

1787

4

            .and_hms_milli_opt(16, 49, 30, subsec_millis)

1788

4

            .unwrap()

1789

4

            .and_local_timezone(chrono::Utc)

1790

4

            .unwrap()

1791

4

1792

1793

4

    fn generic_check_dt_case_0<DaysLen: ProvidesDaysLength>(

1794

4

        time_provider: &CdsTime<DaysLen>,

1795

4

        subsec_millis: u32,

1796

4

        datetime_utc: chrono::DateTime<chrono::Utc>,

1797

4

) {

1798

4

        // https://www.timeanddate.com/date/durationresult.html?d1=01&m1=01&y1=1958&d2=14&m2=01&y2=2023

1799

4

        // Leap years need to be accounted for as well.

1800

4

        assert_eq!(time_provider.ccsds_days, 23754.into());

1801

4

        assert_eq!(

1802

4

            time_provider.ms_of_day,

1803

4

            30 * 1000 + 49 * 60 * 1000 + 16 * 60 * 60 * 1000 + subsec_millis

1804

4

);

1805

4

        assert_eq!(time_provider.chrono_date_time().unwrap(), datetime_utc);

1806

4

1807

1808

    #[test]

1809

2

    fn test_creation_from_dt_u16_days() {

1810

2

        let subsec_millis = 250;

1811

2

        let datetime_utc = generic_dt_case_0_no_prec(subsec_millis);

1812

2

        let time_provider = CdsTime::from_dt_with_u16_days(&datetime_utc).unwrap();

1813

2

        generic_check_dt_case_0(&time_provider, subsec_millis, datetime_utc);

1814

2

        let time_provider_2: CdsTime<DaysLen16Bits> =

1815

2

            datetime_utc.try_into().expect("conversion failed");

1816

2

        // Test the TryInto trait impl

1817

2

        assert_eq!(time_provider, time_provider_2);

1818

2

1819

    #[test]

1820

2

    fn test_creation_from_dt_u24_days() {

1821

2

        let subsec_millis = 250;

1822

2

        let datetime_utc = generic_dt_case_0_no_prec(subsec_millis);

1823

2

        let time_provider = CdsTime::from_dt_with_u24_days(&datetime_utc).unwrap();

1824

2

        generic_check_dt_case_0(&time_provider, subsec_millis, datetime_utc);

1825

2

        let time_provider_2: CdsTime<DaysLen24Bits> =

1826

2

            datetime_utc.try_into().expect("conversion failed");

1827

2

        // Test the TryInto trait impl

1828

2

        assert_eq!(time_provider, time_provider_2);

1829

2

1830

1831

4

    fn generic_dt_case_1_us_prec(subsec_millis: u32) -> chrono::DateTime<chrono::Utc> {

1832

4

        // 250 ms + 500 us

1833

4

        let subsec_micros = subsec_millis * 1000 + 500;

1834

4

        NaiveDate::from_ymd_opt(2023, 1, 14)

1835

4

            .unwrap()

1836

4

            .and_hms_micro_opt(16, 49, 30, subsec_micros)

1837

4

            .unwrap()

1838

4

            .and_local_timezone(chrono::Utc)

1839

4

            .unwrap()

1840

4

1841

1842

4

    fn generic_check_dt_case_1_us_prec<DaysLen: ProvidesDaysLength>(

1843

4

        time_provider: &CdsTime<DaysLen>,

1844

4

        subsec_millis: u32,

1845

4

        datetime_utc: chrono::DateTime<chrono::Utc>,

1846

4

) {

1847

4

        // https://www.timeanddate.com/date/durationresult.html?d1=01&m1=01&y1=1958&d2=14&m2=01&y2=2023

1848

4

        // Leap years need to be accounted for as well.

1849

4

        assert_eq!(time_provider.ccsds_days, 23754.into());

1850

4

        assert_eq!(

1851

4

            time_provider.ms_of_day,

1852

4

            30 * 1000 + 49 * 60 * 1000 + 16 * 60 * 60 * 1000 + subsec_millis

1853

4

);

1854

4

        assert_eq!(

1855

4

            time_provider.submillis_precision(),

1856

4

            SubmillisPrecision::Microseconds

1857

4

);

1858

4

        assert_eq!(time_provider.submillis(), 500);

1859

4

        assert_eq!(time_provider.chrono_date_time().unwrap(), datetime_utc);

1860

4

1861

1862

    #[test]

1863

2

    fn test_creation_from_dt_u16_days_us_prec() {

1864

2

        let subsec_millis = 250;

1865

2

        let datetime_utc = generic_dt_case_1_us_prec(subsec_millis);

1866

2

        let time_provider = CdsTime::from_dt_with_u16_days_us_precision(&datetime_utc).unwrap();

1867

2

        generic_check_dt_case_1_us_prec(&time_provider, subsec_millis, datetime_utc);

1868

2

1869

1870

    #[test]

1871

2

    fn test_creation_from_dt_u24_days_us_prec() {

1872

2

        let subsec_millis = 250;

1873

2

        let datetime_utc = generic_dt_case_1_us_prec(subsec_millis);

1874

2

        let time_provider = CdsTime::from_dt_with_u24_days_us_precision(&datetime_utc).unwrap();

1875

2

        generic_check_dt_case_1_us_prec(&time_provider, subsec_millis, datetime_utc);

1876

2

1877

1878

4

    fn generic_dt_case_2_ps_prec(subsec_millis: u32) -> (chrono::DateTime<chrono::Utc>, u32) {

1879

4

        // 250 ms + 500 us

1880

4

        let subsec_nanos = subsec_millis * 1000 * 1000 + 500 * 1000;

1881

4

        let submilli_nanos = subsec_nanos % 10_u32.pow(6);

1882

4

1883

4

            NaiveDate::from_ymd_opt(2023, 1, 14)

1884

4

                .unwrap()

1885

4

                .and_hms_nano_opt(16, 49, 30, subsec_nanos)

1886

4

                .unwrap()

1887

4

                .and_local_timezone(chrono::Utc)

1888

4

                .unwrap(),

1889

4

            submilli_nanos,

1890

4

1891

4

1892

1893

4

    fn generic_check_dt_case_2_ps_prec<DaysLen: ProvidesDaysLength>(

1894

4

        time_provider: &CdsTime<DaysLen>,

1895

4

        subsec_millis: u32,

1896

4

        submilli_nanos: u32,

1897

4

        datetime_utc: chrono::DateTime<chrono::Utc>,

1898

4

) {

1899

4

        // https://www.timeanddate.com/date/durationresult.html?d1=01&m1=01&y1=1958&d2=14&m2=01&y2=2023

1900

4

        // Leap years need to be accounted for as well.

1901

4

        assert_eq!(time_provider.ccsds_days, 23754.into());

1902

4

        assert_eq!(

1903

4

            time_provider.ms_of_day,

1904

4

            30 * 1000 + 49 * 60 * 1000 + 16 * 60 * 60 * 1000 + subsec_millis

1905

4

);

1906

4

        assert_eq!(

1907

4

            time_provider.submillis_precision(),

1908

4

            SubmillisPrecision::Picoseconds

1909

4

);

1910

4

        assert_eq!(time_provider.submillis(), submilli_nanos * 1000);

1911

4

        assert_eq!(time_provider.chrono_date_time().unwrap(), datetime_utc);

1912

4

1913

1914

    #[test]

1915

2

    fn test_creation_from_dt_u16_days_ps_prec() {

1916

2

        let subsec_millis = 250;

1917

2

        let (datetime_utc, submilli_nanos) = generic_dt_case_2_ps_prec(subsec_millis);

1918

2

        let time_provider = CdsTime::from_dt_with_u16_days_ps_precision(&datetime_utc).unwrap();

1919

2

        generic_check_dt_case_2_ps_prec(

1920

2

            &time_provider,

1921

2

            subsec_millis,

1922

2

            submilli_nanos,

1923

2

            datetime_utc,

1924

2

);

1925

2

1926

1927

    #[test]

1928

2

    fn test_creation_from_dt_u24_days_ps_prec() {

1929

2

        let subsec_millis = 250;

1930

2

        let (datetime_utc, submilli_nanos) = generic_dt_case_2_ps_prec(subsec_millis);

1931

2

        let time_provider = CdsTime::from_dt_with_u24_days_ps_precision(&datetime_utc).unwrap();

1932

2

        generic_check_dt_case_2_ps_prec(

1933

2

            &time_provider,

1934

2

            subsec_millis,

1935

2

            submilli_nanos,

1936

2

            datetime_utc,

1937

2

);

1938

2

1939

1940

    #[test]

1941

2

    fn test_creation_from_unix_stamp_0_u16_days() {

1942

2

        let unix_secs = 0;

1943

2

        let subsec_millis = 0;

1944

2

        let time_provider = CdsTime::from_unix_time_with_u16_days(

1945

2

            &UnixTime::new(unix_secs, subsec_millis),

1946

2

            SubmillisPrecision::Absent,

1947

2

1948

2

        .expect("creating provider from unix stamp failed");

1949

2

        assert_eq!(time_provider.ccsds_days, -DAYS_CCSDS_TO_UNIX as u16)

1950

2

1951

1952

    #[test]

1953

2

    fn test_creation_from_unix_stamp_0_u24_days() {

1954

2

        let unix_secs = 0;

1955

2

        let subsec_millis = 0;

1956

2

        let time_provider = CdsTime::from_unix_time_with_u24_day(

1957

2

            &UnixTime::new(unix_secs, subsec_millis),

1958

2

            SubmillisPrecision::Absent,

1959

2

1960

2

        .expect("creating provider from unix stamp failed");

1961

2

        assert_eq!(time_provider.ccsds_days, (-DAYS_CCSDS_TO_UNIX) as u32)

1962

2

1963

1964

    #[test]

1965

2

    fn test_creation_from_unix_stamp_1() {

1966

2

        let subsec_millis = 250;

1967

2

        let datetime_utc = NaiveDate::from_ymd_opt(2023, 1, 14)

1968

2

            .unwrap()

1969

2

            .and_hms_milli_opt(16, 49, 30, subsec_millis)

1970

2

            .unwrap()

1971

2

            .and_local_timezone(chrono::Utc)

1972

2

            .unwrap();

1973

2

        let time_provider =

1974

2

            CdsTime::from_unix_time_with_u16_days(&datetime_utc.into(), SubmillisPrecision::Absent)

1975

2

                .expect("creating provider from unix stamp failed");

1976

2

        // https://www.timeanddate.com/date/durationresult.html?d1=01&m1=01&y1=1958&d2=14&m2=01&y2=2023

1977

2

        // Leap years need to be accounted for as well.

1978

2

        assert_eq!(time_provider.ccsds_days, 23754);

1979

2

        assert_eq!(

1980

2

            time_provider.ms_of_day,

1981

2

            30 * 1000 + 49 * 60 * 1000 + 16 * 60 * 60 * 1000 + subsec_millis

1982

2

);

1983

2

        let dt_back = time_provider.chrono_date_time().unwrap();

1984

2

        assert_eq!(datetime_utc, dt_back);

1985

2

1986

1987

    #[test]

1988

2

    fn test_creation_0_ccsds_days() {

1989

2

        let unix_secs = DAYS_CCSDS_TO_UNIX as i64 * SECONDS_PER_DAY as i64;

1990

2

        let subsec_millis = 0;

1991

2

        let time_provider = CdsTime::from_unix_time_with_u16_days(

1992

2

            &UnixTime::new(unix_secs, subsec_millis),

1993

2

            SubmillisPrecision::Absent,

1994

2

1995

2

        .expect("creating provider from unix stamp failed");

1996

2

        assert_eq!(time_provider.ccsds_days, 0)

1997

2

1998

1999

    #[test]

2000

2

    fn test_invalid_creation_from_unix_stamp_days_too_large() {

2001

2

        let invalid_unix_secs: i64 = (u16::MAX as i64 + 1) * SECONDS_PER_DAY as i64;

2002

2

        let subsec_millis = 0;

2003

2

        match CdsTime::from_unix_time_with_u16_days(

2004

2

            &UnixTime::new(invalid_unix_secs, subsec_millis),

2005

2

            SubmillisPrecision::Absent,

2006

2

) {

2007

            Ok(_) => {

2008

                panic!("creation should not succeed")

2009

2010

2

            Err(e) => {

2011

2

                if let CdsError::InvalidCcsdsDays(days) = e {

2012

2

                    assert_eq!(

2013

2

                        days,

2014

2

                        unix_to_ccsds_days(invalid_unix_secs / SECONDS_PER_DAY as i64)

2015

2

);

2016

2

                    assert_eq!(e.to_string(), "invalid ccsds days 69919");

2017

                } else {

2018

                    panic!("unexpected error {}", e)

2019

2020

2021

2022

2

2023

2024

    #[test]

2025

2

    fn test_invalid_creation_from_unix_stamp_before_ccsds_epoch() {

2026

2

        // This is a unix stamp before the CCSDS epoch (01-01-1958 00:00:00), this should be

2027

2

        // precisely 31-12-1957 23:59:55

2028

2

        let unix_secs = DAYS_CCSDS_TO_UNIX * SECONDS_PER_DAY as i32 - 5;

2029

2

        let subsec_millis = 0;

2030

2

        match CdsTime::from_unix_time_with_u16_days(

2031

2

            &UnixTime::new(unix_secs as i64, subsec_millis),

2032

2

            SubmillisPrecision::Absent,

2033

2

) {

2034

            Ok(_) => {

2035

                panic!("creation should not succeed")

2036

2037

2

            Err(e) => {

2038

2

                if let CdsError::DateBeforeCcsdsEpoch(DateBeforeCcsdsEpochError(unix_dt)) = e {

2039

2

                    let dt = unix_dt.chrono_date_time();

2040

2

                    if let chrono::LocalResult::Single(dt) = dt {

2041

2

                        assert_eq!(dt.year(), 1957);

2042

2

                        assert_eq!(dt.month(), 12);

2043

2

                        assert_eq!(dt.day(), 31);

2044

2

                        assert_eq!(dt.hour(), 23);

2045

2

                        assert_eq!(dt.minute(), 59);

2046

2

                        assert_eq!(dt.second(), 55);

2047

                    } else {

2048

                        panic!("unexpected error {}", e)

2049

2050

                } else {

2051

                    panic!("unexpected error {}", e)

2052

2053

2054

2055

2

2056

2057

    #[test]

2058

2

    fn test_addition_u16_days_day_increment() {

2059

2

        let mut provider = CdsTime::new_with_u16_days(0, MS_PER_DAY - 5 * 1000);

2060

2

        let seconds_offset = Duration::from_secs(10);

2061

2

        assert_eq!(provider.ccsds_days, 0);

2062

2

        assert_eq!(provider.ms_of_day, MS_PER_DAY - 5 * 1000);

2063

2

        provider += seconds_offset;

2064

2

        assert_eq!(provider.ccsds_days, 1);

2065

2

        assert_eq!(provider.ms_of_day, 5000);

2066

2

2067

2068

    #[test]

2069

2

    fn test_addition_u16_days() {

2070

2

        let mut provider = CdsTime::new_with_u16_days(0, 0);

2071

2

        let seconds_offset = Duration::from_secs(5);

2072

2

        assert_eq!(provider.ccsds_days, 0);

2073

2

        assert_eq!(provider.ms_of_day, 0);

2074

2

        provider += seconds_offset;

2075

2

        assert_eq!(provider.ms_of_day, 5000);

2076

        // Add one day and test Add operator

2077

2

        let provider2 = provider + Duration::from_secs(60 * 60 * 24);

2078

2

        assert_eq!(provider2.ccsds_days, 1);

2079

2

        assert_eq!(provider2.ms_of_day, 5000);

2080

2

2081

2082

    #[test]

2083

2

    fn test_addition_u24_days() {

2084

2

        let mut provider = CdsTime::new_with_u24_days(u16::MAX as u32, 0).unwrap();

2085

2

        let seconds_offset = Duration::from_secs(5);

2086

2

        assert_eq!(provider.ccsds_days, u16::MAX as u32);

2087

2

        assert_eq!(provider.ms_of_day, 0);

2088

2

        provider += seconds_offset;

2089

2

        assert_eq!(provider.ms_of_day, 5000);

2090

        // Add one day and test Add operator

2091

2

        let provider2 = provider + Duration::from_secs(60 * 60 * 24);

2092

2

        assert_eq!(provider2.ccsds_days, u16::MAX as u32 + 1);

2093

2

        assert_eq!(provider2.ms_of_day, 5000);

2094

2

2095

2096

    #[test]

2097

2

    fn test_dyn_creation_u24_days() {

2098

2

        let stamp = CdsTime::new_with_u24_days(u16::MAX as u32 + 1, 24).unwrap();

2099

2

        let mut buf: [u8; 32] = [0; 32];

2100

2

        stamp.write_to_bytes(&mut buf).unwrap();

2101

2

        let dyn_provider = get_dyn_time_provider_from_bytes(&buf);

2102

2

        assert!(dyn_provider.is_ok());

2103

2

        let dyn_provider = dyn_provider.unwrap();

2104

2

        assert_eq!(dyn_provider.ccdsd_time_code(), CcsdsTimeCode::Cds);

2105

2

        assert_eq!(dyn_provider.ccsds_days_as_u32(), u16::MAX as u32 + 1);

2106

2

        assert_eq!(dyn_provider.ms_of_day(), 24);

2107

2

        assert_eq!(

2108

2

            dyn_provider.submillis_precision(),

2109

2

            SubmillisPrecision::Absent

2110

2

);

2111

2

        assert_eq!(

2112

2

            dyn_provider.len_of_day_seg(),

2113

2

            LengthOfDaySegment::Long24Bits

2114

2

);

2115

2

2116

2117

    #[test]

2118

2

    fn test_addition_with_us_precision_u16_days() {

2119

2

        let mut provider = CdsTime::new_with_u16_days(0, 0);

2120

2

        provider.set_submillis(SubmillisPrecision::Microseconds, 0);

2121

2

        let duration = Duration::from_micros(500);

2122

2

        provider += duration;

2123

2

        assert_eq!(

2124

2

            provider.submillis_precision(),

2125

2

            SubmillisPrecision::Microseconds

2126

2

);

2127

2

        assert_eq!(provider.submillis(), 500);

2128

2

2129

2130

    #[test]

2131

2

    fn test_addition_with_us_precision_u16_days_with_subsec_millis() {

2132

2

        let mut provider = CdsTime::new_with_u16_days(0, 0);

2133

2

        provider.set_submillis(SubmillisPrecision::Microseconds, 0);

2134

2

        let duration = Duration::from_micros(1200);

2135

2

        provider += duration;

2136

2

        assert_eq!(

2137

2

            provider.submillis_precision(),

2138

2

            SubmillisPrecision::Microseconds

2139

2

);

2140

2

        assert_eq!(provider.submillis(), 200);

2141

2

        assert_eq!(provider.ms_of_day(), 1);

2142

2

2143

2144

    #[test]

2145

2

    fn test_addition_with_us_precision_u16_days_carry_over() {

2146

2

        let mut provider = CdsTime::new_with_u16_days(0, 0);

2147

2

        provider.set_submillis(SubmillisPrecision::Microseconds, 800);

2148

2

        let duration = Duration::from_micros(400);

2149

2

        provider += duration;

2150

2

2151

2

        assert_eq!(

2152

2

            provider.submillis_precision(),

2153

2

            SubmillisPrecision::Microseconds

2154

2

);

2155

2

        assert_eq!(provider.submillis(), 200);

2156

2

        assert_eq!(provider.ms_of_day(), 1);

2157

2

2158

2159

    #[test]

2160

2

    fn test_addition_with_ps_precision_u16_days() {

2161

2

        let mut provider = CdsTime::new_with_u16_days(0, 0);

2162

2

        provider.set_submillis(SubmillisPrecision::Picoseconds, 0);

2163

2

        // 500 us as ns

2164

2

        let duration = Duration::from_nanos(500 * 10u32.pow(3) as u64);

2165

2

        provider += duration;

2166

2

2167

2

        assert_eq!(

2168

2

            provider.submillis_precision(),

2169

2

            SubmillisPrecision::Picoseconds

2170

2

);

2171

2

        assert_eq!(provider.submillis(), 500 * 10u32.pow(6));

2172

2

2173

2174

    #[test]

2175

2

    fn test_addition_on_ref() {

2176

2

        // This test case also tests the case where there is no submillis precision but subsecond

2177

2

        // milliseconds.

2178

2

        let provider_ref = &CdsTime::new_with_u16_days(2, 500);

2179

2

        let new_stamp = provider_ref + Duration::from_millis(2 * 24 * 60 * 60 * 1000 + 500);

2180

2

        assert_eq!(new_stamp.ccsds_days_as_u32(), 4);

2181

2

        assert_eq!(new_stamp.ms_of_day, 1000);

2182

2

2183

2184

4

    fn check_ps_and_carryover(prec: SubmillisPrecision, submillis: u32, ms_of_day: u32, val: u32) {

2185

4

        if prec == SubmillisPrecision::Picoseconds {

2186

4

            assert_eq!(submillis, val);

2187

4

            assert_eq!(ms_of_day, 1);

2188

        } else {

2189

            panic!("invalid precision {:?}", prec)

2190

2191

4

2192

    #[test]

2193

2

    fn test_addition_with_ps_precision_u16_days_with_subsec_millis() {

2194

2

        let mut provider = CdsTime::new_with_u16_days(0, 0);

2195

2

        provider.set_submillis(SubmillisPrecision::Picoseconds, 0);

2196

2

        // 1200 us as ns

2197

2

        let duration = Duration::from_nanos(1200 * 10u32.pow(3) as u64);

2198

2

        provider += duration;

2199

2

        check_ps_and_carryover(

2200

2

            provider.submillis_precision(),

2201

2

            provider.submillis(),

2202

2

            provider.ms_of_day,

2203

2

            200 * 10_u32.pow(6),

2204

2

);

2205

2

2206

2207

    #[test]

2208

2

    fn test_addition_with_ps_precision_u16_days_carryover() {

2209

2

        let mut provider = CdsTime::new_with_u16_days(0, 0);

2210

2

        // 800 us as ps

2211

2

        provider.set_submillis(SubmillisPrecision::Picoseconds, 800 * 10_u32.pow(6));

2212

2

        // 400 us as ns

2213

2

        let duration = Duration::from_nanos(400 * 10u32.pow(3) as u64);

2214

2

        provider += duration;

2215

2

        check_ps_and_carryover(

2216

2

            provider.submillis_precision(),

2217

2

            provider.submillis(),

2218

2

            provider.ms_of_day,

2219

2

            200 * 10_u32.pow(6),

2220

2

);

2221

2

2222

2223

    #[test]

2224

2

    fn test_dyn_creation_u16_days_with_precision() {

2225

2

        let mut stamp = CdsTime::new_with_u16_days(24, 24);

2226

2

        stamp.set_submillis(SubmillisPrecision::Microseconds, 666);

2227

2

        let mut buf: [u8; 32] = [0; 32];

2228

2

        stamp.write_to_bytes(&mut buf).unwrap();

2229

2

        let dyn_provider = get_dyn_time_provider_from_bytes(&buf);

2230

2

        assert!(dyn_provider.is_ok());

2231

2

        let dyn_provider = dyn_provider.unwrap();

2232

2

        assert_eq!(dyn_provider.ccdsd_time_code(), CcsdsTimeCode::Cds);

2233

2

        assert_eq!(dyn_provider.ccsds_days_as_u32(), 24);

2234

2

        assert_eq!(dyn_provider.ms_of_day(), 24);

2235

2

        assert_eq!(

2236

2

            dyn_provider.len_of_day_seg(),

2237

2

            LengthOfDaySegment::Short16Bits

2238

2

);

2239

2

        assert_eq!(

2240

2

            dyn_provider.submillis_precision(),

2241

2

            SubmillisPrecision::Microseconds

2242

2

);

2243

2

        assert_eq!(dyn_provider.submillis(), 666);

2244

2

2245

2246

    #[test]

2247

2

    fn test_new_u24_days_too_large() {

2248

2

        let time_provider = CdsTime::new_with_u24_days(2_u32.pow(24), 0);

2249

2

        assert!(time_provider.is_err());

2250

2

        let e = time_provider.unwrap_err();

2251

2

        if let CdsError::InvalidCcsdsDays(days) = e {

2252

2

            assert_eq!(days, 2_u32.pow(24) as i64);

2253

        } else {

2254

            panic!("unexpected error {}", e)

2255

2256

2

2257

2258

    #[test]

2259

2

    fn test_from_dt_invalid_time() {

2260

2

        // Date before CCSDS epoch

2261

2

        let datetime_utc = NaiveDate::from_ymd_opt(1957, 12, 31)

2262

2

            .unwrap()

2263

2

            .and_hms_milli_opt(23, 59, 59, 999)

2264

2

            .unwrap()

2265

2

            .and_local_timezone(chrono::Utc)

2266

2

            .unwrap();

2267

2

        let time_provider = CdsTime::from_dt_with_u24_days(&datetime_utc);

2268

2

        assert!(time_provider.is_err());

2269

2

        if let CdsError::DateBeforeCcsdsEpoch(DateBeforeCcsdsEpochError(dt)) =

2270

2

            time_provider.unwrap_err()

2271

2272

2

            assert_eq!(dt, datetime_utc.into());

2273

2274

2

2275

2276

    #[test]

2277

2

    fn test_eq() {

2278

2

        let stamp0 = CdsTime::new_with_u16_days(0, 0);

2279

2

        let mut buf: [u8; 7] = [0; 7];

2280

2

        stamp0.write_to_bytes(&mut buf).unwrap();

2281

2

        let stamp1 = CdsTime::from_bytes_with_u16_days(&buf).unwrap();

2282

2

        assert_eq!(stamp0, stamp1);

2283

2

        assert!(stamp0 >= stamp1);

2284

2

        assert!(stamp1 <= stamp0);

2285

2

2286

2287

    #[test]

2288

2

    fn test_ord() {

2289

2

        let stamp0 = CdsTime::new_with_u24_days(0, 0).unwrap();

2290

2

        let stamp1 = CdsTime::new_with_u24_days(0, 50000).unwrap();

2291

2

        let mut stamp2 = CdsTime::new_with_u24_days(0, 50000).unwrap();

2292

2

        stamp2.set_submillis(SubmillisPrecision::Microseconds, 500);

2293

2

        let stamp3 = CdsTime::new_with_u24_days(1, 0).unwrap();

2294

2

        assert!(stamp1 > stamp0);

2295

2

        assert!(stamp2 > stamp0);

2296

2

        assert!(stamp2 > stamp1);

2297

2

        assert!(stamp3 > stamp0);

2298

2

        assert!(stamp3 > stamp1);

2299

2

        assert!(stamp3 > stamp2);

2300

2

2301

2302

    #[test]

2303

2

    fn test_conversion() {

2304

2

        let mut stamp_small = CdsTime::new_with_u16_days(u16::MAX, 500);

2305

2

        let stamp_larger: CdsTime<DaysLen24Bits> = stamp_small.into();

2306

2

        assert_eq!(stamp_larger.ccsds_days_as_u32(), u16::MAX as u32);

2307

2

        assert_eq!(stamp_larger.ms_of_day(), 500);

2308

2

        stamp_small = stamp_larger.try_into().unwrap();

2309

2

        assert_eq!(stamp_small.ccsds_days_as_u32(), u16::MAX as u32);

2310

2

        assert_eq!(stamp_small.ms_of_day(), 500);

2311

2

2312

2313

    #[test]

2314

    #[cfg_attr(miri, ignore)]

2315

2

    fn test_update_from_now() {

2316

2

        let mut stamp = CdsTime::new_with_u16_days(0, 0);

2317

2

        let _ = stamp.update_from_now();

2318

2

        let dt = stamp.unix_time().chrono_date_time().unwrap();

2319

2

        assert!(dt.year() > 2020);

2320

2

2321

2322

    #[test]

2323

2

    fn test_setting_submillis_precision() {

2324

2

        let mut provider = CdsTime::new_with_u16_days(0, 15);

2325

2

        provider.set_submillis(SubmillisPrecision::Microseconds, 500);

2326

2

2327

2328

    #[test]

2329

    #[cfg(feature = "serde")]

2330

    #[cfg_attr(miri, ignore)]

2331

2

    fn test_serialization() {

2332

2

        let stamp_now = CdsTime::now_with_u16_days().expect("Error retrieving time");

2333

2

        let val = to_allocvec(&stamp_now).expect("Serializing timestamp failed");

2334

2

        assert!(val.len() > 0);

2335

2

        let stamp_deser: CdsTime = from_bytes(&val).expect("Stamp deserialization failed");

2336

2

        assert_eq!(stamp_deser, stamp_now);

2337

2

2338

2339

30

    fn generic_dt_property_equality_check(first: u32, second: u32, start: u32, end: u32) {

2340

30

        if second < first {

2341

            assert_eq!(second, start);

2342

            assert_eq!(first, end);

2343

30

        } else if second > first {

2344

            assert_eq!(second - first, 1);

2345

        } else {

2346

30

            assert_eq!(first, second);

2347

2348

30

2349

2350

    #[test]

2351

2

    fn test_stamp_to_vec_u16() {

2352

2

        let stamp = CdsTime::new_with_u16_days(1, 1);

2353

2

        let stamp_vec = stamp.to_vec().unwrap();

2354

2

        let mut buf: [u8; 7] = [0; 7];

2355

2

        stamp.write_to_bytes(&mut buf).unwrap();

2356

2

        assert_eq!(stamp_vec, buf);

2357

2

2358

2359

    #[test]

2360

2

    fn test_stamp_to_vec_u24() {

2361

2

        let stamp = CdsTime::new_with_u24_days(1, 1).unwrap();

2362

2

        let stamp_vec = stamp.to_vec().unwrap();

2363

2

        let mut buf: [u8; 10] = [0; 10];

2364

2

        stamp.write_to_bytes(&mut buf).unwrap();

2365

2

        assert_eq!(stamp_vec, buf[..stamp.len_written()]);

2366

2

2367

2368

    #[test]

2369

    #[cfg(feature = "timelib")]

2370

2

    fn test_timelib_stamp() {

2371

2

        let stamp = CdsTime::new_with_u16_days(0, 0);

2372

2

        let timelib_dt = stamp.timelib_date_time().unwrap();

2373

2

        assert_eq!(timelib_dt.year(), 1958);

2374

2

        assert_eq!(timelib_dt.month(), time::Month::January);

2375

2

        assert_eq!(timelib_dt.day(), 1);

2376

2

        assert_eq!(timelib_dt.hour(), 0);

2377

2

        assert_eq!(timelib_dt.minute(), 0);

2378

2

        assert_eq!(timelib_dt.second(), 0);

2379

2

2380