libpostal-sys 0.1.1

Low-level wrappers for libpostal address normalization (with locks to support thread-safe initialization)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

#include "graph_builder.h"


#define ks_lt_graph_edge(a, b) ((a).v1 < (b).v1)
KSORT_INIT(graph_edge_array, graph_edge_t, ks_lt_graph_edge)

#define ks_lt_graph_edge_sort_vertices(a, b) (((a).v1 < (b).v1) || ((a).v1 == (b).v1 && (a).v2 < (b).v2))
KSORT_INIT(graph_edge_array_sort_vertices, graph_edge_t, ks_lt_graph_edge_sort_vertices)


void graph_builder_destroy(graph_builder_t *self) {
    if (self == NULL) return;

    if (self->edges != NULL) {
        graph_edge_array_destroy(self->edges);
    }

    free(self);
}

graph_builder_t *graph_builder_new(graph_type_t type, bool fixed_rows) {
    graph_builder_t *builder = malloc(sizeof(graph_builder_t));

    builder->type = type;
    builder->m = 0;
    builder->n = 0;
    builder->fixed_rows = fixed_rows;

    builder->edges = graph_edge_array_new();
    if (builder->edges == NULL) {
        graph_builder_destroy(builder);
        return NULL;
    }

    return builder;
}


static graph_t *graph_builder_build_edges(graph_builder_t *self, bool remove_duplicates) {
    graph_t *graph = graph_new(self->type);
    if (graph == NULL) return NULL;

    uint32_t last_vertex = 0;
    uint32_t last_edge = 0;

    for (int i = 0; i < self->edges->n; i++) {
        graph_edge_t edge = self->edges->a[i];
        if (edge.v1 > last_vertex) {
            for (uint32_t row = last_vertex; row < edge.v1; row++) {
                // Sorting is done prior to this
                graph_finalize_vertex_no_sort(graph);
            }
        }

        if (!remove_duplicates || i == 0 || edge.v1 != last_vertex || edge.v2 != last_edge) {
            graph_append_edge(graph, edge.v2);
        }
        last_vertex = edge.v1;
        last_edge = edge.v2;
    }

    graph_finalize_vertex_no_sort(graph);

    return graph;
}

graph_t *graph_builder_finalize(graph_builder_t *self, bool sort_edges, bool remove_duplicates) {
    graph_t *graph;
    if (remove_duplicates && !sort_edges) {
        sort_edges = true;
    }

    if (!sort_edges) {
        ks_introsort(graph_edge_array, self->edges->n, self->edges->a);
        graph = graph_builder_build_edges(self, remove_duplicates);
    } else {
        ks_introsort(graph_edge_array_sort_vertices, self->edges->n, self->edges->a);
        graph = graph_builder_build_edges(self, remove_duplicates);
    }

    graph->fixed_rows = self->fixed_rows;
    graph_set_size(graph);

    graph_builder_destroy(self);
    return graph;
}

void graph_builder_add_edge(graph_builder_t *self, uint32_t v1, uint32_t v2) {
    if (v1 == v2) return;
    graph_edge_t edge;

    if (self->type != GRAPH_UNDIRECTED || v2 > v1) {
        edge = (graph_edge_t) {v1, v2};
    } else {
        edge = (graph_edge_t) {v2, v1};
    }

    graph_edge_array_push(self->edges, edge);

    if (v1 >= self->m) {
        self->m = v1 + 1;
    }

    if (v2 >= self->n) {
        self->n = v2 + 1;
    }
}