[MERGE] libi2ncommon: (reinhard) added clear() method to Interval and Intervals.

[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);

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);
};


/**
 * @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