TMBitsets for subgraph membership

Author: yakra

siteupdate/cplusplus/classes/GraphGeneration/HGEdge.cpp

@@ -9,49 +9,26 @@
 
 HGEdge::HGEdge(HighwaySegment *s)
 {	// initial construction is based on a HighwaySegment
-	written = new char[Args::numthreads];
-		  // deleted by HGEdge::detach
-	// we only need to initialize the first element, for master graphs.
-	// the rest will get zeroed out for each subgraph set.
-	written[0] = 0;
 	vertex1 = s->waypoint1->hashpoint()->vertex;
 	vertex2 = s->waypoint2->hashpoint()->vertex;
 	format = simple | collapsed | traveled;
 	segment_name = s->segment_name();
-	vertex1->incident_s_edges.push_back(this);
-	vertex2->incident_s_edges.push_back(this);
-	vertex1->incident_c_edges.push_back(this);
-	vertex2->incident_c_edges.push_back(this);
-	vertex1->incident_t_edges.push_back(this);
-	vertex2->incident_t_edges.push_back(this);
+	vertex1->incident_edges.push_back(this);
+	vertex2->incident_edges.push_back(this);
+	vertex1->edge_count++;
+	vertex2->edge_count++;
 	// canonical segment, used to reference region and list of travelers
 	// assumption: each edge/segment lives within a unique region
 	// and a 'multi-edge' would not be able to span regions as there
 	// would be a required visible waypoint at the border
 	segment = s;
 }
 
-HGEdge::HGEdge(HGVertex *vertex, unsigned char fmt_mask)
+HGEdge::HGEdge(HGVertex *vertex, int& deletions, unsigned char fmt_mask, HGEdge *e1, HGEdge *e2)
 {	// build by collapsing two existing edges around a common hidden vertex
-	written = new char[Args::numthreads];
-		  // deleted by HGEdge::detach
-	written[0] = 0;
 	format = fmt_mask;
-	// we know there are exactly 2 incident edges, as we
-	// checked for that, and we will replace these two
-	// with the single edge we are constructing here...
-	HGEdge *edge1 = 0;
-	HGEdge *edge2 = 0;
-	if (fmt_mask & collapsed)
-	{	// ...in the compressed graph, and/or...
-		edge1 = vertex->incident_c_edges.front();
-		edge2 = vertex->incident_c_edges.back();
-	}
-	if (fmt_mask & traveled)
-	{	// ...in the traveled graph, as appropriate
-		edge1 = vertex->incident_t_edges.front();
-		edge2 = vertex->incident_t_edges.back();
-	}
+	HGEdge *edge1 = e1;
+	HGEdge *edge2 = e2;
 	// segment names should match as routes should not start or end
 	// nor should concurrencies begin or end at a hidden point
 	if (edge1->segment_name != edge2->segment_name)
@@ -103,46 +80,29 @@ HGEdge::HGEdge(HGVertex *vertex, unsigned char fmt_mask)
 			intermediate_point_string() << " to " << *(vertex2->unique_name) << std::endl;
 	//std::cout << "DEBUG: new " << str() << std::endl;
 
+	// clear format bits of old edges
+	// anything with a format of 0 won't be moved to the graph, and
+	// will be destroyed when the temp_edges container exits scope
+	edge1->format &= ~fmt_mask;
+	edge2->format &= ~fmt_mask;
 	// replace edge references at our endpoints with ourself
-	edge1->detach(fmt_mask);
-	edge2->detach(fmt_mask);
-	if (fmt_mask & collapsed)
-	{	vertex1->incident_c_edges.push_back(this);
-		vertex2->incident_c_edges.push_back(this);
-	}
-	if (fmt_mask & traveled)
-	{	vertex1->incident_t_edges.push_back(this);
-		vertex2->incident_t_edges.push_back(this);
-	}
+	if (!edge1->format) {edge1->detach(); deletions++;}
+	if (!edge2->format) {edge2->detach(); deletions++;}
+	vertex1->incident_edges.push_back(this);
+	vertex2->incident_edges.push_back(this);
 }
 
-void HGEdge::detach() {return detach(format);}
-void HGEdge::detach(unsigned char fmt_mask)
+void HGEdge::detach()
 {	// detach edge from vertices in graph(s) specified in fmt_mask
-	#define DETACH(v) \
-	  for (std::list<HGEdge*>::iterator e = v.begin(); e != v.end(); e++) \
+	auto detach = [&](std::vector<HGEdge*>& v) \
+	{ for (std::vector<HGEdge*>::iterator e = v.begin(); e != v.end(); e++) \
 	    if (*e == this) \
 	    {	v.erase(e); \
 		break; \
 	    }
-	if (fmt_mask & simple)
-	{	DETACH(vertex1->incident_s_edges)
-		DETACH(vertex2->incident_s_edges)
-	}
-	if (fmt_mask & collapsed)
-	{	DETACH(vertex1->incident_c_edges)
-		DETACH(vertex2->incident_c_edges)
-	}
-	if (fmt_mask & traveled)
-	{	DETACH(vertex1->incident_t_edges)
-		DETACH(vertex2->incident_t_edges)
-	}
-	#undef DETACH
-	format &= ~fmt_mask;
-	if (!format)
-	{	delete[] written;
-		delete this;
-	}
+	};
+	detach(vertex1->incident_edges);
+	detach(vertex2->incident_edges);
 }
 
 // write line to tmg collapsed edge file

