ovsdb-tool: Put version number in comment when compacting or converting.
[openvswitch] / ovsdb / column.c
1 /* Copyright (c) 2009, 2010, 2011 Nicira Networks
2  *
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15
16 #include <config.h>
17
18 #include "ovsdb/column.h"
19
20 #include <stdlib.h>
21
22 #include "column.h"
23 #include "dynamic-string.h"
24 #include "json.h"
25 #include "ovsdb-error.h"
26 #include "ovsdb-parser.h"
27 #include "table.h"
28 #include "util.h"
29
30 struct ovsdb_column *
31 ovsdb_column_create(const char *name,
32                     bool mutable, bool persistent,
33                     const struct ovsdb_type *type)
34 {
35     /* Doesn't set the new column's 'index': the caller must do that. */
36     struct ovsdb_column *column;
37
38     column = xzalloc(sizeof *column);
39     column->name = xstrdup(name);
40     column->mutable = mutable;
41     column->persistent = persistent;
42     ovsdb_type_clone(&column->type, type);
43
44     return column;
45 }
46
47 struct ovsdb_column *
48 ovsdb_column_clone(const struct ovsdb_column *old)
49 {
50     /* Doesn't copy the column's 'index': the caller must do that. */
51     return ovsdb_column_create(old->name,
52                                old->mutable, old->persistent,
53                                &old->type);
54 }
55
56 void
57 ovsdb_column_destroy(struct ovsdb_column *column)
58 {
59     ovsdb_type_destroy(&column->type);
60     free(column->name);
61     free(column);
62 }
63
64 struct ovsdb_error *
65 ovsdb_column_from_json(const struct json *json, const char *name,
66                        struct ovsdb_column **columnp)
67 {
68     const struct json *mutable, *ephemeral, *type_json;
69     struct ovsdb_error *error;
70     struct ovsdb_type type;
71     struct ovsdb_parser parser;
72     bool persistent;
73
74     *columnp = NULL;
75
76     ovsdb_parser_init(&parser, json, "schema for column %s", name);
77     mutable = ovsdb_parser_member(&parser, "mutable",
78                                 OP_TRUE | OP_FALSE | OP_OPTIONAL);
79     ephemeral = ovsdb_parser_member(&parser, "ephemeral",
80                                     OP_TRUE | OP_FALSE | OP_OPTIONAL);
81     type_json = ovsdb_parser_member(&parser, "type", OP_STRING | OP_OBJECT);
82     error = ovsdb_parser_finish(&parser);
83     if (error) {
84         return error;
85     }
86
87     error = ovsdb_type_from_json(&type, type_json);
88     if (error) {
89         return error;
90     }
91
92     persistent = ephemeral ? !json_boolean(ephemeral) : true;
93     *columnp = ovsdb_column_create(name,
94                                    mutable ? json_boolean(mutable) : true,
95                                    persistent, &type);
96
97     ovsdb_type_destroy(&type);
98
99     return NULL;
100 }
101
102 struct json *
103 ovsdb_column_to_json(const struct ovsdb_column *column)
104 {
105     struct json *json = json_object_create();
106     if (!column->mutable) {
107         json_object_put(json, "mutable", json_boolean_create(false));
108     }
109     if (!column->persistent) {
110         json_object_put(json, "ephemeral", json_boolean_create(true));
111     }
112     json_object_put(json, "type", ovsdb_type_to_json(&column->type));
113     return json;
114 }
115 \f
116 void
117 ovsdb_column_set_init(struct ovsdb_column_set *set)
118 {
119     set->columns = NULL;
120     set->n_columns = set->allocated_columns = 0;
121 }
122
123 void
124 ovsdb_column_set_destroy(struct ovsdb_column_set *set)
125 {
126     free(set->columns);
127 }
128
129 void
130 ovsdb_column_set_clone(struct ovsdb_column_set *new,
131                        const struct ovsdb_column_set *old)
132 {
133     new->columns = xmemdup(old->columns,
134                            old->n_columns * sizeof *old->columns);
135     new->n_columns = new->allocated_columns = old->n_columns;
136 }
137
138 struct ovsdb_error *
139 ovsdb_column_set_from_json(const struct json *json,
140                            const struct ovsdb_table_schema *schema,
141                            struct ovsdb_column_set *set)
142 {
143     ovsdb_column_set_init(set);
144     if (!json) {
145         struct shash_node *node;
146
147         SHASH_FOR_EACH (node, &schema->columns) {
148             const struct ovsdb_column *column = node->data;
149             ovsdb_column_set_add(set, column);
150         }
151
152         return NULL;
153     } else {
154         struct ovsdb_error *error = NULL;
155         size_t i;
156
157         if (json->type != JSON_ARRAY) {
158             goto error;
159         }
160
161         /* XXX this is O(n**2) */
162         for (i = 0; i < json->u.array.n; i++) {
163             const struct ovsdb_column *column;
164             const char *s;
165
166             if (json->u.array.elems[i]->type != JSON_STRING) {
167                 goto error;
168             }
169
170             s = json->u.array.elems[i]->u.string;
171             column = shash_find_data(&schema->columns, s);
172             if (!column) {
173                 error = ovsdb_syntax_error(json, NULL, "%s is not a valid "
174                                            "column name", s);
175                 goto error;
176             } else if (ovsdb_column_set_contains(set, column->index)) {
177                 goto error;
178             }
179             ovsdb_column_set_add(set, column);
180         }
181         return NULL;
182
183     error:
184         ovsdb_column_set_destroy(set);
185         ovsdb_column_set_init(set);
186         if (!error) {
187             error = ovsdb_syntax_error(json, NULL, "array of distinct column "
188                                        "names expected");
189         }
190         return error;
191     }
192 }
193
194 struct json *
195 ovsdb_column_set_to_json(const struct ovsdb_column_set *set)
196 {
197     struct json *json;
198     size_t i;
199
200     json = json_array_create_empty();
201     for (i = 0; i < set->n_columns; i++) {
202         json_array_add(json, json_string_create(set->columns[i]->name));
203     }
204     return json;
205 }
206
207 /* Returns an English string listing the contents of 'set', e.g. "columns
208  * \"a\", \"b\", and \"c\"".  The caller must free the string. */
209 char *
210 ovsdb_column_set_to_string(const struct ovsdb_column_set *set)
211 {
212     if (!set->n_columns) {
213         return xstrdup("no columns");
214     } else {
215         struct ds s;
216         size_t i;
217
218         ds_init(&s);
219         ds_put_format(&s, "column%s ", set->n_columns > 1 ? "s" : "");
220         for (i = 0; i < set->n_columns; i++) {
221             const char *delimiter = english_list_delimiter(i, set->n_columns);
222             ds_put_format(&s, "%s\"%s\"", delimiter, set->columns[i]->name);
223         }
224         return ds_steal_cstr(&s);
225     }
226 }
227
228 void
229 ovsdb_column_set_add(struct ovsdb_column_set *set,
230                      const struct ovsdb_column *column)
231 {
232     if (set->n_columns >= set->allocated_columns) {
233         set->columns = x2nrealloc(set->columns, &set->allocated_columns,
234                                   sizeof *set->columns);
235     }
236     set->columns[set->n_columns++] = column;
237 }
238
239 void
240 ovsdb_column_set_add_all(struct ovsdb_column_set *set,
241                          const struct ovsdb_table *table)
242 {
243     struct shash_node *node;
244
245     SHASH_FOR_EACH (node, &table->schema->columns) {
246         const struct ovsdb_column *column = node->data;
247         ovsdb_column_set_add(set, column);
248     }
249 }
250
251 bool
252 ovsdb_column_set_contains(const struct ovsdb_column_set *set,
253                           unsigned int column_index)
254 {
255     size_t i;
256
257     for (i = 0; i < set->n_columns; i++) {
258         if (set->columns[i]->index == column_index) {
259             return true;
260         }
261     }
262     return false;
263 }
264
265 /* This comparison is sensitive to ordering of columns within a set, but that's
266  * good: the only existing caller wants to make sure that hash values are
267  * comparable, which is only true if column ordering is the same. */
268 bool
269 ovsdb_column_set_equals(const struct ovsdb_column_set *a,
270                         const struct ovsdb_column_set *b)
271 {
272     size_t i;
273
274     if (a->n_columns != b->n_columns) {
275         return false;
276     }
277     for (i = 0; i < a->n_columns; i++) {
278         if (a->columns[i] != b->columns[i]) {
279             return false;
280         }
281     }
282     return true;
283 }