traffic.h

Go to the documentation of this file.

 
#ifndef NAVIT_TRAFFIC_H
#define NAVIT_TRAFFIC_H
 
#include "route.h"
#include <time.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define order_to_min_road_class(x) (x <= 8 ? "PRIMARY" : x <= 10 ? "SECONDARY" : x <= 12 ? "TERTIARY" : NULL)
 
/* If additional event classes are introduced, traffic_event_is_valid() must be adapted to recognize them. */
enum event_class {
    event_class_invalid = 0, 
    event_class_congestion,  
    event_class_delay,       
    event_class_restriction, 
};
 
/* If additional events are introduced, remember to do the following:
 * - If the events belong to an existing class, insert them right after the last existing event for that class.
 * - If the events belong to a new class, insert them at the end of the list.
 * - Always keep events of the same class together.
 * - After adding events (of any class) at the end of the list, adapt traffic_event_is_valid() to recognize them. */
enum event_type {
    event_invalid = 0,                                 
    event_congestion_cleared,                          
    event_congestion_forecast_withdrawn,               
    event_congestion_heavy_traffic,                    
    event_congestion_long_queue,                       
    event_congestion_none,                             
    event_congestion_normal_traffic,                   
    event_congestion_queue,                            
    event_congestion_queue_likely,                     
    event_congestion_slow_traffic,                     
    event_congestion_stationary_traffic,               
    event_congestion_stationary_traffic_likely,        
    event_congestion_traffic_building_up,              
    event_congestion_traffic_congestion,               
    event_congestion_traffic_easing,                   
    event_congestion_traffic_flowing_freely,           
    event_congestion_traffic_heavier_than_normal,      
    event_congestion_traffic_lighter_than_normal,      
    event_congestion_traffic_much_heavier_than_normal, 
    event_congestion_traffic_problem,                  
    event_delay_clearance,                             
    event_delay_delay,                                 
    event_delay_delay_possible,                        
    event_delay_forecast_withdrawn,                    
    event_delay_long_delay,                            
    event_delay_several_hours,                         
    event_delay_uncertain_duration,                    
    event_delay_very_long_delay,                       
    event_restriction_access_restrictions_lifted,      
    event_restriction_all_carriageways_cleared,        
    event_restriction_all_carriageways_reopened,       
    event_restriction_batch_service,                   
    event_restriction_blocked,                         
    event_restriction_blocked_ahead,                   
    event_restriction_carriageway_blocked,             
    event_restriction_carriageway_closed,              
    event_restriction_contraflow,                      
    event_restriction_closed,                          
    event_restriction_closed_ahead,                    
    event_restriction_entry_blocked,                   
    event_restriction_entry_reopened,                  
    event_restriction_exit_blocked,                    
    event_restriction_exit_reopened,                   
    event_restriction_intermittent_closures,           
    event_restriction_lane_blocked,                    
    event_restriction_lane_closed,                     
    event_restriction_open,                            
    event_restriction_ramp_blocked,                    
    event_restriction_ramp_closed,                     
    event_restriction_ramp_reopened,                   
    event_restriction_reduced_lanes,                   
    event_restriction_reopened,                        
    event_restriction_road_cleared,                    
    event_restriction_single_alternate_line_traffic,   
    event_restriction_speed_limit,                     
    event_restriction_speed_limit_lifted,              
};
 
enum location_dir {
    location_dir_one = 1,  
    location_dir_both = 2, 
};
 
enum location_fuzziness {
    location_fuzziness_none = 0,       
    location_fuzziness_low_res,        
    location_fuzziness_end_unknown,    
    location_fuzziness_start_unknown,  
    location_fuzziness_extent_unknown, 
};
 
enum location_ramps {
    location_ramps_none = 0, 
    location_ramps_all,      
    location_ramps_entry,    
    location_ramps_exit,     
};
 
enum si_class {
    si_class_invalid = 0, 
    si_class_place,       
    si_class_tendency,    
    si_class_vehicle,     
};
 
enum si_type {
    si_invalid = 0,               
    si_place_bridge,              
    si_place_ramp,                
    si_place_roadworks,           
    si_place_tunnel,              
    si_tendency_queue_decreasing, 
    si_tendency_queue_increasing, 
    si_vehicle_all,               
    si_vehicle_bus,               
    si_vehicle_car,               
    si_vehicle_car_with_caravan,  
    si_vehicle_car_with_trailer,  
    si_vehicle_hazmat,            
    si_vehicle_hgv,               
    si_vehicle_motor,             
    si_vehicle_with_trailer,      
};
 
struct traffic;
struct traffic_priv;
struct traffic_location_priv;
struct traffic_message_priv;
 
struct traffic_methods {
    struct traffic_message **(*get_messages)(
        struct traffic_priv *this_);             
    void (*destroy)(struct traffic_priv *this_); 
};
 
struct traffic_point {
    struct coord_geo coord; 
    char *junction_name;    
    char *junction_ref;     
    char *tmc_id;           
};
 
struct traffic_location {
    struct traffic_point *at;           
    struct traffic_point *from;         
    struct traffic_point *to;           
    struct traffic_point *via;          
    struct traffic_point *not_via;      
    char *destination;                  
    char *direction;                    
    enum location_dir directionality;   
    enum location_fuzziness fuzziness;  
    enum location_ramps ramps;          
    enum item_type road_type;           
    char *road_name;                    
    char *road_ref;                     
    char *tmc_table;                    
    int tmc_direction;                  
    struct traffic_location_priv *priv; 
};
 
/*
 * For now, these are various integer types, but other types may be added in the future.
 */
