cOrdinalDate

Overview

Types and Definitions

cOrdinalDate

struct cOrdinalDate
{
   int32_t year;
   int16_t day;
};
typedef struct cOrdinalDate cOrdinalDate;

A cOrdinalDate struct represents a ordinal date.

Generated

cOrdinalDateSlice

struct cOrdinalDateSlice
{
   int64_t s;
   cOrdinalDate const* v;
};
typedef struct cOrdinalDate cOrdinalDate;

Via the macros SLICE_DEF_C_ and SLICE_IMPL_C_ declared and implemented struct. The macros declare and implement also the following functions.

/* init */
cOrdinalDateSlice ordinal_date_slice_c( int64_t s, cOrdinalDate const* v );
cOrdinalDateSlice make_ordinal_date_slice_c( cOrdinalDate const* beg,
                                             cOrdinalDate const* end );
cOrdinalDateSlice empty_ordinal_date_slice_c( void );
/* sub */
cOrdinalDateSlice left_ordinal_date_slice_c( cOrdinalDateSlice slice,
                                             int64_t maxLen );
cOrdinalDateSlice mid_ordinal_date_slice_c( cOrdinalDateSlice slice,
                                            int64_t index );
cOrdinalDateSlice right_ordinal_date_slice_c( cOrdinalDateSlice slice,
                                              int64_t maxLen );
cOrdinalDateSlice sub_ordinal_date_slice_c( cOrdinalDateSlice slice,
                                            int64_t begIdx,
                                            int64_t endIdx );

cVarOrdinalDateSlice

struct cVarOrdinalDateSlice
{
   int64_t s;
   cOrdinalDate* v;
};
typedef struct cVarOrdinalDateSlice cVarOrdinalDateSlice;

Via the macros SLICE_DEF_C_ and SLICE_IMPL_C_ declared and implemented struct. The macros declare and implement also the following functions.

/* init */
cVarOrdinalDateSlice var_ordinal_date_slice_c( int64_t s, cOrdinalDate* v );
cVarOrdinalDateSlice make_var_ordinal_date_slice_c( cOrdinalDate* beg,
                                                    cOrdinalDate* end );
cVarOrdinalDateSlice empty_var_ordinal_date_slice_c( void );
/* sub */
cVarOrdinalDateSlice left_var_ordinal_date_slice_c( cVarOrdinalDateSlice slice,
                                                    int64_t maxLen );
cVarOrdinalDateSlice mid_var_ordinal_date_slice_c( cVarOrdinalDateSlice slice,
                                                   int64_t index );
cVarOrdinalDateSlice right_var_ordinal_date_slcie_c( cVarOrdinalDateSlice slice,
                                                     int64_t maxLen );
cVarOrdinalDateSlice sub_var_ordinal_date_slice_c( cVarOrdinalDateSlice slice,
                                                   int64_t begIdx,
                                                   int64_t endIdx );
/* var slice */
cOrdinalDateSlice as_ordinal_date_slice_c( cVarOrdinalDateSlice slice );
cVarOrdinalDateSlice cast_ordinal_date_slice_c( cVarOrdinalDateSlice slice,
                                                cOrdinalDateSlice sub );
int64_t set_ordinal_date_slice_c( cVarOrdinalDateSlice dst,
                                  cOrdinalDateSlice src );

Functions

overall

cmp_ordinal_date_c

int cmp_ordinal_date_c( cOrdinalDate a, cOrdinalDate b );

Compares two cOrdinalDate values and returns the three possible results:

<0

if a is earlier as b

0

if both dates are equal

>0

if a is later as b

Example
#include "clingo/lang/expect.h"
#include "clingo/time/cOrdinalDate.h"

int main( void )
{
   init_tap_c_();

   cOrdinalDate od = ordinal_date_c( 2014, 125 );
   cOrdinalDate before = ordinal_date_c( 2013, 256 );
   cOrdinalDate after = ordinal_date_c( 2014, 126 );

   expect_eq_c_( cmp_ordinal_date_c( od, od ) );
   expect_gt_c_( cmp_ordinal_date_c( od, before ) );
   expect_lt_c_( cmp_ordinal_date_c( od, after ) );

   return finish_tap_c_();
}

