Graph class

GTS_GNODE_CLASS()

#define     GTS_GNODE_CLASS(klass)

GTS_GNODE()

#define     GTS_GNODE(obj)

GTS_IS_GNODE()

#define     GTS_IS_GNODE(obj)

GTS_GNODE_NEIGHBOR()

#define GTS_GNODE_NEIGHBOR(n,e)   (GTS_GEDGE (e)->n1 == n ? GTS_GEDGE (e)->n2 : GTS_GEDGE (e)->n2 == n ? GTS_GEDGE (e)->n1 : NULL)

struct GtsGNodeClass

struct GtsGNodeClass {

  GtsSListContainerClass parent_class;

  gfloat (* weight) (GtsGNode *);
  void   (* write)  (GtsGNode *, FILE *);
};

struct GtsGNode

struct GtsGNode {

  GtsSListContainer container;

  guint level;
};

gts_gnode_class ()

GtsGNodeClass* gts_gnode_class              (void);

gts_gnode_new ()

GtsGNode*   gts_gnode_new                   (GtsGNodeClass *klass);

gts_gnode_degree ()

guint       gts_gnode_degree                (GtsGNode *n,
                                             GtsGraph *g);

gts_gnode_foreach_edge ()

void        gts_gnode_foreach_edge          (GtsGNode *n,
                                             GtsGraph *g,
                                             GtsFunc func,
                                             gpointer data);

