clock-time.h

Go to the documentation of this file.

/*
 * Present - Date/Time Library
 *
 * Definition of the ClockTime structure and declarations of the corresponding
 * functions
 *
 * This file may be included individually ONLY if being used by a C compiler.
 * However, it is recommended (and required for C++ projects) to include
 * "present.h" rather than these individual header files.
 *
 * Licensed under the MIT License.
 * For details, see LICENSE.
 */

#include <time.h>

#include "present/internal/cpp-guard.h"
#include "present/internal/header-utils.h"
#include "present/internal/types.h"

#include "present/internal/present-clock-time-data.h"

#ifndef _PRESENT_CLOCK_TIME_H_
#define _PRESENT_CLOCK_TIME_H_

/*
 * Forward Declarations
 */

struct TimeDelta;

/*
 * C++ Class / C Struct Definition
 */

struct PRESENT_API ClockTime {
    present_bool has_error;

    struct {
        unsigned int hour_out_of_range          : 1,
                     minute_out_of_range        : 1,
                     second_out_of_range        : 1,
                     nanosecond_out_of_range    : 1;
    } errors;

    /* Internal data representation */
    struct PresentClockTimeData data_;

#ifdef __cplusplus

    static ClockTime create(int_hour hour);

    static ClockTime create(int_hour hour, int_minute minute);

    static ClockTime create(
            int_hour hour,
            int_minute minute,
            int_second second);

    static ClockTime create(
            int_hour hour,
            int_minute minute,
            int_second second,
            int_nanosecond nanosecond);

    static ClockTime create_with_decimal_seconds(
            int_hour hour,
            int_minute minute,
            double second);

    static ClockTime midnight(void);

    static ClockTime noon();

    int_hour hour() const;

    int_minute minute() const;

    int_second second() const;

    int_nanosecond nanosecond() const;

    double second_decimal() const;

    TimeDelta time_since_midnight() const;

    ClockTime & operator+=(const TimeDelta & delta);
    ClockTime & operator-=(const TimeDelta & delta);

    friend const ClockTime operator+(
            const ClockTime & lhs,
            const TimeDelta & rhs);
    friend const ClockTime operator+(
            const TimeDelta & lhs,
            const ClockTime & rhs);

    friend const ClockTime operator-(
            const ClockTime & lhs,
            const TimeDelta & rhs);

    static short compare(const ClockTime & lhs, const ClockTime & rhs);

    friend bool operator==(const ClockTime & lhs, const ClockTime & rhs);
    friend bool operator!=(const ClockTime & lhs, const ClockTime & rhs);

    friend bool operator<(const ClockTime & lhs, const ClockTime & rhs);
    friend bool operator<=(const ClockTime & lhs, const ClockTime & rhs);
    friend bool operator>(const ClockTime & lhs, const ClockTime & rhs);
    friend bool operator>=(const ClockTime & lhs, const ClockTime & rhs);
#endif
};

/*
 * C Method Declarations
 */

#ifdef __cplusplus
extern "C" {
#endif

PRESENT_API struct ClockTime
ClockTime_from_hour(int_hour hour);

PRESENT_API void
ClockTime_ptr_from_hour(struct ClockTime * const result, int_hour hour);

PRESENT_API struct ClockTime
ClockTime_from_hour_minute(int_hour hour, int_minute minute);

PRESENT_API void
ClockTime_ptr_from_hour_minute(
        struct ClockTime * const result,
        int_hour hour,
        int_minute minute);

PRESENT_API struct ClockTime
ClockTime_from_hour_minute_second(
        int_hour hour,
        int_minute minute,
        int_second second);

PRESENT_API void
ClockTime_ptr_from_hour_minute_second(
        struct ClockTime * const result,
        int_hour hour,
        int_minute minute,
        int_second second);

PRESENT_API struct ClockTime
ClockTime_from_hour_minute_second_nanosecond(
        int_hour hour,
        int_minute minute,
        int_second second,
        int_nanosecond nanosecond);

PRESENT_API void
ClockTime_ptr_from_hour_minute_second_nanosecond(
        struct ClockTime * const result,
        int_hour hour,
        int_minute minute,
        int_second second,
        int_nanosecond nanosecond);

#define ClockTime_create(...)    \
    PRESENT_OVERLOAD_MAX_4(__VA_ARGS__,                 \
        ClockTime_from_hour_minute_second_nanosecond,   \
        ClockTime_from_hour_minute_second,              \
        ClockTime_from_hour_minute,                     \
        ClockTime_from_hour,                            \
        dummy)(__VA_ARGS__)

#define ClockTime_ptr_create(result, ...)   \
    PRESENT_OVERLOAD_MAX_4(__VA_ARGS__,                     \
        ClockTime_ptr_from_hour_minute_second_nanosecond,   \
        ClockTime_ptr_from_hour_minute_second,              \
        ClockTime_ptr_from_hour_minute,                     \
        ClockTime_ptr_from_hour,                            \
        dummy)(result, __VA_ARGS__)

PRESENT_API struct ClockTime
ClockTime_create_with_decimal_seconds(
        int_hour hour,
        int_minute minute,
        double second);

PRESENT_API void
ClockTime_ptr_create_with_decimal_seconds(
        struct ClockTime * const result,
        int_hour hour,
        int_minute minute,
        double second);

PRESENT_API struct ClockTime
ClockTime_midnight(void);

PRESENT_API void
ClockTime_ptr_midnight(struct ClockTime * const result);

PRESENT_API struct ClockTime
ClockTime_noon(void);

PRESENT_API void
ClockTime_ptr_noon(struct ClockTime * const result);

PRESENT_API int_hour
ClockTime_hour(const struct ClockTime * const self);

PRESENT_API int_minute
ClockTime_minute(const struct ClockTime * const self);

PRESENT_API int_second
ClockTime_second(const struct ClockTime * const self);

PRESENT_API int_nanosecond
ClockTime_nanosecond(const struct ClockTime * const self);

PRESENT_API double
ClockTime_second_decimal(const struct ClockTime * const self);

PRESENT_API struct TimeDelta
ClockTime_time_since_midnight(const struct ClockTime * const self);

PRESENT_API void
ClockTime_add_TimeDelta(
        struct ClockTime * const self,
        const struct TimeDelta * const delta);

PRESENT_API void
ClockTime_subtract_TimeDelta(
        struct ClockTime * const self,
        const struct TimeDelta * const delta);

PRESENT_API short
ClockTime_compare(
        const struct ClockTime * const lhs,
        const struct ClockTime * const rhs);

PRESENT_API present_bool
ClockTime_equal(
        const struct ClockTime * const lhs,
        const struct ClockTime * const rhs);

PRESENT_API present_bool
ClockTime_less_than(
        const struct ClockTime * const lhs,
        const struct ClockTime * const rhs);

PRESENT_API present_bool
ClockTime_less_than_or_equal(
        const struct ClockTime * const lhs,
        const struct ClockTime * const rhs);

PRESENT_API present_bool
ClockTime_greater_than(
        const struct ClockTime * const lhs,
        const struct ClockTime * const rhs);

PRESENT_API present_bool
ClockTime_greater_than_or_equal(
        const struct ClockTime * const lhs,
        const struct ClockTime * const rhs);

#ifdef __cplusplus
}
#endif

#endif /* _PRESENT_CLOCK_TIME_H_ */