void glp_create_index(glp_prob *lp)
{ GLPROW *row;
GLPCOL *col;
int i, j;
/* create row name index */
if (lp->r_tree == NULL)
{ lp->r_tree = avl_create_tree(avl_strcmp, NULL);
for (i = 1; i <= lp->m; i++)
{ row = lp->row[i];
xassert(row->node == NULL);
if (row->name != NULL)
{ row->node = avl_insert_node(lp->r_tree, row->name);
avl_set_node_link(row->node, row);
}
}
}
/* create column name index */
if (lp->c_tree == NULL)
{ lp->c_tree = avl_create_tree(avl_strcmp, NULL);
for (j = 1; j <= lp->n; j++)
{ col = lp->col[j];
xassert(col->node == NULL);
if (col->name != NULL)
{ col->node = avl_insert_node(lp->c_tree, col->name);
avl_set_node_link(col->node, col);
}
}
}
return;
}
void glp_set_col_name(glp_prob *lp, int j, const char *name)
{ GLPCOL *col;
if (!(1 <= j && j <= lp->n))
xerror("glp_set_col_name: j = %d; column number out of range\n"
, j);
col = lp->col[j];
if (col->name != NULL)
{ if (col->node != NULL)
{ xassert(lp->c_tree != NULL);
avl_delete_node(lp->c_tree, col->node);
col->node = NULL;
}
dmp_free_atom(lp->pool, col->name, strlen(col->name)+1);
col->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ if (strlen(name) > 255)
xerror("glp_set_col_name: j = %d; column name too long\n",
j);
col->name = dmp_get_atom(lp->pool, strlen(name)+1);
strcpy(col->name, name);
if (lp->c_tree != NULL && col->name != NULL)
{ xassert(col->node == NULL);
col->node = avl_insert_node(lp->c_tree, col->name);
avl_set_node_link(col->node, col);
}
}
return;
}
void glp_set_row_name(glp_prob *lp, int i, const char *name)
{ GLPROW *row;
if (!(1 <= i && i <= lp->m))
xerror("glp_set_row_name: i = %d; row number out of range\n",
i);
row = lp->row[i];
if (row->name != NULL)
{ if (row->node != NULL)
{ xassert(lp->r_tree != NULL);
avl_delete_node(lp->r_tree, row->node);
row->node = NULL;
}
dmp_free_atom(lp->pool, row->name, strlen(row->name)+1);
row->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ if (strlen(name) > 255)
xerror("glp_set_row_name: i = %d; row name too long\n", i);
row->name = dmp_get_atom(lp->pool, strlen(name)+1);
strcpy(row->name, name);
if (lp->r_tree != NULL)
{ xassert(row->node == NULL);
row->node = avl_insert_node(lp->r_tree, row->name);
avl_set_node_link(row->node, row);
}
}
return;
}
static avl_node_t* avl_insert_node(
bs_avl_t* avl,
avl_node_t *parent,
avl_data_t data)
{
avl_node_t *new_node = NULL;
if(NULL == avl || NULL == avl->compare)
{
return NULL;
}
if(NULL == parent)
{
new_node = (avl_node_t*)bs_malloc(sizeof(avl_node_t));
if(NULL == new_node)
{
bs_debug("Failed to allocate memory!\n");
return NULL;
}
new_node->left_child = NULL;
new_node->right_child = NULL;
new_node->data = data;
//bs_debug("insert %d \n", (int8_t)data);
return new_node;
}
else if(avl->compare(parent->data, data) < 0)
{
//bs_debug("parent->data[%c] < data[%c] \n", parent->data, data);
parent->right_child =
avl_insert_node(avl, parent->right_child, data);
return avl_rebalance(parent);
}
else if(avl->compare(parent->data, data) > 0)
{
//bs_debug("parent->data[%c] > data[%c] \n", parent->data, data);
parent->left_child =
avl_insert_node(avl, parent->left_child, data);
return avl_rebalance(parent);
}
else
{
//bs_debug("same data!! \n");
}
return parent;
}
/* insert data to tree */
int avl_insert(avl_tree_t* tree, avl_key_t key, void* data)
{
if (tree)
{
tree->root = avl_insert_node(tree->root, key, data);
tree->size++;
return 1;
}
return 0;
}
int32_t bs_avl_insert(bs_avl_t* avl, avl_data_t data)
{
avl->root = (void*)avl_insert_node(avl,
(avl_node_t*)avl->root, data);
avl->root = avl_rebalance((avl_node_t*)avl->root);
//bs_debug("root:%p\n", avl->root);
if(NULL == avl->root)
return -1;
return 0;
}
/* insert an node to tree */
static avl_node_t* avl_insert_node(avl_node_t* root, avl_key_t key, void* data)
{
int rotate = 0;
if (root == NULL)
{
return avl_new_node(key, data);
}
if (key < root->key)
{
rotate = ROT_LEFT;
root->left = avl_insert_node(root->left, key, data);
}
else if (key > root->key)
{
rotate = ROT_RIGHT;
root->right = avl_insert_node(root->right, key, data);
}
else
assert(!"duplicated key insertion not supported");
/* update height */
root->height = MAX(HEIGHT(root->left), HEIGHT(root->right)) + 1;
return avl_balance_node(root, avl_get_balance(root), rotate);
}
void glp_create_v_index(glp_graph *G)
{ /* create vertex name index */
glp_vertex *v;
int i;
if (G->index == NULL)
{ G->index = avl_create_tree(avl_strcmp, NULL);
for (i = 1; i <= G->nv; i++)
{ v = G->v[i];
xassert(v->entry == NULL);
if (v->name != NULL)
{ v->entry = avl_insert_node(G->index, v->name);
avl_set_node_link(v->entry, v);
}
}
}
return;
}
void glp_set_row_name(glp_prob *lp, int i, const char *name)
{ glp_tree *tree = lp->tree;
GLPROW *row;
if (!(1 <= i && i <= lp->m))
xerror("glp_set_row_name: i = %d; row number out of range\n",
i);
row = lp->row[i];
if (tree != NULL && tree->reason != 0)
{ xassert(tree->curr != NULL);
xassert(row->level == tree->curr->level);
}
if (row->name != NULL)
{ if (row->node != NULL)
{ xassert(lp->r_tree != NULL);
avl_delete_node(lp->r_tree, row->node);
row->node = NULL;
}
dmp_free_atom(lp->pool, row->name, strlen(row->name)+1);
row->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ int k;
for (k = 0; name[k] != '\0'; k++)
{ if (k == 256)
xerror("glp_set_row_name: i = %d; row name too long\n",
i);
if (iscntrl((unsigned char)name[k]))
xerror("glp_set_row_name: i = %d: row name contains inva"
"lid character(s)\n", i);
}
row->name = dmp_get_atom(lp->pool, strlen(name)+1);
strcpy(row->name, name);
if (lp->r_tree != NULL)
{ xassert(row->node == NULL);
row->node = avl_insert_node(lp->r_tree, row->name);
avl_set_node_link(row->node, row);
}
}
return;
}
void glp_set_col_name(glp_prob *lp, int j, const char *name)
{ glp_tree *tree = lp->tree;
GLPCOL *col;
if (tree != NULL && tree->reason != 0)
xerror("glp_set_col_name: operation not allowed\n");
if (!(1 <= j && j <= lp->n))
xerror("glp_set_col_name: j = %d; column number out of range\n"
, j);
col = lp->col[j];
if (col->name != NULL)
{ if (col->node != NULL)
{ xassert(lp->c_tree != NULL);
avl_delete_node(lp->c_tree, col->node);
col->node = NULL;
}
dmp_free_atom(lp->pool, col->name, strlen(col->name)+1);
col->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ int k;
for (k = 0; name[k] != '\0'; k++)
{ if (k == 256)
xerror("glp_set_col_name: j = %d; column name too long\n"
, j);
if (iscntrl((unsigned char)name[k]))
xerror("glp_set_col_name: j = %d: column name contains i"
"nvalid character(s)\n", j);
}
col->name = dmp_get_atom(lp->pool, strlen(name)+1);
strcpy(col->name, name);
if (lp->c_tree != NULL && col->name != NULL)
{ xassert(col->node == NULL);
col->node = avl_insert_node(lp->c_tree, col->name);
avl_set_node_link(col->node, col);
}
}
return;
}
void glp_set_vertex_name(glp_graph *G, int i, const char *name)
{ /* assign (change) vertex name */
glp_vertex *v;
if (!(1 <= i && i <= G->nv))
xerror("glp_set_vertex_name: i = %d; vertex number out of rang"
"e\n", i);
v = G->v[i];
if (v->name != NULL)
{ if (v->entry != NULL)
{ xassert(G->index != NULL);
avl_delete_node(G->index, v->entry);
v->entry = NULL;
}
dmp_free_atom(G->pool, v->name, strlen(v->name)+1);
v->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ int k;
for (k = 0; name[k] != '\0'; k++)
{ if (k == 256)
xerror("glp_set_vertex_name: i = %d; vertex name too lon"
"g\n", i);
if (iscntrl((unsigned char)name[k]))
xerror("glp_set_vertex_name: i = %d; vertex name contain"
"s invalid character(s)\n", i);
}
v->name = dmp_get_atom(G->pool, strlen(name)+1);
strcpy(v->name, name);
if (G->index != NULL)
{ xassert(v->entry == NULL);
v->entry = avl_insert_node(G->index, v->name);
avl_set_node_link(v->entry, v);
}
}
return;
}
bool add_edge_h(connection_t *c) {
edge_t *e;
node_t *from, *to;
char from_name[MAX_STRING_SIZE];
char to_name[MAX_STRING_SIZE];
char to_address[MAX_STRING_SIZE];
char to_port[MAX_STRING_SIZE];
sockaddr_t address;
uint32_t options;
int weight;
if(sscanf(c->buffer, "%*d %*x "MAX_STRING" "MAX_STRING" "MAX_STRING" "MAX_STRING" %x %d",
from_name, to_name, to_address, to_port, &options, &weight) != 6) {
logger(LOG_ERR, "Got bad %s from %s (%s)", "ADD_EDGE", c->name,
c->hostname);
return false;
}
/* Check if names are valid */
if(!check_id(from_name) || !check_id(to_name)) {
logger(LOG_ERR, "Got bad %s from %s (%s): %s", "ADD_EDGE", c->name,
c->hostname, "invalid name");
return false;
}
if(seen_request(c->buffer))
return true;
/* Lookup nodes */
from = lookup_node(from_name);
to = lookup_node(to_name);
if(tunnelserver &&
from != myself && from != c->node &&
to != myself && to != c->node) {
/* ignore indirect edge registrations for tunnelserver */
ifdebug(PROTOCOL) logger(LOG_WARNING,
"Ignoring indirect %s from %s (%s)",
"ADD_EDGE", c->name, c->hostname);
return true;
}
if(!from) {
from = new_node();
from->name = xstrdup(from_name);
node_add(from);
}
if(!to) {
to = new_node();
to->name = xstrdup(to_name);
node_add(to);
}
/* Convert addresses */
address = str2sockaddr(to_address, to_port);
/* Check if edge already exists */
e = lookup_edge(from, to);
if(e) {
if(e->weight != weight || e->options != options || sockaddrcmp(&e->address, &address)) {
if(from == myself) {
ifdebug(PROTOCOL) logger(LOG_WARNING, "Got %s from %s (%s) for ourself which does not match existing entry",
"ADD_EDGE", c->name, c->hostname);
send_add_edge(c, e);
return true;
} else {
ifdebug(PROTOCOL) logger(LOG_WARNING, "Got %s from %s (%s) which does not match existing entry",
"ADD_EDGE", c->name, c->hostname);
e->options = options;
if(sockaddrcmp(&e->address, &address)) {
sockaddrfree(&e->address);
e->address = address;
}
if(e->weight != weight) {
avl_node_t *node = avl_unlink(edge_weight_tree, e);
e->weight = weight;
avl_insert_node(edge_weight_tree, node);
}
goto done;
}
} else
return true;
} else if(from == myself) {
ifdebug(PROTOCOL) logger(LOG_WARNING, "Got %s from %s (%s) for ourself which does not exist",
"ADD_EDGE", c->name, c->hostname);
contradicting_add_edge++;
e = new_edge();
e->from = from;
e->to = to;
send_del_edge(c, e);
free_edge(e);
return true;
}
e = new_edge();
e->from = from;
e->to = to;
e->address = address;
e->options = options;
e->weight = weight;
edge_add(e);
done:
/* Tell the rest about the new edge */
if(!tunnelserver)
forward_request(c);
/* Run MST before or after we tell the rest? */
graph();
return true;
}
