/* Generated automatically -- do not modify!    -*- buffer-read-only: t -*- */

#ifndef OVSREC_IDL_HEADER

#define OVSREC_IDL_HEADER 1

#include <stdbool.h>

#include <stddef.h>

#include <stdint.h>

#include "openvswitch/json.h"

#include "ovsdb-data.h"

#include "ovsdb-idl-provider.h"

#include "smap.h"

#include "uuid.h"

#ifdef  __cplusplus

extern "C" {

#endif

struct ovsdb_type;

/* AutoAttach table. */

struct ovsrec_autoattach {

  struct ovsdb_idl_row header_;

  /* mappings column. */

  int64_t *key_mappings;

  int64_t *value_mappings;

  size_t n_mappings;

  /* system_description column. */

  char *system_description; /* Always nonnull. */

  /* system_name column. */

  char *system_name;  /* Always nonnull. */

};

enum ovsrec_autoattach_column_id {

    OVSREC_AUTOATTACH_COL_MAPPINGS,

    OVSREC_AUTOATTACH_COL_SYSTEM_DESCRIPTION,

    OVSREC_AUTOATTACH_COL_SYSTEM_NAME,

    OVSREC_AUTOATTACH_N_COLUMNS

};

#define ovsrec_autoattach_col_mappings (ovsrec_autoattach_columns[OVSREC_AUTOATTACH_COL_MAPPINGS])

#define ovsrec_autoattach_col_system_description (ovsrec_autoattach_columns[OVSREC_AUTOATTACH_COL_SYSTEM_DESCRIPTION])

#define ovsrec_autoattach_col_system_name (ovsrec_autoattach_columns[OVSREC_AUTOATTACH_COL_SYSTEM_NAME])

extern struct ovsdb_idl_column ovsrec_autoattach_columns[OVSREC_AUTOATTACH_N_COLUMNS];

bool ovsrec_server_has_autoattach_table_col_mappings(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_autoattach_mappings_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_autoattach_table_col_system_description(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_autoattach_system_description_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_autoattach_table_col_system_name(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_autoattach_system_name_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_autoattach_table(const struct ovsdb_idl *);

const struct ovsrec_autoattach_table *ovsrec_autoattach_table_get(const struct ovsdb_idl *);

const struct ovsrec_autoattach *ovsrec_autoattach_table_first(const struct ovsrec_autoattach_table *);

#define OVSREC_AUTOATTACH_TABLE_FOR_EACH(ROW, TABLE) \

        for ((ROW) = ovsrec_autoattach_table_first(TABLE); \

             (ROW); \

             (ROW) = ovsrec_autoattach_next(ROW))

#define OVSREC_AUTOATTACH_TABLE_FOR_EACH_SAFE_LONG(ROW, NEXT, TABLE) \

        for ((ROW) = ovsrec_autoattach_table_first(TABLE); \

             (ROW) ? ((NEXT) = ovsrec_autoattach_next(ROW), 1) : 0; \

             (ROW) = (NEXT))

#define OVSREC_AUTOATTACH_TABLE_FOR_EACH_SAFE_SHORT(ROW, TABLE) \

        for (const struct ovsrec_autoattach * ROW__next = ((ROW) = ovsrec_autoattach_table_first(TABLE), NULL); \

             (ROW) ? (ROW__next = ovsrec_autoattach_next(ROW), 1) : (ROW__next = NULL, 0); \

             (ROW) = ROW__next)

#define OVSREC_AUTOATTACH_TABLE_FOR_EACH_SAFE(...)                                        \

        OVERLOAD_SAFE_MACRO(OVSREC_AUTOATTACH_TABLE_FOR_EACH_SAFE_LONG,                   \

                            OVSREC_AUTOATTACH_TABLE_FOR_EACH_SAFE_SHORT, 3, __VA_ARGS__)

const struct ovsrec_autoattach *ovsrec_autoattach_get_for_uuid(const struct ovsdb_idl *, const struct uuid *);

const struct ovsrec_autoattach *ovsrec_autoattach_table_get_for_uuid(const struct ovsrec_autoattach_table *, const struct uuid *);

const struct ovsrec_autoattach *ovsrec_autoattach_first(const struct ovsdb_idl *);

const struct ovsrec_autoattach *ovsrec_autoattach_next(const struct ovsrec_autoattach *);

#define OVSREC_AUTOATTACH_FOR_EACH(ROW, IDL) \

        for ((ROW) = ovsrec_autoattach_first(IDL); \

             (ROW); \

             (ROW) = ovsrec_autoattach_next(ROW))

#define OVSREC_AUTOATTACH_FOR_EACH_SAFE_LONG(ROW, NEXT, IDL) \

        for ((ROW) = ovsrec_autoattach_first(IDL); \

             (ROW) ? ((NEXT) = ovsrec_autoattach_next(ROW), 1) : 0; \

             (ROW) = (NEXT))

#define OVSREC_AUTOATTACH_FOR_EACH_SAFE_SHORT(ROW, IDL) \

        for (const struct ovsrec_autoattach * ROW__next = ((ROW) = ovsrec_autoattach_first(IDL), NULL); \

             (ROW) ? (ROW__next = ovsrec_autoattach_next(ROW), 1) : (ROW__next = NULL, 0); \

             (ROW) = ROW__next)

#define OVSREC_AUTOATTACH_FOR_EACH_SAFE(...)                                         \

        OVERLOAD_SAFE_MACRO(OVSREC_AUTOATTACH_FOR_EACH_SAFE_LONG,                    \

                            OVSREC_AUTOATTACH_FOR_EACH_SAFE_SHORT, 3, __VA_ARGS__)

unsigned int ovsrec_autoattach_get_seqno(const struct ovsdb_idl *);

unsigned int ovsrec_autoattach_row_get_seqno(const struct ovsrec_autoattach *row, enum ovsdb_idl_change change);

const struct ovsrec_autoattach *ovsrec_autoattach_track_get_first(const struct ovsdb_idl *);

const struct ovsrec_autoattach *ovsrec_autoattach_track_get_next(const struct ovsrec_autoattach *);

#define OVSREC_AUTOATTACH_FOR_EACH_TRACKED(ROW, IDL) \

        for ((ROW) = ovsrec_autoattach_track_get_first(IDL); \

             (ROW); \

             (ROW) = ovsrec_autoattach_track_get_next(ROW))

const struct ovsrec_autoattach *ovsrec_autoattach_table_track_get_first(const struct ovsrec_autoattach_table *);

#define OVSREC_AUTOATTACH_TABLE_FOR_EACH_TRACKED(ROW, TABLE) \

        for ((ROW) = ovsrec_autoattach_table_track_get_first(TABLE); \

             (ROW); \

             (ROW) = ovsrec_autoattach_track_get_next(ROW))

/* Returns true if 'row' was inserted since the last change tracking reset.

 *

 * Note: This can only be used to test rows of tracked changes. This cannot be

 * used to test if an uncommitted row that has been added locally is new or it

 * may given unexpected results. */

static inline bool ovsrec_autoattach_is_new(const struct ovsrec_autoattach *row)

{

    return ovsrec_autoattach_row_get_seqno(row, OVSDB_IDL_CHANGE_INSERT) > 0;

}

Unexecuted instantiation: userspace-tso.c:ovsrec_autoattach_is_new

Unexecuted instantiation: dpdk-stub.c:ovsrec_autoattach_is_new

Unexecuted instantiation: vswitch-idl.c:ovsrec_autoattach_is_new

/* Returns true if 'row' was deleted since the last change tracking reset.

 *

 * Note: This can only be used to test rows of tracked changes. This cannot be

 * used to test if an uncommitted row that has been added locally has been

 * deleted or it may given unexpected results. */

static inline bool ovsrec_autoattach_is_deleted(const struct ovsrec_autoattach *row)

{

    return ovsrec_autoattach_row_get_seqno(row, OVSDB_IDL_CHANGE_DELETE) > 0;

}

Unexecuted instantiation: userspace-tso.c:ovsrec_autoattach_is_deleted

Unexecuted instantiation: dpdk-stub.c:ovsrec_autoattach_is_deleted

Unexecuted instantiation: vswitch-idl.c:ovsrec_autoattach_is_deleted

void ovsrec_autoattach_index_destroy_row(const struct ovsrec_autoattach *);

struct ovsrec_autoattach *ovsrec_autoattach_index_find(struct ovsdb_idl_index *, const struct ovsrec_autoattach *);

int ovsrec_autoattach_index_compare(

    struct ovsdb_idl_index *, 

    const struct ovsrec_autoattach *, 

    const struct ovsrec_autoattach *);

struct ovsdb_idl_cursor ovsrec_autoattach_cursor_first(struct ovsdb_idl_index *);

struct ovsdb_idl_cursor ovsrec_autoattach_cursor_first_eq(

    struct ovsdb_idl_index *, const struct ovsrec_autoattach *);

struct ovsdb_idl_cursor ovsrec_autoattach_cursor_first_ge(

    struct ovsdb_idl_index *, const struct ovsrec_autoattach *);

struct ovsrec_autoattach *ovsrec_autoattach_cursor_data(struct ovsdb_idl_cursor *);

#define OVSREC_AUTOATTACH_FOR_EACH_RANGE(ROW, FROM, TO, INDEX) \

        for (struct ovsdb_idl_cursor cursor__ = ovsrec_autoattach_cursor_first_ge(INDEX, FROM); \

             (cursor__.position \

              && ((ROW) = ovsrec_autoattach_cursor_data(&cursor__), \

                  !(TO) || ovsrec_autoattach_index_compare(INDEX, ROW, TO) <= 0)); \

             ovsdb_idl_cursor_next(&cursor__))

#define OVSREC_AUTOATTACH_FOR_EACH_EQUAL(ROW, KEY, INDEX) \

        for (struct ovsdb_idl_cursor cursor__ = ovsrec_autoattach_cursor_first_eq(INDEX, KEY); \

             (cursor__.position \

              ? ((ROW) = ovsrec_autoattach_cursor_data(&cursor__), \

                 ovsdb_idl_cursor_next_eq(&cursor__), \

                 true) \

              : false); \

            )

#define OVSREC_AUTOATTACH_FOR_EACH_BYINDEX(ROW, INDEX) \

        for (struct ovsdb_idl_cursor cursor__ = ovsrec_autoattach_cursor_first(INDEX); \

             (cursor__.position \

              ? ((ROW) = ovsrec_autoattach_cursor_data(&cursor__), \

                 ovsdb_idl_cursor_next(&cursor__), \

                 true) \

              : false); \

            )

void ovsrec_autoattach_init(struct ovsrec_autoattach *);

void ovsrec_autoattach_delete(const struct ovsrec_autoattach *);

struct ovsrec_autoattach *ovsrec_autoattach_insert(struct ovsdb_idl_txn *);

struct ovsrec_autoattach *ovsrec_autoattach_insert_persist_uuid(

    struct ovsdb_idl_txn *txn, const struct uuid *uuid);

/* Returns true if the tracked column referenced by 'enum ovsrec_autoattach_column_id' of

 * the row referenced by 'struct ovsrec_autoattach *' was updated since the last change

 * tracking reset.

 *

 * Note: This can only be used to test rows of tracked changes. This cannot be

 * used to test if an uncommitted row that has been added locally has been

 * updated or it may given unexpected results. */

bool ovsrec_autoattach_is_updated(const struct ovsrec_autoattach *, enum ovsrec_autoattach_column_id);

void ovsrec_autoattach_verify_mappings(const struct ovsrec_autoattach *);

void ovsrec_autoattach_verify_system_description(const struct ovsrec_autoattach *);

void ovsrec_autoattach_verify_system_name(const struct ovsrec_autoattach *);

const struct ovsdb_datum *ovsrec_autoattach_get_mappings(const struct ovsrec_autoattach *, enum ovsdb_atomic_type key_type, enum ovsdb_atomic_type value_type);

const struct ovsdb_datum *ovsrec_autoattach_get_system_description(const struct ovsrec_autoattach *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_autoattach_get_system_name(const struct ovsrec_autoattach *, enum ovsdb_atomic_type key_type);

void ovsrec_autoattach_set_mappings(const struct ovsrec_autoattach *, const int64_t *key_mappings, const int64_t *value_mappings, size_t n_mappings);

void ovsrec_autoattach_set_system_description(const struct ovsrec_autoattach *, const char *system_description);

void ovsrec_autoattach_set_system_name(const struct ovsrec_autoattach *, const char *system_name);

void ovsrec_autoattach_update_mappings_setkey(const struct ovsrec_autoattach *,  int64_t , int64_t );

void ovsrec_autoattach_update_mappings_delkey(const struct ovsrec_autoattach *,  int64_t );

void ovsrec_autoattach_add_clause_mappings(struct ovsdb_idl_condition *, enum ovsdb_function function, const int64_t *key_mappings, const int64_t *value_mappings, size_t n_mappings);

unsigned int ovsrec_autoattach_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_autoattach_add_clause_system_description(struct ovsdb_idl_condition *, enum ovsdb_function function, const char *system_description);

unsigned int ovsrec_autoattach_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_autoattach_add_clause_system_name(struct ovsdb_idl_condition *, enum ovsdb_function function, const char *system_name);

unsigned int ovsrec_autoattach_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

struct ovsrec_autoattach *ovsrec_autoattach_index_init_row(struct ovsdb_idl_index *);

void ovsrec_autoattach_index_set_mappings(const struct ovsrec_autoattach *,

const int64_t *key_mappings, const int64_t *value_mappings, size_t n_mappings);

void ovsrec_autoattach_index_set_system_description(const struct ovsrec_autoattach *,

const char *system_description);

void ovsrec_autoattach_index_set_system_name(const struct ovsrec_autoattach *,

const char *system_name);

/* Bridge table. */

struct ovsrec_bridge {

  struct ovsdb_idl_row header_;

  /* auto_attach column. */

  struct ovsrec_autoattach *auto_attach;

  /* controller column. */

  struct ovsrec_controller **controller;

  size_t n_controller;

  /* datapath_id column. */

  char *datapath_id;

  /* datapath_type column. */

  char *datapath_type;  /* Always nonnull. */

  /* datapath_version column. */

  char *datapath_version; /* Always nonnull. */

  /* external_ids column. */

  struct smap external_ids;

  /* fail_mode column. */

  char *fail_mode;

  /* flood_vlans column. */

  int64_t *flood_vlans;

  size_t n_flood_vlans;

  /* flow_tables column. */

  int64_t *key_flow_tables;

  struct ovsrec_flow_table **value_flow_tables;

  size_t n_flow_tables;

  /* ipfix column. */

  struct ovsrec_ipfix *ipfix;

  /* mcast_snooping_enable column. */

  bool mcast_snooping_enable;

  /* mirrors column. */

  struct ovsrec_mirror **mirrors;

  size_t n_mirrors;

  /* name column. */

  char *name; /* Always nonnull. */

  /* netflow column. */

  struct ovsrec_netflow *netflow;

  /* other_config column. */

  struct smap other_config;

  /* ports column. */

  struct ovsrec_port **ports;

  size_t n_ports;

  /* protocols column. */

  char **protocols;

  size_t n_protocols;

  /* rstp_enable column. */

  bool rstp_enable;

  /* rstp_status column. */

  struct smap rstp_status;

  /* sflow column. */

  struct ovsrec_sflow *sflow;

  /* status column. */

  struct smap status;

  /* stp_enable column. */

  bool stp_enable;

};

enum ovsrec_bridge_column_id {

    OVSREC_BRIDGE_COL_AUTO_ATTACH,

    OVSREC_BRIDGE_COL_CONTROLLER,

    OVSREC_BRIDGE_COL_DATAPATH_ID,

    OVSREC_BRIDGE_COL_DATAPATH_TYPE,

    OVSREC_BRIDGE_COL_DATAPATH_VERSION,

    OVSREC_BRIDGE_COL_EXTERNAL_IDS,

    OVSREC_BRIDGE_COL_FAIL_MODE,

    OVSREC_BRIDGE_COL_FLOOD_VLANS,

    OVSREC_BRIDGE_COL_FLOW_TABLES,

    OVSREC_BRIDGE_COL_IPFIX,

    OVSREC_BRIDGE_COL_MCAST_SNOOPING_ENABLE,

    OVSREC_BRIDGE_COL_MIRRORS,

    OVSREC_BRIDGE_COL_NAME,

    OVSREC_BRIDGE_COL_NETFLOW,

    OVSREC_BRIDGE_COL_OTHER_CONFIG,

    OVSREC_BRIDGE_COL_PORTS,

    OVSREC_BRIDGE_COL_PROTOCOLS,

    OVSREC_BRIDGE_COL_RSTP_ENABLE,

    OVSREC_BRIDGE_COL_RSTP_STATUS,

    OVSREC_BRIDGE_COL_SFLOW,

    OVSREC_BRIDGE_COL_STATUS,

    OVSREC_BRIDGE_COL_STP_ENABLE,

    OVSREC_BRIDGE_N_COLUMNS

};

#define ovsrec_bridge_col_auto_attach (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_AUTO_ATTACH])

#define ovsrec_bridge_col_controller (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_CONTROLLER])

#define ovsrec_bridge_col_datapath_id (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_DATAPATH_ID])

#define ovsrec_bridge_col_datapath_type (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_DATAPATH_TYPE])

#define ovsrec_bridge_col_datapath_version (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_DATAPATH_VERSION])

#define ovsrec_bridge_col_external_ids (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_EXTERNAL_IDS])

#define ovsrec_bridge_col_fail_mode (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_FAIL_MODE])

#define ovsrec_bridge_col_flood_vlans (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_FLOOD_VLANS])

#define ovsrec_bridge_col_flow_tables (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_FLOW_TABLES])

#define ovsrec_bridge_col_ipfix (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_IPFIX])

#define ovsrec_bridge_col_mcast_snooping_enable (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_MCAST_SNOOPING_ENABLE])

#define ovsrec_bridge_col_mirrors (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_MIRRORS])

#define ovsrec_bridge_col_name (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_NAME])

#define ovsrec_bridge_col_netflow (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_NETFLOW])

#define ovsrec_bridge_col_other_config (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_OTHER_CONFIG])

#define ovsrec_bridge_col_ports (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_PORTS])

#define ovsrec_bridge_col_protocols (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_PROTOCOLS])

#define ovsrec_bridge_col_rstp_enable (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_RSTP_ENABLE])

#define ovsrec_bridge_col_rstp_status (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_RSTP_STATUS])

#define ovsrec_bridge_col_sflow (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_SFLOW])

#define ovsrec_bridge_col_status (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_STATUS])

#define ovsrec_bridge_col_stp_enable (ovsrec_bridge_columns[OVSREC_BRIDGE_COL_STP_ENABLE])

extern struct ovsdb_idl_column ovsrec_bridge_columns[OVSREC_BRIDGE_N_COLUMNS];

bool ovsrec_server_has_bridge_table_col_auto_attach(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_auto_attach_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_controller(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_controller_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_datapath_id(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_datapath_id_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_datapath_type(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_datapath_type_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_datapath_version(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_datapath_version_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_external_ids(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_external_ids_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_fail_mode(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_fail_mode_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_flood_vlans(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_flood_vlans_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_flow_tables(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_flow_tables_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_ipfix(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_ipfix_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_mcast_snooping_enable(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_mcast_snooping_enable_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_mirrors(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_mirrors_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_name(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_name_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_netflow(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_netflow_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_other_config(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_other_config_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_ports(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_ports_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_protocols(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_protocols_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_rstp_enable(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_rstp_enable_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_rstp_status(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_rstp_status_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_sflow(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_sflow_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_status(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_status_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table_col_stp_enable(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_bridge_stp_enable_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_bridge_table(const struct ovsdb_idl *);

const struct ovsrec_bridge_table *ovsrec_bridge_table_get(const struct ovsdb_idl *);

const struct ovsrec_bridge *ovsrec_bridge_table_first(const struct ovsrec_bridge_table *);

#define OVSREC_BRIDGE_TABLE_FOR_EACH(ROW, TABLE) \

        for ((ROW) = ovsrec_bridge_table_first(TABLE); \

             (ROW); \

             (ROW) = ovsrec_bridge_next(ROW))

#define OVSREC_BRIDGE_TABLE_FOR_EACH_SAFE_LONG(ROW, NEXT, TABLE) \

        for ((ROW) = ovsrec_bridge_table_first(TABLE); \

             (ROW) ? ((NEXT) = ovsrec_bridge_next(ROW), 1) : 0; \

             (ROW) = (NEXT))

#define OVSREC_BRIDGE_TABLE_FOR_EACH_SAFE_SHORT(ROW, TABLE) \

        for (const struct ovsrec_bridge * ROW__next = ((ROW) = ovsrec_bridge_table_first(TABLE), NULL); \

             (ROW) ? (ROW__next = ovsrec_bridge_next(ROW), 1) : (ROW__next = NULL, 0); \

             (ROW) = ROW__next)

#define OVSREC_BRIDGE_TABLE_FOR_EACH_SAFE(...)                                        \

        OVERLOAD_SAFE_MACRO(OVSREC_BRIDGE_TABLE_FOR_EACH_SAFE_LONG,                   \

                            OVSREC_BRIDGE_TABLE_FOR_EACH_SAFE_SHORT, 3, __VA_ARGS__)

const struct ovsrec_bridge *ovsrec_bridge_get_for_uuid(const struct ovsdb_idl *, const struct uuid *);

const struct ovsrec_bridge *ovsrec_bridge_table_get_for_uuid(const struct ovsrec_bridge_table *, const struct uuid *);

const struct ovsrec_bridge *ovsrec_bridge_first(const struct ovsdb_idl *);

const struct ovsrec_bridge *ovsrec_bridge_next(const struct ovsrec_bridge *);

#define OVSREC_BRIDGE_FOR_EACH(ROW, IDL) \

        for ((ROW) = ovsrec_bridge_first(IDL); \

             (ROW); \

             (ROW) = ovsrec_bridge_next(ROW))

#define OVSREC_BRIDGE_FOR_EACH_SAFE_LONG(ROW, NEXT, IDL) \

        for ((ROW) = ovsrec_bridge_first(IDL); \

             (ROW) ? ((NEXT) = ovsrec_bridge_next(ROW), 1) : 0; \

             (ROW) = (NEXT))

#define OVSREC_BRIDGE_FOR_EACH_SAFE_SHORT(ROW, IDL) \

        for (const struct ovsrec_bridge * ROW__next = ((ROW) = ovsrec_bridge_first(IDL), NULL); \

             (ROW) ? (ROW__next = ovsrec_bridge_next(ROW), 1) : (ROW__next = NULL, 0); \

             (ROW) = ROW__next)

#define OVSREC_BRIDGE_FOR_EACH_SAFE(...)                                         \

        OVERLOAD_SAFE_MACRO(OVSREC_BRIDGE_FOR_EACH_SAFE_LONG,                    \

                            OVSREC_BRIDGE_FOR_EACH_SAFE_SHORT, 3, __VA_ARGS__)

unsigned int ovsrec_bridge_get_seqno(const struct ovsdb_idl *);

unsigned int ovsrec_bridge_row_get_seqno(const struct ovsrec_bridge *row, enum ovsdb_idl_change change);

const struct ovsrec_bridge *ovsrec_bridge_track_get_first(const struct ovsdb_idl *);

const struct ovsrec_bridge *ovsrec_bridge_track_get_next(const struct ovsrec_bridge *);

#define OVSREC_BRIDGE_FOR_EACH_TRACKED(ROW, IDL) \

        for ((ROW) = ovsrec_bridge_track_get_first(IDL); \

             (ROW); \

             (ROW) = ovsrec_bridge_track_get_next(ROW))

const struct ovsrec_bridge *ovsrec_bridge_table_track_get_first(const struct ovsrec_bridge_table *);

#define OVSREC_BRIDGE_TABLE_FOR_EACH_TRACKED(ROW, TABLE) \

        for ((ROW) = ovsrec_bridge_table_track_get_first(TABLE); \

             (ROW); \

             (ROW) = ovsrec_bridge_track_get_next(ROW))

/* Returns true if 'row' was inserted since the last change tracking reset.

 *

 * Note: This can only be used to test rows of tracked changes. This cannot be

 * used to test if an uncommitted row that has been added locally is new or it

 * may given unexpected results. */

static inline bool ovsrec_bridge_is_new(const struct ovsrec_bridge *row)

{

    return ovsrec_bridge_row_get_seqno(row, OVSDB_IDL_CHANGE_INSERT) > 0;

}

Unexecuted instantiation: userspace-tso.c:ovsrec_bridge_is_new

Unexecuted instantiation: dpdk-stub.c:ovsrec_bridge_is_new

Unexecuted instantiation: vswitch-idl.c:ovsrec_bridge_is_new

/* Returns true if 'row' was deleted since the last change tracking reset.

 *

 * Note: This can only be used to test rows of tracked changes. This cannot be

 * used to test if an uncommitted row that has been added locally has been

 * deleted or it may given unexpected results. */

static inline bool ovsrec_bridge_is_deleted(const struct ovsrec_bridge *row)

{

    return ovsrec_bridge_row_get_seqno(row, OVSDB_IDL_CHANGE_DELETE) > 0;

}

Unexecuted instantiation: userspace-tso.c:ovsrec_bridge_is_deleted

Unexecuted instantiation: dpdk-stub.c:ovsrec_bridge_is_deleted

Unexecuted instantiation: vswitch-idl.c:ovsrec_bridge_is_deleted

void ovsrec_bridge_index_destroy_row(const struct ovsrec_bridge *);

struct ovsrec_bridge *ovsrec_bridge_index_find(struct ovsdb_idl_index *, const struct ovsrec_bridge *);

int ovsrec_bridge_index_compare(

    struct ovsdb_idl_index *, 

    const struct ovsrec_bridge *, 

    const struct ovsrec_bridge *);

struct ovsdb_idl_cursor ovsrec_bridge_cursor_first(struct ovsdb_idl_index *);

struct ovsdb_idl_cursor ovsrec_bridge_cursor_first_eq(

    struct ovsdb_idl_index *, const struct ovsrec_bridge *);

struct ovsdb_idl_cursor ovsrec_bridge_cursor_first_ge(

    struct ovsdb_idl_index *, const struct ovsrec_bridge *);

struct ovsrec_bridge *ovsrec_bridge_cursor_data(struct ovsdb_idl_cursor *);

#define OVSREC_BRIDGE_FOR_EACH_RANGE(ROW, FROM, TO, INDEX) \

        for (struct ovsdb_idl_cursor cursor__ = ovsrec_bridge_cursor_first_ge(INDEX, FROM); \

             (cursor__.position \

              && ((ROW) = ovsrec_bridge_cursor_data(&cursor__), \

                  !(TO) || ovsrec_bridge_index_compare(INDEX, ROW, TO) <= 0)); \

             ovsdb_idl_cursor_next(&cursor__))

#define OVSREC_BRIDGE_FOR_EACH_EQUAL(ROW, KEY, INDEX) \

        for (struct ovsdb_idl_cursor cursor__ = ovsrec_bridge_cursor_first_eq(INDEX, KEY); \

             (cursor__.position \

              ? ((ROW) = ovsrec_bridge_cursor_data(&cursor__), \

                 ovsdb_idl_cursor_next_eq(&cursor__), \

                 true) \

              : false); \

            )

#define OVSREC_BRIDGE_FOR_EACH_BYINDEX(ROW, INDEX) \

        for (struct ovsdb_idl_cursor cursor__ = ovsrec_bridge_cursor_first(INDEX); \

             (cursor__.position \

              ? ((ROW) = ovsrec_bridge_cursor_data(&cursor__), \

                 ovsdb_idl_cursor_next(&cursor__), \

                 true) \

              : false); \

            )

void ovsrec_bridge_init(struct ovsrec_bridge *);

void ovsrec_bridge_delete(const struct ovsrec_bridge *);

struct ovsrec_bridge *ovsrec_bridge_insert(struct ovsdb_idl_txn *);

struct ovsrec_bridge *ovsrec_bridge_insert_persist_uuid(

    struct ovsdb_idl_txn *txn, const struct uuid *uuid);

/* Returns true if the tracked column referenced by 'enum ovsrec_bridge_column_id' of

 * the row referenced by 'struct ovsrec_bridge *' was updated since the last change

 * tracking reset.

 *

 * Note: This can only be used to test rows of tracked changes. This cannot be

 * used to test if an uncommitted row that has been added locally has been

 * updated or it may given unexpected results. */

bool ovsrec_bridge_is_updated(const struct ovsrec_bridge *, enum ovsrec_bridge_column_id);

void ovsrec_bridge_verify_auto_attach(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_controller(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_datapath_id(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_datapath_type(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_datapath_version(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_external_ids(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_fail_mode(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_flood_vlans(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_flow_tables(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_ipfix(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_mcast_snooping_enable(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_mirrors(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_name(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_netflow(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_other_config(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_ports(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_protocols(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_rstp_enable(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_rstp_status(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_sflow(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_status(const struct ovsrec_bridge *);

void ovsrec_bridge_verify_stp_enable(const struct ovsrec_bridge *);

const struct ovsdb_datum *ovsrec_bridge_get_auto_attach(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_controller(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_datapath_id(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_datapath_type(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_datapath_version(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_external_ids(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type, enum ovsdb_atomic_type value_type);

const struct ovsdb_datum *ovsrec_bridge_get_fail_mode(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_flood_vlans(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_flow_tables(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type, enum ovsdb_atomic_type value_type);

const struct ovsdb_datum *ovsrec_bridge_get_ipfix(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_mcast_snooping_enable(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_mirrors(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_name(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_netflow(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_other_config(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type, enum ovsdb_atomic_type value_type);

const struct ovsdb_datum *ovsrec_bridge_get_ports(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_protocols(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_rstp_enable(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_rstp_status(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type, enum ovsdb_atomic_type value_type);

const struct ovsdb_datum *ovsrec_bridge_get_sflow(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_bridge_get_status(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type, enum ovsdb_atomic_type value_type);

const struct ovsdb_datum *ovsrec_bridge_get_stp_enable(const struct ovsrec_bridge *, enum ovsdb_atomic_type key_type);

void ovsrec_bridge_set_auto_attach(const struct ovsrec_bridge *, const struct ovsrec_autoattach *auto_attach);

void ovsrec_bridge_set_controller(const struct ovsrec_bridge *, struct ovsrec_controller **controller, size_t n_controller);

void ovsrec_bridge_set_datapath_id(const struct ovsrec_bridge *, const char *datapath_id);

void ovsrec_bridge_set_datapath_type(const struct ovsrec_bridge *, const char *datapath_type);

void ovsrec_bridge_set_datapath_version(const struct ovsrec_bridge *, const char *datapath_version);

void ovsrec_bridge_set_external_ids(const struct ovsrec_bridge *, const struct smap *);

void ovsrec_bridge_set_fail_mode(const struct ovsrec_bridge *, const char *fail_mode);

void ovsrec_bridge_set_flood_vlans(const struct ovsrec_bridge *, const int64_t *flood_vlans, size_t n_flood_vlans);

void ovsrec_bridge_set_flow_tables(const struct ovsrec_bridge *, const int64_t *key_flow_tables, struct ovsrec_flow_table **value_flow_tables, size_t n_flow_tables);

void ovsrec_bridge_set_ipfix(const struct ovsrec_bridge *, const struct ovsrec_ipfix *ipfix);

void ovsrec_bridge_set_mcast_snooping_enable(const struct ovsrec_bridge *, bool mcast_snooping_enable);

void ovsrec_bridge_set_mirrors(const struct ovsrec_bridge *, struct ovsrec_mirror **mirrors, size_t n_mirrors);

void ovsrec_bridge_set_name(const struct ovsrec_bridge *, const char *name);

void ovsrec_bridge_set_netflow(const struct ovsrec_bridge *, const struct ovsrec_netflow *netflow);

void ovsrec_bridge_set_other_config(const struct ovsrec_bridge *, const struct smap *);

void ovsrec_bridge_set_ports(const struct ovsrec_bridge *, struct ovsrec_port **ports, size_t n_ports);

void ovsrec_bridge_set_protocols(const struct ovsrec_bridge *, const char **protocols, size_t n_protocols);

void ovsrec_bridge_set_rstp_enable(const struct ovsrec_bridge *, bool rstp_enable);

void ovsrec_bridge_set_rstp_status(const struct ovsrec_bridge *, const struct smap *);

void ovsrec_bridge_set_sflow(const struct ovsrec_bridge *, const struct ovsrec_sflow *sflow);

void ovsrec_bridge_set_status(const struct ovsrec_bridge *, const struct smap *);

void ovsrec_bridge_set_stp_enable(const struct ovsrec_bridge *, bool stp_enable);

void ovsrec_bridge_update_auto_attach_addvalue(const struct ovsrec_bridge *,  const struct ovsrec_autoattach *);

void ovsrec_bridge_update_auto_attach_delvalue(const struct ovsrec_bridge *,  const struct ovsrec_autoattach *);

void ovsrec_bridge_add_clause_auto_attach(struct ovsdb_idl_condition *, enum ovsdb_function function, const struct uuid *auto_attach);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_update_controller_addvalue(const struct ovsrec_bridge *,  const struct ovsrec_controller *);

void ovsrec_bridge_update_controller_delvalue(const struct ovsrec_bridge *,  const struct ovsrec_controller *);

void ovsrec_bridge_add_clause_controller(struct ovsdb_idl_condition *, enum ovsdb_function function, struct uuid **controller, size_t n_controller);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_update_datapath_id_addvalue(const struct ovsrec_bridge *,  const char *);

void ovsrec_bridge_update_datapath_id_delvalue(const struct ovsrec_bridge *,  const char *);

void ovsrec_bridge_add_clause_datapath_id(struct ovsdb_idl_condition *, enum ovsdb_function function, const char *datapath_id);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_add_clause_datapath_type(struct ovsdb_idl_condition *, enum ovsdb_function function, const char *datapath_type);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_add_clause_datapath_version(struct ovsdb_idl_condition *, enum ovsdb_function function, const char *datapath_version);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_update_external_ids_setkey(const struct ovsrec_bridge *,  const char *, const char *);

void ovsrec_bridge_update_external_ids_delkey(const struct ovsrec_bridge *,  const char *);

void ovsrec_bridge_add_clause_external_ids(struct ovsdb_idl_condition *, enum ovsdb_function function, const struct smap *);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_update_fail_mode_addvalue(const struct ovsrec_bridge *,  const char *);

void ovsrec_bridge_update_fail_mode_delvalue(const struct ovsrec_bridge *,  const char *);

void ovsrec_bridge_add_clause_fail_mode(struct ovsdb_idl_condition *, enum ovsdb_function function, const char *fail_mode);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_update_flood_vlans_addvalue(const struct ovsrec_bridge *,  int64_t );

void ovsrec_bridge_update_flood_vlans_delvalue(const struct ovsrec_bridge *,  int64_t );

void ovsrec_bridge_add_clause_flood_vlans(struct ovsdb_idl_condition *, enum ovsdb_function function, const int64_t *flood_vlans, size_t n_flood_vlans);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_update_flow_tables_setkey(const struct ovsrec_bridge *,  int64_t , const struct ovsrec_flow_table *);

void ovsrec_bridge_update_flow_tables_delkey(const struct ovsrec_bridge *,  int64_t );

void ovsrec_bridge_add_clause_flow_tables(struct ovsdb_idl_condition *, enum ovsdb_function function, const int64_t *key_flow_tables, struct uuid **value_flow_tables, size_t n_flow_tables);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_update_ipfix_addvalue(const struct ovsrec_bridge *,  const struct ovsrec_ipfix *);

void ovsrec_bridge_update_ipfix_delvalue(const struct ovsrec_bridge *,  const struct ovsrec_ipfix *);

void ovsrec_bridge_add_clause_ipfix(struct ovsdb_idl_condition *, enum ovsdb_function function, const struct uuid *ipfix);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_add_clause_mcast_snooping_enable(struct ovsdb_idl_condition *, enum ovsdb_function function, bool mcast_snooping_enable);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_update_mirrors_addvalue(const struct ovsrec_bridge *,  const struct ovsrec_mirror *);

void ovsrec_bridge_update_mirrors_delvalue(const struct ovsrec_bridge *,  const struct ovsrec_mirror *);

void ovsrec_bridge_add_clause_mirrors(struct ovsdb_idl_condition *, enum ovsdb_function function, struct uuid **mirrors, size_t n_mirrors);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_add_clause_name(struct ovsdb_idl_condition *, enum ovsdb_function function, const char *name);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_update_netflow_addvalue(const struct ovsrec_bridge *,  const struct ovsrec_netflow *);

void ovsrec_bridge_update_netflow_delvalue(const struct ovsrec_bridge *,  const struct ovsrec_netflow *);

void ovsrec_bridge_add_clause_netflow(struct ovsdb_idl_condition *, enum ovsdb_function function, const struct uuid *netflow);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_update_other_config_setkey(const struct ovsrec_bridge *,  const char *, const char *);

void ovsrec_bridge_update_other_config_delkey(const struct ovsrec_bridge *,  const char *);

void ovsrec_bridge_add_clause_other_config(struct ovsdb_idl_condition *, enum ovsdb_function function, const struct smap *);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_update_ports_addvalue(const struct ovsrec_bridge *,  const struct ovsrec_port *);

void ovsrec_bridge_update_ports_delvalue(const struct ovsrec_bridge *,  const struct ovsrec_port *);

void ovsrec_bridge_add_clause_ports(struct ovsdb_idl_condition *, enum ovsdb_function function, struct uuid **ports, size_t n_ports);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_update_protocols_addvalue(const struct ovsrec_bridge *,  const char *);

void ovsrec_bridge_update_protocols_delvalue(const struct ovsrec_bridge *,  const char *);

void ovsrec_bridge_add_clause_protocols(struct ovsdb_idl_condition *, enum ovsdb_function function, const char **protocols, size_t n_protocols);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_add_clause_rstp_enable(struct ovsdb_idl_condition *, enum ovsdb_function function, bool rstp_enable);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_update_rstp_status_setkey(const struct ovsrec_bridge *,  const char *, const char *);

void ovsrec_bridge_update_rstp_status_delkey(const struct ovsrec_bridge *,  const char *);

void ovsrec_bridge_add_clause_rstp_status(struct ovsdb_idl_condition *, enum ovsdb_function function, const struct smap *);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_update_sflow_addvalue(const struct ovsrec_bridge *,  const struct ovsrec_sflow *);

void ovsrec_bridge_update_sflow_delvalue(const struct ovsrec_bridge *,  const struct ovsrec_sflow *);

void ovsrec_bridge_add_clause_sflow(struct ovsdb_idl_condition *, enum ovsdb_function function, const struct uuid *sflow);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_update_status_setkey(const struct ovsrec_bridge *,  const char *, const char *);

void ovsrec_bridge_update_status_delkey(const struct ovsrec_bridge *,  const char *);

void ovsrec_bridge_add_clause_status(struct ovsdb_idl_condition *, enum ovsdb_function function, const struct smap *);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_bridge_add_clause_stp_enable(struct ovsdb_idl_condition *, enum ovsdb_function function, bool stp_enable);

unsigned int ovsrec_bridge_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

struct ovsrec_bridge *ovsrec_bridge_index_init_row(struct ovsdb_idl_index *);

void ovsrec_bridge_index_set_auto_attach(const struct ovsrec_bridge *,

const struct ovsrec_autoattach *auto_attach);

void ovsrec_bridge_index_set_controller(const struct ovsrec_bridge *,

struct ovsrec_controller **controller, size_t n_controller);

void ovsrec_bridge_index_set_datapath_id(const struct ovsrec_bridge *,

const char *datapath_id);

void ovsrec_bridge_index_set_datapath_type(const struct ovsrec_bridge *,

const char *datapath_type);

void ovsrec_bridge_index_set_datapath_version(const struct ovsrec_bridge *,

const char *datapath_version);

void ovsrec_bridge_index_set_external_ids(const struct ovsrec_bridge *,

const struct smap *);

void ovsrec_bridge_index_set_fail_mode(const struct ovsrec_bridge *,

const char *fail_mode);

void ovsrec_bridge_index_set_flood_vlans(const struct ovsrec_bridge *,

const int64_t *flood_vlans, size_t n_flood_vlans);

void ovsrec_bridge_index_set_flow_tables(const struct ovsrec_bridge *,

const int64_t *key_flow_tables, struct ovsrec_flow_table **value_flow_tables, size_t n_flow_tables);

void ovsrec_bridge_index_set_ipfix(const struct ovsrec_bridge *,

const struct ovsrec_ipfix *ipfix);

void ovsrec_bridge_index_set_mcast_snooping_enable(const struct ovsrec_bridge *,

bool mcast_snooping_enable);

void ovsrec_bridge_index_set_mirrors(const struct ovsrec_bridge *,

struct ovsrec_mirror **mirrors, size_t n_mirrors);

void ovsrec_bridge_index_set_name(const struct ovsrec_bridge *,

const char *name);

void ovsrec_bridge_index_set_netflow(const struct ovsrec_bridge *,

const struct ovsrec_netflow *netflow);

void ovsrec_bridge_index_set_other_config(const struct ovsrec_bridge *,

const struct smap *);

void ovsrec_bridge_index_set_ports(const struct ovsrec_bridge *,

struct ovsrec_port **ports, size_t n_ports);

void ovsrec_bridge_index_set_protocols(const struct ovsrec_bridge *,

const char **protocols, size_t n_protocols);

void ovsrec_bridge_index_set_rstp_enable(const struct ovsrec_bridge *,

bool rstp_enable);

void ovsrec_bridge_index_set_rstp_status(const struct ovsrec_bridge *,

const struct smap *);

void ovsrec_bridge_index_set_sflow(const struct ovsrec_bridge *,

const struct ovsrec_sflow *sflow);

void ovsrec_bridge_index_set_status(const struct ovsrec_bridge *,

const struct smap *);

void ovsrec_bridge_index_set_stp_enable(const struct ovsrec_bridge *,

bool stp_enable);

/* CT_Timeout_Policy table. */

struct ovsrec_ct_timeout_policy {

  struct ovsdb_idl_row header_;

  /* external_ids column. */

  struct smap external_ids;

  /* timeouts column. */

  char **key_timeouts;

  int64_t *value_timeouts;

  size_t n_timeouts;

};

enum ovsrec_ct_timeout_policy_column_id {

    OVSREC_CT_TIMEOUT_POLICY_COL_EXTERNAL_IDS,

    OVSREC_CT_TIMEOUT_POLICY_COL_TIMEOUTS,

    OVSREC_CT_TIMEOUT_POLICY_N_COLUMNS

};

#define ovsrec_ct_timeout_policy_col_external_ids (ovsrec_ct_timeout_policy_columns[OVSREC_CT_TIMEOUT_POLICY_COL_EXTERNAL_IDS])

#define ovsrec_ct_timeout_policy_col_timeouts (ovsrec_ct_timeout_policy_columns[OVSREC_CT_TIMEOUT_POLICY_COL_TIMEOUTS])

extern struct ovsdb_idl_column ovsrec_ct_timeout_policy_columns[OVSREC_CT_TIMEOUT_POLICY_N_COLUMNS];

bool ovsrec_server_has_ct_timeout_policy_table_col_external_ids(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_ct_timeout_policy_external_ids_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_ct_timeout_policy_table_col_timeouts(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_ct_timeout_policy_timeouts_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_ct_timeout_policy_table(const struct ovsdb_idl *);

const struct ovsrec_ct_timeout_policy_table *ovsrec_ct_timeout_policy_table_get(const struct ovsdb_idl *);

const struct ovsrec_ct_timeout_policy *ovsrec_ct_timeout_policy_table_first(const struct ovsrec_ct_timeout_policy_table *);

#define OVSREC_CT_TIMEOUT_POLICY_TABLE_FOR_EACH(ROW, TABLE) \

        for ((ROW) = ovsrec_ct_timeout_policy_table_first(TABLE); \

             (ROW); \

             (ROW) = ovsrec_ct_timeout_policy_next(ROW))

#define OVSREC_CT_TIMEOUT_POLICY_TABLE_FOR_EACH_SAFE_LONG(ROW, NEXT, TABLE) \

        for ((ROW) = ovsrec_ct_timeout_policy_table_first(TABLE); \

             (ROW) ? ((NEXT) = ovsrec_ct_timeout_policy_next(ROW), 1) : 0; \

             (ROW) = (NEXT))

#define OVSREC_CT_TIMEOUT_POLICY_TABLE_FOR_EACH_SAFE_SHORT(ROW, TABLE) \

        for (const struct ovsrec_ct_timeout_policy * ROW__next = ((ROW) = ovsrec_ct_timeout_policy_table_first(TABLE), NULL); \

             (ROW) ? (ROW__next = ovsrec_ct_timeout_policy_next(ROW), 1) : (ROW__next = NULL, 0); \

             (ROW) = ROW__next)

#define OVSREC_CT_TIMEOUT_POLICY_TABLE_FOR_EACH_SAFE(...)                                        \

        OVERLOAD_SAFE_MACRO(OVSREC_CT_TIMEOUT_POLICY_TABLE_FOR_EACH_SAFE_LONG,                   \

                            OVSREC_CT_TIMEOUT_POLICY_TABLE_FOR_EACH_SAFE_SHORT, 3, __VA_ARGS__)

const struct ovsrec_ct_timeout_policy *ovsrec_ct_timeout_policy_get_for_uuid(const struct ovsdb_idl *, const struct uuid *);

const struct ovsrec_ct_timeout_policy *ovsrec_ct_timeout_policy_table_get_for_uuid(const struct ovsrec_ct_timeout_policy_table *, const struct uuid *);

const struct ovsrec_ct_timeout_policy *ovsrec_ct_timeout_policy_first(const struct ovsdb_idl *);

const struct ovsrec_ct_timeout_policy *ovsrec_ct_timeout_policy_next(const struct ovsrec_ct_timeout_policy *);

#define OVSREC_CT_TIMEOUT_POLICY_FOR_EACH(ROW, IDL) \

        for ((ROW) = ovsrec_ct_timeout_policy_first(IDL); \

             (ROW); \

             (ROW) = ovsrec_ct_timeout_policy_next(ROW))

#define OVSREC_CT_TIMEOUT_POLICY_FOR_EACH_SAFE_LONG(ROW, NEXT, IDL) \

        for ((ROW) = ovsrec_ct_timeout_policy_first(IDL); \

             (ROW) ? ((NEXT) = ovsrec_ct_timeout_policy_next(ROW), 1) : 0; \

             (ROW) = (NEXT))

#define OVSREC_CT_TIMEOUT_POLICY_FOR_EACH_SAFE_SHORT(ROW, IDL) \

        for (const struct ovsrec_ct_timeout_policy * ROW__next = ((ROW) = ovsrec_ct_timeout_policy_first(IDL), NULL); \

             (ROW) ? (ROW__next = ovsrec_ct_timeout_policy_next(ROW), 1) : (ROW__next = NULL, 0); \

             (ROW) = ROW__next)

#define OVSREC_CT_TIMEOUT_POLICY_FOR_EACH_SAFE(...)                                         \

        OVERLOAD_SAFE_MACRO(OVSREC_CT_TIMEOUT_POLICY_FOR_EACH_SAFE_LONG,                    \

                            OVSREC_CT_TIMEOUT_POLICY_FOR_EACH_SAFE_SHORT, 3, __VA_ARGS__)

unsigned int ovsrec_ct_timeout_policy_get_seqno(const struct ovsdb_idl *);

unsigned int ovsrec_ct_timeout_policy_row_get_seqno(const struct ovsrec_ct_timeout_policy *row, enum ovsdb_idl_change change);

const struct ovsrec_ct_timeout_policy *ovsrec_ct_timeout_policy_track_get_first(const struct ovsdb_idl *);

const struct ovsrec_ct_timeout_policy *ovsrec_ct_timeout_policy_track_get_next(const struct ovsrec_ct_timeout_policy *);

#define OVSREC_CT_TIMEOUT_POLICY_FOR_EACH_TRACKED(ROW, IDL) \

        for ((ROW) = ovsrec_ct_timeout_policy_track_get_first(IDL); \

             (ROW); \

             (ROW) = ovsrec_ct_timeout_policy_track_get_next(ROW))

const struct ovsrec_ct_timeout_policy *ovsrec_ct_timeout_policy_table_track_get_first(const struct ovsrec_ct_timeout_policy_table *);

#define OVSREC_CT_TIMEOUT_POLICY_TABLE_FOR_EACH_TRACKED(ROW, TABLE) \

        for ((ROW) = ovsrec_ct_timeout_policy_table_track_get_first(TABLE); \

             (ROW); \

             (ROW) = ovsrec_ct_timeout_policy_track_get_next(ROW))

/* Returns true if 'row' was inserted since the last change tracking reset.

 *

 * Note: This can only be used to test rows of tracked changes. This cannot be

 * used to test if an uncommitted row that has been added locally is new or it

 * may given unexpected results. */

static inline bool ovsrec_ct_timeout_policy_is_new(const struct ovsrec_ct_timeout_policy *row)

{

    return ovsrec_ct_timeout_policy_row_get_seqno(row, OVSDB_IDL_CHANGE_INSERT) > 0;

}

Unexecuted instantiation: userspace-tso.c:ovsrec_ct_timeout_policy_is_new

Unexecuted instantiation: dpdk-stub.c:ovsrec_ct_timeout_policy_is_new

Unexecuted instantiation: vswitch-idl.c:ovsrec_ct_timeout_policy_is_new

/* Returns true if 'row' was deleted since the last change tracking reset.

 *

 * Note: This can only be used to test rows of tracked changes. This cannot be

 * used to test if an uncommitted row that has been added locally has been

 * deleted or it may given unexpected results. */

static inline bool ovsrec_ct_timeout_policy_is_deleted(const struct ovsrec_ct_timeout_policy *row)

{

    return ovsrec_ct_timeout_policy_row_get_seqno(row, OVSDB_IDL_CHANGE_DELETE) > 0;

}

Unexecuted instantiation: userspace-tso.c:ovsrec_ct_timeout_policy_is_deleted

Unexecuted instantiation: dpdk-stub.c:ovsrec_ct_timeout_policy_is_deleted

Unexecuted instantiation: vswitch-idl.c:ovsrec_ct_timeout_policy_is_deleted

void ovsrec_ct_timeout_policy_index_destroy_row(const struct ovsrec_ct_timeout_policy *);

struct ovsrec_ct_timeout_policy *ovsrec_ct_timeout_policy_index_find(struct ovsdb_idl_index *, const struct ovsrec_ct_timeout_policy *);

int ovsrec_ct_timeout_policy_index_compare(

    struct ovsdb_idl_index *, 

    const struct ovsrec_ct_timeout_policy *, 

    const struct ovsrec_ct_timeout_policy *);

struct ovsdb_idl_cursor ovsrec_ct_timeout_policy_cursor_first(struct ovsdb_idl_index *);

struct ovsdb_idl_cursor ovsrec_ct_timeout_policy_cursor_first_eq(

    struct ovsdb_idl_index *, const struct ovsrec_ct_timeout_policy *);

struct ovsdb_idl_cursor ovsrec_ct_timeout_policy_cursor_first_ge(

    struct ovsdb_idl_index *, const struct ovsrec_ct_timeout_policy *);

struct ovsrec_ct_timeout_policy *ovsrec_ct_timeout_policy_cursor_data(struct ovsdb_idl_cursor *);

#define OVSREC_CT_TIMEOUT_POLICY_FOR_EACH_RANGE(ROW, FROM, TO, INDEX) \

        for (struct ovsdb_idl_cursor cursor__ = ovsrec_ct_timeout_policy_cursor_first_ge(INDEX, FROM); \

             (cursor__.position \

              && ((ROW) = ovsrec_ct_timeout_policy_cursor_data(&cursor__), \

                  !(TO) || ovsrec_ct_timeout_policy_index_compare(INDEX, ROW, TO) <= 0)); \

             ovsdb_idl_cursor_next(&cursor__))

#define OVSREC_CT_TIMEOUT_POLICY_FOR_EACH_EQUAL(ROW, KEY, INDEX) \

        for (struct ovsdb_idl_cursor cursor__ = ovsrec_ct_timeout_policy_cursor_first_eq(INDEX, KEY); \

             (cursor__.position \

              ? ((ROW) = ovsrec_ct_timeout_policy_cursor_data(&cursor__), \

                 ovsdb_idl_cursor_next_eq(&cursor__), \

                 true) \

              : false); \

            )

#define OVSREC_CT_TIMEOUT_POLICY_FOR_EACH_BYINDEX(ROW, INDEX) \

        for (struct ovsdb_idl_cursor cursor__ = ovsrec_ct_timeout_policy_cursor_first(INDEX); \

             (cursor__.position \

              ? ((ROW) = ovsrec_ct_timeout_policy_cursor_data(&cursor__), \

                 ovsdb_idl_cursor_next(&cursor__), \

                 true) \

              : false); \

            )

void ovsrec_ct_timeout_policy_init(struct ovsrec_ct_timeout_policy *);

void ovsrec_ct_timeout_policy_delete(const struct ovsrec_ct_timeout_policy *);

struct ovsrec_ct_timeout_policy *ovsrec_ct_timeout_policy_insert(struct ovsdb_idl_txn *);

struct ovsrec_ct_timeout_policy *ovsrec_ct_timeout_policy_insert_persist_uuid(

    struct ovsdb_idl_txn *txn, const struct uuid *uuid);

/* Returns true if the tracked column referenced by 'enum ovsrec_ct_timeout_policy_column_id' of

 * the row referenced by 'struct ovsrec_ct_timeout_policy *' was updated since the last change

 * tracking reset.

 *

 * Note: This can only be used to test rows of tracked changes. This cannot be

 * used to test if an uncommitted row that has been added locally has been

 * updated or it may given unexpected results. */

bool ovsrec_ct_timeout_policy_is_updated(const struct ovsrec_ct_timeout_policy *, enum ovsrec_ct_timeout_policy_column_id);

void ovsrec_ct_timeout_policy_verify_external_ids(const struct ovsrec_ct_timeout_policy *);

void ovsrec_ct_timeout_policy_verify_timeouts(const struct ovsrec_ct_timeout_policy *);

const struct ovsdb_datum *ovsrec_ct_timeout_policy_get_external_ids(const struct ovsrec_ct_timeout_policy *, enum ovsdb_atomic_type key_type, enum ovsdb_atomic_type value_type);

const struct ovsdb_datum *ovsrec_ct_timeout_policy_get_timeouts(const struct ovsrec_ct_timeout_policy *, enum ovsdb_atomic_type key_type, enum ovsdb_atomic_type value_type);

void ovsrec_ct_timeout_policy_set_external_ids(const struct ovsrec_ct_timeout_policy *, const struct smap *);

void ovsrec_ct_timeout_policy_set_timeouts(const struct ovsrec_ct_timeout_policy *, const char **key_timeouts, const int64_t *value_timeouts, size_t n_timeouts);

void ovsrec_ct_timeout_policy_update_external_ids_setkey(const struct ovsrec_ct_timeout_policy *,  const char *, const char *);

void ovsrec_ct_timeout_policy_update_external_ids_delkey(const struct ovsrec_ct_timeout_policy *,  const char *);

void ovsrec_ct_timeout_policy_add_clause_external_ids(struct ovsdb_idl_condition *, enum ovsdb_function function, const struct smap *);

unsigned int ovsrec_ct_timeout_policy_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_ct_timeout_policy_update_timeouts_setkey(const struct ovsrec_ct_timeout_policy *,  const char *, int64_t );

void ovsrec_ct_timeout_policy_update_timeouts_delkey(const struct ovsrec_ct_timeout_policy *,  const char *);

void ovsrec_ct_timeout_policy_add_clause_timeouts(struct ovsdb_idl_condition *, enum ovsdb_function function, const char **key_timeouts, const int64_t *value_timeouts, size_t n_timeouts);

unsigned int ovsrec_ct_timeout_policy_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

struct ovsrec_ct_timeout_policy *ovsrec_ct_timeout_policy_index_init_row(struct ovsdb_idl_index *);

void ovsrec_ct_timeout_policy_index_set_external_ids(const struct ovsrec_ct_timeout_policy *,

const struct smap *);

void ovsrec_ct_timeout_policy_index_set_timeouts(const struct ovsrec_ct_timeout_policy *,

const char **key_timeouts, const int64_t *value_timeouts, size_t n_timeouts);

/* CT_Zone table. */

struct ovsrec_ct_zone {

  struct ovsdb_idl_row header_;

  /* external_ids column. */

  struct smap external_ids;

  /* limit column. */

  int64_t *limit;

  size_t n_limit;

  /* timeout_policy column. */

  struct ovsrec_ct_timeout_policy *timeout_policy;

};

enum ovsrec_ct_zone_column_id {

    OVSREC_CT_ZONE_COL_EXTERNAL_IDS,

    OVSREC_CT_ZONE_COL_LIMIT,

    OVSREC_CT_ZONE_COL_TIMEOUT_POLICY,

    OVSREC_CT_ZONE_N_COLUMNS

};

#define ovsrec_ct_zone_col_external_ids (ovsrec_ct_zone_columns[OVSREC_CT_ZONE_COL_EXTERNAL_IDS])

#define ovsrec_ct_zone_col_limit (ovsrec_ct_zone_columns[OVSREC_CT_ZONE_COL_LIMIT])

#define ovsrec_ct_zone_col_timeout_policy (ovsrec_ct_zone_columns[OVSREC_CT_ZONE_COL_TIMEOUT_POLICY])

extern struct ovsdb_idl_column ovsrec_ct_zone_columns[OVSREC_CT_ZONE_N_COLUMNS];

bool ovsrec_server_has_ct_zone_table_col_external_ids(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_ct_zone_external_ids_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_ct_zone_table_col_limit(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_ct_zone_limit_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_ct_zone_table_col_timeout_policy(const struct ovsdb_idl *); 

const struct ovsdb_type *ovsrec_ct_zone_timeout_policy_server_type(const struct ovsdb_idl *); 

bool ovsrec_server_has_ct_zone_table(const struct ovsdb_idl *);

const struct ovsrec_ct_zone_table *ovsrec_ct_zone_table_get(const struct ovsdb_idl *);

const struct ovsrec_ct_zone *ovsrec_ct_zone_table_first(const struct ovsrec_ct_zone_table *);

#define OVSREC_CT_ZONE_TABLE_FOR_EACH(ROW, TABLE) \

        for ((ROW) = ovsrec_ct_zone_table_first(TABLE); \

             (ROW); \

             (ROW) = ovsrec_ct_zone_next(ROW))

#define OVSREC_CT_ZONE_TABLE_FOR_EACH_SAFE_LONG(ROW, NEXT, TABLE) \

        for ((ROW) = ovsrec_ct_zone_table_first(TABLE); \

             (ROW) ? ((NEXT) = ovsrec_ct_zone_next(ROW), 1) : 0; \

             (ROW) = (NEXT))

#define OVSREC_CT_ZONE_TABLE_FOR_EACH_SAFE_SHORT(ROW, TABLE) \

        for (const struct ovsrec_ct_zone * ROW__next = ((ROW) = ovsrec_ct_zone_table_first(TABLE), NULL); \

             (ROW) ? (ROW__next = ovsrec_ct_zone_next(ROW), 1) : (ROW__next = NULL, 0); \

             (ROW) = ROW__next)

#define OVSREC_CT_ZONE_TABLE_FOR_EACH_SAFE(...)                                        \

        OVERLOAD_SAFE_MACRO(OVSREC_CT_ZONE_TABLE_FOR_EACH_SAFE_LONG,                   \

                            OVSREC_CT_ZONE_TABLE_FOR_EACH_SAFE_SHORT, 3, __VA_ARGS__)

const struct ovsrec_ct_zone *ovsrec_ct_zone_get_for_uuid(const struct ovsdb_idl *, const struct uuid *);

const struct ovsrec_ct_zone *ovsrec_ct_zone_table_get_for_uuid(const struct ovsrec_ct_zone_table *, const struct uuid *);

const struct ovsrec_ct_zone *ovsrec_ct_zone_first(const struct ovsdb_idl *);

const struct ovsrec_ct_zone *ovsrec_ct_zone_next(const struct ovsrec_ct_zone *);

#define OVSREC_CT_ZONE_FOR_EACH(ROW, IDL) \

        for ((ROW) = ovsrec_ct_zone_first(IDL); \

             (ROW); \

             (ROW) = ovsrec_ct_zone_next(ROW))

#define OVSREC_CT_ZONE_FOR_EACH_SAFE_LONG(ROW, NEXT, IDL) \

        for ((ROW) = ovsrec_ct_zone_first(IDL); \

             (ROW) ? ((NEXT) = ovsrec_ct_zone_next(ROW), 1) : 0; \

             (ROW) = (NEXT))

#define OVSREC_CT_ZONE_FOR_EACH_SAFE_SHORT(ROW, IDL) \

        for (const struct ovsrec_ct_zone * ROW__next = ((ROW) = ovsrec_ct_zone_first(IDL), NULL); \

             (ROW) ? (ROW__next = ovsrec_ct_zone_next(ROW), 1) : (ROW__next = NULL, 0); \

             (ROW) = ROW__next)

#define OVSREC_CT_ZONE_FOR_EACH_SAFE(...)                                         \

        OVERLOAD_SAFE_MACRO(OVSREC_CT_ZONE_FOR_EACH_SAFE_LONG,                    \

                            OVSREC_CT_ZONE_FOR_EACH_SAFE_SHORT, 3, __VA_ARGS__)

unsigned int ovsrec_ct_zone_get_seqno(const struct ovsdb_idl *);

unsigned int ovsrec_ct_zone_row_get_seqno(const struct ovsrec_ct_zone *row, enum ovsdb_idl_change change);

const struct ovsrec_ct_zone *ovsrec_ct_zone_track_get_first(const struct ovsdb_idl *);

const struct ovsrec_ct_zone *ovsrec_ct_zone_track_get_next(const struct ovsrec_ct_zone *);

#define OVSREC_CT_ZONE_FOR_EACH_TRACKED(ROW, IDL) \

        for ((ROW) = ovsrec_ct_zone_track_get_first(IDL); \

             (ROW); \

             (ROW) = ovsrec_ct_zone_track_get_next(ROW))

const struct ovsrec_ct_zone *ovsrec_ct_zone_table_track_get_first(const struct ovsrec_ct_zone_table *);

#define OVSREC_CT_ZONE_TABLE_FOR_EACH_TRACKED(ROW, TABLE) \

        for ((ROW) = ovsrec_ct_zone_table_track_get_first(TABLE); \

             (ROW); \

             (ROW) = ovsrec_ct_zone_track_get_next(ROW))

/* Returns true if 'row' was inserted since the last change tracking reset.

 *

 * Note: This can only be used to test rows of tracked changes. This cannot be

 * used to test if an uncommitted row that has been added locally is new or it

 * may given unexpected results. */

static inline bool ovsrec_ct_zone_is_new(const struct ovsrec_ct_zone *row)

{

    return ovsrec_ct_zone_row_get_seqno(row, OVSDB_IDL_CHANGE_INSERT) > 0;

}

Unexecuted instantiation: userspace-tso.c:ovsrec_ct_zone_is_new

Unexecuted instantiation: dpdk-stub.c:ovsrec_ct_zone_is_new

Unexecuted instantiation: vswitch-idl.c:ovsrec_ct_zone_is_new

/* Returns true if 'row' was deleted since the last change tracking reset.

 *

 * Note: This can only be used to test rows of tracked changes. This cannot be

 * used to test if an uncommitted row that has been added locally has been

 * deleted or it may given unexpected results. */

static inline bool ovsrec_ct_zone_is_deleted(const struct ovsrec_ct_zone *row)

{

    return ovsrec_ct_zone_row_get_seqno(row, OVSDB_IDL_CHANGE_DELETE) > 0;

}

Unexecuted instantiation: userspace-tso.c:ovsrec_ct_zone_is_deleted

Unexecuted instantiation: dpdk-stub.c:ovsrec_ct_zone_is_deleted

Unexecuted instantiation: vswitch-idl.c:ovsrec_ct_zone_is_deleted

void ovsrec_ct_zone_index_destroy_row(const struct ovsrec_ct_zone *);

struct ovsrec_ct_zone *ovsrec_ct_zone_index_find(struct ovsdb_idl_index *, const struct ovsrec_ct_zone *);

int ovsrec_ct_zone_index_compare(

    struct ovsdb_idl_index *, 

    const struct ovsrec_ct_zone *, 

    const struct ovsrec_ct_zone *);

struct ovsdb_idl_cursor ovsrec_ct_zone_cursor_first(struct ovsdb_idl_index *);

struct ovsdb_idl_cursor ovsrec_ct_zone_cursor_first_eq(

    struct ovsdb_idl_index *, const struct ovsrec_ct_zone *);

struct ovsdb_idl_cursor ovsrec_ct_zone_cursor_first_ge(

    struct ovsdb_idl_index *, const struct ovsrec_ct_zone *);

struct ovsrec_ct_zone *ovsrec_ct_zone_cursor_data(struct ovsdb_idl_cursor *);

#define OVSREC_CT_ZONE_FOR_EACH_RANGE(ROW, FROM, TO, INDEX) \

        for (struct ovsdb_idl_cursor cursor__ = ovsrec_ct_zone_cursor_first_ge(INDEX, FROM); \

             (cursor__.position \

              && ((ROW) = ovsrec_ct_zone_cursor_data(&cursor__), \

                  !(TO) || ovsrec_ct_zone_index_compare(INDEX, ROW, TO) <= 0)); \

             ovsdb_idl_cursor_next(&cursor__))

#define OVSREC_CT_ZONE_FOR_EACH_EQUAL(ROW, KEY, INDEX) \

        for (struct ovsdb_idl_cursor cursor__ = ovsrec_ct_zone_cursor_first_eq(INDEX, KEY); \

             (cursor__.position \

              ? ((ROW) = ovsrec_ct_zone_cursor_data(&cursor__), \

                 ovsdb_idl_cursor_next_eq(&cursor__), \

                 true) \

              : false); \

            )

#define OVSREC_CT_ZONE_FOR_EACH_BYINDEX(ROW, INDEX) \

        for (struct ovsdb_idl_cursor cursor__ = ovsrec_ct_zone_cursor_first(INDEX); \

             (cursor__.position \

              ? ((ROW) = ovsrec_ct_zone_cursor_data(&cursor__), \

                 ovsdb_idl_cursor_next(&cursor__), \

                 true) \

              : false); \

            )

void ovsrec_ct_zone_init(struct ovsrec_ct_zone *);

void ovsrec_ct_zone_delete(const struct ovsrec_ct_zone *);

struct ovsrec_ct_zone *ovsrec_ct_zone_insert(struct ovsdb_idl_txn *);

struct ovsrec_ct_zone *ovsrec_ct_zone_insert_persist_uuid(

    struct ovsdb_idl_txn *txn, const struct uuid *uuid);

/* Returns true if the tracked column referenced by 'enum ovsrec_ct_zone_column_id' of

 * the row referenced by 'struct ovsrec_ct_zone *' was updated since the last change

 * tracking reset.

 *

 * Note: This can only be used to test rows of tracked changes. This cannot be

 * used to test if an uncommitted row that has been added locally has been

 * updated or it may given unexpected results. */

bool ovsrec_ct_zone_is_updated(const struct ovsrec_ct_zone *, enum ovsrec_ct_zone_column_id);

void ovsrec_ct_zone_verify_external_ids(const struct ovsrec_ct_zone *);

void ovsrec_ct_zone_verify_limit(const struct ovsrec_ct_zone *);

void ovsrec_ct_zone_verify_timeout_policy(const struct ovsrec_ct_zone *);

const struct ovsdb_datum *ovsrec_ct_zone_get_external_ids(const struct ovsrec_ct_zone *, enum ovsdb_atomic_type key_type, enum ovsdb_atomic_type value_type);

const struct ovsdb_datum *ovsrec_ct_zone_get_limit(const struct ovsrec_ct_zone *, enum ovsdb_atomic_type key_type);

const struct ovsdb_datum *ovsrec_ct_zone_get_timeout_policy(const struct ovsrec_ct_zone *, enum ovsdb_atomic_type key_type);

void ovsrec_ct_zone_set_external_ids(const struct ovsrec_ct_zone *, const struct smap *);

void ovsrec_ct_zone_set_limit(const struct ovsrec_ct_zone *, const int64_t *limit, size_t n_limit);

void ovsrec_ct_zone_set_timeout_policy(const struct ovsrec_ct_zone *, const struct ovsrec_ct_timeout_policy *timeout_policy);

void ovsrec_ct_zone_update_external_ids_setkey(const struct ovsrec_ct_zone *,  const char *, const char *);

void ovsrec_ct_zone_update_external_ids_delkey(const struct ovsrec_ct_zone *,  const char *);

void ovsrec_ct_zone_add_clause_external_ids(struct ovsdb_idl_condition *, enum ovsdb_function function, const struct smap *);

unsigned int ovsrec_ct_zone_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_ct_zone_update_limit_addvalue(const struct ovsrec_ct_zone *,  int64_t );

void ovsrec_ct_zone_update_limit_delvalue(const struct ovsrec_ct_zone *,  int64_t );

void ovsrec_ct_zone_add_clause_limit(struct ovsdb_idl_condition *, enum ovsdb_function function, const int64_t *limit, size_t n_limit);

unsigned int ovsrec_ct_zone_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

void ovsrec_ct_zone_update_timeout_policy_addvalue(const struct ovsrec_ct_zone *,  const struct ovsrec_ct_timeout_policy *);

void ovsrec_ct_zone_update_timeout_policy_delvalue(const struct ovsrec_ct_zone *,  const struct ovsrec_ct_timeout_policy *);

void ovsrec_ct_zone_add_clause_timeout_policy(struct ovsdb_idl_condition *, enum ovsdb_function function, const struct uuid *timeout_policy);

unsigned int ovsrec_ct_zone_set_condition(struct ovsdb_idl *, struct ovsdb_idl_condition *);

struct ovsrec_ct_zone *ovsrec_ct_zone_index_init_row(struct ovsdb_idl_index *);

void ovsrec_ct_zone_index_set_external_ids(const struct ovsrec_ct_zone *,

const struct smap *);

void ovsrec_ct_zone_index_set_limit(const struct ovsrec_ct_zone *,

const int64_t *limit, size_t n_limit);

void ovsrec_ct_zone_index_set_timeout_policy(const struct ovsrec_ct_zone *,

const struct ovsrec_ct_timeout_policy *timeout_policy);

/* Controller table. */

struct ovsrec_controller {

  struct ovsdb_idl_row header_;

  /* connection_mode column. */

  char *connection_mode;

  /* controller_burst_limit column. */

  int64_t *controller_burst_limit;

  size_t n_controller_burst_limit;

  /* controller_queue_size column. */

  int64_t *controller_queue_size;

  size_t n_controller_queue_size;

  /* controller_rate_limit column. */

  int64_t *controller_rate_limit;

  size_t n_controller_rate_limit;

  /* enable_async_messages column. */

  bool *enable_async_messages;