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)

GtsGNodeClass

typedef struct {
  GtsSListContainerClass parent_class;

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

GtsGNode

typedef struct {
  GtsSListContainer container;

  guint level;
} GtsGNode;

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)

GtsGEdgeClass

typedef struct {
  GtsContaineeClass parent_class;

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

GtsGEdge

typedef struct {
  GtsContainee containee;

  GtsGNode * n1;
  GtsGNode * n2;
} GtsGEdge;

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)

GtsGraphClass

typedef struct {
  GtsHashContainerClass parent_class;

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

GtsGraph

typedef struct {
  GtsHashContainer object;

  GtsGraphClass * graph_class;
  GtsGNodeClass * node_class;
  GtsGEdgeClass * edge_class;
} GtsGraph;

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 ()

GtsGraph*   gts_graph_read                  (GtsFile *fp);

Reads a graph from a file.

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.

GtsGraphTraverse

typedef struct _GtsGraphTraverse 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)

GtsFNode

typedef struct {
  GtsGNode node;

  GtsFace * f;
} GtsFNode;

GtsFNodeClass

typedef struct {
  GtsGNodeClass parent_class;
} GtsFNodeClass;

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);