// color `node' using the color `to_assign'
// and try color all its adjacent nodes
bool ConstraintGraph::recur_color(const GNode &node,COLOR to_assign){
assert( to_assign != G ); // color will not be G!!
COLOR cur_color = get_color(node);
// this node has been colored to H or L
if( cur_color == to_assign )
return true;
// this node has colored to different color, fail!
else if( cur_color != G )
return false;
// it is G, color it, and all its neighbours
set_color(node,to_assign);
COLOR opposite_color = next_color(to_assign);
int idx = get_node_idx(node);
vector<GEdge> & elist = edge[idx];
for(int i = 0; i < row+col; i++) {
GEdge & e = elist[i];
if( i!=idx && e.count > 0){
bool result;
if( e.type == DIFF )
result = recur_color(e.v,opposite_color);
else
result = recur_color(e.v,to_assign);
if( result == false ) return false;
}
}
// safely colored all neighbour
return true;
}
int local_get_node_list(const struct sd_req *req, struct sd_rsp *rsp,
void *data)
{
struct sd_node_rsp *node_rsp = (struct sd_node_rsp *)rsp;
int nr_nodes;
if (current_vnode_info) {
nr_nodes = current_vnode_info->nr_nodes;
memcpy(data, current_vnode_info->nodes,
sizeof(struct sd_node) * nr_nodes);
node_rsp->data_length = nr_nodes * sizeof(struct sd_node);
node_rsp->nr_nodes = nr_nodes;
node_rsp->local_idx = get_node_idx(current_vnode_info,
&sys->this_node);
} else {
node_rsp->nr_nodes = 0;
node_rsp->local_idx = 0;
}
node_rsp->master_idx = -1;
return SD_RES_SUCCESS;
}
// recursively reverse the color of a componenet, which contains `node'
void ConstraintGraph::recur_reverse_color(const GNode &node,
BoolVector & mark){
int idx = get_node_idx(node);
// check if this node has been visited
if( mark[idx] == true ) return;
else mark[idx] = true;
COLOR origin_color = get_color(node);
COLOR new_color = next_color(origin_color);
set_color(node,new_color);
// reverse color all its adjacent nodes
vector<GEdge> & adj_nodes = edge[idx];
for (int v_idx=0; v_idx<row+col;v_idx++) {
// 1.no need to check itself
// 2.only check if edge exist
GEdge & e = adj_nodes[v_idx];
if( v_idx != idx && e.type != NOEDGE ){
assert( e.v != node );
recur_reverse_color(e.v,mark);
}
}
}
void CandyController::schedule_next_poll(byte node_id){
byte node_idx = get_node_idx(node_id);
_nodes[node_idx].next_poll = millis() + _nodes[node_idx].poll_interval;
debug("CC: poll scheduled");
}
// try to add edge with color awareness
// return EXIST if the edge exists already
bool ConstraintGraph::add_edge_color(const GNode &u,const GNode &v, EType type)
{
// first check if edge exist
int a=get_node_idx(u);
int b=get_node_idx(v);
//GEdge & uv = access_edge(u,v);
GEdge & uv = edge[a][b];
if( uv.type != NOEDGE ){// already has an edge
if( uv.type != type ) return false; // type incompatible
else do_add_edge(u,v,type); // safely add dummy edge
}
// now we ensure u-v edge NOT exist(NOEDGE)
// check if adding this edge will conflict
// explore all 9 cases: {G,H,V} X {G,H,V}
assert( u != v );
GNode & unode = access_node(u);
GNode & vnode = access_node(v);
COLOR ucolor = get_color(u);
COLOR vcolor = get_color(v);
// node u standalone, which means color = G
if( ucolor == G ){
assert( unode.ecount == 0 );
do_add_edge(u,v,type); // safely add edge
if( vcolor == G ){ // G,G: color them
set_color(unode,HI);
if( type == DIFF ) set_color(vnode,LO);
else set_color(vnode,HI);
}
else if( vcolor == HI ){// G,H
if( type == DIFF ) set_color(unode,LO);
else set_color(unode,HI);
}
else{// G,L
if( type == DIFF ) set_color(unode,HI);
else set_color(unode,LO);
}
return SUCCESS;
}
// v standlone(symmetric to previous case)
else if( vcolor == G ) {
assert( vnode.ecount == 0 );
do_add_edge(v,u,type); // safely add edge
if( ucolor == G ){ // G,G: color them
set_color(unode,LO);
if( type == DIFF ) set_color(vnode,HI);
else set_color(vnode,LO);
}
else if( ucolor == HI ){// H,G
if( type == DIFF ) set_color(vnode,LO);
else set_color(vnode,HI);
}
else{// L,G
if( type == DIFF ) set_color(vnode,HI);
else set_color(vnode,LO);
}
return SUCCESS;
}
else{// u,v not standalone => u,v has colors, but not connected
if( (ucolor != vcolor &&
type == DIFF) || // different color, DIFF edge
(ucolor == vcolor &&
type == SAME)) // same color, SAME edge
{// type compatible
do_add_edge(u,v,type); // safely link them
return SUCCESS;
}
// H-L, H-H or L-L
// try to swap the color
// of one connected component
//ConstraintGraph bak(*this); // make backup
reverse_color(v); // reverse the coloring of v component
COLOR u_newcolor = get_color(u);
if( ucolor != u_newcolor ){
// if u's color changed=>2-color failed
//*this = bak;
return FAIL;
}
else{
do_add_edge(u,v,type);// safely link them
return SUCCESS;
}
}
}