Calls func for each GtsGEdge connecting n to another GtsGNode (belonging to g if g is not NULL.

gts_gnode_foreach_neighbor ()

void        gts_gnode_foreach_neighbor      (GtsGNode *n,
                                             GtsGraph *g,
                                             GtsFunc func,
                                             gpointer data);

Calls func for each neighbor GtsGNode of n (belonging to g if g is not NULL.

gts_gnode_weight ()

gfloat      gts_gnode_weight                (GtsGNode *n);

gts_gnode_move_cost ()

gfloat      gts_gnode_move_cost             (GtsGNode *n,
                                             GtsGraph *src,
                                             GtsGraph *dst);

GTS_GEDGE_CLASS()

#define     GTS_GEDGE_CLASS(klass)

GTS_GEDGE()

#define     GTS_GEDGE(obj)

GTS_IS_GEDGE()

#define     GTS_IS_GEDGE(obj)

struct GtsGEdgeClass

struct GtsGEdgeClass {

  GtsContaineeClass parent_class;

  GtsGEdge * (* link)   (GtsGEdge * e, GtsGNode * n1, GtsGNode * n2);
  gfloat     (* weight) (GtsGEdge * e);
  void       (* write)  (GtsGEdge * e, FILE * fp);
};

struct GtsGEdge

struct GtsGEdge {

  GtsContainee containee;

  GtsGNode * n1;
  GtsGNode * n2;
};

gts_gedge_class ()

GtsGEdgeClass* gts_gedge_class              (void);

gts_gedge_new ()

GtsGEdge*   gts_gedge_new                   (GtsGEdgeClass *klass,
                                             GtsGNode *n1,
                                             GtsGNode *n2);

gts_gedge_weight ()

gfloat      gts_gedge_weight                (GtsGEdge *e);

gts_gedge_connects()

#define     gts_gedge_connects(e, a1, a2)

GTS_GRAPH_CLASS()

#define     GTS_GRAPH_CLASS(klass)

GTS_GRAPH()

#define     GTS_GRAPH(obj)

GTS_IS_GRAPH()

#define     GTS_IS_GRAPH(obj)

struct GtsGraphClass

struct GtsGraphClass {

  GtsHashContainerClass parent_class;

  gfloat (* weight) (GtsGraph *);
};

struct GtsGraph

struct GtsGraph {

  GtsHashContainer object;

  GtsGNodeClass * node_class;
  GtsGEdgeClass * edge_class;
};

gts_graph_class ()

GtsGraphClass* gts_graph_class              (void);

gts_graph_new ()

GtsGraph*   gts_graph_new                   (GtsGraphClass *klass,
                                             GtsGNodeClass *node_class,
                                             GtsGEdgeClass *edge_class);

gts_graph_read ()

guint       gts_graph_read                  (GtsGraph *g,
                                             GtsFile *fp);

Adds to g the data read from fp. The format of the file pointed to by fp is as described in gts_graph_write().

gts_graph_read_jostle ()

guint       gts_graph_read_jostle           (GtsGraph *g,
                                             GtsFile *fp);

Adds to g the nodes and edges defined in the file pointed to by fp. This file must use the Jostle "graph" ASCII format. The nodes created are of type GtsNGNode and their identities are the line number at which they appear in fp.

gts_graph_write ()

void        gts_graph_write                 (GtsGraph *g,
                                             FILE *fp);

Writes in the file fp an ASCII representation of g. The file format is as follows.

All the lines beginning with GTS_COMMENTS are ignored. The first line contains two unsigned integers separated by spaces. The first integer is the number of nodes, nn, the second is the number of edges, ne.

Follows nn lines containing node description. Follows ne lines containing the two indices (starting from one) of the nodes of each edge.

The format described above is the least common denominator to all GTS files. Consistent with an object-oriented approach, the GTS file format is extensible. Each of the lines of the file can be extended with user-specific attributes accessible through the read() and write() virtual methods of each of the objects written (graph, nodes or edges). When read with different object classes, these extra attributes are just ignored.

gts_graph_write_dot ()

void        gts_graph_write_dot             (GtsGraph *g,
                                             FILE *fp);

Writes in the file fp an ASCII representation of g in the dot format of AT&T Bell Labs.

gts_graph_print_stats ()

void        gts_graph_print_stats           (GtsGraph *g,
                                             FILE *fp);

Writes to fp a summary of the properties of g.

gts_graph_foreach_edge ()

void        gts_graph_foreach_edge          (GtsGraph *g,
                                             GtsFunc func,
                                             gpointer data);

Calls func for each GtsEdge of g.

struct GtsGraphTraverse

struct GtsGraphTraverse;

enum GtsTraverseType

typedef enum   { GTS_BREADTH_FIRST
               }   GtsTraverseType;

gts_graph_traverse_new ()

GtsGraphTraverse* gts_graph_traverse_new    (GtsGraph *g,
                                             GtsGNode *n,
                                             GtsTraverseType type,
                                             gboolean reinit);

gts_graph_traverse_next ()

GtsGNode*   gts_graph_traverse_next         (GtsGraphTraverse *t);

gts_graph_traverse_what_next ()

GtsGNode*   gts_graph_traverse_what_next    (GtsGraphTraverse *t);

gts_graph_traverse_destroy ()

void        gts_graph_traverse_destroy      (GtsGraphTraverse *t);

Frees all the memory allocated for t.

gts_graph_edges_cut ()

guint       gts_graph_edges_cut             (GtsGraph *g);

gts_graph_edges_cut_weight ()

gfloat      gts_graph_edges_cut_weight      (GtsGraph *g);

gts_graph_distance_sum ()

guint       gts_graph_distance_sum          (GtsGraph *g,
                                             GtsGNode *center);

gts_graph_farthest ()

GtsGNode*   gts_graph_farthest              (GtsGraph *g,
                                             GSList *gnodes);

gts_graph_weight ()

gfloat      gts_graph_weight                (GtsGraph *g);

GTS_FNODE_CLASS()

#define     GTS_FNODE_CLASS(klass)

GTS_FNODE()

#define     GTS_FNODE(obj)

GTS_IS_FNODE()

#define     GTS_IS_FNODE(obj)

struct GtsFNode

struct GtsFNode {

  GtsGNode node;

  GtsFace * f;
};

struct GtsFNodeClass

struct GtsFNodeClass {

  GtsGNodeClass parent_class;
};

gts_fnode_class ()

GtsFNodeClass* gts_fnode_class              (void);

gts_fnode_new ()

GtsFNode*   gts_fnode_new                   (GtsFNodeClass *klass,
                                             GtsFace *f);

gts_surface_graph_new ()

GtsGraph*   gts_surface_graph_new           (GtsGraphClass *klass,
                                             GtsSurface *s);

gts_surface_graph_surface ()

GtsSurface* gts_surface_graph_surface       (GtsGraph *surface_graph,
                                             GtsSurface *s);

gts_segments_graph_new ()

GtsGraph*   gts_segments_graph_new          (GtsGraphClass *klass,
                                             GSList *segments);