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-cache.h"
  15 #include "soup-content-decoder.h"
  16 #include "soup-content-sniffer.h"
  17 #include "soup-cookie.h"
  18 #include "soup-cookie-jar.h"
  19 #include "soup-cookie-jar-text.h"
  20 #include "soup-date.h"
  21 #include "soup-form.h"
  22 #include "soup-headers.h"
  23 #include "soup-logger.h"
  24 #include "soup-message.h"
  25 #include "soup-message-body.h"
  26 #include "soup-message-headers.h"
  27 #include "soup-method.h"
  28 #include "soup-misc.h"
  29 #include "soup-multipart.h"
  30 #include "soup-password-manager.h"
  31 #include "soup-portability.h"
  32 #include "soup-proxy-resolver.h"
  33 #include "soup-proxy-resolver-default.h"
  34 #include "soup-proxy-uri-resolver.h"
  35 #include "soup-request.h"
  36 #include "soup-request-data.h"
  37 #include "soup-request-file.h"
  38 #include "soup-request-http.h"
  39 #include "soup-requester.h"
  40 #include "soup-server.h"
  41 #include "soup-session.h"
  42 #include "soup-session-async.h"
  43 #include "soup-session-feature.h"
  44 #include "soup-session-sync.h"
  45 #include "soup-socket.h"
  46 #include "soup-status.h"
  47 #include "soup-types.h"
  48 #include "soup-uri.h"
  49 #include "soup-value-utils.h"
  50 #include "soup-xmlrpc.h"
  51 #include "soup-cookie-jar-sqlite.h"
  52 #include "soup-gnome.h"
  53 #include "soup-gnome-features.h"
  54
  55 GType
  56 soup_address_family_get_type (void)
  57 {
  58   static volatile gsize g_define_type_id__volatile = 0;
  59
  60   if (g_once_init_enter (&g_define_type_id__volatile))
  61     {
  62       static const GEnumValue values[] = {
  63         { SOUP_ADDRESS_FAMILY_INVALID, "SOUP_ADDRESS_FAMILY_INVALID", "invalid" },
  64         { SOUP_ADDRESS_FAMILY_IPV4, "SOUP_ADDRESS_FAMILY_IPV4", "ipv4" },
  65         { SOUP_ADDRESS_FAMILY_IPV6, "SOUP_ADDRESS_FAMILY_IPV6", "ipv6" },
  66         { 0, NULL, NULL }
  67       };
  68       GType g_define_type_id =
  69         g_enum_register_static (g_intern_static_string ("SoupAddressFamily"), values);
  70       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
  71     }
  72
  73   return g_define_type_id__volatile;
  74 }
  75 GType
  76 soup_cacheability_get_type (void)
  77 {
  78   static volatile gsize g_define_type_id__volatile = 0;
  79
  80   if (g_once_init_enter (&g_define_type_id__volatile))
  81     {
  82       static const GFlagsValue values[] = {
  83         { SOUP_CACHE_CACHEABLE, "SOUP_CACHE_CACHEABLE", "cacheable" },
  84         { SOUP_CACHE_UNCACHEABLE, "SOUP_CACHE_UNCACHEABLE", "uncacheable" },
  85         { SOUP_CACHE_INVALIDATES, "SOUP_CACHE_INVALIDATES", "invalidates" },
  86         { SOUP_CACHE_VALIDATES, "SOUP_CACHE_VALIDATES", "validates" },
  87         { 0, NULL, NULL }
  88       };
  89       GType g_define_type_id =
  90         g_flags_register_static (g_intern_static_string ("SoupCacheability"), values);
  91       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
  92     }
  93
  94   return g_define_type_id__volatile;
  95 }
  96 GType
  97 soup_cache_response_get_type (void)
  98 {
  99   static volatile gsize g_define_type_id__volatile = 0;
 100
 101   if (g_once_init_enter (&g_define_type_id__volatile))
 102     {
 103       static const GEnumValue values[] = {
 104         { SOUP_CACHE_RESPONSE_FRESH, "SOUP_CACHE_RESPONSE_FRESH", "fresh" },
 105         { SOUP_CACHE_RESPONSE_NEEDS_VALIDATION, "SOUP_CACHE_RESPONSE_NEEDS_VALIDATION", "needs-validation" },
 106         { SOUP_CACHE_RESPONSE_STALE, "SOUP_CACHE_RESPONSE_STALE", "stale" },
 107         { 0, NULL, NULL }
 108       };
 109       GType g_define_type_id =
 110         g_enum_register_static (g_intern_static_string ("SoupCacheResponse"), values);
 111       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 112     }
 113
 114   return g_define_type_id__volatile;
 115 }
 116 GType
 117 soup_cache_type_get_type (void)
 118 {
 119   static volatile gsize g_define_type_id__volatile = 0;
 120
 121   if (g_once_init_enter (&g_define_type_id__volatile))
 122     {
 123       static const GEnumValue values[] = {
 124         { SOUP_CACHE_SINGLE_USER, "SOUP_CACHE_SINGLE_USER", "single-user" },
 125         { SOUP_CACHE_SHARED, "SOUP_CACHE_SHARED", "shared" },
 126         { 0, NULL, NULL }
 127       };
 128       GType g_define_type_id =
 129         g_enum_register_static (g_intern_static_string ("SoupCacheType"), values);
 130       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 131     }
 132
 133   return g_define_type_id__volatile;
 134 }
 135 GType
 136 soup_cookie_jar_accept_policy_get_type (void)
 137 {
 138   static volatile gsize g_define_type_id__volatile = 0;
 139
 140   if (g_once_init_enter (&g_define_type_id__volatile))
 141     {
 142       static const GEnumValue values[] = {
 143         { SOUP_COOKIE_JAR_ACCEPT_ALWAYS, "SOUP_COOKIE_JAR_ACCEPT_ALWAYS", "always" },
 144         { SOUP_COOKIE_JAR_ACCEPT_NEVER, "SOUP_COOKIE_JAR_ACCEPT_NEVER", "never" },
 145         { SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY, "SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY", "no-third-party" },
 146         { 0, NULL, NULL }
 147       };
 148       GType g_define_type_id =
 149         g_enum_register_static (g_intern_static_string ("SoupCookieJarAcceptPolicy"), values);
 150       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 151     }
 152
 153   return g_define_type_id__volatile;
 154 }
 155 GType
 156 soup_date_format_get_type (void)
 157 {
 158   static volatile gsize g_define_type_id__volatile = 0;
 159
 160   if (g_once_init_enter (&g_define_type_id__volatile))
 161     {
 162       static const GEnumValue values[] = {
 163         { SOUP_DATE_HTTP, "SOUP_DATE_HTTP", "http" },
 164         { SOUP_DATE_COOKIE, "SOUP_DATE_COOKIE", "cookie" },
 165         { SOUP_DATE_RFC2822, "SOUP_DATE_RFC2822", "rfc2822" },
 166         { SOUP_DATE_ISO8601_COMPACT, "SOUP_DATE_ISO8601_COMPACT", "iso8601-compact" },
 167         { SOUP_DATE_ISO8601_FULL, "SOUP_DATE_ISO8601_FULL", "iso8601-full" },
 168         { SOUP_DATE_ISO8601, "SOUP_DATE_ISO8601", "iso8601" },
 169         { SOUP_DATE_ISO8601_XMLRPC, "SOUP_DATE_ISO8601_XMLRPC", "iso8601-xmlrpc" },
 170         { 0, NULL, NULL }
 171       };
 172       GType g_define_type_id =
 173         g_enum_register_static (g_intern_static_string ("SoupDateFormat"), values);
 174       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 175     }
 176
 177   return g_define_type_id__volatile;
 178 }
 179 GType
 180 soup_logger_log_level_get_type (void)
 181 {
 182   static volatile gsize g_define_type_id__volatile = 0;
 183
 184   if (g_once_init_enter (&g_define_type_id__volatile))
 185     {
 186       static const GEnumValue values[] = {
 187         { SOUP_LOGGER_LOG_NONE, "SOUP_LOGGER_LOG_NONE", "none" },
 188         { SOUP_LOGGER_LOG_MINIMAL, "SOUP_LOGGER_LOG_MINIMAL", "minimal" },
 189         { SOUP_LOGGER_LOG_HEADERS, "SOUP_LOGGER_LOG_HEADERS", "headers" },
 190         { SOUP_LOGGER_LOG_BODY, "SOUP_LOGGER_LOG_BODY", "body" },
 191         { 0, NULL, NULL }
 192       };
 193       GType g_define_type_id =
 194         g_enum_register_static (g_intern_static_string ("SoupLoggerLogLevel"), values);
 195       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 196     }
 197
 198   return g_define_type_id__volatile;
 199 }
 200 GType
 201 soup_http_version_get_type (void)
 202 {
 203   static volatile gsize g_define_type_id__volatile = 0;
 204
 205   if (g_once_init_enter (&g_define_type_id__volatile))
 206     {
 207       static const GEnumValue values[] = {
 208         { SOUP_HTTP_1_0, "SOUP_HTTP_1_0", "http-1-0" },
 209         { SOUP_HTTP_1_1, "SOUP_HTTP_1_1", "http-1-1" },
 210         { 0, NULL, NULL }
 211       };
 212       GType g_define_type_id =
 213         g_enum_register_static (g_intern_static_string ("SoupHTTPVersion"), values);
 214       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 215     }
 216
 217   return g_define_type_id__volatile;
 218 }
 219 GType
 220 soup_message_flags_get_type (void)
 221 {
 222   static volatile gsize g_define_type_id__volatile = 0;
 223
 224   if (g_once_init_enter (&g_define_type_id__volatile))
 225     {
 226       static const GFlagsValue values[] = {
 227         { SOUP_MESSAGE_NO_REDIRECT, "SOUP_MESSAGE_NO_REDIRECT", "no-redirect" },
 228         { SOUP_MESSAGE_CAN_REBUILD, "SOUP_MESSAGE_CAN_REBUILD", "can-rebuild" },
 229         { SOUP_MESSAGE_OVERWRITE_CHUNKS, "SOUP_MESSAGE_OVERWRITE_CHUNKS", "overwrite-chunks" },
 230         { SOUP_MESSAGE_CONTENT_DECODED, "SOUP_MESSAGE_CONTENT_DECODED", "content-decoded" },
 231         { SOUP_MESSAGE_CERTIFICATE_TRUSTED, "SOUP_MESSAGE_CERTIFICATE_TRUSTED", "certificate-trusted" },
 232         { SOUP_MESSAGE_NEW_CONNECTION, "SOUP_MESSAGE_NEW_CONNECTION", "new-connection" },
 233         { 0, NULL, NULL }
 234       };
 235       GType g_define_type_id =
 236         g_flags_register_static (g_intern_static_string ("SoupMessageFlags"), values);
 237       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 238     }
 239
 240   return g_define_type_id__volatile;
 241 }
 242 GType
 243 soup_memory_use_get_type (void)
 244 {
 245   static volatile gsize g_define_type_id__volatile = 0;
 246
 247   if (g_once_init_enter (&g_define_type_id__volatile))
 248     {
 249       static const GEnumValue values[] = {
 250         { SOUP_MEMORY_STATIC, "SOUP_MEMORY_STATIC", "static" },
 251         { SOUP_MEMORY_TAKE, "SOUP_MEMORY_TAKE", "take" },
 252         { SOUP_MEMORY_COPY, "SOUP_MEMORY_COPY", "copy" },
 253         { SOUP_MEMORY_TEMPORARY, "SOUP_MEMORY_TEMPORARY", "temporary" },
 254         { 0, NULL, NULL }
 255       };
 256       GType g_define_type_id =
 257         g_enum_register_static (g_intern_static_string ("SoupMemoryUse"), values);
 258       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 259     }
 260
 261   return g_define_type_id__volatile;
 262 }
 263 GType
 264 soup_message_headers_type_get_type (void)
 265 {
 266   static volatile gsize g_define_type_id__volatile = 0;
 267
 268   if (g_once_init_enter (&g_define_type_id__volatile))
 269     {
 270       static const GEnumValue values[] = {
 271         { SOUP_MESSAGE_HEADERS_REQUEST, "SOUP_MESSAGE_HEADERS_REQUEST", "request" },
 272         { SOUP_MESSAGE_HEADERS_RESPONSE, "SOUP_MESSAGE_HEADERS_RESPONSE", "response" },
 273         { SOUP_MESSAGE_HEADERS_MULTIPART, "SOUP_MESSAGE_HEADERS_MULTIPART", "multipart" },
 274         { 0, NULL, NULL }
 275       };
 276       GType g_define_type_id =
 277         g_enum_register_static (g_intern_static_string ("SoupMessageHeadersType"), values);
 278       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 279     }
 280
 281   return g_define_type_id__volatile;
 282 }
 283 GType
 284 soup_encoding_get_type (void)
 285 {
 286   static volatile gsize g_define_type_id__volatile = 0;
 287
 288   if (g_once_init_enter (&g_define_type_id__volatile))
 289     {
 290       static const GEnumValue values[] = {
 291         { SOUP_ENCODING_UNRECOGNIZED, "SOUP_ENCODING_UNRECOGNIZED", "unrecognized" },
 292         { SOUP_ENCODING_NONE, "SOUP_ENCODING_NONE", "none" },
 293         { SOUP_ENCODING_CONTENT_LENGTH, "SOUP_ENCODING_CONTENT_LENGTH", "content-length" },
 294         { SOUP_ENCODING_EOF, "SOUP_ENCODING_EOF", "eof" },
 295         { SOUP_ENCODING_CHUNKED, "SOUP_ENCODING_CHUNKED", "chunked" },
 296         { SOUP_ENCODING_BYTERANGES, "SOUP_ENCODING_BYTERANGES", "byteranges" },
 297         { 0, NULL, NULL }
 298       };
 299       GType g_define_type_id =
 300         g_enum_register_static (g_intern_static_string ("SoupEncoding"), values);
 301       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 302     }
 303
 304   return g_define_type_id__volatile;
 305 }
 306 GType
 307 soup_expectation_get_type (void)
 308 {
 309   static volatile gsize g_define_type_id__volatile = 0;
 310
 311   if (g_once_init_enter (&g_define_type_id__volatile))
 312     {
 313       static const GFlagsValue values[] = {
 314         { SOUP_EXPECTATION_UNRECOGNIZED, "SOUP_EXPECTATION_UNRECOGNIZED", "unrecognized" },
 315         { SOUP_EXPECTATION_CONTINUE, "SOUP_EXPECTATION_CONTINUE", "continue" },
 316         { 0, NULL, NULL }
 317       };
 318       GType g_define_type_id =
 319         g_flags_register_static (g_intern_static_string ("SoupExpectation"), values);
 320       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 321     }
 322
 323   return g_define_type_id__volatile;
 324 }
 325 GType
 326 soup_connection_state_get_type (void)
 327 {
 328   static volatile gsize g_define_type_id__volatile = 0;
 329
 330   if (g_once_init_enter (&g_define_type_id__volatile))
 331     {
 332       static const GEnumValue values[] = {
 333         { SOUP_CONNECTION_NEW, "SOUP_CONNECTION_NEW", "new" },
 334         { SOUP_CONNECTION_CONNECTING, "SOUP_CONNECTION_CONNECTING", "connecting" },
 335         { SOUP_CONNECTION_IDLE, "SOUP_CONNECTION_IDLE", "idle" },
 336         { SOUP_CONNECTION_IN_USE, "SOUP_CONNECTION_IN_USE", "in-use" },
 337         { SOUP_CONNECTION_REMOTE_DISCONNECTED, "SOUP_CONNECTION_REMOTE_DISCONNECTED", "remote-disconnected" },
 338         { SOUP_CONNECTION_DISCONNECTED, "SOUP_CONNECTION_DISCONNECTED", "disconnected" },
 339         { 0, NULL, NULL }
 340       };
 341       GType g_define_type_id =
 342         g_enum_register_static (g_intern_static_string ("SoupConnectionState"), values);
 343       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 344     }
 345
 346   return g_define_type_id__volatile;
 347 }
 348 GType
 349 soup_requester_error_get_type (void)
 350 {
 351   static volatile gsize g_define_type_id__volatile = 0;
 352
 353   if (g_once_init_enter (&g_define_type_id__volatile))
 354     {
 355       static const GEnumValue values[] = {
 356         { SOUP_REQUESTER_ERROR_BAD_URI, "SOUP_REQUESTER_ERROR_BAD_URI", "bad-uri" },
 357         { SOUP_REQUESTER_ERROR_UNSUPPORTED_URI_SCHEME, "SOUP_REQUESTER_ERROR_UNSUPPORTED_URI_SCHEME", "unsupported-uri-scheme" },
 358         { 0, NULL, NULL }
 359       };
 360       GType g_define_type_id =
 361         g_enum_register_static (g_intern_static_string ("SoupRequesterError"), values);
 362       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 363     }
 364
 365   return g_define_type_id__volatile;
 366 }
 367 GType
 368 soup_socket_io_status_get_type (void)
 369 {
 370   static volatile gsize g_define_type_id__volatile = 0;
 371
 372   if (g_once_init_enter (&g_define_type_id__volatile))
 373     {
 374       static const GEnumValue values[] = {
 375         { SOUP_SOCKET_OK, "SOUP_SOCKET_OK", "ok" },
 376         { SOUP_SOCKET_WOULD_BLOCK, "SOUP_SOCKET_WOULD_BLOCK", "would-block" },
 377         { SOUP_SOCKET_EOF, "SOUP_SOCKET_EOF", "eof" },
 378         { SOUP_SOCKET_ERROR, "SOUP_SOCKET_ERROR", "error" },
 379         { 0, NULL, NULL }
 380       };
 381       GType g_define_type_id =
 382         g_enum_register_static (g_intern_static_string ("SoupSocketIOStatus"), values);
 383       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 384     }
 385
 386   return g_define_type_id__volatile;
 387 }
 388 GType
 389 soup_known_status_code_get_type (void)
 390 {
 391   static volatile gsize g_define_type_id__volatile = 0;
 392
 393   if (g_once_init_enter (&g_define_type_id__volatile))
 394     {
 395       static const GEnumValue values[] = {
 396         { SOUP_STATUS_NONE, "SOUP_STATUS_NONE", "none" },
 397         { SOUP_STATUS_CANCELLED, "SOUP_STATUS_CANCELLED", "cancelled" },
 398         { SOUP_STATUS_CANT_RESOLVE, "SOUP_STATUS_CANT_RESOLVE", "cant-resolve" },
 399         { SOUP_STATUS_CANT_RESOLVE_PROXY, "SOUP_STATUS_CANT_RESOLVE_PROXY", "cant-resolve-proxy" },
 400         { SOUP_STATUS_CANT_CONNECT, "SOUP_STATUS_CANT_CONNECT", "cant-connect" },
 401         { SOUP_STATUS_CANT_CONNECT_PROXY, "SOUP_STATUS_CANT_CONNECT_PROXY", "cant-connect-proxy" },
 402         { SOUP_STATUS_SSL_FAILED, "SOUP_STATUS_SSL_FAILED", "ssl-failed" },
 403         { SOUP_STATUS_IO_ERROR, "SOUP_STATUS_IO_ERROR", "io-error" },
 404         { SOUP_STATUS_MALFORMED, "SOUP_STATUS_MALFORMED", "malformed" },
 405         { SOUP_STATUS_TRY_AGAIN, "SOUP_STATUS_TRY_AGAIN", "try-again" },
 406         { SOUP_STATUS_TOO_MANY_REDIRECTS, "SOUP_STATUS_TOO_MANY_REDIRECTS", "too-many-redirects" },
 407         { SOUP_STATUS_TLS_FAILED, "SOUP_STATUS_TLS_FAILED", "tls-failed" },
 408         { SOUP_STATUS_CONTINUE, "SOUP_STATUS_CONTINUE", "continue" },
 409         { SOUP_STATUS_SWITCHING_PROTOCOLS, "SOUP_STATUS_SWITCHING_PROTOCOLS", "switching-protocols" },
 410         { SOUP_STATUS_PROCESSING, "SOUP_STATUS_PROCESSING", "processing" },
 411         { SOUP_STATUS_OK, "SOUP_STATUS_OK", "ok" },
 412         { SOUP_STATUS_CREATED, "SOUP_STATUS_CREATED", "created" },
 413         { SOUP_STATUS_ACCEPTED, "SOUP_STATUS_ACCEPTED", "accepted" },
 414         { SOUP_STATUS_NON_AUTHORITATIVE, "SOUP_STATUS_NON_AUTHORITATIVE", "non-authoritative" },
 415         { SOUP_STATUS_NO_CONTENT, "SOUP_STATUS_NO_CONTENT", "no-content" },
 416         { SOUP_STATUS_RESET_CONTENT, "SOUP_STATUS_RESET_CONTENT", "reset-content" },
 417         { SOUP_STATUS_PARTIAL_CONTENT, "SOUP_STATUS_PARTIAL_CONTENT", "partial-content" },
 418         { SOUP_STATUS_MULTI_STATUS, "SOUP_STATUS_MULTI_STATUS", "multi-status" },
 419         { SOUP_STATUS_MULTIPLE_CHOICES, "SOUP_STATUS_MULTIPLE_CHOICES", "multiple-choices" },
 420         { SOUP_STATUS_MOVED_PERMANENTLY, "SOUP_STATUS_MOVED_PERMANENTLY", "moved-permanently" },
 421         { SOUP_STATUS_FOUND, "SOUP_STATUS_FOUND", "found" },
 422         { SOUP_STATUS_MOVED_TEMPORARILY, "SOUP_STATUS_MOVED_TEMPORARILY", "moved-temporarily" },
 423         { SOUP_STATUS_SEE_OTHER, "SOUP_STATUS_SEE_OTHER", "see-other" },
 424         { SOUP_STATUS_NOT_MODIFIED, "SOUP_STATUS_NOT_MODIFIED", "not-modified" },
 425         { SOUP_STATUS_USE_PROXY, "SOUP_STATUS_USE_PROXY", "use-proxy" },
 426         { SOUP_STATUS_NOT_APPEARING_IN_THIS_PROTOCOL, "SOUP_STATUS_NOT_APPEARING_IN_THIS_PROTOCOL", "not-appearing-in-this-protocol" },
 427         { SOUP_STATUS_TEMPORARY_REDIRECT, "SOUP_STATUS_TEMPORARY_REDIRECT", "temporary-redirect" },
 428         { SOUP_STATUS_BAD_REQUEST, "SOUP_STATUS_BAD_REQUEST", "bad-request" },
 429         { SOUP_STATUS_UNAUTHORIZED, "SOUP_STATUS_UNAUTHORIZED", "unauthorized" },
 430         { SOUP_STATUS_PAYMENT_REQUIRED, "SOUP_STATUS_PAYMENT_REQUIRED", "payment-required" },
 431         { SOUP_STATUS_FORBIDDEN, "SOUP_STATUS_FORBIDDEN", "forbidden" },
 432         { SOUP_STATUS_NOT_FOUND, "SOUP_STATUS_NOT_FOUND", "not-found" },
 433         { SOUP_STATUS_METHOD_NOT_ALLOWED, "SOUP_STATUS_METHOD_NOT_ALLOWED", "method-not-allowed" },
 434         { SOUP_STATUS_NOT_ACCEPTABLE, "SOUP_STATUS_NOT_ACCEPTABLE", "not-acceptable" },
 435         { SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED, "SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED", "proxy-authentication-required" },
 436         { SOUP_STATUS_PROXY_UNAUTHORIZED, "SOUP_STATUS_PROXY_UNAUTHORIZED", "proxy-unauthorized" },
 437         { SOUP_STATUS_REQUEST_TIMEOUT, "SOUP_STATUS_REQUEST_TIMEOUT", "request-timeout" },
 438         { SOUP_STATUS_CONFLICT, "SOUP_STATUS_CONFLICT", "conflict" },
 439         { SOUP_STATUS_GONE, "SOUP_STATUS_GONE", "gone" },
 440         { SOUP_STATUS_LENGTH_REQUIRED, "SOUP_STATUS_LENGTH_REQUIRED", "length-required" },
 441         { SOUP_STATUS_PRECONDITION_FAILED, "SOUP_STATUS_PRECONDITION_FAILED", "precondition-failed" },
 442         { SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE, "SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE", "request-entity-too-large" },
 443         { SOUP_STATUS_REQUEST_URI_TOO_LONG, "SOUP_STATUS_REQUEST_URI_TOO_LONG", "request-uri-too-long" },
 444         { SOUP_STATUS_UNSUPPORTED_MEDIA_TYPE, "SOUP_STATUS_UNSUPPORTED_MEDIA_TYPE", "unsupported-media-type" },
 445         { SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE, "SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE", "requested-range-not-satisfiable" },
 446         { SOUP_STATUS_INVALID_RANGE, "SOUP_STATUS_INVALID_RANGE", "invalid-range" },
 447         { SOUP_STATUS_EXPECTATION_FAILED, "SOUP_STATUS_EXPECTATION_FAILED", "expectation-failed" },
 448         { SOUP_STATUS_UNPROCESSABLE_ENTITY, "SOUP_STATUS_UNPROCESSABLE_ENTITY", "unprocessable-entity" },
 449         { SOUP_STATUS_LOCKED, "SOUP_STATUS_LOCKED", "locked" },
 450         { SOUP_STATUS_FAILED_DEPENDENCY, "SOUP_STATUS_FAILED_DEPENDENCY", "failed-dependency" },
 451         { SOUP_STATUS_INTERNAL_SERVER_ERROR, "SOUP_STATUS_INTERNAL_SERVER_ERROR", "internal-server-error" },
 452         { SOUP_STATUS_NOT_IMPLEMENTED, "SOUP_STATUS_NOT_IMPLEMENTED", "not-implemented" },
 453         { SOUP_STATUS_BAD_GATEWAY, "SOUP_STATUS_BAD_GATEWAY", "bad-gateway" },
 454         { SOUP_STATUS_SERVICE_UNAVAILABLE, "SOUP_STATUS_SERVICE_UNAVAILABLE", "service-unavailable" },
 455         { SOUP_STATUS_GATEWAY_TIMEOUT, "SOUP_STATUS_GATEWAY_TIMEOUT", "gateway-timeout" },
 456         { SOUP_STATUS_HTTP_VERSION_NOT_SUPPORTED, "SOUP_STATUS_HTTP_VERSION_NOT_SUPPORTED", "http-version-not-supported" },
 457         { SOUP_STATUS_INSUFFICIENT_STORAGE, "SOUP_STATUS_INSUFFICIENT_STORAGE", "insufficient-storage" },
 458         { SOUP_STATUS_NOT_EXTENDED, "SOUP_STATUS_NOT_EXTENDED", "not-extended" },
 459         { 0, NULL, NULL }
 460       };
 461       GType g_define_type_id =
 462         g_enum_register_static (g_intern_static_string ("SoupKnownStatusCode"), values);
 463       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 464     }
 465
 466   return g_define_type_id__volatile;
 467 }
 468 GType
 469 soup_xmlrpc_error_get_type (void)
 470 {
 471   static volatile gsize g_define_type_id__volatile = 0;
 472
 473   if (g_once_init_enter (&g_define_type_id__volatile))
 474     {
 475       static const GEnumValue values[] = {
 476         { SOUP_XMLRPC_ERROR_ARGUMENTS, "SOUP_XMLRPC_ERROR_ARGUMENTS", "arguments" },
 477         { SOUP_XMLRPC_ERROR_RETVAL, "SOUP_XMLRPC_ERROR_RETVAL", "retval" },
 478         { 0, NULL, NULL }
 479       };
 480       GType g_define_type_id =
 481         g_enum_register_static (g_intern_static_string ("SoupXMLRPCError"), values);
 482       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 483     }
 484
 485   return g_define_type_id__volatile;
 486 }
 487 GType
 488 soup_xmlrpc_fault_get_type (void)
 489 {
 490   static volatile gsize g_define_type_id__volatile = 0;
 491
 492   if (g_once_init_enter (&g_define_type_id__volatile))
 493     {
 494       static const GEnumValue values[] = {
 495         { SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED, "SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED", "parse-error-not-well-formed" },
 496         { SOUP_XMLRPC_FAULT_PARSE_ERROR_UNSUPPORTED_ENCODING, "SOUP_XMLRPC_FAULT_PARSE_ERROR_UNSUPPORTED_ENCODING", "parse-error-unsupported-encoding" },
 497         { SOUP_XMLRPC_FAULT_PARSE_ERROR_INVALID_CHARACTER_FOR_ENCODING, "SOUP_XMLRPC_FAULT_PARSE_ERROR_INVALID_CHARACTER_FOR_ENCODING", "parse-error-invalid-character-for-encoding" },
 498         { SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_XML_RPC, "SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_XML_RPC", "server-error-invalid-xml-rpc" },
 499         { SOUP_XMLRPC_FAULT_SERVER_ERROR_REQUESTED_METHOD_NOT_FOUND, "SOUP_XMLRPC_FAULT_SERVER_ERROR_REQUESTED_METHOD_NOT_FOUND", "server-error-requested-method-not-found" },
 500         { SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_METHOD_PARAMETERS, "SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_METHOD_PARAMETERS", "server-error-invalid-method-parameters" },
 501         { SOUP_XMLRPC_FAULT_SERVER_ERROR_INTERNAL_XML_RPC_ERROR, "SOUP_XMLRPC_FAULT_SERVER_ERROR_INTERNAL_XML_RPC_ERROR", "server-error-internal-xml-rpc-error" },
 502         { SOUP_XMLRPC_FAULT_APPLICATION_ERROR, "SOUP_XMLRPC_FAULT_APPLICATION_ERROR", "application-error" },
 503         { SOUP_XMLRPC_FAULT_SYSTEM_ERROR, "SOUP_XMLRPC_FAULT_SYSTEM_ERROR", "system-error" },
 504         { SOUP_XMLRPC_FAULT_TRANSPORT_ERROR, "SOUP_XMLRPC_FAULT_TRANSPORT_ERROR", "transport-error" },
 505         { 0, NULL, NULL }
 506       };
 507       GType g_define_type_id =
 508         g_enum_register_static (g_intern_static_string ("SoupXMLRPCFault"), values);
 509       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
 510     }
 511
 512   return g_define_type_id__volatile;
 513 }
 514
 515
 516