struct quantifier {
    union {
        int q_duration;      
        int q_int;           
        int q_speed;         
        unsigned int q_time; 
    } u;
};
 
struct traffic_suppl_info {
    enum si_class si_class;        
    enum si_type type;             
    struct quantifier *quantifier; 
};
 
struct traffic_event {
    enum event_class event_class;   
    enum event_type type;           
    int length;                     
    int speed;                      
    struct quantifier *quantifier;  
    int si_count;                   
    struct traffic_suppl_info **si; 
};
 
struct traffic_message {
    char *id;                          
    time_t receive_time;               
    time_t update_time;                
    time_t expiration_time;            
    time_t start_time;                 
    time_t end_time;                   
    int is_cancellation;               
    int is_forecast;                   
    int replaced_count;                
    char **replaces;                   
    struct traffic_location *location; 
    int event_count;                   
    struct traffic_event **events;     
    struct traffic_message_priv *priv; 
};
 
struct map;
struct mapset;
struct traffic;
 
enum event_class event_class_new(char *string);
 
const char *event_class_to_string(enum event_class this_);
 
enum event_type event_type_new(char *string);
 
const char *event_type_to_string(enum event_type this_);
 
enum item_type item_type_from_road_type(char *string, int is_urban);
 
enum location_dir location_dir_new(char *string);
 
enum location_fuzziness location_fuzziness_new(char *string);
 
const char *location_fuzziness_to_string(enum location_fuzziness this_);
 
enum location_ramps location_ramps_new(char *string);
 
const char *location_ramps_to_string(enum location_ramps this_);
 
enum si_class si_class_new(char *string);
 
const char *si_class_to_string(enum si_class this_);
 
enum si_type si_type_new(char *string);
 
const char *si_type_to_string(enum si_type this_);
 
struct traffic_point *traffic_point_new(float lon, float lat, char *junction_name, char *junction_ref, char *tmc_id);
 
struct traffic_point *traffic_point_new_short(float lon, float lat);
 
void traffic_point_destroy(struct traffic_point *this_);
 
// TODO split CID/LTN?
struct traffic_location *traffic_location_new(struct traffic_point *at, struct traffic_point *from,
                                              struct traffic_point *to, struct traffic_point *via,
                                              struct traffic_point *not_via, char *destination, char *direction,
                                              enum location_dir directionality, enum location_fuzziness fuzziness,
                                              enum location_ramps ramps, enum item_type road_type, char *road_name,
                                              char *road_ref, char *tmc_table, int tmc_direction);
 
struct traffic_location *traffic_location_new_short(struct traffic_point *at, struct traffic_point *from,
                                                    struct traffic_point *to, struct traffic_point *via,
                                                    struct traffic_point *not_via, enum location_dir directionality,
                                                    enum location_fuzziness fuzziness);
 
void traffic_location_destroy(struct traffic_location *this_);
 
struct traffic_suppl_info *traffic_suppl_info_new(enum si_class si_class, enum si_type type,
                                                  struct quantifier *quantifier);
 
void traffic_suppl_info_destroy(struct traffic_suppl_info *this_);
 
struct traffic_event *traffic_event_new(enum event_class event_class, enum event_type type, int length, int speed,
                                        struct quantifier *quantifier, int si_count, struct traffic_suppl_info **si);
 
struct traffic_event *traffic_event_new_short(enum event_class event_class, enum event_type type);
 
void traffic_event_destroy(struct traffic_event *this_);
 
void traffic_event_add_suppl_info(struct traffic_event *this_, struct traffic_suppl_info *si);
 
struct traffic_suppl_info *traffic_event_get_suppl_info(struct traffic_event *this_, int index);
 
struct traffic_message *traffic_message_new(char *id, time_t receive_time, time_t update_time, time_t expiration_time,
                                            time_t start_time, time_t end_time, int is_cancellation, int is_Forecast,
                                            int replaced_count, char **replaces, struct traffic_location *location,
                                            int event_count, struct traffic_event **events);
 
struct traffic_message *traffic_message_new_short(char *id, time_t receive_time, time_t update_time,
                                                  time_t expiration_time, int is_forecast,
                                                  struct traffic_location *location, int event_count,
                                                  struct traffic_event **events);
 
struct traffic_message *traffic_message_new_single_event(char *id, time_t receive_time, time_t update_time,
                                                         time_t expiration_time, int is_forecast,
                                                         struct traffic_location *location,
                                                         enum event_class event_class, enum event_type type);
 
struct traffic_message *traffic_message_new_cancellation(char *id, time_t receive_time, time_t update_time,
                                                         time_t expiration_time, struct traffic_location *location);
 
void traffic_message_destroy(struct traffic_message *this_);
 
void traffic_message_add_event(struct traffic_message *this_, struct traffic_event *event);
 
struct traffic_event *traffic_message_get_event(struct traffic_message *this_, int index);
 
struct item **traffic_message_get_items(struct traffic_message *this_);
 
void traffic_init(void);
 
struct traffic_message **traffic_get_messages_from_xml_file(struct traffic *this_, char *filename);
 
struct traffic_message **traffic_get_messages_from_xml_string(struct traffic *this_, char *xml);
 
struct map *traffic_get_map(struct traffic *this_);
 
struct traffic_message **traffic_get_stored_messages(struct traffic *this_);
 
void traffic_process_messages(struct traffic *this_, struct traffic_message **messages);
 
void traffic_set_mapset(struct traffic *this_, struct mapset *ms);
 
void traffic_set_route(struct traffic *this_, struct route *rt);
 
void traffic_destroy(struct traffic *this_);
 
/* end of prototypes */
#ifdef __cplusplus
}
#endif
 
#endif