traffic.h

Go to the documentation of this file.

 
#ifndef NAVIT_TRAFFIC_H
#define NAVIT_TRAFFIC_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