datetime.h

Go to the documentation of this file.

// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
// Copyright (C) 2015 Cherokees of Idaho.
//
// This file is part of GNU uCommon C++.
//
// GNU uCommon C++ is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU uCommon C++ is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef _UCOMMON_DATETIME_H_
#define _UCOMMON_DATETIME_H_
 
#ifndef _UCOMMON_CONFIG_H_
#include <ucommon/platform.h>
#endif
 
#ifndef _UCOMMON_NUMBERS_H_
#include <ucommon/numbers.h>
#endif
 
#ifndef _UCOMMON_TYPEREF_H_
#include <ucommon/typeref.h>
#endif
 
#ifndef _MSWINDOWS_
#include <unistd.h>
#include <sys/time.h>
#endif
 
#include <time.h>
 
#define DATE_STRING_SIZE        10
#define DATE_BUFFER_SIZE        11
#define TIME_STRING_SIZE        8
#define TIME_BUFFER_SIZE        9
#define DATETIME_STRING_SIZE    19
#define DATETIME_BUFFER_SIZE    20
 
typedef struct tm   tm_t;
 
namespace ucommon {
 
#ifdef __BORLANDC__
    using std::tm;
    using std::time_t;
#endif
 
class __EXPORT Date
{
protected:
    long julian;
 
    void set(long year, long month, long day);
 
    virtual void update(void);
 
public:
    static const size_t sz_string;
 
    Date(time_t value);
 
    Date(const struct tm *object);
 
    Date(const char *pointer, size_t size = 0);
 
    Date(int year, unsigned month, unsigned day);
 
    Date(const Date& object);
 
    Date();
 
    virtual ~Date();
 
    int year(void) const;
 
    unsigned month(void) const;
 
    unsigned day(void) const;
 
    unsigned dow(void) const;
 
    const char *put(char *buffer) const;
 
    time_t timeref(void) const;
 
    long get(void) const;
 
    void set(void);
 
    void set(const char *pointer, size_t size = 0);
 
    bool is_valid(void) const;
 
    inline operator long() const {
        return get();
    }
 
    inline long operator*() const {
        return get();
    }
 
    stringref_t operator()() const;
 
    Date& operator++();
 
    Date& operator--();
 
    Date& operator+=(long offset);
 
    Date& operator-=(long offset);
 
    const Date operator+(long days) const;
 
    const Date operator-(long days) const;
 
    inline long operator-(const Date &date) {
        return (julian - date.julian);
    }
 
    Date& operator=(const Date& date);
 
    bool operator==(const Date& date) const;
 
    bool operator!=(const Date& date) const;
 
    bool operator<(const Date& date) const;
 
    bool operator<=(const Date& date) const;
 
    bool operator>(const Date& date) const;
 
    bool operator>=(const Date& date) const;
 
    inline bool operator!() const {
        return !is_valid();
    }
 
    inline operator bool() const {
        return is_valid();
    }
};
 
class __EXPORT Time
{
protected:
    long seconds;
 
protected:
    virtual void update(void);
 
public:
    void set(int hour, int minute = 0, int second = 0);
 
    static const long c_day;
 
    static const long c_hour;
 
    static const long c_week;
 
    static const size_t sz_string;
 
    Time(const time_t value);
 
    Time(const tm_t *object);
 
    Time(const char *pointer, size_t size = 0);
 
    Time(int hour, int minute, int second);
 
    Time(const Time& object);
 
    Time();
 
    virtual ~Time();
 
    long get(void) const;
 
    int hour(void) const;
 
    int minute(void) const;
 
    int second(void) const;
 
    const char *put(char *buffer) const;
 
    void set(void);
 
    void set(const char *pointer, size_t size = 0);
 
    bool is_valid(void) const;
 
    inline operator bool() const {
        return is_valid();
    }
 
    inline bool operator!() const {
        return !is_valid();
    }
 
    long operator-(const Time &reference);
 
    const Time operator+(long seconds) const;
 
    const Time operator-(long seconds) const;
 
    inline operator long() const {
        return get();
    }
 
    inline long operator*() const {
        return get();
    }
 
