自学教程：C++ End_Progress函数代码示例

void TripSum::Write_Zones (void){	int i, nrec;	Point_Time_Data *end_ptr;	Show_Message ("Writing %s -- Record", zone_end_file.File_Type ());	Set_Progress (1000);	//---- write each zone ----	nrec = 0;	for (end_ptr = zone_end_data.First_Key (); end_ptr; end_ptr = zone_end_data.Next_Key ()) {		Show_Progress ();		if (end_ptr->Periods () > 0) {			zone_end_file.ID (end_ptr->ID ());			for (i=1; i <= num_inc; i++) {				zone_end_file.Total_In (i, end_ptr->In (i));				zone_end_file.Total_Out (i, end_ptr->Out (i));			}			if (!zone_end_file.Write ()) {				Error ("Writing %s", zone_end_file.File_Type ());			}			nrec++;		}	}	End_Progress ();	Print (2, "Number of %s Records = %d", zone_end_file.File_Type (), nrec);	zone_end_file.Close ();}

void LocationData::Read_Boundary (void){	int zone;	Points_Map_Stat map_stat;	//---- read zone polygons----	Show_Message (String ("Reading %s -- Record") % boundary_file.File_Type ());	Set_Progress ();	while (boundary_file.Read_Record ()) {		Show_Progress ();		//---- get the zone number ----		zone = boundary_file.Get_Integer (zone_field);		if (zone == 0) continue;		if (zone_map.find (zone) == zone_map.end ()) continue;		if (range_flag && !zone_range.In_Range (zone)) continue;		map_stat = boundary_map.insert (Points_Map_Data (zone, boundary_file));		if (!map_stat.second) {			Warning ("Duplicate Zone Number = ") << zone;		}	}	End_Progress ();	boundary_file.Close ();	Print (2, "Number of ") << boundary_file.File_Type () << " Records = " << boundary_map.size ();}

void LineSum::Read_Service (void){	String line;	int peak, offpeak, service;	//---- read the line service file ----	Show_Message (String ("Reading %s -- Record") % service_file.File_Type ());	Set_Progress ();	//---- read each record ----	while (service_file.Read ()) {		Show_Progress ();		line = service_file.Get_String (line_fld);		line.To_Upper ();		peak = service_file.Get_Integer (peak_fld);		offpeak = service_file.Get_Integer (offpeak_fld);		service = (peak << 16) + offpeak;		service_map.insert (Str_ID_Data (line, service));	}	End_Progress ();	Print (2, String ("Number of %s Records = %d") % service_file.File_Type () % service_map.size ());		service_file.Close ();}

void Network_Service::Read_Line (void){	Line_File *file = (Line_File *) Network_Db_File (TRANSIT_ROUTE);	//---- store the transit route data ----	Show_Message ("Reading %s -- Record", file->File_Type ());	Set_Progress ();	if (Check_Data () || Renumber ()) {		if (!Network_Data_Flag (TRANSIT_STOP) && 			(Network_File_Flag (TRANSIT_STOP) || Network_Option_Flag (TRANSIT_STOP))) {			Error (file_error, "Transit Stop", file->File_ID ());		}	}	First_Record (true);	int i, num;	while (file->Read (false)) {		Show_Progress ();		if (Line_Processing (file)) {			if (!line_data.Add ()) goto add_error;		}		First_Record (false);		num = file->Stops ();		for (i=1; i <= num; i++) {			if (!file->Read (true)) {				Error ("Number of Nested Records for Route %d", file->Route ());			}			Show_Progress ();			if (Line_Processing (file)) {				if (!line_data.Add ()) goto add_error;			}					}		}	End_Progress ();	file->Close ();	line_data.Route_Records (Progress_Count ());	Print (2, "Number of %s Records = %d", file->File_Type (), Progress_Count ());	num = line_data.Num_Records ();	if (num && num != Progress_Count ()) {		Print (1, "Number of Transit Route Data Records = %d", num);	}	line_data.Optimize ();	if (num > 0) Network_Data_True (TRANSIT_ROUTE);	return;add_error:	Error ("Adding Record to the Transit Route Data List");}

void ArcNet::Write_Subzone (void){	XYZ_Point point;	int z_field = subzone_file.Optional_Field ("Z_COORD", "ELEVATION", "Z");	arcview_subzone.Num_Points (1);	Show_Message ("Reading %s -- Record", subzone_file.File_Type ());	Set_Progress (1000);	while (subzone_file.Read ()) {		Show_Progress ();		arcview_subzone.Copy_Fields (&subzone_file);		point.x = subzone_file.X ();		point.y = subzone_file.Y ();		subzone_file.Get_Field (z_field, &(point.z));		arcview_subzone.points.Set (1, &point);		if (!arcview_subzone.Write_Record ()) {			Error ("Writing ArcView Subzone File");		}	}	End_Progress ();		subzone_file.Close ();	arcview_subzone.Close ();	Print (2, "Number of %s Records = %d", subzone_file.File_Type (), Progress_Count ());}

void IntControl::Read_Deletes (void){    int node;    //---- store the delete data ----    Show_Message ("Reading %s -- Record", delete_file.File_Type ());    Set_Progress ();    while (delete_file.Read ()) {        Show_Progress ();        Get_Integer (delete_file.Record (), &node);        if (node == 0) continue;        if (!delete_node.Add (node)) {            Error ("Adding Delete Node Record");        }    }    End_Progress ();    delete_file.Close ();    Print (2, "Number of %s Records = %d", delete_file.File_Type (), Progress_Count ());}

void LineSum::Read_Shapes (void){	int anode, bnode;	//---- read the arcview shape file ----	Show_Message (String ("Reading %s -- Record") % link_shape.File_Type ());	Set_Progress ();	//---- read each record ----	while (link_shape.Read_Record ()) {		Show_Progress ();		anode = link_shape.Get_Integer (anode_field);		bnode = link_shape.Get_Integer (bnode_field);		points_map.insert (I2_Points_Map_Data (Int2_Key (anode, bnode), link_shape));	}	End_Progress ();	Print (2, String ("Number of %s Records = %d") % link_shape.File_Type () % points_map.size ());		link_shape.Close ();}

void LocationData::Read_Polygons (void){	int i, index, num_pts;	Arcview_File *poly_file;	Boundary poly_rec;	Index_Array *polygon;	Db_Index_Array *data;	//---- read the arcview boundary file ----	for (i=0; i < num_polygons; i++) {		poly_file = polygon_files [i];		if (poly_file == NULL) continue;		Show_Message ("Reading %s -- Record", poly_file->File_Type ());		Set_Progress (1000);		//---- read each record ----		index = 0;		polygon = polygons [i];		data = polygon_db [i];		while (poly_file->Read_Record ()) {			Show_Progress ();			poly_rec.zone = ++index;			num_pts = poly_file->Num_Points ();			poly_rec.points = new Point_Data ();			if (poly_rec.points == NULL || !poly_rec.points->Num_Points (num_pts)) {				Error ("Insufficient Memory for Boundary Polygons");			}			num_pts *= sizeof (XY_Point);			memcpy (poly_rec.points->Get_XY_Data (1), poly_file->Get_XY_Data (1), num_pts);			if (!polygon->Add (&poly_rec)) {				Error ("Adding Boundary Polygon");			}			//----- add to the database ----			data->Copy_Fields (poly_file);			data->Put_Field (1, index);			if (!data->Add_Record ()) {				Error ("Writing Boundary Polygon Database");			}		}		End_Progress ();		Print (2, "Number of %s Records = %d", poly_file->File_Type (), Progress_Count ());				poly_file->Close ();	}}

void RoutePrep::Read_Node_Map (void){	String record;	Strings fields;	int node, index;	Int_Map_Itr map_itr;	Int_Map_Stat map_stat;	Node_Data *node_ptr;	Show_Message (String ("Reading %s -- Record") % node_map_file.File_Type ());	Set_Progress ();	while (node_map_file.Read ()) {		Show_Progress ();		record = node_map_file.Record_String ();		record.Parse (fields);		node = fields [0].Integer ();		if (node <= 0) continue;		index = fields [1].Integer ();		if (index > 0) {			map_itr = node_map.find (index);			if (map_itr == node_map.end ()) {				Warning (String ("Node Map %d to %d was Not Found in the Node File") % node % index);				continue;			}			index = map_itr->second;		}		//---- insert the node;		map_stat = input_map.insert (Int_Map_Data (node, index));		if (!map_stat.second) {			Warning (String ("Duplicate Node Map %d to %d and %d") % node % index % map_stat.first->second);			continue;		}		if (index >= 0) {			node_ptr = &node_array [index];			node_ptr->Control (node);		}	}	End_Progress ();	node_map_file.Close ();	Print (2, String ("Number of %s Records = %d") % node_map_file.File_Type () % Progress_Count ());}

void Emissions::Write_HPMS_VMT (void){	int vt, vt_field, yr_field, fac_field, vmt_field, off_field, max_vt, num_vt, year;	//---- create the data fields ----	hpms_file.Add_Field ("HPMSVtypeID", Db_Code::INTEGER, 3);	vt_field = 1;	hpms_file.Add_Field ("yearID", Db_Code::INTEGER, 5);	yr_field = 2;		hpms_file.Add_Field ("VMTGrowthFactor", Db_Code::DOUBLE, 9, 6);	fac_field = 3;		hpms_file.Add_Field ("HPMSBaseYearVMT", Db_Code::DOUBLE, 20, 2);	vmt_field = 4;		hpms_file.Add_Field ("baseYearOffNetVMT", Db_Code::DOUBLE, 20, 2);	off_field = 5;	hpms_file.Write_Header ();	//---- save the data to the file ----	Show_Message ("Writing %s -- Record", hpms_file.File_Type ());	Set_Progress ();	year = years.First ();	if (year == 0) year = 2007;	max_vt = category_data.Get (HPMS)->Max_Value ();	num_vt = 0;	for (vt=1; vt <= max_vt; vt++) {		Show_Progress ();		if (hpms_vmt [vt] == 0.0) continue;		hpms_file.Put_Field (vt_field, vt);		hpms_file.Put_Field (yr_field, year);		hpms_file.Put_Field (fac_field, 0);		hpms_file.Put_Field (vmt_field, hpms_vmt [vt] / MILETOMETER);		hpms_file.Put_Field (off_field, 0);		if (!hpms_file.Write ()) {			Error ("Writing %s", hpms_file.File_Type ());		}		num_vt++;	}	End_Progress ();	hpms_file.Close ();	Print (2, "Number of %s Records = %d", hpms_file.File_Type (), num_vt);}

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 ArcRider::Write_Stops (void){	int index, board, alight, stop_field, board_field, alight_field, total_field;	bool stop_flag;	Offset_Data *stop_ptr;	XYZ_Point point;	stop_field = arcview_stop.Field_Number ("STOP");	board_field = arcview_stop.Field_Number ("BOARD");	alight_field = arcview_stop.Field_Number ("ALIGHT");	total_field = arcview_stop.Field_Number ("TOTAL");		stop_flag = (transit_stops.Num_Ranges () > 0);	arcview_stop.Num_Points (1);	Show_Message ("Writing %s -- Record", arcview_stop.File_Type ());	Set_Progress (1000);	//---- process each stop ----	for (stop_ptr = stop_offset.First (); stop_ptr; stop_ptr = stop_offset.Next ()) {		Show_Progress ();		if (stop_flag && !transit_stops.In_Range (stop_ptr->ID ())) continue;		index = stop_offset.Record_Index ();		board = board_data [index];		alight = alight_data [index];		if (board <= 0 && alight <= 0) continue;		//---- write the stop record ----		point.x = stop_ptr->X ();		point.y = stop_ptr->Y ();		point.z = stop_ptr->Z ();		arcview_stop.Put_Field (stop_field, stop_ptr->ID ());		arcview_stop.Put_Field (board_field, board);		arcview_stop.Put_Field (alight_field, alight);		arcview_stop.Put_Field (total_field, (board + alight));		arcview_stop.points.Set (1, &point);		if (!arcview_stop.Write_Record ()) {			Error ("Writing ArcView Stop Demand File");		}		num_stop++;	}	End_Progress ();	arcview_stop.Close ();}

void ZoneData::Read_Data (int num){	int id, field, count;	Db_Index_Array *data;	Db_Header *file;	//---- set the file pointers ----	file = data_files [num];	if (file == NULL) return;	data = data_db [num];	field = data_field [num];	if (!data->Max_Records (file->Num_Records ())) {		Error ("Insufficient Memory for Data File Database");	}	//---- read the data file ----	Show_Message ("Reading %s -- Record", file->File_Type ());	Set_Progress (1000);	count = 0;	while (file->Read ()) {		Show_Progress ();		//---- get the join field id ----		file->Get_Field (field, &id);		if (id == 0) continue;		//---- copy the data fields ----		data->Copy_Fields (file);		//---- set the record index and location count ----		data->Put_Field (1, id);		data->Put_Field (2, 0);		//---- save the database record ----		if (!data->Add_Record ()) {			Error ("Writing Data File Database");		}		count++;	}	End_Progress ();	Print (2, "Number of %s Records = %d", file->File_Type (), count);		file->Close ();}

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 TransitAccess::Read_Link (void){	int anode, bnode, dist, zone, type;	double len;	String text;	Zone_Map_Itr zone_itr;	Node_Map_Itr node_itr;	//---- walk link data ----	Show_Message (String ("Reading %s -- Record") % link_data_file.File_Type ());	Set_Progress ();	while (link_data_file.Read ()) {		Show_Progress ();		anode = link_data_file.Get_Integer (link_anode_fld);		bnode = link_data_file.Get_Integer (link_bnode_fld);		if (skip_links.find (Int2_Key (anode, bnode)) != skip_links.end ()) continue;		if (skip_links.find (Int2_Key (bnode, anode)) != skip_links.end ()) continue;		len = link_data_file.Get_Double (link_len_fld);		zone = link_data_file.Get_Integer (link_zone_fld);		type = link_data_file.Get_Integer (link_type_fld);		if (!type_range.In_Range (type)) continue;		zone_itr = zone_map.find (zone);		if (zone_itr == zone_map.end ()) continue;		if (zone_itr->second.walk == 0) continue;		dist = DTOI (len * 100.0 * zone_itr->second.weight);		node_itr = node_map.find (anode);		if (node_itr != node_map.end ()) {			node_itr->second.use = 1;		}		node_itr = node_map.find (bnode);		if (node_itr != node_map.end ()) {			node_itr->second.use = 1;		}			text (" N=%d-%d MODE=13 SPEED=3 ONEWAY=T DIST=%d") % anode % bnode % dist;		sidewalk_file.File () << "SUPPORT" << text << endl;		walk_link_file.File () << "SUPPLINK" << text << endl;	}	End_Progress ();	link_data_file.Close ();	Print (2, "Number of Link Data Records = ") << Progress_Count ();}

void ActivityPattern::Survey_Population (void){	int hhold;	Survey_HHold *household_ptr;	Survey_Person *population_ptr;	if (!survey_pop_data.Max_Records (survey_pop_file.Num_Records ())) goto mem_error;	//---- read the survey population file ----	Show_Message ("Reading %s -- Record", survey_pop_file.File_Type ());	Set_Progress (50000);		while (survey_pop_file.Read ()) {		Show_Progress ();		//---- check the household id ----		hhold = survey_pop_file.Household ();		if (hhold <= 0) continue;		household_ptr = survey_hh_data.Get (hhold);		if (household_ptr == NULL) {			Error ("Survey Person Household %d was Not Found", hhold);		}		population_ptr = survey_pop_data.New_Record (true);		if (population_ptr == NULL) goto mem_error;		population_ptr->Household (hhold);		population_ptr->Person (survey_pop_file.Person ());		population_ptr->Age (survey_pop_file.Age ());		population_ptr->Gender (survey_pop_file.Gender ());		population_ptr->Work (survey_pop_file.Work ());		population_ptr->Drive (survey_pop_file.Drive ());		population_ptr->Count (0);		if (!survey_pop_data.Add ()) {			Error ("Adding Record to the Population Data Array");		}	}	End_Progress ();	survey_pop_file.Close ();	Print (2, "Number of %s Records = %d", survey_pop_file.File_Type (), Progress_Count ());	survey_pop_data.Optimize ();	return;mem_error:	Error ("Insufficient Memory for Survey Population Data");}

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 PlanSum::Write_Turns (void){    int i;    char *time1_ptr, *time2_ptr;    Movement_Data *move_ptr;    Movement_Array *array_ptr;    Dir_Data *dir_ptr;    Show_Message ("Writing %s -- Record", turn_file.File_Type ());    Set_Progress (10000);    //---- write each turn movement ----    for (i=1; i <= num_inc; i++) {        array_ptr = movement_data [i];        time1_ptr = time_periods.Range_Format (i);        time2_ptr = strstr (time1_ptr, "..");        *time2_ptr = '/0';        time2_ptr += 2;        for (move_ptr = array_ptr->First_Key (); move_ptr; move_ptr = array_ptr->Next_Key ()) {            Show_Progress ();            turn_file.Node (move_ptr->node);            dir_ptr = dir_data [move_ptr->in_link];            turn_file.In_Link (dir_ptr->Link ());            dir_ptr = dir_data [move_ptr->out_link];            turn_file.Out_Link (dir_ptr->Link ());            turn_file.Start (time1_ptr);            turn_file.End (time2_ptr);            turn_file.Volume (move_ptr->volume);            //---- save the record ----            if (!turn_file.Write ()) {                Error ("Writing Turn Movement File");            }        }    }    End_Progress ();    Print (2, "Number of %s Records = %d", turn_file.File_Type (), Progress_Count ());    turn_file.Close ();}

void ZoneData::Read_Data (void){	int id, field, count;	Db_Sort_Array *data;	Db_Header *file;	Data_Itr data_itr;	for (data_itr = data_group.begin (); data_itr != data_group.end (); data_itr++) {		file = data_itr->file;		data = data_itr->data_db;		field = data_itr->join_field;		//---- read the data file ----		Show_Message (String ("Reading %s -- Record") % file->File_Type ());		Set_Progress ();		count = 0;		while (file->Read ()) {			Show_Progress ();			//---- get the join field id ----			id = file->Get_Integer (field);			if (id == 0) continue;			//---- copy the data fields ----			data->Copy_Fields (*file);			//---- set the record index and zone count ----			data->Put_Field (0, id);			data->Put_Field (1, 0);			//---- save the database record ----			if (!data->Write_Record (id)) {				Error ("Writing Data File Database");			}			count++;		}		End_Progress ();		Print (2, String ("Number of Data #%d Records = %d") % data_itr->group % count);				file->Close ();	}}

void ArcPlan::Write_Parking (void){	int index, in, out, park_field, out_field, in_field, tot_field;	Offset_Data *parking_ptr;	XYZ_Point point;	park_field = arcview_parking.Field_Number ("PARKING");	out_field = arcview_parking.Field_Number ("DEPART");	in_field = arcview_parking.Field_Number ("ARRIVE");	tot_field = arcview_parking.Field_Number ("TOTAL");	arcview_parking.Num_Points (1);	Show_Message ("Writing %s -- Record", arcview_parking.File_Type ());	Set_Progress (1000);	//---- process each parking lot ----	for (parking_ptr = parking_offset.First (); parking_ptr; parking_ptr = parking_offset.Next ()) {		Show_Progress ();		index = parking_offset.Record_Index ();		out = parking_out [index];		in = parking_in [index];		if (in <= 0 && out <= 0) continue;		//---- write the parking record ----		point.x = parking_ptr->X ();		point.y = parking_ptr->Y ();		arcview_parking.Put_Field (park_field, parking_ptr->ID ());		arcview_parking.Put_Field (out_field, out);		arcview_parking.Put_Field (in_field, in);		arcview_parking.Put_Field (tot_field, (out + in));		arcview_parking.points.Set (1, &point);		if (!arcview_parking.Write_Record ()) {			Error ("Writing ArcView Parking Demand File");		}		num_parking++;	}	End_Progress ();	arcview_parking.Close ();}

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 TransimsNet::Add_Node_Data (void){	int node, count;	Db_Sort_Itr db_itr;	Int_Map_Stat map_stat;	Node_Data node_rec;	//---- read the data file ----	Show_Message (String ("Adding %s -- Record") % node_data_file.File_Type ());	Set_Progress ();	count = 0;	for (db_itr = node_data_array.begin (); db_itr != node_data_array.end (); db_itr++) {		Show_Progress ();		node = db_itr->first;		if (node_map.find (node) != node_map.end ()) continue;		update_node_range.Add_Range (node, node);		node_data_array.Read_Record (node);		count++;		node_data_file.Copy_Fields (node_data_array);		node_rec.Clear ();		node_rec.Node (node_data_file.Node ());		node_rec.X (node_data_file.X ());		node_rec.Y (node_data_file.Y ());		node_rec.Z (node_data_file.Z ());		node_rec.Subarea (node_data_file.Subarea ());		node_rec.Notes (node_data_file.Notes ());		map_stat = node_map.insert (Int_Map_Data (node_rec.Node (), (int) node_array.size ()));		if (!map_stat.second) {			Warning ("Duplicate Node Number = ") << node_rec.Node ();			continue;		} else {			node_array.push_back (node_rec);		}	}	End_Progress ();	Print (2, String ("Number of %s Records Added = %d") % node_data_file.File_Type () % count);}

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 Network_Service::Read_Phasing (void){	Db_File *file = Network_Db_File (PHASING_PLAN);	//---- store the phasing plan data ----	Show_Message ("Reading %s -- Record", file->File_Type ());	Set_Progress ();	if (Check_Data () || Renumber ()) { 		if (!Network_File_Flag (NODE) && Network_Option_Flag (NODE)) {			Error (file_error, "Node", file->File_ID ());		}		if (!Network_File_Flag (LINK) && Network_Option_Flag (LINK)) {			Error (file_error, "Link", file->File_ID ());		}		if (!Network_File_Flag (TIMING_PLAN) && Network_Option_Flag (TIMING_PLAN)) {			Error (file_error, "Timing Plan", file->File_ID ());		}	}	file->Num_Records ();	First_Record (true);	while (file->Read ()) {		Show_Progress ();		if (Phasing_Processing (file)) {			if (!phasing_data.Add ()) {				Error ("Adding Record to the Phasing Plan List");			}		}		First_Record (false);	}	End_Progress ();	file->Close ();	phasing_data.Max_Records (phasing_data.Num_Records ());	Print (2, "Number of %s Records = %d", file->File_Type (), Progress_Count ());	int num = phasing_data.Num_Records ();	if (num && num != Progress_Count ()) {		Print (1, "Number of Phasing Plan Data Records = %d", num);	}	if (num > 0) Network_Data_True (PHASING_PLAN);}

void PlanTrips::Write_Activity (void){	Activity_Data *act_ptr;	char buffer [FIELD_BUFFER];		Show_Message ("Writing %s", act_file->File_Type ());	Set_Progress (10000);	//---- process each activity ----	for (act_ptr = activity_data.First_Key (); act_ptr; act_ptr = activity_data.Next_Key ()) {		Show_Progress ();		act_file->Household (act_ptr->Household ());		act_file->Person (act_ptr->Person ());		act_file->Activity (act_ptr->Activity ());		act_file->Purpose (act_ptr->Purpose ());		act_file->Priority (act_ptr->Priority ());		trip_time.Format_Step (act_ptr->Start_Time (), buffer);		act_file->Start_Min (buffer);		act_file->Start_Max (buffer);				trip_time.Format_Step (act_ptr->End_Time (), buffer);		act_file->End_Min (buffer);		act_file->End_Max (buffer);				trip_time.Format_Duration (act_ptr->Duration (), buffer);		act_file->Time_Min (buffer);		act_file->Time_Max (buffer);		act_file->Mode (act_ptr->Mode ());		act_file->Vehicle (act_ptr->Vehicle ());		act_file->Location (act_ptr->Location ());		act_file->Passengers (act_ptr->Passengers ());		act_file->Constraint (act_ptr->Constraint ());		if (!act_file->Write ()) {			Error ("Writing %s", act_file->File_Type ());		}		num_act++;	}	End_Progress ();	act_file->Close ();}

void GISNet::Read_Node (void){	int node, node_field, z_field;	XYZ_Point *pt_ptr;	Node_Data node_rec;	//---- initialize the node array ----	node_field = gis_node.Required_Field ("NODE", "ID", "NODE_ID", "NODEID", "N");	z_field = gis_node.Optional_Field ("Z_COORD", "ELEVATION", "Z");	//---- read each node record----	Show_Message ("Reading %s -- Record", gis_node.File_Type ());	Set_Progress (1000);	while (gis_node.Read_Record ()) {		Show_Progress ();		//---- read the node data ----		gis_node.Get_Field (node_field, &node);		if (node == 0) continue;		if (node >= first_node) first_node = node + 1;				pt_ptr = gis_node.points.First ();		//---- save to index class -----		node_rec.Node (node);		node_rec.X (Round (pt_ptr->x));		node_rec.Y (Round (pt_ptr->y));		node_rec.Z (Round (pt_ptr->z));		if (!node_data.Add (&node_rec)) {			Error ("Adding Node Data Record");		}	}	End_Progress ();	gis_node.Close ();	Print (2, "Number of %s Records = %d", gis_node.File_Type (), Progress_Count ());}

void Data_Service::Write_Households (void){	int part, num_part, count;	Household_File *file = System_Household_File (true);	Int_Map_Itr itr;	Household_Data *hhold_ptr;	Household_Itr hhold_itr;	Partition_Files <Household_File> new_file_set;	if (file->Part_Flag ()) {		for (num_part=0, hhold_itr = hhold_array.begin (); hhold_itr != hhold_array.end (); hhold_itr++) {			part = Partition_Index (hhold_itr->Partition ());			if (part > num_part) num_part = part;		}		new_file_set.Initialize (file, ++num_part);		Show_Message (String ("Writing %ss -- Record") % file->File_Type ());	} else {		num_part = 1;		Show_Message (String ("Writing %s -- Record") % file->File_Type ());	}	Set_Progress ();	for (count=0, itr = hhold_map.begin (); itr != hhold_map.end (); itr++) {		Show_Progress ();		hhold_ptr = &hhold_array [itr->second];		if (hhold_ptr->Partition () < 0) continue;		if (file->Part_Flag ()) {			part = Partition_Index (hhold_ptr->Partition ());			if (part < 0) continue;			file = new_file_set [part];		}		count += Put_Household_Data (*file, *hhold_ptr);	}	End_Progress ();	file->Close ();		Print (2, String ("%s Records = %d") % file->File_Type () % count);	if (num_part > 1) Print (0, String (" (%d files)") % num_part);}

void Network_Service::Read_Turn (void){	Turn_File *file = (Turn_File *) Network_Db_File (TURN_PROHIBITION);	//---- store the turn prohibition data ----	Show_Message ("Reading %s -- Record", file->File_Type ());	Set_Progress ();	if (Check_Data () || Renumber ()) {		if (!Network_File_Flag (NODE) && Network_Option_Flag (NODE) && file->Node_Based ()) {			Error (file_error, "Node", file->File_ID ());		}		if (!Network_File_Flag (LINK) && Network_Option_Flag (LINK)) {			Error (file_error, "Link", file->File_ID ());		}	}	file->Num_Records ();	First_Record (true);	while (file->Read ()) {		Show_Progress ();		if (Turn_Processing (file)) {			if (!turn_data.Add ()) {				Error ("Adding Record to the Turn Data List");			}		}		First_Record (false);	}	End_Progress ();	file->Close ();	Print (2, "Number of %s Records = %d", file->File_Type (), Progress_Count ());	int num = turn_data.Num_Records ();	if (num && num != Progress_Count ()) {		Print (1, "Number of Turn Prohibition Data Records = %d", num);	}	turn_data.Optimize ();	if (num > 0) Network_Data_True (TURN_PROHIBITION);}

void Demand_Service::Read_Vehicle (void){	vehicle_data.Sorted (!sort_flag);	Db_File *file = Demand_Db_File (VEHICLE);	//---- store the vehicle data ----	Show_Message ("Reading %s -- Record", file->File_Type ());	Set_Progress (50000);	if (Check_Data () || Renumber ()) { 		if (!Network_File_Flag (PARKING) && Network_Option_Flag (PARKING)) {			Error (file_error, "Parking", file->File_ID ());		}	}	//file->Num_Records ();	First_Record (true);	while (file->Read ()) {		Show_Progress ();		if (Vehicle_Processing (file)) {			if (!vehicle_data.Add ()) {				Error ("Adding Record to the Vehicle Data Array");			}		}		First_Record (false);	}	End_Progress ();	file->Close ();	Print (2, "Number of %s Records = %d", file->File_Type (), Progress_Count ());	int num = vehicle_data.Num_Records ();	if (num && num != Progress_Count ()) {		Print (1, "Number of Vehicle Data Records = %d", num);	}	vehicle_data.Optimize (compress_flag);	if (num > 0) Demand_Data_True (VEHICLE);}

void TripSum::Write_Link_Trips (void){	int i, j, p, link, num_periods, total, count;	Int_Map_Itr map_itr;	Integers *trips;	Show_Message ("Writing Link Trip Ends -- Link");	Set_Progress ();	count = 0;	num_periods = sum_periods.Num_Periods ();	for (map_itr = link_map.begin (); map_itr != link_map.end (); map_itr++) {		Show_Progress ();		link = map_itr->second;		link_trip_file.Put_Field (0, map_itr->first);		trips = &link_trip_data [link];		total = 0;		j = num_periods * 2;		for (i=0; i < j; i++) {			total += trips->at (i);		}		if (total == 0) continue;		//---- process each time period ----		for (i=1, p=j=0; p < num_periods; p++) {			link_trip_file.Put_Field (i++, trips->at (j++));			link_trip_file.Put_Field (i++, trips->at (j++));		}		link_trip_file.Write ();		count++;	}	End_Progress ();	Print (2, "Number of New Link Trip End Records = ") << count;}