siteupdate/cplusplus/classes/GraphGeneration/HGEdge.h

@@ -10,7 +10,6 @@ class HGEdge
     edge that can incorporate intermediate points.
     */
 	public:
-	char *written;
 	std::string segment_name;
 	HGVertex *vertex1, *vertex2;
 	std::list<HGVertex*> intermediate_points; // if more than 1, will go from vertex1 to vertex2
@@ -23,10 +22,9 @@ class HGEdge
 	static constexpr unsigned char traveled = 4;
 
 	HGEdge(HighwaySegment *);
-	HGEdge(HGVertex *, unsigned char);
+	HGEdge(HGVertex *, int&, unsigned char, HGEdge*, HGEdge*);
 
 	void detach();
-	void detach(unsigned char);
 	void collapsed_tmg_line(std::ofstream&, char*, unsigned int, std::vector<HighwaySystem*>*);
 	void traveled_tmg_line (std::ofstream&, char*, unsigned int, std::vector<HighwaySystem*>*, bool, char*);
 	std::string debug_tmg_line(std::vector<HighwaySystem*> *, unsigned int);

siteupdate/cplusplus/classes/GraphGeneration/HGVertex.cpp

@@ -16,31 +16,49 @@ void HGVertex::setup(Waypoint *wpt, const std::string *n)
 	t_vertex_num = new int[Args::numthreads];
 		       // deleted by ~HGVertex, called by HighwayGraph::clear
 	unique_name = n;
+	edge_count = 0;
 	visibility = 0;
 	    // permitted values:
 	    // 0: never visible outside of simple graphs
 	    // 1: visible only in traveled graph; hidden in collapsed graph
 	    // 2: visible in both traveled & collapsed graphs
 	if (!wpt->colocated)
 	{	if (!wpt->is_hidden) visibility = 2;
-		wpt->route->region->add_vertex(this, wpt);
-		wpt->route->system->add_vertex(this);
 		return;
 	}
 	for (Waypoint *w : *(wpt->colocated))
-	{	// will consider hidden iff all colocated waypoints are hidden
-		if (!w->is_hidden) visibility = 2;
-		w->route->region->add_vertex(this, wpt);// Yes, a region/system can get the same vertex multiple times
-		w->route->system->add_vertex(this);	// from different routes. But HighwayGraph::write_subgraphs_tmg
-	}						// gets rid of any redundancy when making the final set.
+		// will consider hidden iff all colocated waypoints are hidden
+		if (!w->is_hidden)
+		{	visibility = 2;
+			break;
+		}
 }
 
 HGVertex::~HGVertex()
 {	//std::cout << "deleting vertex at " << first_waypoint->str() << std::endl;
-	while (incident_s_edges.size()) incident_s_edges.front()->detach();
-	while (incident_c_edges.size()) incident_c_edges.front()->detach();
-	while (incident_t_edges.size()) incident_t_edges.front()->detach();
 	delete[] s_vertex_num;
 	delete[] c_vertex_num;
 	delete[] t_vertex_num;
 }
+
+HGEdge* HGVertex::front(unsigned char format)
+{	for (HGEdge* e : incident_edges)
+	  if (e->format & format)
+	    return e;
+	// Using this as intended with single-format bitmasks,
+	// we should never reach this point, because this function
+	// will only be called on vertices with edge_count of 2.
+	// Nonetheless, let's stop the compiler from complaining.
+	throw this;
+}
+
+HGEdge* HGVertex::back(unsigned char format)
+{	for (auto e = incident_edges.rbegin(); e != incident_edges.rend(); ++e)
+	  if ((*e)->format & format)
+	    return *e;
+	// Using this as intended with single-format bitmasks,
+	// we should never reach this point, because this function
+	// will only be called on vertices with edge_count of 2.
+	// Nonetheless, let's stop the compiler from complaining.
+	throw this;
+}

siteupdate/cplusplus/classes/GraphGeneration/HGVertex.h

@@ -2,7 +2,7 @@ class HGEdge;
 class HighwaySystem;
 class Region;
 class Waypoint;
-#include <list>
+#include <vector>
 #include <string>
 
 class HGVertex
@@ -12,14 +12,16 @@ class HGVertex
 	public:
 	double lat, lng;
 	const std::string *unique_name;
-	std::list<HGEdge*> incident_s_edges; // simple
-	std::list<HGEdge*> incident_c_edges; // collapsed
-	std::list<HGEdge*> incident_t_edges; // traveled
+	std::vector<HGEdge*> incident_edges;
 	int *s_vertex_num;
 	int *c_vertex_num;
 	int *t_vertex_num;
+	uint16_t edge_count;
 	char visibility;
 
 	void setup(Waypoint*, const std::string*);
 	~HGVertex();
+
+	HGEdge* front(unsigned char);
+	HGEdge* back (unsigned char);
 };