agent/agent-enum-types.c

   1
   2 /* This file is generated by glib-mkenums, do not modify it. This code is licensed under the same license as the containing project. Note that it links to GLib, so must comply with the LGPL linking clauses. */
   3
   4 #include <config.h>
   5 #include <glib-object.h>
   6 #include "agent.h"
   7 #include "pseudotcp.h"
   8 #include "agent-enum-types.h"
   9
  10 /* enumerations from "./agent.h" */
  11 GType
  12 nice_component_state_get_type (void)
  13 {
  14   static GType type = 0;
  15   if (!type) {
  16     static const GEnumValue values[] = {
  17       { NICE_COMPONENT_STATE_DISCONNECTED, "NICE_COMPONENT_STATE_DISCONNECTED", "disconnected" },
  18       { NICE_COMPONENT_STATE_GATHERING, "NICE_COMPONENT_STATE_GATHERING", "gathering" },
  19       { NICE_COMPONENT_STATE_CONNECTING, "NICE_COMPONENT_STATE_CONNECTING", "connecting" },
  20       { NICE_COMPONENT_STATE_CONNECTED, "NICE_COMPONENT_STATE_CONNECTED", "connected" },
  21       { NICE_COMPONENT_STATE_READY, "NICE_COMPONENT_STATE_READY", "ready" },
  22       { NICE_COMPONENT_STATE_FAILED, "NICE_COMPONENT_STATE_FAILED", "failed" },
  23       { NICE_COMPONENT_STATE_LAST, "NICE_COMPONENT_STATE_LAST", "last" },
  24       { 0, NULL, NULL }
  25     };
  26     type = g_enum_register_static ("NiceComponentState", values);
  27   }
  28   return type;
  29 }
  30 GType
  31 nice_component_type_get_type (void)
  32 {
  33   static GType type = 0;
  34   if (!type) {
  35     static const GEnumValue values[] = {
  36       { NICE_COMPONENT_TYPE_RTP, "NICE_COMPONENT_TYPE_RTP", "rtp" },
  37       { NICE_COMPONENT_TYPE_RTCP, "NICE_COMPONENT_TYPE_RTCP", "rtcp" },
  38       { 0, NULL, NULL }
  39     };
  40     type = g_enum_register_static ("NiceComponentType", values);
  41   }
  42   return type;
  43 }
  44 GType
  45 nice_compatibility_get_type (void)
  46 {
  47   static GType type = 0;
  48   if (!type) {
  49     static const GEnumValue values[] = {
  50       { NICE_COMPATIBILITY_RFC5245, "NICE_COMPATIBILITY_RFC5245", "rfc5245" },
  51       { NICE_COMPATIBILITY_DRAFT19, "NICE_COMPATIBILITY_DRAFT19", "draft19" },
  52       { NICE_COMPATIBILITY_GOOGLE, "NICE_COMPATIBILITY_GOOGLE", "google" },
  53       { NICE_COMPATIBILITY_MSN, "NICE_COMPATIBILITY_MSN", "msn" },
  54       { NICE_COMPATIBILITY_WLM2009, "NICE_COMPATIBILITY_WLM2009", "wlm2009" },
  55       { NICE_COMPATIBILITY_OC2007, "NICE_COMPATIBILITY_OC2007", "oc2007" },
  56       { NICE_COMPATIBILITY_OC2007R2, "NICE_COMPATIBILITY_OC2007R2", "oc2007r2" },
  57       { NICE_COMPATIBILITY_LAST, "NICE_COMPATIBILITY_LAST", "last" },
  58       { 0, NULL, NULL }
  59     };
  60     type = g_enum_register_static ("NiceCompatibility", values);
  61   }
  62   return type;
  63 }
  64 GType
  65 nice_proxy_type_get_type (void)
  66 {
  67   static GType type = 0;
  68   if (!type) {
  69     static const GEnumValue values[] = {
  70       { NICE_PROXY_TYPE_NONE, "NICE_PROXY_TYPE_NONE", "none" },
  71       { NICE_PROXY_TYPE_SOCKS5, "NICE_PROXY_TYPE_SOCKS5", "socks5" },
  72       { NICE_PROXY_TYPE_HTTP, "NICE_PROXY_TYPE_HTTP", "http" },
  73       { NICE_PROXY_TYPE_LAST, "NICE_PROXY_TYPE_LAST", "last" },
  74       { 0, NULL, NULL }
  75     };
  76     type = g_enum_register_static ("NiceProxyType", values);
  77   }
  78   return type;
  79 }
  80 GType
  81 nice_nomination_mode_get_type (void)
  82 {
  83   static GType type = 0;
  84   if (!type) {
  85     static const GEnumValue values[] = {
  86       { NICE_NOMINATION_MODE_REGULAR, "NICE_NOMINATION_MODE_REGULAR", "regular" },
  87       { NICE_NOMINATION_MODE_AGGRESSIVE, "NICE_NOMINATION_MODE_AGGRESSIVE", "aggressive" },
  88       { 0, NULL, NULL }
  89     };
  90     type = g_enum_register_static ("NiceNominationMode", values);
  91   }
  92   return type;
  93 }
  94 GType
  95 nice_agent_option_get_type (void)
  96 {
  97   static GType type = 0;
  98   if (!type) {
  99     static const GFlagsValue values[] = {
 100       { NICE_AGENT_OPTION_REGULAR_NOMINATION, "NICE_AGENT_OPTION_REGULAR_NOMINATION", "regular-nomination" },
 101       { NICE_AGENT_OPTION_RELIABLE, "NICE_AGENT_OPTION_RELIABLE", "reliable" },
 102       { NICE_AGENT_OPTION_LITE_MODE, "NICE_AGENT_OPTION_LITE_MODE", "lite-mode" },
 103       { NICE_AGENT_OPTION_ICE_TRICKLE, "NICE_AGENT_OPTION_ICE_TRICKLE", "ice-trickle" },
 104       { NICE_AGENT_OPTION_SUPPORT_RENOMINATION, "NICE_AGENT_OPTION_SUPPORT_RENOMINATION", "support-renomination" },
 105       { 0, NULL, NULL }
 106     };
 107     type = g_flags_register_static ("NiceAgentOption", values);
 108   }
 109   return type;
 110 }
 111
 112 /* enumerations from "./candidate.h" */
 113 GType
 114 nice_candidate_type_get_type (void)
 115 {
 116   static GType type = 0;
 117   if (!type) {
 118     static const GEnumValue values[] = {
 119       { NICE_CANDIDATE_TYPE_HOST, "NICE_CANDIDATE_TYPE_HOST", "host" },
 120       { NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE, "NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE", "server-reflexive" },
 121       { NICE_CANDIDATE_TYPE_PEER_REFLEXIVE, "NICE_CANDIDATE_TYPE_PEER_REFLEXIVE", "peer-reflexive" },
 122       { NICE_CANDIDATE_TYPE_RELAYED, "NICE_CANDIDATE_TYPE_RELAYED", "relayed" },
 123       { 0, NULL, NULL }
 124     };
 125     type = g_enum_register_static ("NiceCandidateType", values);
 126   }
 127   return type;
 128 }
 129 GType
 130 nice_candidate_transport_get_type (void)
 131 {
 132   static GType type = 0;
 133   if (!type) {
 134     static const GEnumValue values[] = {
 135       { NICE_CANDIDATE_TRANSPORT_UDP, "NICE_CANDIDATE_TRANSPORT_UDP", "udp" },
 136       { NICE_CANDIDATE_TRANSPORT_TCP_ACTIVE, "NICE_CANDIDATE_TRANSPORT_TCP_ACTIVE", "tcp-active" },
 137       { NICE_CANDIDATE_TRANSPORT_TCP_PASSIVE, "NICE_CANDIDATE_TRANSPORT_TCP_PASSIVE", "tcp-passive" },
 138       { NICE_CANDIDATE_TRANSPORT_TCP_SO, "NICE_CANDIDATE_TRANSPORT_TCP_SO", "tcp-so" },
 139       { 0, NULL, NULL }
 140     };
 141     type = g_enum_register_static ("NiceCandidateTransport", values);
 142   }
 143   return type;
 144 }
 145 GType
 146 nice_relay_type_get_type (void)
 147 {
 148   static GType type = 0;
 149   if (!type) {
 150     static const GEnumValue values[] = {
 151       { NICE_RELAY_TYPE_TURN_UDP, "NICE_RELAY_TYPE_TURN_UDP", "udp" },
 152       { NICE_RELAY_TYPE_TURN_TCP, "NICE_RELAY_TYPE_TURN_TCP", "tcp" },
 153       { NICE_RELAY_TYPE_TURN_TLS, "NICE_RELAY_TYPE_TURN_TLS", "tls" },
 154       { 0, NULL, NULL }
 155     };
 156     type = g_enum_register_static ("NiceRelayType", values);
 157   }
 158   return type;
 159 }
 160
 161 /* enumerations from "./pseudotcp.h" */
 162 GType
 163 pseudo_tcp_debug_level_get_type (void)
 164 {
 165   static GType type = 0;
 166   if (!type) {
 167     static const GEnumValue values[] = {
 168       { PSEUDO_TCP_DEBUG_NONE, "PSEUDO_TCP_DEBUG_NONE", "none" },
 169       { PSEUDO_TCP_DEBUG_NORMAL, "PSEUDO_TCP_DEBUG_NORMAL", "normal" },
 170       { PSEUDO_TCP_DEBUG_VERBOSE, "PSEUDO_TCP_DEBUG_VERBOSE", "verbose" },
 171       { 0, NULL, NULL }
 172     };
 173     type = g_enum_register_static ("PseudoTcpDebugLevel", values);
 174   }
 175   return type;
 176 }
 177 GType
 178 pseudo_tcp_state_get_type (void)
 179 {
 180   static GType type = 0;
 181   if (!type) {
 182     static const GEnumValue values[] = {
 183       { PSEUDO_TCP_LISTEN, "PSEUDO_TCP_LISTEN", "listen" },
 184       { PSEUDO_TCP_SYN_SENT, "PSEUDO_TCP_SYN_SENT", "syn-sent" },
 185       { PSEUDO_TCP_SYN_RECEIVED, "PSEUDO_TCP_SYN_RECEIVED", "syn-received" },
 186       { PSEUDO_TCP_ESTABLISHED, "PSEUDO_TCP_ESTABLISHED", "established" },
 187       { PSEUDO_TCP_CLOSED, "PSEUDO_TCP_CLOSED", "closed" },
 188       { PSEUDO_TCP_FIN_WAIT_1, "PSEUDO_TCP_FIN_WAIT_1", "fin-wait-1" },
 189       { PSEUDO_TCP_FIN_WAIT_2, "PSEUDO_TCP_FIN_WAIT_2", "fin-wait-2" },
 190       { PSEUDO_TCP_CLOSING, "PSEUDO_TCP_CLOSING", "closing" },
 191       { PSEUDO_TCP_TIME_WAIT, "PSEUDO_TCP_TIME_WAIT", "time-wait" },
 192       { PSEUDO_TCP_CLOSE_WAIT, "PSEUDO_TCP_CLOSE_WAIT", "close-wait" },
 193       { PSEUDO_TCP_LAST_ACK, "PSEUDO_TCP_LAST_ACK", "last-ack" },
 194       { 0, NULL, NULL }
 195     };
 196     type = g_enum_register_static ("PseudoTcpState", values);
 197   }
 198   return type;
 199 }
 200 GType
 201 pseudo_tcp_write_result_get_type (void)
 202 {
 203   static GType type = 0;
 204   if (!type) {
 205     static const GEnumValue values[] = {
 206       { WR_SUCCESS, "WR_SUCCESS", "success" },
 207       { WR_TOO_LARGE, "WR_TOO_LARGE", "too-large" },
 208       { WR_FAIL, "WR_FAIL", "fail" },
 209       { 0, NULL, NULL }
 210     };
 211     type = g_enum_register_static ("PseudoTcpWriteResult", values);
 212   }
 213   return type;
 214 }
 215 GType
 216 pseudo_tcp_shutdown_get_type (void)
 217 {
 218   static GType type = 0;
 219   if (!type) {
 220     static const GEnumValue values[] = {
 221       { PSEUDO_TCP_SHUTDOWN_RD, "PSEUDO_TCP_SHUTDOWN_RD", "rd" },
 222       { PSEUDO_TCP_SHUTDOWN_WR, "PSEUDO_TCP_SHUTDOWN_WR", "wr" },
 223       { PSEUDO_TCP_SHUTDOWN_RDWR, "PSEUDO_TCP_SHUTDOWN_RDWR", "rdwr" },
 224       { 0, NULL, NULL }
 225     };
 226     type = g_enum_register_static ("PseudoTcpShutdown", values);
 227   }
 228   return type;
 229 }
 230
 231 /* Generated data ends here */
 232