ordinal_date_c

cOrdinalDate ordinal_date_c( int64_t year, int64_t day );

Initialise a ordinal date with a year and day value.

ordinal_date_is_valid_c

bool ordinal_date_is_valid_c( cOrdinalDate od );

Returns true if the specified ordinal date is valid, otherwise false.

Example
#include "clingo/lang/expect.h"
#include "clingo/time/cOrdinalDate.h"

int main( void )
{
   init_tap_c_();

   expect_c_(  ordinal_date_is_valid_c( ordinal_date_c( 2014, 365 ) ) );
   expect_c_( !ordinal_date_is_valid_c( ordinal_date_c( 2014, 366 ) ) );

   expect_c_(  ordinal_date_is_valid_c( ordinal_date_c( 2012, 366 ) ) );
   expect_c_( !ordinal_date_is_valid_c( ordinal_date_c( 2012, 367 ) ) );

   return finish_tap_c_();
}

from

Example
#include "clingo/lang/expect.h"
#include "clingo/time/cOrdinalDate.h"

TEMP_SLICE_DEF_C_(
   test,
   {
      cYmd ymd;
      cOrdinalDate od;
   }
)
#define t_( ... ) ((test){__VA_ARGS__})

int main( void )
{
   init_tap_c_();

   testSlice tests = slice_c_( test,
      t_( ymd_c( 2021,  4, 29 ), ordinal_date_c( 2021, 119 ) )
   );

   for_each_c_( test const*, t, tests )
   {
      cRecorder* rec = &recorder_c_( 32 );
      write_ordinal_date_c_( rec, t->od );
      record_chars_c_( rec, " / " );
      write_ymd_c_( rec, t->ymd );
      tap_note_c( turn_into_cstr_c( rec ) );

      {  //-------------------------------------------- ordinal_date_from_ymd_c
         cOrdinalDate od = ordinal_date_from_ymd_c( t->ymd );

         write_ordinal_date_c_( rec, od );

         bool res = eq_c( cmp_ordinal_date_c( od, t->od ) );
         tap_desc_c( res, turn_into_cstr_c( rec ) );
      }
      {  //-------------------------------------------- ymd_from_ordinal_date_c
         cYmd ymd = ymd_from_ordinal_date_c( t->od );

         write_ymd_c_( rec, ymd );

         bool res = eq_c( cmp_ymd_c( ymd, t->ymd ) );
         tap_desc_c( res, turn_into_cstr_c( rec ) );
      }
   }

   return finish_tap_c_();
}

ordinal_date_from_ymd_c

cOrdinalDate ordinal_date_from_ymd_c( cYmd ymd );

Creates a cOrdinalDate value from a cYmd value. An invalid cYmd value leads to an invalid cOrdinalDate value.

ymd_from_ordinal_date_c

cYmd ymd_from_ordinal_date_c( cOrdinalDate od );

Creates a cYmd valud from a cOrdinalDate value. An invalid cOrdinalDate value leads to an invalid cYmd value.

io

The functions read_ordinal_date_c and write_ordinal_date_c are using the following format:

Table 1. format

C

The day of year as a number without a leading character

1 to 365

__C

The day of year as a number with leading spaces

1 to 365

CCC

The day of year as a number with leading zeros

001 to 365

YY

The year as a two digit number

00 to 99

YYYY

The year as a four digit number

like 1878

read_ordinal_date_c

#define read_ordinal_date_c_( Sca, Od )                                        \
   read_ordinal_day_c( (Sca), (Od), "" )
bool read_ordinal_date_c( cScanner sca[static 1],
                          cOrdinalDate od[static 1],
                          char const fmt[static 1] );

