ovsdb/column.c

   1 /* Copyright (c) 2009, 2010, 2011 Nicira, Inc.
   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 }