[MERGE] libi2ncommon: (reinhard) added some (bit) operators to class WEEK.

[libi2ncommon] / src / timefunc.hxx

/** @file
 * @brief time related functions.
 *
 * @copyright Copyright © 2001-2008 by Intra2net AG
 * @license commercial
 * @contact info@intra2net.com
 *
 */

#ifndef __TIMEFUNC_HXX
#define __TIMEFUNC_HXX

#include <string>
#include <bitset>
#include <list>


double prec_time(void);

int date_to_seconds(const std::string &date);

std::string make_nice_time(int seconds);
std::string format_full_time(int seconds);
void seconds_to_hour_minute(int seconds, int *hour, int *minute);
std::string output_hour_minute(int hour, int minute, bool h_for_00=true);

inline std::string output_hour_minute_from_seconds(int seconds)
{
    int hour, minute;
    seconds_to_hour_minute(seconds,&hour,&minute);
    return output_hour_minute(hour,minute);
}

std::string get_month_name(unsigned char month);


/**
 * @brief represents some days of a week.
 *
 */
class WEEK
{
    private:
        std::bitset<7> days;

    public:
        enum WEEKDAY { SU=0, MO=1, TU=2, WE=3, TH=4, FR=5, SA=6 };

        // throws out_of_range if illegal week
        WEEK(const std::string& daystring);

        WEEK(const std::bitset<7> &_days)
            : days(_days)
            { }

        WEEK()
            { }

        void clear()
            { days.reset(); }

        operator std::bitset<7>() const
            { return days; }

        void set(WEEKDAY d, bool value=true)
            { days[d]=value; }

        bool all_set() const
            { return (days.count()==7); }
        bool none_set() const
            { return days.none(); }

        std::string get_daystring() const;
        std::string get_displaystring() const;
        std::string get_netfilterstring() const;

        static std::string get_day_display(WEEKDAY day);
        static std::string get_english_display(WEEKDAY day);

        // some operators for convenience:

        WEEK& operator&=(const WEEK& rhs)
        {
            days &= rhs.days;
            return *this;
        }

        WEEK& operator|=(const WEEK& rhs)
        {
            days|= rhs.days;
            return *this;
        }

        WEEK& operator^=(const WEEK& rhs)
        {
            days^= rhs.days;
            return *this;
        }

        bool operator==(const WEEK& rhs)
        {
            return days == rhs.days;
        }

        bool operator!=(const WEEK& rhs)
        {
            return days != rhs.days;
        }

}; // eo class WEEK


/**
 * @brief delivers a week containing the days which are in both weeks.
 * @param lhs first week.
 * @param rhs second week.
 * @return week which has only those days which are in both weeks.
 */
inline WEEK operator&(const WEEK& lhs, const WEEK& rhs)
{
    WEEK result(lhs);
    return result &= rhs;
} // eo operator&(const WEEK&,const WEEK&)


/**
 * @brief delivers a week containing the days which are at least in one of both weeks.
 * @param lhs first week.
 * @param rhs second week.
 * @return week which has only those days which are at least in one of both weeks.
 */
inline WEEK operator|(const WEEK& lhs, const WEEK& rhs)
{
    WEEK result(lhs);
    return result |= rhs;
} // eo operator&(const WEEK&,const WEEK&)


/**
 * @brief delivers a week containing the days which are in only one of both weeks.
 * @param lhs first week.
 * @param rhs second week.
 * @return week which has only those days which are in only one of both weeks.
 */
inline WEEK operator^(const WEEK& lhs, const WEEK& rhs)
{
    WEEK result(lhs);
    return result ^= rhs;
} // eo operator&(const WEEK&,const WEEK&)


/**
 * @brief structure representing a single (half-open) interval.
 */
class Interval
{
    public:
        Interval()
        : m_lower_bound(0)
        , m_upper_bound(0)
        {
        } //

        Interval( unsigned int start, unsigned int end )
        : m_lower_bound(start)
        , m_upper_bound(end)
        {
        } //


        void clear();

        bool is_valid() const
        {
            return m_lower_bound <= m_upper_bound;
        } // eo is_valid() const

        bool empty() const
        {
            return m_lower_bound == m_upper_bound;
        } // eo empty() const


        unsigned int lower_bound() const { return m_lower_bound; }
        unsigned int upper_bound() const { return m_upper_bound; }


        bool operator== (const Interval& other) const
        {
            return m_lower_bound == other.m_lower_bound and m_upper_bound == other.m_upper_bound;
        } // eo operator==(const Interval&)


        /**
         * @brief less operator. compares only the start times!
         * @param other the other interval to compare with.
         * @return @a true if the current start is less than the other start.
         */
        bool operator<(const Interval& other) const
        {
            return m_lower_bound < other.m_lower_bound;
        } // eo operator<(const Interval&)


        bool intersects(const Interval& other) const;
        bool contains(const Interval& other) const;


    protected:

        friend class Intervals;

        unsigned int m_lower_bound;
        unsigned int m_upper_bound;

}; // eo Interval



/**
 * @brief structure representing a combination of single disjoint (half open) intervals.
 *
 * Basic idea is that this structure provides an interface for adding and
 * subtracting single intervals and keeps the internal list of intervals as
 * a list of disjoint intervals.
 *
 * @note the list is sorted by the start; lower comes first.
 *
 * @note the class provides some methods similar to STL container classes;
 * i.e. it can be used with (at least some) STL algorithms.
 * 
 * @internal
 * we use a std::list for the intervals; this means we don't invalidate all
 * iterators when we insert or delete within loops...
 * And we use that fact!!
 */
class Intervals
{
    public:
        typedef std::list< Interval > IntervalList;
        typedef IntervalList::value_type        value_type;
        typedef IntervalList::const_iterator    const_iterator;
        typedef IntervalList::const_iterator    iterator; // we allow only const...
        typedef IntervalList::size_type         size_type;

    public:
        Intervals();

        void add(const Interval& new_frame);
        void sub(const Interval& new_frame);

        void clear();

        const_iterator begin() const { return m_intervals.begin(); }
        const_iterator end() const { return m_intervals.end(); }

        bool empty() const { return m_intervals.empty(); }
        const Interval& front() const { return m_intervals.front(); }
        const Interval& back() const { return m_intervals.back(); }

        size_type size() const { return m_intervals.size(); }

        bool intersects(const Interval& other) const;
        bool intersects(const Intervals& other) const;

        bool contains(const Interval& other) const;
        bool contains(const Intervals& other) const;

        bool operator==(const Intervals& other) const;
        bool operator!=(const Intervals& other) const {return not (*this == other) ; }

        Intervals& operator+=(const Interval& other);
        Intervals& operator-=(const Interval& other);

        Intervals& operator+=(const Intervals& other);
        Intervals& operator-=(const Intervals& other);

    protected:

        std::list< Interval > m_intervals;

}; // eo Intervals




#endif