chrono.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Andreas Huggel (ahu)
             Rene Schneider (rsn)
             Stephan Broennimann (vb)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.74 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file 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 General Public License
   for more details.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _CHRONO_H_
#define _CHRONO_H_

// *********************************************************************
// included header files
// + standard includes
#include <string>

// + local headers

// *********************************************************************
// namespace extensions
namespace OSB_LIB {

// *********************************************************************
// type definitions

    enum Weekday { Mon = 1, Tue, Wed, Thu, Fri, Sat, Sun };

    enum Month { Jan = 1, Feb, Mar, Apr, May, Jun,
                     Jul, Aug, Sep, Oct, Nov, Dec };

// *********************************************************************
// class declarations

    class Date {
    public:
        static const int daytab_[2][13];
    public:
        inline Date();

        Date(int dd, Month mm, int yy);
        explicit Date(
            const std::string& src,
            const std::string& format = "%d-%m-%Y"
        );
        Date(Weekday dd, int ww, Month mm, int yy);

    public:


        static Date today();
        static inline const Date min();
        static inline const Date max();



        bool isSet() const;
        bool notSet() const;
        int day() const;
        Month month() const;
        int year() const;
        int dayOfYear() const;
        Weekday dayOfWeek() const;
        inline void getDmy(int& day, Month& mon, int& year) const;

        std::string str(
            const std::string& format = "%d-%m-%Y"
        ) const;



        Date& addYears(int n);
        Date& addMonths(int n);
        Date& addDays(long n);



        long operator- (const Date& b) const { return j_ -  b.j_; }
        bool operator==(const Date& b) const { return j_ == b.j_; }
        bool operator!=(const Date& b) const { return j_ != b.j_; }
        bool operator< (const Date& b) const { return j_ <  b.j_; }
        bool operator> (const Date& b) const { return j_ >  b.j_; }
        bool operator<=(const Date& b) const { return j_ <= b.j_; }
        bool operator>=(const Date& b) const { return j_ >= b.j_; }

    private:
        static const int baseYear_;
        static const int monday_;
        static const int minDay_;
        static const int maxDay_;

    private:
        explicit Date(long days);
        void dmy2j(int dd, Month mm, int yy);
        void j2dmy(int &dd, Month& mm, int& yy) const;

    private:
        long j_;
    };                                  // class Date



    inline bool leapyear(int year);
    inline int lastDay(Month, int year);


    Date& operator+=(Date&, long);
    Date& operator-=(Date&, long);
    Date& operator++(Date&);
    Date  operator++(Date&, int);
    Date& operator--(Date&);
    Date  operator--(Date&, int);
    Date  operator+ (Date, long);
    Date  operator- (Date, long);

    class Time {
    public:
        explicit Time(int sec = 0);
        Time(int hour, int min, int sec);
        explicit Time(const std::string& src);

    public:
        static Time now();



        int hour() const;
        int minute() const;
        int second() const;
        long numSeconds() const;
        std::string str() const;
        inline void getHms(int& hour, int& min, int& sec) const
        {
            return t2hms(hour, min, sec);
        }



        Time& addHours(int);
        Time& addMinutes(int);
        Time& addSeconds(long);



        Time& operator+ (const Time&);
        Time& operator+= (const Time&);
        Time& operator- (const Time&);
        Time& operator-= (const Time&);



        bool operator==(const Time&) const;
        bool operator!=(const Time&) const;
        bool operator< (const Time&) const;
        bool operator> (const Time&) const;
        bool operator<=(const Time&) const;
        bool operator>=(const Time&) const;

    private:
        long t_;
        void hms2t(int hour, int min, int sec);
        void t2hms(int &hour, int &min, int& sec) const;
    };

    class DateTime {
    public:
        class Offset {
            friend class DateTime;
        private:
            enum Status {
                notSet = 0,
                gmtOnly,
                gmtSys
            };
        public:
            inline Offset();
            inline Offset(long utcOff);
            inline bool isSet() const;
            inline long utcOff() const;
        private:
            Status status_;
            long   offGmt_;
            long   offSys_;
        };
    public:
        DateTime() {}

        explicit inline DateTime(
            const Date&  date,
            const Time&  time   = Time(),
                  Offset offset = Offset()
        );