Reads a cOrdinalDate value from a text with a scanner. The function will use C_IsoOrdinalDate( "YYYY-CCC" ) as default format.

Example
#include "clingo/io/read.h"
#include "clingo/lang/expect.h"
#include "clingo/time/cOrdinalDate.h"

TEMP_SLICE_DEF_C_(
   test,
   {
      char const* inp;
      char const* fmt;
      cOrdinalDate exp;
      int err;
   }
)
#define t_( ... ) ((test){__VA_ARGS__})

int main( void )
{
   init_tap_c_();

   //********************************************************************* tests
   testSlice tests = slice_c_( test,
      t_( "2014-023", "YYYY-CCC", ordinal_date_c( 2014,  23 ) ),
      t_( "14/23", "YY/C", ordinal_date_c( 2014, 23 ) ),
      t_( "2014-DDD.1", "YYYY-DDD.C", ordinal_date_c( 2014, 1 ) )
   );

   for_each_c_( test const*, t, tests )
   {
      cScanner* sca = &cstr_scanner_c_( t->inp );

      cOrdinalDate od = ordinal_date_c( 1970, 1 );
      bool res = read_ordinal_date_c( sca, &od, t->fmt );
      res &= eq_c( cmp_ordinal_date_c( od, t->exp ) );

      cRecorder* rec = &recorder_c_( 32 );
      write_ordinal_date_c_( rec, od );
      tap_descf_c( res, "%s -> %s", t->fmt, turn_into_cstr_c( rec ) );
   }

   //**************************************************************** withErrors
   testSlice withErrors = slice_c_( test,
      t_( "", "YYYY-CC", ordinal_date_c( 1970, 1 ), c_NotAbleToReadValue )
   );

   for_each_c_( test const*, t, withErrors )
   {
      cScanner* sca = &cstr_scanner_c_( t->inp );

      cOrdinalDate od = ordinal_date_c( 1970, 1 );
      bool res = not read_ordinal_date_c( sca, &od, t->fmt );
      res &= ( sca->err == t->err );
      res &= eq_c( cmp_ordinal_date_c( od, t->exp ) );

      cRecorder* rec = &recorder_c_( 32 );
      write_ordinal_date_c_( rec, od );
      tap_descf_c( res, "%s -> %s", t->fmt, turn_into_cstr_c( rec ) );
   }
   return finish_tap_c_();
}

write_ordinal_date_c

#define write_ordinal_date_c_( Rec, Od )                                       \
   write_ordinal_date_c( (Rec), (Od), "" )
bool write_ordinal_date_c( cRecorder rec[static 1],
                           cOrdinalDate od,
                           char const fmt[static 1] );

Writes a cOrdinalDate value into the recorder. The function will use C_IsoOrdinalDate( "YYYY-CCC" ) as default format.

Example
#include "clingo/io/write.h"
#include "clingo/lang/expect.h"
#include "clingo/time/cOrdinalDate.h"

TEMP_SLICE_DEF_C_(
   test,
   {
      cOrdinalDate od;
      int err;
      char const* fmt;
      char const* exp;
   }
)
#define t_( ... ) ((test){__VA_ARGS__})

int main( void )
{
   init_tap_c_();

   cOrdinalDate od = ordinal_date_c( 2014, 23 );
   testSlice tests = slice_c_( test,
      t_( od, cNoError_, "YYYY-CCC", "2014-023" ),
      t_( od, cNoError_, "YY/C", "14/23" ),
      t_( od, c_InvalidWriteFormat, "YYYY-CC", "" ),
      t_( od, cNoError_, "YYYY-DDD", "2014-DDD" )
   );

   for_each_c_( test const*, t, tests )
   {
      cRecorder* rec = &recorder_c_( 32 );

      write_ordinal_date_c( rec, t->od, t->fmt );
      bool res = ( rec->err == t->err );
      res &= recorded_is_c( rec, t->exp );

      tap_descf_c( res, "test: %s -> %s", t->fmt, t->exp );
   }

   return finish_tap_c_();
}