libsoup/soup-enum-types.c

   1
   2
   3
   4 /* Generated by glib-mkenums. Do not edit */
   5
   6 #include "soup-enum-types.h"
   7 #define LIBSOUP_USE_UNSTABLE_REQUEST_API
   8 #include "soup.h"
   9 #include "soup-address.h"
  10 #include "soup-auth.h"
  11 #include "soup-auth-domain.h"
  12 #include "soup-auth-domain-basic.h"
  13 #include "soup-auth-domain-digest.h"
  14 #include "soup-auth-manager.h"
  15 #include "soup-cache.h"
  16 #include "soup-content-decoder.h"
  17 #include "soup-content-sniffer.h"
  18 #include "soup-cookie.h"
  19 #include "soup-cookie-jar.h"
  20 #include "soup-cookie-jar-db.h"
  21 #include "soup-cookie-jar-text.h"
  22 #include "soup-date.h"
  23 #include "soup-form.h"
  24 #include "soup-headers.h"
  25 #include "soup-logger.h"
  26 #include "soup-message.h"
  27 #include "soup-message-body.h"
  28 #include "soup-message-headers.h"
  29 #include "soup-method.h"
  30 #include "soup-misc.h"
  31 #include "soup-multipart.h"
  32 #include "soup-multipart-input-stream.h"
  33 #include "soup-password-manager.h"
  34 #include "soup-portability.h"
  35 #include "soup-proxy-resolver.h"
  36 #include "soup-proxy-resolver-default.h"
  37 #include "soup-proxy-uri-resolver.h"
  38 #include "soup-request.h"
  39 #include "soup-request-data.h"
  40 #include "soup-request-file.h"
  41 #include "soup-request-http.h"
  42 #include "soup-requester.h"
  43 #include "soup-server.h"
  44 #include "soup-session.h"
  45 #include "soup-session-async.h"
  46 #include "soup-session-feature.h"
  47 #include "soup-session-sync.h"
  48 #include "soup-socket.h"
  49 #include "soup-status.h"
  50 #include "soup-tld.h"
  51 #include "soup-types.h"
  52 #include "soup-uri.h"
  53 #include "soup-value-utils.h"
  54 #include "soup-xmlrpc.h"
  55 #include "soup-cookie-jar-sqlite.h"
  56 #include "soup-gnome.h"
  57 #include "soup-gnome-features.h"
  58
  59 GType
  60 soup_address_family_get_type (void)
  61 {
  62   static volatile gsize g_define_type_id__volatile = 0;
  63
  64   if (g_once_init_enter (&g_define_type_id__volatile))
  65     {
  66       static const GEnumValue values[] = {
  67         { SOUP_ADDRESS_FAMILY_INVALID, "SOUP_ADDRESS_FAMILY_INVALID", "invalid" },
  68         { SOUP_ADDRESS_FAMILY_IPV4, "SOUP_ADDRESS_FAMILY_IPV4", "ipv4" },
  69         { SOUP_ADDRESS_FAMILY_IPV6, "SOUP_ADDRESS_FAMILY_IPV6", "ipv6" },
  70         { 0, NULL, NULL }
  71       };
  72       GType g_define_type_id =
  73         g_enum_register_static (g_intern_static_string ("SoupAddressFamily"), values);
  74       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
  75     }
  76
  77   return g_define_type_id__volatile;
  78 }
  79 GType
  80 soup_cacheability_get_type (void)
  81 {
  82   static volatile gsize g_define_type_id__volatile = 0;
  83
  84   if (g_once_init_enter (&g_define_type_id__volatile))
  85     {
  86       static const GFlagsValue values[] = {
  87         { SOUP_CACHE_CACHEABLE, "SOUP_CACHE_CACHEABLE", "cacheable" },
  88         { SOUP_CACHE_UNCACHEABLE, "SOUP_CACHE_UNCACHEABLE", "uncacheable" },
  89         { SOUP_CACHE_INVALIDATES, "SOUP_CACHE_INVALIDATES", "invalidates" },
  90         { SOUP_CACHE_VALIDATES, "SOUP_CACHE_VALIDATES", "validates" },
  91         { 0, NULL, NULL }
  92       };
  93       GType g_define_type_id =
  94         g_flags_register_static (g_intern_static_string ("SoupCacheability"), values);
  95       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
  96     }
  97
  98   return g_define_type_id__volatile;
  99 }
 100 GType
 101 soup_cache_response_get_type (void)
 102 {
 103   static volatile gsize g_define_type_id__volatile = 0;
 104
 105   if (g_once_init_enter (&g_define_type_id__volatile))
 106     {
 107       static const GEnumValue values[] = {
 108         { SOUP_CACHE_RESPONSE_FRESH, "SOUP_CACHE_RESPONSE_FRESH", "fresh" },
 109         { SOUP_CACHE_RESPONSE_NEEDS_VALIDATION, "SOUP_CACHE_RESPONSE_NEEDS_VALIDATION", "needs-validation" },
 110         { SOUP_CACHE_RESPONSE_STALE, "SOUP_CACHE_RESPONSE_STALE", "stale" },
 111         { 0, NULL, NULL }
 112       };
 113       GType g_define_type_id =
 114         g_enum_register_static (g_intern_static_string ("SoupCacheResponse"), values);
 115       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 116     }
 117
 118   return g_define_type_id__volatile;
 119 }
 120 GType
 121 soup_cache_type_get_type (void)
 122 {
 123   static volatile gsize g_define_type_id__volatile = 0;
 124
 125   if (g_once_init_enter (&g_define_type_id__volatile))
 126     {
 127       static const GEnumValue values[] = {
 128         { SOUP_CACHE_SINGLE_USER, "SOUP_CACHE_SINGLE_USER", "single-user" },
 129         { SOUP_CACHE_SHARED, "SOUP_CACHE_SHARED", "shared" },
 130         { 0, NULL, NULL }
 131       };
 132       GType g_define_type_id =
 133         g_enum_register_static (g_intern_static_string ("SoupCacheType"), values);
 134       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 135     }
 136
 137   return g_define_type_id__volatile;
 138 }
 139 GType
 140 soup_cookie_jar_accept_policy_get_type (void)
 141 {
 142   static volatile gsize g_define_type_id__volatile = 0;
 143
 144   if (g_once_init_enter (&g_define_type_id__volatile))
 145     {
 146       static const GEnumValue values[] = {
 147         { SOUP_COOKIE_JAR_ACCEPT_ALWAYS, "SOUP_COOKIE_JAR_ACCEPT_ALWAYS", "always" },
 148         { SOUP_COOKIE_JAR_ACCEPT_NEVER, "SOUP_COOKIE_JAR_ACCEPT_NEVER", "never" },
 149         { SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY, "SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY", "no-third-party" },
 150         { 0, NULL, NULL }
 151       };
 152       GType g_define_type_id =
 153         g_enum_register_static (g_intern_static_string ("SoupCookieJarAcceptPolicy"), values);
 154       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 155     }
 156
 157   return g_define_type_id__volatile;
 158 }
 159 GType
 160 soup_date_format_get_type (void)
 161 {
 162   static volatile gsize g_define_type_id__volatile = 0;
 163
 164   if (g_once_init_enter (&g_define_type_id__volatile))
 165     {
 166       static const GEnumValue values[] = {
 167         { SOUP_DATE_HTTP, "SOUP_DATE_HTTP", "http" },
 168         { SOUP_DATE_COOKIE, "SOUP_DATE_COOKIE", "cookie" },
 169         { SOUP_DATE_RFC2822, "SOUP_DATE_RFC2822", "rfc2822" },
 170         { SOUP_DATE_ISO8601_COMPACT, "SOUP_DATE_ISO8601_COMPACT", "iso8601-compact" },
 171         { SOUP_DATE_ISO8601_FULL, "SOUP_DATE_ISO8601_FULL", "iso8601-full" },
 172         { SOUP_DATE_ISO8601, "SOUP_DATE_ISO8601", "iso8601" },
 173         { SOUP_DATE_ISO8601_XMLRPC, "SOUP_DATE_ISO8601_XMLRPC", "iso8601-xmlrpc" },
 174         { 0, NULL, NULL }
 175       };
 176       GType g_define_type_id =
 177         g_enum_register_static (g_intern_static_string ("SoupDateFormat"), values);
 178       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 179     }
 180
 181   return g_define_type_id__volatile;
 182 }
 183 GType
 184 soup_logger_log_level_get_type (void)
 185 {
 186   static volatile gsize g_define_type_id__volatile = 0;
 187
 188   if (g_once_init_enter (&g_define_type_id__volatile))
 189     {
 190       static const GEnumValue values[] = {
 191         { SOUP_LOGGER_LOG_NONE, "SOUP_LOGGER_LOG_NONE", "none" },
 192         { SOUP_LOGGER_LOG_MINIMAL, "SOUP_LOGGER_LOG_MINIMAL", "minimal" },
 193         { SOUP_LOGGER_LOG_HEADERS, "SOUP_LOGGER_LOG_HEADERS", "headers" },
 194         { SOUP_LOGGER_LOG_BODY, "SOUP_LOGGER_LOG_BODY", "body" },
 195         { 0, NULL, NULL }
 196       };
 197       GType g_define_type_id =
 198         g_enum_register_static (g_intern_static_string ("SoupLoggerLogLevel"), values);
 199       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 200     }
 201
 202   return g_define_type_id__volatile;
 203 }
 204 GType
 205 soup_http_version_get_type (void)
 206 {
 207   static volatile gsize g_define_type_id__volatile = 0;
 208
 209   if (g_once_init_enter (&g_define_type_id__volatile))
 210     {
 211       static const GEnumValue values[] = {
 212         { SOUP_HTTP_1_0, "SOUP_HTTP_1_0", "http-1-0" },
 213         { SOUP_HTTP_1_1, "SOUP_HTTP_1_1", "http-1-1" },
 214         { 0, NULL, NULL }
 215       };
 216       GType g_define_type_id =
 217         g_enum_register_static (g_intern_static_string ("SoupHTTPVersion"), values);
 218       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 219     }
 220
 221   return g_define_type_id__volatile;
 222 }
 223 GType
 224 soup_message_flags_get_type (void)
 225 {
 226   static volatile gsize g_define_type_id__volatile = 0;
 227
 228   if (g_once_init_enter (&g_define_type_id__volatile))
 229     {
 230       static const GFlagsValue values[] = {
 231         { SOUP_MESSAGE_NO_REDIRECT, "SOUP_MESSAGE_NO_REDIRECT", "no-redirect" },
 232         { SOUP_MESSAGE_CAN_REBUILD, "SOUP_MESSAGE_CAN_REBUILD", "can-rebuild" },
 233         { SOUP_MESSAGE_OVERWRITE_CHUNKS, "SOUP_MESSAGE_OVERWRITE_CHUNKS", "overwrite-chunks" },
 234         { SOUP_MESSAGE_CONTENT_DECODED, "SOUP_MESSAGE_CONTENT_DECODED", "content-decoded" },
 235         { SOUP_MESSAGE_CERTIFICATE_TRUSTED, "SOUP_MESSAGE_CERTIFICATE_TRUSTED", "certificate-trusted" },
 236         { SOUP_MESSAGE_NEW_CONNECTION, "SOUP_MESSAGE_NEW_CONNECTION", "new-connection" },
 237         { SOUP_MESSAGE_IDEMPOTENT, "SOUP_MESSAGE_IDEMPOTENT", "idempotent" },
 238         { 0, NULL, NULL }
 239       };
 240       GType g_define_type_id =
 241         g_flags_register_static (g_intern_static_string ("SoupMessageFlags"), values);
 242       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 243     }
 244
 245   return g_define_type_id__volatile;
 246 }
 247 GType
 248 soup_message_priority_get_type (void)
 249 {
 250   static volatile gsize g_define_type_id__volatile = 0;
 251
 252   if (g_once_init_enter (&g_define_type_id__volatile))
 253     {
 254       static const GEnumValue values[] = {
 255         { SOUP_MESSAGE_PRIORITY_VERY_LOW, "SOUP_MESSAGE_PRIORITY_VERY_LOW", "very-low" },
 256         { SOUP_MESSAGE_PRIORITY_LOW, "SOUP_MESSAGE_PRIORITY_LOW", "low" },
 257         { SOUP_MESSAGE_PRIORITY_NORMAL, "SOUP_MESSAGE_PRIORITY_NORMAL", "normal" },
 258         { SOUP_MESSAGE_PRIORITY_HIGH, "SOUP_MESSAGE_PRIORITY_HIGH", "high" },
 259         { SOUP_MESSAGE_PRIORITY_VERY_HIGH, "SOUP_MESSAGE_PRIORITY_VERY_HIGH", "very-high" },
 260         { 0, NULL, NULL }
 261       };
 262       GType g_define_type_id =
 263         g_enum_register_static (g_intern_static_string ("SoupMessagePriority"), values);
 264       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 265     }
 266
 267   return g_define_type_id__volatile;
 268 }
 269 GType
 270 soup_memory_use_get_type (void)
 271 {
 272   static volatile gsize g_define_type_id__volatile = 0;
 273
 274   if (g_once_init_enter (&g_define_type_id__volatile))
 275     {
 276       static const GEnumValue values[] = {
 277         { SOUP_MEMORY_STATIC, "SOUP_MEMORY_STATIC", "static" },
 278         { SOUP_MEMORY_TAKE, "SOUP_MEMORY_TAKE", "take" },
 279         { SOUP_MEMORY_COPY, "SOUP_MEMORY_COPY", "copy" },
 280         { SOUP_MEMORY_TEMPORARY, "SOUP_MEMORY_TEMPORARY", "temporary" },
 281         { 0, NULL, NULL }
 282       };
 283       GType g_define_type_id =
 284         g_enum_register_static (g_intern_static_string ("SoupMemoryUse"), values);
 285       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 286     }
 287
 288   return g_define_type_id__volatile;
 289 }
 290 GType
 291 soup_message_headers_type_get_type (void)
 292 {
 293   static volatile gsize g_define_type_id__volatile = 0;
 294
 295   if (g_once_init_enter (&g_define_type_id__volatile))
 296     {
 297       static const GEnumValue values[] = {
 298         { SOUP_MESSAGE_HEADERS_REQUEST, "SOUP_MESSAGE_HEADERS_REQUEST", "request" },
 299         { SOUP_MESSAGE_HEADERS_RESPONSE, "SOUP_MESSAGE_HEADERS_RESPONSE", "response" },
 300         { SOUP_MESSAGE_HEADERS_MULTIPART, "SOUP_MESSAGE_HEADERS_MULTIPART", "multipart" },
 301         { 0, NULL, NULL }
 302       };
 303       GType g_define_type_id =
 304         g_enum_register_static (g_intern_static_string ("SoupMessageHeadersType"), values);
 305       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 306     }
 307
 308   return g_define_type_id__volatile;
 309 }
 310 GType
 311 soup_encoding_get_type (void)
 312 {
 313   static volatile gsize g_define_type_id__volatile = 0;
 314
 315   if (g_once_init_enter (&g_define_type_id__volatile))
 316     {
 317       static const GEnumValue values[] = {
 318         { SOUP_ENCODING_UNRECOGNIZED, "SOUP_ENCODING_UNRECOGNIZED", "unrecognized" },
 319         { SOUP_ENCODING_NONE, "SOUP_ENCODING_NONE", "none" },
 320         { SOUP_ENCODING_CONTENT_LENGTH, "SOUP_ENCODING_CONTENT_LENGTH", "content-length" },
 321         { SOUP_ENCODING_EOF, "SOUP_ENCODING_EOF", "eof" },
 322         { SOUP_ENCODING_CHUNKED, "SOUP_ENCODING_CHUNKED", "chunked" },
 323         { SOUP_ENCODING_BYTERANGES, "SOUP_ENCODING_BYTERANGES", "byteranges" },
 324         { 0, NULL, NULL }
 325       };
 326       GType g_define_type_id =
 327         g_enum_register_static (g_intern_static_string ("SoupEncoding"), values);
 328       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 329     }
 330
 331   return g_define_type_id__volatile;
 332 }
 333 GType
 334 soup_expectation_get_type (void)
 335 {
 336   static volatile gsize g_define_type_id__volatile = 0;
 337
 338   if (g_once_init_enter (&g_define_type_id__volatile))
 339     {
 340       static const GFlagsValue values[] = {
 341         { SOUP_EXPECTATION_UNRECOGNIZED, "SOUP_EXPECTATION_UNRECOGNIZED", "unrecognized" },
 342         { SOUP_EXPECTATION_CONTINUE, "SOUP_EXPECTATION_CONTINUE", "continue" },
 343         { 0, NULL, NULL }
 344       };
 345       GType g_define_type_id =
 346         g_flags_register_static (g_intern_static_string ("SoupExpectation"), values);
 347       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 348     }
 349
 350   return g_define_type_id__volatile;
 351 }
 352 GType
 353 soup_connection_state_get_type (void)
 354 {
 355   static volatile gsize g_define_type_id__volatile = 0;
 356
 357   if (g_once_init_enter (&g_define_type_id__volatile))
 358     {
 359       static const GEnumValue values[] = {
 360         { SOUP_CONNECTION_NEW, "SOUP_CONNECTION_NEW", "new" },
 361         { SOUP_CONNECTION_CONNECTING, "SOUP_CONNECTION_CONNECTING", "connecting" },
 362         { SOUP_CONNECTION_IDLE, "SOUP_CONNECTION_IDLE", "idle" },
 363         { SOUP_CONNECTION_IN_USE, "SOUP_CONNECTION_IN_USE", "in-use" },
 364         { SOUP_CONNECTION_REMOTE_DISCONNECTED, "SOUP_CONNECTION_REMOTE_DISCONNECTED", "remote-disconnected" },
 365         { SOUP_CONNECTION_DISCONNECTED, "SOUP_CONNECTION_DISCONNECTED", "disconnected" },
 366         { 0, NULL, NULL }
 367       };
 368       GType g_define_type_id =
 369         g_enum_register_static (g_intern_static_string ("SoupConnectionState"), values);
 370       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 371     }
 372
 373   return g_define_type_id__volatile;
 374 }
 375 GType
 376 soup_requester_error_get_type (void)
 377 {
 378   static volatile gsize g_define_type_id__volatile = 0;
 379
 380   if (g_once_init_enter (&g_define_type_id__volatile))
 381     {
 382       static const GEnumValue values[] = {
 383         { SOUP_REQUESTER_ERROR_BAD_URI, "SOUP_REQUESTER_ERROR_BAD_URI", "bad-uri" },
 384         { SOUP_REQUESTER_ERROR_UNSUPPORTED_URI_SCHEME, "SOUP_REQUESTER_ERROR_UNSUPPORTED_URI_SCHEME", "unsupported-uri-scheme" },
 385         { 0, NULL, NULL }
 386       };
 387       GType g_define_type_id =
 388         g_enum_register_static (g_intern_static_string ("SoupRequesterError"), values);
 389       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 390     }
 391
 392   return g_define_type_id__volatile;
 393 }
 394 GType
 395 soup_request_error_get_type (void)
 396 {
 397   static volatile gsize g_define_type_id__volatile = 0;
 398
 399   if (g_once_init_enter (&g_define_type_id__volatile))
 400     {
 401       static const GEnumValue values[] = {
 402         { SOUP_REQUEST_ERROR_BAD_URI, "SOUP_REQUEST_ERROR_BAD_URI", "bad-uri" },
 403         { SOUP_REQUEST_ERROR_UNSUPPORTED_URI_SCHEME, "SOUP_REQUEST_ERROR_UNSUPPORTED_URI_SCHEME", "unsupported-uri-scheme" },
 404         { SOUP_REQUEST_ERROR_PARSING, "SOUP_REQUEST_ERROR_PARSING", "parsing" },
 405         { SOUP_REQUEST_ERROR_ENCODING, "SOUP_REQUEST_ERROR_ENCODING", "encoding" },
 406         { 0, NULL, NULL }
 407       };
 408       GType g_define_type_id =
 409         g_enum_register_static (g_intern_static_string ("SoupRequestError"), values);
 410       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 411     }
 412
 413   return g_define_type_id__volatile;
 414 }
 415 GType
 416 soup_socket_io_status_get_type (void)
 417 {
 418   static volatile gsize g_define_type_id__volatile = 0;
 419
 420   if (g_once_init_enter (&g_define_type_id__volatile))
 421     {
 422       static const GEnumValue values[] = {
 423         { SOUP_SOCKET_OK, "SOUP_SOCKET_OK", "ok" },
 424         { SOUP_SOCKET_WOULD_BLOCK, "SOUP_SOCKET_WOULD_BLOCK", "would-block" },
 425         { SOUP_SOCKET_EOF, "SOUP_SOCKET_EOF", "eof" },
 426         { SOUP_SOCKET_ERROR, "SOUP_SOCKET_ERROR", "error" },
 427         { 0, NULL, NULL }
 428       };
 429       GType g_define_type_id =
 430         g_enum_register_static (g_intern_static_string ("SoupSocketIOStatus"), values);
 431       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 432     }
 433
 434   return g_define_type_id__volatile;
 435 }
 436 GType
 437 soup_status_get_type (void)
 438 {
 439   static volatile gsize g_define_type_id__volatile = 0;
 440
 441   if (g_once_init_enter (&g_define_type_id__volatile))
 442     {
 443       static const GEnumValue values[] = {
 444         { SOUP_STATUS_NONE, "SOUP_STATUS_NONE", "none" },
 445         { SOUP_STATUS_CANCELLED, "SOUP_STATUS_CANCELLED", "cancelled" },
 446         { SOUP_STATUS_CANT_RESOLVE, "SOUP_STATUS_CANT_RESOLVE", "cant-resolve" },
 447         { SOUP_STATUS_CANT_RESOLVE_PROXY, "SOUP_STATUS_CANT_RESOLVE_PROXY", "cant-resolve-proxy" },
 448         { SOUP_STATUS_CANT_CONNECT, "SOUP_STATUS_CANT_CONNECT", "cant-connect" },
 449         { SOUP_STATUS_CANT_CONNECT_PROXY, "SOUP_STATUS_CANT_CONNECT_PROXY", "cant-connect-proxy" },
 450         { SOUP_STATUS_SSL_FAILED, "SOUP_STATUS_SSL_FAILED", "ssl-failed" },
 451         { SOUP_STATUS_IO_ERROR, "SOUP_STATUS_IO_ERROR", "io-error" },
 452         { SOUP_STATUS_MALFORMED, "SOUP_STATUS_MALFORMED", "malformed" },
 453         { SOUP_STATUS_TRY_AGAIN, "SOUP_STATUS_TRY_AGAIN", "try-again" },
 454         { SOUP_STATUS_TOO_MANY_REDIRECTS, "SOUP_STATUS_TOO_MANY_REDIRECTS", "too-many-redirects" },
 455         { SOUP_STATUS_TLS_FAILED, "SOUP_STATUS_TLS_FAILED", "tls-failed" },
 456         { SOUP_STATUS_CONTINUE, "SOUP_STATUS_CONTINUE", "continue" },
 457         { SOUP_STATUS_SWITCHING_PROTOCOLS, "SOUP_STATUS_SWITCHING_PROTOCOLS", "switching-protocols" },
 458         { SOUP_STATUS_PROCESSING, "SOUP_STATUS_PROCESSING", "processing" },
 459         { SOUP_STATUS_OK, "SOUP_STATUS_OK", "ok" },
 460         { SOUP_STATUS_CREATED, "SOUP_STATUS_CREATED", "created" },
 461         { SOUP_STATUS_ACCEPTED, "SOUP_STATUS_ACCEPTED", "accepted" },
 462         { SOUP_STATUS_NON_AUTHORITATIVE, "SOUP_STATUS_NON_AUTHORITATIVE", "non-authoritative" },
 463         { SOUP_STATUS_NO_CONTENT, "SOUP_STATUS_NO_CONTENT", "no-content" },
 464         { SOUP_STATUS_RESET_CONTENT, "SOUP_STATUS_RESET_CONTENT", "reset-content" },
 465         { SOUP_STATUS_PARTIAL_CONTENT, "SOUP_STATUS_PARTIAL_CONTENT", "partial-content" },
 466         { SOUP_STATUS_MULTI_STATUS, "SOUP_STATUS_MULTI_STATUS", "multi-status" },
 467         { SOUP_STATUS_MULTIPLE_CHOICES, "SOUP_STATUS_MULTIPLE_CHOICES", "multiple-choices" },
 468         { SOUP_STATUS_MOVED_PERMANENTLY, "SOUP_STATUS_MOVED_PERMANENTLY", "moved-permanently" },
 469         { SOUP_STATUS_FOUND, "SOUP_STATUS_FOUND", "found" },
 470         { SOUP_STATUS_MOVED_TEMPORARILY, "SOUP_STATUS_MOVED_TEMPORARILY", "moved-temporarily" },
 471         { SOUP_STATUS_SEE_OTHER, "SOUP_STATUS_SEE_OTHER", "see-other" },
 472         { SOUP_STATUS_NOT_MODIFIED, "SOUP_STATUS_NOT_MODIFIED", "not-modified" },
 473         { SOUP_STATUS_USE_PROXY, "SOUP_STATUS_USE_PROXY", "use-proxy" },
 474         { SOUP_STATUS_NOT_APPEARING_IN_THIS_PROTOCOL, "SOUP_STATUS_NOT_APPEARING_IN_THIS_PROTOCOL", "not-appearing-in-this-protocol" },
 475         { SOUP_STATUS_TEMPORARY_REDIRECT, "SOUP_STATUS_TEMPORARY_REDIRECT", "temporary-redirect" },
 476         { SOUP_STATUS_BAD_REQUEST, "SOUP_STATUS_BAD_REQUEST", "bad-request" },
 477         { SOUP_STATUS_UNAUTHORIZED, "SOUP_STATUS_UNAUTHORIZED", "unauthorized" },
 478         { SOUP_STATUS_PAYMENT_REQUIRED, "SOUP_STATUS_PAYMENT_REQUIRED", "payment-required" },
 479         { SOUP_STATUS_FORBIDDEN, "SOUP_STATUS_FORBIDDEN", "forbidden" },
 480         { SOUP_STATUS_NOT_FOUND, "SOUP_STATUS_NOT_FOUND", "not-found" },
 481         { SOUP_STATUS_METHOD_NOT_ALLOWED, "SOUP_STATUS_METHOD_NOT_ALLOWED", "method-not-allowed" },
 482         { SOUP_STATUS_NOT_ACCEPTABLE, "SOUP_STATUS_NOT_ACCEPTABLE", "not-acceptable" },
 483         { SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED, "SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED", "proxy-authentication-required" },
 484         { SOUP_STATUS_PROXY_UNAUTHORIZED, "SOUP_STATUS_PROXY_UNAUTHORIZED", "proxy-unauthorized" },
 485         { SOUP_STATUS_REQUEST_TIMEOUT, "SOUP_STATUS_REQUEST_TIMEOUT", "request-timeout" },
 486         { SOUP_STATUS_CONFLICT, "SOUP_STATUS_CONFLICT", "conflict" },
 487         { SOUP_STATUS_GONE, "SOUP_STATUS_GONE", "gone" },
 488         { SOUP_STATUS_LENGTH_REQUIRED, "SOUP_STATUS_LENGTH_REQUIRED", "length-required" },
 489         { SOUP_STATUS_PRECONDITION_FAILED, "SOUP_STATUS_PRECONDITION_FAILED", "precondition-failed" },
 490         { SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE, "SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE", "request-entity-too-large" },
 491         { SOUP_STATUS_REQUEST_URI_TOO_LONG, "SOUP_STATUS_REQUEST_URI_TOO_LONG", "request-uri-too-long" },
 492         { SOUP_STATUS_UNSUPPORTED_MEDIA_TYPE, "SOUP_STATUS_UNSUPPORTED_MEDIA_TYPE", "unsupported-media-type" },
 493         { SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE, "SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE", "requested-range-not-satisfiable" },
 494         { SOUP_STATUS_INVALID_RANGE, "SOUP_STATUS_INVALID_RANGE", "invalid-range" },
 495         { SOUP_STATUS_EXPECTATION_FAILED, "SOUP_STATUS_EXPECTATION_FAILED", "expectation-failed" },
 496         { SOUP_STATUS_UNPROCESSABLE_ENTITY, "SOUP_STATUS_UNPROCESSABLE_ENTITY", "unprocessable-entity" },
 497         { SOUP_STATUS_LOCKED, "SOUP_STATUS_LOCKED", "locked" },
 498         { SOUP_STATUS_FAILED_DEPENDENCY, "SOUP_STATUS_FAILED_DEPENDENCY", "failed-dependency" },
 499         { SOUP_STATUS_INTERNAL_SERVER_ERROR, "SOUP_STATUS_INTERNAL_SERVER_ERROR", "internal-server-error" },
 500         { SOUP_STATUS_NOT_IMPLEMENTED, "SOUP_STATUS_NOT_IMPLEMENTED", "not-implemented" },
 501         { SOUP_STATUS_BAD_GATEWAY, "SOUP_STATUS_BAD_GATEWAY", "bad-gateway" },
 502         { SOUP_STATUS_SERVICE_UNAVAILABLE, "SOUP_STATUS_SERVICE_UNAVAILABLE", "service-unavailable" },
 503         { SOUP_STATUS_GATEWAY_TIMEOUT, "SOUP_STATUS_GATEWAY_TIMEOUT", "gateway-timeout" },
 504         { SOUP_STATUS_HTTP_VERSION_NOT_SUPPORTED, "SOUP_STATUS_HTTP_VERSION_NOT_SUPPORTED", "http-version-not-supported" },
 505         { SOUP_STATUS_INSUFFICIENT_STORAGE, "SOUP_STATUS_INSUFFICIENT_STORAGE", "insufficient-storage" },
 506         { SOUP_STATUS_NOT_EXTENDED, "SOUP_STATUS_NOT_EXTENDED", "not-extended" },
 507         { 0, NULL, NULL }
 508       };
 509       GType g_define_type_id =
 510         g_enum_register_static (g_intern_static_string ("SoupStatus"), values);
 511       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 512     }
 513
 514   return g_define_type_id__volatile;
 515 }
 516 GType
 517 soup_known_status_code_get_type (void)
 518 {
 519   static volatile gsize g_define_type_id__volatile = 0;
 520
 521   if (g_once_init_enter (&g_define_type_id__volatile))
 522     {
 523       static const GEnumValue values[] = {
 524         { SOUP_KNOWN_STATUS_CODE_NONE, "SOUP_KNOWN_STATUS_CODE_NONE", "none" },
 525         { SOUP_KNOWN_STATUS_CODE_CANCELLED, "SOUP_KNOWN_STATUS_CODE_CANCELLED", "cancelled" },
 526         { SOUP_KNOWN_STATUS_CODE_CANT_RESOLVE, "SOUP_KNOWN_STATUS_CODE_CANT_RESOLVE", "cant-resolve" },
 527         { SOUP_KNOWN_STATUS_CODE_CANT_RESOLVE_PROXY, "SOUP_KNOWN_STATUS_CODE_CANT_RESOLVE_PROXY", "cant-resolve-proxy" },
 528         { SOUP_KNOWN_STATUS_CODE_CANT_CONNECT, "SOUP_KNOWN_STATUS_CODE_CANT_CONNECT", "cant-connect" },
 529         { SOUP_KNOWN_STATUS_CODE_CANT_CONNECT_PROXY, "SOUP_KNOWN_STATUS_CODE_CANT_CONNECT_PROXY", "cant-connect-proxy" },
 530         { SOUP_KNOWN_STATUS_CODE_SSL_FAILED, "SOUP_KNOWN_STATUS_CODE_SSL_FAILED", "ssl-failed" },
 531         { SOUP_KNOWN_STATUS_CODE_IO_ERROR, "SOUP_KNOWN_STATUS_CODE_IO_ERROR", "io-error" },
 532         { SOUP_KNOWN_STATUS_CODE_MALFORMED, "SOUP_KNOWN_STATUS_CODE_MALFORMED", "malformed" },
 533         { SOUP_KNOWN_STATUS_CODE_TRY_AGAIN, "SOUP_KNOWN_STATUS_CODE_TRY_AGAIN", "try-again" },
 534         { SOUP_KNOWN_STATUS_CODE_TOO_MANY_REDIRECTS, "SOUP_KNOWN_STATUS_CODE_TOO_MANY_REDIRECTS", "too-many-redirects" },
 535         { SOUP_KNOWN_STATUS_CODE_TLS_FAILED, "SOUP_KNOWN_STATUS_CODE_TLS_FAILED", "tls-failed" },
 536         { SOUP_KNOWN_STATUS_CODE_CONTINUE, "SOUP_KNOWN_STATUS_CODE_CONTINUE", "continue" },
 537         { SOUP_KNOWN_STATUS_CODE_SWITCHING_PROTOCOLS, "SOUP_KNOWN_STATUS_CODE_SWITCHING_PROTOCOLS", "switching-protocols" },
 538         { SOUP_KNOWN_STATUS_CODE_PROCESSING, "SOUP_KNOWN_STATUS_CODE_PROCESSING", "processing" },
 539         { SOUP_KNOWN_STATUS_CODE_OK, "SOUP_KNOWN_STATUS_CODE_OK", "ok" },
 540         { SOUP_KNOWN_STATUS_CODE_CREATED, "SOUP_KNOWN_STATUS_CODE_CREATED", "created" },
 541         { SOUP_KNOWN_STATUS_CODE_ACCEPTED, "SOUP_KNOWN_STATUS_CODE_ACCEPTED", "accepted" },
 542         { SOUP_KNOWN_STATUS_CODE_NON_AUTHORITATIVE, "SOUP_KNOWN_STATUS_CODE_NON_AUTHORITATIVE", "non-authoritative" },
 543         { SOUP_KNOWN_STATUS_CODE_NO_CONTENT, "SOUP_KNOWN_STATUS_CODE_NO_CONTENT", "no-content" },
 544         { SOUP_KNOWN_STATUS_CODE_RESET_CONTENT, "SOUP_KNOWN_STATUS_CODE_RESET_CONTENT", "reset-content" },
 545         { SOUP_KNOWN_STATUS_CODE_PARTIAL_CONTENT, "SOUP_KNOWN_STATUS_CODE_PARTIAL_CONTENT", "partial-content" },
 546         { SOUP_KNOWN_STATUS_CODE_MULTI_STATUS, "SOUP_KNOWN_STATUS_CODE_MULTI_STATUS", "multi-status" },
 547         { SOUP_KNOWN_STATUS_CODE_MULTIPLE_CHOICES, "SOUP_KNOWN_STATUS_CODE_MULTIPLE_CHOICES", "multiple-choices" },
 548         { SOUP_KNOWN_STATUS_CODE_MOVED_PERMANENTLY, "SOUP_KNOWN_STATUS_CODE_MOVED_PERMANENTLY", "moved-permanently" },
 549         { SOUP_KNOWN_STATUS_CODE_FOUND, "SOUP_KNOWN_STATUS_CODE_FOUND", "found" },
 550         { SOUP_KNOWN_STATUS_CODE_MOVED_TEMPORARILY, "SOUP_KNOWN_STATUS_CODE_MOVED_TEMPORARILY", "moved-temporarily" },
 551         { SOUP_KNOWN_STATUS_CODE_SEE_OTHER, "SOUP_KNOWN_STATUS_CODE_SEE_OTHER", "see-other" },
 552         { SOUP_KNOWN_STATUS_CODE_NOT_MODIFIED, "SOUP_KNOWN_STATUS_CODE_NOT_MODIFIED", "not-modified" },
 553         { SOUP_KNOWN_STATUS_CODE_USE_PROXY, "SOUP_KNOWN_STATUS_CODE_USE_PROXY", "use-proxy" },
 554         { SOUP_KNOWN_STATUS_CODE_NOT_APPEARING_IN_THIS_PROTOCOL, "SOUP_KNOWN_STATUS_CODE_NOT_APPEARING_IN_THIS_PROTOCOL", "not-appearing-in-this-protocol" },
 555         { SOUP_KNOWN_STATUS_CODE_TEMPORARY_REDIRECT, "SOUP_KNOWN_STATUS_CODE_TEMPORARY_REDIRECT", "temporary-redirect" },
 556         { SOUP_KNOWN_STATUS_CODE_BAD_REQUEST, "SOUP_KNOWN_STATUS_CODE_BAD_REQUEST", "bad-request" },
 557         { SOUP_KNOWN_STATUS_CODE_UNAUTHORIZED, "SOUP_KNOWN_STATUS_CODE_UNAUTHORIZED", "unauthorized" },
 558         { SOUP_KNOWN_STATUS_CODE_PAYMENT_REQUIRED, "SOUP_KNOWN_STATUS_CODE_PAYMENT_REQUIRED", "payment-required" },
 559         { SOUP_KNOWN_STATUS_CODE_FORBIDDEN, "SOUP_KNOWN_STATUS_CODE_FORBIDDEN", "forbidden" },
 560         { SOUP_KNOWN_STATUS_CODE_NOT_FOUND, "SOUP_KNOWN_STATUS_CODE_NOT_FOUND", "not-found" },
 561         { SOUP_KNOWN_STATUS_CODE_METHOD_NOT_ALLOWED, "SOUP_KNOWN_STATUS_CODE_METHOD_NOT_ALLOWED", "method-not-allowed" },
 562         { SOUP_KNOWN_STATUS_CODE_NOT_ACCEPTABLE, "SOUP_KNOWN_STATUS_CODE_NOT_ACCEPTABLE", "not-acceptable" },
 563         { SOUP_KNOWN_STATUS_CODE_PROXY_AUTHENTICATION_REQUIRED, "SOUP_KNOWN_STATUS_CODE_PROXY_AUTHENTICATION_REQUIRED", "proxy-authentication-required" },
 564         { SOUP_KNOWN_STATUS_CODE_PROXY_UNAUTHORIZED, "SOUP_KNOWN_STATUS_CODE_PROXY_UNAUTHORIZED", "proxy-unauthorized" },
 565         { SOUP_KNOWN_STATUS_CODE_REQUEST_TIMEOUT, "SOUP_KNOWN_STATUS_CODE_REQUEST_TIMEOUT", "request-timeout" },
 566         { SOUP_KNOWN_STATUS_CODE_CONFLICT, "SOUP_KNOWN_STATUS_CODE_CONFLICT", "conflict" },
 567         { SOUP_KNOWN_STATUS_CODE_GONE, "SOUP_KNOWN_STATUS_CODE_GONE", "gone" },
 568         { SOUP_KNOWN_STATUS_CODE_LENGTH_REQUIRED, "SOUP_KNOWN_STATUS_CODE_LENGTH_REQUIRED", "length-required" },
 569         { SOUP_KNOWN_STATUS_CODE_PRECONDITION_FAILED, "SOUP_KNOWN_STATUS_CODE_PRECONDITION_FAILED", "precondition-failed" },
 570         { SOUP_KNOWN_STATUS_CODE_REQUEST_ENTITY_TOO_LARGE, "SOUP_KNOWN_STATUS_CODE_REQUEST_ENTITY_TOO_LARGE", "request-entity-too-large" },
 571         { SOUP_KNOWN_STATUS_CODE_REQUEST_URI_TOO_LONG, "SOUP_KNOWN_STATUS_CODE_REQUEST_URI_TOO_LONG", "request-uri-too-long" },
 572         { SOUP_KNOWN_STATUS_CODE_UNSUPPORTED_MEDIA_TYPE, "SOUP_KNOWN_STATUS_CODE_UNSUPPORTED_MEDIA_TYPE", "unsupported-media-type" },
 573         { SOUP_KNOWN_STATUS_CODE_REQUESTED_RANGE_NOT_SATISFIABLE, "SOUP_KNOWN_STATUS_CODE_REQUESTED_RANGE_NOT_SATISFIABLE", "requested-range-not-satisfiable" },
 574         { SOUP_KNOWN_STATUS_CODE_INVALID_RANGE, "SOUP_KNOWN_STATUS_CODE_INVALID_RANGE", "invalid-range" },
 575         { SOUP_KNOWN_STATUS_CODE_EXPECTATION_FAILED, "SOUP_KNOWN_STATUS_CODE_EXPECTATION_FAILED", "expectation-failed" },
 576         { SOUP_KNOWN_STATUS_CODE_UNPROCESSABLE_ENTITY, "SOUP_KNOWN_STATUS_CODE_UNPROCESSABLE_ENTITY", "unprocessable-entity" },
 577         { SOUP_KNOWN_STATUS_CODE_LOCKED, "SOUP_KNOWN_STATUS_CODE_LOCKED", "locked" },
 578         { SOUP_KNOWN_STATUS_CODE_FAILED_DEPENDENCY, "SOUP_KNOWN_STATUS_CODE_FAILED_DEPENDENCY", "failed-dependency" },
 579         { SOUP_KNOWN_STATUS_CODE_INTERNAL_SERVER_ERROR, "SOUP_KNOWN_STATUS_CODE_INTERNAL_SERVER_ERROR", "internal-server-error" },
 580         { SOUP_KNOWN_STATUS_CODE_NOT_IMPLEMENTED, "SOUP_KNOWN_STATUS_CODE_NOT_IMPLEMENTED", "not-implemented" },
 581         { SOUP_KNOWN_STATUS_CODE_BAD_GATEWAY, "SOUP_KNOWN_STATUS_CODE_BAD_GATEWAY", "bad-gateway" },
 582         { SOUP_KNOWN_STATUS_CODE_SERVICE_UNAVAILABLE, "SOUP_KNOWN_STATUS_CODE_SERVICE_UNAVAILABLE", "service-unavailable" },
 583         { SOUP_KNOWN_STATUS_CODE_GATEWAY_TIMEOUT, "SOUP_KNOWN_STATUS_CODE_GATEWAY_TIMEOUT", "gateway-timeout" },
 584         { SOUP_KNOWN_STATUS_CODE_HTTP_VERSION_NOT_SUPPORTED, "SOUP_KNOWN_STATUS_CODE_HTTP_VERSION_NOT_SUPPORTED", "http-version-not-supported" },
 585         { SOUP_KNOWN_STATUS_CODE_INSUFFICIENT_STORAGE, "SOUP_KNOWN_STATUS_CODE_INSUFFICIENT_STORAGE", "insufficient-storage" },
 586         { SOUP_KNOWN_STATUS_CODE_NOT_EXTENDED, "SOUP_KNOWN_STATUS_CODE_NOT_EXTENDED", "not-extended" },
 587         { 0, NULL, NULL }
 588       };
 589       GType g_define_type_id =
 590         g_enum_register_static (g_intern_static_string ("SoupKnownStatusCode"), values);
 591       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 592     }
 593
 594   return g_define_type_id__volatile;
 595 }
 596 GType
 597 soup_tld_error_get_type (void)
 598 {
 599   static volatile gsize g_define_type_id__volatile = 0;
 600
 601   if (g_once_init_enter (&g_define_type_id__volatile))
 602     {
 603       static const GEnumValue values[] = {
 604         { SOUP_TLD_ERROR_INVALID_HOSTNAME, "SOUP_TLD_ERROR_INVALID_HOSTNAME", "invalid-hostname" },
 605         { SOUP_TLD_ERROR_IS_IP_ADDRESS, "SOUP_TLD_ERROR_IS_IP_ADDRESS", "is-ip-address" },
 606         { SOUP_TLD_ERROR_NOT_ENOUGH_DOMAINS, "SOUP_TLD_ERROR_NOT_ENOUGH_DOMAINS", "not-enough-domains" },
 607         { SOUP_TLD_ERROR_NO_BASE_DOMAIN, "SOUP_TLD_ERROR_NO_BASE_DOMAIN", "no-base-domain" },
 608         { 0, NULL, NULL }
 609       };
 610       GType g_define_type_id =
 611         g_enum_register_static (g_intern_static_string ("SoupTLDError"), values);
 612       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 613     }
 614
 615   return g_define_type_id__volatile;
 616 }
 617 GType
 618 soup_xmlrpc_error_get_type (void)
 619 {
 620   static volatile gsize g_define_type_id__volatile = 0;
 621
 622   if (g_once_init_enter (&g_define_type_id__volatile))
 623     {
 624       static const GEnumValue values[] = {
 625         { SOUP_XMLRPC_ERROR_ARGUMENTS, "SOUP_XMLRPC_ERROR_ARGUMENTS", "arguments" },
 626         { SOUP_XMLRPC_ERROR_RETVAL, "SOUP_XMLRPC_ERROR_RETVAL", "retval" },
 627         { 0, NULL, NULL }
 628       };
 629       GType g_define_type_id =
 630         g_enum_register_static (g_intern_static_string ("SoupXMLRPCError"), values);
 631       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 632     }
 633
 634   return g_define_type_id__volatile;
 635 }
 636 GType
 637 soup_xmlrpc_fault_get_type (void)
 638 {
 639   static volatile gsize g_define_type_id__volatile = 0;
 640
 641   if (g_once_init_enter (&g_define_type_id__volatile))
 642     {
 643       static const GEnumValue values[] = {
 644         { SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED, "SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED", "parse-error-not-well-formed" },
 645         { SOUP_XMLRPC_FAULT_PARSE_ERROR_UNSUPPORTED_ENCODING, "SOUP_XMLRPC_FAULT_PARSE_ERROR_UNSUPPORTED_ENCODING", "parse-error-unsupported-encoding" },
 646         { SOUP_XMLRPC_FAULT_PARSE_ERROR_INVALID_CHARACTER_FOR_ENCODING, "SOUP_XMLRPC_FAULT_PARSE_ERROR_INVALID_CHARACTER_FOR_ENCODING", "parse-error-invalid-character-for-encoding" },
 647         { SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_XML_RPC, "SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_XML_RPC", "server-error-invalid-xml-rpc" },
 648         { SOUP_XMLRPC_FAULT_SERVER_ERROR_REQUESTED_METHOD_NOT_FOUND, "SOUP_XMLRPC_FAULT_SERVER_ERROR_REQUESTED_METHOD_NOT_FOUND", "server-error-requested-method-not-found" },
 649         { SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_METHOD_PARAMETERS, "SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_METHOD_PARAMETERS", "server-error-invalid-method-parameters" },
 650         { SOUP_XMLRPC_FAULT_SERVER_ERROR_INTERNAL_XML_RPC_ERROR, "SOUP_XMLRPC_FAULT_SERVER_ERROR_INTERNAL_XML_RPC_ERROR", "server-error-internal-xml-rpc-error" },
 651         { SOUP_XMLRPC_FAULT_APPLICATION_ERROR, "SOUP_XMLRPC_FAULT_APPLICATION_ERROR", "application-error" },
 652         { SOUP_XMLRPC_FAULT_SYSTEM_ERROR, "SOUP_XMLRPC_FAULT_SYSTEM_ERROR", "system-error" },
 653         { SOUP_XMLRPC_FAULT_TRANSPORT_ERROR, "SOUP_XMLRPC_FAULT_TRANSPORT_ERROR", "transport-error" },
 654         { 0, NULL, NULL }
 655       };
 656       GType g_define_type_id =
 657         g_enum_register_static (g_intern_static_string ("SoupXMLRPCFault"), values);
 658       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 659     }
 660
 661   return g_define_type_id__volatile;
 662 }
 663
 664
 665