time_queue.h

Go to the documentation of this file.

#pragma once
#ifndef SYDEVS_TIME_QUEUE_H_
#define SYDEVS_TIME_QUEUE_H_

#include <sydevs/time/time_point.h>
#include <map>
#include <set>
#include <deque>

namespace sydevs {


class time_queue
{
public:
    using event_id_set = std::set<int64>;  

    time_queue();                               
    explicit time_queue(duration dt0);          
    explicit time_queue(const time_point& t0);  

    time_queue(const time_queue&)             = default;  
    time_queue& operator=(const time_queue&)  = default;  
    time_queue(time_queue&&)                  = default;  
    time_queue& operator=(time_queue&&)       = default;  
    ~time_queue()                             = default;  

    bool empty() const;        
    int64 size() const;        
    int64 time_count() const;  

    const time_point& current_time() const;  

    const time_point& advance_time();                    
    const time_point& advance_time(duration dt);         
    const time_point& advance_time(const time_point t);  

    bool can_advance_by(duration dt);  

    duration imminent_duration() const;             
    duration duration_until(int64 event_id) const;  
    duration duration_at(int64 time_index) const;   

    const event_id_set& imminent_event_ids() const;            
    const event_id_set& event_ids_at(int64 time_index) const;  

    void pop_imminent_event(int64 event_id);  
    void pop_imminent_events();               

    void plan_event(int64 event_id, duration dt);  
    bool cancel_event(int64 event_id);             

private:
    using event_account = std::pair<duration, scale>;
    using queue_iterator = std::deque<duration>::iterator;

    duration duration_from_phase(duration pdt) const;
    duration refined_duration(duration dt, scale precision) const;
    duration refined_duration_from_phase(duration pdt, scale precision) const;
    duration rescaled_duration_from_phase(duration pdt, scale precision) const;
    duration phase_from_duration(duration dt);

    queue_iterator lower_bound(duration pdt);

    scale default_precision_;
    time_point ct_;
    std::deque<duration> queue_;
    std::map<duration, event_id_set> event_id_sets_;
    std::map<int64, event_account> event_accounts_;
};


inline bool time_queue::empty() const
{
    return event_accounts_.empty();
}


inline int64 time_queue::size() const
{
    return int64(event_accounts_.size());
}


inline int64 time_queue::time_count() const
{
    return int64(event_id_sets_.size());
}


inline const time_point& time_queue::current_time() const
{
    return ct_;
}


}  // namespace

#endif