static struct gale_packet *cat_filter(struct gale_packet *msg,void *d) {
struct directed *dir = (struct directed *) d;
struct gale_packet *rewrite;
struct gale_text cat = null_text;
int do_transmit = 0;
gale_create(rewrite);
rewrite->routing = null_text;
rewrite->content = msg->content;
while (gale_text_token(msg->routing,':',&cat)) {
struct gale_text base,host;
int orig_flag;
int flag = is_directed(cat,&orig_flag,&base,&host) && orig_flag
&& !gale_text_compare(host,dir->host);
base = category_escape(base,flag);
do_transmit |= flag;
rewrite->routing =
gale_text_concat(3,rewrite->routing,G_(":"),base);
}
if (!do_transmit) {
gale_dprintf(5,"*** no positive categories; dropped message\n");
return NULL;
}
/* strip leading colon */
if (rewrite->routing.l > 0)
rewrite->routing = gale_text_right(rewrite->routing,-1);
gale_dprintf(5,"*** \"%s\": rewrote categories to \"%s\"\n",
gale_text_to(gale_global->enc_console,dir->host),
gale_text_to(gale_global->enc_console,rewrite->routing));
return rewrite;
}
bool operator()(const Edge& e) const {
if (is_directed(m_g))
return source(e, m_g) == m_u && target(e, m_g) == m_v;
else
return (source(e, m_g) == m_u && target(e, m_g) == m_v)
|| (source(e, m_g) == m_v && target(e, m_g) == m_u);
}
// layer-specific attribute stores are initialized if needed
AttributeStoreSharedPtr MLNetwork::edge_features(const LayerSharedPtr& layer1, const LayerSharedPtr& layer2) {
if (edge_attributes.count(layer1->id)==0 || edge_attributes.at(layer1->id).count(layer2->id)==0) {
edge_attributes[layer1->id][layer2->id] = AttributeStore::create();
if (!is_directed(layer1,layer2))
edge_attributes[layer2->id][layer1->id] = edge_attributes[layer1->id][layer2->id];
}
return edge_attributes[layer1->id][layer2->id];
}
void subscr_transmit(
oop_source *src,
struct gale_packet *msg,struct connect *avoid)
{
struct gale_text cat = null_text;
struct gale_packet *rewrite;
while (gale_text_token(msg->routing,':',&cat)) {
struct gale_text host;
if (is_directed(cat,NULL,NULL,&host))
send_directed(src,host);
}
++stamp;
assert(list == NULL);
cat = null_text;
gale_create(rewrite);
rewrite->routing = null_text;
rewrite->content = msg->content;
while (gale_text_token(msg->routing,':',&cat)) {
struct gale_text base,host;
int flag;
gale_dprintf(3,"*** transmitting \"%s\"\n",
gale_text_to(gale_global->enc_console,cat));
is_directed(cat,&flag,&base,&host);
transmit(&root,base,avoid,flag);
base = category_escape(base,1);
rewrite->routing =
gale_text_concat(3,rewrite->routing,G_(":"),base);
}
/* strip leading colon */
if (rewrite->routing.l > 0)
rewrite->routing = gale_text_right(rewrite->routing,-1);
while (list != NULL) {
if (list->flag) {
gale_dprintf(4,"[%p] sending message\n",list->link);
send_connect(list->link,rewrite);
}
list = list->next;
}
}
void Graph<VertexDataType, EdgeDataType>::remove_edge(int u, int v) {
assert(1 <= u && u <= vertices() && 1 <= v && v <= vertices());
u--; v--;
if (contains_edge(u + 1, v + 1)) {
number_of_edges_--;
int pos = search(u, v);
adjacent_lists_[u].erase(pos + adjacent_lists_[u].begin());
if (!is_directed()) {
pos = search(v, u);
adjacent_lists_[v].erase(pos + adjacent_lists_[v].begin());
}
}
}
void Graph<VertexDataType, EdgeDataType>::add_edge(int u, int v, EdgeDataType edge_data) {
assert(1 <= u && u <= vertices() && 1 <= v && v <= vertices());
u--; v--;
int pos = search(u, v);
if (pos == -1) {
number_of_edges_++;
adjacent_lists_[u].push_back(Edge(u, v, edge_data));
}
if (!is_directed()) {
pos = search(v, u);
if (pos == -1) {
number_of_edges_++;
adjacent_lists_[v].push_back(Edge(v, u, edge_data));
}
}
}
static void subscr(oop_source *src,struct gale_text spec,struct connect *link,
void (*func)(struct node *,struct gale_text,struct sub *),
void (*dir)(oop_source *,struct gale_text))
{
struct gale_text cat = null_text;
struct sub sub;
sub.priority = 0;
gale_create(sub.connect);
sub.connect->stamp = stamp;
sub.connect->link = link;
/* easy escape */
if (!gale_text_compare(spec,G_("-"))) return;
gale_dprintf(3,"--- subscribing to all of \"%s\"\n",
gale_text_to(gale_global->enc_console,spec));
while (gale_text_token(spec,':',&cat)) {
struct gale_text host,base;
if (is_directed(cat,&sub.flag,&base,&host)) dir(src,host);
func(&root,base,&sub);
++sub.priority;
}
}
EdgeSharedPtr MLNetwork::add_edge(const NodeSharedPtr& node1, const NodeSharedPtr& node2) {
EdgeSharedPtr check = get_edge(node1,node2);
if (check) return NULL;
edge_id eid = ++max_edge_id;
bool edge_directed = is_directed(node1->layer,node2->layer);
EdgeSharedPtr new_edge_v1_v2(new edge(eid,node1,node2,edge_directed));
cidx_edge_by_nodes[node1->id][node2->id] = new_edge_v1_v2;
sidx_neighbors_out[node1->id].insert(node2->id,node2);
sidx_neighbors_in[node2->id].insert(node1->id,node1);
sidx_neighbors_all[node1->id].insert(node2->id,node2);
sidx_neighbors_all[node2->id].insert(node1->id,node1); // if node1 and node2 are the same, it also works
sidx_edges_by_layer_pair[node1->layer->id][node2->layer->id].insert(eid,new_edge_v1_v2);
edges.insert(eid,new_edge_v1_v2);
if (!edge_directed) {
// create an additional edge with the same identifier but inverted nodes
EdgeSharedPtr new_edge_v2_v1(new edge(eid,node2,node1,edge_directed));
cidx_edge_by_nodes[node2->id][node1->id] = new_edge_v2_v1;
sidx_neighbors_out[node2->id].insert(node1->id,node1);
sidx_neighbors_in[node1->id].insert(node2->id,node2);
if (node1->layer->id!=node2->layer->id)
sidx_edges_by_layer_pair[node2->layer->id][node1->layer->id].insert(eid,new_edge_v2_v1);
}
return new_edge_v1_v2;
}
bool is_undirected(const Graph& g) {
return !is_directed(g);
}
void create_network(NETWORK *network)
{
int i;
int length;
char *ptr;
char *start,*stop;
char line[LINELENGTH];
char label[LINELENGTH];
// Determine whether the network is directed
network->directed = is_directed();
// Count the vertices
network->nvertices = count_vertices();
// Make space for the vertices
network->vertex = calloc(network->nvertices,sizeof(VERTEX));
// Go through the file reading the details of each vertex one by one
reset_buffer();
for (i=0; i<network->nvertices; i++) {
// Skip to next "node" entry
do {
next_line(line);
} while (strstr(line,"node")==NULL);
// Read in the details of this vertex
do {
// Look for ID
ptr = strstr(line,"id");
if (ptr!=NULL) sscanf(ptr,"id %i",&network->vertex[i].id);
// Look for label
ptr = (strstr(line,"label"));
if (ptr!=NULL) {
start = strchr(line,'"');
if (start==NULL) {
sscanf(ptr,"label %s",&label);
} else {
stop = strchr(++start,'"');
if (stop==NULL) length = strlen(line) - (start-line);
else length = stop - start;
strncpy(label,start,length);
label[length] = '\0';
network->vertex[i].label = malloc((length+1)*sizeof(char));
strcpy(network->vertex[i].label,label);
}
}
// If we see a closing square bracket we are done
if (strstr(line,"]")!=NULL) break;
} while (next_line(line)==0);
}
// Sort the vertices in increasing order of their IDs so we can find them
// quickly later
qsort(network->vertex,network->nvertices,sizeof(VERTEX),(void*)cmpid);
}
