void Data_Service::Read_Lines (Line_File &file)
{
int i, num;
bool keep_flag;
Int_Map_Stat map_stat;
Line_Data line_rec;
//---- store the route data ----
Show_Message (String ("Reading %s -- Record") % file.File_Type ());
Set_Progress ();
Initialize_Lines (file);
while (file.Read (false)) {
Show_Progress ();
line_rec.Clear ();
keep_flag = Get_Line_Data (file, line_rec);
num = file.Num_Nest ();
if (num > 0) line_rec.reserve (num);
for (i=1; i <= num; i++) {
if (!file.Read (true)) {
Error (String ("Number of Stop Records for Route %d") % file.Route ());
}
Show_Progress ();
Get_Line_Data (file, line_rec);
}
if (keep_flag) {
map_stat = line_map.insert (Int_Map_Data (line_rec.Route (), (int) line_array.size ()));
if (!map_stat.second) {
Warning ("Duplicate Route Number = ") << line_rec.Route ();
} else {
line_array.push_back (line_rec);
line_array.Add_Route_Stops ((int) line_rec.size ());
}
}
}
End_Progress ();
file.Close ();
Print (2, String ("Number of %s Records = %d") % file.File_Type () % Progress_Count ());
num = (int) line_array.size ();
if (num && num != Progress_Count ()) {
Print (1, String ("Number of %s Data Records = %d") % file.File_ID () % num);
}
if (num > 0) System_Data_True (TRANSIT_ROUTE);
}
void Data_Service::Read_Shapes (Shape_File &file)
{
int i, num;
bool keep_flag;
Shape_Data shape_rec;
Int_Map_Stat map_stat;
//---- store the shape point data ----
Show_Message (String ("Reading %s -- Record") % file.File_Type ());
Set_Progress ();
Initialize_Shapes (file);
while (file.Read (false)) {
Show_Progress ();
shape_rec.Clear ();
keep_flag = Get_Shape_Data (file, shape_rec);
num = file.Num_Nest ();
if (num > 0) shape_rec.reserve (num);
for (i=1; i <= num; i++) {
if (!file.Read (true)) {
Error (String ("Number of Nested Records for Link %d") % file.Link ());
}
Show_Progress ();
Get_Shape_Data (file, shape_rec);
}
if (keep_flag) {
map_stat = shape_map.insert (Int_Map_Data (shape_rec.Link (), (int) shape_array.size ()));
if (!map_stat.second) {
Warning ("Duplicate Link Number = ") << shape_rec.Link ();
} else {
shape_array.push_back (shape_rec);
}
}
}
End_Progress ();
file.Close ();
Print (2, String ("Number of %s Records = %d") % file.File_Type () % Progress_Count ());
num = (int) shape_array.size ();
if (num && num != Progress_Count ()) {
Print (1, String ("Number of Link %s Records = %d") % file.File_ID () % num);
}
if (num > 0) System_Data_True (SHAPE);
}
void Data_Service::Read_Locations (void)
{
Location_File *file = (Location_File *) System_File_Handle (LOCATION);
int num;
bool zone_flag = System_Data_Flag (ZONE);
Int_Map_Stat map_stat;
Location_Data location_rec;
//---- store the location data ----
Show_Message (String ("Reading %s -- Record") % file->File_Type ());
Set_Progress ();
Initialize_Locations (*file);
while (file->Read ()) {
Show_Progress ();
location_rec.Clear ();
if (Get_Location_Data (*file, location_rec)) {
map_stat = location_map.insert (Int_Map_Data (location_rec.Location (), (int) location_array.size ()));
if (!map_stat.second) {
Warning ("Duplicate Location Number = ") << location_rec.Location ();
continue;
} else {
if (!file->Setback_Flag () && location_rec.Setback () == 0) {
location_rec.Setback (Internal_Units (100.0, FEET));
}
location_array.push_back (location_rec);
if (!zone_flag && location_rec.Zone () > Max_Zone_Number ()) {
Max_Zone_Number (location_rec.Zone ());
}
}
}
}
End_Progress ();
file->Close ();
Print (2, String ("Number of %s Records = %d") % file->File_Type () % Progress_Count ());
num = (int) location_array.size ();
if (num && num != Progress_Count ()) {
Print (1, String ("Number of %s Data Records = %d") % file->File_ID () % num);
}
if (num > 0) System_Data_True (LOCATION);
}
void Data_Service::Read_Events (void)
{
Event_File *file = (Event_File *) System_File_Handle (EVENT);
int num;
Event_Data event_rec;
Event_Index event_index;
Event_Map_Stat map_stat;
//---- store the event data ----
Show_Message (String ("Reading %s -- Record") % file->File_Type ());
Set_Progress ();
Initialize_Events (*file);
while (file->Read ()) {
Show_Progress ();
event_rec.Clear ();
if (Get_Event_Data (*file, event_rec)) {
event_rec.Get_Event_Index (event_index);
map_stat = event_map.insert (Event_Map_Data (event_index, (int) event_array.size ()));
if (!map_stat.second) {
Warning (String ("Duplicate Event Record = %d-%d-%d-%d-%d") %
event_index.Household () % event_index.Person () % event_index.Tour () %
event_index.Trip () % event_index.Event ());
continue;
} else {
event_array.push_back (event_rec);
}
}
}
End_Progress ();
file->Close ();
Print (2, String ("Number of %s Records = %d") % file->File_Type () % Progress_Count ());
num = (int) event_array.size ();
if (num && num != Progress_Count ()) {
Print (1, String ("Number of %d Data Records = %d") % file->File_ID () % num);
}
if (num > 0) System_Data_True (EVENT);
}
void Data_Service::Read_Zones (void)
{
Zone_File *file = (Zone_File *) System_File_Handle (ZONE);
Zone_Data zone_rec;
Int_Map_Stat map_stat;
//---- store the zone data ----
Show_Message (String ("Reading %s -- Record") % file->File_Type ());
Set_Progress ();
Initialize_Zones (*file);
while (file->Read ()) {
Show_Progress ();
zone_rec.Clear ();
if (Get_Zone_Data (*file, zone_rec)) {
map_stat = zone_map.insert (Int_Map_Data (zone_rec.Zone (), (int) zone_array.size ()));
if (!map_stat.second) {
Warning ("Duplicate Zone Number = ") << zone_rec.Zone ();
continue;
} else {
zone_array.push_back (zone_rec);
if (zone_rec.Zone () > Max_Zone_Number ()) {
Max_Zone_Number (zone_rec.Zone ());
}
}
}
}
End_Progress ();
file->Close ();
Print (2, String ("Number of %s Records = %d") % file->File_Type () % Progress_Count ());
int num = (int) zone_array.size ();
if (num && num != Progress_Count ()) {
Print (1, String ("Number of %s Data Records = %d") % file->File_ID () % num);
}
if (num != Max_Zone_Number ()) Print (1, "Highest Zone Number = ") << Max_Zone_Number ();
if (num > 0) System_Data_True (ZONE);
}
void Data_Service::Read_Timing_Plans (Timing_File &file)
{
int i, num, count;
bool keep;
Timing_Record timing_rec;
Timing_Data *timing_ptr;
Signal_Data *signal_ptr;
//---- store the timing plan data ----
Show_Message (String ("Reading %s -- Record") % file.File_Type ());
Set_Progress ();
Initialize_Timing_Plans (file);
count = 0;
timing_ptr = &(timing_rec.timing_data);
while (file.Read (false)) {
Show_Progress ();
timing_rec.Clear ();
keep = Get_Timing_Data (file, timing_rec);
num = file.Num_Nest ();
if (num > 0) timing_ptr->reserve (num);
for (i=1; i <= num; i++) {
if (!file.Read (true)) {
Error (String ("Number of Phase Records for Signal %d Plan %d") %
file.Signal () % file.Timing ());
}
Show_Progress ();
Get_Timing_Data (file, timing_rec);
}
//---- save the results ----
if (keep) {
if (file.Version () <= 40) {
bool keep;
Timing40_Map_Itr timing40_itr;
Timing40_Data *timing40_ptr;
Timing_Itr timing_itr;
timing40_itr = timing40_map.find (timing_ptr->Timing ());
if (timing40_itr == timing40_map.end ()) {
Warning (String ("Timing Plan %d was Not Found in the Signal file") % timing_ptr->Timing ());
continue;
}
timing40_ptr = (Timing40_Data *) &(timing40_itr->second);
timing_rec.Signal (timing40_ptr->Signal ());
signal_ptr = &signal_array [timing_rec.Signal ()];
keep = true;
for (timing_itr = signal_ptr->timing_plan.begin (); timing_itr != signal_ptr->timing_plan.end (); timing_itr++) {
if (timing_itr->Timing () == timing40_ptr->Timing ()) {
Timing_Phase_Itr phase_itr = timing_ptr->begin ();
timing_itr->push_back (*phase_itr);
count++;
keep = false;
break;
}
}
if (!keep) continue;
timing_ptr->Timing (timing40_ptr->Timing ());
timing_ptr->Type (timing40_ptr->Type ());
timing_ptr->Offset (timing40_ptr->Offset ());
} else {
signal_ptr = &signal_array [timing_rec.Signal ()];
}
signal_ptr->timing_plan.push_back (*timing_ptr);
count += (int) timing_ptr->size () + 1;
}
}
End_Progress ();
file.Close ();
Print (2, String ("Number of %s Records = %d") % file.File_Type () % Progress_Count ());
if (count && count != Progress_Count ()) {
Print (1, String ("Number of %s Data Records = %d") % file.File_ID () % count);
}
if (count > 0) System_Data_True (TIMING_PLAN);
//---- repair Version 4.0 data ----
if (file.Version () <= 40) {
int first, prev, next, barrier, ring, position, cycle;
bool flag;
Signal_Itr signal_itr;
Timing_Itr timing_itr;
Timing_Phase_Itr phase_itr;
for (signal_itr = signal_array.begin (); signal_itr != signal_array.end (); signal_itr++) {
for (timing_itr = signal_itr->timing_plan.begin (); timing_itr != signal_itr->timing_plan.end (); timing_itr++) {
//---- map the ring positions ----
for (ring=1; ; ring++) {
flag = false;
for (phase_itr = timing_itr->begin (); phase_itr != timing_itr->end (); phase_itr++) {
if (phase_itr->Ring () == ring) {
flag = true;
break;
}
}
if (!flag) break;
first = prev = phase_itr->Phase ();
next = phase_itr->Position ();
barrier = phase_itr->Barrier ();
if (barrier == 0) {
phase_itr->Barrier ((barrier = 1));
}
count = (int) timing_itr->size ();
position = 1;
phase_itr->Position (position);
cycle = MAX ((phase_itr->Min_Green () + phase_itr->Extension ()), phase_itr->Max_Green ()) +
phase_itr->Yellow () + phase_itr->All_Red ();
while (next != first && count-- > 0) {
flag = false;
for (phase_itr = timing_itr->begin (); phase_itr != timing_itr->end (); phase_itr++) {
if (phase_itr->Phase () == next) {
flag = true;
break;
}
}
if (!flag) {
Warning (String ("Signal %d Timing %d Phase %d was Not Found") %
signal_itr->Signal () % timing_itr->Timing () % next);
break;
}
if (phase_itr->Ring () == 0) {
phase_itr->Ring (ring);
} else if (phase_itr->Ring () != ring) {
Warning (String ("Signal %d Timing %d Phase %d to %d is Not in Ring %d") %
signal_itr->Signal () % timing_itr->Timing () % prev % next % ring);
break;
}
if (phase_itr->Barrier () == 0) {
phase_itr->Barrier (barrier);
}
if (phase_itr->Barrier () == barrier) {
position++;
} else {
position = 1;
barrier = phase_itr->Barrier ();
}
prev = next;
next = phase_itr->Position ();
phase_itr->Position (position);
cycle += MAX ((phase_itr->Min_Green () + phase_itr->Extension ()), phase_itr->Max_Green ()) +
phase_itr->Yellow () + phase_itr->All_Red ();
}
if (ring == 1) {
timing_itr->Cycle (cycle);
}
}
}
}
}
}
void Data_Service::Read_Lane_Uses (Lane_Use_File &file)
{
int i, num, index, first_index, rec, lanes0, lanes1, lane, group, periods, size;
Dir_Itr dir_itr;
Link_Data *link_ptr;
Lane_Use_Period period_rec;
Use_Period_Array period_array;
Use_Period_Itr period_itr;
Int_Set time_sort;
Int_Set_Itr time_itr;
Link_Dir_Data index_rec, *index_ptr;
Integers lane_type;
Int_RItr lane_ritr;
Lane_Use_Data lane_use_rec;
//---- store the lane use data ----
Show_Message (String ("Reading %s -- Record") % file.File_Type ());
Set_Progress ();
Initialize_Lane_Uses (file);
num = 0;
while (file.Read ()) {
Show_Progress ();
lane_use_rec.Clear ();
if (Get_Lane_Use_Data (file, lane_use_rec)) {
lane_use_array.push_back (lane_use_rec);
}
}
End_Progress ();
file.Close ();
Print (2, String ("Number of %s Records = %d") % file.File_Type () % Progress_Count ());
num = (int) lane_use_array.size ();
if (num && num != Progress_Count ()) {
Print (1, String ("Number of %s Data Records = %d") % file.File_ID () % num);
}
if (num > 0) {
System_Data_True (LANE_USE);
Lane_Use_Data *lane_use_ptr;
Dir_Data *dir_ptr;
//---- create directional link list ----
while (num--) {
lane_use_ptr = &lane_use_array [num];
dir_ptr = &dir_array [lane_use_ptr->Dir_Index ()];
lane_use_ptr->Next_Index (dir_ptr->First_Lane_Use ());
dir_ptr->First_Lane_Use (num);
}
//----- identify time period restrictions ----
size = (int) dir_array.size ();
for (index=0, dir_itr = dir_array.begin (); dir_itr != dir_array.end (); dir_itr++, index++) {
first_index = dir_itr->First_Lane_Use ();
if (first_index < 0) continue;
//---- sort lane use time points ----
link_ptr = &link_array [dir_itr->Link ()];
time_sort.clear ();
for (num = first_index; num >= 0; num = lane_use_ptr->Next_Index ()) {
lane_use_ptr = &lane_use_array [num];
time_sort.insert (lane_use_ptr->Start ());
time_sort.insert (lane_use_ptr->End ());
}
//---- create start-end time combinations ----
period_array.clear ();
period_rec.Clear ();
periods = 0;
for (time_itr = time_sort.begin (); time_itr != time_sort.end (); time_itr++) {
period_rec.End (*time_itr);
if (periods > 0) {
period_array.push_back (period_rec);
}
period_rec.Start (*time_itr);
periods++;
}
periods = 0;
//---- identify lane use records within each time period ----
dir_itr->First_Lane_Use ((int) use_period_array.size ());
for (period_itr = period_array.begin (); period_itr != period_array.end (); period_itr++) {
period_itr->Index ((int) use_period_index.size ());
for (num = first_index; num >= 0; num = lane_use_ptr->Next_Index ()) {
lane_use_ptr = &lane_use_array [num];
if (period_itr->Start () >= lane_use_ptr->Start () && period_itr->End () <= lane_use_ptr->End ()) {
period_itr->Add_Record ();
index_rec.Link (num);
index_rec.Dir (0);
use_period_index.push_back (index_rec);
}
}
if (period_itr->Records () == 0) continue;
periods++;
//---- check for lane groups ----
num = period_itr->Records ();
lanes1 = 0;
lanes0 = dir_itr->Lanes ();
lane_type.assign (lanes0, 0);
for (i=1, rec=period_itr->Index (); i <= num; i++, rec++) {
index_ptr = &use_period_index [rec];
lane_use_ptr = &lane_use_array [index_ptr->Link ()];
//---- must be a full length restriction ----
if (lane_use_ptr->Offset () > 0 || lane_use_ptr->Length () > 0) continue;
group = i;
if (lane_use_ptr->Type () == APPLY) {
//---- must apply to a subset of lanes ----
if (lane_use_ptr->Low_Lane () <= dir_itr->Left () &&
lane_use_ptr->High_Lane () >= (dir_itr->Left () + dir_itr->Lanes ())) {
continue;
}
} else if ((lane_use_ptr->Type () == LIMIT && dat->Use_Permission (lane_use_ptr->Use (), NONE)) ||
(lane_use_ptr->Type () == PROHIBIT && lane_use_ptr->Use () == ANY_USE_CODE)) {
group = -1;
}
lanes0 = lane_use_ptr->Low_Lane () - dir_itr->Left ();
if (lanes0 < 0) lanes0 = 0;
lanes1 = lane_use_ptr->High_Lane () - dir_itr->Left ();
if (lanes1 >= dir_itr->Lanes ()) lanes1 = dir_itr->Lanes () - 1;
for (lane = lanes0; lane <= lanes1; lane++) {
lane_type [lane] = group;
}
}
lanes0 = lanes1 = group = 0;
for (lane_ritr = lane_type.rbegin (); lane_ritr != lane_type.rend (); lane_ritr++) {
if (*lane_ritr < 0) continue;
if (lanes0 == 0) {
lanes0++;
group = *lane_ritr;
} else if (*lane_ritr == group) {
lanes0++;
} else {
lanes1++;
}
}
period_itr->Lanes0 (lanes0);
period_itr->Lanes1 (lanes1);
if (lanes0 != 0 && lanes1 != 0) {
//----- set flow index for lane groups ----
if (Lane_Use_Flows () && dir_itr->Use_Index () < 0) {
dir_itr->Use_Index (size + Add_Lane_Use_Flows ());
lane_use_flow_index.push_back (index);
}
//---- set the group flags ----
for (i=1, rec=period_itr->Index (); i <= num; i++, rec++) {
index_ptr = &use_period_index [rec];
if (i > group) index_ptr->Dir (1);
}
}
}
//---- save the period records ----
for (period_itr = period_array.begin (); period_itr != period_array.end (); period_itr++) {
if (period_itr->Records () > 0) {
period_itr->Periods (--periods);
use_period_array.push_back (*period_itr);
}
}
}
Print (1, "Number of Lane Use Flow Records = ") << Num_Lane_Use_Flows ();
}
}
void Data_Service::Read_Trips (Trip_File &file)
{
int part, num, num_rec, part_num, first;
Trip_Data trip_rec;
Trip_Index trip_index;
Trip_Map_Stat map_stat;
Initialize_Trips (file);
num_rec = first = 0;
//---- check the partition number ----
if (file.Part_Flag () && First_Partition () != file.Part_Number ()) {
file.Open (0);
} else if (First_Partition () >= 0) {
first = First_Partition ();
}
//---- process each partition ----
for (part=0; ; part++) {
if (part > 0) {
if (!file.Open (part)) break;
}
//---- store the trip data ----
if (file.Part_Flag ()) {
part_num = file.Part_Number ();
Show_Message (String ("Reading %s %d -- Record") % file.File_Type () % part_num);
} else {
part_num = part + first;
Show_Message (String ("Reading %s -- Record") % file.File_Type ());
}
Set_Progress ();
while (file.Read ()) {
Show_Progress ();
trip_rec.Clear ();
if (Get_Trip_Data (file, trip_rec, part_num)) {
trip_rec.Internal_IDs ();
trip_rec.Get_Index (trip_index);
trip_rec.Index ((int) trip_array.size ());
//---- process the record ----
map_stat = trip_map.insert (Trip_Map_Data (trip_index, trip_rec.Index ()));
if (!map_stat.second) {
Warning (String ("Duplicate Trip Record = %d-%d-%d-%d") %
trip_index.Household () % trip_index.Person () % trip_index.Tour () % trip_index.Trip ());
} else {
trip_array.push_back (trip_rec);
trip_array.Max_Partition (trip_rec);
file.Add_Trip (trip_index.Household (), trip_index.Person (), trip_index.Tour ());
}
}
}
End_Progress ();
num_rec += Progress_Count ();
}
file.Close ();
Print (2, String ("Number of %s Records = %d") % file.File_Type () % num_rec);
if (part > 1) Print (0, String (" (%d files)") % part);
num = (int) trip_array.size ();
if (num && num != num_rec) {
Print (1, String ("Number of %s Data Records = %d") % file.File_ID () % num);
}
if (num > 0) System_Data_True (TRIP);
}
void Data_Service::Read_Veh_Types (Veh_Type_File &file)
{
int num, cell_size;
double length, min_len;
Veh_Type_Data veh_type_rec;
Int_Map_Stat map_stat;
Veh_Type_Itr veh_type_itr;
//---- store the vehicle type data ----
Show_Message (String ("Reading %s -- Record") % file.File_Type ());
Set_Progress ();
Initialize_Veh_Types (file);
while (file.Read ()) {
Show_Progress ();
veh_type_rec.Clear ();
if (Get_Veh_Type_Data (file, veh_type_rec)) {
map_stat = veh_type_map.insert (Int_Map_Data (veh_type_rec.Type (), (int) veh_type_array.size ()));
if (!map_stat.second) {
Warning ("Duplicate Vehicle Type Number = ") << veh_type_rec.Type ();
continue;
} else {
veh_type_array.push_back (veh_type_rec);
}
}
}
End_Progress ();
file.Close ();
Print (2, String ("Number of %s Records = %d") % file.File_Type () % Progress_Count ());
num = (int) veh_type_array.size ();
if (num && num != Progress_Count ()) {
Print (1, String ("Number of %d Data Records = %d") % file.File_ID () % num);
}
if (num > 0) System_Data_True (VEHICLE_TYPE);
//---- set the PCE factor ----
num = Use_Code ("CAR");
length = 0.0;
min_len = MAX_INTEGER;
for (veh_type_itr = veh_type_array.begin (); veh_type_itr != veh_type_array.end (); veh_type_itr++) {
if ((veh_type_itr->Use () & num) != 0) {
length = veh_type_itr->Length ();
break;
}
if (veh_type_itr->Length () < min_len) min_len = veh_type_itr->Length ();
}
if (length <= 0.0) length = min_len;
if (length <= 0.0) return;
cell_size = DTOI (min_len);
for (veh_type_itr = veh_type_array.begin (); veh_type_itr != veh_type_array.end (); veh_type_itr++) {
veh_type_itr->PCE (Round (veh_type_itr->Length () / length));
veh_type_itr->Cells (MAX (((veh_type_itr->Length () + cell_size / 2) / cell_size), 1));
}
}
void Data_Service::Read_Drivers (void)
{
Driver_File *file = (Driver_File *) System_File_Handle (TRANSIT_DRIVER);
int i, num, count;
bool keep_flag;
Line_Data *line_ptr;
Driver_Data driver_rec;
//---- store the transit driver data ----
Show_Message (String ("Reading %s -- Record") % file->File_Type ());
Set_Progress ();
Initialize_Drivers (*file);
count = 0;
while (file->Read (false)) {
Show_Progress ();
driver_rec.Clear ();
keep_flag = Get_Driver_Data (*file, driver_rec);
num = file->Num_Nest ();
if (num > 0) driver_rec.reserve (num);
for (i=1; i <= num; i++) {
if (!file->Read (true)) {
Error (String ("Number of Link Records for Route %d") % file->Route ());
}
Show_Progress ();
Get_Driver_Data (*file, driver_rec);
}
if (keep_flag) {
line_ptr = &line_array [driver_rec.Route ()];
if (driver_rec.Type () > 0 && line_ptr->Type () == 0) line_ptr->Type (driver_rec.Type ());
line_ptr->driver_array.swap (driver_rec);
count += (int) driver_rec.size ();
}
}
End_Progress ();
file->Close ();
line_array.Driver_Records (Progress_Count ());
Print (2, String ("Number of %s Records = %d") % file->File_Type () % Progress_Count ());
if (count && count != Progress_Count ()) {
Print (1, String ("Number of %s Data Records = %d") % file->File_ID () % count);
}
if (count > 0) System_Data_True (TRANSIT_DRIVER);
//---- check for driver path for each route ----
if ((int) line_array.size () > 0 && (int) stop_array.size () > 0) {
int length, offset;
bool first;
Line_Itr line_itr;
Line_Stop_Itr stop_itr;
Driver_Itr driver_itr;
Stop_Data *stop_ptr;
Dir_Data *dir_ptr;
Link_Data *link_ptr;
for (line_itr = line_array.begin (); line_itr != line_array.end (); line_itr++) {
length = offset = 0;
first = true;
driver_itr = line_itr->driver_array.begin ();
if (driver_itr == line_itr->driver_array.end ()) continue;
for (stop_itr = line_itr->begin(); stop_itr != line_itr->end (); stop_itr++) {
stop_ptr = &stop_array [stop_itr->Stop ()];
for (; driver_itr != line_itr->driver_array.end (); driver_itr++) {
dir_ptr = &dir_array [*driver_itr];
if (stop_ptr->Link_Dir () == dir_ptr->Link_Dir ()) break;
link_ptr = &link_array [dir_ptr->Link ()];
length += link_ptr->Length () - offset;
offset = 0;
}
if (driver_itr == line_itr->driver_array.end ()) {
Error (String ("Route %d Stops and Driver Links are Incompatible") % line_itr->Route ());
}
if (first) {
first = false;
length = 0;
} else {
length += stop_ptr->Offset () - offset;
stop_itr->Length (length);
}
offset = stop_ptr->Offset ();
}
}
}
}
void Data_Service::Read_Connections (void)
{
Connect_File *file = (Connect_File *) System_File_Handle (CONNECTION);
int num, in, out;
Int2_Map_Stat map_stat;
Connect_Data connect_rec;
//---- store the lane connectivity data ----
Show_Message (String ("Reading %s -- Record") % file->File_Type ());
Set_Progress ();
Initialize_Connects (*file);
num = 0;
while (file->Read ()) {
Show_Progress ();
connect_rec.Clear ();
if (Get_Connect_Data (*file, connect_rec)) {
in = connect_rec.Dir_Index ();
out = connect_rec.To_Index ();
map_stat = connect_map.insert (Int2_Map_Data (Int2_Key (in, out), (int) connect_array.size ()));
if (!map_stat.second) {
Dir_Data *dir_ptr;
Link_Data *link_ptr;
dir_ptr = &dir_array [in];
link_ptr = &link_array [dir_ptr->Link ()];
in = link_ptr->Link ();
dir_ptr = &dir_array [out];
link_ptr = &link_array [dir_ptr->Link ()];
out = link_ptr->Link ();
Warning (String ("Duplicate Link Connection = %d to %d") % in % out);
continue;
} else {
connect_array.push_back (connect_rec);
}
}
}
End_Progress ();
file->Close ();
Print (2, String ("Number of %s Records = %d") % file->File_Type () % Progress_Count ());
num = (int) connect_array.size ();
if (num && num != Progress_Count ()) {
Print (1, String ("Number of %s Data Records = %d") % file->File_ID () % num);
}
if (num > 0) {
System_Data_True (CONNECTION);
Connect_Data *connect_ptr;
Dir_Data *dir_ptr;
//---- create directional link list ----
while (num--) {
connect_ptr = &connect_array [num];
dir_ptr = &dir_array [connect_ptr->Dir_Index ()];
connect_ptr->Next_To (dir_ptr->First_Connect_To ());
dir_ptr->First_Connect_To (num);
dir_ptr = &dir_array [connect_ptr->To_Index ()];
connect_ptr->Next_From (dir_ptr->First_Connect_From ());
dir_ptr->First_Connect_From (num);
}
}
}