    stringref_t operator()() const;
 
    Time& operator++();
 
    Time& operator--();
 
    Time& operator=(const Time& time);
 
    Time& operator+=(long seconds);
 
    Time& operator-=(long seconds);
 
    bool operator==(const Time &time) const;
 
    bool operator!=(const Time &time) const;
 
    bool operator<(const Time &time) const;
 
    bool operator<=(const Time &time) const;
 
    bool operator>(const Time &time) const;
 
    bool operator>=(const Time &time) const;
};
 
class __EXPORT DateTime : public Date, public Time
{
protected:
    virtual void update(void) __OVERRIDE;
 
public:
    static const size_t sz_string;
 
    DateTime(const time_t time);
 
    DateTime(const tm_t *tm);
 
    DateTime(const char *pointer, size_t size = 0);
 
    DateTime(int year, unsigned month, unsigned day,
         int hour = 0, int minute = 0, int second = 0);
 
    DateTime(const DateTime& object);
 
    DateTime();
 
    virtual ~DateTime();
 
    const char *put(char *buffer) const;
 
    time_t get(void) const;
 
    bool is_valid(void) const;
 
    long operator-(const DateTime &datetime);
 
    DateTime& operator=(const DateTime& datetime);
 
    DateTime& operator+=(long seconds);
 
    DateTime& operator-=(long seconds);
 
    const DateTime operator+(long seconds) const;
 
    const DateTime operator-(long seconds) const;
 
    DateTime& operator++();
 
    DateTime& operator--();
 
    bool operator==(const DateTime& datetime) const;
 
    bool operator!=(const DateTime& datetime) const;
 
    bool operator<(const DateTime& datetime) const;
 
    bool operator<=(const DateTime& datetime) const;
 
    bool operator>(const DateTime& datetime) const;
 
    bool operator>=(const DateTime& datetime) const;
 
    bool operator!() const;
 
    operator bool() const;
 
    inline operator long() const {
        return Date::get();
    }
 
    void set(void);
 
    operator double() const;
 
    stringref_t format(const char *strftime) const;
 
    static tm_t *local(const time_t *time = NULL);
 
    static tm_t *gmt(const time_t *time = NULL);
 
    static void release(tm_t *object);
};
 
class __EXPORT DateTimeString : public DateTime
{
public:
    typedef enum {
        DATE, TIME, BOTH
    } mode_t;
 
private:
    char buffer[DATETIME_BUFFER_SIZE];
    mode_t mode;
 
protected:
    virtual void update(void) __OVERRIDE;
 
public:
    DateTimeString(const time_t time);
 
    DateTimeString(const tm_t *tm);
 
    DateTimeString(const char *pointer, size_t size = 0);
 
    DateTimeString(int year, unsigned month, unsigned day,
         int hour = 0, int minute = 0, int second = 0);
 
    DateTimeString(const DateTimeString& object);
 
    DateTimeString(mode_t string = DateTimeString::BOTH);
 
    virtual ~DateTimeString();
 
    inline const char *c_str(void) const {
        return buffer;
    }
 
    inline operator const char *(void) const {
        return buffer;
    }
 
    void set(void);
 
    void set(mode_t string);
};
 
class __EXPORT DateNumber : public Number, public Date
{
protected:
    virtual void update(void) __OVERRIDE;
 
public:
    DateNumber(char *pointer);
 
    virtual ~DateNumber();
 
    void set(void);
};
 
class __EXPORT isotime : public __PROTOCOL PrintProtocol, public __PROTOCOL InputProtocol
{
private:
    Date *d;
    Time *t;
 
    enum {
        DATE, TIME, DATETIME
    } mode;
 
    char buf[32];
    unsigned pos;
 
protected:
    const char *_print(void) const;
 
    int _input(int code) __OVERRIDE;
 
public:
    isotime(Date& date, Time& time);
    isotime(Date& date);
    isotime(Time& time);
};
 
typedef DateTime    datetime_t;
 
typedef DateTimeString  datetimestring_t;
 
typedef Date        date_t;
 
typedef Time        tod_t;
 
} // namespace ucommon
 
#endif