trunk/src/results.h

/***************************************
 $Header: /home/amb/CVS/routino/src/results.h,v 1.8 2009-01-24 16:21:44 amb Exp $

 A header file for the results.
 ******************/ /******************
 Written by Andrew M. Bishop

 This file Copyright 2009 Andrew M. Bishop
 It may be distributed under the GNU Public License, version 2, or
 any higher version.  See section COPYING of the GNU Public license
 for conditions under which this file may be redistributed.
 ***************************************/


#ifndef RESULTS_H
#define RESULTS_H    /*+ To stop multiple inclusions. +*/

#include <stdint.h>

#include "nodes.h"
#include "segments.h"


/* Data structures */

/*+ One part of the result for a node. +*/
typedef struct _HalfResult
{
 node_t      prev;              /*+ The previous node following the shortest path. +*/
 node_t      next;              /*+ The next node following the shortest path. +*/
 distance_t  distance;          /*+ The distance travelled to the node following the shortest path. +*/
 duration_t  duration;          /*+ The time taken to the node following the shortest path. +*/
}
 HalfResult;

/*+ One complete result for a node. +*/
typedef struct _Result
{
 node_t     node;               /*+ The node for which this result applies. +*/
 HalfResult shortest;           /*+ The result for the shortest path. +*/
 HalfResult quickest;           /*+ The result for the quickest path. +*/
}
 Result;

/*+ A list of results. +*/
typedef struct _Results
{
 uint32_t nbins;                /*+ The number of bins. +*/
 uint32_t mask;                 /*+ A bit mask to select the bottom 'nbins' bits. +*/

 uint32_t alloced;              /*+ The amount of space allocated for results
                                    (the length of the number and pointers arrays and
                                     1/nbins times the amount in the real results). +*/
 uint32_t number;               /*+ The total number of occupied results. +*/

 uint32_t *count;               /*+ An array of nbins counters of results in each array. +*/
 Result ***point;               /*+ An array of nbins arrays of pointers to actual results. +*/

 Result  **data;                /*+ An array of arrays containing the actual results
                                    (don't need to realloc the array of data when adding more,
                                    only realloc the array that points to the array of data).
                                    Most importantly pointers into the real data don't change
                                    as more space is allocted (since realloc is not being used). +*/
}
 Results;


/* Functions */

Results *NewResultsList(int nbins);
void FreeResultsList(Results *results);

Result *InsertResult(Results *results,node_t node);

Result *FindResult(Results *results,node_t node);

Result *FirstResult(Results *results);
Result *NextResult(Results *results,Result *result);

/* Queue Functions */

void insert_in_queue(Result *result);
Result *pop_from_queue(void);


#endif /* RESULTS_H */
1	amb	29	/***************************************
2	amb	79	$Header: /home/amb/CVS/routino/src/results.h,v 1.8 2009-01-24 16:21:44 amb Exp $
3	amb	29
4			A header file for the results.
5			****************/ /****************
6			Written by Andrew M. Bishop
7
8			This file Copyright 2009 Andrew M. Bishop
9			It may be distributed under the GNU Public License, version 2, or
10			any higher version. See section COPYING of the GNU Public license
11			for conditions under which this file may be redistributed.
12			***************************************/
13
14
15			#ifndef RESULTS_H
16			#define RESULTS_H /+ To stop multiple inclusions. +/
17
18			#include <stdint.h>
19
20			#include "nodes.h"
21			#include "segments.h"
22
23
24			/* Data structures */
25
26			/+ One part of the result for a node. +/
27			typedef struct _HalfResult
28			{
29	amb	43	node_t prev; /+ The previous node following the shortest path. +/
30			node_t next; /+ The next node following the shortest path. +/
31	amb	29	distance_t distance; /+ The distance travelled to the node following the shortest path. +/
32			duration_t duration; /+ The time taken to the node following the shortest path. +/
33			}
34			HalfResult;
35
36			/+ One complete result for a node. +/
37			typedef struct _Result
38			{
39	amb	43	node_t node; /+ The node for which this result applies. +/
40	amb	29	HalfResult shortest; /+ The result for the shortest path. +/
41			HalfResult quickest; /+ The result for the quickest path. +/
42			}
43			Result;
44
45			/+ A list of results. +/
46			typedef struct _Results
47			{
48	amb	71	uint32_t nbins; /+ The number of bins. +/
49			uint32_t mask; /+ A bit mask to select the bottom 'nbins' bits. +/
50
51	amb	79	uint32_t alloced; /*+ The amount of space allocated for results
52			(the length of the number and pointers arrays and
53			1/nbins times the amount in the real results). +*/
54	amb	45	uint32_t number; /+ The total number of occupied results. +/
55	amb	71
56	amb	79	uint32_t count; /+ An array of nbins counters of results in each array. +*/
57			Result **point; /+ An array of nbins arrays of pointers to actual results. +*/
58	amb	71
59	amb	79	Result *data; /+ An array of arrays containing the actual results
60			(don't need to realloc the array of data when adding more,
61			only realloc the array that points to the array of data).
62			Most importantly pointers into the real data don't change
63			as more space is allocted (since realloc is not being used). +*/
64	amb	29	}
65			Results;
66
67
68			/* Functions */
69
70	amb	71	Results *NewResultsList(int nbins);
71	amb	29	void FreeResultsList(Results *results);
72
73			Result InsertResult(Results results,node_t node);
74
75			Result FindResult(Results results,node_t node);
76
77	amb	79	Result FirstResult(Results results);
78			Result NextResult(Results results,Result *result);
79	amb	29
80	amb	67	/* Queue Functions */
81
82	amb	79	void insert_in_queue(Result *result);
83			Result *pop_from_queue(void);
84	amb	67
85
86	amb	29	#endif /* RESULTS_H */