ctimers.h

/*
 * ctimers.h
 *
 *  Created on: 26.01.2014
 *      Author: andreas
 */

#ifndef CTIMERS_H_
#define CTIMERS_H_

#include <set>
#include <algorithm>

#include "rofl/common/ctimer.h"
#include "rofl/common/logging.h"
#include "rofl/common/thread_helper.h"
#include "rofl/common/croflexception.h"

namespace rofl {

class eTimersBase               : public RoflException {};
class eTimersNotFound   : public eTimersBase {};

class ctimers {
public:

        virtual
        ~ctimers()
        {};

        ctimers()
        {};

        ctimers(
                        const rofl::ctimers& timers)
        { *this = timers; };

public:

        ctimers&
        operator= (
                        const rofl::ctimers& t) {
                if (this == &t)
                        return *this;
                RwLock lock(rwlock, RwLock::RWLOCK_WRITE);
                timers.clear();
                timers.insert(t.timers.begin(), t.timers.end());
                return *this;
        };

public:

        bool
        empty() {
                RwLock lock(rwlock, RwLock::RWLOCK_READ);
                return (timers.empty());
        };

        rofl::ctimer
        get_next_timer() {
                RwLock lock(rwlock, RwLock::RWLOCK_WRITE);
                if (timers.empty())
                        throw eTimersNotFound();
                std::multiset<ctimer>::iterator first = timers.begin();
                ctimer timer(*first);
                return timer;
        };

        const rofl::ctimerid&
        add_timer(
                        const rofl::ctimer& t) {
                RwLock lock(rwlock, RwLock::RWLOCK_WRITE);
                std::multiset<ctimer>::iterator it = timers.insert(t);
                return it->get_timer_id();
        };

        const rofl::ctimerid&
        reset(
                        const rofl::ctimerid& timer_id,
                        const rofl::ctimespec& timespec) {
                RwLock lock(rwlock, RwLock::RWLOCK_WRITE);
                std::multiset<ctimer>::iterator it;
                if ((it = find_if(timers.begin(), timers.end(), ctimer::ctimer_find_by_timer_id(timer_id))) == timers.end()) {
                        throw eTimersNotFound();
                }
                const ctimerid& timerid = timers.insert(ctimer(it->get_timer_env(), it->get_opaque(), timespec))->get_timer_id();
                timers.erase(it);
                return timerid;
        };

        rofl::ctimer
        get_expired_timer() {
                RwLock lock(rwlock, RwLock::RWLOCK_WRITE);
                if (timers.empty()) {
                        throw eTimersNotFound();
                }
                ctimer now = ctimer::now();

                std::multiset<ctimer>::iterator it = timers.begin();

                ctimer timer = *(it);

                if (timer > now) {
                        throw eTimersNotFound();
                }

                timers.erase(it);

                return timer;
        };

        bool
        pending(
                        const rofl::ctimerid& timer_id) {
                RwLock lock(rwlock, RwLock::RWLOCK_READ);
                std::multiset<ctimer>::iterator it;
                if ((it = find_if(timers.begin(), timers.end(), ctimer::ctimer_find_by_timer_id(timer_id))) == timers.end()) {
                        return false;
                }
                return true;
        };

        void
        cancel(
                        const ctimerid& timer_id) {
                RwLock lock(rwlock, RwLock::RWLOCK_WRITE);
                std::multiset<ctimer>::iterator it;
                if ((it = find_if(timers.begin(), timers.end(), ctimer::ctimer_find_by_timer_id(timer_id))) == timers.end()) {
                        return;
                }
                timers.erase(it);
        };

        void
        clear() {
                RwLock lock(rwlock, RwLock::RWLOCK_WRITE);
                timers.clear();
        };

public:

        friend std::ostream&
        operator<< (std::ostream& os, const rofl::ctimers& t) {
                os << indent(0) << "<ctimers: >" << std::endl;
                indent i(2);
                for (std::multiset<ctimer>::const_iterator it = t.timers.begin(); it != t.timers.end(); ++it) {
                        os << (*it);
                }
                return os;
        };

private:

        std::multiset<rofl::ctimer>     timers;
        PthreadRwLock               rwlock;
};

};

#endif /* CTIMERS_H_ */