void strvector_print(const igraph_strvector_t *sv) {
long int i, s=igraph_strvector_size(sv);
for (i=0; i<s; i++) {
printf("---%s---\n", STR(*sv, i));
}
}
int main() {
igraph_strvector_t sv1, sv2;
char *str1;
int i;
/* igraph_strvector_init, igraph_strvector_destroy */
igraph_strvector_init(&sv1, 10);
igraph_strvector_destroy(&sv1);
igraph_strvector_init(&sv1, 0);
igraph_strvector_destroy(&sv1);
/* igraph_strvector_get, igraph_strvector_set */
igraph_strvector_init(&sv1, 5);
for (i=0; i<igraph_strvector_size(&sv1); i++) {
igraph_strvector_get(&sv1, i, &str1);
printf("---%s---\n", str1);
}
igraph_strvector_set(&sv1, 0, "zero");
igraph_strvector_set(&sv1, 1, "one");
igraph_strvector_set(&sv1, 2, "two");
igraph_strvector_set(&sv1, 3, "three");
igraph_strvector_set(&sv1, 4, "four");
for (i=0; i<igraph_strvector_size(&sv1); i++) {
igraph_strvector_get(&sv1, i, &str1);
printf("---%s---\n", str1);
}
/* igraph_strvector_remove_section, igraph_strvector_remove,
igraph_strvector_resize, igraph_strvector_size */
igraph_strvector_remove_section(&sv1, 0, 5);
if (igraph_strvector_size(&sv1) != 0) {
return 1;
}
igraph_strvector_resize(&sv1, 10);
igraph_strvector_set(&sv1, 0, "zero");
igraph_strvector_set(&sv1, 1, "one");
igraph_strvector_set(&sv1, 2, "two");
igraph_strvector_set(&sv1, 3, "three");
igraph_strvector_set(&sv1, 4, "four");
igraph_strvector_resize(&sv1, 5);
for (i=0; i<igraph_strvector_size(&sv1); i++) {
igraph_strvector_get(&sv1, i, &str1);
printf("---%s---\n", str1);
}
igraph_strvector_resize(&sv1, 0);
if (igraph_strvector_size(&sv1) != 0) {
return 1;
}
igraph_strvector_resize(&sv1, 10);
igraph_strvector_set(&sv1, 0, "zero");
igraph_strvector_set(&sv1, 1, "one");
igraph_strvector_set(&sv1, 2, "two");
igraph_strvector_set(&sv1, 3, "three");
igraph_strvector_set(&sv1, 4, "four");
igraph_strvector_resize(&sv1, 5);
for (i=0; i<igraph_strvector_size(&sv1); i++) {
igraph_strvector_get(&sv1, i, &str1);
printf("---%s---\n", str1);
}
/* igraph_strvector_move_interval */
igraph_strvector_move_interval(&sv1, 3, 5, 0);
for (i=0; i<igraph_strvector_size(&sv1); i++) {
igraph_strvector_get(&sv1, i, &str1);
printf("---%s---\n", str1);
}
/* igraph_strvector_copy */
igraph_strvector_copy(&sv2, &sv1);
for (i=0; i<igraph_strvector_size(&sv2); i++) {
igraph_strvector_get(&sv2, i, &str1);
printf("---%s---\n", str1);
}
igraph_strvector_resize(&sv1, 0);
igraph_strvector_destroy(&sv2);
igraph_strvector_copy(&sv2, &sv1);
if (igraph_strvector_size(&sv2) != 0) {
return 2;
}
igraph_strvector_destroy(&sv2);
/* igraph_strvector_add */
igraph_strvector_add(&sv1, "zeroth");
igraph_strvector_add(&sv1, "first");
igraph_strvector_add(&sv1, "second");
igraph_strvector_add(&sv1, "third");
igraph_strvector_add(&sv1, "fourth");
for (i=0; i<igraph_strvector_size(&sv1); i++) {
igraph_strvector_get(&sv1, i, &str1);
printf("---%s---\n", str1);
}
/* TODO: igraph_strvector_permdelete */
/* TODO: igraph_strvector_remove_negidx */
igraph_strvector_destroy(&sv1);
/* append */
printf("---\n");
igraph_strvector_init(&sv1, 0);
igraph_strvector_init(&sv2, 0);
igraph_strvector_append(&sv1, &sv2);
strvector_print(&sv1);
printf("---\n");
igraph_strvector_resize(&sv1, 3);
igraph_strvector_append(&sv1, &sv2);
strvector_print(&sv1);
printf("---\n");
igraph_strvector_append(&sv2, &sv1);
strvector_print(&sv2);
printf("---\n");
igraph_strvector_set(&sv1, 0, "0");
igraph_strvector_set(&sv1, 1, "1");
igraph_strvector_set(&sv1, 2, "2");
igraph_strvector_set(&sv2, 0, "3");
igraph_strvector_set(&sv2, 1, "4");
igraph_strvector_set(&sv2, 2, "5");
igraph_strvector_append(&sv1, &sv2);
strvector_print(&sv1);
igraph_strvector_destroy(&sv1);
igraph_strvector_destroy(&sv2);
/* clear */
igraph_strvector_init(&sv1, 3);
igraph_strvector_set(&sv1, 0, "0");
igraph_strvector_set(&sv1, 1, "1");
igraph_strvector_set(&sv1, 2, "2");
igraph_strvector_clear(&sv1);
if (igraph_strvector_size(&sv1) != 0) {
return 3;
}
igraph_strvector_resize(&sv1, 4);
strvector_print(&sv1);
igraph_strvector_set(&sv1, 0, "one");
igraph_strvector_set(&sv1, 2, "two");
strvector_print(&sv1);
igraph_strvector_destroy(&sv1);
/* STR */
igraph_strvector_init(&sv1, 5);
igraph_strvector_set(&sv1, 0, "one");
igraph_strvector_set(&sv1, 1, "two");
igraph_strvector_set(&sv1, 2, "three");
igraph_strvector_set(&sv1, 3, "four");
igraph_strvector_set(&sv1, 4, "five");
strvector_print(&sv1);
igraph_strvector_destroy(&sv1);
if (!IGRAPH_FINALLY_STACK_EMPTY) return 4;
return 0;
}
int ggen_write_graph(igraph_t *g, FILE *output)
{
Agraph_t *cg;
Agnode_t *f,*t;
Agedge_t *edge;
igraph_vector_ptr_t vertices;
igraph_eit_t eit;
int err;
unsigned long i,j;
unsigned long vcount = igraph_vcount(g);
igraph_integer_t from,to;
char name[GGEN_DEFAULT_NAME_SIZE];
char *str = NULL;
igraph_strvector_t gnames,vnames,enames;
igraph_vector_t gtypes,vtypes,etypes;
Agsym_t *attr;
/* see warning below */
igraph_error_handler_t *error_handler;
err = igraph_vector_ptr_init(&vertices,vcount);
if(err) return 1;
/* WARNING: this should be changed if igraph-0.6 gets
* stable.
* We need to ignore some igraph_cattribute errors
* because we try to retrieve special attributes (ggen specifics).
* igraph version 0.6 include a cattribute_has_attr that should be
* used instead of ignoring errors.
*/
error_handler = igraph_set_error_handler(igraph_error_handler_ignore);
/* open graph
* its name is saved in __ggen_graph_name if it exists
*/
str =(char *) GAS(g,GGEN_GRAPH_NAME_ATTR);
if(!str)
cg = agopen(GGEN_DEFAULT_GRAPH_NAME,Agdirected,NULL);
else
cg = agopen(str,Agdirected,NULL);
if(!cg)
{
err = 1;
goto d_v;
}
/* save a pointer to each vertex */
for(i = 0; i < vcount; i++)
{
/* find a vertex name */
str = vid2vname_unsafe(name,g,i);
if(!str)
f = agnode(cg,name,1);
else
f = agnode(cg,str,1);
VECTOR(vertices)[i] = (void *)f;
}
/* We have finished with dangerous attributes accesses */
igraph_set_error_handler(error_handler);
/* now loop through edges in the igraph */
err = igraph_eit_create(g,igraph_ess_all(IGRAPH_EDGEORDER_ID),&eit);
if(err) goto c_ag;
for(IGRAPH_EIT_RESET(eit); !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit))
{
err = igraph_edge(g,IGRAPH_EIT_GET(eit),&from,&to);
if(err) goto d_eit;
f = (Agnode_t *) VECTOR(vertices)[(unsigned long)from];
t = (Agnode_t *) VECTOR(vertices)[(unsigned long)to];
agedge(cg,f,t,NULL,1);
}
/* find all properties */
igraph_strvector_init(&gnames,1);
igraph_strvector_init(&vnames,vcount);
igraph_strvector_init(&enames,igraph_ecount(g));
igraph_vector_init(>ypes,1);
igraph_vector_init(&vtypes,vcount);
igraph_vector_init(&etypes,igraph_ecount(g));
err = igraph_cattribute_list(g,&gnames,>ypes,&vnames,&vtypes,&enames,&etypes);
if(err) goto d_eit;
/* add graph properties */
for(i = 0; i < igraph_strvector_size(&gnames); i++)
{
if(strcmp(GGEN_GRAPH_NAME_ATTR,STR(gnames,i)))
{
if(VECTOR(gtypes)[i]==IGRAPH_ATTRIBUTE_NUMERIC) {
snprintf(name,GGEN_DEFAULT_NAME_SIZE,"%f",
(double)GAN(g,STR(gnames,i)));
agattr(cg,AGRAPH,(char *)STR(gnames,i),name);
}
else
agattr(cg,AGRAPH,(char *)STR(gnames,i),
(char *)GAS(g,STR(gnames,i)));
}
}
/* add vertex properties */
for(i = 0; i < igraph_strvector_size(&vnames); i++)
{
if(strcmp(GGEN_VERTEX_NAME_ATTR,STR(vnames,i)))
{
/* creates the attribute but we still need to set it for each vertex */
attr = agattr(cg,AGNODE,(char *)STR(vnames,i),GGEN_CGRAPH_DEFAULT_VALUE);
for(j = 0; j < vcount; j++)
{
f = (Agnode_t *) VECTOR(vertices)[j];
if(VECTOR(vtypes)[i]==IGRAPH_ATTRIBUTE_NUMERIC) {
snprintf(name,GGEN_DEFAULT_NAME_SIZE,"%f",
(double)VAN(g,STR(vnames,i),j));
agxset(f,attr,name);
}
else
agxset(f,attr,(char *)VAS(g,STR(vnames,i),j));
}
}
}
/* add edges properties */
for(i = 0; i < igraph_strvector_size(&enames); i++)
{
/* creates the attribute but we still need to set it for each edge */
attr = agattr(cg,AGEDGE,(char *)STR(enames,i),GGEN_CGRAPH_DEFAULT_VALUE);
for(j = 0; j < igraph_ecount(g); j++)
{
igraph_edge(g,j,&from,&to);
f = (Agnode_t *) VECTOR(vertices)[(unsigned long)from];
t = (Agnode_t *) VECTOR(vertices)[(unsigned long)to];
edge = agedge(cg,f,t,NULL,0);
if(VECTOR(etypes)[i]==IGRAPH_ATTRIBUTE_NUMERIC) {
snprintf(name,GGEN_DEFAULT_NAME_SIZE,"%f",
(double)EAN(g,STR(enames,i),j));
agxset(edge,attr,name);
}
else
agxset(edge,attr,(char *)EAS(g,STR(enames,i),j));
}
}
/* write the graph */
err = agwrite(cg,(void *)output);
d_eit:
igraph_eit_destroy(&eit);
c_ag:
agclose(cg);
d_v:
igraph_vector_ptr_destroy(&vertices);
return err;
}
static GError* _tgengraph_parseGraphProperties(TGenGraph* g) {
TGEN_ASSERT(g);
gint result = 0;
tgen_debug("checking graph properties...");
/* IGRAPH_WEAK means the undirected version of the graph is connected
* IGRAPH_STRONG means a vertex can reach all others via a directed path */
result = igraph_is_connected(g->graph, &(g->isConnected), IGRAPH_WEAK);
if(result != IGRAPH_SUCCESS) {
return g_error_new(G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"igraph_is_connected return non-success code %i", result);
}
igraph_integer_t clusterCount;
result = igraph_clusters(g->graph, NULL, NULL, &(g->clusterCount), IGRAPH_WEAK);
if(result != IGRAPH_SUCCESS) {
return g_error_new(G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"igraph_clusters return non-success code %i", result);
}
/* it must be connected */
if(!g->isConnected || g->clusterCount > 1) {
return g_error_new(G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
"graph must be but is not connected");
}
g->isDirected = igraph_is_directed(g->graph);
tgen_debug("checking graph attributes...");
/* now check list of all attributes */
igraph_strvector_t gnames, vnames, enames;
igraph_vector_t gtypes, vtypes, etypes;
igraph_strvector_init(&gnames, 25);
igraph_vector_init(>ypes, 25);
igraph_strvector_init(&vnames, 25);
igraph_vector_init(&vtypes, 25);
igraph_strvector_init(&enames, 25);
igraph_vector_init(&etypes, 25);
result = igraph_cattribute_list(g->graph, &gnames, >ypes, &vnames, &vtypes, &enames, &etypes);
if(result != IGRAPH_SUCCESS) {
return g_error_new(G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"igraph_cattribute_list return non-success code %i", result);
}
gint i = 0;
for(i = 0; i < igraph_strvector_size(&gnames); i++) {
gchar* name = NULL;
igraph_strvector_get(&gnames, (glong) i, &name);
tgen_debug("found graph attribute '%s'", name);
}
for(i = 0; i < igraph_strvector_size(&vnames); i++) {
gchar* name = NULL;
igraph_strvector_get(&vnames, (glong) i, &name);
tgen_debug("found vertex attribute '%s'", name);
g->knownAttributes |= _tgengraph_vertexAttributeToFlag(name);
}
for(i = 0; i < igraph_strvector_size(&enames); i++) {
gchar* name = NULL;
igraph_strvector_get(&enames, (glong) i, &name);
tgen_debug("found edge attribute '%s'", name);
g->knownAttributes |= _tgengraph_edgeAttributeToFlag(name);
}
igraph_strvector_destroy(&gnames);
igraph_vector_destroy(>ypes);
igraph_strvector_destroy(&vnames);
igraph_vector_destroy(&vtypes);
igraph_strvector_destroy(&enames);
igraph_vector_destroy(&etypes);
tgen_info("successfully verified graph properties and attributes");
return NULL;
}
int print_attributes(const igraph_t *g) {
igraph_vector_t gtypes, vtypes, etypes;
igraph_strvector_t gnames, vnames, enames;
long int i;
igraph_vector_t vec;
igraph_strvector_t svec;
long int j;
igraph_vector_init(>ypes, 0);
igraph_vector_init(&vtypes, 0);
igraph_vector_init(&etypes, 0);
igraph_strvector_init(&gnames, 0);
igraph_strvector_init(&vnames, 0);
igraph_strvector_init(&enames, 0);
igraph_cattribute_list(g, &gnames, >ypes, &vnames, &vtypes,
&enames, &etypes);
/* Graph attributes */
for (i=0; i<igraph_strvector_size(&gnames); i++) {
printf("%s=", STR(gnames, i));
if (VECTOR(gtypes)[i]==IGRAPH_ATTRIBUTE_NUMERIC) {
igraph_real_printf(GAN(g, STR(gnames,i)));
putchar(' ');
} else {
printf("\"%s\" ", GAS(g, STR(gnames,i)));
}
}
printf("\n");
for (i=0; i<igraph_vcount(g); i++) {
long int j;
printf("Vertex %li: ", i);
for (j=0; j<igraph_strvector_size(&vnames); j++) {
printf("%s=", STR(vnames, j));
if (VECTOR(vtypes)[j]==IGRAPH_ATTRIBUTE_NUMERIC) {
igraph_real_printf(VAN(g, STR(vnames,j), i));
putchar(' ');
} else {
printf("\"%s\" ", VAS(g, STR(vnames,j), i));
}
}
printf("\n");
}
for (i=0; i<igraph_ecount(g); i++) {
long int j;
printf("Edge %li (%i-%i): ", i, (int)IGRAPH_FROM(g,i), (int)IGRAPH_TO(g,i));
for (j=0; j<igraph_strvector_size(&enames); j++) {
printf("%s=", STR(enames, j));
if (VECTOR(etypes)[j]==IGRAPH_ATTRIBUTE_NUMERIC) {
igraph_real_printf(EAN(g, STR(enames, j), i));
putchar(' ');
} else {
printf("\"%s\" ", EAS(g, STR(enames, j), i));
}
}
printf("\n");
}
/* Check vector-based query functions */
igraph_vector_init(&vec, 0);
igraph_strvector_init(&svec, 0);
for (j=0; j<igraph_strvector_size(&vnames); j++) {
if (VECTOR(vtypes)[j]==IGRAPH_ATTRIBUTE_NUMERIC) {
igraph_cattribute_VANV(g, STR(vnames, j), igraph_vss_all(), &vec);
for (i=0; i<igraph_vcount(g); i++) {
igraph_real_t num=VAN(g, STR(vnames, j), i);
if (num != VECTOR(vec)[i] &&
(!isnan(num) || !isnan(VECTOR(vec)[i]))) {
exit(51);
}
}
} else {
igraph_cattribute_VASV(g, STR(vnames, j), igraph_vss_all(), &svec);
for (i=0; i<igraph_vcount(g); i++) {
const char *str=VAS(g, STR(vnames, j), i);
if (strcmp(str,STR(svec, i))) {
exit(52);
}
}
}
}
for (j=0; j<igraph_strvector_size(&enames); j++) {
if (VECTOR(etypes)[j]==IGRAPH_ATTRIBUTE_NUMERIC) {
igraph_cattribute_EANV(g, STR(enames, j),
igraph_ess_all(IGRAPH_EDGEORDER_ID), &vec);
for (i=0; i<igraph_ecount(g); i++) {
igraph_real_t num=EAN(g, STR(enames, j), i);
if (num != VECTOR(vec)[i] &&
(!isnan(num) || !isnan(VECTOR(vec)[i]))) {
exit(53);
}
}
} else {
igraph_cattribute_EASV(g, STR(enames, j),
igraph_ess_all(IGRAPH_EDGEORDER_ID), &svec);
for (i=0; i<igraph_ecount(g); i++) {
const char *str=EAS(g, STR(enames, j), i);
if (strcmp(str,STR(svec, i))) {
exit(54);
}
}
}
}
igraph_strvector_destroy(&svec);
igraph_vector_destroy(&vec);
igraph_strvector_destroy(&enames);
igraph_strvector_destroy(&vnames);
igraph_strvector_destroy(&gnames);
igraph_vector_destroy(&etypes);
igraph_vector_destroy(&vtypes);
igraph_vector_destroy(>ypes);
return 0;
}
int main() {
igraph_t g, g2;
FILE *ifile;
igraph_vector_t gtypes, vtypes, etypes;
igraph_strvector_t gnames, vnames, enames;
long int i;
igraph_vector_t y;
igraph_strvector_t id;
char str[20];
/* turn on attribute handling */
igraph_i_set_attribute_table(&igraph_cattribute_table);
ifile=fopen("LINKS.NET", "r");
if (ifile==0) {
return 10;
}
igraph_read_graph_pajek(&g, ifile);
fclose(ifile);
igraph_vector_init(>ypes, 0);
igraph_vector_init(&vtypes, 0);
igraph_vector_init(&etypes, 0);
igraph_strvector_init(&gnames, 0);
igraph_strvector_init(&vnames, 0);
igraph_strvector_init(&enames, 0);
igraph_cattribute_list(&g, &gnames, >ypes, &vnames, &vtypes,
&enames, &etypes);
/* List attribute names and types */
printf("Graph attributes: ");
for (i=0; i<igraph_strvector_size(&gnames); i++) {
printf("%s (%i) ", STR(gnames, i), (int)VECTOR(gtypes)[i]);
}
printf("\n");
printf("Vertex attributes: ");
for (i=0; i<igraph_strvector_size(&vnames); i++) {
printf("%s (%i) ", STR(vnames, i), (int)VECTOR(vtypes)[i]);
}
printf("\n");
printf("Edge attributes: ");
for (i=0; i<igraph_strvector_size(&enames); i++) {
printf("%s (%i) ", STR(enames, i), (int)VECTOR(etypes)[i]);
}
printf("\n");
print_attributes(&g);
/* Copying a graph */
igraph_copy(&g2, &g);
print_attributes(&g2);
igraph_destroy(&g2);
/* Adding vertices */
igraph_add_vertices(&g, 3, 0);
print_attributes(&g);
/* Adding edges */
igraph_add_edge(&g, 1, 1);
igraph_add_edge(&g, 2, 5);
igraph_add_edge(&g, 3, 6);
print_attributes(&g);
/* Deleting vertices */
igraph_delete_vertices(&g, igraph_vss_1(1));
igraph_delete_vertices(&g, igraph_vss_1(4));
print_attributes(&g);
/* Deleting edges */
igraph_delete_edges(&g, igraph_ess_1(igraph_ecount(&g)-1));
igraph_delete_edges(&g, igraph_ess_1(0));
print_attributes(&g);
/* Set graph attributes */
SETGAN(&g, "id", 10);
if (GAN(&g, "id") != 10) {
return 11;
}
SETGAS(&g, "name", "toy");
if (strcmp(GAS(&g, "name"), "toy")) {
return 12;
}
/* Delete graph attributes */
DELGA(&g, "id");
DELGA(&g, "name");
igraph_cattribute_list(&g, &gnames, 0,0,0,0,0);
if (igraph_strvector_size(&gnames) != 0) {
return 14;
}
/* Delete vertex attributes */
DELVA(&g, "x");
DELVA(&g, "shape");
DELVA(&g, "xfact");
DELVA(&g, "yfact");
igraph_cattribute_list(&g, 0,0, &vnames, 0,0,0);
if (igraph_strvector_size(&vnames) != 2) {
return 15;
}
/* Delete edge attributes */
igraph_cattribute_list(&g, 0,0,0,0,&enames,0);
i=igraph_strvector_size(&enames);
DELEA(&g, "hook1");
DELEA(&g, "hook2");
DELEA(&g, "label");
igraph_cattribute_list(&g, 0,0,0,0,&enames,0);
if (igraph_strvector_size(&enames) != i-3) {
return 16;
}
/* Set vertex attributes */
SETVAN(&g, "y", 0, -1);
SETVAN(&g, "y", 1, 2.1);
if (VAN(&g, "y", 0) != -1 ||
VAN(&g, "y", 1) != 2.1) {
return 17;
}
SETVAS(&g, "id", 0, "foo");
SETVAS(&g, "id", 1, "bar");
if (strcmp(VAS(&g, "id", 0), "foo") ||
strcmp(VAS(&g, "id", 1), "bar")) {
return 18;
}
/* Set edge attributes */
SETEAN(&g, "weight", 2, 100.0);
SETEAN(&g, "weight", 0, -100.1);
if (EAN(&g, "weight", 2) != 100.0 ||
EAN(&g, "weight", 0) != -100.1) {
return 19;
}
SETEAS(&g, "color", 2, "RED");
SETEAS(&g, "color", 0, "Blue");
if (strcmp(EAS(&g, "color", 2), "RED") ||
strcmp(EAS(&g, "color", 0), "Blue")) {
return 20;
}
/* Set vector attributes as vector */
igraph_vector_init(&y, igraph_vcount(&g));
igraph_vector_fill(&y, 1.23);
SETVANV(&g, "y", &y);
igraph_vector_destroy(&y);
for (i=0; i<igraph_vcount(&g); i++) {
if (VAN(&g, "y", i) != 1.23) {
return 21;
}
}
igraph_vector_init_seq(&y, 0, igraph_vcount(&g)-1);
SETVANV(&g, "foobar", &y);
igraph_vector_destroy(&y);
for (i=0; i<igraph_vcount(&g); i++) {
if (VAN(&g, "foobar", i) != i) {
return 22;
}
}
igraph_strvector_init(&id, igraph_vcount(&g));
for (i=0; i<igraph_vcount(&g); i++) {
snprintf(str, sizeof(str)-1, "%li", i);
igraph_strvector_set(&id, i, str);
}
SETVASV(&g, "foo", &id);
igraph_strvector_destroy(&id);
for (i=0; i<igraph_vcount(&g); i++) {
printf("%s ", VAS(&g, "foo", i));
}
printf("\n");
igraph_strvector_init(&id, igraph_vcount(&g));
for (i=0; i<igraph_vcount(&g); i++) {
snprintf(str, sizeof(str)-1, "%li", i);
igraph_strvector_set(&id, i, str);
}
SETVASV(&g, "id", &id);
igraph_strvector_destroy(&id);
for (i=0; i<igraph_vcount(&g); i++) {
printf("%s ", VAS(&g, "id", i));
}
printf("\n");
/* Set edge attributes as vector */
igraph_vector_init(&y, igraph_ecount(&g));
igraph_vector_fill(&y, 12.3);
SETEANV(&g, "weight", &y);
igraph_vector_destroy(&y);
for (i=0; i<igraph_ecount(&g); i++) {
if (EAN(&g, "weight", i) != 12.3) {
return 23;
}
}
igraph_vector_init_seq(&y, 0, igraph_ecount(&g)-1);
SETEANV(&g, "foobar", &y);
igraph_vector_destroy(&y);
for (i=0; i<igraph_ecount(&g); i++) {
if (VAN(&g, "foobar", i) != i) {
return 24;
}
}
igraph_strvector_init(&id, igraph_ecount(&g));
for (i=0; i<igraph_ecount(&g); i++) {
snprintf(str, sizeof(str)-1, "%li", i);
igraph_strvector_set(&id, i, str);
}
SETEASV(&g, "foo", &id);
igraph_strvector_destroy(&id);
for (i=0; i<igraph_ecount(&g); i++) {
printf("%s ", EAS(&g, "foo", i));
}
printf("\n");
igraph_strvector_init(&id, igraph_ecount(&g));
for (i=0; i<igraph_ecount(&g); i++) {
snprintf(str, sizeof(str)-1, "%li", i);
igraph_strvector_set(&id, i, str);
}
SETEASV(&g, "color", &id);
igraph_strvector_destroy(&id);
for (i=0; i<igraph_ecount(&g); i++) {
printf("%s ", EAS(&g, "color", i));
}
printf("\n");
/* Delete all remaining attributes */
DELALL(&g);
igraph_cattribute_list(&g, &gnames, >ypes, &vnames, &vtypes, &enames, &etypes);
if (igraph_strvector_size(&gnames) != 0 ||
igraph_strvector_size(&vnames) != 0 ||
igraph_strvector_size(&enames) != 0) {
return 25;
}
/* Destroy */
igraph_vector_destroy(>ypes);
igraph_vector_destroy(&vtypes);
igraph_vector_destroy(&etypes);
igraph_strvector_destroy(&gnames);
igraph_strvector_destroy(&vnames);
igraph_strvector_destroy(&enames);
igraph_destroy(&g);
return 0;
}
void igraph_i_graphml_sax_handler_end_document(void *state0) {
struct igraph_i_graphml_parser_state *state=
(struct igraph_i_graphml_parser_state*)state0;
long i, l;
int r;
igraph_i_attribute_record_t idrec, eidrec;
const char *idstr="id";
igraph_bool_t already_has_vertex_id=0, already_has_edge_id=0;
if (!state->successful) return;
if (state->index<0) {
igraph_vector_ptr_t vattr, eattr, gattr;
long int esize=igraph_vector_ptr_size(&state->e_attrs);
const void **tmp;
r=igraph_vector_ptr_init(&vattr,
igraph_vector_ptr_size(&state->v_attrs)+1);
if (r) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, r);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &vattr);
if (igraph_strvector_size(&state->edgeids) != 0) {
esize++;
}
r=igraph_vector_ptr_init(&eattr, esize);
if (r) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, r);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &eattr);
r=igraph_vector_ptr_init(&gattr, igraph_vector_ptr_size(&state->g_attrs));
if (r) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, r);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &gattr);
for (i=0; i<igraph_vector_ptr_size(&state->v_attrs); i++) {
igraph_i_graphml_attribute_record_t *graphmlrec=
VECTOR(state->v_attrs)[i];
igraph_i_attribute_record_t *rec=&graphmlrec->record;
/* Check that the name of the vertex attribute is not 'id'.
If it is then we cannot the complimentary 'id' attribute. */
if (! strcmp(rec->name, idstr)) {
already_has_vertex_id=1;
}
if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
igraph_vector_t *vec=(igraph_vector_t*)rec->value;
long int origsize=igraph_vector_size(vec);
long int nodes=igraph_trie_size(&state->node_trie);
igraph_vector_resize(vec, nodes);
for (l=origsize; l<nodes; l++) {
VECTOR(*vec)[l]=IGRAPH_NAN;
}
} else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
igraph_strvector_t *strvec=(igraph_strvector_t*)rec->value;
long int origsize=igraph_strvector_size(strvec);
long int nodes=igraph_trie_size(&state->node_trie);
igraph_strvector_resize(strvec, nodes);
for (l=origsize; l<nodes; l++) {
igraph_strvector_set(strvec, l, "");
}
}
VECTOR(vattr)[i]=rec;
}
if (!already_has_vertex_id) {
idrec.name=idstr;
idrec.type=IGRAPH_ATTRIBUTE_STRING;
tmp=&idrec.value;
igraph_trie_getkeys(&state->node_trie, (const igraph_strvector_t **)tmp);
VECTOR(vattr)[i]=&idrec;
} else {
igraph_vector_ptr_pop_back(&vattr);
IGRAPH_WARNING("Could not add vertex ids, "
"there is already an 'id' vertex attribute");
}
for (i=0; i<igraph_vector_ptr_size(&state->e_attrs); i++) {
igraph_i_graphml_attribute_record_t *graphmlrec=
VECTOR(state->e_attrs)[i];
igraph_i_attribute_record_t *rec=&graphmlrec->record;
if (! strcmp(rec->name, idstr)) {
already_has_edge_id=1;
}
if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
igraph_vector_t *vec=(igraph_vector_t*)rec->value;
long int origsize=igraph_vector_size(vec);
long int edges=igraph_vector_size(&state->edgelist)/2;
igraph_vector_resize(vec, edges);
for (l=origsize; l<edges; l++) {
VECTOR(*vec)[l]=IGRAPH_NAN;
}
} else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
igraph_strvector_t *strvec=(igraph_strvector_t*)rec->value;
long int origsize=igraph_strvector_size(strvec);
long int edges=igraph_vector_size(&state->edgelist)/2;
igraph_strvector_resize(strvec, edges);
for (l=origsize; l<edges; l++) {
igraph_strvector_set(strvec, l, "");
}
}
VECTOR(eattr)[i]=rec;
}
if (igraph_strvector_size(&state->edgeids) != 0) {
if (!already_has_edge_id) {
long int origsize=igraph_strvector_size(&state->edgeids);
eidrec.name=idstr;
eidrec.type=IGRAPH_ATTRIBUTE_STRING;
igraph_strvector_resize(&state->edgeids,
igraph_vector_size(&state->edgelist)/2);
for (; origsize < igraph_strvector_size(&state->edgeids); origsize++) {
igraph_strvector_set(&state->edgeids, origsize, "");
}
eidrec.value=&state->edgeids;
VECTOR(eattr)[(long int)igraph_vector_ptr_size(&eattr)-1]=&eidrec;
} else {
igraph_vector_ptr_pop_back(&eattr);
IGRAPH_WARNING("Could not add edge ids, "
"there is already an 'id' edge attribute");
}
}
for (i=0; i<igraph_vector_ptr_size(&state->g_attrs); i++) {
igraph_i_graphml_attribute_record_t *graphmlrec=
VECTOR(state->g_attrs)[i];
igraph_i_attribute_record_t *rec=&graphmlrec->record;
if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
igraph_vector_t *vec=(igraph_vector_t*)rec->value;
long int origsize=igraph_vector_size(vec);
igraph_vector_resize(vec, 1);
for (l=origsize; l<1; l++) {
VECTOR(*vec)[l]=IGRAPH_NAN;
}
} else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
igraph_strvector_t *strvec=(igraph_strvector_t*)rec->value;
long int origsize=igraph_strvector_size(strvec);
igraph_strvector_resize(strvec, 1);
for (l=origsize; l<1; l++) {
igraph_strvector_set(strvec, l, "");
}
}
VECTOR(gattr)[i]=rec;
}
igraph_empty_attrs(state->g, 0, state->edges_directed, &gattr);
igraph_add_vertices(state->g, igraph_trie_size(&state->node_trie),
&vattr);
igraph_add_edges(state->g, &state->edgelist, &eattr);
igraph_vector_ptr_destroy(&vattr);
igraph_vector_ptr_destroy(&eattr);
igraph_vector_ptr_destroy(&gattr);
IGRAPH_FINALLY_CLEAN(3);
}
igraph_i_graphml_destroy_state(state);
}