        explicit DateTime(
            time_t sec,
            Offset offset = Offset()
        );

        explicit DateTime(
            const std::string& src,
            const std::string& format = "%d-%m-%Y %T",
            Offset offset = Offset()
        );

    public:


        static DateTime now();
        static inline const DateTime min();
        static inline const DateTime max();

        static inline long getTimezone();



        inline bool isSet() const;
        inline bool notSet() const;
        const Date& date() const { return d_; }
        const Time& time() const { return t_; }
        int day() const;
        Month month() const;
        int year() const;
        int hour() const;
        int minute() const;
        int second() const;
        const Offset& offset() const;
        std::string strLocale() const;
        std::string str() const;
        std::string strTs() const;
        std::string strTsLoc() const;



        DateTime& addDays(long);
        DateTime& addMonths(int);
        DateTime& addYears(int);
        DateTime& addHours(int);
        DateTime& addMinutes(int);
        DateTime& addSeconds(long);



        DateTime& operator+ (const Time&);
        DateTime& operator+= (const Time&);
        DateTime& operator- (const Time&);
        DateTime& operator-= (const Time&);



        bool operator==(const DateTime&) const;
        bool operator!=(const DateTime&) const;
        bool operator< (const DateTime&) const;
        bool operator> (const DateTime&) const;
        bool operator<=(const DateTime&) const;
        bool operator>=(const DateTime&) const;

    private:
        void normalize();

        void applyOffset();
    private:
        Date d_;
        Time t_;
        Offset offset_;
    };                                  // class DateTime
}                                       // namespace OSB_LIB

// *********************************************************************
// inline definitions
namespace OSB_LIB {
    inline bool leapyear(int yy)
    {
        return yy % 4 == 0 && yy % 100 != 0 || yy % 400 == 0;
    }

    inline int lastDay(Month mm, int yy)
    {
        int rc = 0;
        if (mm < 1 || mm > 12) {
            rc = -1;            // could I throw an exception here?
        }
        else {
            rc = Date::daytab_[leapyear(yy)][mm];
        }
        return rc;
    }

    // ********************************************************************
    // class Date
    inline Date::Date() : j_(minDay_-1)
    {
        // empty
    }

    inline Date::Date(long days) : j_(days)
    {
        // empty
    }

    inline const Date Date::min()
    {
        return Date(minDay_);
    }

    inline const Date Date::max()
    {
        return Date(maxDay_);
    }

    inline bool Date::notSet() const
    {
        return j_ == minDay_-1;
    }

    inline bool Date::isSet() const
    {
        return !notSet();
    }

    inline Date& Date::addDays(long n)
    {
        j_ += n;
        return *this;
    }

    inline void Date::getDmy(int& day, Month& mon, int& year) const
    {
        return j2dmy(day, mon, year);
    }

    // ********************************************************************
    // class Time
    inline Time::Time(int sec)
      : t_(sec)
    {
        // empty
    }

    inline long Time::numSeconds() const
    {
        return t_;
    }

    // ********************************************************************
    // class DateTime
    inline DateTime::DateTime(
        const Date&  date,
        const Time&  time,
              Offset offset
    ) : d_(date), t_(time), offset_(offset)
    {
        normalize();
        if (offset_.isSet()) applyOffset();
    }

    const DateTime DateTime::min()
    {
        return DateTime(Date::min());
    }

    const DateTime DateTime::max()
    {
        return DateTime(Date::max());
    }

    long DateTime::getTimezone()
    {
        tzset();
        return -1*::timezone;
    }

    inline bool DateTime::isSet() const
    {
        return d_.isSet();
    }

    inline bool DateTime::notSet() const
    {
        return d_.notSet();
    }

    // ********************************************************************
    // class DateTime::Offset
    inline DateTime::Offset::Offset()
      : status_(notSet), offGmt_(0), offSys_(0)
    {
        // empty
    }

    inline DateTime::Offset::Offset(long utcOff)
      : status_(gmtOnly), offGmt_(utcOff), offSys_(0)
    {
        // empty
    }

    inline bool DateTime::Offset::isSet() const
    {
        return notSet != status_;
    }

    inline long DateTime::Offset::utcOff() const
    {
        if (!isSet()) return -1;
        return offGmt_ + offSys_;
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _CHRONO_H_

---