lib/ovsdb-types.h

   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 #ifndef OVSDB_TYPES_H
  17 #define OVSDB_TYPES_H 1
  18
  19 #include <float.h>
  20 #include <stdbool.h>
  21 #include <stdint.h>
  22 #include "compiler.h"
  23 #include "uuid.h"
  24
  25 #ifdef __cplusplus
  26 extern "C" {
  27 #endif
  28
  29 struct json;
  30
  31 /* An atomic type: one that OVSDB regards as a single unit of data. */
  32 enum ovsdb_atomic_type {
  33     OVSDB_TYPE_VOID,            /* No value. */
  34     OVSDB_TYPE_INTEGER,         /* Signed 64-bit integer. */
  35     OVSDB_TYPE_REAL,            /* IEEE 754 double-precision floating point. */
  36     OVSDB_TYPE_BOOLEAN,         /* True or false. */
  37     OVSDB_TYPE_STRING,          /* UTF-8 string. */
  38     OVSDB_TYPE_UUID,            /* RFC 4122 UUID referencing a table row. */
  39     OVSDB_N_TYPES
  40 };
  41
  42 static inline bool ovsdb_atomic_type_is_valid(enum ovsdb_atomic_type);
  43 bool ovsdb_atomic_type_from_string(const char *, enum ovsdb_atomic_type *);
  44 struct ovsdb_error *ovsdb_atomic_type_from_json(enum ovsdb_atomic_type *,
  45                                                 const struct json *);
  46 const char *ovsdb_atomic_type_to_string(enum ovsdb_atomic_type);
  47 struct json *ovsdb_atomic_type_to_json(enum ovsdb_atomic_type);
  48 \f
  49 /* An atomic type plus optional constraints. */
  50
  51 enum ovsdb_ref_type {
  52     OVSDB_REF_STRONG,           /* Target must exist. */
  53     OVSDB_REF_WEAK              /* Delete reference if target disappears. */
  54 };
  55
  56 struct ovsdb_integer_constraints {
  57     int64_t min;        /* minInteger or INT64_MIN. */
  58     int64_t max;        /* maxInteger or INT64_MAX. */
  59 };
  60
  61 struct ovsdb_real_constraints {
  62     double min;         /* minReal or -DBL_MAX. */
  63     double max;         /* minReal or DBL_MAX. */
  64 };
  65
  66 struct ovsdb_string_constraints {
  67     unsigned int minLen; /* minLength or 0. */
  68     unsigned int maxLen; /* maxLength or UINT_MAX. */
  69 };
  70
  71 struct ovsdb_uuid_constraints {
  72     char *refTableName; /* Name of referenced table, or NULL. */
  73     struct ovsdb_table *refTable; /* Referenced table, if available. */
  74     enum ovsdb_ref_type refType;  /* Reference type. */
  75 };
  76
  77 struct ovsdb_base_type {
  78     enum ovsdb_atomic_type type;
  79
  80     /* If nonnull, a datum with keys of type 'type' that expresses all the
  81      * valid values for this base_type. */
  82     struct ovsdb_datum *enum_;
  83
  84     union {
  85         struct ovsdb_integer_constraints integer;
  86         struct ovsdb_real_constraints real;
  87         /* No constraints for Boolean types. */
  88         struct ovsdb_string_constraints string;
  89         struct ovsdb_uuid_constraints uuid;
  90     };
  91 };
  92
  93 #define OVSDB_BASE_VOID_INIT    { .type = OVSDB_TYPE_VOID }
  94 #define OVSDB_BASE_INTEGER_INIT { .type = OVSDB_TYPE_INTEGER,           \
  95                                   .integer = { INT64_MIN, INT64_MAX } }
  96 #define OVSDB_BASE_REAL_INIT    { .type = OVSDB_TYPE_REAL,          \
  97                                   .real = { -DBL_MAX, DBL_MAX } }
  98 #define OVSDB_BASE_BOOLEAN_INIT { .type = OVSDB_TYPE_BOOLEAN }
  99 #define OVSDB_BASE_STRING_INIT  { .type = OVSDB_TYPE_STRING,    \
 100                                   .string = { 0, UINT_MAX } }
 101 #define OVSDB_BASE_UUID_INIT    { .type = OVSDB_TYPE_UUID,      \
 102                                   .uuid = { NULL, NULL, 0 } }
 103
 104 void ovsdb_base_type_init(struct ovsdb_base_type *, enum ovsdb_atomic_type);
 105 void ovsdb_base_type_clone(struct ovsdb_base_type *,
 106                            const struct ovsdb_base_type *);
 107 void ovsdb_base_type_destroy(struct ovsdb_base_type *);
 108
 109 bool ovsdb_base_type_is_valid(const struct ovsdb_base_type *);
 110 bool ovsdb_base_type_has_constraints(const struct ovsdb_base_type *);
 111 void ovsdb_base_type_clear_constraints(struct ovsdb_base_type *);
 112 const struct ovsdb_type *ovsdb_base_type_get_enum_type(enum ovsdb_atomic_type);
 113
 114 struct ovsdb_error *ovsdb_base_type_from_json(struct ovsdb_base_type *,
 115                                               const struct json *)
 116     OVS_WARN_UNUSED_RESULT;
 117 struct json *ovsdb_base_type_to_json(const struct ovsdb_base_type *);
 118
 119 static inline bool ovsdb_base_type_is_ref(const struct ovsdb_base_type *);
 120 static inline bool ovsdb_base_type_is_strong_ref(
 121     const struct ovsdb_base_type *);
 122 static inline bool ovsdb_base_type_is_weak_ref(const struct ovsdb_base_type *);
 123 \f
 124 /* An OVSDB type.
 125  *
 126  * Several rules constrain the valid types.  See ovsdb_type_is_valid() (in
 127  * ovsdb-types.c) for details.
 128  *
 129  * If 'value_type' is OVSDB_TYPE_VOID, 'n_min' is 1, and 'n_max' is 1, then the
 130  * type is a single atomic 'key_type'.
 131  *
 132  * If 'value_type' is OVSDB_TYPE_VOID and 'n_min' or 'n_max' (or both) has a
 133  * value other than 1, then the type is a set of 'key_type'.  If 'n_min' is 0
 134  * and 'n_max' is 1, then the type can also be considered an optional
 135  * 'key_type'.
 136  *
 137  * If 'value_type' is not OVSDB_TYPE_VOID, then the type is a map from
 138  * 'key_type' to 'value_type'.  If 'n_min' is 0 and 'n_max' is 1, then the type
 139  * can also be considered an optional pair of 'key_type' and 'value_type'.
 140  */
 141 struct ovsdb_type {
 142     struct ovsdb_base_type key;
 143     struct ovsdb_base_type value;
 144     unsigned int n_min;
 145     unsigned int n_max;         /* UINT_MAX stands in for "unlimited". */
 146 };
 147
 148 #define OVSDB_TYPE_SCALAR_INITIALIZER(KEY) { KEY, OVSDB_BASE_VOID_INIT, 1, 1 }
 149
 150 extern const struct ovsdb_type ovsdb_type_integer;
 151 extern const struct ovsdb_type ovsdb_type_real;
 152 extern const struct ovsdb_type ovsdb_type_boolean;
 153 extern const struct ovsdb_type ovsdb_type_string;
 154 extern const struct ovsdb_type ovsdb_type_uuid;
 155
 156 void ovsdb_type_clone(struct ovsdb_type *, const struct ovsdb_type *);
 157 void ovsdb_type_destroy(struct ovsdb_type *);
 158
 159 bool ovsdb_type_is_valid(const struct ovsdb_type *);
 160
 161 static inline bool ovsdb_type_is_scalar(const struct ovsdb_type *);
 162 static inline bool ovsdb_type_is_optional(const struct ovsdb_type *);
 163 static inline bool ovsdb_type_is_optional_scalar(
 164     const struct ovsdb_type *);
 165 static inline bool ovsdb_type_is_composite(const struct ovsdb_type *);
 166 static inline bool ovsdb_type_is_set(const struct ovsdb_type *);
 167 static inline bool ovsdb_type_is_map(const struct ovsdb_type *);
 168
 169 char *ovsdb_type_to_english(const struct ovsdb_type *);
 170
 171 struct ovsdb_error *ovsdb_type_from_json(struct ovsdb_type *,
 172                                          const struct json *)
 173     OVS_WARN_UNUSED_RESULT;
 174 struct json *ovsdb_type_to_json(const struct ovsdb_type *);
 175 \f
 176 /* Inline function implementations. */
 177
 178 static inline bool
 179 ovsdb_atomic_type_is_valid(enum ovsdb_atomic_type atomic_type)
 180 {
 181     return (int) atomic_type >= 0 && atomic_type < OVSDB_N_TYPES;
 182 }
 183
 184 static inline bool
 185 ovsdb_base_type_is_ref(const struct ovsdb_base_type *base)
 186 {
 187     return base->type == OVSDB_TYPE_UUID && base->uuid.refTableName;
 188 }
 189
 190 static inline bool
 191 ovsdb_base_type_is_strong_ref(const struct ovsdb_base_type *base)
 192 {
 193     return (ovsdb_base_type_is_ref(base)
 194             && base->uuid.refType == OVSDB_REF_STRONG);
 195 }
 196
 197 static inline bool
 198 ovsdb_base_type_is_weak_ref(const struct ovsdb_base_type *base)
 199 {
 200     return (ovsdb_base_type_is_ref(base)
 201             && base->uuid.refType == OVSDB_REF_WEAK);
 202 }
 203
 204 static inline bool ovsdb_type_is_scalar(const struct ovsdb_type *type)
 205 {
 206     return (type->value.type == OVSDB_TYPE_VOID
 207             && type->n_min == 1 && type->n_max == 1);
 208 }
 209
 210 static inline bool ovsdb_type_is_optional(const struct ovsdb_type *type)
 211 {
 212     return type->n_min == 0;
 213 }
 214
 215 static inline bool ovsdb_type_is_optional_scalar(
 216     const struct ovsdb_type *type)
 217 {
 218     return (type->value.type == OVSDB_TYPE_VOID
 219             && type->n_min == 0 && type->n_max == 1);
 220 }
 221
 222 static inline bool ovsdb_type_is_composite(const struct ovsdb_type *type)
 223 {
 224     return type->n_max > 1;
 225 }
 226
 227 static inline bool ovsdb_type_is_set(const struct ovsdb_type *type)
 228 {
 229     return (type->value.type == OVSDB_TYPE_VOID
 230             && (type->n_min != 1 || type->n_max != 1));
 231 }
 232
 233 static inline bool ovsdb_type_is_map(const struct ovsdb_type *type)
 234 {
 235     return type->value.type != OVSDB_TYPE_VOID;
 236 }
 237
 238 #ifdef __cplusplus
 239 }
 240 #endif
 241
 242 #endif /* ovsdb-types.h */