Line data    Source code

       1             : /*
       2             :  *------------------------------------------------------------------
       3             :  * json_format.h
       4             :  *
       5             :  * Copyright (c) 2015 Cisco and/or its affiliates.
       6             :  * Licensed under the Apache License, Version 2.0 (the "License");
       7             :  * you may not use this file except in compliance with the License.
       8             :  * You may obtain a copy of the License at:
       9             :  *
      10             :  *     http://www.apache.org/licenses/LICENSE-2.0
      11             :  *
      12             :  * Unless required by applicable law or agreed to in writing, software
      13             :  * distributed under the License is distributed on an "AS IS" BASIS,
      14             :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      15             :  * See the License for the specific language governing permissions and
      16             :  * limitations under the License.
      17             :  *------------------------------------------------------------------
      18             :  */
      19             : 
      20             : #ifndef __JSON_FORMAT_H__
      21             : #define __JSON_FORMAT_H__
      22             : 
      23             : #include <vppinfra/clib.h>
      24             : #include <vppinfra/format.h>
      25             : #include <netinet/ip.h>
      26             : 
      27             : /* JSON value type */
      28             : typedef enum
      29             : {
      30             :   VAT_JSON_NONE,
      31             :   VAT_JSON_OBJECT,
      32             :   VAT_JSON_ARRAY,
      33             :   VAT_JSON_STRING,
      34             :   VAT_JSON_REAL,
      35             :   VAT_JSON_UINT,
      36             :   VAT_JSON_INT,
      37             :   VAT_JSON_IPV4,
      38             :   VAT_JSON_IPV6,
      39             :   VAT_JSON_MAX
      40             : } vat_json_val_type_t;
      41             : 
      42             : typedef struct vat_json_node_s vat_json_node_t;
      43             : typedef struct vat_json_pair_s vat_json_pair_t;
      44             : 
      45             : /* JSON object structure */
      46             : struct vat_json_node_s
      47             : {
      48             :   vat_json_val_type_t type;
      49             :   union
      50             :   {
      51             :     vat_json_pair_t *pairs;
      52             :     vat_json_node_t *array;
      53             :     u8 *string;
      54             :     struct in_addr ip4;
      55             :     struct in6_addr ip6;
      56             :     u64 uint;
      57             :     i64 sint;
      58             :     f64 real;
      59             :   };
      60             : };
      61             : 
      62             : struct vat_json_pair_s
      63             : {
      64             :   const char *name;
      65             :   vat_json_node_t value;
      66             : };
      67             : 
      68             : void vat_json_print (FILE * ofp, vat_json_node_t * node);
      69             : void vat_json_free (vat_json_node_t * node);
      70             : 
      71             : static_always_inline void
      72           0 : vat_json_init_object (vat_json_node_t * json)
      73             : {
      74           0 :   json->type = VAT_JSON_OBJECT;
      75           0 :   json->pairs = NULL;
      76           0 : }
      77             : 
      78             : static_always_inline void
      79           0 : vat_json_init_array (vat_json_node_t * json)
      80             : {
      81           0 :   json->type = VAT_JSON_ARRAY;
      82           0 :   json->array = NULL;
      83           0 : }
      84             : 
      85             : static_always_inline void
      86             : vat_json_set_string (vat_json_node_t * json, u8 * str)
      87             : {
      88             :   json->type = VAT_JSON_STRING;
      89             :   json->string = str;
      90             : }
      91             : 
      92             : static_always_inline void
      93             : vat_json_set_string_copy (vat_json_node_t * json, const u8 * str)
      94             : {
      95             :   u8 *ns = NULL;
      96             :   int len = strlen ((const char *) str);
      97             :   vec_validate_init_c_string (ns, str, len);
      98             :   vat_json_set_string (json, ns);
      99             : }
     100             : 
     101             : static_always_inline void
     102           0 : vat_json_set_int (vat_json_node_t * json, i64 num)
     103             : {
     104           0 :   json->type = VAT_JSON_INT;
     105           0 :   json->sint = num;
     106           0 : }
     107             : 
     108             : static_always_inline void
     109           0 : vat_json_set_uint (vat_json_node_t * json, u64 num)
     110             : {
     111           0 :   json->type = VAT_JSON_UINT;
     112           0 :   json->uint = num;
     113           0 : }
     114             : 
     115             : static_always_inline void
     116             : vat_json_set_real (vat_json_node_t * json, f64 real)
     117             : {
     118             :   json->type = VAT_JSON_REAL;
     119             :   json->real = real;
     120             : }
     121             : 
     122             : static_always_inline void
     123             : vat_json_set_ip4 (vat_json_node_t * json, struct in_addr ip4)
     124             : {
     125             :   json->type = VAT_JSON_IPV4;
     126             :   json->ip4 = ip4;
     127             : }
     128             : 
     129             : static_always_inline void
     130             : vat_json_set_ip6 (vat_json_node_t * json, struct in6_addr ip6)
     131             : {
     132             :   json->type = VAT_JSON_IPV6;
     133             :   json->ip6 = ip6;
     134             : }
     135             : 
     136             : static_always_inline vat_json_node_t *
     137           0 : vat_json_object_add (vat_json_node_t * json, const char *name)
     138             : {
     139           0 :   ASSERT (VAT_JSON_OBJECT == json->type);
     140           0 :   uword pos = vec_len (json->pairs);
     141           0 :   vec_validate (json->pairs, pos);
     142           0 :   json->pairs[pos].name = name;
     143           0 :   return &json->pairs[pos].value;
     144             : }
     145             : 
     146             : static_always_inline vat_json_node_t *
     147             : vat_json_array_add (vat_json_node_t * json)
     148             : {
     149             :   ASSERT (VAT_JSON_ARRAY == json->type);
     150             :   uword pos = vec_len (json->array);
     151             :   vec_validate (json->array, pos);
     152             :   return &json->array[pos];
     153             : }
     154             : 
     155             : static_always_inline vat_json_node_t *
     156             : vat_json_object_add_list (vat_json_node_t * json, const char *name)
     157             : {
     158             :   vat_json_node_t *array_node = vat_json_object_add (json, name);
     159             :   vat_json_init_array (array_node);
     160             :   return array_node;
     161             : }
     162             : 
     163             : static_always_inline void
     164             : vat_json_object_add_string_copy (vat_json_node_t * json,
     165             :                                  const char *name, u8 * str)
     166             : {
     167             :   vat_json_set_string_copy (vat_json_object_add (json, name), str);
     168             : }
     169             : 
     170             : static_always_inline void
     171           0 : vat_json_object_add_uint (vat_json_node_t * json,
     172             :                           const char *name, u64 number)
     173             : {
     174           0 :   vat_json_set_uint (vat_json_object_add (json, name), number);
     175           0 : }
     176             : 
     177             : static_always_inline void
     178           0 : vat_json_object_add_int (vat_json_node_t * json, const char *name, i64 number)
     179             : {
     180           0 :   vat_json_set_int (vat_json_object_add (json, name), number);
     181           0 : }
     182             : 
     183             : static_always_inline void
     184             : vat_json_object_add_real (vat_json_node_t * json, const char *name, f64 real)
     185             : {
     186             :   vat_json_set_real (vat_json_object_add (json, name), real);
     187             : }
     188             : 
     189             : static_always_inline void
     190             : vat_json_object_add_ip4 (vat_json_node_t * json,
     191             :                          const char *name, struct in_addr ip4)
     192             : {
     193             :   vat_json_set_ip4 (vat_json_object_add (json, name), ip4);
     194             : }
     195             : 
     196             : static_always_inline void
     197             : vat_json_object_add_ip6 (vat_json_node_t * json,
     198             :                          const char *name, struct in6_addr ip6)
     199             : {
     200             :   vat_json_set_ip6 (vat_json_object_add (json, name), ip6);
     201             : }
     202             : 
     203             : static_always_inline void
     204             : vat_json_array_add_int (vat_json_node_t * json, i64 number)
     205             : {
     206             :   vat_json_set_int (vat_json_array_add (json), number);
     207             : }
     208             : 
     209             : static_always_inline void
     210             : vat_json_array_add_uint (vat_json_node_t * json, u64 number)
     211             : {
     212             :   vat_json_set_uint (vat_json_array_add (json), number);
     213             : }
     214             : 
     215             : static_always_inline void
     216             : vat_json_object_add_bytes (vat_json_node_t * json,
     217             :                            const char *name, u8 * array, uword size)
     218             : {
     219             :   ASSERT (VAT_JSON_OBJECT == json->type);
     220             :   vat_json_node_t *json_array = vat_json_object_add (json, name);
     221             :   vat_json_init_array (json_array);
     222             :   int i;
     223             :   for (i = 0; i < size; i++)
     224             :     {
     225             :       vat_json_array_add_uint (json_array, array[i]);
     226             :     }
     227             : }
     228             : 
     229             : static_always_inline vat_json_node_t *
     230             : vat_json_object_get_element (vat_json_node_t * json, const char *name)
     231             : {
     232             :   int i = 0;
     233             : 
     234             :   ASSERT (VAT_JSON_OBJECT == json->type);
     235             :   for (i = 0; i < vec_len (json->pairs); i++)
     236             :     {
     237             :       if (0 == strcmp (json->pairs[i].name, name))
     238             :         {
     239             :           return &json->pairs[i].value;
     240             :         }
     241             :     }
     242             :   return NULL;
     243             : }
     244             : 
     245             : #endif /* __JSON_FORMAT_H__ */
     246             : 
     247             : /*
     248             :  * fd.io coding-style-patch-verification: ON
     249             :  *
     250             :  * Local Variables:
     251             :  * eval: (c-set-style "gnu")
     252             :  * End:
     253             :  */