amqp_definitions.c

00001 
00002 
00003 // Copyright (c) Microsoft. All rights reserved.
00004 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
00005 
00006 #include <stdlib.h>
00007 #ifdef _CRTDBG_MAP_ALLOC
00008 #include <crtdbg.h>
00009 #endif
00010 #include "azure_uamqp_c/amqpvalue.h"
00011 #include "azure_uamqp_c/amqp_definitions.h"
00012 #include "azure_uamqp_c/amqpalloc.h"
00013 #include <stdlib.h>
00014 #include <stdbool.h>
00015 
00016 /* role */
00017 
00018 AMQP_VALUE amqpvalue_create_role(role value)
00019 {
00020     return amqpvalue_create_boolean(value);
00021 }
00022 
00023 /* sender-settle-mode */
00024 
00025 AMQP_VALUE amqpvalue_create_sender_settle_mode(sender_settle_mode value)
00026 {
00027     return amqpvalue_create_ubyte(value);
00028 }
00029 
00030 /* receiver-settle-mode */
00031 
00032 AMQP_VALUE amqpvalue_create_receiver_settle_mode(receiver_settle_mode value)
00033 {
00034     return amqpvalue_create_ubyte(value);
00035 }
00036 
00037 /* handle */
00038 
00039 AMQP_VALUE amqpvalue_create_handle(handle value)
00040 {
00041     return amqpvalue_create_uint(value);
00042 }
00043 
00044 /* seconds */
00045 
00046 AMQP_VALUE amqpvalue_create_seconds(seconds value)
00047 {
00048     return amqpvalue_create_uint(value);
00049 }
00050 
00051 /* milliseconds */
00052 
00053 AMQP_VALUE amqpvalue_create_milliseconds(milliseconds value)
00054 {
00055     return amqpvalue_create_uint(value);
00056 }
00057 
00058 /* delivery-tag */
00059 
00060 AMQP_VALUE amqpvalue_create_delivery_tag(delivery_tag value)
00061 {
00062     return amqpvalue_create_binary(value);
00063 }
00064 
00065 /* sequence-no */
00066 
00067 AMQP_VALUE amqpvalue_create_sequence_no(sequence_no value)
00068 {
00069     return amqpvalue_create_uint(value);
00070 }
00071 
00072 /* delivery-number */
00073 
00074 AMQP_VALUE amqpvalue_create_delivery_number(delivery_number value)
00075 {
00076     return amqpvalue_create_sequence_no(value);
00077 }
00078 
00079 /* transfer-number */
00080 
00081 AMQP_VALUE amqpvalue_create_transfer_number(transfer_number value)
00082 {
00083     return amqpvalue_create_sequence_no(value);
00084 }
00085 
00086 /* message-format */
00087 
00088 AMQP_VALUE amqpvalue_create_message_format(message_format value)
00089 {
00090     return amqpvalue_create_uint(value);
00091 }
00092 
00093 /* ietf-language-tag */
00094 
00095 AMQP_VALUE amqpvalue_create_ietf_language_tag(ietf_language_tag value)
00096 {
00097     return amqpvalue_create_symbol(value);
00098 }
00099 
00100 /* fields */
00101 
00102 AMQP_VALUE amqpvalue_create_fields(AMQP_VALUE value)
00103 {
00104     return amqpvalue_clone(value);
00105 }
00106 
00107 /* error */
00108 
00109 typedef struct ERROR_INSTANCE_TAG
00110 {
00111     AMQP_VALUE composite_value;
00112 } ERROR_INSTANCE;
00113 
00114 static ERROR_HANDLE error_create_internal(void)
00115 {
00116     ERROR_INSTANCE* error_instance = (ERROR_INSTANCE*)amqpalloc_malloc(sizeof(ERROR_INSTANCE));
00117     if (error_instance != NULL)
00118     {
00119         error_instance->composite_value = NULL;
00120     }
00121 
00122     return error_instance;
00123 }
00124 
00125 ERROR_HANDLE error_create(const char* condition_value)
00126 {
00127     ERROR_INSTANCE* error_instance = (ERROR_INSTANCE*)amqpalloc_malloc(sizeof(ERROR_INSTANCE));
00128     if (error_instance != NULL)
00129     {
00130         error_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(29);
00131         if (error_instance->composite_value == NULL)
00132         {
00133             amqpalloc_free(error_instance);
00134             error_instance = NULL;
00135         }
00136         else
00137         {
00138             AMQP_VALUE condition_amqp_value;
00139             int result = 0;
00140 
00141             condition_amqp_value = amqpvalue_create_symbol(condition_value);
00142             if ((result == 0) && (amqpvalue_set_composite_item(error_instance->composite_value, 0, condition_amqp_value) != 0))
00143             {
00144                 result = __LINE__;
00145             }
00146 
00147             amqpvalue_destroy(condition_amqp_value);
00148         }
00149     }
00150 
00151     return error_instance;
00152 }
00153 
00154 ERROR_HANDLE error_clone(ERROR_HANDLE value)
00155 {
00156     ERROR_INSTANCE* error_instance = (ERROR_INSTANCE*)amqpalloc_malloc(sizeof(ERROR_INSTANCE));
00157     if (error_instance != NULL)
00158     {
00159         error_instance->composite_value = amqpvalue_clone(((ERROR_INSTANCE*)value)->composite_value);
00160         if (error_instance->composite_value == NULL)
00161         {
00162             amqpalloc_free(error_instance);
00163             error_instance = NULL;
00164         }
00165     }
00166 
00167     return error_instance;
00168 }
00169 
00170 void error_destroy(ERROR_HANDLE error)
00171 {
00172     if (error != NULL)
00173     {
00174         ERROR_INSTANCE* error_instance = (ERROR_INSTANCE*)error;
00175         amqpvalue_destroy(error_instance->composite_value);
00176         amqpalloc_free(error_instance);
00177     }
00178 }
00179 
00180 AMQP_VALUE amqpvalue_create_error(ERROR_HANDLE error)
00181 {
00182     AMQP_VALUE result;
00183 
00184     if (error == NULL)
00185     {
00186         result = NULL;
00187     }
00188     else
00189     {
00190         ERROR_INSTANCE* error_instance = (ERROR_INSTANCE*)error;
00191         result = amqpvalue_clone(error_instance->composite_value);
00192     }
00193 
00194     return result;
00195 }
00196 
00197 bool is_error_type_by_descriptor(AMQP_VALUE descriptor)
00198 {
00199     bool result;
00200 
00201     uint64_t descriptor_ulong;
00202     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
00203         (descriptor_ulong == 29))
00204     {
00205         result = true;
00206     }
00207     else
00208     {
00209         result = false;
00210     }
00211 
00212     return result;
00213 }
00214 
00215 
00216 int amqpvalue_get_error(AMQP_VALUE value, ERROR_HANDLE* error_handle)
00217 {
00218     int result;
00219     ERROR_INSTANCE* error_instance = (ERROR_INSTANCE*)error_create_internal();
00220     *error_handle = error_instance;
00221     if (*error_handle == NULL)
00222     {
00223         result = __LINE__;
00224     }
00225     else
00226     {
00227         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
00228         if (list_value == NULL)
00229         {
00230             error_destroy(*error_handle);
00231             result = __LINE__;
00232         }
00233         else
00234         {
00235             do
00236             {
00237                 AMQP_VALUE item_value;
00238                 /* condition */
00239                 item_value = amqpvalue_get_list_item(list_value, 0);
00240                 if (item_value == NULL)
00241                 {
00242                     {
00243                         error_destroy(*error_handle);
00244                         result = __LINE__;
00245                         break;
00246                     }
00247                 }
00248                 else
00249                 {
00250                     const char* condition;
00251                     if (amqpvalue_get_symbol(item_value, &condition) != 0)
00252                     {
00253                         error_destroy(*error_handle);
00254                         result = __LINE__;
00255                         break;
00256                     }
00257 
00258                     amqpvalue_destroy(item_value);
00259                 }
00260                 /* description */
00261                 item_value = amqpvalue_get_list_item(list_value, 1);
00262                 if (item_value == NULL)
00263                 {
00264                     /* do nothing */
00265                 }
00266                 else
00267                 {
00268                     const char* description;
00269                     if (amqpvalue_get_string(item_value, &description) != 0)
00270                     {
00271                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
00272                         {
00273                             error_destroy(*error_handle);
00274                             result = __LINE__;
00275                             break;
00276                         }
00277                     }
00278 
00279                     amqpvalue_destroy(item_value);
00280                 }
00281                 /* info */
00282                 item_value = amqpvalue_get_list_item(list_value, 2);
00283                 if (item_value == NULL)
00284                 {
00285                     /* do nothing */
00286                 }
00287                 else
00288                 {
00289                     fields info;
00290                     if (amqpvalue_get_fields(item_value, &info) != 0)
00291                     {
00292                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
00293                         {
00294                             error_destroy(*error_handle);
00295                             result = __LINE__;
00296                             break;
00297                         }
00298                     }
00299 
00300                     amqpvalue_destroy(item_value);
00301                 }
00302 
00303                 error_instance->composite_value = amqpvalue_clone(value);
00304 
00305                 result = 0;
00306             } while (0);
00307         }
00308     }
00309 
00310     return result;
00311 }
00312 
00313 int error_get_condition(ERROR_HANDLE error, const char** condition_value)
00314 {
00315     int result;
00316 
00317     if (error == NULL)
00318     {
00319         result = __LINE__;
00320     }
00321     else
00322     {
00323         ERROR_INSTANCE* error_instance = (ERROR_INSTANCE*)error;
00324         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(error_instance->composite_value, 0);
00325         if (item_value == NULL)
00326         {
00327             result = __LINE__;
00328         }
00329         else
00330         {
00331             if (amqpvalue_get_symbol(item_value, condition_value) != 0)
00332             {
00333                 result = __LINE__;
00334             }
00335             else
00336             {
00337                 result = 0;
00338             }
00339         }
00340     }
00341 
00342     return result;
00343 }
00344 
00345 int error_set_condition(ERROR_HANDLE error, const char* condition_value)
00346 {
00347     int result;
00348 
00349     if (error == NULL)
00350     {
00351         result = __LINE__;
00352     }
00353     else
00354     {
00355         ERROR_INSTANCE* error_instance = (ERROR_INSTANCE*)error;
00356         AMQP_VALUE condition_amqp_value = amqpvalue_create_symbol(condition_value);
00357         if (condition_amqp_value == NULL)
00358         {
00359             result = __LINE__;
00360         }
00361         else
00362         {
00363             if (amqpvalue_set_composite_item(error_instance->composite_value, 0, condition_amqp_value) != 0)
00364             {
00365                 result = __LINE__;
00366             }
00367             else
00368             {
00369                 result = 0;
00370             }
00371 
00372             amqpvalue_destroy(condition_amqp_value);
00373         }
00374     }
00375 
00376     return result;
00377 }
00378 
00379 int error_get_description(ERROR_HANDLE error, const char** description_value)
00380 {
00381     int result;
00382 
00383     if (error == NULL)
00384     {
00385         result = __LINE__;
00386     }
00387     else
00388     {
00389         ERROR_INSTANCE* error_instance = (ERROR_INSTANCE*)error;
00390         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(error_instance->composite_value, 1);
00391         if (item_value == NULL)
00392         {
00393             result = __LINE__;
00394         }
00395         else
00396         {
00397             if (amqpvalue_get_string(item_value, description_value) != 0)
00398             {
00399                 result = __LINE__;
00400             }
00401             else
00402             {
00403                 result = 0;
00404             }
00405         }
00406     }
00407 
00408     return result;
00409 }
00410 
00411 int error_set_description(ERROR_HANDLE error, const char* description_value)
00412 {
00413     int result;
00414 
00415     if (error == NULL)
00416     {
00417         result = __LINE__;
00418     }
00419     else
00420     {
00421         ERROR_INSTANCE* error_instance = (ERROR_INSTANCE*)error;
00422         AMQP_VALUE description_amqp_value = amqpvalue_create_string(description_value);
00423         if (description_amqp_value == NULL)
00424         {
00425             result = __LINE__;
00426         }
00427         else
00428         {
00429             if (amqpvalue_set_composite_item(error_instance->composite_value, 1, description_amqp_value) != 0)
00430             {
00431                 result = __LINE__;
00432             }
00433             else
00434             {
00435                 result = 0;
00436             }
00437 
00438             amqpvalue_destroy(description_amqp_value);
00439         }
00440     }
00441 
00442     return result;
00443 }
00444 
00445 int error_get_info(ERROR_HANDLE error, fields* info_value)
00446 {
00447     int result;
00448 
00449     if (error == NULL)
00450     {
00451         result = __LINE__;
00452     }
00453     else
00454     {
00455         ERROR_INSTANCE* error_instance = (ERROR_INSTANCE*)error;
00456         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(error_instance->composite_value, 2);
00457         if (item_value == NULL)
00458         {
00459             result = __LINE__;
00460         }
00461         else
00462         {
00463             if (amqpvalue_get_fields(item_value, info_value) != 0)
00464             {
00465                 result = __LINE__;
00466             }
00467             else
00468             {
00469                 result = 0;
00470             }
00471         }
00472     }
00473 
00474     return result;
00475 }
00476 
00477 int error_set_info(ERROR_HANDLE error, fields info_value)
00478 {
00479     int result;
00480 
00481     if (error == NULL)
00482     {
00483         result = __LINE__;
00484     }
00485     else
00486     {
00487         ERROR_INSTANCE* error_instance = (ERROR_INSTANCE*)error;
00488         AMQP_VALUE info_amqp_value = amqpvalue_create_fields(info_value);
00489         if (info_amqp_value == NULL)
00490         {
00491             result = __LINE__;
00492         }
00493         else
00494         {
00495             if (amqpvalue_set_composite_item(error_instance->composite_value, 2, info_amqp_value) != 0)
00496             {
00497                 result = __LINE__;
00498             }
00499             else
00500             {
00501                 result = 0;
00502             }
00503 
00504             amqpvalue_destroy(info_amqp_value);
00505         }
00506     }
00507 
00508     return result;
00509 }
00510 
00511 
00512 /* amqp-error */
00513 
00514 AMQP_VALUE amqpvalue_create_amqp_error(amqp_error value)
00515 {
00516     return amqpvalue_create_symbol(value);
00517 }
00518 
00519 /* connection-error */
00520 
00521 AMQP_VALUE amqpvalue_create_connection_error(connection_error value)
00522 {
00523     return amqpvalue_create_symbol(value);
00524 }
00525 
00526 /* session-error */
00527 
00528 AMQP_VALUE amqpvalue_create_session_error(session_error value)
00529 {
00530     return amqpvalue_create_symbol(value);
00531 }
00532 
00533 /* link-error */
00534 
00535 AMQP_VALUE amqpvalue_create_link_error(link_error value)
00536 {
00537     return amqpvalue_create_symbol(value);
00538 }
00539 
00540 /* open */
00541 
00542 typedef struct OPEN_INSTANCE_TAG
00543 {
00544     AMQP_VALUE composite_value;
00545 } OPEN_INSTANCE;
00546 
00547 static OPEN_HANDLE open_create_internal(void)
00548 {
00549     OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)amqpalloc_malloc(sizeof(OPEN_INSTANCE));
00550     if (open_instance != NULL)
00551     {
00552         open_instance->composite_value = NULL;
00553     }
00554 
00555     return open_instance;
00556 }
00557 
00558 OPEN_HANDLE open_create(const char* container_id_value)
00559 {
00560     OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)amqpalloc_malloc(sizeof(OPEN_INSTANCE));
00561     if (open_instance != NULL)
00562     {
00563         open_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(16);
00564         if (open_instance->composite_value == NULL)
00565         {
00566             amqpalloc_free(open_instance);
00567             open_instance = NULL;
00568         }
00569         else
00570         {
00571             AMQP_VALUE container_id_amqp_value;
00572             int result = 0;
00573 
00574             container_id_amqp_value = amqpvalue_create_string(container_id_value);
00575             if ((result == 0) && (amqpvalue_set_composite_item(open_instance->composite_value, 0, container_id_amqp_value) != 0))
00576             {
00577                 result = __LINE__;
00578             }
00579 
00580             amqpvalue_destroy(container_id_amqp_value);
00581         }
00582     }
00583 
00584     return open_instance;
00585 }
00586 
00587 OPEN_HANDLE open_clone(OPEN_HANDLE value)
00588 {
00589     OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)amqpalloc_malloc(sizeof(OPEN_INSTANCE));
00590     if (open_instance != NULL)
00591     {
00592         open_instance->composite_value = amqpvalue_clone(((OPEN_INSTANCE*)value)->composite_value);
00593         if (open_instance->composite_value == NULL)
00594         {
00595             amqpalloc_free(open_instance);
00596             open_instance = NULL;
00597         }
00598     }
00599 
00600     return open_instance;
00601 }
00602 
00603 void open_destroy(OPEN_HANDLE open)
00604 {
00605     if (open != NULL)
00606     {
00607         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
00608         amqpvalue_destroy(open_instance->composite_value);
00609         amqpalloc_free(open_instance);
00610     }
00611 }
00612 
00613 AMQP_VALUE amqpvalue_create_open(OPEN_HANDLE open)
00614 {
00615     AMQP_VALUE result;
00616 
00617     if (open == NULL)
00618     {
00619         result = NULL;
00620     }
00621     else
00622     {
00623         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
00624         result = amqpvalue_clone(open_instance->composite_value);
00625     }
00626 
00627     return result;
00628 }
00629 
00630 bool is_open_type_by_descriptor(AMQP_VALUE descriptor)
00631 {
00632     bool result;
00633 
00634     uint64_t descriptor_ulong;
00635     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
00636         (descriptor_ulong == 16))
00637     {
00638         result = true;
00639     }
00640     else
00641     {
00642         result = false;
00643     }
00644 
00645     return result;
00646 }
00647 
00648 
00649 int amqpvalue_get_open(AMQP_VALUE value, OPEN_HANDLE* open_handle)
00650 {
00651     int result;
00652     OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open_create_internal();
00653     *open_handle = open_instance;
00654     if (*open_handle == NULL)
00655     {
00656         result = __LINE__;
00657     }
00658     else
00659     {
00660         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
00661         if (list_value == NULL)
00662         {
00663             open_destroy(*open_handle);
00664             result = __LINE__;
00665         }
00666         else
00667         {
00668             do
00669             {
00670                 AMQP_VALUE item_value;
00671                 /* container-id */
00672                 item_value = amqpvalue_get_list_item(list_value, 0);
00673                 if (item_value == NULL)
00674                 {
00675                     {
00676                         open_destroy(*open_handle);
00677                         result = __LINE__;
00678                         break;
00679                     }
00680                 }
00681                 else
00682                 {
00683                     const char* container_id;
00684                     if (amqpvalue_get_string(item_value, &container_id) != 0)
00685                     {
00686                         open_destroy(*open_handle);
00687                         result = __LINE__;
00688                         break;
00689                     }
00690 
00691                     amqpvalue_destroy(item_value);
00692                 }
00693                 /* hostname */
00694                 item_value = amqpvalue_get_list_item(list_value, 1);
00695                 if (item_value == NULL)
00696                 {
00697                     /* do nothing */
00698                 }
00699                 else
00700                 {
00701                     const char* hostname;
00702                     if (amqpvalue_get_string(item_value, &hostname) != 0)
00703                     {
00704                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
00705                         {
00706                             open_destroy(*open_handle);
00707                             result = __LINE__;
00708                             break;
00709                         }
00710                     }
00711 
00712                     amqpvalue_destroy(item_value);
00713                 }
00714                 /* max-frame-size */
00715                 item_value = amqpvalue_get_list_item(list_value, 2);
00716                 if (item_value == NULL)
00717                 {
00718                     /* do nothing */
00719                 }
00720                 else
00721                 {
00722                     uint32_t max_frame_size;
00723                     if (amqpvalue_get_uint(item_value, &max_frame_size) != 0)
00724                     {
00725                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
00726                         {
00727                             open_destroy(*open_handle);
00728                             result = __LINE__;
00729                             break;
00730                         }
00731                     }
00732 
00733                     amqpvalue_destroy(item_value);
00734                 }
00735                 /* channel-max */
00736                 item_value = amqpvalue_get_list_item(list_value, 3);
00737                 if (item_value == NULL)
00738                 {
00739                     /* do nothing */
00740                 }
00741                 else
00742                 {
00743                     uint16_t channel_max;
00744                     if (amqpvalue_get_ushort(item_value, &channel_max) != 0)
00745                     {
00746                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
00747                         {
00748                             open_destroy(*open_handle);
00749                             result = __LINE__;
00750                             break;
00751                         }
00752                     }
00753 
00754                     amqpvalue_destroy(item_value);
00755                 }
00756                 /* idle-time-out */
00757                 item_value = amqpvalue_get_list_item(list_value, 4);
00758                 if (item_value == NULL)
00759                 {
00760                     /* do nothing */
00761                 }
00762                 else
00763                 {
00764                     milliseconds idle_time_out;
00765                     if (amqpvalue_get_milliseconds(item_value, &idle_time_out) != 0)
00766                     {
00767                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
00768                         {
00769                             open_destroy(*open_handle);
00770                             result = __LINE__;
00771                             break;
00772                         }
00773                     }
00774 
00775                     amqpvalue_destroy(item_value);
00776                 }
00777                 /* outgoing-locales */
00778                 item_value = amqpvalue_get_list_item(list_value, 5);
00779                 if (item_value == NULL)
00780                 {
00781                     /* do nothing */
00782                 }
00783                 else
00784                 {
00785                     ietf_language_tag outgoing_locales;
00786                     AMQP_VALUE outgoing_locales_array;
00787                     if ((amqpvalue_get_array(item_value, &outgoing_locales_array) != 0) &&
00788                         (amqpvalue_get_ietf_language_tag(item_value, &outgoing_locales) != 0))
00789                     {
00790                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
00791                         {
00792                             open_destroy(*open_handle);
00793                             result = __LINE__;
00794                             break;
00795                         }
00796                     }
00797 
00798                     amqpvalue_destroy(item_value);
00799                 }
00800                 /* incoming-locales */
00801                 item_value = amqpvalue_get_list_item(list_value, 6);
00802                 if (item_value == NULL)
00803                 {
00804                     /* do nothing */
00805                 }
00806                 else
00807                 {
00808                     ietf_language_tag incoming_locales;
00809                     AMQP_VALUE incoming_locales_array;
00810                     if ((amqpvalue_get_array(item_value, &incoming_locales_array) != 0) &&
00811                         (amqpvalue_get_ietf_language_tag(item_value, &incoming_locales) != 0))
00812                     {
00813                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
00814                         {
00815                             open_destroy(*open_handle);
00816                             result = __LINE__;
00817                             break;
00818                         }
00819                     }
00820 
00821                     amqpvalue_destroy(item_value);
00822                 }
00823                 /* offered-capabilities */
00824                 item_value = amqpvalue_get_list_item(list_value, 7);
00825                 if (item_value == NULL)
00826                 {
00827                     /* do nothing */
00828                 }
00829                 else
00830                 {
00831                     const char* offered_capabilities;
00832                     AMQP_VALUE offered_capabilities_array;
00833                     if ((amqpvalue_get_array(item_value, &offered_capabilities_array) != 0) &&
00834                         (amqpvalue_get_symbol(item_value, &offered_capabilities) != 0))
00835                     {
00836                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
00837                         {
00838                             open_destroy(*open_handle);
00839                             result = __LINE__;
00840                             break;
00841                         }
00842                     }
00843 
00844                     amqpvalue_destroy(item_value);
00845                 }
00846                 /* desired-capabilities */
00847                 item_value = amqpvalue_get_list_item(list_value, 8);
00848                 if (item_value == NULL)
00849                 {
00850                     /* do nothing */
00851                 }
00852                 else
00853                 {
00854                     const char* desired_capabilities;
00855                     AMQP_VALUE desired_capabilities_array;
00856                     if ((amqpvalue_get_array(item_value, &desired_capabilities_array) != 0) &&
00857                         (amqpvalue_get_symbol(item_value, &desired_capabilities) != 0))
00858                     {
00859                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
00860                         {
00861                             open_destroy(*open_handle);
00862                             result = __LINE__;
00863                             break;
00864                         }
00865                     }
00866 
00867                     amqpvalue_destroy(item_value);
00868                 }
00869                 /* properties */
00870                 item_value = amqpvalue_get_list_item(list_value, 9);
00871                 if (item_value == NULL)
00872                 {
00873                     /* do nothing */
00874                 }
00875                 else
00876                 {
00877                     fields properties;
00878                     if (amqpvalue_get_fields(item_value, &properties) != 0)
00879                     {
00880                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
00881                         {
00882                             open_destroy(*open_handle);
00883                             result = __LINE__;
00884                             break;
00885                         }
00886                     }
00887 
00888                     amqpvalue_destroy(item_value);
00889                 }
00890 
00891                 open_instance->composite_value = amqpvalue_clone(value);
00892 
00893                 result = 0;
00894             } while (0);
00895         }
00896     }
00897 
00898     return result;
00899 }
00900 
00901 int open_get_container_id(OPEN_HANDLE open, const char** container_id_value)
00902 {
00903     int result;
00904 
00905     if (open == NULL)
00906     {
00907         result = __LINE__;
00908     }
00909     else
00910     {
00911         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
00912         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(open_instance->composite_value, 0);
00913         if (item_value == NULL)
00914         {
00915             result = __LINE__;
00916         }
00917         else
00918         {
00919             if (amqpvalue_get_string(item_value, container_id_value) != 0)
00920             {
00921                 result = __LINE__;
00922             }
00923             else
00924             {
00925                 result = 0;
00926             }
00927         }
00928     }
00929 
00930     return result;
00931 }
00932 
00933 int open_set_container_id(OPEN_HANDLE open, const char* container_id_value)
00934 {
00935     int result;
00936 
00937     if (open == NULL)
00938     {
00939         result = __LINE__;
00940     }
00941     else
00942     {
00943         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
00944         AMQP_VALUE container_id_amqp_value = amqpvalue_create_string(container_id_value);
00945         if (container_id_amqp_value == NULL)
00946         {
00947             result = __LINE__;
00948         }
00949         else
00950         {
00951             if (amqpvalue_set_composite_item(open_instance->composite_value, 0, container_id_amqp_value) != 0)
00952             {
00953                 result = __LINE__;
00954             }
00955             else
00956             {
00957                 result = 0;
00958             }
00959 
00960             amqpvalue_destroy(container_id_amqp_value);
00961         }
00962     }
00963 
00964     return result;
00965 }
00966 
00967 int open_get_hostname(OPEN_HANDLE open, const char** hostname_value)
00968 {
00969     int result;
00970 
00971     if (open == NULL)
00972     {
00973         result = __LINE__;
00974     }
00975     else
00976     {
00977         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
00978         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(open_instance->composite_value, 1);
00979         if (item_value == NULL)
00980         {
00981             result = __LINE__;
00982         }
00983         else
00984         {
00985             if (amqpvalue_get_string(item_value, hostname_value) != 0)
00986             {
00987                 result = __LINE__;
00988             }
00989             else
00990             {
00991                 result = 0;
00992             }
00993         }
00994     }
00995 
00996     return result;
00997 }
00998 
00999 int open_set_hostname(OPEN_HANDLE open, const char* hostname_value)
01000 {
01001     int result;
01002 
01003     if (open == NULL)
01004     {
01005         result = __LINE__;
01006     }
01007     else
01008     {
01009         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01010         AMQP_VALUE hostname_amqp_value = amqpvalue_create_string(hostname_value);
01011         if (hostname_amqp_value == NULL)
01012         {
01013             result = __LINE__;
01014         }
01015         else
01016         {
01017             if (amqpvalue_set_composite_item(open_instance->composite_value, 1, hostname_amqp_value) != 0)
01018             {
01019                 result = __LINE__;
01020             }
01021             else
01022             {
01023                 result = 0;
01024             }
01025 
01026             amqpvalue_destroy(hostname_amqp_value);
01027         }
01028     }
01029 
01030     return result;
01031 }
01032 
01033 int open_get_max_frame_size(OPEN_HANDLE open, uint32_t* max_frame_size_value)
01034 {
01035     int result;
01036 
01037     if (open == NULL)
01038     {
01039         result = __LINE__;
01040     }
01041     else
01042     {
01043         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01044         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(open_instance->composite_value, 2);
01045         if (item_value == NULL)
01046         {
01047             result = __LINE__;
01048         }
01049         else
01050         {
01051             if (amqpvalue_get_uint(item_value, max_frame_size_value) != 0)
01052             {
01053                 result = __LINE__;
01054             }
01055             else
01056             {
01057                 result = 0;
01058             }
01059         }
01060     }
01061 
01062     return result;
01063 }
01064 
01065 int open_set_max_frame_size(OPEN_HANDLE open, uint32_t max_frame_size_value)
01066 {
01067     int result;
01068 
01069     if (open == NULL)
01070     {
01071         result = __LINE__;
01072     }
01073     else
01074     {
01075         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01076         AMQP_VALUE max_frame_size_amqp_value = amqpvalue_create_uint(max_frame_size_value);
01077         if (max_frame_size_amqp_value == NULL)
01078         {
01079             result = __LINE__;
01080         }
01081         else
01082         {
01083             if (amqpvalue_set_composite_item(open_instance->composite_value, 2, max_frame_size_amqp_value) != 0)
01084             {
01085                 result = __LINE__;
01086             }
01087             else
01088             {
01089                 result = 0;
01090             }
01091 
01092             amqpvalue_destroy(max_frame_size_amqp_value);
01093         }
01094     }
01095 
01096     return result;
01097 }
01098 
01099 int open_get_channel_max(OPEN_HANDLE open, uint16_t* channel_max_value)
01100 {
01101     int result;
01102 
01103     if (open == NULL)
01104     {
01105         result = __LINE__;
01106     }
01107     else
01108     {
01109         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01110         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(open_instance->composite_value, 3);
01111         if (item_value == NULL)
01112         {
01113             result = __LINE__;
01114         }
01115         else
01116         {
01117             if (amqpvalue_get_ushort(item_value, channel_max_value) != 0)
01118             {
01119                 result = __LINE__;
01120             }
01121             else
01122             {
01123                 result = 0;
01124             }
01125         }
01126     }
01127 
01128     return result;
01129 }
01130 
01131 int open_set_channel_max(OPEN_HANDLE open, uint16_t channel_max_value)
01132 {
01133     int result;
01134 
01135     if (open == NULL)
01136     {
01137         result = __LINE__;
01138     }
01139     else
01140     {
01141         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01142         AMQP_VALUE channel_max_amqp_value = amqpvalue_create_ushort(channel_max_value);
01143         if (channel_max_amqp_value == NULL)
01144         {
01145             result = __LINE__;
01146         }
01147         else
01148         {
01149             if (amqpvalue_set_composite_item(open_instance->composite_value, 3, channel_max_amqp_value) != 0)
01150             {
01151                 result = __LINE__;
01152             }
01153             else
01154             {
01155                 result = 0;
01156             }
01157 
01158             amqpvalue_destroy(channel_max_amqp_value);
01159         }
01160     }
01161 
01162     return result;
01163 }
01164 
01165 int open_get_idle_time_out(OPEN_HANDLE open, milliseconds* idle_time_out_value)
01166 {
01167     int result;
01168 
01169     if (open == NULL)
01170     {
01171         result = __LINE__;
01172     }
01173     else
01174     {
01175         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01176         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(open_instance->composite_value, 4);
01177         if (item_value == NULL)
01178         {
01179             result = __LINE__;
01180         }
01181         else
01182         {
01183             if (amqpvalue_get_milliseconds(item_value, idle_time_out_value) != 0)
01184             {
01185                 result = __LINE__;
01186             }
01187             else
01188             {
01189                 result = 0;
01190             }
01191         }
01192     }
01193 
01194     return result;
01195 }
01196 
01197 int open_set_idle_time_out(OPEN_HANDLE open, milliseconds idle_time_out_value)
01198 {
01199     int result;
01200 
01201     if (open == NULL)
01202     {
01203         result = __LINE__;
01204     }
01205     else
01206     {
01207         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01208         AMQP_VALUE idle_time_out_amqp_value = amqpvalue_create_milliseconds(idle_time_out_value);
01209         if (idle_time_out_amqp_value == NULL)
01210         {
01211             result = __LINE__;
01212         }
01213         else
01214         {
01215             if (amqpvalue_set_composite_item(open_instance->composite_value, 4, idle_time_out_amqp_value) != 0)
01216             {
01217                 result = __LINE__;
01218             }
01219             else
01220             {
01221                 result = 0;
01222             }
01223 
01224             amqpvalue_destroy(idle_time_out_amqp_value);
01225         }
01226     }
01227 
01228     return result;
01229 }
01230 
01231 int open_get_outgoing_locales(OPEN_HANDLE open, AMQP_VALUE* outgoing_locales_value)
01232 {
01233     int result;
01234 
01235     if (open == NULL)
01236     {
01237         result = __LINE__;
01238     }
01239     else
01240     {
01241         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01242         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(open_instance->composite_value, 5);
01243         if (item_value == NULL)
01244         {
01245             result = __LINE__;
01246         }
01247         else
01248         {
01249             if (amqpvalue_get_array(item_value, outgoing_locales_value) != 0)
01250             {
01251                 result = __LINE__;
01252             }
01253             else
01254             {
01255                 result = 0;
01256             }
01257         }
01258     }
01259 
01260     return result;
01261 }
01262 
01263 int open_set_outgoing_locales(OPEN_HANDLE open, AMQP_VALUE outgoing_locales_value)
01264 {
01265     int result;
01266 
01267     if (open == NULL)
01268     {
01269         result = __LINE__;
01270     }
01271     else
01272     {
01273         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01274         AMQP_VALUE outgoing_locales_amqp_value = amqpvalue_clone(outgoing_locales_value);
01275         if (outgoing_locales_amqp_value == NULL)
01276         {
01277             result = __LINE__;
01278         }
01279         else
01280         {
01281             if (amqpvalue_set_composite_item(open_instance->composite_value, 5, outgoing_locales_amqp_value) != 0)
01282             {
01283                 result = __LINE__;
01284             }
01285             else
01286             {
01287                 result = 0;
01288             }
01289 
01290             amqpvalue_destroy(outgoing_locales_amqp_value);
01291         }
01292     }
01293 
01294     return result;
01295 }
01296 
01297 int open_get_incoming_locales(OPEN_HANDLE open, AMQP_VALUE* incoming_locales_value)
01298 {
01299     int result;
01300 
01301     if (open == NULL)
01302     {
01303         result = __LINE__;
01304     }
01305     else
01306     {
01307         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01308         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(open_instance->composite_value, 6);
01309         if (item_value == NULL)
01310         {
01311             result = __LINE__;
01312         }
01313         else
01314         {
01315             if (amqpvalue_get_array(item_value, incoming_locales_value) != 0)
01316             {
01317                 result = __LINE__;
01318             }
01319             else
01320             {
01321                 result = 0;
01322             }
01323         }
01324     }
01325 
01326     return result;
01327 }
01328 
01329 int open_set_incoming_locales(OPEN_HANDLE open, AMQP_VALUE incoming_locales_value)
01330 {
01331     int result;
01332 
01333     if (open == NULL)
01334     {
01335         result = __LINE__;
01336     }
01337     else
01338     {
01339         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01340         AMQP_VALUE incoming_locales_amqp_value = amqpvalue_clone(incoming_locales_value);
01341         if (incoming_locales_amqp_value == NULL)
01342         {
01343             result = __LINE__;
01344         }
01345         else
01346         {
01347             if (amqpvalue_set_composite_item(open_instance->composite_value, 6, incoming_locales_amqp_value) != 0)
01348             {
01349                 result = __LINE__;
01350             }
01351             else
01352             {
01353                 result = 0;
01354             }
01355 
01356             amqpvalue_destroy(incoming_locales_amqp_value);
01357         }
01358     }
01359 
01360     return result;
01361 }
01362 
01363 int open_get_offered_capabilities(OPEN_HANDLE open, AMQP_VALUE* offered_capabilities_value)
01364 {
01365     int result;
01366 
01367     if (open == NULL)
01368     {
01369         result = __LINE__;
01370     }
01371     else
01372     {
01373         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01374         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(open_instance->composite_value, 7);
01375         if (item_value == NULL)
01376         {
01377             result = __LINE__;
01378         }
01379         else
01380         {
01381             if (amqpvalue_get_array(item_value, offered_capabilities_value) != 0)
01382             {
01383                 result = __LINE__;
01384             }
01385             else
01386             {
01387                 result = 0;
01388             }
01389         }
01390     }
01391 
01392     return result;
01393 }
01394 
01395 int open_set_offered_capabilities(OPEN_HANDLE open, AMQP_VALUE offered_capabilities_value)
01396 {
01397     int result;
01398 
01399     if (open == NULL)
01400     {
01401         result = __LINE__;
01402     }
01403     else
01404     {
01405         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01406         AMQP_VALUE offered_capabilities_amqp_value = amqpvalue_clone(offered_capabilities_value);
01407         if (offered_capabilities_amqp_value == NULL)
01408         {
01409             result = __LINE__;
01410         }
01411         else
01412         {
01413             if (amqpvalue_set_composite_item(open_instance->composite_value, 7, offered_capabilities_amqp_value) != 0)
01414             {
01415                 result = __LINE__;
01416             }
01417             else
01418             {
01419                 result = 0;
01420             }
01421 
01422             amqpvalue_destroy(offered_capabilities_amqp_value);
01423         }
01424     }
01425 
01426     return result;
01427 }
01428 
01429 int open_get_desired_capabilities(OPEN_HANDLE open, AMQP_VALUE* desired_capabilities_value)
01430 {
01431     int result;
01432 
01433     if (open == NULL)
01434     {
01435         result = __LINE__;
01436     }
01437     else
01438     {
01439         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01440         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(open_instance->composite_value, 8);
01441         if (item_value == NULL)
01442         {
01443             result = __LINE__;
01444         }
01445         else
01446         {
01447             if (amqpvalue_get_array(item_value, desired_capabilities_value) != 0)
01448             {
01449                 result = __LINE__;
01450             }
01451             else
01452             {
01453                 result = 0;
01454             }
01455         }
01456     }
01457 
01458     return result;
01459 }
01460 
01461 int open_set_desired_capabilities(OPEN_HANDLE open, AMQP_VALUE desired_capabilities_value)
01462 {
01463     int result;
01464 
01465     if (open == NULL)
01466     {
01467         result = __LINE__;
01468     }
01469     else
01470     {
01471         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01472         AMQP_VALUE desired_capabilities_amqp_value = amqpvalue_clone(desired_capabilities_value);
01473         if (desired_capabilities_amqp_value == NULL)
01474         {
01475             result = __LINE__;
01476         }
01477         else
01478         {
01479             if (amqpvalue_set_composite_item(open_instance->composite_value, 8, desired_capabilities_amqp_value) != 0)
01480             {
01481                 result = __LINE__;
01482             }
01483             else
01484             {
01485                 result = 0;
01486             }
01487 
01488             amqpvalue_destroy(desired_capabilities_amqp_value);
01489         }
01490     }
01491 
01492     return result;
01493 }
01494 
01495 int open_get_properties(OPEN_HANDLE open, fields* properties_value)
01496 {
01497     int result;
01498 
01499     if (open == NULL)
01500     {
01501         result = __LINE__;
01502     }
01503     else
01504     {
01505         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01506         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(open_instance->composite_value, 9);
01507         if (item_value == NULL)
01508         {
01509             result = __LINE__;
01510         }
01511         else
01512         {
01513             if (amqpvalue_get_fields(item_value, properties_value) != 0)
01514             {
01515                 result = __LINE__;
01516             }
01517             else
01518             {
01519                 result = 0;
01520             }
01521         }
01522     }
01523 
01524     return result;
01525 }
01526 
01527 int open_set_properties(OPEN_HANDLE open, fields properties_value)
01528 {
01529     int result;
01530 
01531     if (open == NULL)
01532     {
01533         result = __LINE__;
01534     }
01535     else
01536     {
01537         OPEN_INSTANCE* open_instance = (OPEN_INSTANCE*)open;
01538         AMQP_VALUE properties_amqp_value = amqpvalue_create_fields(properties_value);
01539         if (properties_amqp_value == NULL)
01540         {
01541             result = __LINE__;
01542         }
01543         else
01544         {
01545             if (amqpvalue_set_composite_item(open_instance->composite_value, 9, properties_amqp_value) != 0)
01546             {
01547                 result = __LINE__;
01548             }
01549             else
01550             {
01551                 result = 0;
01552             }
01553 
01554             amqpvalue_destroy(properties_amqp_value);
01555         }
01556     }
01557 
01558     return result;
01559 }
01560 
01561 
01562 /* begin */
01563 
01564 typedef struct BEGIN_INSTANCE_TAG
01565 {
01566     AMQP_VALUE composite_value;
01567 } BEGIN_INSTANCE;
01568 
01569 static BEGIN_HANDLE begin_create_internal(void)
01570 {
01571     BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)amqpalloc_malloc(sizeof(BEGIN_INSTANCE));
01572     if (begin_instance != NULL)
01573     {
01574         begin_instance->composite_value = NULL;
01575     }
01576 
01577     return begin_instance;
01578 }
01579 
01580 BEGIN_HANDLE begin_create(transfer_number next_outgoing_id_value, uint32_t incoming_window_value, uint32_t outgoing_window_value)
01581 {
01582     BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)amqpalloc_malloc(sizeof(BEGIN_INSTANCE));
01583     if (begin_instance != NULL)
01584     {
01585         begin_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(17);
01586         if (begin_instance->composite_value == NULL)
01587         {
01588             amqpalloc_free(begin_instance);
01589             begin_instance = NULL;
01590         }
01591         else
01592         {
01593             AMQP_VALUE next_outgoing_id_amqp_value;
01594             AMQP_VALUE incoming_window_amqp_value;
01595             AMQP_VALUE outgoing_window_amqp_value;
01596             int result = 0;
01597 
01598             next_outgoing_id_amqp_value = amqpvalue_create_transfer_number(next_outgoing_id_value);
01599             if ((result == 0) && (amqpvalue_set_composite_item(begin_instance->composite_value, 1, next_outgoing_id_amqp_value) != 0))
01600             {
01601                 result = __LINE__;
01602             }
01603             incoming_window_amqp_value = amqpvalue_create_uint(incoming_window_value);
01604             if ((result == 0) && (amqpvalue_set_composite_item(begin_instance->composite_value, 2, incoming_window_amqp_value) != 0))
01605             {
01606                 result = __LINE__;
01607             }
01608             outgoing_window_amqp_value = amqpvalue_create_uint(outgoing_window_value);
01609             if ((result == 0) && (amqpvalue_set_composite_item(begin_instance->composite_value, 3, outgoing_window_amqp_value) != 0))
01610             {
01611                 result = __LINE__;
01612             }
01613 
01614             amqpvalue_destroy(next_outgoing_id_amqp_value);
01615             amqpvalue_destroy(incoming_window_amqp_value);
01616             amqpvalue_destroy(outgoing_window_amqp_value);
01617         }
01618     }
01619 
01620     return begin_instance;
01621 }
01622 
01623 BEGIN_HANDLE begin_clone(BEGIN_HANDLE value)
01624 {
01625     BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)amqpalloc_malloc(sizeof(BEGIN_INSTANCE));
01626     if (begin_instance != NULL)
01627     {
01628         begin_instance->composite_value = amqpvalue_clone(((BEGIN_INSTANCE*)value)->composite_value);
01629         if (begin_instance->composite_value == NULL)
01630         {
01631             amqpalloc_free(begin_instance);
01632             begin_instance = NULL;
01633         }
01634     }
01635 
01636     return begin_instance;
01637 }
01638 
01639 void begin_destroy(BEGIN_HANDLE begin)
01640 {
01641     if (begin != NULL)
01642     {
01643         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
01644         amqpvalue_destroy(begin_instance->composite_value);
01645         amqpalloc_free(begin_instance);
01646     }
01647 }
01648 
01649 AMQP_VALUE amqpvalue_create_begin(BEGIN_HANDLE begin)
01650 {
01651     AMQP_VALUE result;
01652 
01653     if (begin == NULL)
01654     {
01655         result = NULL;
01656     }
01657     else
01658     {
01659         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
01660         result = amqpvalue_clone(begin_instance->composite_value);
01661     }
01662 
01663     return result;
01664 }
01665 
01666 bool is_begin_type_by_descriptor(AMQP_VALUE descriptor)
01667 {
01668     bool result;
01669 
01670     uint64_t descriptor_ulong;
01671     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
01672         (descriptor_ulong == 17))
01673     {
01674         result = true;
01675     }
01676     else
01677     {
01678         result = false;
01679     }
01680 
01681     return result;
01682 }
01683 
01684 
01685 int amqpvalue_get_begin(AMQP_VALUE value, BEGIN_HANDLE* begin_handle)
01686 {
01687     int result;
01688     BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin_create_internal();
01689     *begin_handle = begin_instance;
01690     if (*begin_handle == NULL)
01691     {
01692         result = __LINE__;
01693     }
01694     else
01695     {
01696         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
01697         if (list_value == NULL)
01698         {
01699             begin_destroy(*begin_handle);
01700             result = __LINE__;
01701         }
01702         else
01703         {
01704             do
01705             {
01706                 AMQP_VALUE item_value;
01707                 /* remote-channel */
01708                 item_value = amqpvalue_get_list_item(list_value, 0);
01709                 if (item_value == NULL)
01710                 {
01711                     /* do nothing */
01712                 }
01713                 else
01714                 {
01715                     uint16_t remote_channel;
01716                     if (amqpvalue_get_ushort(item_value, &remote_channel) != 0)
01717                     {
01718                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
01719                         {
01720                             begin_destroy(*begin_handle);
01721                             result = __LINE__;
01722                             break;
01723                         }
01724                     }
01725 
01726                     amqpvalue_destroy(item_value);
01727                 }
01728                 /* next-outgoing-id */
01729                 item_value = amqpvalue_get_list_item(list_value, 1);
01730                 if (item_value == NULL)
01731                 {
01732                     {
01733                         begin_destroy(*begin_handle);
01734                         result = __LINE__;
01735                         break;
01736                     }
01737                 }
01738                 else
01739                 {
01740                     transfer_number next_outgoing_id;
01741                     if (amqpvalue_get_transfer_number(item_value, &next_outgoing_id) != 0)
01742                     {
01743                         begin_destroy(*begin_handle);
01744                         result = __LINE__;
01745                         break;
01746                     }
01747 
01748                     amqpvalue_destroy(item_value);
01749                 }
01750                 /* incoming-window */
01751                 item_value = amqpvalue_get_list_item(list_value, 2);
01752                 if (item_value == NULL)
01753                 {
01754                     {
01755                         begin_destroy(*begin_handle);
01756                         result = __LINE__;
01757                         break;
01758                     }
01759                 }
01760                 else
01761                 {
01762                     uint32_t incoming_window;
01763                     if (amqpvalue_get_uint(item_value, &incoming_window) != 0)
01764                     {
01765                         begin_destroy(*begin_handle);
01766                         result = __LINE__;
01767                         break;
01768                     }
01769 
01770                     amqpvalue_destroy(item_value);
01771                 }
01772                 /* outgoing-window */
01773                 item_value = amqpvalue_get_list_item(list_value, 3);
01774                 if (item_value == NULL)
01775                 {
01776                     {
01777                         begin_destroy(*begin_handle);
01778                         result = __LINE__;
01779                         break;
01780                     }
01781                 }
01782                 else
01783                 {
01784                     uint32_t outgoing_window;
01785                     if (amqpvalue_get_uint(item_value, &outgoing_window) != 0)
01786                     {
01787                         begin_destroy(*begin_handle);
01788                         result = __LINE__;
01789                         break;
01790                     }
01791 
01792                     amqpvalue_destroy(item_value);
01793                 }
01794                 /* handle-max */
01795                 item_value = amqpvalue_get_list_item(list_value, 4);
01796                 if (item_value == NULL)
01797                 {
01798                     /* do nothing */
01799                 }
01800                 else
01801                 {
01802                     handle handle_max;
01803                     if (amqpvalue_get_handle(item_value, &handle_max) != 0)
01804                     {
01805                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
01806                         {
01807                             begin_destroy(*begin_handle);
01808                             result = __LINE__;
01809                             break;
01810                         }
01811                     }
01812 
01813                     amqpvalue_destroy(item_value);
01814                 }
01815                 /* offered-capabilities */
01816                 item_value = amqpvalue_get_list_item(list_value, 5);
01817                 if (item_value == NULL)
01818                 {
01819                     /* do nothing */
01820                 }
01821                 else
01822                 {
01823                     const char* offered_capabilities;
01824                     AMQP_VALUE offered_capabilities_array;
01825                     if ((amqpvalue_get_array(item_value, &offered_capabilities_array) != 0) &&
01826                         (amqpvalue_get_symbol(item_value, &offered_capabilities) != 0))
01827                     {
01828                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
01829                         {
01830                             begin_destroy(*begin_handle);
01831                             result = __LINE__;
01832                             break;
01833                         }
01834                     }
01835 
01836                     amqpvalue_destroy(item_value);
01837                 }
01838                 /* desired-capabilities */
01839                 item_value = amqpvalue_get_list_item(list_value, 6);
01840                 if (item_value == NULL)
01841                 {
01842                     /* do nothing */
01843                 }
01844                 else
01845                 {
01846                     const char* desired_capabilities;
01847                     AMQP_VALUE desired_capabilities_array;
01848                     if ((amqpvalue_get_array(item_value, &desired_capabilities_array) != 0) &&
01849                         (amqpvalue_get_symbol(item_value, &desired_capabilities) != 0))
01850                     {
01851                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
01852                         {
01853                             begin_destroy(*begin_handle);
01854                             result = __LINE__;
01855                             break;
01856                         }
01857                     }
01858 
01859                     amqpvalue_destroy(item_value);
01860                 }
01861                 /* properties */
01862                 item_value = amqpvalue_get_list_item(list_value, 7);
01863                 if (item_value == NULL)
01864                 {
01865                     /* do nothing */
01866                 }
01867                 else
01868                 {
01869                     fields properties;
01870                     if (amqpvalue_get_fields(item_value, &properties) != 0)
01871                     {
01872                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
01873                         {
01874                             begin_destroy(*begin_handle);
01875                             result = __LINE__;
01876                             break;
01877                         }
01878                     }
01879 
01880                     amqpvalue_destroy(item_value);
01881                 }
01882 
01883                 begin_instance->composite_value = amqpvalue_clone(value);
01884 
01885                 result = 0;
01886             } while (0);
01887         }
01888     }
01889 
01890     return result;
01891 }
01892 
01893 int begin_get_remote_channel(BEGIN_HANDLE begin, uint16_t* remote_channel_value)
01894 {
01895     int result;
01896 
01897     if (begin == NULL)
01898     {
01899         result = __LINE__;
01900     }
01901     else
01902     {
01903         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
01904         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(begin_instance->composite_value, 0);
01905         if (item_value == NULL)
01906         {
01907             result = __LINE__;
01908         }
01909         else
01910         {
01911             if (amqpvalue_get_ushort(item_value, remote_channel_value) != 0)
01912             {
01913                 result = __LINE__;
01914             }
01915             else
01916             {
01917                 result = 0;
01918             }
01919         }
01920     }
01921 
01922     return result;
01923 }
01924 
01925 int begin_set_remote_channel(BEGIN_HANDLE begin, uint16_t remote_channel_value)
01926 {
01927     int result;
01928 
01929     if (begin == NULL)
01930     {
01931         result = __LINE__;
01932     }
01933     else
01934     {
01935         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
01936         AMQP_VALUE remote_channel_amqp_value = amqpvalue_create_ushort(remote_channel_value);
01937         if (remote_channel_amqp_value == NULL)
01938         {
01939             result = __LINE__;
01940         }
01941         else
01942         {
01943             if (amqpvalue_set_composite_item(begin_instance->composite_value, 0, remote_channel_amqp_value) != 0)
01944             {
01945                 result = __LINE__;
01946             }
01947             else
01948             {
01949                 result = 0;
01950             }
01951 
01952             amqpvalue_destroy(remote_channel_amqp_value);
01953         }
01954     }
01955 
01956     return result;
01957 }
01958 
01959 int begin_get_next_outgoing_id(BEGIN_HANDLE begin, transfer_number* next_outgoing_id_value)
01960 {
01961     int result;
01962 
01963     if (begin == NULL)
01964     {
01965         result = __LINE__;
01966     }
01967     else
01968     {
01969         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
01970         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(begin_instance->composite_value, 1);
01971         if (item_value == NULL)
01972         {
01973             result = __LINE__;
01974         }
01975         else
01976         {
01977             if (amqpvalue_get_transfer_number(item_value, next_outgoing_id_value) != 0)
01978             {
01979                 result = __LINE__;
01980             }
01981             else
01982             {
01983                 result = 0;
01984             }
01985         }
01986     }
01987 
01988     return result;
01989 }
01990 
01991 int begin_set_next_outgoing_id(BEGIN_HANDLE begin, transfer_number next_outgoing_id_value)
01992 {
01993     int result;
01994 
01995     if (begin == NULL)
01996     {
01997         result = __LINE__;
01998     }
01999     else
02000     {
02001         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
02002         AMQP_VALUE next_outgoing_id_amqp_value = amqpvalue_create_transfer_number(next_outgoing_id_value);
02003         if (next_outgoing_id_amqp_value == NULL)
02004         {
02005             result = __LINE__;
02006         }
02007         else
02008         {
02009             if (amqpvalue_set_composite_item(begin_instance->composite_value, 1, next_outgoing_id_amqp_value) != 0)
02010             {
02011                 result = __LINE__;
02012             }
02013             else
02014             {
02015                 result = 0;
02016             }
02017 
02018             amqpvalue_destroy(next_outgoing_id_amqp_value);
02019         }
02020     }
02021 
02022     return result;
02023 }
02024 
02025 int begin_get_incoming_window(BEGIN_HANDLE begin, uint32_t* incoming_window_value)
02026 {
02027     int result;
02028 
02029     if (begin == NULL)
02030     {
02031         result = __LINE__;
02032     }
02033     else
02034     {
02035         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
02036         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(begin_instance->composite_value, 2);
02037         if (item_value == NULL)
02038         {
02039             result = __LINE__;
02040         }
02041         else
02042         {
02043             if (amqpvalue_get_uint(item_value, incoming_window_value) != 0)
02044             {
02045                 result = __LINE__;
02046             }
02047             else
02048             {
02049                 result = 0;
02050             }
02051         }
02052     }
02053 
02054     return result;
02055 }
02056 
02057 int begin_set_incoming_window(BEGIN_HANDLE begin, uint32_t incoming_window_value)
02058 {
02059     int result;
02060 
02061     if (begin == NULL)
02062     {
02063         result = __LINE__;
02064     }
02065     else
02066     {
02067         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
02068         AMQP_VALUE incoming_window_amqp_value = amqpvalue_create_uint(incoming_window_value);
02069         if (incoming_window_amqp_value == NULL)
02070         {
02071             result = __LINE__;
02072         }
02073         else
02074         {
02075             if (amqpvalue_set_composite_item(begin_instance->composite_value, 2, incoming_window_amqp_value) != 0)
02076             {
02077                 result = __LINE__;
02078             }
02079             else
02080             {
02081                 result = 0;
02082             }
02083 
02084             amqpvalue_destroy(incoming_window_amqp_value);
02085         }
02086     }
02087 
02088     return result;
02089 }
02090 
02091 int begin_get_outgoing_window(BEGIN_HANDLE begin, uint32_t* outgoing_window_value)
02092 {
02093     int result;
02094 
02095     if (begin == NULL)
02096     {
02097         result = __LINE__;
02098     }
02099     else
02100     {
02101         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
02102         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(begin_instance->composite_value, 3);
02103         if (item_value == NULL)
02104         {
02105             result = __LINE__;
02106         }
02107         else
02108         {
02109             if (amqpvalue_get_uint(item_value, outgoing_window_value) != 0)
02110             {
02111                 result = __LINE__;
02112             }
02113             else
02114             {
02115                 result = 0;
02116             }
02117         }
02118     }
02119 
02120     return result;
02121 }
02122 
02123 int begin_set_outgoing_window(BEGIN_HANDLE begin, uint32_t outgoing_window_value)
02124 {
02125     int result;
02126 
02127     if (begin == NULL)
02128     {
02129         result = __LINE__;
02130     }
02131     else
02132     {
02133         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
02134         AMQP_VALUE outgoing_window_amqp_value = amqpvalue_create_uint(outgoing_window_value);
02135         if (outgoing_window_amqp_value == NULL)
02136         {
02137             result = __LINE__;
02138         }
02139         else
02140         {
02141             if (amqpvalue_set_composite_item(begin_instance->composite_value, 3, outgoing_window_amqp_value) != 0)
02142             {
02143                 result = __LINE__;
02144             }
02145             else
02146             {
02147                 result = 0;
02148             }
02149 
02150             amqpvalue_destroy(outgoing_window_amqp_value);
02151         }
02152     }
02153 
02154     return result;
02155 }
02156 
02157 int begin_get_handle_max(BEGIN_HANDLE begin, handle* handle_max_value)
02158 {
02159     int result;
02160 
02161     if (begin == NULL)
02162     {
02163         result = __LINE__;
02164     }
02165     else
02166     {
02167         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
02168         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(begin_instance->composite_value, 4);
02169         if (item_value == NULL)
02170         {
02171             result = __LINE__;
02172         }
02173         else
02174         {
02175             if (amqpvalue_get_handle(item_value, handle_max_value) != 0)
02176             {
02177                 result = __LINE__;
02178             }
02179             else
02180             {
02181                 result = 0;
02182             }
02183         }
02184     }
02185 
02186     return result;
02187 }
02188 
02189 int begin_set_handle_max(BEGIN_HANDLE begin, handle handle_max_value)
02190 {
02191     int result;
02192 
02193     if (begin == NULL)
02194     {
02195         result = __LINE__;
02196     }
02197     else
02198     {
02199         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
02200         AMQP_VALUE handle_max_amqp_value = amqpvalue_create_handle(handle_max_value);
02201         if (handle_max_amqp_value == NULL)
02202         {
02203             result = __LINE__;
02204         }
02205         else
02206         {
02207             if (amqpvalue_set_composite_item(begin_instance->composite_value, 4, handle_max_amqp_value) != 0)
02208             {
02209                 result = __LINE__;
02210             }
02211             else
02212             {
02213                 result = 0;
02214             }
02215 
02216             amqpvalue_destroy(handle_max_amqp_value);
02217         }
02218     }
02219 
02220     return result;
02221 }
02222 
02223 int begin_get_offered_capabilities(BEGIN_HANDLE begin, AMQP_VALUE* offered_capabilities_value)
02224 {
02225     int result;
02226 
02227     if (begin == NULL)
02228     {
02229         result = __LINE__;
02230     }
02231     else
02232     {
02233         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
02234         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(begin_instance->composite_value, 5);
02235         if (item_value == NULL)
02236         {
02237             result = __LINE__;
02238         }
02239         else
02240         {
02241             if (amqpvalue_get_array(item_value, offered_capabilities_value) != 0)
02242             {
02243                 result = __LINE__;
02244             }
02245             else
02246             {
02247                 result = 0;
02248             }
02249         }
02250     }
02251 
02252     return result;
02253 }
02254 
02255 int begin_set_offered_capabilities(BEGIN_HANDLE begin, AMQP_VALUE offered_capabilities_value)
02256 {
02257     int result;
02258 
02259     if (begin == NULL)
02260     {
02261         result = __LINE__;
02262     }
02263     else
02264     {
02265         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
02266         AMQP_VALUE offered_capabilities_amqp_value = amqpvalue_clone(offered_capabilities_value);
02267         if (offered_capabilities_amqp_value == NULL)
02268         {
02269             result = __LINE__;
02270         }
02271         else
02272         {
02273             if (amqpvalue_set_composite_item(begin_instance->composite_value, 5, offered_capabilities_amqp_value) != 0)
02274             {
02275                 result = __LINE__;
02276             }
02277             else
02278             {
02279                 result = 0;
02280             }
02281 
02282             amqpvalue_destroy(offered_capabilities_amqp_value);
02283         }
02284     }
02285 
02286     return result;
02287 }
02288 
02289 int begin_get_desired_capabilities(BEGIN_HANDLE begin, AMQP_VALUE* desired_capabilities_value)
02290 {
02291     int result;
02292 
02293     if (begin == NULL)
02294     {
02295         result = __LINE__;
02296     }
02297     else
02298     {
02299         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
02300         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(begin_instance->composite_value, 6);
02301         if (item_value == NULL)
02302         {
02303             result = __LINE__;
02304         }
02305         else
02306         {
02307             if (amqpvalue_get_array(item_value, desired_capabilities_value) != 0)
02308             {
02309                 result = __LINE__;
02310             }
02311             else
02312             {
02313                 result = 0;
02314             }
02315         }
02316     }
02317 
02318     return result;
02319 }
02320 
02321 int begin_set_desired_capabilities(BEGIN_HANDLE begin, AMQP_VALUE desired_capabilities_value)
02322 {
02323     int result;
02324 
02325     if (begin == NULL)
02326     {
02327         result = __LINE__;
02328     }
02329     else
02330     {
02331         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
02332         AMQP_VALUE desired_capabilities_amqp_value = amqpvalue_clone(desired_capabilities_value);
02333         if (desired_capabilities_amqp_value == NULL)
02334         {
02335             result = __LINE__;
02336         }
02337         else
02338         {
02339             if (amqpvalue_set_composite_item(begin_instance->composite_value, 6, desired_capabilities_amqp_value) != 0)
02340             {
02341                 result = __LINE__;
02342             }
02343             else
02344             {
02345                 result = 0;
02346             }
02347 
02348             amqpvalue_destroy(desired_capabilities_amqp_value);
02349         }
02350     }
02351 
02352     return result;
02353 }
02354 
02355 int begin_get_properties(BEGIN_HANDLE begin, fields* properties_value)
02356 {
02357     int result;
02358 
02359     if (begin == NULL)
02360     {
02361         result = __LINE__;
02362     }
02363     else
02364     {
02365         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
02366         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(begin_instance->composite_value, 7);
02367         if (item_value == NULL)
02368         {
02369             result = __LINE__;
02370         }
02371         else
02372         {
02373             if (amqpvalue_get_fields(item_value, properties_value) != 0)
02374             {
02375                 result = __LINE__;
02376             }
02377             else
02378             {
02379                 result = 0;
02380             }
02381         }
02382     }
02383 
02384     return result;
02385 }
02386 
02387 int begin_set_properties(BEGIN_HANDLE begin, fields properties_value)
02388 {
02389     int result;
02390 
02391     if (begin == NULL)
02392     {
02393         result = __LINE__;
02394     }
02395     else
02396     {
02397         BEGIN_INSTANCE* begin_instance = (BEGIN_INSTANCE*)begin;
02398         AMQP_VALUE properties_amqp_value = amqpvalue_create_fields(properties_value);
02399         if (properties_amqp_value == NULL)
02400         {
02401             result = __LINE__;
02402         }
02403         else
02404         {
02405             if (amqpvalue_set_composite_item(begin_instance->composite_value, 7, properties_amqp_value) != 0)
02406             {
02407                 result = __LINE__;
02408             }
02409             else
02410             {
02411                 result = 0;
02412             }
02413 
02414             amqpvalue_destroy(properties_amqp_value);
02415         }
02416     }
02417 
02418     return result;
02419 }
02420 
02421 
02422 /* attach */
02423 
02424 typedef struct ATTACH_INSTANCE_TAG
02425 {
02426     AMQP_VALUE composite_value;
02427 } ATTACH_INSTANCE;
02428 
02429 static ATTACH_HANDLE attach_create_internal(void)
02430 {
02431     ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)amqpalloc_malloc(sizeof(ATTACH_INSTANCE));
02432     if (attach_instance != NULL)
02433     {
02434         attach_instance->composite_value = NULL;
02435     }
02436 
02437     return attach_instance;
02438 }
02439 
02440 ATTACH_HANDLE attach_create(const char* name_value, handle handle_value, role role_value)
02441 {
02442     ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)amqpalloc_malloc(sizeof(ATTACH_INSTANCE));
02443     if (attach_instance != NULL)
02444     {
02445         attach_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(18);
02446         if (attach_instance->composite_value == NULL)
02447         {
02448             amqpalloc_free(attach_instance);
02449             attach_instance = NULL;
02450         }
02451         else
02452         {
02453             AMQP_VALUE name_amqp_value;
02454             AMQP_VALUE handle_amqp_value;
02455             AMQP_VALUE role_amqp_value;
02456             int result = 0;
02457 
02458             name_amqp_value = amqpvalue_create_string(name_value);
02459             if ((result == 0) && (amqpvalue_set_composite_item(attach_instance->composite_value, 0, name_amqp_value) != 0))
02460             {
02461                 result = __LINE__;
02462             }
02463             handle_amqp_value = amqpvalue_create_handle(handle_value);
02464             if ((result == 0) && (amqpvalue_set_composite_item(attach_instance->composite_value, 1, handle_amqp_value) != 0))
02465             {
02466                 result = __LINE__;
02467             }
02468             role_amqp_value = amqpvalue_create_role(role_value);
02469             if ((result == 0) && (amqpvalue_set_composite_item(attach_instance->composite_value, 2, role_amqp_value) != 0))
02470             {
02471                 result = __LINE__;
02472             }
02473 
02474             amqpvalue_destroy(name_amqp_value);
02475             amqpvalue_destroy(handle_amqp_value);
02476             amqpvalue_destroy(role_amqp_value);
02477         }
02478     }
02479 
02480     return attach_instance;
02481 }
02482 
02483 ATTACH_HANDLE attach_clone(ATTACH_HANDLE value)
02484 {
02485     ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)amqpalloc_malloc(sizeof(ATTACH_INSTANCE));
02486     if (attach_instance != NULL)
02487     {
02488         attach_instance->composite_value = amqpvalue_clone(((ATTACH_INSTANCE*)value)->composite_value);
02489         if (attach_instance->composite_value == NULL)
02490         {
02491             amqpalloc_free(attach_instance);
02492             attach_instance = NULL;
02493         }
02494     }
02495 
02496     return attach_instance;
02497 }
02498 
02499 void attach_destroy(ATTACH_HANDLE attach)
02500 {
02501     if (attach != NULL)
02502     {
02503         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
02504         amqpvalue_destroy(attach_instance->composite_value);
02505         amqpalloc_free(attach_instance);
02506     }
02507 }
02508 
02509 AMQP_VALUE amqpvalue_create_attach(ATTACH_HANDLE attach)
02510 {
02511     AMQP_VALUE result;
02512 
02513     if (attach == NULL)
02514     {
02515         result = NULL;
02516     }
02517     else
02518     {
02519         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
02520         result = amqpvalue_clone(attach_instance->composite_value);
02521     }
02522 
02523     return result;
02524 }
02525 
02526 bool is_attach_type_by_descriptor(AMQP_VALUE descriptor)
02527 {
02528     bool result;
02529 
02530     uint64_t descriptor_ulong;
02531     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
02532         (descriptor_ulong == 18))
02533     {
02534         result = true;
02535     }
02536     else
02537     {
02538         result = false;
02539     }
02540 
02541     return result;
02542 }
02543 
02544 
02545 int amqpvalue_get_attach(AMQP_VALUE value, ATTACH_HANDLE* attach_handle)
02546 {
02547     int result;
02548     ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach_create_internal();
02549     *attach_handle = attach_instance;
02550     if (*attach_handle == NULL)
02551     {
02552         result = __LINE__;
02553     }
02554     else
02555     {
02556         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
02557         if (list_value == NULL)
02558         {
02559             attach_destroy(*attach_handle);
02560             result = __LINE__;
02561         }
02562         else
02563         {
02564             do
02565             {
02566                 AMQP_VALUE item_value;
02567                 /* name */
02568                 item_value = amqpvalue_get_list_item(list_value, 0);
02569                 if (item_value == NULL)
02570                 {
02571                     {
02572                         attach_destroy(*attach_handle);
02573                         result = __LINE__;
02574                         break;
02575                     }
02576                 }
02577                 else
02578                 {
02579                     const char* name;
02580                     if (amqpvalue_get_string(item_value, &name) != 0)
02581                     {
02582                         attach_destroy(*attach_handle);
02583                         result = __LINE__;
02584                         break;
02585                     }
02586 
02587                     amqpvalue_destroy(item_value);
02588                 }
02589                 /* handle */
02590                 item_value = amqpvalue_get_list_item(list_value, 1);
02591                 if (item_value == NULL)
02592                 {
02593                     {
02594                         attach_destroy(*attach_handle);
02595                         result = __LINE__;
02596                         break;
02597                     }
02598                 }
02599                 else
02600                 {
02601                     handle handle;
02602                     if (amqpvalue_get_handle(item_value, &handle) != 0)
02603                     {
02604                         attach_destroy(*attach_handle);
02605                         result = __LINE__;
02606                         break;
02607                     }
02608 
02609                     amqpvalue_destroy(item_value);
02610                 }
02611                 /* role */
02612                 item_value = amqpvalue_get_list_item(list_value, 2);
02613                 if (item_value == NULL)
02614                 {
02615                     {
02616                         attach_destroy(*attach_handle);
02617                         result = __LINE__;
02618                         break;
02619                     }
02620                 }
02621                 else
02622                 {
02623                     role role;
02624                     if (amqpvalue_get_role(item_value, &role) != 0)
02625                     {
02626                         attach_destroy(*attach_handle);
02627                         result = __LINE__;
02628                         break;
02629                     }
02630 
02631                     amqpvalue_destroy(item_value);
02632                 }
02633                 /* snd-settle-mode */
02634                 item_value = amqpvalue_get_list_item(list_value, 3);
02635                 if (item_value == NULL)
02636                 {
02637                     /* do nothing */
02638                 }
02639                 else
02640                 {
02641                     sender_settle_mode snd_settle_mode;
02642                     if (amqpvalue_get_sender_settle_mode(item_value, &snd_settle_mode) != 0)
02643                     {
02644                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
02645                         {
02646                             attach_destroy(*attach_handle);
02647                             result = __LINE__;
02648                             break;
02649                         }
02650                     }
02651 
02652                     amqpvalue_destroy(item_value);
02653                 }
02654                 /* rcv-settle-mode */
02655                 item_value = amqpvalue_get_list_item(list_value, 4);
02656                 if (item_value == NULL)
02657                 {
02658                     /* do nothing */
02659                 }
02660                 else
02661                 {
02662                     receiver_settle_mode rcv_settle_mode;
02663                     if (amqpvalue_get_receiver_settle_mode(item_value, &rcv_settle_mode) != 0)
02664                     {
02665                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
02666                         {
02667                             attach_destroy(*attach_handle);
02668                             result = __LINE__;
02669                             break;
02670                         }
02671                     }
02672 
02673                     amqpvalue_destroy(item_value);
02674                 }
02675                 /* source */
02676                 item_value = amqpvalue_get_list_item(list_value, 5);
02677                 if (item_value == NULL)
02678                 {
02679                     /* do nothing */
02680                 }
02681                 else
02682                 {
02683                     amqpvalue_destroy(item_value);
02684                 }
02685                 /* target */
02686                 item_value = amqpvalue_get_list_item(list_value, 6);
02687                 if (item_value == NULL)
02688                 {
02689                     /* do nothing */
02690                 }
02691                 else
02692                 {
02693                     amqpvalue_destroy(item_value);
02694                 }
02695                 /* unsettled */
02696                 item_value = amqpvalue_get_list_item(list_value, 7);
02697                 if (item_value == NULL)
02698                 {
02699                     /* do nothing */
02700                 }
02701                 else
02702                 {
02703                     AMQP_VALUE unsettled;
02704                     if (amqpvalue_get_map(item_value, &unsettled) != 0)
02705                     {
02706                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
02707                         {
02708                             attach_destroy(*attach_handle);
02709                             result = __LINE__;
02710                             break;
02711                         }
02712                     }
02713 
02714                     amqpvalue_destroy(item_value);
02715                 }
02716                 /* incomplete-unsettled */
02717                 item_value = amqpvalue_get_list_item(list_value, 8);
02718                 if (item_value == NULL)
02719                 {
02720                     /* do nothing */
02721                 }
02722                 else
02723                 {
02724                     bool incomplete_unsettled;
02725                     if (amqpvalue_get_boolean(item_value, &incomplete_unsettled) != 0)
02726                     {
02727                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
02728                         {
02729                             attach_destroy(*attach_handle);
02730                             result = __LINE__;
02731                             break;
02732                         }
02733                     }
02734 
02735                     amqpvalue_destroy(item_value);
02736                 }
02737                 /* initial-delivery-count */
02738                 item_value = amqpvalue_get_list_item(list_value, 9);
02739                 if (item_value == NULL)
02740                 {
02741                     /* do nothing */
02742                 }
02743                 else
02744                 {
02745                     sequence_no initial_delivery_count;
02746                     if (amqpvalue_get_sequence_no(item_value, &initial_delivery_count) != 0)
02747                     {
02748                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
02749                         {
02750                             attach_destroy(*attach_handle);
02751                             result = __LINE__;
02752                             break;
02753                         }
02754                     }
02755 
02756                     amqpvalue_destroy(item_value);
02757                 }
02758                 /* max-message-size */
02759                 item_value = amqpvalue_get_list_item(list_value, 10);
02760                 if (item_value == NULL)
02761                 {
02762                     /* do nothing */
02763                 }
02764                 else
02765                 {
02766                     uint64_t max_message_size;
02767                     if (amqpvalue_get_ulong(item_value, &max_message_size) != 0)
02768                     {
02769                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
02770                         {
02771                             attach_destroy(*attach_handle);
02772                             result = __LINE__;
02773                             break;
02774                         }
02775                     }
02776 
02777                     amqpvalue_destroy(item_value);
02778                 }
02779                 /* offered-capabilities */
02780                 item_value = amqpvalue_get_list_item(list_value, 11);
02781                 if (item_value == NULL)
02782                 {
02783                     /* do nothing */
02784                 }
02785                 else
02786                 {
02787                     const char* offered_capabilities;
02788                     AMQP_VALUE offered_capabilities_array;
02789                     if ((amqpvalue_get_array(item_value, &offered_capabilities_array) != 0) &&
02790                         (amqpvalue_get_symbol(item_value, &offered_capabilities) != 0))
02791                     {
02792                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
02793                         {
02794                             attach_destroy(*attach_handle);
02795                             result = __LINE__;
02796                             break;
02797                         }
02798                     }
02799 
02800                     amqpvalue_destroy(item_value);
02801                 }
02802                 /* desired-capabilities */
02803                 item_value = amqpvalue_get_list_item(list_value, 12);
02804                 if (item_value == NULL)
02805                 {
02806                     /* do nothing */
02807                 }
02808                 else
02809                 {
02810                     const char* desired_capabilities;
02811                     AMQP_VALUE desired_capabilities_array;
02812                     if ((amqpvalue_get_array(item_value, &desired_capabilities_array) != 0) &&
02813                         (amqpvalue_get_symbol(item_value, &desired_capabilities) != 0))
02814                     {
02815                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
02816                         {
02817                             attach_destroy(*attach_handle);
02818                             result = __LINE__;
02819                             break;
02820                         }
02821                     }
02822 
02823                     amqpvalue_destroy(item_value);
02824                 }
02825                 /* properties */
02826                 item_value = amqpvalue_get_list_item(list_value, 13);
02827                 if (item_value == NULL)
02828                 {
02829                     /* do nothing */
02830                 }
02831                 else
02832                 {
02833                     fields properties;
02834                     if (amqpvalue_get_fields(item_value, &properties) != 0)
02835                     {
02836                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
02837                         {
02838                             attach_destroy(*attach_handle);
02839                             result = __LINE__;
02840                             break;
02841                         }
02842                     }
02843 
02844                     amqpvalue_destroy(item_value);
02845                 }
02846 
02847                 attach_instance->composite_value = amqpvalue_clone(value);
02848 
02849                 result = 0;
02850             } while (0);
02851         }
02852     }
02853 
02854     return result;
02855 }
02856 
02857 int attach_get_name(ATTACH_HANDLE attach, const char** name_value)
02858 {
02859     int result;
02860 
02861     if (attach == NULL)
02862     {
02863         result = __LINE__;
02864     }
02865     else
02866     {
02867         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
02868         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(attach_instance->composite_value, 0);
02869         if (item_value == NULL)
02870         {
02871             result = __LINE__;
02872         }
02873         else
02874         {
02875             if (amqpvalue_get_string(item_value, name_value) != 0)
02876             {
02877                 result = __LINE__;
02878             }
02879             else
02880             {
02881                 result = 0;
02882             }
02883         }
02884     }
02885 
02886     return result;
02887 }
02888 
02889 int attach_set_name(ATTACH_HANDLE attach, const char* name_value)
02890 {
02891     int result;
02892 
02893     if (attach == NULL)
02894     {
02895         result = __LINE__;
02896     }
02897     else
02898     {
02899         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
02900         AMQP_VALUE name_amqp_value = amqpvalue_create_string(name_value);
02901         if (name_amqp_value == NULL)
02902         {
02903             result = __LINE__;
02904         }
02905         else
02906         {
02907             if (amqpvalue_set_composite_item(attach_instance->composite_value, 0, name_amqp_value) != 0)
02908             {
02909                 result = __LINE__;
02910             }
02911             else
02912             {
02913                 result = 0;
02914             }
02915 
02916             amqpvalue_destroy(name_amqp_value);
02917         }
02918     }
02919 
02920     return result;
02921 }
02922 
02923 int attach_get_handle(ATTACH_HANDLE attach, handle* handle_value)
02924 {
02925     int result;
02926 
02927     if (attach == NULL)
02928     {
02929         result = __LINE__;
02930     }
02931     else
02932     {
02933         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
02934         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(attach_instance->composite_value, 1);
02935         if (item_value == NULL)
02936         {
02937             result = __LINE__;
02938         }
02939         else
02940         {
02941             if (amqpvalue_get_handle(item_value, handle_value) != 0)
02942             {
02943                 result = __LINE__;
02944             }
02945             else
02946             {
02947                 result = 0;
02948             }
02949         }
02950     }
02951 
02952     return result;
02953 }
02954 
02955 int attach_set_handle(ATTACH_HANDLE attach, handle handle_value)
02956 {
02957     int result;
02958 
02959     if (attach == NULL)
02960     {
02961         result = __LINE__;
02962     }
02963     else
02964     {
02965         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
02966         AMQP_VALUE handle_amqp_value = amqpvalue_create_handle(handle_value);
02967         if (handle_amqp_value == NULL)
02968         {
02969             result = __LINE__;
02970         }
02971         else
02972         {
02973             if (amqpvalue_set_composite_item(attach_instance->composite_value, 1, handle_amqp_value) != 0)
02974             {
02975                 result = __LINE__;
02976             }
02977             else
02978             {
02979                 result = 0;
02980             }
02981 
02982             amqpvalue_destroy(handle_amqp_value);
02983         }
02984     }
02985 
02986     return result;
02987 }
02988 
02989 int attach_get_role(ATTACH_HANDLE attach, role* role_value)
02990 {
02991     int result;
02992 
02993     if (attach == NULL)
02994     {
02995         result = __LINE__;
02996     }
02997     else
02998     {
02999         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03000         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(attach_instance->composite_value, 2);
03001         if (item_value == NULL)
03002         {
03003             result = __LINE__;
03004         }
03005         else
03006         {
03007             if (amqpvalue_get_role(item_value, role_value) != 0)
03008             {
03009                 result = __LINE__;
03010             }
03011             else
03012             {
03013                 result = 0;
03014             }
03015         }
03016     }
03017 
03018     return result;
03019 }
03020 
03021 int attach_set_role(ATTACH_HANDLE attach, role role_value)
03022 {
03023     int result;
03024 
03025     if (attach == NULL)
03026     {
03027         result = __LINE__;
03028     }
03029     else
03030     {
03031         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03032         AMQP_VALUE role_amqp_value = amqpvalue_create_role(role_value);
03033         if (role_amqp_value == NULL)
03034         {
03035             result = __LINE__;
03036         }
03037         else
03038         {
03039             if (amqpvalue_set_composite_item(attach_instance->composite_value, 2, role_amqp_value) != 0)
03040             {
03041                 result = __LINE__;
03042             }
03043             else
03044             {
03045                 result = 0;
03046             }
03047 
03048             amqpvalue_destroy(role_amqp_value);
03049         }
03050     }
03051 
03052     return result;
03053 }
03054 
03055 int attach_get_snd_settle_mode(ATTACH_HANDLE attach, sender_settle_mode* snd_settle_mode_value)
03056 {
03057     int result;
03058 
03059     if (attach == NULL)
03060     {
03061         result = __LINE__;
03062     }
03063     else
03064     {
03065         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03066         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(attach_instance->composite_value, 3);
03067         if (item_value == NULL)
03068         {
03069             result = __LINE__;
03070         }
03071         else
03072         {
03073             if (amqpvalue_get_sender_settle_mode(item_value, snd_settle_mode_value) != 0)
03074             {
03075                 result = __LINE__;
03076             }
03077             else
03078             {
03079                 result = 0;
03080             }
03081         }
03082     }
03083 
03084     return result;
03085 }
03086 
03087 int attach_set_snd_settle_mode(ATTACH_HANDLE attach, sender_settle_mode snd_settle_mode_value)
03088 {
03089     int result;
03090 
03091     if (attach == NULL)
03092     {
03093         result = __LINE__;
03094     }
03095     else
03096     {
03097         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03098         AMQP_VALUE snd_settle_mode_amqp_value = amqpvalue_create_sender_settle_mode(snd_settle_mode_value);
03099         if (snd_settle_mode_amqp_value == NULL)
03100         {
03101             result = __LINE__;
03102         }
03103         else
03104         {
03105             if (amqpvalue_set_composite_item(attach_instance->composite_value, 3, snd_settle_mode_amqp_value) != 0)
03106             {
03107                 result = __LINE__;
03108             }
03109             else
03110             {
03111                 result = 0;
03112             }
03113 
03114             amqpvalue_destroy(snd_settle_mode_amqp_value);
03115         }
03116     }
03117 
03118     return result;
03119 }
03120 
03121 int attach_get_rcv_settle_mode(ATTACH_HANDLE attach, receiver_settle_mode* rcv_settle_mode_value)
03122 {
03123     int result;
03124 
03125     if (attach == NULL)
03126     {
03127         result = __LINE__;
03128     }
03129     else
03130     {
03131         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03132         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(attach_instance->composite_value, 4);
03133         if (item_value == NULL)
03134         {
03135             result = __LINE__;
03136         }
03137         else
03138         {
03139             if (amqpvalue_get_receiver_settle_mode(item_value, rcv_settle_mode_value) != 0)
03140             {
03141                 result = __LINE__;
03142             }
03143             else
03144             {
03145                 result = 0;
03146             }
03147         }
03148     }
03149 
03150     return result;
03151 }
03152 
03153 int attach_set_rcv_settle_mode(ATTACH_HANDLE attach, receiver_settle_mode rcv_settle_mode_value)
03154 {
03155     int result;
03156 
03157     if (attach == NULL)
03158     {
03159         result = __LINE__;
03160     }
03161     else
03162     {
03163         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03164         AMQP_VALUE rcv_settle_mode_amqp_value = amqpvalue_create_receiver_settle_mode(rcv_settle_mode_value);
03165         if (rcv_settle_mode_amqp_value == NULL)
03166         {
03167             result = __LINE__;
03168         }
03169         else
03170         {
03171             if (amqpvalue_set_composite_item(attach_instance->composite_value, 4, rcv_settle_mode_amqp_value) != 0)
03172             {
03173                 result = __LINE__;
03174             }
03175             else
03176             {
03177                 result = 0;
03178             }
03179 
03180             amqpvalue_destroy(rcv_settle_mode_amqp_value);
03181         }
03182     }
03183 
03184     return result;
03185 }
03186 
03187 int attach_get_source(ATTACH_HANDLE attach, AMQP_VALUE* source_value)
03188 {
03189     int result;
03190 
03191     if (attach == NULL)
03192     {
03193         result = __LINE__;
03194     }
03195     else
03196     {
03197         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03198         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(attach_instance->composite_value, 5);
03199         if (item_value == NULL)
03200         {
03201             result = __LINE__;
03202         }
03203         else
03204         {
03205             *source_value = item_value;
03206             result = 0;
03207         }
03208     }
03209 
03210     return result;
03211 }
03212 
03213 int attach_set_source(ATTACH_HANDLE attach, AMQP_VALUE source_value)
03214 {
03215     int result;
03216 
03217     if (attach == NULL)
03218     {
03219         result = __LINE__;
03220     }
03221     else
03222     {
03223         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03224         AMQP_VALUE source_amqp_value = amqpvalue_clone(source_value);
03225         if (source_amqp_value == NULL)
03226         {
03227             result = __LINE__;
03228         }
03229         else
03230         {
03231             if (amqpvalue_set_composite_item(attach_instance->composite_value, 5, source_amqp_value) != 0)
03232             {
03233                 result = __LINE__;
03234             }
03235             else
03236             {
03237                 result = 0;
03238             }
03239 
03240             amqpvalue_destroy(source_amqp_value);
03241         }
03242     }
03243 
03244     return result;
03245 }
03246 
03247 int attach_get_target(ATTACH_HANDLE attach, AMQP_VALUE* target_value)
03248 {
03249     int result;
03250 
03251     if (attach == NULL)
03252     {
03253         result = __LINE__;
03254     }
03255     else
03256     {
03257         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03258         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(attach_instance->composite_value, 6);
03259         if (item_value == NULL)
03260         {
03261             result = __LINE__;
03262         }
03263         else
03264         {
03265             *target_value = item_value;
03266             result = 0;
03267         }
03268     }
03269 
03270     return result;
03271 }
03272 
03273 int attach_set_target(ATTACH_HANDLE attach, AMQP_VALUE target_value)
03274 {
03275     int result;
03276 
03277     if (attach == NULL)
03278     {
03279         result = __LINE__;
03280     }
03281     else
03282     {
03283         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03284         AMQP_VALUE target_amqp_value = amqpvalue_clone(target_value);
03285         if (target_amqp_value == NULL)
03286         {
03287             result = __LINE__;
03288         }
03289         else
03290         {
03291             if (amqpvalue_set_composite_item(attach_instance->composite_value, 6, target_amqp_value) != 0)
03292             {
03293                 result = __LINE__;
03294             }
03295             else
03296             {
03297                 result = 0;
03298             }
03299 
03300             amqpvalue_destroy(target_amqp_value);
03301         }
03302     }
03303 
03304     return result;
03305 }
03306 
03307 int attach_get_unsettled(ATTACH_HANDLE attach, AMQP_VALUE* unsettled_value)
03308 {
03309     int result;
03310 
03311     if (attach == NULL)
03312     {
03313         result = __LINE__;
03314     }
03315     else
03316     {
03317         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03318         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(attach_instance->composite_value, 7);
03319         if (item_value == NULL)
03320         {
03321             result = __LINE__;
03322         }
03323         else
03324         {
03325             if (amqpvalue_get_map(item_value, unsettled_value) != 0)
03326             {
03327                 result = __LINE__;
03328             }
03329             else
03330             {
03331                 result = 0;
03332             }
03333         }
03334     }
03335 
03336     return result;
03337 }
03338 
03339 int attach_set_unsettled(ATTACH_HANDLE attach, AMQP_VALUE unsettled_value)
03340 {
03341     int result;
03342 
03343     if (attach == NULL)
03344     {
03345         result = __LINE__;
03346     }
03347     else
03348     {
03349         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03350         AMQP_VALUE unsettled_amqp_value = amqpvalue_clone(unsettled_value);
03351         if (unsettled_amqp_value == NULL)
03352         {
03353             result = __LINE__;
03354         }
03355         else
03356         {
03357             if (amqpvalue_set_composite_item(attach_instance->composite_value, 7, unsettled_amqp_value) != 0)
03358             {
03359                 result = __LINE__;
03360             }
03361             else
03362             {
03363                 result = 0;
03364             }
03365 
03366             amqpvalue_destroy(unsettled_amqp_value);
03367         }
03368     }
03369 
03370     return result;
03371 }
03372 
03373 int attach_get_incomplete_unsettled(ATTACH_HANDLE attach, bool* incomplete_unsettled_value)
03374 {
03375     int result;
03376 
03377     if (attach == NULL)
03378     {
03379         result = __LINE__;
03380     }
03381     else
03382     {
03383         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03384         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(attach_instance->composite_value, 8);
03385         if (item_value == NULL)
03386         {
03387             result = __LINE__;
03388         }
03389         else
03390         {
03391             if (amqpvalue_get_boolean(item_value, incomplete_unsettled_value) != 0)
03392             {
03393                 result = __LINE__;
03394             }
03395             else
03396             {
03397                 result = 0;
03398             }
03399         }
03400     }
03401 
03402     return result;
03403 }
03404 
03405 int attach_set_incomplete_unsettled(ATTACH_HANDLE attach, bool incomplete_unsettled_value)
03406 {
03407     int result;
03408 
03409     if (attach == NULL)
03410     {
03411         result = __LINE__;
03412     }
03413     else
03414     {
03415         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03416         AMQP_VALUE incomplete_unsettled_amqp_value = amqpvalue_create_boolean(incomplete_unsettled_value);
03417         if (incomplete_unsettled_amqp_value == NULL)
03418         {
03419             result = __LINE__;
03420         }
03421         else
03422         {
03423             if (amqpvalue_set_composite_item(attach_instance->composite_value, 8, incomplete_unsettled_amqp_value) != 0)
03424             {
03425                 result = __LINE__;
03426             }
03427             else
03428             {
03429                 result = 0;
03430             }
03431 
03432             amqpvalue_destroy(incomplete_unsettled_amqp_value);
03433         }
03434     }
03435 
03436     return result;
03437 }
03438 
03439 int attach_get_initial_delivery_count(ATTACH_HANDLE attach, sequence_no* initial_delivery_count_value)
03440 {
03441     int result;
03442 
03443     if (attach == NULL)
03444     {
03445         result = __LINE__;
03446     }
03447     else
03448     {
03449         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03450         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(attach_instance->composite_value, 9);
03451         if (item_value == NULL)
03452         {
03453             result = __LINE__;
03454         }
03455         else
03456         {
03457             if (amqpvalue_get_sequence_no(item_value, initial_delivery_count_value) != 0)
03458             {
03459                 result = __LINE__;
03460             }
03461             else
03462             {
03463                 result = 0;
03464             }
03465         }
03466     }
03467 
03468     return result;
03469 }
03470 
03471 int attach_set_initial_delivery_count(ATTACH_HANDLE attach, sequence_no initial_delivery_count_value)
03472 {
03473     int result;
03474 
03475     if (attach == NULL)
03476     {
03477         result = __LINE__;
03478     }
03479     else
03480     {
03481         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03482         AMQP_VALUE initial_delivery_count_amqp_value = amqpvalue_create_sequence_no(initial_delivery_count_value);
03483         if (initial_delivery_count_amqp_value == NULL)
03484         {
03485             result = __LINE__;
03486         }
03487         else
03488         {
03489             if (amqpvalue_set_composite_item(attach_instance->composite_value, 9, initial_delivery_count_amqp_value) != 0)
03490             {
03491                 result = __LINE__;
03492             }
03493             else
03494             {
03495                 result = 0;
03496             }
03497 
03498             amqpvalue_destroy(initial_delivery_count_amqp_value);
03499         }
03500     }
03501 
03502     return result;
03503 }
03504 
03505 int attach_get_max_message_size(ATTACH_HANDLE attach, uint64_t* max_message_size_value)
03506 {
03507     int result;
03508 
03509     if (attach == NULL)
03510     {
03511         result = __LINE__;
03512     }
03513     else
03514     {
03515         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03516         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(attach_instance->composite_value, 10);
03517         if (item_value == NULL)
03518         {
03519             result = __LINE__;
03520         }
03521         else
03522         {
03523             if (amqpvalue_get_ulong(item_value, max_message_size_value) != 0)
03524             {
03525                 result = __LINE__;
03526             }
03527             else
03528             {
03529                 result = 0;
03530             }
03531         }
03532     }
03533 
03534     return result;
03535 }
03536 
03537 int attach_set_max_message_size(ATTACH_HANDLE attach, uint64_t max_message_size_value)
03538 {
03539     int result;
03540 
03541     if (attach == NULL)
03542     {
03543         result = __LINE__;
03544     }
03545     else
03546     {
03547         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03548         AMQP_VALUE max_message_size_amqp_value = amqpvalue_create_ulong(max_message_size_value);
03549         if (max_message_size_amqp_value == NULL)
03550         {
03551             result = __LINE__;
03552         }
03553         else
03554         {
03555             if (amqpvalue_set_composite_item(attach_instance->composite_value, 10, max_message_size_amqp_value) != 0)
03556             {
03557                 result = __LINE__;
03558             }
03559             else
03560             {
03561                 result = 0;
03562             }
03563 
03564             amqpvalue_destroy(max_message_size_amqp_value);
03565         }
03566     }
03567 
03568     return result;
03569 }
03570 
03571 int attach_get_offered_capabilities(ATTACH_HANDLE attach, AMQP_VALUE* offered_capabilities_value)
03572 {
03573     int result;
03574 
03575     if (attach == NULL)
03576     {
03577         result = __LINE__;
03578     }
03579     else
03580     {
03581         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03582         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(attach_instance->composite_value, 11);
03583         if (item_value == NULL)
03584         {
03585             result = __LINE__;
03586         }
03587         else
03588         {
03589             if (amqpvalue_get_array(item_value, offered_capabilities_value) != 0)
03590             {
03591                 result = __LINE__;
03592             }
03593             else
03594             {
03595                 result = 0;
03596             }
03597         }
03598     }
03599 
03600     return result;
03601 }
03602 
03603 int attach_set_offered_capabilities(ATTACH_HANDLE attach, AMQP_VALUE offered_capabilities_value)
03604 {
03605     int result;
03606 
03607     if (attach == NULL)
03608     {
03609         result = __LINE__;
03610     }
03611     else
03612     {
03613         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03614         AMQP_VALUE offered_capabilities_amqp_value = amqpvalue_clone(offered_capabilities_value);
03615         if (offered_capabilities_amqp_value == NULL)
03616         {
03617             result = __LINE__;
03618         }
03619         else
03620         {
03621             if (amqpvalue_set_composite_item(attach_instance->composite_value, 11, offered_capabilities_amqp_value) != 0)
03622             {
03623                 result = __LINE__;
03624             }
03625             else
03626             {
03627                 result = 0;
03628             }
03629 
03630             amqpvalue_destroy(offered_capabilities_amqp_value);
03631         }
03632     }
03633 
03634     return result;
03635 }
03636 
03637 int attach_get_desired_capabilities(ATTACH_HANDLE attach, AMQP_VALUE* desired_capabilities_value)
03638 {
03639     int result;
03640 
03641     if (attach == NULL)
03642     {
03643         result = __LINE__;
03644     }
03645     else
03646     {
03647         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03648         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(attach_instance->composite_value, 12);
03649         if (item_value == NULL)
03650         {
03651             result = __LINE__;
03652         }
03653         else
03654         {
03655             if (amqpvalue_get_array(item_value, desired_capabilities_value) != 0)
03656             {
03657                 result = __LINE__;
03658             }
03659             else
03660             {
03661                 result = 0;
03662             }
03663         }
03664     }
03665 
03666     return result;
03667 }
03668 
03669 int attach_set_desired_capabilities(ATTACH_HANDLE attach, AMQP_VALUE desired_capabilities_value)
03670 {
03671     int result;
03672 
03673     if (attach == NULL)
03674     {
03675         result = __LINE__;
03676     }
03677     else
03678     {
03679         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03680         AMQP_VALUE desired_capabilities_amqp_value = amqpvalue_clone(desired_capabilities_value);
03681         if (desired_capabilities_amqp_value == NULL)
03682         {
03683             result = __LINE__;
03684         }
03685         else
03686         {
03687             if (amqpvalue_set_composite_item(attach_instance->composite_value, 12, desired_capabilities_amqp_value) != 0)
03688             {
03689                 result = __LINE__;
03690             }
03691             else
03692             {
03693                 result = 0;
03694             }
03695 
03696             amqpvalue_destroy(desired_capabilities_amqp_value);
03697         }
03698     }
03699 
03700     return result;
03701 }
03702 
03703 int attach_get_properties(ATTACH_HANDLE attach, fields* properties_value)
03704 {
03705     int result;
03706 
03707     if (attach == NULL)
03708     {
03709         result = __LINE__;
03710     }
03711     else
03712     {
03713         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03714         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(attach_instance->composite_value, 13);
03715         if (item_value == NULL)
03716         {
03717             result = __LINE__;
03718         }
03719         else
03720         {
03721             if (amqpvalue_get_fields(item_value, properties_value) != 0)
03722             {
03723                 result = __LINE__;
03724             }
03725             else
03726             {
03727                 result = 0;
03728             }
03729         }
03730     }
03731 
03732     return result;
03733 }
03734 
03735 int attach_set_properties(ATTACH_HANDLE attach, fields properties_value)
03736 {
03737     int result;
03738 
03739     if (attach == NULL)
03740     {
03741         result = __LINE__;
03742     }
03743     else
03744     {
03745         ATTACH_INSTANCE* attach_instance = (ATTACH_INSTANCE*)attach;
03746         AMQP_VALUE properties_amqp_value = amqpvalue_create_fields(properties_value);
03747         if (properties_amqp_value == NULL)
03748         {
03749             result = __LINE__;
03750         }
03751         else
03752         {
03753             if (amqpvalue_set_composite_item(attach_instance->composite_value, 13, properties_amqp_value) != 0)
03754             {
03755                 result = __LINE__;
03756             }
03757             else
03758             {
03759                 result = 0;
03760             }
03761 
03762             amqpvalue_destroy(properties_amqp_value);
03763         }
03764     }
03765 
03766     return result;
03767 }
03768 
03769 
03770 /* flow */
03771 
03772 typedef struct FLOW_INSTANCE_TAG
03773 {
03774     AMQP_VALUE composite_value;
03775 } FLOW_INSTANCE;
03776 
03777 static FLOW_HANDLE flow_create_internal(void)
03778 {
03779     FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)amqpalloc_malloc(sizeof(FLOW_INSTANCE));
03780     if (flow_instance != NULL)
03781     {
03782         flow_instance->composite_value = NULL;
03783     }
03784 
03785     return flow_instance;
03786 }
03787 
03788 FLOW_HANDLE flow_create(uint32_t incoming_window_value, transfer_number next_outgoing_id_value, uint32_t outgoing_window_value)
03789 {
03790     FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)amqpalloc_malloc(sizeof(FLOW_INSTANCE));
03791     if (flow_instance != NULL)
03792     {
03793         flow_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(19);
03794         if (flow_instance->composite_value == NULL)
03795         {
03796             amqpalloc_free(flow_instance);
03797             flow_instance = NULL;
03798         }
03799         else
03800         {
03801             AMQP_VALUE incoming_window_amqp_value;
03802             AMQP_VALUE next_outgoing_id_amqp_value;
03803             AMQP_VALUE outgoing_window_amqp_value;
03804             int result = 0;
03805 
03806             incoming_window_amqp_value = amqpvalue_create_uint(incoming_window_value);
03807             if ((result == 0) && (amqpvalue_set_composite_item(flow_instance->composite_value, 1, incoming_window_amqp_value) != 0))
03808             {
03809                 result = __LINE__;
03810             }
03811             next_outgoing_id_amqp_value = amqpvalue_create_transfer_number(next_outgoing_id_value);
03812             if ((result == 0) && (amqpvalue_set_composite_item(flow_instance->composite_value, 2, next_outgoing_id_amqp_value) != 0))
03813             {
03814                 result = __LINE__;
03815             }
03816             outgoing_window_amqp_value = amqpvalue_create_uint(outgoing_window_value);
03817             if ((result == 0) && (amqpvalue_set_composite_item(flow_instance->composite_value, 3, outgoing_window_amqp_value) != 0))
03818             {
03819                 result = __LINE__;
03820             }
03821 
03822             amqpvalue_destroy(incoming_window_amqp_value);
03823             amqpvalue_destroy(next_outgoing_id_amqp_value);
03824             amqpvalue_destroy(outgoing_window_amqp_value);
03825         }
03826     }
03827 
03828     return flow_instance;
03829 }
03830 
03831 FLOW_HANDLE flow_clone(FLOW_HANDLE value)
03832 {
03833     FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)amqpalloc_malloc(sizeof(FLOW_INSTANCE));
03834     if (flow_instance != NULL)
03835     {
03836         flow_instance->composite_value = amqpvalue_clone(((FLOW_INSTANCE*)value)->composite_value);
03837         if (flow_instance->composite_value == NULL)
03838         {
03839             amqpalloc_free(flow_instance);
03840             flow_instance = NULL;
03841         }
03842     }
03843 
03844     return flow_instance;
03845 }
03846 
03847 void flow_destroy(FLOW_HANDLE flow)
03848 {
03849     if (flow != NULL)
03850     {
03851         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
03852         amqpvalue_destroy(flow_instance->composite_value);
03853         amqpalloc_free(flow_instance);
03854     }
03855 }
03856 
03857 AMQP_VALUE amqpvalue_create_flow(FLOW_HANDLE flow)
03858 {
03859     AMQP_VALUE result;
03860 
03861     if (flow == NULL)
03862     {
03863         result = NULL;
03864     }
03865     else
03866     {
03867         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
03868         result = amqpvalue_clone(flow_instance->composite_value);
03869     }
03870 
03871     return result;
03872 }
03873 
03874 bool is_flow_type_by_descriptor(AMQP_VALUE descriptor)
03875 {
03876     bool result;
03877 
03878     uint64_t descriptor_ulong;
03879     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
03880         (descriptor_ulong == 19))
03881     {
03882         result = true;
03883     }
03884     else
03885     {
03886         result = false;
03887     }
03888 
03889     return result;
03890 }
03891 
03892 
03893 int amqpvalue_get_flow(AMQP_VALUE value, FLOW_HANDLE* flow_handle)
03894 {
03895     int result;
03896     FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow_create_internal();
03897     *flow_handle = flow_instance;
03898     if (*flow_handle == NULL)
03899     {
03900         result = __LINE__;
03901     }
03902     else
03903     {
03904         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
03905         if (list_value == NULL)
03906         {
03907             flow_destroy(*flow_handle);
03908             result = __LINE__;
03909         }
03910         else
03911         {
03912             do
03913             {
03914                 AMQP_VALUE item_value;
03915                 /* next-incoming-id */
03916                 item_value = amqpvalue_get_list_item(list_value, 0);
03917                 if (item_value == NULL)
03918                 {
03919                     /* do nothing */
03920                 }
03921                 else
03922                 {
03923                     transfer_number next_incoming_id;
03924                     if (amqpvalue_get_transfer_number(item_value, &next_incoming_id) != 0)
03925                     {
03926                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
03927                         {
03928                             flow_destroy(*flow_handle);
03929                             result = __LINE__;
03930                             break;
03931                         }
03932                     }
03933 
03934                     amqpvalue_destroy(item_value);
03935                 }
03936                 /* incoming-window */
03937                 item_value = amqpvalue_get_list_item(list_value, 1);
03938                 if (item_value == NULL)
03939                 {
03940                     {
03941                         flow_destroy(*flow_handle);
03942                         result = __LINE__;
03943                         break;
03944                     }
03945                 }
03946                 else
03947                 {
03948                     uint32_t incoming_window;
03949                     if (amqpvalue_get_uint(item_value, &incoming_window) != 0)
03950                     {
03951                         flow_destroy(*flow_handle);
03952                         result = __LINE__;
03953                         break;
03954                     }
03955 
03956                     amqpvalue_destroy(item_value);
03957                 }
03958                 /* next-outgoing-id */
03959                 item_value = amqpvalue_get_list_item(list_value, 2);
03960                 if (item_value == NULL)
03961                 {
03962                     {
03963                         flow_destroy(*flow_handle);
03964                         result = __LINE__;
03965                         break;
03966                     }
03967                 }
03968                 else
03969                 {
03970                     transfer_number next_outgoing_id;
03971                     if (amqpvalue_get_transfer_number(item_value, &next_outgoing_id) != 0)
03972                     {
03973                         flow_destroy(*flow_handle);
03974                         result = __LINE__;
03975                         break;
03976                     }
03977 
03978                     amqpvalue_destroy(item_value);
03979                 }
03980                 /* outgoing-window */
03981                 item_value = amqpvalue_get_list_item(list_value, 3);
03982                 if (item_value == NULL)
03983                 {
03984                     {
03985                         flow_destroy(*flow_handle);
03986                         result = __LINE__;
03987                         break;
03988                     }
03989                 }
03990                 else
03991                 {
03992                     uint32_t outgoing_window;
03993                     if (amqpvalue_get_uint(item_value, &outgoing_window) != 0)
03994                     {
03995                         flow_destroy(*flow_handle);
03996                         result = __LINE__;
03997                         break;
03998                     }
03999 
04000                     amqpvalue_destroy(item_value);
04001                 }
04002                 /* handle */
04003                 item_value = amqpvalue_get_list_item(list_value, 4);
04004                 if (item_value == NULL)
04005                 {
04006                     /* do nothing */
04007                 }
04008                 else
04009                 {
04010                     handle handle;
04011                     if (amqpvalue_get_handle(item_value, &handle) != 0)
04012                     {
04013                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
04014                         {
04015                             flow_destroy(*flow_handle);
04016                             result = __LINE__;
04017                             break;
04018                         }
04019                     }
04020 
04021                     amqpvalue_destroy(item_value);
04022                 }
04023                 /* delivery-count */
04024                 item_value = amqpvalue_get_list_item(list_value, 5);
04025                 if (item_value == NULL)
04026                 {
04027                     /* do nothing */
04028                 }
04029                 else
04030                 {
04031                     sequence_no delivery_count;
04032                     if (amqpvalue_get_sequence_no(item_value, &delivery_count) != 0)
04033                     {
04034                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
04035                         {
04036                             flow_destroy(*flow_handle);
04037                             result = __LINE__;
04038                             break;
04039                         }
04040                     }
04041 
04042                     amqpvalue_destroy(item_value);
04043                 }
04044                 /* link-credit */
04045                 item_value = amqpvalue_get_list_item(list_value, 6);
04046                 if (item_value == NULL)
04047                 {
04048                     /* do nothing */
04049                 }
04050                 else
04051                 {
04052                     uint32_t link_credit;
04053                     if (amqpvalue_get_uint(item_value, &link_credit) != 0)
04054                     {
04055                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
04056                         {
04057                             flow_destroy(*flow_handle);
04058                             result = __LINE__;
04059                             break;
04060                         }
04061                     }
04062 
04063                     amqpvalue_destroy(item_value);
04064                 }
04065                 /* available */
04066                 item_value = amqpvalue_get_list_item(list_value, 7);
04067                 if (item_value == NULL)
04068                 {
04069                     /* do nothing */
04070                 }
04071                 else
04072                 {
04073                     uint32_t available;
04074                     if (amqpvalue_get_uint(item_value, &available) != 0)
04075                     {
04076                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
04077                         {
04078                             flow_destroy(*flow_handle);
04079                             result = __LINE__;
04080                             break;
04081                         }
04082                     }
04083 
04084                     amqpvalue_destroy(item_value);
04085                 }
04086                 /* drain */
04087                 item_value = amqpvalue_get_list_item(list_value, 8);
04088                 if (item_value == NULL)
04089                 {
04090                     /* do nothing */
04091                 }
04092                 else
04093                 {
04094                     bool drain;
04095                     if (amqpvalue_get_boolean(item_value, &drain) != 0)
04096                     {
04097                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
04098                         {
04099                             flow_destroy(*flow_handle);
04100                             result = __LINE__;
04101                             break;
04102                         }
04103                     }
04104 
04105                     amqpvalue_destroy(item_value);
04106                 }
04107                 /* echo */
04108                 item_value = amqpvalue_get_list_item(list_value, 9);
04109                 if (item_value == NULL)
04110                 {
04111                     /* do nothing */
04112                 }
04113                 else
04114                 {
04115                     bool echo;
04116                     if (amqpvalue_get_boolean(item_value, &echo) != 0)
04117                     {
04118                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
04119                         {
04120                             flow_destroy(*flow_handle);
04121                             result = __LINE__;
04122                             break;
04123                         }
04124                     }
04125 
04126                     amqpvalue_destroy(item_value);
04127                 }
04128                 /* properties */
04129                 item_value = amqpvalue_get_list_item(list_value, 10);
04130                 if (item_value == NULL)
04131                 {
04132                     /* do nothing */
04133                 }
04134                 else
04135                 {
04136                     fields properties;
04137                     if (amqpvalue_get_fields(item_value, &properties) != 0)
04138                     {
04139                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
04140                         {
04141                             flow_destroy(*flow_handle);
04142                             result = __LINE__;
04143                             break;
04144                         }
04145                     }
04146 
04147                     amqpvalue_destroy(item_value);
04148                 }
04149 
04150                 flow_instance->composite_value = amqpvalue_clone(value);
04151 
04152                 result = 0;
04153             } while (0);
04154         }
04155     }
04156 
04157     return result;
04158 }
04159 
04160 int flow_get_next_incoming_id(FLOW_HANDLE flow, transfer_number* next_incoming_id_value)
04161 {
04162     int result;
04163 
04164     if (flow == NULL)
04165     {
04166         result = __LINE__;
04167     }
04168     else
04169     {
04170         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04171         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(flow_instance->composite_value, 0);
04172         if (item_value == NULL)
04173         {
04174             result = __LINE__;
04175         }
04176         else
04177         {
04178             if (amqpvalue_get_transfer_number(item_value, next_incoming_id_value) != 0)
04179             {
04180                 result = __LINE__;
04181             }
04182             else
04183             {
04184                 result = 0;
04185             }
04186         }
04187     }
04188 
04189     return result;
04190 }
04191 
04192 int flow_set_next_incoming_id(FLOW_HANDLE flow, transfer_number next_incoming_id_value)
04193 {
04194     int result;
04195 
04196     if (flow == NULL)
04197     {
04198         result = __LINE__;
04199     }
04200     else
04201     {
04202         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04203         AMQP_VALUE next_incoming_id_amqp_value = amqpvalue_create_transfer_number(next_incoming_id_value);
04204         if (next_incoming_id_amqp_value == NULL)
04205         {
04206             result = __LINE__;
04207         }
04208         else
04209         {
04210             if (amqpvalue_set_composite_item(flow_instance->composite_value, 0, next_incoming_id_amqp_value) != 0)
04211             {
04212                 result = __LINE__;
04213             }
04214             else
04215             {
04216                 result = 0;
04217             }
04218 
04219             amqpvalue_destroy(next_incoming_id_amqp_value);
04220         }
04221     }
04222 
04223     return result;
04224 }
04225 
04226 int flow_get_incoming_window(FLOW_HANDLE flow, uint32_t* incoming_window_value)
04227 {
04228     int result;
04229 
04230     if (flow == NULL)
04231     {
04232         result = __LINE__;
04233     }
04234     else
04235     {
04236         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04237         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(flow_instance->composite_value, 1);
04238         if (item_value == NULL)
04239         {
04240             result = __LINE__;
04241         }
04242         else
04243         {
04244             if (amqpvalue_get_uint(item_value, incoming_window_value) != 0)
04245             {
04246                 result = __LINE__;
04247             }
04248             else
04249             {
04250                 result = 0;
04251             }
04252         }
04253     }
04254 
04255     return result;
04256 }
04257 
04258 int flow_set_incoming_window(FLOW_HANDLE flow, uint32_t incoming_window_value)
04259 {
04260     int result;
04261 
04262     if (flow == NULL)
04263     {
04264         result = __LINE__;
04265     }
04266     else
04267     {
04268         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04269         AMQP_VALUE incoming_window_amqp_value = amqpvalue_create_uint(incoming_window_value);
04270         if (incoming_window_amqp_value == NULL)
04271         {
04272             result = __LINE__;
04273         }
04274         else
04275         {
04276             if (amqpvalue_set_composite_item(flow_instance->composite_value, 1, incoming_window_amqp_value) != 0)
04277             {
04278                 result = __LINE__;
04279             }
04280             else
04281             {
04282                 result = 0;
04283             }
04284 
04285             amqpvalue_destroy(incoming_window_amqp_value);
04286         }
04287     }
04288 
04289     return result;
04290 }
04291 
04292 int flow_get_next_outgoing_id(FLOW_HANDLE flow, transfer_number* next_outgoing_id_value)
04293 {
04294     int result;
04295 
04296     if (flow == NULL)
04297     {
04298         result = __LINE__;
04299     }
04300     else
04301     {
04302         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04303         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(flow_instance->composite_value, 2);
04304         if (item_value == NULL)
04305         {
04306             result = __LINE__;
04307         }
04308         else
04309         {
04310             if (amqpvalue_get_transfer_number(item_value, next_outgoing_id_value) != 0)
04311             {
04312                 result = __LINE__;
04313             }
04314             else
04315             {
04316                 result = 0;
04317             }
04318         }
04319     }
04320 
04321     return result;
04322 }
04323 
04324 int flow_set_next_outgoing_id(FLOW_HANDLE flow, transfer_number next_outgoing_id_value)
04325 {
04326     int result;
04327 
04328     if (flow == NULL)
04329     {
04330         result = __LINE__;
04331     }
04332     else
04333     {
04334         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04335         AMQP_VALUE next_outgoing_id_amqp_value = amqpvalue_create_transfer_number(next_outgoing_id_value);
04336         if (next_outgoing_id_amqp_value == NULL)
04337         {
04338             result = __LINE__;
04339         }
04340         else
04341         {
04342             if (amqpvalue_set_composite_item(flow_instance->composite_value, 2, next_outgoing_id_amqp_value) != 0)
04343             {
04344                 result = __LINE__;
04345             }
04346             else
04347             {
04348                 result = 0;
04349             }
04350 
04351             amqpvalue_destroy(next_outgoing_id_amqp_value);
04352         }
04353     }
04354 
04355     return result;
04356 }
04357 
04358 int flow_get_outgoing_window(FLOW_HANDLE flow, uint32_t* outgoing_window_value)
04359 {
04360     int result;
04361 
04362     if (flow == NULL)
04363     {
04364         result = __LINE__;
04365     }
04366     else
04367     {
04368         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04369         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(flow_instance->composite_value, 3);
04370         if (item_value == NULL)
04371         {
04372             result = __LINE__;
04373         }
04374         else
04375         {
04376             if (amqpvalue_get_uint(item_value, outgoing_window_value) != 0)
04377             {
04378                 result = __LINE__;
04379             }
04380             else
04381             {
04382                 result = 0;
04383             }
04384         }
04385     }
04386 
04387     return result;
04388 }
04389 
04390 int flow_set_outgoing_window(FLOW_HANDLE flow, uint32_t outgoing_window_value)
04391 {
04392     int result;
04393 
04394     if (flow == NULL)
04395     {
04396         result = __LINE__;
04397     }
04398     else
04399     {
04400         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04401         AMQP_VALUE outgoing_window_amqp_value = amqpvalue_create_uint(outgoing_window_value);
04402         if (outgoing_window_amqp_value == NULL)
04403         {
04404             result = __LINE__;
04405         }
04406         else
04407         {
04408             if (amqpvalue_set_composite_item(flow_instance->composite_value, 3, outgoing_window_amqp_value) != 0)
04409             {
04410                 result = __LINE__;
04411             }
04412             else
04413             {
04414                 result = 0;
04415             }
04416 
04417             amqpvalue_destroy(outgoing_window_amqp_value);
04418         }
04419     }
04420 
04421     return result;
04422 }
04423 
04424 int flow_get_handle(FLOW_HANDLE flow, handle* handle_value)
04425 {
04426     int result;
04427 
04428     if (flow == NULL)
04429     {
04430         result = __LINE__;
04431     }
04432     else
04433     {
04434         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04435         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(flow_instance->composite_value, 4);
04436         if (item_value == NULL)
04437         {
04438             result = __LINE__;
04439         }
04440         else
04441         {
04442             if (amqpvalue_get_handle(item_value, handle_value) != 0)
04443             {
04444                 result = __LINE__;
04445             }
04446             else
04447             {
04448                 result = 0;
04449             }
04450         }
04451     }
04452 
04453     return result;
04454 }
04455 
04456 int flow_set_handle(FLOW_HANDLE flow, handle handle_value)
04457 {
04458     int result;
04459 
04460     if (flow == NULL)
04461     {
04462         result = __LINE__;
04463     }
04464     else
04465     {
04466         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04467         AMQP_VALUE handle_amqp_value = amqpvalue_create_handle(handle_value);
04468         if (handle_amqp_value == NULL)
04469         {
04470             result = __LINE__;
04471         }
04472         else
04473         {
04474             if (amqpvalue_set_composite_item(flow_instance->composite_value, 4, handle_amqp_value) != 0)
04475             {
04476                 result = __LINE__;
04477             }
04478             else
04479             {
04480                 result = 0;
04481             }
04482 
04483             amqpvalue_destroy(handle_amqp_value);
04484         }
04485     }
04486 
04487     return result;
04488 }
04489 
04490 int flow_get_delivery_count(FLOW_HANDLE flow, sequence_no* delivery_count_value)
04491 {
04492     int result;
04493 
04494     if (flow == NULL)
04495     {
04496         result = __LINE__;
04497     }
04498     else
04499     {
04500         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04501         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(flow_instance->composite_value, 5);
04502         if (item_value == NULL)
04503         {
04504             result = __LINE__;
04505         }
04506         else
04507         {
04508             if (amqpvalue_get_sequence_no(item_value, delivery_count_value) != 0)
04509             {
04510                 result = __LINE__;
04511             }
04512             else
04513             {
04514                 result = 0;
04515             }
04516         }
04517     }
04518 
04519     return result;
04520 }
04521 
04522 int flow_set_delivery_count(FLOW_HANDLE flow, sequence_no delivery_count_value)
04523 {
04524     int result;
04525 
04526     if (flow == NULL)
04527     {
04528         result = __LINE__;
04529     }
04530     else
04531     {
04532         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04533         AMQP_VALUE delivery_count_amqp_value = amqpvalue_create_sequence_no(delivery_count_value);
04534         if (delivery_count_amqp_value == NULL)
04535         {
04536             result = __LINE__;
04537         }
04538         else
04539         {
04540             if (amqpvalue_set_composite_item(flow_instance->composite_value, 5, delivery_count_amqp_value) != 0)
04541             {
04542                 result = __LINE__;
04543             }
04544             else
04545             {
04546                 result = 0;
04547             }
04548 
04549             amqpvalue_destroy(delivery_count_amqp_value);
04550         }
04551     }
04552 
04553     return result;
04554 }
04555 
04556 int flow_get_link_credit(FLOW_HANDLE flow, uint32_t* link_credit_value)
04557 {
04558     int result;
04559 
04560     if (flow == NULL)
04561     {
04562         result = __LINE__;
04563     }
04564     else
04565     {
04566         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04567         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(flow_instance->composite_value, 6);
04568         if (item_value == NULL)
04569         {
04570             result = __LINE__;
04571         }
04572         else
04573         {
04574             if (amqpvalue_get_uint(item_value, link_credit_value) != 0)
04575             {
04576                 result = __LINE__;
04577             }
04578             else
04579             {
04580                 result = 0;
04581             }
04582         }
04583     }
04584 
04585     return result;
04586 }
04587 
04588 int flow_set_link_credit(FLOW_HANDLE flow, uint32_t link_credit_value)
04589 {
04590     int result;
04591 
04592     if (flow == NULL)
04593     {
04594         result = __LINE__;
04595     }
04596     else
04597     {
04598         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04599         AMQP_VALUE link_credit_amqp_value = amqpvalue_create_uint(link_credit_value);
04600         if (link_credit_amqp_value == NULL)
04601         {
04602             result = __LINE__;
04603         }
04604         else
04605         {
04606             if (amqpvalue_set_composite_item(flow_instance->composite_value, 6, link_credit_amqp_value) != 0)
04607             {
04608                 result = __LINE__;
04609             }
04610             else
04611             {
04612                 result = 0;
04613             }
04614 
04615             amqpvalue_destroy(link_credit_amqp_value);
04616         }
04617     }
04618 
04619     return result;
04620 }
04621 
04622 int flow_get_available(FLOW_HANDLE flow, uint32_t* available_value)
04623 {
04624     int result;
04625 
04626     if (flow == NULL)
04627     {
04628         result = __LINE__;
04629     }
04630     else
04631     {
04632         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04633         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(flow_instance->composite_value, 7);
04634         if (item_value == NULL)
04635         {
04636             result = __LINE__;
04637         }
04638         else
04639         {
04640             if (amqpvalue_get_uint(item_value, available_value) != 0)
04641             {
04642                 result = __LINE__;
04643             }
04644             else
04645             {
04646                 result = 0;
04647             }
04648         }
04649     }
04650 
04651     return result;
04652 }
04653 
04654 int flow_set_available(FLOW_HANDLE flow, uint32_t available_value)
04655 {
04656     int result;
04657 
04658     if (flow == NULL)
04659     {
04660         result = __LINE__;
04661     }
04662     else
04663     {
04664         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04665         AMQP_VALUE available_amqp_value = amqpvalue_create_uint(available_value);
04666         if (available_amqp_value == NULL)
04667         {
04668             result = __LINE__;
04669         }
04670         else
04671         {
04672             if (amqpvalue_set_composite_item(flow_instance->composite_value, 7, available_amqp_value) != 0)
04673             {
04674                 result = __LINE__;
04675             }
04676             else
04677             {
04678                 result = 0;
04679             }
04680 
04681             amqpvalue_destroy(available_amqp_value);
04682         }
04683     }
04684 
04685     return result;
04686 }
04687 
04688 int flow_get_drain(FLOW_HANDLE flow, bool* drain_value)
04689 {
04690     int result;
04691 
04692     if (flow == NULL)
04693     {
04694         result = __LINE__;
04695     }
04696     else
04697     {
04698         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04699         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(flow_instance->composite_value, 8);
04700         if (item_value == NULL)
04701         {
04702             result = __LINE__;
04703         }
04704         else
04705         {
04706             if (amqpvalue_get_boolean(item_value, drain_value) != 0)
04707             {
04708                 result = __LINE__;
04709             }
04710             else
04711             {
04712                 result = 0;
04713             }
04714         }
04715     }
04716 
04717     return result;
04718 }
04719 
04720 int flow_set_drain(FLOW_HANDLE flow, bool drain_value)
04721 {
04722     int result;
04723 
04724     if (flow == NULL)
04725     {
04726         result = __LINE__;
04727     }
04728     else
04729     {
04730         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04731         AMQP_VALUE drain_amqp_value = amqpvalue_create_boolean(drain_value);
04732         if (drain_amqp_value == NULL)
04733         {
04734             result = __LINE__;
04735         }
04736         else
04737         {
04738             if (amqpvalue_set_composite_item(flow_instance->composite_value, 8, drain_amqp_value) != 0)
04739             {
04740                 result = __LINE__;
04741             }
04742             else
04743             {
04744                 result = 0;
04745             }
04746 
04747             amqpvalue_destroy(drain_amqp_value);
04748         }
04749     }
04750 
04751     return result;
04752 }
04753 
04754 int flow_get_echo(FLOW_HANDLE flow, bool* echo_value)
04755 {
04756     int result;
04757 
04758     if (flow == NULL)
04759     {
04760         result = __LINE__;
04761     }
04762     else
04763     {
04764         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04765         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(flow_instance->composite_value, 9);
04766         if (item_value == NULL)
04767         {
04768             result = __LINE__;
04769         }
04770         else
04771         {
04772             if (amqpvalue_get_boolean(item_value, echo_value) != 0)
04773             {
04774                 result = __LINE__;
04775             }
04776             else
04777             {
04778                 result = 0;
04779             }
04780         }
04781     }
04782 
04783     return result;
04784 }
04785 
04786 int flow_set_echo(FLOW_HANDLE flow, bool echo_value)
04787 {
04788     int result;
04789 
04790     if (flow == NULL)
04791     {
04792         result = __LINE__;
04793     }
04794     else
04795     {
04796         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04797         AMQP_VALUE echo_amqp_value = amqpvalue_create_boolean(echo_value);
04798         if (echo_amqp_value == NULL)
04799         {
04800             result = __LINE__;
04801         }
04802         else
04803         {
04804             if (amqpvalue_set_composite_item(flow_instance->composite_value, 9, echo_amqp_value) != 0)
04805             {
04806                 result = __LINE__;
04807             }
04808             else
04809             {
04810                 result = 0;
04811             }
04812 
04813             amqpvalue_destroy(echo_amqp_value);
04814         }
04815     }
04816 
04817     return result;
04818 }
04819 
04820 int flow_get_properties(FLOW_HANDLE flow, fields* properties_value)
04821 {
04822     int result;
04823 
04824     if (flow == NULL)
04825     {
04826         result = __LINE__;
04827     }
04828     else
04829     {
04830         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04831         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(flow_instance->composite_value, 10);
04832         if (item_value == NULL)
04833         {
04834             result = __LINE__;
04835         }
04836         else
04837         {
04838             if (amqpvalue_get_fields(item_value, properties_value) != 0)
04839             {
04840                 result = __LINE__;
04841             }
04842             else
04843             {
04844                 result = 0;
04845             }
04846         }
04847     }
04848 
04849     return result;
04850 }
04851 
04852 int flow_set_properties(FLOW_HANDLE flow, fields properties_value)
04853 {
04854     int result;
04855 
04856     if (flow == NULL)
04857     {
04858         result = __LINE__;
04859     }
04860     else
04861     {
04862         FLOW_INSTANCE* flow_instance = (FLOW_INSTANCE*)flow;
04863         AMQP_VALUE properties_amqp_value = amqpvalue_create_fields(properties_value);
04864         if (properties_amqp_value == NULL)
04865         {
04866             result = __LINE__;
04867         }
04868         else
04869         {
04870             if (amqpvalue_set_composite_item(flow_instance->composite_value, 10, properties_amqp_value) != 0)
04871             {
04872                 result = __LINE__;
04873             }
04874             else
04875             {
04876                 result = 0;
04877             }
04878 
04879             amqpvalue_destroy(properties_amqp_value);
04880         }
04881     }
04882 
04883     return result;
04884 }
04885 
04886 
04887 /* transfer */
04888 
04889 typedef struct TRANSFER_INSTANCE_TAG
04890 {
04891     AMQP_VALUE composite_value;
04892 } TRANSFER_INSTANCE;
04893 
04894 static TRANSFER_HANDLE transfer_create_internal(void)
04895 {
04896     TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)amqpalloc_malloc(sizeof(TRANSFER_INSTANCE));
04897     if (transfer_instance != NULL)
04898     {
04899         transfer_instance->composite_value = NULL;
04900     }
04901 
04902     return transfer_instance;
04903 }
04904 
04905 TRANSFER_HANDLE transfer_create(handle handle_value)
04906 {
04907     TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)amqpalloc_malloc(sizeof(TRANSFER_INSTANCE));
04908     if (transfer_instance != NULL)
04909     {
04910         transfer_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(20);
04911         if (transfer_instance->composite_value == NULL)
04912         {
04913             amqpalloc_free(transfer_instance);
04914             transfer_instance = NULL;
04915         }
04916         else
04917         {
04918             AMQP_VALUE handle_amqp_value;
04919             int result = 0;
04920 
04921             handle_amqp_value = amqpvalue_create_handle(handle_value);
04922             if ((result == 0) && (amqpvalue_set_composite_item(transfer_instance->composite_value, 0, handle_amqp_value) != 0))
04923             {
04924                 result = __LINE__;
04925             }
04926 
04927             amqpvalue_destroy(handle_amqp_value);
04928         }
04929     }
04930 
04931     return transfer_instance;
04932 }
04933 
04934 TRANSFER_HANDLE transfer_clone(TRANSFER_HANDLE value)
04935 {
04936     TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)amqpalloc_malloc(sizeof(TRANSFER_INSTANCE));
04937     if (transfer_instance != NULL)
04938     {
04939         transfer_instance->composite_value = amqpvalue_clone(((TRANSFER_INSTANCE*)value)->composite_value);
04940         if (transfer_instance->composite_value == NULL)
04941         {
04942             amqpalloc_free(transfer_instance);
04943             transfer_instance = NULL;
04944         }
04945     }
04946 
04947     return transfer_instance;
04948 }
04949 
04950 void transfer_destroy(TRANSFER_HANDLE transfer)
04951 {
04952     if (transfer != NULL)
04953     {
04954         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
04955         amqpvalue_destroy(transfer_instance->composite_value);
04956         amqpalloc_free(transfer_instance);
04957     }
04958 }
04959 
04960 AMQP_VALUE amqpvalue_create_transfer(TRANSFER_HANDLE transfer)
04961 {
04962     AMQP_VALUE result;
04963 
04964     if (transfer == NULL)
04965     {
04966         result = NULL;
04967     }
04968     else
04969     {
04970         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
04971         result = amqpvalue_clone(transfer_instance->composite_value);
04972     }
04973 
04974     return result;
04975 }
04976 
04977 bool is_transfer_type_by_descriptor(AMQP_VALUE descriptor)
04978 {
04979     bool result;
04980 
04981     uint64_t descriptor_ulong;
04982     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
04983         (descriptor_ulong == 20))
04984     {
04985         result = true;
04986     }
04987     else
04988     {
04989         result = false;
04990     }
04991 
04992     return result;
04993 }
04994 
04995 
04996 int amqpvalue_get_transfer(AMQP_VALUE value, TRANSFER_HANDLE* transfer_handle)
04997 {
04998     int result;
04999     TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer_create_internal();
05000     *transfer_handle = transfer_instance;
05001     if (*transfer_handle == NULL)
05002     {
05003         result = __LINE__;
05004     }
05005     else
05006     {
05007         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
05008         if (list_value == NULL)
05009         {
05010             transfer_destroy(*transfer_handle);
05011             result = __LINE__;
05012         }
05013         else
05014         {
05015             do
05016             {
05017                 AMQP_VALUE item_value;
05018                 /* handle */
05019                 item_value = amqpvalue_get_list_item(list_value, 0);
05020                 if (item_value == NULL)
05021                 {
05022                     {
05023                         transfer_destroy(*transfer_handle);
05024                         result = __LINE__;
05025                         break;
05026                     }
05027                 }
05028                 else
05029                 {
05030                     handle handle;
05031                     if (amqpvalue_get_handle(item_value, &handle) != 0)
05032                     {
05033                         transfer_destroy(*transfer_handle);
05034                         result = __LINE__;
05035                         break;
05036                     }
05037 
05038                     amqpvalue_destroy(item_value);
05039                 }
05040                 /* delivery-id */
05041                 item_value = amqpvalue_get_list_item(list_value, 1);
05042                 if (item_value == NULL)
05043                 {
05044                     /* do nothing */
05045                 }
05046                 else
05047                 {
05048                     delivery_number delivery_id;
05049                     if (amqpvalue_get_delivery_number(item_value, &delivery_id) != 0)
05050                     {
05051                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
05052                         {
05053                             transfer_destroy(*transfer_handle);
05054                             result = __LINE__;
05055                             break;
05056                         }
05057                     }
05058 
05059                     amqpvalue_destroy(item_value);
05060                 }
05061                 /* delivery-tag */
05062                 item_value = amqpvalue_get_list_item(list_value, 2);
05063                 if (item_value == NULL)
05064                 {
05065                     /* do nothing */
05066                 }
05067                 else
05068                 {
05069                     delivery_tag delivery_tag;
05070                     if (amqpvalue_get_delivery_tag(item_value, &delivery_tag) != 0)
05071                     {
05072                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
05073                         {
05074                             transfer_destroy(*transfer_handle);
05075                             result = __LINE__;
05076                             break;
05077                         }
05078                     }
05079 
05080                     amqpvalue_destroy(item_value);
05081                 }
05082                 /* message-format */
05083                 item_value = amqpvalue_get_list_item(list_value, 3);
05084                 if (item_value == NULL)
05085                 {
05086                     /* do nothing */
05087                 }
05088                 else
05089                 {
05090                     message_format message_format;
05091                     if (amqpvalue_get_message_format(item_value, &message_format) != 0)
05092                     {
05093                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
05094                         {
05095                             transfer_destroy(*transfer_handle);
05096                             result = __LINE__;
05097                             break;
05098                         }
05099                     }
05100 
05101                     amqpvalue_destroy(item_value);
05102                 }
05103                 /* settled */
05104                 item_value = amqpvalue_get_list_item(list_value, 4);
05105                 if (item_value == NULL)
05106                 {
05107                     /* do nothing */
05108                 }
05109                 else
05110                 {
05111                     bool settled;
05112                     if (amqpvalue_get_boolean(item_value, &settled) != 0)
05113                     {
05114                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
05115                         {
05116                             transfer_destroy(*transfer_handle);
05117                             result = __LINE__;
05118                             break;
05119                         }
05120                     }
05121 
05122                     amqpvalue_destroy(item_value);
05123                 }
05124                 /* more */
05125                 item_value = amqpvalue_get_list_item(list_value, 5);
05126                 if (item_value == NULL)
05127                 {
05128                     /* do nothing */
05129                 }
05130                 else
05131                 {
05132                     bool more;
05133                     if (amqpvalue_get_boolean(item_value, &more) != 0)
05134                     {
05135                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
05136                         {
05137                             transfer_destroy(*transfer_handle);
05138                             result = __LINE__;
05139                             break;
05140                         }
05141                     }
05142 
05143                     amqpvalue_destroy(item_value);
05144                 }
05145                 /* rcv-settle-mode */
05146                 item_value = amqpvalue_get_list_item(list_value, 6);
05147                 if (item_value == NULL)
05148                 {
05149                     /* do nothing */
05150                 }
05151                 else
05152                 {
05153                     receiver_settle_mode rcv_settle_mode;
05154                     if (amqpvalue_get_receiver_settle_mode(item_value, &rcv_settle_mode) != 0)
05155                     {
05156                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
05157                         {
05158                             transfer_destroy(*transfer_handle);
05159                             result = __LINE__;
05160                             break;
05161                         }
05162                     }
05163 
05164                     amqpvalue_destroy(item_value);
05165                 }
05166                 /* state */
05167                 item_value = amqpvalue_get_list_item(list_value, 7);
05168                 if (item_value == NULL)
05169                 {
05170                     /* do nothing */
05171                 }
05172                 else
05173                 {
05174                     amqpvalue_destroy(item_value);
05175                 }
05176                 /* resume */
05177                 item_value = amqpvalue_get_list_item(list_value, 8);
05178                 if (item_value == NULL)
05179                 {
05180                     /* do nothing */
05181                 }
05182                 else
05183                 {
05184                     bool resume;
05185                     if (amqpvalue_get_boolean(item_value, &resume) != 0)
05186                     {
05187                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
05188                         {
05189                             transfer_destroy(*transfer_handle);
05190                             result = __LINE__;
05191                             break;
05192                         }
05193                     }
05194 
05195                     amqpvalue_destroy(item_value);
05196                 }
05197                 /* aborted */
05198                 item_value = amqpvalue_get_list_item(list_value, 9);
05199                 if (item_value == NULL)
05200                 {
05201                     /* do nothing */
05202                 }
05203                 else
05204                 {
05205                     bool aborted;
05206                     if (amqpvalue_get_boolean(item_value, &aborted) != 0)
05207                     {
05208                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
05209                         {
05210                             transfer_destroy(*transfer_handle);
05211                             result = __LINE__;
05212                             break;
05213                         }
05214                     }
05215 
05216                     amqpvalue_destroy(item_value);
05217                 }
05218                 /* batchable */
05219                 item_value = amqpvalue_get_list_item(list_value, 10);
05220                 if (item_value == NULL)
05221                 {
05222                     /* do nothing */
05223                 }
05224                 else
05225                 {
05226                     bool batchable;
05227                     if (amqpvalue_get_boolean(item_value, &batchable) != 0)
05228                     {
05229                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
05230                         {
05231                             transfer_destroy(*transfer_handle);
05232                             result = __LINE__;
05233                             break;
05234                         }
05235                     }
05236 
05237                     amqpvalue_destroy(item_value);
05238                 }
05239 
05240                 transfer_instance->composite_value = amqpvalue_clone(value);
05241 
05242                 result = 0;
05243             } while (0);
05244         }
05245     }
05246 
05247     return result;
05248 }
05249 
05250 int transfer_get_handle(TRANSFER_HANDLE transfer, handle* handle_value)
05251 {
05252     int result;
05253 
05254     if (transfer == NULL)
05255     {
05256         result = __LINE__;
05257     }
05258     else
05259     {
05260         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05261         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(transfer_instance->composite_value, 0);
05262         if (item_value == NULL)
05263         {
05264             result = __LINE__;
05265         }
05266         else
05267         {
05268             if (amqpvalue_get_handle(item_value, handle_value) != 0)
05269             {
05270                 result = __LINE__;
05271             }
05272             else
05273             {
05274                 result = 0;
05275             }
05276         }
05277     }
05278 
05279     return result;
05280 }
05281 
05282 int transfer_set_handle(TRANSFER_HANDLE transfer, handle handle_value)
05283 {
05284     int result;
05285 
05286     if (transfer == NULL)
05287     {
05288         result = __LINE__;
05289     }
05290     else
05291     {
05292         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05293         AMQP_VALUE handle_amqp_value = amqpvalue_create_handle(handle_value);
05294         if (handle_amqp_value == NULL)
05295         {
05296             result = __LINE__;
05297         }
05298         else
05299         {
05300             if (amqpvalue_set_composite_item(transfer_instance->composite_value, 0, handle_amqp_value) != 0)
05301             {
05302                 result = __LINE__;
05303             }
05304             else
05305             {
05306                 result = 0;
05307             }
05308 
05309             amqpvalue_destroy(handle_amqp_value);
05310         }
05311     }
05312 
05313     return result;
05314 }
05315 
05316 int transfer_get_delivery_id(TRANSFER_HANDLE transfer, delivery_number* delivery_id_value)
05317 {
05318     int result;
05319 
05320     if (transfer == NULL)
05321     {
05322         result = __LINE__;
05323     }
05324     else
05325     {
05326         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05327         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(transfer_instance->composite_value, 1);
05328         if (item_value == NULL)
05329         {
05330             result = __LINE__;
05331         }
05332         else
05333         {
05334             if (amqpvalue_get_delivery_number(item_value, delivery_id_value) != 0)
05335             {
05336                 result = __LINE__;
05337             }
05338             else
05339             {
05340                 result = 0;
05341             }
05342         }
05343     }
05344 
05345     return result;
05346 }
05347 
05348 int transfer_set_delivery_id(TRANSFER_HANDLE transfer, delivery_number delivery_id_value)
05349 {
05350     int result;
05351 
05352     if (transfer == NULL)
05353     {
05354         result = __LINE__;
05355     }
05356     else
05357     {
05358         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05359         AMQP_VALUE delivery_id_amqp_value = amqpvalue_create_delivery_number(delivery_id_value);
05360         if (delivery_id_amqp_value == NULL)
05361         {
05362             result = __LINE__;
05363         }
05364         else
05365         {
05366             if (amqpvalue_set_composite_item(transfer_instance->composite_value, 1, delivery_id_amqp_value) != 0)
05367             {
05368                 result = __LINE__;
05369             }
05370             else
05371             {
05372                 result = 0;
05373             }
05374 
05375             amqpvalue_destroy(delivery_id_amqp_value);
05376         }
05377     }
05378 
05379     return result;
05380 }
05381 
05382 int transfer_get_delivery_tag(TRANSFER_HANDLE transfer, delivery_tag* delivery_tag_value)
05383 {
05384     int result;
05385 
05386     if (transfer == NULL)
05387     {
05388         result = __LINE__;
05389     }
05390     else
05391     {
05392         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05393         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(transfer_instance->composite_value, 2);
05394         if (item_value == NULL)
05395         {
05396             result = __LINE__;
05397         }
05398         else
05399         {
05400             if (amqpvalue_get_delivery_tag(item_value, delivery_tag_value) != 0)
05401             {
05402                 result = __LINE__;
05403             }
05404             else
05405             {
05406                 result = 0;
05407             }
05408         }
05409     }
05410 
05411     return result;
05412 }
05413 
05414 int transfer_set_delivery_tag(TRANSFER_HANDLE transfer, delivery_tag delivery_tag_value)
05415 {
05416     int result;
05417 
05418     if (transfer == NULL)
05419     {
05420         result = __LINE__;
05421     }
05422     else
05423     {
05424         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05425         AMQP_VALUE delivery_tag_amqp_value = amqpvalue_create_delivery_tag(delivery_tag_value);
05426         if (delivery_tag_amqp_value == NULL)
05427         {
05428             result = __LINE__;
05429         }
05430         else
05431         {
05432             if (amqpvalue_set_composite_item(transfer_instance->composite_value, 2, delivery_tag_amqp_value) != 0)
05433             {
05434                 result = __LINE__;
05435             }
05436             else
05437             {
05438                 result = 0;
05439             }
05440 
05441             amqpvalue_destroy(delivery_tag_amqp_value);
05442         }
05443     }
05444 
05445     return result;
05446 }
05447 
05448 int transfer_get_message_format(TRANSFER_HANDLE transfer, message_format* message_format_value)
05449 {
05450     int result;
05451 
05452     if (transfer == NULL)
05453     {
05454         result = __LINE__;
05455     }
05456     else
05457     {
05458         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05459         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(transfer_instance->composite_value, 3);
05460         if (item_value == NULL)
05461         {
05462             result = __LINE__;
05463         }
05464         else
05465         {
05466             if (amqpvalue_get_message_format(item_value, message_format_value) != 0)
05467             {
05468                 result = __LINE__;
05469             }
05470             else
05471             {
05472                 result = 0;
05473             }
05474         }
05475     }
05476 
05477     return result;
05478 }
05479 
05480 int transfer_set_message_format(TRANSFER_HANDLE transfer, message_format message_format_value)
05481 {
05482     int result;
05483 
05484     if (transfer == NULL)
05485     {
05486         result = __LINE__;
05487     }
05488     else
05489     {
05490         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05491         AMQP_VALUE message_format_amqp_value = amqpvalue_create_message_format(message_format_value);
05492         if (message_format_amqp_value == NULL)
05493         {
05494             result = __LINE__;
05495         }
05496         else
05497         {
05498             if (amqpvalue_set_composite_item(transfer_instance->composite_value, 3, message_format_amqp_value) != 0)
05499             {
05500                 result = __LINE__;
05501             }
05502             else
05503             {
05504                 result = 0;
05505             }
05506 
05507             amqpvalue_destroy(message_format_amqp_value);
05508         }
05509     }
05510 
05511     return result;
05512 }
05513 
05514 int transfer_get_settled(TRANSFER_HANDLE transfer, bool* settled_value)
05515 {
05516     int result;
05517 
05518     if (transfer == NULL)
05519     {
05520         result = __LINE__;
05521     }
05522     else
05523     {
05524         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05525         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(transfer_instance->composite_value, 4);
05526         if (item_value == NULL)
05527         {
05528             result = __LINE__;
05529         }
05530         else
05531         {
05532             if (amqpvalue_get_boolean(item_value, settled_value) != 0)
05533             {
05534                 result = __LINE__;
05535             }
05536             else
05537             {
05538                 result = 0;
05539             }
05540         }
05541     }
05542 
05543     return result;
05544 }
05545 
05546 int transfer_set_settled(TRANSFER_HANDLE transfer, bool settled_value)
05547 {
05548     int result;
05549 
05550     if (transfer == NULL)
05551     {
05552         result = __LINE__;
05553     }
05554     else
05555     {
05556         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05557         AMQP_VALUE settled_amqp_value = amqpvalue_create_boolean(settled_value);
05558         if (settled_amqp_value == NULL)
05559         {
05560             result = __LINE__;
05561         }
05562         else
05563         {
05564             if (amqpvalue_set_composite_item(transfer_instance->composite_value, 4, settled_amqp_value) != 0)
05565             {
05566                 result = __LINE__;
05567             }
05568             else
05569             {
05570                 result = 0;
05571             }
05572 
05573             amqpvalue_destroy(settled_amqp_value);
05574         }
05575     }
05576 
05577     return result;
05578 }
05579 
05580 int transfer_get_more(TRANSFER_HANDLE transfer, bool* more_value)
05581 {
05582     int result;
05583 
05584     if (transfer == NULL)
05585     {
05586         result = __LINE__;
05587     }
05588     else
05589     {
05590         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05591         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(transfer_instance->composite_value, 5);
05592         if (item_value == NULL)
05593         {
05594             result = __LINE__;
05595         }
05596         else
05597         {
05598             if (amqpvalue_get_boolean(item_value, more_value) != 0)
05599             {
05600                 result = __LINE__;
05601             }
05602             else
05603             {
05604                 result = 0;
05605             }
05606         }
05607     }
05608 
05609     return result;
05610 }
05611 
05612 int transfer_set_more(TRANSFER_HANDLE transfer, bool more_value)
05613 {
05614     int result;
05615 
05616     if (transfer == NULL)
05617     {
05618         result = __LINE__;
05619     }
05620     else
05621     {
05622         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05623         AMQP_VALUE more_amqp_value = amqpvalue_create_boolean(more_value);
05624         if (more_amqp_value == NULL)
05625         {
05626             result = __LINE__;
05627         }
05628         else
05629         {
05630             if (amqpvalue_set_composite_item(transfer_instance->composite_value, 5, more_amqp_value) != 0)
05631             {
05632                 result = __LINE__;
05633             }
05634             else
05635             {
05636                 result = 0;
05637             }
05638 
05639             amqpvalue_destroy(more_amqp_value);
05640         }
05641     }
05642 
05643     return result;
05644 }
05645 
05646 int transfer_get_rcv_settle_mode(TRANSFER_HANDLE transfer, receiver_settle_mode* rcv_settle_mode_value)
05647 {
05648     int result;
05649 
05650     if (transfer == NULL)
05651     {
05652         result = __LINE__;
05653     }
05654     else
05655     {
05656         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05657         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(transfer_instance->composite_value, 6);
05658         if (item_value == NULL)
05659         {
05660             result = __LINE__;
05661         }
05662         else
05663         {
05664             if (amqpvalue_get_receiver_settle_mode(item_value, rcv_settle_mode_value) != 0)
05665             {
05666                 result = __LINE__;
05667             }
05668             else
05669             {
05670                 result = 0;
05671             }
05672         }
05673     }
05674 
05675     return result;
05676 }
05677 
05678 int transfer_set_rcv_settle_mode(TRANSFER_HANDLE transfer, receiver_settle_mode rcv_settle_mode_value)
05679 {
05680     int result;
05681 
05682     if (transfer == NULL)
05683     {
05684         result = __LINE__;
05685     }
05686     else
05687     {
05688         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05689         AMQP_VALUE rcv_settle_mode_amqp_value = amqpvalue_create_receiver_settle_mode(rcv_settle_mode_value);
05690         if (rcv_settle_mode_amqp_value == NULL)
05691         {
05692             result = __LINE__;
05693         }
05694         else
05695         {
05696             if (amqpvalue_set_composite_item(transfer_instance->composite_value, 6, rcv_settle_mode_amqp_value) != 0)
05697             {
05698                 result = __LINE__;
05699             }
05700             else
05701             {
05702                 result = 0;
05703             }
05704 
05705             amqpvalue_destroy(rcv_settle_mode_amqp_value);
05706         }
05707     }
05708 
05709     return result;
05710 }
05711 
05712 int transfer_get_state(TRANSFER_HANDLE transfer, AMQP_VALUE* state_value)
05713 {
05714     int result;
05715 
05716     if (transfer == NULL)
05717     {
05718         result = __LINE__;
05719     }
05720     else
05721     {
05722         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05723         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(transfer_instance->composite_value, 7);
05724         if (item_value == NULL)
05725         {
05726             result = __LINE__;
05727         }
05728         else
05729         {
05730             *state_value = item_value;
05731             result = 0;
05732         }
05733     }
05734 
05735     return result;
05736 }
05737 
05738 int transfer_set_state(TRANSFER_HANDLE transfer, AMQP_VALUE state_value)
05739 {
05740     int result;
05741 
05742     if (transfer == NULL)
05743     {
05744         result = __LINE__;
05745     }
05746     else
05747     {
05748         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05749         AMQP_VALUE state_amqp_value = amqpvalue_clone(state_value);
05750         if (state_amqp_value == NULL)
05751         {
05752             result = __LINE__;
05753         }
05754         else
05755         {
05756             if (amqpvalue_set_composite_item(transfer_instance->composite_value, 7, state_amqp_value) != 0)
05757             {
05758                 result = __LINE__;
05759             }
05760             else
05761             {
05762                 result = 0;
05763             }
05764 
05765             amqpvalue_destroy(state_amqp_value);
05766         }
05767     }
05768 
05769     return result;
05770 }
05771 
05772 int transfer_get_resume(TRANSFER_HANDLE transfer, bool* resume_value)
05773 {
05774     int result;
05775 
05776     if (transfer == NULL)
05777     {
05778         result = __LINE__;
05779     }
05780     else
05781     {
05782         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05783         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(transfer_instance->composite_value, 8);
05784         if (item_value == NULL)
05785         {
05786             result = __LINE__;
05787         }
05788         else
05789         {
05790             if (amqpvalue_get_boolean(item_value, resume_value) != 0)
05791             {
05792                 result = __LINE__;
05793             }
05794             else
05795             {
05796                 result = 0;
05797             }
05798         }
05799     }
05800 
05801     return result;
05802 }
05803 
05804 int transfer_set_resume(TRANSFER_HANDLE transfer, bool resume_value)
05805 {
05806     int result;
05807 
05808     if (transfer == NULL)
05809     {
05810         result = __LINE__;
05811     }
05812     else
05813     {
05814         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05815         AMQP_VALUE resume_amqp_value = amqpvalue_create_boolean(resume_value);
05816         if (resume_amqp_value == NULL)
05817         {
05818             result = __LINE__;
05819         }
05820         else
05821         {
05822             if (amqpvalue_set_composite_item(transfer_instance->composite_value, 8, resume_amqp_value) != 0)
05823             {
05824                 result = __LINE__;
05825             }
05826             else
05827             {
05828                 result = 0;
05829             }
05830 
05831             amqpvalue_destroy(resume_amqp_value);
05832         }
05833     }
05834 
05835     return result;
05836 }
05837 
05838 int transfer_get_aborted(TRANSFER_HANDLE transfer, bool* aborted_value)
05839 {
05840     int result;
05841 
05842     if (transfer == NULL)
05843     {
05844         result = __LINE__;
05845     }
05846     else
05847     {
05848         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05849         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(transfer_instance->composite_value, 9);
05850         if (item_value == NULL)
05851         {
05852             result = __LINE__;
05853         }
05854         else
05855         {
05856             if (amqpvalue_get_boolean(item_value, aborted_value) != 0)
05857             {
05858                 result = __LINE__;
05859             }
05860             else
05861             {
05862                 result = 0;
05863             }
05864         }
05865     }
05866 
05867     return result;
05868 }
05869 
05870 int transfer_set_aborted(TRANSFER_HANDLE transfer, bool aborted_value)
05871 {
05872     int result;
05873 
05874     if (transfer == NULL)
05875     {
05876         result = __LINE__;
05877     }
05878     else
05879     {
05880         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05881         AMQP_VALUE aborted_amqp_value = amqpvalue_create_boolean(aborted_value);
05882         if (aborted_amqp_value == NULL)
05883         {
05884             result = __LINE__;
05885         }
05886         else
05887         {
05888             if (amqpvalue_set_composite_item(transfer_instance->composite_value, 9, aborted_amqp_value) != 0)
05889             {
05890                 result = __LINE__;
05891             }
05892             else
05893             {
05894                 result = 0;
05895             }
05896 
05897             amqpvalue_destroy(aborted_amqp_value);
05898         }
05899     }
05900 
05901     return result;
05902 }
05903 
05904 int transfer_get_batchable(TRANSFER_HANDLE transfer, bool* batchable_value)
05905 {
05906     int result;
05907 
05908     if (transfer == NULL)
05909     {
05910         result = __LINE__;
05911     }
05912     else
05913     {
05914         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05915         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(transfer_instance->composite_value, 10);
05916         if (item_value == NULL)
05917         {
05918             result = __LINE__;
05919         }
05920         else
05921         {
05922             if (amqpvalue_get_boolean(item_value, batchable_value) != 0)
05923             {
05924                 result = __LINE__;
05925             }
05926             else
05927             {
05928                 result = 0;
05929             }
05930         }
05931     }
05932 
05933     return result;
05934 }
05935 
05936 int transfer_set_batchable(TRANSFER_HANDLE transfer, bool batchable_value)
05937 {
05938     int result;
05939 
05940     if (transfer == NULL)
05941     {
05942         result = __LINE__;
05943     }
05944     else
05945     {
05946         TRANSFER_INSTANCE* transfer_instance = (TRANSFER_INSTANCE*)transfer;
05947         AMQP_VALUE batchable_amqp_value = amqpvalue_create_boolean(batchable_value);
05948         if (batchable_amqp_value == NULL)
05949         {
05950             result = __LINE__;
05951         }
05952         else
05953         {
05954             if (amqpvalue_set_composite_item(transfer_instance->composite_value, 10, batchable_amqp_value) != 0)
05955             {
05956                 result = __LINE__;
05957             }
05958             else
05959             {
05960                 result = 0;
05961             }
05962 
05963             amqpvalue_destroy(batchable_amqp_value);
05964         }
05965     }
05966 
05967     return result;
05968 }
05969 
05970 
05971 /* disposition */
05972 
05973 typedef struct DISPOSITION_INSTANCE_TAG
05974 {
05975     AMQP_VALUE composite_value;
05976 } DISPOSITION_INSTANCE;
05977 
05978 static DISPOSITION_HANDLE disposition_create_internal(void)
05979 {
05980     DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)amqpalloc_malloc(sizeof(DISPOSITION_INSTANCE));
05981     if (disposition_instance != NULL)
05982     {
05983         disposition_instance->composite_value = NULL;
05984     }
05985 
05986     return disposition_instance;
05987 }
05988 
05989 DISPOSITION_HANDLE disposition_create(role role_value, delivery_number first_value)
05990 {
05991     DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)amqpalloc_malloc(sizeof(DISPOSITION_INSTANCE));
05992     if (disposition_instance != NULL)
05993     {
05994         disposition_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(21);
05995         if (disposition_instance->composite_value == NULL)
05996         {
05997             amqpalloc_free(disposition_instance);
05998             disposition_instance = NULL;
05999         }
06000         else
06001         {
06002             AMQP_VALUE role_amqp_value;
06003             AMQP_VALUE first_amqp_value;
06004             int result = 0;
06005 
06006             role_amqp_value = amqpvalue_create_role(role_value);
06007             if ((result == 0) && (amqpvalue_set_composite_item(disposition_instance->composite_value, 0, role_amqp_value) != 0))
06008             {
06009                 result = __LINE__;
06010             }
06011             first_amqp_value = amqpvalue_create_delivery_number(first_value);
06012             if ((result == 0) && (amqpvalue_set_composite_item(disposition_instance->composite_value, 1, first_amqp_value) != 0))
06013             {
06014                 result = __LINE__;
06015             }
06016 
06017             amqpvalue_destroy(role_amqp_value);
06018             amqpvalue_destroy(first_amqp_value);
06019         }
06020     }
06021 
06022     return disposition_instance;
06023 }
06024 
06025 DISPOSITION_HANDLE disposition_clone(DISPOSITION_HANDLE value)
06026 {
06027     DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)amqpalloc_malloc(sizeof(DISPOSITION_INSTANCE));
06028     if (disposition_instance != NULL)
06029     {
06030         disposition_instance->composite_value = amqpvalue_clone(((DISPOSITION_INSTANCE*)value)->composite_value);
06031         if (disposition_instance->composite_value == NULL)
06032         {
06033             amqpalloc_free(disposition_instance);
06034             disposition_instance = NULL;
06035         }
06036     }
06037 
06038     return disposition_instance;
06039 }
06040 
06041 void disposition_destroy(DISPOSITION_HANDLE disposition)
06042 {
06043     if (disposition != NULL)
06044     {
06045         DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)disposition;
06046         amqpvalue_destroy(disposition_instance->composite_value);
06047         amqpalloc_free(disposition_instance);
06048     }
06049 }
06050 
06051 AMQP_VALUE amqpvalue_create_disposition(DISPOSITION_HANDLE disposition)
06052 {
06053     AMQP_VALUE result;
06054 
06055     if (disposition == NULL)
06056     {
06057         result = NULL;
06058     }
06059     else
06060     {
06061         DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)disposition;
06062         result = amqpvalue_clone(disposition_instance->composite_value);
06063     }
06064 
06065     return result;
06066 }
06067 
06068 bool is_disposition_type_by_descriptor(AMQP_VALUE descriptor)
06069 {
06070     bool result;
06071 
06072     uint64_t descriptor_ulong;
06073     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
06074         (descriptor_ulong == 21))
06075     {
06076         result = true;
06077     }
06078     else
06079     {
06080         result = false;
06081     }
06082 
06083     return result;
06084 }
06085 
06086 
06087 int amqpvalue_get_disposition(AMQP_VALUE value, DISPOSITION_HANDLE* disposition_handle)
06088 {
06089     int result;
06090     DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)disposition_create_internal();
06091     *disposition_handle = disposition_instance;
06092     if (*disposition_handle == NULL)
06093     {
06094         result = __LINE__;
06095     }
06096     else
06097     {
06098         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
06099         if (list_value == NULL)
06100         {
06101             disposition_destroy(*disposition_handle);
06102             result = __LINE__;
06103         }
06104         else
06105         {
06106             do
06107             {
06108                 AMQP_VALUE item_value;
06109                 /* role */
06110                 item_value = amqpvalue_get_list_item(list_value, 0);
06111                 if (item_value == NULL)
06112                 {
06113                     {
06114                         disposition_destroy(*disposition_handle);
06115                         result = __LINE__;
06116                         break;
06117                     }
06118                 }
06119                 else
06120                 {
06121                     role role;
06122                     if (amqpvalue_get_role(item_value, &role) != 0)
06123                     {
06124                         disposition_destroy(*disposition_handle);
06125                         result = __LINE__;
06126                         break;
06127                     }
06128 
06129                     amqpvalue_destroy(item_value);
06130                 }
06131                 /* first */
06132                 item_value = amqpvalue_get_list_item(list_value, 1);
06133                 if (item_value == NULL)
06134                 {
06135                     {
06136                         disposition_destroy(*disposition_handle);
06137                         result = __LINE__;
06138                         break;
06139                     }
06140                 }
06141                 else
06142                 {
06143                     delivery_number first;
06144                     if (amqpvalue_get_delivery_number(item_value, &first) != 0)
06145                     {
06146                         disposition_destroy(*disposition_handle);
06147                         result = __LINE__;
06148                         break;
06149                     }
06150 
06151                     amqpvalue_destroy(item_value);
06152                 }
06153                 /* last */
06154                 item_value = amqpvalue_get_list_item(list_value, 2);
06155                 if (item_value == NULL)
06156                 {
06157                     /* do nothing */
06158                 }
06159                 else
06160                 {
06161                     delivery_number last;
06162                     if (amqpvalue_get_delivery_number(item_value, &last) != 0)
06163                     {
06164                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
06165                         {
06166                             disposition_destroy(*disposition_handle);
06167                             result = __LINE__;
06168                             break;
06169                         }
06170                     }
06171 
06172                     amqpvalue_destroy(item_value);
06173                 }
06174                 /* settled */
06175                 item_value = amqpvalue_get_list_item(list_value, 3);
06176                 if (item_value == NULL)
06177                 {
06178                     /* do nothing */
06179                 }
06180                 else
06181                 {
06182                     bool settled;
06183                     if (amqpvalue_get_boolean(item_value, &settled) != 0)
06184                     {
06185                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
06186                         {
06187                             disposition_destroy(*disposition_handle);
06188                             result = __LINE__;
06189                             break;
06190                         }
06191                     }
06192 
06193                     amqpvalue_destroy(item_value);
06194                 }
06195                 /* state */
06196                 item_value = amqpvalue_get_list_item(list_value, 4);
06197                 if (item_value == NULL)
06198                 {
06199                     /* do nothing */
06200                 }
06201                 else
06202                 {
06203                     amqpvalue_destroy(item_value);
06204                 }
06205                 /* batchable */
06206                 item_value = amqpvalue_get_list_item(list_value, 5);
06207                 if (item_value == NULL)
06208                 {
06209                     /* do nothing */
06210                 }
06211                 else
06212                 {
06213                     bool batchable;
06214                     if (amqpvalue_get_boolean(item_value, &batchable) != 0)
06215                     {
06216                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
06217                         {
06218                             disposition_destroy(*disposition_handle);
06219                             result = __LINE__;
06220                             break;
06221                         }
06222                     }
06223 
06224                     amqpvalue_destroy(item_value);
06225                 }
06226 
06227                 disposition_instance->composite_value = amqpvalue_clone(value);
06228 
06229                 result = 0;
06230             } while (0);
06231         }
06232     }
06233 
06234     return result;
06235 }
06236 
06237 int disposition_get_role(DISPOSITION_HANDLE disposition, role* role_value)
06238 {
06239     int result;
06240 
06241     if (disposition == NULL)
06242     {
06243         result = __LINE__;
06244     }
06245     else
06246     {
06247         DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)disposition;
06248         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(disposition_instance->composite_value, 0);
06249         if (item_value == NULL)
06250         {
06251             result = __LINE__;
06252         }
06253         else
06254         {
06255             if (amqpvalue_get_role(item_value, role_value) != 0)
06256             {
06257                 result = __LINE__;
06258             }
06259             else
06260             {
06261                 result = 0;
06262             }
06263         }
06264     }
06265 
06266     return result;
06267 }
06268 
06269 int disposition_set_role(DISPOSITION_HANDLE disposition, role role_value)
06270 {
06271     int result;
06272 
06273     if (disposition == NULL)
06274     {
06275         result = __LINE__;
06276     }
06277     else
06278     {
06279         DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)disposition;
06280         AMQP_VALUE role_amqp_value = amqpvalue_create_role(role_value);
06281         if (role_amqp_value == NULL)
06282         {
06283             result = __LINE__;
06284         }
06285         else
06286         {
06287             if (amqpvalue_set_composite_item(disposition_instance->composite_value, 0, role_amqp_value) != 0)
06288             {
06289                 result = __LINE__;
06290             }
06291             else
06292             {
06293                 result = 0;
06294             }
06295 
06296             amqpvalue_destroy(role_amqp_value);
06297         }
06298     }
06299 
06300     return result;
06301 }
06302 
06303 int disposition_get_first(DISPOSITION_HANDLE disposition, delivery_number* first_value)
06304 {
06305     int result;
06306 
06307     if (disposition == NULL)
06308     {
06309         result = __LINE__;
06310     }
06311     else
06312     {
06313         DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)disposition;
06314         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(disposition_instance->composite_value, 1);
06315         if (item_value == NULL)
06316         {
06317             result = __LINE__;
06318         }
06319         else
06320         {
06321             if (amqpvalue_get_delivery_number(item_value, first_value) != 0)
06322             {
06323                 result = __LINE__;
06324             }
06325             else
06326             {
06327                 result = 0;
06328             }
06329         }
06330     }
06331 
06332     return result;
06333 }
06334 
06335 int disposition_set_first(DISPOSITION_HANDLE disposition, delivery_number first_value)
06336 {
06337     int result;
06338 
06339     if (disposition == NULL)
06340     {
06341         result = __LINE__;
06342     }
06343     else
06344     {
06345         DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)disposition;
06346         AMQP_VALUE first_amqp_value = amqpvalue_create_delivery_number(first_value);
06347         if (first_amqp_value == NULL)
06348         {
06349             result = __LINE__;
06350         }
06351         else
06352         {
06353             if (amqpvalue_set_composite_item(disposition_instance->composite_value, 1, first_amqp_value) != 0)
06354             {
06355                 result = __LINE__;
06356             }
06357             else
06358             {
06359                 result = 0;
06360             }
06361 
06362             amqpvalue_destroy(first_amqp_value);
06363         }
06364     }
06365 
06366     return result;
06367 }
06368 
06369 int disposition_get_last(DISPOSITION_HANDLE disposition, delivery_number* last_value)
06370 {
06371     int result;
06372 
06373     if (disposition == NULL)
06374     {
06375         result = __LINE__;
06376     }
06377     else
06378     {
06379         DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)disposition;
06380         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(disposition_instance->composite_value, 2);
06381         if (item_value == NULL)
06382         {
06383             result = __LINE__;
06384         }
06385         else
06386         {
06387             if (amqpvalue_get_delivery_number(item_value, last_value) != 0)
06388             {
06389                 result = __LINE__;
06390             }
06391             else
06392             {
06393                 result = 0;
06394             }
06395         }
06396     }
06397 
06398     return result;
06399 }
06400 
06401 int disposition_set_last(DISPOSITION_HANDLE disposition, delivery_number last_value)
06402 {
06403     int result;
06404 
06405     if (disposition == NULL)
06406     {
06407         result = __LINE__;
06408     }
06409     else
06410     {
06411         DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)disposition;
06412         AMQP_VALUE last_amqp_value = amqpvalue_create_delivery_number(last_value);
06413         if (last_amqp_value == NULL)
06414         {
06415             result = __LINE__;
06416         }
06417         else
06418         {
06419             if (amqpvalue_set_composite_item(disposition_instance->composite_value, 2, last_amqp_value) != 0)
06420             {
06421                 result = __LINE__;
06422             }
06423             else
06424             {
06425                 result = 0;
06426             }
06427 
06428             amqpvalue_destroy(last_amqp_value);
06429         }
06430     }
06431 
06432     return result;
06433 }
06434 
06435 int disposition_get_settled(DISPOSITION_HANDLE disposition, bool* settled_value)
06436 {
06437     int result;
06438 
06439     if (disposition == NULL)
06440     {
06441         result = __LINE__;
06442     }
06443     else
06444     {
06445         DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)disposition;
06446         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(disposition_instance->composite_value, 3);
06447         if (item_value == NULL)
06448         {
06449             result = __LINE__;
06450         }
06451         else
06452         {
06453             if (amqpvalue_get_boolean(item_value, settled_value) != 0)
06454             {
06455                 result = __LINE__;
06456             }
06457             else
06458             {
06459                 result = 0;
06460             }
06461         }
06462     }
06463 
06464     return result;
06465 }
06466 
06467 int disposition_set_settled(DISPOSITION_HANDLE disposition, bool settled_value)
06468 {
06469     int result;
06470 
06471     if (disposition == NULL)
06472     {
06473         result = __LINE__;
06474     }
06475     else
06476     {
06477         DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)disposition;
06478         AMQP_VALUE settled_amqp_value = amqpvalue_create_boolean(settled_value);
06479         if (settled_amqp_value == NULL)
06480         {
06481             result = __LINE__;
06482         }
06483         else
06484         {
06485             if (amqpvalue_set_composite_item(disposition_instance->composite_value, 3, settled_amqp_value) != 0)
06486             {
06487                 result = __LINE__;
06488             }
06489             else
06490             {
06491                 result = 0;
06492             }
06493 
06494             amqpvalue_destroy(settled_amqp_value);
06495         }
06496     }
06497 
06498     return result;
06499 }
06500 
06501 int disposition_get_state(DISPOSITION_HANDLE disposition, AMQP_VALUE* state_value)
06502 {
06503     int result;
06504 
06505     if (disposition == NULL)
06506     {
06507         result = __LINE__;
06508     }
06509     else
06510     {
06511         DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)disposition;
06512         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(disposition_instance->composite_value, 4);
06513         if (item_value == NULL)
06514         {
06515             result = __LINE__;
06516         }
06517         else
06518         {
06519             *state_value = item_value;
06520             result = 0;
06521         }
06522     }
06523 
06524     return result;
06525 }
06526 
06527 int disposition_set_state(DISPOSITION_HANDLE disposition, AMQP_VALUE state_value)
06528 {
06529     int result;
06530 
06531     if (disposition == NULL)
06532     {
06533         result = __LINE__;
06534     }
06535     else
06536     {
06537         DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)disposition;
06538         AMQP_VALUE state_amqp_value = amqpvalue_clone(state_value);
06539         if (state_amqp_value == NULL)
06540         {
06541             result = __LINE__;
06542         }
06543         else
06544         {
06545             if (amqpvalue_set_composite_item(disposition_instance->composite_value, 4, state_amqp_value) != 0)
06546             {
06547                 result = __LINE__;
06548             }
06549             else
06550             {
06551                 result = 0;
06552             }
06553 
06554             amqpvalue_destroy(state_amqp_value);
06555         }
06556     }
06557 
06558     return result;
06559 }
06560 
06561 int disposition_get_batchable(DISPOSITION_HANDLE disposition, bool* batchable_value)
06562 {
06563     int result;
06564 
06565     if (disposition == NULL)
06566     {
06567         result = __LINE__;
06568     }
06569     else
06570     {
06571         DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)disposition;
06572         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(disposition_instance->composite_value, 5);
06573         if (item_value == NULL)
06574         {
06575             result = __LINE__;
06576         }
06577         else
06578         {
06579             if (amqpvalue_get_boolean(item_value, batchable_value) != 0)
06580             {
06581                 result = __LINE__;
06582             }
06583             else
06584             {
06585                 result = 0;
06586             }
06587         }
06588     }
06589 
06590     return result;
06591 }
06592 
06593 int disposition_set_batchable(DISPOSITION_HANDLE disposition, bool batchable_value)
06594 {
06595     int result;
06596 
06597     if (disposition == NULL)
06598     {
06599         result = __LINE__;
06600     }
06601     else
06602     {
06603         DISPOSITION_INSTANCE* disposition_instance = (DISPOSITION_INSTANCE*)disposition;
06604         AMQP_VALUE batchable_amqp_value = amqpvalue_create_boolean(batchable_value);
06605         if (batchable_amqp_value == NULL)
06606         {
06607             result = __LINE__;
06608         }
06609         else
06610         {
06611             if (amqpvalue_set_composite_item(disposition_instance->composite_value, 5, batchable_amqp_value) != 0)
06612             {
06613                 result = __LINE__;
06614             }
06615             else
06616             {
06617                 result = 0;
06618             }
06619 
06620             amqpvalue_destroy(batchable_amqp_value);
06621         }
06622     }
06623 
06624     return result;
06625 }
06626 
06627 
06628 /* detach */
06629 
06630 typedef struct DETACH_INSTANCE_TAG
06631 {
06632     AMQP_VALUE composite_value;
06633 } DETACH_INSTANCE;
06634 
06635 static DETACH_HANDLE detach_create_internal(void)
06636 {
06637     DETACH_INSTANCE* detach_instance = (DETACH_INSTANCE*)amqpalloc_malloc(sizeof(DETACH_INSTANCE));
06638     if (detach_instance != NULL)
06639     {
06640         detach_instance->composite_value = NULL;
06641     }
06642 
06643     return detach_instance;
06644 }
06645 
06646 DETACH_HANDLE detach_create(handle handle_value)
06647 {
06648     DETACH_INSTANCE* detach_instance = (DETACH_INSTANCE*)amqpalloc_malloc(sizeof(DETACH_INSTANCE));
06649     if (detach_instance != NULL)
06650     {
06651         detach_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(22);
06652         if (detach_instance->composite_value == NULL)
06653         {
06654             amqpalloc_free(detach_instance);
06655             detach_instance = NULL;
06656         }
06657         else
06658         {
06659             AMQP_VALUE handle_amqp_value;
06660             int result = 0;
06661 
06662             handle_amqp_value = amqpvalue_create_handle(handle_value);
06663             if ((result == 0) && (amqpvalue_set_composite_item(detach_instance->composite_value, 0, handle_amqp_value) != 0))
06664             {
06665                 result = __LINE__;
06666             }
06667 
06668             amqpvalue_destroy(handle_amqp_value);
06669         }
06670     }
06671 
06672     return detach_instance;
06673 }
06674 
06675 DETACH_HANDLE detach_clone(DETACH_HANDLE value)
06676 {
06677     DETACH_INSTANCE* detach_instance = (DETACH_INSTANCE*)amqpalloc_malloc(sizeof(DETACH_INSTANCE));
06678     if (detach_instance != NULL)
06679     {
06680         detach_instance->composite_value = amqpvalue_clone(((DETACH_INSTANCE*)value)->composite_value);
06681         if (detach_instance->composite_value == NULL)
06682         {
06683             amqpalloc_free(detach_instance);
06684             detach_instance = NULL;
06685         }
06686     }
06687 
06688     return detach_instance;
06689 }
06690 
06691 void detach_destroy(DETACH_HANDLE detach)
06692 {
06693     if (detach != NULL)
06694     {
06695         DETACH_INSTANCE* detach_instance = (DETACH_INSTANCE*)detach;
06696         amqpvalue_destroy(detach_instance->composite_value);
06697         amqpalloc_free(detach_instance);
06698     }
06699 }
06700 
06701 AMQP_VALUE amqpvalue_create_detach(DETACH_HANDLE detach)
06702 {
06703     AMQP_VALUE result;
06704 
06705     if (detach == NULL)
06706     {
06707         result = NULL;
06708     }
06709     else
06710     {
06711         DETACH_INSTANCE* detach_instance = (DETACH_INSTANCE*)detach;
06712         result = amqpvalue_clone(detach_instance->composite_value);
06713     }
06714 
06715     return result;
06716 }
06717 
06718 bool is_detach_type_by_descriptor(AMQP_VALUE descriptor)
06719 {
06720     bool result;
06721 
06722     uint64_t descriptor_ulong;
06723     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
06724         (descriptor_ulong == 22))
06725     {
06726         result = true;
06727     }
06728     else
06729     {
06730         result = false;
06731     }
06732 
06733     return result;
06734 }
06735 
06736 
06737 int amqpvalue_get_detach(AMQP_VALUE value, DETACH_HANDLE* detach_handle)
06738 {
06739     int result;
06740     DETACH_INSTANCE* detach_instance = (DETACH_INSTANCE*)detach_create_internal();
06741     *detach_handle = detach_instance;
06742     if (*detach_handle == NULL)
06743     {
06744         result = __LINE__;
06745     }
06746     else
06747     {
06748         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
06749         if (list_value == NULL)
06750         {
06751             detach_destroy(*detach_handle);
06752             result = __LINE__;
06753         }
06754         else
06755         {
06756             do
06757             {
06758                 AMQP_VALUE item_value;
06759                 /* handle */
06760                 item_value = amqpvalue_get_list_item(list_value, 0);
06761                 if (item_value == NULL)
06762                 {
06763                     {
06764                         detach_destroy(*detach_handle);
06765                         result = __LINE__;
06766                         break;
06767                     }
06768                 }
06769                 else
06770                 {
06771                     handle handle;
06772                     if (amqpvalue_get_handle(item_value, &handle) != 0)
06773                     {
06774                         detach_destroy(*detach_handle);
06775                         result = __LINE__;
06776                         break;
06777                     }
06778 
06779                     amqpvalue_destroy(item_value);
06780                 }
06781                 /* closed */
06782                 item_value = amqpvalue_get_list_item(list_value, 1);
06783                 if (item_value == NULL)
06784                 {
06785                     /* do nothing */
06786                 }
06787                 else
06788                 {
06789                     bool closed;
06790                     if (amqpvalue_get_boolean(item_value, &closed) != 0)
06791                     {
06792                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
06793                         {
06794                             detach_destroy(*detach_handle);
06795                             result = __LINE__;
06796                             break;
06797                         }
06798                     }
06799 
06800                     amqpvalue_destroy(item_value);
06801                 }
06802                 /* error */
06803                 item_value = amqpvalue_get_list_item(list_value, 2);
06804                 if (item_value == NULL)
06805                 {
06806                     /* do nothing */
06807                 }
06808                 else
06809                 {
06810                     ERROR_HANDLE error;
06811                     if (amqpvalue_get_error(item_value, &error) != 0)
06812                     {
06813                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
06814                         {
06815                             detach_destroy(*detach_handle);
06816                             result = __LINE__;
06817                             break;
06818                         }
06819                     }
06820 
06821                     amqpvalue_destroy(item_value);
06822                 }
06823 
06824                 detach_instance->composite_value = amqpvalue_clone(value);
06825 
06826                 result = 0;
06827             } while (0);
06828         }
06829     }
06830 
06831     return result;
06832 }
06833 
06834 int detach_get_handle(DETACH_HANDLE detach, handle* handle_value)
06835 {
06836     int result;
06837 
06838     if (detach == NULL)
06839     {
06840         result = __LINE__;
06841     }
06842     else
06843     {
06844         DETACH_INSTANCE* detach_instance = (DETACH_INSTANCE*)detach;
06845         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(detach_instance->composite_value, 0);
06846         if (item_value == NULL)
06847         {
06848             result = __LINE__;
06849         }
06850         else
06851         {
06852             if (amqpvalue_get_handle(item_value, handle_value) != 0)
06853             {
06854                 result = __LINE__;
06855             }
06856             else
06857             {
06858                 result = 0;
06859             }
06860         }
06861     }
06862 
06863     return result;
06864 }
06865 
06866 int detach_set_handle(DETACH_HANDLE detach, handle handle_value)
06867 {
06868     int result;
06869 
06870     if (detach == NULL)
06871     {
06872         result = __LINE__;
06873     }
06874     else
06875     {
06876         DETACH_INSTANCE* detach_instance = (DETACH_INSTANCE*)detach;
06877         AMQP_VALUE handle_amqp_value = amqpvalue_create_handle(handle_value);
06878         if (handle_amqp_value == NULL)
06879         {
06880             result = __LINE__;
06881         }
06882         else
06883         {
06884             if (amqpvalue_set_composite_item(detach_instance->composite_value, 0, handle_amqp_value) != 0)
06885             {
06886                 result = __LINE__;
06887             }
06888             else
06889             {
06890                 result = 0;
06891             }
06892 
06893             amqpvalue_destroy(handle_amqp_value);
06894         }
06895     }
06896 
06897     return result;
06898 }
06899 
06900 int detach_get_closed(DETACH_HANDLE detach, bool* closed_value)
06901 {
06902     int result;
06903 
06904     if (detach == NULL)
06905     {
06906         result = __LINE__;
06907     }
06908     else
06909     {
06910         DETACH_INSTANCE* detach_instance = (DETACH_INSTANCE*)detach;
06911         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(detach_instance->composite_value, 1);
06912         if (item_value == NULL)
06913         {
06914             result = __LINE__;
06915         }
06916         else
06917         {
06918             if (amqpvalue_get_boolean(item_value, closed_value) != 0)
06919             {
06920                 result = __LINE__;
06921             }
06922             else
06923             {
06924                 result = 0;
06925             }
06926         }
06927     }
06928 
06929     return result;
06930 }
06931 
06932 int detach_set_closed(DETACH_HANDLE detach, bool closed_value)
06933 {
06934     int result;
06935 
06936     if (detach == NULL)
06937     {
06938         result = __LINE__;
06939     }
06940     else
06941     {
06942         DETACH_INSTANCE* detach_instance = (DETACH_INSTANCE*)detach;
06943         AMQP_VALUE closed_amqp_value = amqpvalue_create_boolean(closed_value);
06944         if (closed_amqp_value == NULL)
06945         {
06946             result = __LINE__;
06947         }
06948         else
06949         {
06950             if (amqpvalue_set_composite_item(detach_instance->composite_value, 1, closed_amqp_value) != 0)
06951             {
06952                 result = __LINE__;
06953             }
06954             else
06955             {
06956                 result = 0;
06957             }
06958 
06959             amqpvalue_destroy(closed_amqp_value);
06960         }
06961     }
06962 
06963     return result;
06964 }
06965 
06966 int detach_get_error(DETACH_HANDLE detach, ERROR_HANDLE* error_value)
06967 {
06968     int result;
06969 
06970     if (detach == NULL)
06971     {
06972         result = __LINE__;
06973     }
06974     else
06975     {
06976         DETACH_INSTANCE* detach_instance = (DETACH_INSTANCE*)detach;
06977         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(detach_instance->composite_value, 2);
06978         if (item_value == NULL)
06979         {
06980             result = __LINE__;
06981         }
06982         else
06983         {
06984             if (amqpvalue_get_error(item_value, error_value) != 0)
06985             {
06986                 result = __LINE__;
06987             }
06988             else
06989             {
06990                 result = 0;
06991             }
06992         }
06993     }
06994 
06995     return result;
06996 }
06997 
06998 int detach_set_error(DETACH_HANDLE detach, ERROR_HANDLE error_value)
06999 {
07000     int result;
07001 
07002     if (detach == NULL)
07003     {
07004         result = __LINE__;
07005     }
07006     else
07007     {
07008         DETACH_INSTANCE* detach_instance = (DETACH_INSTANCE*)detach;
07009         AMQP_VALUE error_amqp_value = amqpvalue_create_error(error_value);
07010         if (error_amqp_value == NULL)
07011         {
07012             result = __LINE__;
07013         }
07014         else
07015         {
07016             if (amqpvalue_set_composite_item(detach_instance->composite_value, 2, error_amqp_value) != 0)
07017             {
07018                 result = __LINE__;
07019             }
07020             else
07021             {
07022                 result = 0;
07023             }
07024 
07025             amqpvalue_destroy(error_amqp_value);
07026         }
07027     }
07028 
07029     return result;
07030 }
07031 
07032 
07033 /* end */
07034 
07035 typedef struct END_INSTANCE_TAG
07036 {
07037     AMQP_VALUE composite_value;
07038 } END_INSTANCE;
07039 
07040 static END_HANDLE end_create_internal(void)
07041 {
07042     END_INSTANCE* end_instance = (END_INSTANCE*)amqpalloc_malloc(sizeof(END_INSTANCE));
07043     if (end_instance != NULL)
07044     {
07045         end_instance->composite_value = NULL;
07046     }
07047 
07048     return end_instance;
07049 }
07050 
07051 END_HANDLE end_create(void)
07052 {
07053     END_INSTANCE* end_instance = (END_INSTANCE*)amqpalloc_malloc(sizeof(END_INSTANCE));
07054     if (end_instance != NULL)
07055     {
07056         end_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(23);
07057         if (end_instance->composite_value == NULL)
07058         {
07059             amqpalloc_free(end_instance);
07060             end_instance = NULL;
07061         }
07062     }
07063 
07064     return end_instance;
07065 }
07066 
07067 END_HANDLE end_clone(END_HANDLE value)
07068 {
07069     END_INSTANCE* end_instance = (END_INSTANCE*)amqpalloc_malloc(sizeof(END_INSTANCE));
07070     if (end_instance != NULL)
07071     {
07072         end_instance->composite_value = amqpvalue_clone(((END_INSTANCE*)value)->composite_value);
07073         if (end_instance->composite_value == NULL)
07074         {
07075             amqpalloc_free(end_instance);
07076             end_instance = NULL;
07077         }
07078     }
07079 
07080     return end_instance;
07081 }
07082 
07083 void end_destroy(END_HANDLE end)
07084 {
07085     if (end != NULL)
07086     {
07087         END_INSTANCE* end_instance = (END_INSTANCE*)end;
07088         amqpvalue_destroy(end_instance->composite_value);
07089         amqpalloc_free(end_instance);
07090     }
07091 }
07092 
07093 AMQP_VALUE amqpvalue_create_end(END_HANDLE end)
07094 {
07095     AMQP_VALUE result;
07096 
07097     if (end == NULL)
07098     {
07099         result = NULL;
07100     }
07101     else
07102     {
07103         END_INSTANCE* end_instance = (END_INSTANCE*)end;
07104         result = amqpvalue_clone(end_instance->composite_value);
07105     }
07106 
07107     return result;
07108 }
07109 
07110 bool is_end_type_by_descriptor(AMQP_VALUE descriptor)
07111 {
07112     bool result;
07113 
07114     uint64_t descriptor_ulong;
07115     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
07116         (descriptor_ulong == 23))
07117     {
07118         result = true;
07119     }
07120     else
07121     {
07122         result = false;
07123     }
07124 
07125     return result;
07126 }
07127 
07128 
07129 int amqpvalue_get_end(AMQP_VALUE value, END_HANDLE* end_handle)
07130 {
07131     int result;
07132     END_INSTANCE* end_instance = (END_INSTANCE*)end_create_internal();
07133     *end_handle = end_instance;
07134     if (*end_handle == NULL)
07135     {
07136         result = __LINE__;
07137     }
07138     else
07139     {
07140         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
07141         if (list_value == NULL)
07142         {
07143             end_destroy(*end_handle);
07144             result = __LINE__;
07145         }
07146         else
07147         {
07148             do
07149             {
07150                 AMQP_VALUE item_value;
07151                 /* error */
07152                 item_value = amqpvalue_get_list_item(list_value, 0);
07153                 if (item_value == NULL)
07154                 {
07155                     /* do nothing */
07156                 }
07157                 else
07158                 {
07159                     ERROR_HANDLE error;
07160                     if (amqpvalue_get_error(item_value, &error) != 0)
07161                     {
07162                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
07163                         {
07164                             end_destroy(*end_handle);
07165                             result = __LINE__;
07166                             break;
07167                         }
07168                     }
07169 
07170                     amqpvalue_destroy(item_value);
07171                 }
07172 
07173                 end_instance->composite_value = amqpvalue_clone(value);
07174 
07175                 result = 0;
07176             } while (0);
07177         }
07178     }
07179 
07180     return result;
07181 }
07182 
07183 int end_get_error(END_HANDLE end, ERROR_HANDLE* error_value)
07184 {
07185     int result;
07186 
07187     if (end == NULL)
07188     {
07189         result = __LINE__;
07190     }
07191     else
07192     {
07193         END_INSTANCE* end_instance = (END_INSTANCE*)end;
07194         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(end_instance->composite_value, 0);
07195         if (item_value == NULL)
07196         {
07197             result = __LINE__;
07198         }
07199         else
07200         {
07201             if (amqpvalue_get_error(item_value, error_value) != 0)
07202             {
07203                 result = __LINE__;
07204             }
07205             else
07206             {
07207                 result = 0;
07208             }
07209         }
07210     }
07211 
07212     return result;
07213 }
07214 
07215 int end_set_error(END_HANDLE end, ERROR_HANDLE error_value)
07216 {
07217     int result;
07218 
07219     if (end == NULL)
07220     {
07221         result = __LINE__;
07222     }
07223     else
07224     {
07225         END_INSTANCE* end_instance = (END_INSTANCE*)end;
07226         AMQP_VALUE error_amqp_value = amqpvalue_create_error(error_value);
07227         if (error_amqp_value == NULL)
07228         {
07229             result = __LINE__;
07230         }
07231         else
07232         {
07233             if (amqpvalue_set_composite_item(end_instance->composite_value, 0, error_amqp_value) != 0)
07234             {
07235                 result = __LINE__;
07236             }
07237             else
07238             {
07239                 result = 0;
07240             }
07241 
07242             amqpvalue_destroy(error_amqp_value);
07243         }
07244     }
07245 
07246     return result;
07247 }
07248 
07249 
07250 /* close */
07251 
07252 typedef struct CLOSE_INSTANCE_TAG
07253 {
07254     AMQP_VALUE composite_value;
07255 } CLOSE_INSTANCE;
07256 
07257 static CLOSE_HANDLE close_create_internal(void)
07258 {
07259     CLOSE_INSTANCE* close_instance = (CLOSE_INSTANCE*)amqpalloc_malloc(sizeof(CLOSE_INSTANCE));
07260     if (close_instance != NULL)
07261     {
07262         close_instance->composite_value = NULL;
07263     }
07264 
07265     return close_instance;
07266 }
07267 
07268 CLOSE_HANDLE close_create(void)
07269 {
07270     CLOSE_INSTANCE* close_instance = (CLOSE_INSTANCE*)amqpalloc_malloc(sizeof(CLOSE_INSTANCE));
07271     if (close_instance != NULL)
07272     {
07273         close_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(24);
07274         if (close_instance->composite_value == NULL)
07275         {
07276             amqpalloc_free(close_instance);
07277             close_instance = NULL;
07278         }
07279     }
07280 
07281     return close_instance;
07282 }
07283 
07284 CLOSE_HANDLE close_clone(CLOSE_HANDLE value)
07285 {
07286     CLOSE_INSTANCE* close_instance = (CLOSE_INSTANCE*)amqpalloc_malloc(sizeof(CLOSE_INSTANCE));
07287     if (close_instance != NULL)
07288     {
07289         close_instance->composite_value = amqpvalue_clone(((CLOSE_INSTANCE*)value)->composite_value);
07290         if (close_instance->composite_value == NULL)
07291         {
07292             amqpalloc_free(close_instance);
07293             close_instance = NULL;
07294         }
07295     }
07296 
07297     return close_instance;
07298 }
07299 
07300 void close_destroy(CLOSE_HANDLE close)
07301 {
07302     if (close != NULL)
07303     {
07304         CLOSE_INSTANCE* close_instance = (CLOSE_INSTANCE*)close;
07305         amqpvalue_destroy(close_instance->composite_value);
07306         amqpalloc_free(close_instance);
07307     }
07308 }
07309 
07310 AMQP_VALUE amqpvalue_create_close(CLOSE_HANDLE close)
07311 {
07312     AMQP_VALUE result;
07313 
07314     if (close == NULL)
07315     {
07316         result = NULL;
07317     }
07318     else
07319     {
07320         CLOSE_INSTANCE* close_instance = (CLOSE_INSTANCE*)close;
07321         result = amqpvalue_clone(close_instance->composite_value);
07322     }
07323 
07324     return result;
07325 }
07326 
07327 bool is_close_type_by_descriptor(AMQP_VALUE descriptor)
07328 {
07329     bool result;
07330 
07331     uint64_t descriptor_ulong;
07332     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
07333         (descriptor_ulong == 24))
07334     {
07335         result = true;
07336     }
07337     else
07338     {
07339         result = false;
07340     }
07341 
07342     return result;
07343 }
07344 
07345 
07346 int amqpvalue_get_close(AMQP_VALUE value, CLOSE_HANDLE* close_handle)
07347 {
07348     int result;
07349     CLOSE_INSTANCE* close_instance = (CLOSE_INSTANCE*)close_create_internal();
07350     *close_handle = close_instance;
07351     if (*close_handle == NULL)
07352     {
07353         result = __LINE__;
07354     }
07355     else
07356     {
07357         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
07358         if (list_value == NULL)
07359         {
07360             close_destroy(*close_handle);
07361             result = __LINE__;
07362         }
07363         else
07364         {
07365             do
07366             {
07367                 AMQP_VALUE item_value;
07368                 /* error */
07369                 item_value = amqpvalue_get_list_item(list_value, 0);
07370                 if (item_value == NULL)
07371                 {
07372                     /* do nothing */
07373                 }
07374                 else
07375                 {
07376                     ERROR_HANDLE error;
07377                     if (amqpvalue_get_error(item_value, &error) != 0)
07378                     {
07379                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
07380                         {
07381                             close_destroy(*close_handle);
07382                             result = __LINE__;
07383                             break;
07384                         }
07385                     }
07386 
07387                     amqpvalue_destroy(item_value);
07388                 }
07389 
07390                 close_instance->composite_value = amqpvalue_clone(value);
07391 
07392                 result = 0;
07393             } while (0);
07394         }
07395     }
07396 
07397     return result;
07398 }
07399 
07400 int close_get_error(CLOSE_HANDLE close, ERROR_HANDLE* error_value)
07401 {
07402     int result;
07403 
07404     if (close == NULL)
07405     {
07406         result = __LINE__;
07407     }
07408     else
07409     {
07410         CLOSE_INSTANCE* close_instance = (CLOSE_INSTANCE*)close;
07411         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(close_instance->composite_value, 0);
07412         if (item_value == NULL)
07413         {
07414             result = __LINE__;
07415         }
07416         else
07417         {
07418             if (amqpvalue_get_error(item_value, error_value) != 0)
07419             {
07420                 result = __LINE__;
07421             }
07422             else
07423             {
07424                 result = 0;
07425             }
07426         }
07427     }
07428 
07429     return result;
07430 }
07431 
07432 int close_set_error(CLOSE_HANDLE close, ERROR_HANDLE error_value)
07433 {
07434     int result;
07435 
07436     if (close == NULL)
07437     {
07438         result = __LINE__;
07439     }
07440     else
07441     {
07442         CLOSE_INSTANCE* close_instance = (CLOSE_INSTANCE*)close;
07443         AMQP_VALUE error_amqp_value = amqpvalue_create_error(error_value);
07444         if (error_amqp_value == NULL)
07445         {
07446             result = __LINE__;
07447         }
07448         else
07449         {
07450             if (amqpvalue_set_composite_item(close_instance->composite_value, 0, error_amqp_value) != 0)
07451             {
07452                 result = __LINE__;
07453             }
07454             else
07455             {
07456                 result = 0;
07457             }
07458 
07459             amqpvalue_destroy(error_amqp_value);
07460         }
07461     }
07462 
07463     return result;
07464 }
07465 
07466 
07467 /* sasl-code */
07468 
07469 AMQP_VALUE amqpvalue_create_sasl_code(sasl_code value)
07470 {
07471     return amqpvalue_create_ubyte(value);
07472 }
07473 
07474 /* sasl-mechanisms */
07475 
07476 typedef struct SASL_MECHANISMS_INSTANCE_TAG
07477 {
07478     AMQP_VALUE composite_value;
07479 } SASL_MECHANISMS_INSTANCE;
07480 
07481 static SASL_MECHANISMS_HANDLE sasl_mechanisms_create_internal(void)
07482 {
07483     SASL_MECHANISMS_INSTANCE* sasl_mechanisms_instance = (SASL_MECHANISMS_INSTANCE*)amqpalloc_malloc(sizeof(SASL_MECHANISMS_INSTANCE));
07484     if (sasl_mechanisms_instance != NULL)
07485     {
07486         sasl_mechanisms_instance->composite_value = NULL;
07487     }
07488 
07489     return sasl_mechanisms_instance;
07490 }
07491 
07492 SASL_MECHANISMS_HANDLE sasl_mechanisms_create(AMQP_VALUE sasl_server_mechanisms_value)
07493 {
07494     SASL_MECHANISMS_INSTANCE* sasl_mechanisms_instance = (SASL_MECHANISMS_INSTANCE*)amqpalloc_malloc(sizeof(SASL_MECHANISMS_INSTANCE));
07495     if (sasl_mechanisms_instance != NULL)
07496     {
07497         sasl_mechanisms_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(64);
07498         if (sasl_mechanisms_instance->composite_value == NULL)
07499         {
07500             amqpalloc_free(sasl_mechanisms_instance);
07501             sasl_mechanisms_instance = NULL;
07502         }
07503         else
07504         {
07505             AMQP_VALUE sasl_server_mechanisms_amqp_value;
07506             int result = 0;
07507 
07508             sasl_server_mechanisms_amqp_value = sasl_server_mechanisms_value;
07509             if ((result == 0) && (amqpvalue_set_composite_item(sasl_mechanisms_instance->composite_value, 0, sasl_server_mechanisms_amqp_value) != 0))
07510             {
07511                 result = __LINE__;
07512             }
07513 
07514             amqpvalue_destroy(sasl_server_mechanisms_amqp_value);
07515         }
07516     }
07517 
07518     return sasl_mechanisms_instance;
07519 }
07520 
07521 SASL_MECHANISMS_HANDLE sasl_mechanisms_clone(SASL_MECHANISMS_HANDLE value)
07522 {
07523     SASL_MECHANISMS_INSTANCE* sasl_mechanisms_instance = (SASL_MECHANISMS_INSTANCE*)amqpalloc_malloc(sizeof(SASL_MECHANISMS_INSTANCE));
07524     if (sasl_mechanisms_instance != NULL)
07525     {
07526         sasl_mechanisms_instance->composite_value = amqpvalue_clone(((SASL_MECHANISMS_INSTANCE*)value)->composite_value);
07527         if (sasl_mechanisms_instance->composite_value == NULL)
07528         {
07529             amqpalloc_free(sasl_mechanisms_instance);
07530             sasl_mechanisms_instance = NULL;
07531         }
07532     }
07533 
07534     return sasl_mechanisms_instance;
07535 }
07536 
07537 void sasl_mechanisms_destroy(SASL_MECHANISMS_HANDLE sasl_mechanisms)
07538 {
07539     if (sasl_mechanisms != NULL)
07540     {
07541         SASL_MECHANISMS_INSTANCE* sasl_mechanisms_instance = (SASL_MECHANISMS_INSTANCE*)sasl_mechanisms;
07542         amqpvalue_destroy(sasl_mechanisms_instance->composite_value);
07543         amqpalloc_free(sasl_mechanisms_instance);
07544     }
07545 }
07546 
07547 AMQP_VALUE amqpvalue_create_sasl_mechanisms(SASL_MECHANISMS_HANDLE sasl_mechanisms)
07548 {
07549     AMQP_VALUE result;
07550 
07551     if (sasl_mechanisms == NULL)
07552     {
07553         result = NULL;
07554     }
07555     else
07556     {
07557         SASL_MECHANISMS_INSTANCE* sasl_mechanisms_instance = (SASL_MECHANISMS_INSTANCE*)sasl_mechanisms;
07558         result = amqpvalue_clone(sasl_mechanisms_instance->composite_value);
07559     }
07560 
07561     return result;
07562 }
07563 
07564 bool is_sasl_mechanisms_type_by_descriptor(AMQP_VALUE descriptor)
07565 {
07566     bool result;
07567 
07568     uint64_t descriptor_ulong;
07569     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
07570         (descriptor_ulong == 64))
07571     {
07572         result = true;
07573     }
07574     else
07575     {
07576         result = false;
07577     }
07578 
07579     return result;
07580 }
07581 
07582 
07583 int amqpvalue_get_sasl_mechanisms(AMQP_VALUE value, SASL_MECHANISMS_HANDLE* sasl_mechanisms_handle)
07584 {
07585     int result;
07586     SASL_MECHANISMS_INSTANCE* sasl_mechanisms_instance = (SASL_MECHANISMS_INSTANCE*)sasl_mechanisms_create_internal();
07587     *sasl_mechanisms_handle = sasl_mechanisms_instance;
07588     if (*sasl_mechanisms_handle == NULL)
07589     {
07590         result = __LINE__;
07591     }
07592     else
07593     {
07594         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
07595         if (list_value == NULL)
07596         {
07597             sasl_mechanisms_destroy(*sasl_mechanisms_handle);
07598             result = __LINE__;
07599         }
07600         else
07601         {
07602             do
07603             {
07604                 AMQP_VALUE item_value;
07605                 /* sasl-server-mechanisms */
07606                 item_value = amqpvalue_get_list_item(list_value, 0);
07607                 if (item_value == NULL)
07608                 {
07609                     {
07610                         sasl_mechanisms_destroy(*sasl_mechanisms_handle);
07611                         result = __LINE__;
07612                         break;
07613                     }
07614                 }
07615                 else
07616                 {
07617                     const char* sasl_server_mechanisms;
07618                     AMQP_VALUE sasl_server_mechanisms_array;
07619                     if ((amqpvalue_get_array(item_value, &sasl_server_mechanisms_array) != 0) &&
07620                         (amqpvalue_get_symbol(item_value, &sasl_server_mechanisms) != 0))
07621                     {
07622                         sasl_mechanisms_destroy(*sasl_mechanisms_handle);
07623                         result = __LINE__;
07624                         break;
07625                     }
07626 
07627                     amqpvalue_destroy(item_value);
07628                 }
07629 
07630                 sasl_mechanisms_instance->composite_value = amqpvalue_clone(value);
07631 
07632                 result = 0;
07633             } while (0);
07634         }
07635     }
07636 
07637     return result;
07638 }
07639 
07640 int sasl_mechanisms_get_sasl_server_mechanisms(SASL_MECHANISMS_HANDLE sasl_mechanisms, AMQP_VALUE* sasl_server_mechanisms_value)
07641 {
07642     int result;
07643 
07644     if (sasl_mechanisms == NULL)
07645     {
07646         result = __LINE__;
07647     }
07648     else
07649     {
07650         SASL_MECHANISMS_INSTANCE* sasl_mechanisms_instance = (SASL_MECHANISMS_INSTANCE*)sasl_mechanisms;
07651         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(sasl_mechanisms_instance->composite_value, 0);
07652         if (item_value == NULL)
07653         {
07654             result = __LINE__;
07655         }
07656         else
07657         {
07658             if (amqpvalue_get_array(item_value, sasl_server_mechanisms_value) != 0)
07659             {
07660                 result = __LINE__;
07661             }
07662             else
07663             {
07664                 result = 0;
07665             }
07666         }
07667     }
07668 
07669     return result;
07670 }
07671 
07672 int sasl_mechanisms_set_sasl_server_mechanisms(SASL_MECHANISMS_HANDLE sasl_mechanisms, AMQP_VALUE sasl_server_mechanisms_value)
07673 {
07674     int result;
07675 
07676     if (sasl_mechanisms == NULL)
07677     {
07678         result = __LINE__;
07679     }
07680     else
07681     {
07682         SASL_MECHANISMS_INSTANCE* sasl_mechanisms_instance = (SASL_MECHANISMS_INSTANCE*)sasl_mechanisms;
07683         AMQP_VALUE sasl_server_mechanisms_amqp_value = amqpvalue_clone(sasl_server_mechanisms_value);
07684         if (sasl_server_mechanisms_amqp_value == NULL)
07685         {
07686             result = __LINE__;
07687         }
07688         else
07689         {
07690             if (amqpvalue_set_composite_item(sasl_mechanisms_instance->composite_value, 0, sasl_server_mechanisms_amqp_value) != 0)
07691             {
07692                 result = __LINE__;
07693             }
07694             else
07695             {
07696                 result = 0;
07697             }
07698 
07699             amqpvalue_destroy(sasl_server_mechanisms_amqp_value);
07700         }
07701     }
07702 
07703     return result;
07704 }
07705 
07706 
07707 /* sasl-init */
07708 
07709 typedef struct SASL_INIT_INSTANCE_TAG
07710 {
07711     AMQP_VALUE composite_value;
07712 } SASL_INIT_INSTANCE;
07713 
07714 static SASL_INIT_HANDLE sasl_init_create_internal(void)
07715 {
07716     SASL_INIT_INSTANCE* sasl_init_instance = (SASL_INIT_INSTANCE*)amqpalloc_malloc(sizeof(SASL_INIT_INSTANCE));
07717     if (sasl_init_instance != NULL)
07718     {
07719         sasl_init_instance->composite_value = NULL;
07720     }
07721 
07722     return sasl_init_instance;
07723 }
07724 
07725 SASL_INIT_HANDLE sasl_init_create(const char* mechanism_value)
07726 {
07727     SASL_INIT_INSTANCE* sasl_init_instance = (SASL_INIT_INSTANCE*)amqpalloc_malloc(sizeof(SASL_INIT_INSTANCE));
07728     if (sasl_init_instance != NULL)
07729     {
07730         sasl_init_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(65);
07731         if (sasl_init_instance->composite_value == NULL)
07732         {
07733             amqpalloc_free(sasl_init_instance);
07734             sasl_init_instance = NULL;
07735         }
07736         else
07737         {
07738             AMQP_VALUE mechanism_amqp_value;
07739             int result = 0;
07740 
07741             mechanism_amqp_value = amqpvalue_create_symbol(mechanism_value);
07742             if ((result == 0) && (amqpvalue_set_composite_item(sasl_init_instance->composite_value, 0, mechanism_amqp_value) != 0))
07743             {
07744                 result = __LINE__;
07745             }
07746 
07747             amqpvalue_destroy(mechanism_amqp_value);
07748         }
07749     }
07750 
07751     return sasl_init_instance;
07752 }
07753 
07754 SASL_INIT_HANDLE sasl_init_clone(SASL_INIT_HANDLE value)
07755 {
07756     SASL_INIT_INSTANCE* sasl_init_instance = (SASL_INIT_INSTANCE*)amqpalloc_malloc(sizeof(SASL_INIT_INSTANCE));
07757     if (sasl_init_instance != NULL)
07758     {
07759         sasl_init_instance->composite_value = amqpvalue_clone(((SASL_INIT_INSTANCE*)value)->composite_value);
07760         if (sasl_init_instance->composite_value == NULL)
07761         {
07762             amqpalloc_free(sasl_init_instance);
07763             sasl_init_instance = NULL;
07764         }
07765     }
07766 
07767     return sasl_init_instance;
07768 }
07769 
07770 void sasl_init_destroy(SASL_INIT_HANDLE sasl_init)
07771 {
07772     if (sasl_init != NULL)
07773     {
07774         SASL_INIT_INSTANCE* sasl_init_instance = (SASL_INIT_INSTANCE*)sasl_init;
07775         amqpvalue_destroy(sasl_init_instance->composite_value);
07776         amqpalloc_free(sasl_init_instance);
07777     }
07778 }
07779 
07780 AMQP_VALUE amqpvalue_create_sasl_init(SASL_INIT_HANDLE sasl_init)
07781 {
07782     AMQP_VALUE result;
07783 
07784     if (sasl_init == NULL)
07785     {
07786         result = NULL;
07787     }
07788     else
07789     {
07790         SASL_INIT_INSTANCE* sasl_init_instance = (SASL_INIT_INSTANCE*)sasl_init;
07791         result = amqpvalue_clone(sasl_init_instance->composite_value);
07792     }
07793 
07794     return result;
07795 }
07796 
07797 bool is_sasl_init_type_by_descriptor(AMQP_VALUE descriptor)
07798 {
07799     bool result;
07800 
07801     uint64_t descriptor_ulong;
07802     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
07803         (descriptor_ulong == 65))
07804     {
07805         result = true;
07806     }
07807     else
07808     {
07809         result = false;
07810     }
07811 
07812     return result;
07813 }
07814 
07815 
07816 int amqpvalue_get_sasl_init(AMQP_VALUE value, SASL_INIT_HANDLE* sasl_init_handle)
07817 {
07818     int result;
07819     SASL_INIT_INSTANCE* sasl_init_instance = (SASL_INIT_INSTANCE*)sasl_init_create_internal();
07820     *sasl_init_handle = sasl_init_instance;
07821     if (*sasl_init_handle == NULL)
07822     {
07823         result = __LINE__;
07824     }
07825     else
07826     {
07827         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
07828         if (list_value == NULL)
07829         {
07830             sasl_init_destroy(*sasl_init_handle);
07831             result = __LINE__;
07832         }
07833         else
07834         {
07835             do
07836             {
07837                 AMQP_VALUE item_value;
07838                 /* mechanism */
07839                 item_value = amqpvalue_get_list_item(list_value, 0);
07840                 if (item_value == NULL)
07841                 {
07842                     {
07843                         sasl_init_destroy(*sasl_init_handle);
07844                         result = __LINE__;
07845                         break;
07846                     }
07847                 }
07848                 else
07849                 {
07850                     const char* mechanism;
07851                     if (amqpvalue_get_symbol(item_value, &mechanism) != 0)
07852                     {
07853                         sasl_init_destroy(*sasl_init_handle);
07854                         result = __LINE__;
07855                         break;
07856                     }
07857 
07858                     amqpvalue_destroy(item_value);
07859                 }
07860                 /* initial-response */
07861                 item_value = amqpvalue_get_list_item(list_value, 1);
07862                 if (item_value == NULL)
07863                 {
07864                     /* do nothing */
07865                 }
07866                 else
07867                 {
07868                     amqp_binary initial_response;
07869                     if (amqpvalue_get_binary(item_value, &initial_response) != 0)
07870                     {
07871                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
07872                         {
07873                             sasl_init_destroy(*sasl_init_handle);
07874                             result = __LINE__;
07875                             break;
07876                         }
07877                     }
07878 
07879                     amqpvalue_destroy(item_value);
07880                 }
07881                 /* hostname */
07882                 item_value = amqpvalue_get_list_item(list_value, 2);
07883                 if (item_value == NULL)
07884                 {
07885                     /* do nothing */
07886                 }
07887                 else
07888                 {
07889                     const char* hostname;
07890                     if (amqpvalue_get_string(item_value, &hostname) != 0)
07891                     {
07892                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
07893                         {
07894                             sasl_init_destroy(*sasl_init_handle);
07895                             result = __LINE__;
07896                             break;
07897                         }
07898                     }
07899 
07900                     amqpvalue_destroy(item_value);
07901                 }
07902 
07903                 sasl_init_instance->composite_value = amqpvalue_clone(value);
07904 
07905                 result = 0;
07906             } while (0);
07907         }
07908     }
07909 
07910     return result;
07911 }
07912 
07913 int sasl_init_get_mechanism(SASL_INIT_HANDLE sasl_init, const char** mechanism_value)
07914 {
07915     int result;
07916 
07917     if (sasl_init == NULL)
07918     {
07919         result = __LINE__;
07920     }
07921     else
07922     {
07923         SASL_INIT_INSTANCE* sasl_init_instance = (SASL_INIT_INSTANCE*)sasl_init;
07924         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(sasl_init_instance->composite_value, 0);
07925         if (item_value == NULL)
07926         {
07927             result = __LINE__;
07928         }
07929         else
07930         {
07931             if (amqpvalue_get_symbol(item_value, mechanism_value) != 0)
07932             {
07933                 result = __LINE__;
07934             }
07935             else
07936             {
07937                 result = 0;
07938             }
07939         }
07940     }
07941 
07942     return result;
07943 }
07944 
07945 int sasl_init_set_mechanism(SASL_INIT_HANDLE sasl_init, const char* mechanism_value)
07946 {
07947     int result;
07948 
07949     if (sasl_init == NULL)
07950     {
07951         result = __LINE__;
07952     }
07953     else
07954     {
07955         SASL_INIT_INSTANCE* sasl_init_instance = (SASL_INIT_INSTANCE*)sasl_init;
07956         AMQP_VALUE mechanism_amqp_value = amqpvalue_create_symbol(mechanism_value);
07957         if (mechanism_amqp_value == NULL)
07958         {
07959             result = __LINE__;
07960         }
07961         else
07962         {
07963             if (amqpvalue_set_composite_item(sasl_init_instance->composite_value, 0, mechanism_amqp_value) != 0)
07964             {
07965                 result = __LINE__;
07966             }
07967             else
07968             {
07969                 result = 0;
07970             }
07971 
07972             amqpvalue_destroy(mechanism_amqp_value);
07973         }
07974     }
07975 
07976     return result;
07977 }
07978 
07979 int sasl_init_get_initial_response(SASL_INIT_HANDLE sasl_init, amqp_binary* initial_response_value)
07980 {
07981     int result;
07982 
07983     if (sasl_init == NULL)
07984     {
07985         result = __LINE__;
07986     }
07987     else
07988     {
07989         SASL_INIT_INSTANCE* sasl_init_instance = (SASL_INIT_INSTANCE*)sasl_init;
07990         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(sasl_init_instance->composite_value, 1);
07991         if (item_value == NULL)
07992         {
07993             result = __LINE__;
07994         }
07995         else
07996         {
07997             if (amqpvalue_get_binary(item_value, initial_response_value) != 0)
07998             {
07999                 result = __LINE__;
08000             }
08001             else
08002             {
08003                 result = 0;
08004             }
08005         }
08006     }
08007 
08008     return result;
08009 }
08010 
08011 int sasl_init_set_initial_response(SASL_INIT_HANDLE sasl_init, amqp_binary initial_response_value)
08012 {
08013     int result;
08014 
08015     if (sasl_init == NULL)
08016     {
08017         result = __LINE__;
08018     }
08019     else
08020     {
08021         SASL_INIT_INSTANCE* sasl_init_instance = (SASL_INIT_INSTANCE*)sasl_init;
08022         AMQP_VALUE initial_response_amqp_value = amqpvalue_create_binary(initial_response_value);
08023         if (initial_response_amqp_value == NULL)
08024         {
08025             result = __LINE__;
08026         }
08027         else
08028         {
08029             if (amqpvalue_set_composite_item(sasl_init_instance->composite_value, 1, initial_response_amqp_value) != 0)
08030             {
08031                 result = __LINE__;
08032             }
08033             else
08034             {
08035                 result = 0;
08036             }
08037 
08038             amqpvalue_destroy(initial_response_amqp_value);
08039         }
08040     }
08041 
08042     return result;
08043 }
08044 
08045 int sasl_init_get_hostname(SASL_INIT_HANDLE sasl_init, const char** hostname_value)
08046 {
08047     int result;
08048 
08049     if (sasl_init == NULL)
08050     {
08051         result = __LINE__;
08052     }
08053     else
08054     {
08055         SASL_INIT_INSTANCE* sasl_init_instance = (SASL_INIT_INSTANCE*)sasl_init;
08056         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(sasl_init_instance->composite_value, 2);
08057         if (item_value == NULL)
08058         {
08059             result = __LINE__;
08060         }
08061         else
08062         {
08063             if (amqpvalue_get_string(item_value, hostname_value) != 0)
08064             {
08065                 result = __LINE__;
08066             }
08067             else
08068             {
08069                 result = 0;
08070             }
08071         }
08072     }
08073 
08074     return result;
08075 }
08076 
08077 int sasl_init_set_hostname(SASL_INIT_HANDLE sasl_init, const char* hostname_value)
08078 {
08079     int result;
08080 
08081     if (sasl_init == NULL)
08082     {
08083         result = __LINE__;
08084     }
08085     else
08086     {
08087         SASL_INIT_INSTANCE* sasl_init_instance = (SASL_INIT_INSTANCE*)sasl_init;
08088         AMQP_VALUE hostname_amqp_value = amqpvalue_create_string(hostname_value);
08089         if (hostname_amqp_value == NULL)
08090         {
08091             result = __LINE__;
08092         }
08093         else
08094         {
08095             if (amqpvalue_set_composite_item(sasl_init_instance->composite_value, 2, hostname_amqp_value) != 0)
08096             {
08097                 result = __LINE__;
08098             }
08099             else
08100             {
08101                 result = 0;
08102             }
08103 
08104             amqpvalue_destroy(hostname_amqp_value);
08105         }
08106     }
08107 
08108     return result;
08109 }
08110 
08111 
08112 /* sasl-challenge */
08113 
08114 typedef struct SASL_CHALLENGE_INSTANCE_TAG
08115 {
08116     AMQP_VALUE composite_value;
08117 } SASL_CHALLENGE_INSTANCE;
08118 
08119 static SASL_CHALLENGE_HANDLE sasl_challenge_create_internal(void)
08120 {
08121     SASL_CHALLENGE_INSTANCE* sasl_challenge_instance = (SASL_CHALLENGE_INSTANCE*)amqpalloc_malloc(sizeof(SASL_CHALLENGE_INSTANCE));
08122     if (sasl_challenge_instance != NULL)
08123     {
08124         sasl_challenge_instance->composite_value = NULL;
08125     }
08126 
08127     return sasl_challenge_instance;
08128 }
08129 
08130 SASL_CHALLENGE_HANDLE sasl_challenge_create(amqp_binary challenge_value)
08131 {
08132     SASL_CHALLENGE_INSTANCE* sasl_challenge_instance = (SASL_CHALLENGE_INSTANCE*)amqpalloc_malloc(sizeof(SASL_CHALLENGE_INSTANCE));
08133     if (sasl_challenge_instance != NULL)
08134     {
08135         sasl_challenge_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(66);
08136         if (sasl_challenge_instance->composite_value == NULL)
08137         {
08138             amqpalloc_free(sasl_challenge_instance);
08139             sasl_challenge_instance = NULL;
08140         }
08141         else
08142         {
08143             AMQP_VALUE challenge_amqp_value;
08144             int result = 0;
08145 
08146             challenge_amqp_value = amqpvalue_create_binary(challenge_value);
08147             if ((result == 0) && (amqpvalue_set_composite_item(sasl_challenge_instance->composite_value, 0, challenge_amqp_value) != 0))
08148             {
08149                 result = __LINE__;
08150             }
08151 
08152             amqpvalue_destroy(challenge_amqp_value);
08153         }
08154     }
08155 
08156     return sasl_challenge_instance;
08157 }
08158 
08159 SASL_CHALLENGE_HANDLE sasl_challenge_clone(SASL_CHALLENGE_HANDLE value)
08160 {
08161     SASL_CHALLENGE_INSTANCE* sasl_challenge_instance = (SASL_CHALLENGE_INSTANCE*)amqpalloc_malloc(sizeof(SASL_CHALLENGE_INSTANCE));
08162     if (sasl_challenge_instance != NULL)
08163     {
08164         sasl_challenge_instance->composite_value = amqpvalue_clone(((SASL_CHALLENGE_INSTANCE*)value)->composite_value);
08165         if (sasl_challenge_instance->composite_value == NULL)
08166         {
08167             amqpalloc_free(sasl_challenge_instance);
08168             sasl_challenge_instance = NULL;
08169         }
08170     }
08171 
08172     return sasl_challenge_instance;
08173 }
08174 
08175 void sasl_challenge_destroy(SASL_CHALLENGE_HANDLE sasl_challenge)
08176 {
08177     if (sasl_challenge != NULL)
08178     {
08179         SASL_CHALLENGE_INSTANCE* sasl_challenge_instance = (SASL_CHALLENGE_INSTANCE*)sasl_challenge;
08180         amqpvalue_destroy(sasl_challenge_instance->composite_value);
08181         amqpalloc_free(sasl_challenge_instance);
08182     }
08183 }
08184 
08185 AMQP_VALUE amqpvalue_create_sasl_challenge(SASL_CHALLENGE_HANDLE sasl_challenge)
08186 {
08187     AMQP_VALUE result;
08188 
08189     if (sasl_challenge == NULL)
08190     {
08191         result = NULL;
08192     }
08193     else
08194     {
08195         SASL_CHALLENGE_INSTANCE* sasl_challenge_instance = (SASL_CHALLENGE_INSTANCE*)sasl_challenge;
08196         result = amqpvalue_clone(sasl_challenge_instance->composite_value);
08197     }
08198 
08199     return result;
08200 }
08201 
08202 bool is_sasl_challenge_type_by_descriptor(AMQP_VALUE descriptor)
08203 {
08204     bool result;
08205 
08206     uint64_t descriptor_ulong;
08207     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
08208         (descriptor_ulong == 66))
08209     {
08210         result = true;
08211     }
08212     else
08213     {
08214         result = false;
08215     }
08216 
08217     return result;
08218 }
08219 
08220 
08221 int amqpvalue_get_sasl_challenge(AMQP_VALUE value, SASL_CHALLENGE_HANDLE* sasl_challenge_handle)
08222 {
08223     int result;
08224     SASL_CHALLENGE_INSTANCE* sasl_challenge_instance = (SASL_CHALLENGE_INSTANCE*)sasl_challenge_create_internal();
08225     *sasl_challenge_handle = sasl_challenge_instance;
08226     if (*sasl_challenge_handle == NULL)
08227     {
08228         result = __LINE__;
08229     }
08230     else
08231     {
08232         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
08233         if (list_value == NULL)
08234         {
08235             sasl_challenge_destroy(*sasl_challenge_handle);
08236             result = __LINE__;
08237         }
08238         else
08239         {
08240             do
08241             {
08242                 AMQP_VALUE item_value;
08243                 /* challenge */
08244                 item_value = amqpvalue_get_list_item(list_value, 0);
08245                 if (item_value == NULL)
08246                 {
08247                     {
08248                         sasl_challenge_destroy(*sasl_challenge_handle);
08249                         result = __LINE__;
08250                         break;
08251                     }
08252                 }
08253                 else
08254                 {
08255                     amqp_binary challenge;
08256                     if (amqpvalue_get_binary(item_value, &challenge) != 0)
08257                     {
08258                         sasl_challenge_destroy(*sasl_challenge_handle);
08259                         result = __LINE__;
08260                         break;
08261                     }
08262 
08263                     amqpvalue_destroy(item_value);
08264                 }
08265 
08266                 sasl_challenge_instance->composite_value = amqpvalue_clone(value);
08267 
08268                 result = 0;
08269             } while (0);
08270         }
08271     }
08272 
08273     return result;
08274 }
08275 
08276 int sasl_challenge_get_challenge(SASL_CHALLENGE_HANDLE sasl_challenge, amqp_binary* challenge_value)
08277 {
08278     int result;
08279 
08280     if (sasl_challenge == NULL)
08281     {
08282         result = __LINE__;
08283     }
08284     else
08285     {
08286         SASL_CHALLENGE_INSTANCE* sasl_challenge_instance = (SASL_CHALLENGE_INSTANCE*)sasl_challenge;
08287         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(sasl_challenge_instance->composite_value, 0);
08288         if (item_value == NULL)
08289         {
08290             result = __LINE__;
08291         }
08292         else
08293         {
08294             if (amqpvalue_get_binary(item_value, challenge_value) != 0)
08295             {
08296                 result = __LINE__;
08297             }
08298             else
08299             {
08300                 result = 0;
08301             }
08302         }
08303     }
08304 
08305     return result;
08306 }
08307 
08308 int sasl_challenge_set_challenge(SASL_CHALLENGE_HANDLE sasl_challenge, amqp_binary challenge_value)
08309 {
08310     int result;
08311 
08312     if (sasl_challenge == NULL)
08313     {
08314         result = __LINE__;
08315     }
08316     else
08317     {
08318         SASL_CHALLENGE_INSTANCE* sasl_challenge_instance = (SASL_CHALLENGE_INSTANCE*)sasl_challenge;
08319         AMQP_VALUE challenge_amqp_value = amqpvalue_create_binary(challenge_value);
08320         if (challenge_amqp_value == NULL)
08321         {
08322             result = __LINE__;
08323         }
08324         else
08325         {
08326             if (amqpvalue_set_composite_item(sasl_challenge_instance->composite_value, 0, challenge_amqp_value) != 0)
08327             {
08328                 result = __LINE__;
08329             }
08330             else
08331             {
08332                 result = 0;
08333             }
08334 
08335             amqpvalue_destroy(challenge_amqp_value);
08336         }
08337     }
08338 
08339     return result;
08340 }
08341 
08342 
08343 /* sasl-response */
08344 
08345 typedef struct SASL_RESPONSE_INSTANCE_TAG
08346 {
08347     AMQP_VALUE composite_value;
08348 } SASL_RESPONSE_INSTANCE;
08349 
08350 static SASL_RESPONSE_HANDLE sasl_response_create_internal(void)
08351 {
08352     SASL_RESPONSE_INSTANCE* sasl_response_instance = (SASL_RESPONSE_INSTANCE*)amqpalloc_malloc(sizeof(SASL_RESPONSE_INSTANCE));
08353     if (sasl_response_instance != NULL)
08354     {
08355         sasl_response_instance->composite_value = NULL;
08356     }
08357 
08358     return sasl_response_instance;
08359 }
08360 
08361 SASL_RESPONSE_HANDLE sasl_response_create(amqp_binary response_value)
08362 {
08363     SASL_RESPONSE_INSTANCE* sasl_response_instance = (SASL_RESPONSE_INSTANCE*)amqpalloc_malloc(sizeof(SASL_RESPONSE_INSTANCE));
08364     if (sasl_response_instance != NULL)
08365     {
08366         sasl_response_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(67);
08367         if (sasl_response_instance->composite_value == NULL)
08368         {
08369             amqpalloc_free(sasl_response_instance);
08370             sasl_response_instance = NULL;
08371         }
08372         else
08373         {
08374             AMQP_VALUE response_amqp_value;
08375             int result = 0;
08376 
08377             response_amqp_value = amqpvalue_create_binary(response_value);
08378             if ((result == 0) && (amqpvalue_set_composite_item(sasl_response_instance->composite_value, 0, response_amqp_value) != 0))
08379             {
08380                 result = __LINE__;
08381             }
08382 
08383             amqpvalue_destroy(response_amqp_value);
08384         }
08385     }
08386 
08387     return sasl_response_instance;
08388 }
08389 
08390 SASL_RESPONSE_HANDLE sasl_response_clone(SASL_RESPONSE_HANDLE value)
08391 {
08392     SASL_RESPONSE_INSTANCE* sasl_response_instance = (SASL_RESPONSE_INSTANCE*)amqpalloc_malloc(sizeof(SASL_RESPONSE_INSTANCE));
08393     if (sasl_response_instance != NULL)
08394     {
08395         sasl_response_instance->composite_value = amqpvalue_clone(((SASL_RESPONSE_INSTANCE*)value)->composite_value);
08396         if (sasl_response_instance->composite_value == NULL)
08397         {
08398             amqpalloc_free(sasl_response_instance);
08399             sasl_response_instance = NULL;
08400         }
08401     }
08402 
08403     return sasl_response_instance;
08404 }
08405 
08406 void sasl_response_destroy(SASL_RESPONSE_HANDLE sasl_response)
08407 {
08408     if (sasl_response != NULL)
08409     {
08410         SASL_RESPONSE_INSTANCE* sasl_response_instance = (SASL_RESPONSE_INSTANCE*)sasl_response;
08411         amqpvalue_destroy(sasl_response_instance->composite_value);
08412         amqpalloc_free(sasl_response_instance);
08413     }
08414 }
08415 
08416 AMQP_VALUE amqpvalue_create_sasl_response(SASL_RESPONSE_HANDLE sasl_response)
08417 {
08418     AMQP_VALUE result;
08419 
08420     if (sasl_response == NULL)
08421     {
08422         result = NULL;
08423     }
08424     else
08425     {
08426         SASL_RESPONSE_INSTANCE* sasl_response_instance = (SASL_RESPONSE_INSTANCE*)sasl_response;
08427         result = amqpvalue_clone(sasl_response_instance->composite_value);
08428     }
08429 
08430     return result;
08431 }
08432 
08433 bool is_sasl_response_type_by_descriptor(AMQP_VALUE descriptor)
08434 {
08435     bool result;
08436 
08437     uint64_t descriptor_ulong;
08438     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
08439         (descriptor_ulong == 67))
08440     {
08441         result = true;
08442     }
08443     else
08444     {
08445         result = false;
08446     }
08447 
08448     return result;
08449 }
08450 
08451 
08452 int amqpvalue_get_sasl_response(AMQP_VALUE value, SASL_RESPONSE_HANDLE* sasl_response_handle)
08453 {
08454     int result;
08455     SASL_RESPONSE_INSTANCE* sasl_response_instance = (SASL_RESPONSE_INSTANCE*)sasl_response_create_internal();
08456     *sasl_response_handle = sasl_response_instance;
08457     if (*sasl_response_handle == NULL)
08458     {
08459         result = __LINE__;
08460     }
08461     else
08462     {
08463         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
08464         if (list_value == NULL)
08465         {
08466             sasl_response_destroy(*sasl_response_handle);
08467             result = __LINE__;
08468         }
08469         else
08470         {
08471             do
08472             {
08473                 AMQP_VALUE item_value;
08474                 /* response */
08475                 item_value = amqpvalue_get_list_item(list_value, 0);
08476                 if (item_value == NULL)
08477                 {
08478                     {
08479                         sasl_response_destroy(*sasl_response_handle);
08480                         result = __LINE__;
08481                         break;
08482                     }
08483                 }
08484                 else
08485                 {
08486                     amqp_binary response;
08487                     if (amqpvalue_get_binary(item_value, &response) != 0)
08488                     {
08489                         sasl_response_destroy(*sasl_response_handle);
08490                         result = __LINE__;
08491                         break;
08492                     }
08493 
08494                     amqpvalue_destroy(item_value);
08495                 }
08496 
08497                 sasl_response_instance->composite_value = amqpvalue_clone(value);
08498 
08499                 result = 0;
08500             } while (0);
08501         }
08502     }
08503 
08504     return result;
08505 }
08506 
08507 int sasl_response_get_response(SASL_RESPONSE_HANDLE sasl_response, amqp_binary* response_value)
08508 {
08509     int result;
08510 
08511     if (sasl_response == NULL)
08512     {
08513         result = __LINE__;
08514     }
08515     else
08516     {
08517         SASL_RESPONSE_INSTANCE* sasl_response_instance = (SASL_RESPONSE_INSTANCE*)sasl_response;
08518         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(sasl_response_instance->composite_value, 0);
08519         if (item_value == NULL)
08520         {
08521             result = __LINE__;
08522         }
08523         else
08524         {
08525             if (amqpvalue_get_binary(item_value, response_value) != 0)
08526             {
08527                 result = __LINE__;
08528             }
08529             else
08530             {
08531                 result = 0;
08532             }
08533         }
08534     }
08535 
08536     return result;
08537 }
08538 
08539 int sasl_response_set_response(SASL_RESPONSE_HANDLE sasl_response, amqp_binary response_value)
08540 {
08541     int result;
08542 
08543     if (sasl_response == NULL)
08544     {
08545         result = __LINE__;
08546     }
08547     else
08548     {
08549         SASL_RESPONSE_INSTANCE* sasl_response_instance = (SASL_RESPONSE_INSTANCE*)sasl_response;
08550         AMQP_VALUE response_amqp_value = amqpvalue_create_binary(response_value);
08551         if (response_amqp_value == NULL)
08552         {
08553             result = __LINE__;
08554         }
08555         else
08556         {
08557             if (amqpvalue_set_composite_item(sasl_response_instance->composite_value, 0, response_amqp_value) != 0)
08558             {
08559                 result = __LINE__;
08560             }
08561             else
08562             {
08563                 result = 0;
08564             }
08565 
08566             amqpvalue_destroy(response_amqp_value);
08567         }
08568     }
08569 
08570     return result;
08571 }
08572 
08573 
08574 /* sasl-outcome */
08575 
08576 typedef struct SASL_OUTCOME_INSTANCE_TAG
08577 {
08578     AMQP_VALUE composite_value;
08579 } SASL_OUTCOME_INSTANCE;
08580 
08581 static SASL_OUTCOME_HANDLE sasl_outcome_create_internal(void)
08582 {
08583     SASL_OUTCOME_INSTANCE* sasl_outcome_instance = (SASL_OUTCOME_INSTANCE*)amqpalloc_malloc(sizeof(SASL_OUTCOME_INSTANCE));
08584     if (sasl_outcome_instance != NULL)
08585     {
08586         sasl_outcome_instance->composite_value = NULL;
08587     }
08588 
08589     return sasl_outcome_instance;
08590 }
08591 
08592 SASL_OUTCOME_HANDLE sasl_outcome_create(sasl_code code_value)
08593 {
08594     SASL_OUTCOME_INSTANCE* sasl_outcome_instance = (SASL_OUTCOME_INSTANCE*)amqpalloc_malloc(sizeof(SASL_OUTCOME_INSTANCE));
08595     if (sasl_outcome_instance != NULL)
08596     {
08597         sasl_outcome_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(68);
08598         if (sasl_outcome_instance->composite_value == NULL)
08599         {
08600             amqpalloc_free(sasl_outcome_instance);
08601             sasl_outcome_instance = NULL;
08602         }
08603         else
08604         {
08605             AMQP_VALUE code_amqp_value;
08606             int result = 0;
08607 
08608             code_amqp_value = amqpvalue_create_sasl_code(code_value);
08609             if ((result == 0) && (amqpvalue_set_composite_item(sasl_outcome_instance->composite_value, 0, code_amqp_value) != 0))
08610             {
08611                 result = __LINE__;
08612             }
08613 
08614             amqpvalue_destroy(code_amqp_value);
08615         }
08616     }
08617 
08618     return sasl_outcome_instance;
08619 }
08620 
08621 SASL_OUTCOME_HANDLE sasl_outcome_clone(SASL_OUTCOME_HANDLE value)
08622 {
08623     SASL_OUTCOME_INSTANCE* sasl_outcome_instance = (SASL_OUTCOME_INSTANCE*)amqpalloc_malloc(sizeof(SASL_OUTCOME_INSTANCE));
08624     if (sasl_outcome_instance != NULL)
08625     {
08626         sasl_outcome_instance->composite_value = amqpvalue_clone(((SASL_OUTCOME_INSTANCE*)value)->composite_value);
08627         if (sasl_outcome_instance->composite_value == NULL)
08628         {
08629             amqpalloc_free(sasl_outcome_instance);
08630             sasl_outcome_instance = NULL;
08631         }
08632     }
08633 
08634     return sasl_outcome_instance;
08635 }
08636 
08637 void sasl_outcome_destroy(SASL_OUTCOME_HANDLE sasl_outcome)
08638 {
08639     if (sasl_outcome != NULL)
08640     {
08641         SASL_OUTCOME_INSTANCE* sasl_outcome_instance = (SASL_OUTCOME_INSTANCE*)sasl_outcome;
08642         amqpvalue_destroy(sasl_outcome_instance->composite_value);
08643         amqpalloc_free(sasl_outcome_instance);
08644     }
08645 }
08646 
08647 AMQP_VALUE amqpvalue_create_sasl_outcome(SASL_OUTCOME_HANDLE sasl_outcome)
08648 {
08649     AMQP_VALUE result;
08650 
08651     if (sasl_outcome == NULL)
08652     {
08653         result = NULL;
08654     }
08655     else
08656     {
08657         SASL_OUTCOME_INSTANCE* sasl_outcome_instance = (SASL_OUTCOME_INSTANCE*)sasl_outcome;
08658         result = amqpvalue_clone(sasl_outcome_instance->composite_value);
08659     }
08660 
08661     return result;
08662 }
08663 
08664 bool is_sasl_outcome_type_by_descriptor(AMQP_VALUE descriptor)
08665 {
08666     bool result;
08667 
08668     uint64_t descriptor_ulong;
08669     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
08670         (descriptor_ulong == 68))
08671     {
08672         result = true;
08673     }
08674     else
08675     {
08676         result = false;
08677     }
08678 
08679     return result;
08680 }
08681 
08682 
08683 int amqpvalue_get_sasl_outcome(AMQP_VALUE value, SASL_OUTCOME_HANDLE* sasl_outcome_handle)
08684 {
08685     int result;
08686     SASL_OUTCOME_INSTANCE* sasl_outcome_instance = (SASL_OUTCOME_INSTANCE*)sasl_outcome_create_internal();
08687     *sasl_outcome_handle = sasl_outcome_instance;
08688     if (*sasl_outcome_handle == NULL)
08689     {
08690         result = __LINE__;
08691     }
08692     else
08693     {
08694         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
08695         if (list_value == NULL)
08696         {
08697             sasl_outcome_destroy(*sasl_outcome_handle);
08698             result = __LINE__;
08699         }
08700         else
08701         {
08702             do
08703             {
08704                 AMQP_VALUE item_value;
08705                 /* code */
08706                 item_value = amqpvalue_get_list_item(list_value, 0);
08707                 if (item_value == NULL)
08708                 {
08709                     {
08710                         sasl_outcome_destroy(*sasl_outcome_handle);
08711                         result = __LINE__;
08712                         break;
08713                     }
08714                 }
08715                 else
08716                 {
08717                     sasl_code code;
08718                     if (amqpvalue_get_sasl_code(item_value, &code) != 0)
08719                     {
08720                         sasl_outcome_destroy(*sasl_outcome_handle);
08721                         result = __LINE__;
08722                         break;
08723                     }
08724 
08725                     amqpvalue_destroy(item_value);
08726                 }
08727                 /* additional-data */
08728                 item_value = amqpvalue_get_list_item(list_value, 1);
08729                 if (item_value == NULL)
08730                 {
08731                     /* do nothing */
08732                 }
08733                 else
08734                 {
08735                     amqp_binary additional_data;
08736                     if (amqpvalue_get_binary(item_value, &additional_data) != 0)
08737                     {
08738                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
08739                         {
08740                             sasl_outcome_destroy(*sasl_outcome_handle);
08741                             result = __LINE__;
08742                             break;
08743                         }
08744                     }
08745 
08746                     amqpvalue_destroy(item_value);
08747                 }
08748 
08749                 sasl_outcome_instance->composite_value = amqpvalue_clone(value);
08750 
08751                 result = 0;
08752             } while (0);
08753         }
08754     }
08755 
08756     return result;
08757 }
08758 
08759 int sasl_outcome_get_code(SASL_OUTCOME_HANDLE sasl_outcome, sasl_code* code_value)
08760 {
08761     int result;
08762 
08763     if (sasl_outcome == NULL)
08764     {
08765         result = __LINE__;
08766     }
08767     else
08768     {
08769         SASL_OUTCOME_INSTANCE* sasl_outcome_instance = (SASL_OUTCOME_INSTANCE*)sasl_outcome;
08770         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(sasl_outcome_instance->composite_value, 0);
08771         if (item_value == NULL)
08772         {
08773             result = __LINE__;
08774         }
08775         else
08776         {
08777             if (amqpvalue_get_sasl_code(item_value, code_value) != 0)
08778             {
08779                 result = __LINE__;
08780             }
08781             else
08782             {
08783                 result = 0;
08784             }
08785         }
08786     }
08787 
08788     return result;
08789 }
08790 
08791 int sasl_outcome_set_code(SASL_OUTCOME_HANDLE sasl_outcome, sasl_code code_value)
08792 {
08793     int result;
08794 
08795     if (sasl_outcome == NULL)
08796     {
08797         result = __LINE__;
08798     }
08799     else
08800     {
08801         SASL_OUTCOME_INSTANCE* sasl_outcome_instance = (SASL_OUTCOME_INSTANCE*)sasl_outcome;
08802         AMQP_VALUE code_amqp_value = amqpvalue_create_sasl_code(code_value);
08803         if (code_amqp_value == NULL)
08804         {
08805             result = __LINE__;
08806         }
08807         else
08808         {
08809             if (amqpvalue_set_composite_item(sasl_outcome_instance->composite_value, 0, code_amqp_value) != 0)
08810             {
08811                 result = __LINE__;
08812             }
08813             else
08814             {
08815                 result = 0;
08816             }
08817 
08818             amqpvalue_destroy(code_amqp_value);
08819         }
08820     }
08821 
08822     return result;
08823 }
08824 
08825 int sasl_outcome_get_additional_data(SASL_OUTCOME_HANDLE sasl_outcome, amqp_binary* additional_data_value)
08826 {
08827     int result;
08828 
08829     if (sasl_outcome == NULL)
08830     {
08831         result = __LINE__;
08832     }
08833     else
08834     {
08835         SASL_OUTCOME_INSTANCE* sasl_outcome_instance = (SASL_OUTCOME_INSTANCE*)sasl_outcome;
08836         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(sasl_outcome_instance->composite_value, 1);
08837         if (item_value == NULL)
08838         {
08839             result = __LINE__;
08840         }
08841         else
08842         {
08843             if (amqpvalue_get_binary(item_value, additional_data_value) != 0)
08844             {
08845                 result = __LINE__;
08846             }
08847             else
08848             {
08849                 result = 0;
08850             }
08851         }
08852     }
08853 
08854     return result;
08855 }
08856 
08857 int sasl_outcome_set_additional_data(SASL_OUTCOME_HANDLE sasl_outcome, amqp_binary additional_data_value)
08858 {
08859     int result;
08860 
08861     if (sasl_outcome == NULL)
08862     {
08863         result = __LINE__;
08864     }
08865     else
08866     {
08867         SASL_OUTCOME_INSTANCE* sasl_outcome_instance = (SASL_OUTCOME_INSTANCE*)sasl_outcome;
08868         AMQP_VALUE additional_data_amqp_value = amqpvalue_create_binary(additional_data_value);
08869         if (additional_data_amqp_value == NULL)
08870         {
08871             result = __LINE__;
08872         }
08873         else
08874         {
08875             if (amqpvalue_set_composite_item(sasl_outcome_instance->composite_value, 1, additional_data_amqp_value) != 0)
08876             {
08877                 result = __LINE__;
08878             }
08879             else
08880             {
08881                 result = 0;
08882             }
08883 
08884             amqpvalue_destroy(additional_data_amqp_value);
08885         }
08886     }
08887 
08888     return result;
08889 }
08890 
08891 
08892 /* terminus-durability */
08893 
08894 AMQP_VALUE amqpvalue_create_terminus_durability(terminus_durability value)
08895 {
08896     return amqpvalue_create_uint(value);
08897 }
08898 
08899 /* terminus-expiry-policy */
08900 
08901 AMQP_VALUE amqpvalue_create_terminus_expiry_policy(terminus_expiry_policy value)
08902 {
08903     return amqpvalue_create_symbol(value);
08904 }
08905 
08906 /* node-properties */
08907 
08908 AMQP_VALUE amqpvalue_create_node_properties(node_properties value)
08909 {
08910     return amqpvalue_create_fields(value);
08911 }
08912 
08913 /* filter-set */
08914 
08915 AMQP_VALUE amqpvalue_create_filter_set(AMQP_VALUE value)
08916 {
08917     return amqpvalue_clone(value);
08918 }
08919 
08920 /* source */
08921 
08922 typedef struct SOURCE_INSTANCE_TAG
08923 {
08924     AMQP_VALUE composite_value;
08925 } SOURCE_INSTANCE;
08926 
08927 static SOURCE_HANDLE source_create_internal(void)
08928 {
08929     SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)amqpalloc_malloc(sizeof(SOURCE_INSTANCE));
08930     if (source_instance != NULL)
08931     {
08932         source_instance->composite_value = NULL;
08933     }
08934 
08935     return source_instance;
08936 }
08937 
08938 SOURCE_HANDLE source_create(void)
08939 {
08940     SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)amqpalloc_malloc(sizeof(SOURCE_INSTANCE));
08941     if (source_instance != NULL)
08942     {
08943         source_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(40);
08944         if (source_instance->composite_value == NULL)
08945         {
08946             amqpalloc_free(source_instance);
08947             source_instance = NULL;
08948         }
08949     }
08950 
08951     return source_instance;
08952 }
08953 
08954 SOURCE_HANDLE source_clone(SOURCE_HANDLE value)
08955 {
08956     SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)amqpalloc_malloc(sizeof(SOURCE_INSTANCE));
08957     if (source_instance != NULL)
08958     {
08959         source_instance->composite_value = amqpvalue_clone(((SOURCE_INSTANCE*)value)->composite_value);
08960         if (source_instance->composite_value == NULL)
08961         {
08962             amqpalloc_free(source_instance);
08963             source_instance = NULL;
08964         }
08965     }
08966 
08967     return source_instance;
08968 }
08969 
08970 void source_destroy(SOURCE_HANDLE source)
08971 {
08972     if (source != NULL)
08973     {
08974         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
08975         amqpvalue_destroy(source_instance->composite_value);
08976         amqpalloc_free(source_instance);
08977     }
08978 }
08979 
08980 AMQP_VALUE amqpvalue_create_source(SOURCE_HANDLE source)
08981 {
08982     AMQP_VALUE result;
08983 
08984     if (source == NULL)
08985     {
08986         result = NULL;
08987     }
08988     else
08989     {
08990         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
08991         result = amqpvalue_clone(source_instance->composite_value);
08992     }
08993 
08994     return result;
08995 }
08996 
08997 bool is_source_type_by_descriptor(AMQP_VALUE descriptor)
08998 {
08999     bool result;
09000 
09001     uint64_t descriptor_ulong;
09002     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
09003         (descriptor_ulong == 40))
09004     {
09005         result = true;
09006     }
09007     else
09008     {
09009         result = false;
09010     }
09011 
09012     return result;
09013 }
09014 
09015 
09016 int amqpvalue_get_source(AMQP_VALUE value, SOURCE_HANDLE* source_handle)
09017 {
09018     int result;
09019     SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source_create_internal();
09020     *source_handle = source_instance;
09021     if (*source_handle == NULL)
09022     {
09023         result = __LINE__;
09024     }
09025     else
09026     {
09027         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
09028         if (list_value == NULL)
09029         {
09030             source_destroy(*source_handle);
09031             result = __LINE__;
09032         }
09033         else
09034         {
09035             do
09036             {
09037                 AMQP_VALUE item_value;
09038                 /* address */
09039                 item_value = amqpvalue_get_list_item(list_value, 0);
09040                 if (item_value == NULL)
09041                 {
09042                     /* do nothing */
09043                 }
09044                 else
09045                 {
09046                     amqpvalue_destroy(item_value);
09047                 }
09048                 /* durable */
09049                 item_value = amqpvalue_get_list_item(list_value, 1);
09050                 if (item_value == NULL)
09051                 {
09052                     /* do nothing */
09053                 }
09054                 else
09055                 {
09056                     terminus_durability durable;
09057                     if (amqpvalue_get_terminus_durability(item_value, &durable) != 0)
09058                     {
09059                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
09060                         {
09061                             source_destroy(*source_handle);
09062                             result = __LINE__;
09063                             break;
09064                         }
09065                     }
09066 
09067                     amqpvalue_destroy(item_value);
09068                 }
09069                 /* expiry-policy */
09070                 item_value = amqpvalue_get_list_item(list_value, 2);
09071                 if (item_value == NULL)
09072                 {
09073                     /* do nothing */
09074                 }
09075                 else
09076                 {
09077                     terminus_expiry_policy expiry_policy;
09078                     if (amqpvalue_get_terminus_expiry_policy(item_value, &expiry_policy) != 0)
09079                     {
09080                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
09081                         {
09082                             source_destroy(*source_handle);
09083                             result = __LINE__;
09084                             break;
09085                         }
09086                     }
09087 
09088                     amqpvalue_destroy(item_value);
09089                 }
09090                 /* timeout */
09091                 item_value = amqpvalue_get_list_item(list_value, 3);
09092                 if (item_value == NULL)
09093                 {
09094                     /* do nothing */
09095                 }
09096                 else
09097                 {
09098                     seconds timeout;
09099                     if (amqpvalue_get_seconds(item_value, &timeout) != 0)
09100                     {
09101                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
09102                         {
09103                             source_destroy(*source_handle);
09104                             result = __LINE__;
09105                             break;
09106                         }
09107                     }
09108 
09109                     amqpvalue_destroy(item_value);
09110                 }
09111                 /* dynamic */
09112                 item_value = amqpvalue_get_list_item(list_value, 4);
09113                 if (item_value == NULL)
09114                 {
09115                     /* do nothing */
09116                 }
09117                 else
09118                 {
09119                     bool dynamic;
09120                     if (amqpvalue_get_boolean(item_value, &dynamic) != 0)
09121                     {
09122                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
09123                         {
09124                             source_destroy(*source_handle);
09125                             result = __LINE__;
09126                             break;
09127                         }
09128                     }
09129 
09130                     amqpvalue_destroy(item_value);
09131                 }
09132                 /* dynamic-node-properties */
09133                 item_value = amqpvalue_get_list_item(list_value, 5);
09134                 if (item_value == NULL)
09135                 {
09136                     /* do nothing */
09137                 }
09138                 else
09139                 {
09140                     node_properties dynamic_node_properties;
09141                     if (amqpvalue_get_node_properties(item_value, &dynamic_node_properties) != 0)
09142                     {
09143                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
09144                         {
09145                             source_destroy(*source_handle);
09146                             result = __LINE__;
09147                             break;
09148                         }
09149                     }
09150 
09151                     amqpvalue_destroy(item_value);
09152                 }
09153                 /* distribution-mode */
09154                 item_value = amqpvalue_get_list_item(list_value, 6);
09155                 if (item_value == NULL)
09156                 {
09157                     /* do nothing */
09158                 }
09159                 else
09160                 {
09161                     const char* distribution_mode;
09162                     if (amqpvalue_get_symbol(item_value, &distribution_mode) != 0)
09163                     {
09164                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
09165                         {
09166                             source_destroy(*source_handle);
09167                             result = __LINE__;
09168                             break;
09169                         }
09170                     }
09171 
09172                     amqpvalue_destroy(item_value);
09173                 }
09174                 /* filter */
09175                 item_value = amqpvalue_get_list_item(list_value, 7);
09176                 if (item_value == NULL)
09177                 {
09178                     /* do nothing */
09179                 }
09180                 else
09181                 {
09182                     filter_set filter;
09183                     if (amqpvalue_get_filter_set(item_value, &filter) != 0)
09184                     {
09185                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
09186                         {
09187                             source_destroy(*source_handle);
09188                             result = __LINE__;
09189                             break;
09190                         }
09191                     }
09192 
09193                     amqpvalue_destroy(item_value);
09194                 }
09195                 /* default-outcome */
09196                 item_value = amqpvalue_get_list_item(list_value, 8);
09197                 if (item_value == NULL)
09198                 {
09199                     /* do nothing */
09200                 }
09201                 else
09202                 {
09203                     amqpvalue_destroy(item_value);
09204                 }
09205                 /* outcomes */
09206                 item_value = amqpvalue_get_list_item(list_value, 9);
09207                 if (item_value == NULL)
09208                 {
09209                     /* do nothing */
09210                 }
09211                 else
09212                 {
09213                     const char* outcomes;
09214                     AMQP_VALUE outcomes_array;
09215                     if ((amqpvalue_get_array(item_value, &outcomes_array) != 0) &&
09216                         (amqpvalue_get_symbol(item_value, &outcomes) != 0))
09217                     {
09218                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
09219                         {
09220                             source_destroy(*source_handle);
09221                             result = __LINE__;
09222                             break;
09223                         }
09224                     }
09225 
09226                     amqpvalue_destroy(item_value);
09227                 }
09228                 /* capabilities */
09229                 item_value = amqpvalue_get_list_item(list_value, 10);
09230                 if (item_value == NULL)
09231                 {
09232                     /* do nothing */
09233                 }
09234                 else
09235                 {
09236                     const char* capabilities;
09237                     AMQP_VALUE capabilities_array;
09238                     if ((amqpvalue_get_array(item_value, &capabilities_array) != 0) &&
09239                         (amqpvalue_get_symbol(item_value, &capabilities) != 0))
09240                     {
09241                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
09242                         {
09243                             source_destroy(*source_handle);
09244                             result = __LINE__;
09245                             break;
09246                         }
09247                     }
09248 
09249                     amqpvalue_destroy(item_value);
09250                 }
09251 
09252                 source_instance->composite_value = amqpvalue_clone(value);
09253 
09254                 result = 0;
09255             } while (0);
09256         }
09257     }
09258 
09259     return result;
09260 }
09261 
09262 int source_get_address(SOURCE_HANDLE source, AMQP_VALUE* address_value)
09263 {
09264     int result;
09265 
09266     if (source == NULL)
09267     {
09268         result = __LINE__;
09269     }
09270     else
09271     {
09272         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09273         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(source_instance->composite_value, 0);
09274         if (item_value == NULL)
09275         {
09276             result = __LINE__;
09277         }
09278         else
09279         {
09280             *address_value = item_value;
09281             result = 0;
09282         }
09283     }
09284 
09285     return result;
09286 }
09287 
09288 int source_set_address(SOURCE_HANDLE source, AMQP_VALUE address_value)
09289 {
09290     int result;
09291 
09292     if (source == NULL)
09293     {
09294         result = __LINE__;
09295     }
09296     else
09297     {
09298         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09299         AMQP_VALUE address_amqp_value = amqpvalue_clone(address_value);
09300         if (address_amqp_value == NULL)
09301         {
09302             result = __LINE__;
09303         }
09304         else
09305         {
09306             if (amqpvalue_set_composite_item(source_instance->composite_value, 0, address_amqp_value) != 0)
09307             {
09308                 result = __LINE__;
09309             }
09310             else
09311             {
09312                 result = 0;
09313             }
09314 
09315             amqpvalue_destroy(address_amqp_value);
09316         }
09317     }
09318 
09319     return result;
09320 }
09321 
09322 int source_get_durable(SOURCE_HANDLE source, terminus_durability* durable_value)
09323 {
09324     int result;
09325 
09326     if (source == NULL)
09327     {
09328         result = __LINE__;
09329     }
09330     else
09331     {
09332         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09333         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(source_instance->composite_value, 1);
09334         if (item_value == NULL)
09335         {
09336             result = __LINE__;
09337         }
09338         else
09339         {
09340             if (amqpvalue_get_terminus_durability(item_value, durable_value) != 0)
09341             {
09342                 result = __LINE__;
09343             }
09344             else
09345             {
09346                 result = 0;
09347             }
09348         }
09349     }
09350 
09351     return result;
09352 }
09353 
09354 int source_set_durable(SOURCE_HANDLE source, terminus_durability durable_value)
09355 {
09356     int result;
09357 
09358     if (source == NULL)
09359     {
09360         result = __LINE__;
09361     }
09362     else
09363     {
09364         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09365         AMQP_VALUE durable_amqp_value = amqpvalue_create_terminus_durability(durable_value);
09366         if (durable_amqp_value == NULL)
09367         {
09368             result = __LINE__;
09369         }
09370         else
09371         {
09372             if (amqpvalue_set_composite_item(source_instance->composite_value, 1, durable_amqp_value) != 0)
09373             {
09374                 result = __LINE__;
09375             }
09376             else
09377             {
09378                 result = 0;
09379             }
09380 
09381             amqpvalue_destroy(durable_amqp_value);
09382         }
09383     }
09384 
09385     return result;
09386 }
09387 
09388 int source_get_expiry_policy(SOURCE_HANDLE source, terminus_expiry_policy* expiry_policy_value)
09389 {
09390     int result;
09391 
09392     if (source == NULL)
09393     {
09394         result = __LINE__;
09395     }
09396     else
09397     {
09398         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09399         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(source_instance->composite_value, 2);
09400         if (item_value == NULL)
09401         {
09402             result = __LINE__;
09403         }
09404         else
09405         {
09406             if (amqpvalue_get_terminus_expiry_policy(item_value, expiry_policy_value) != 0)
09407             {
09408                 result = __LINE__;
09409             }
09410             else
09411             {
09412                 result = 0;
09413             }
09414         }
09415     }
09416 
09417     return result;
09418 }
09419 
09420 int source_set_expiry_policy(SOURCE_HANDLE source, terminus_expiry_policy expiry_policy_value)
09421 {
09422     int result;
09423 
09424     if (source == NULL)
09425     {
09426         result = __LINE__;
09427     }
09428     else
09429     {
09430         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09431         AMQP_VALUE expiry_policy_amqp_value = amqpvalue_create_terminus_expiry_policy(expiry_policy_value);
09432         if (expiry_policy_amqp_value == NULL)
09433         {
09434             result = __LINE__;
09435         }
09436         else
09437         {
09438             if (amqpvalue_set_composite_item(source_instance->composite_value, 2, expiry_policy_amqp_value) != 0)
09439             {
09440                 result = __LINE__;
09441             }
09442             else
09443             {
09444                 result = 0;
09445             }
09446 
09447             amqpvalue_destroy(expiry_policy_amqp_value);
09448         }
09449     }
09450 
09451     return result;
09452 }
09453 
09454 int source_get_timeout(SOURCE_HANDLE source, seconds* timeout_value)
09455 {
09456     int result;
09457 
09458     if (source == NULL)
09459     {
09460         result = __LINE__;
09461     }
09462     else
09463     {
09464         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09465         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(source_instance->composite_value, 3);
09466         if (item_value == NULL)
09467         {
09468             result = __LINE__;
09469         }
09470         else
09471         {
09472             if (amqpvalue_get_seconds(item_value, timeout_value) != 0)
09473             {
09474                 result = __LINE__;
09475             }
09476             else
09477             {
09478                 result = 0;
09479             }
09480         }
09481     }
09482 
09483     return result;
09484 }
09485 
09486 int source_set_timeout(SOURCE_HANDLE source, seconds timeout_value)
09487 {
09488     int result;
09489 
09490     if (source == NULL)
09491     {
09492         result = __LINE__;
09493     }
09494     else
09495     {
09496         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09497         AMQP_VALUE timeout_amqp_value = amqpvalue_create_seconds(timeout_value);
09498         if (timeout_amqp_value == NULL)
09499         {
09500             result = __LINE__;
09501         }
09502         else
09503         {
09504             if (amqpvalue_set_composite_item(source_instance->composite_value, 3, timeout_amqp_value) != 0)
09505             {
09506                 result = __LINE__;
09507             }
09508             else
09509             {
09510                 result = 0;
09511             }
09512 
09513             amqpvalue_destroy(timeout_amqp_value);
09514         }
09515     }
09516 
09517     return result;
09518 }
09519 
09520 int source_get_dynamic(SOURCE_HANDLE source, bool* dynamic_value)
09521 {
09522     int result;
09523 
09524     if (source == NULL)
09525     {
09526         result = __LINE__;
09527     }
09528     else
09529     {
09530         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09531         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(source_instance->composite_value, 4);
09532         if (item_value == NULL)
09533         {
09534             result = __LINE__;
09535         }
09536         else
09537         {
09538             if (amqpvalue_get_boolean(item_value, dynamic_value) != 0)
09539             {
09540                 result = __LINE__;
09541             }
09542             else
09543             {
09544                 result = 0;
09545             }
09546         }
09547     }
09548 
09549     return result;
09550 }
09551 
09552 int source_set_dynamic(SOURCE_HANDLE source, bool dynamic_value)
09553 {
09554     int result;
09555 
09556     if (source == NULL)
09557     {
09558         result = __LINE__;
09559     }
09560     else
09561     {
09562         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09563         AMQP_VALUE dynamic_amqp_value = amqpvalue_create_boolean(dynamic_value);
09564         if (dynamic_amqp_value == NULL)
09565         {
09566             result = __LINE__;
09567         }
09568         else
09569         {
09570             if (amqpvalue_set_composite_item(source_instance->composite_value, 4, dynamic_amqp_value) != 0)
09571             {
09572                 result = __LINE__;
09573             }
09574             else
09575             {
09576                 result = 0;
09577             }
09578 
09579             amqpvalue_destroy(dynamic_amqp_value);
09580         }
09581     }
09582 
09583     return result;
09584 }
09585 
09586 int source_get_dynamic_node_properties(SOURCE_HANDLE source, node_properties* dynamic_node_properties_value)
09587 {
09588     int result;
09589 
09590     if (source == NULL)
09591     {
09592         result = __LINE__;
09593     }
09594     else
09595     {
09596         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09597         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(source_instance->composite_value, 5);
09598         if (item_value == NULL)
09599         {
09600             result = __LINE__;
09601         }
09602         else
09603         {
09604             if (amqpvalue_get_node_properties(item_value, dynamic_node_properties_value) != 0)
09605             {
09606                 result = __LINE__;
09607             }
09608             else
09609             {
09610                 result = 0;
09611             }
09612         }
09613     }
09614 
09615     return result;
09616 }
09617 
09618 int source_set_dynamic_node_properties(SOURCE_HANDLE source, node_properties dynamic_node_properties_value)
09619 {
09620     int result;
09621 
09622     if (source == NULL)
09623     {
09624         result = __LINE__;
09625     }
09626     else
09627     {
09628         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09629         AMQP_VALUE dynamic_node_properties_amqp_value = amqpvalue_create_node_properties(dynamic_node_properties_value);
09630         if (dynamic_node_properties_amqp_value == NULL)
09631         {
09632             result = __LINE__;
09633         }
09634         else
09635         {
09636             if (amqpvalue_set_composite_item(source_instance->composite_value, 5, dynamic_node_properties_amqp_value) != 0)
09637             {
09638                 result = __LINE__;
09639             }
09640             else
09641             {
09642                 result = 0;
09643             }
09644 
09645             amqpvalue_destroy(dynamic_node_properties_amqp_value);
09646         }
09647     }
09648 
09649     return result;
09650 }
09651 
09652 int source_get_distribution_mode(SOURCE_HANDLE source, const char** distribution_mode_value)
09653 {
09654     int result;
09655 
09656     if (source == NULL)
09657     {
09658         result = __LINE__;
09659     }
09660     else
09661     {
09662         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09663         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(source_instance->composite_value, 6);
09664         if (item_value == NULL)
09665         {
09666             result = __LINE__;
09667         }
09668         else
09669         {
09670             if (amqpvalue_get_symbol(item_value, distribution_mode_value) != 0)
09671             {
09672                 result = __LINE__;
09673             }
09674             else
09675             {
09676                 result = 0;
09677             }
09678         }
09679     }
09680 
09681     return result;
09682 }
09683 
09684 int source_set_distribution_mode(SOURCE_HANDLE source, const char* distribution_mode_value)
09685 {
09686     int result;
09687 
09688     if (source == NULL)
09689     {
09690         result = __LINE__;
09691     }
09692     else
09693     {
09694         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09695         AMQP_VALUE distribution_mode_amqp_value = amqpvalue_create_symbol(distribution_mode_value);
09696         if (distribution_mode_amqp_value == NULL)
09697         {
09698             result = __LINE__;
09699         }
09700         else
09701         {
09702             if (amqpvalue_set_composite_item(source_instance->composite_value, 6, distribution_mode_amqp_value) != 0)
09703             {
09704                 result = __LINE__;
09705             }
09706             else
09707             {
09708                 result = 0;
09709             }
09710 
09711             amqpvalue_destroy(distribution_mode_amqp_value);
09712         }
09713     }
09714 
09715     return result;
09716 }
09717 
09718 int source_get_filter(SOURCE_HANDLE source, filter_set* filter_value)
09719 {
09720     int result;
09721 
09722     if (source == NULL)
09723     {
09724         result = __LINE__;
09725     }
09726     else
09727     {
09728         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09729         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(source_instance->composite_value, 7);
09730         if (item_value == NULL)
09731         {
09732             result = __LINE__;
09733         }
09734         else
09735         {
09736             if (amqpvalue_get_filter_set(item_value, filter_value) != 0)
09737             {
09738                 result = __LINE__;
09739             }
09740             else
09741             {
09742                 result = 0;
09743             }
09744         }
09745     }
09746 
09747     return result;
09748 }
09749 
09750 int source_set_filter(SOURCE_HANDLE source, filter_set filter_value)
09751 {
09752     int result;
09753 
09754     if (source == NULL)
09755     {
09756         result = __LINE__;
09757     }
09758     else
09759     {
09760         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09761         AMQP_VALUE filter_amqp_value = amqpvalue_create_filter_set(filter_value);
09762         if (filter_amqp_value == NULL)
09763         {
09764             result = __LINE__;
09765         }
09766         else
09767         {
09768             if (amqpvalue_set_composite_item(source_instance->composite_value, 7, filter_amqp_value) != 0)
09769             {
09770                 result = __LINE__;
09771             }
09772             else
09773             {
09774                 result = 0;
09775             }
09776 
09777             amqpvalue_destroy(filter_amqp_value);
09778         }
09779     }
09780 
09781     return result;
09782 }
09783 
09784 int source_get_default_outcome(SOURCE_HANDLE source, AMQP_VALUE* default_outcome_value)
09785 {
09786     int result;
09787 
09788     if (source == NULL)
09789     {
09790         result = __LINE__;
09791     }
09792     else
09793     {
09794         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09795         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(source_instance->composite_value, 8);
09796         if (item_value == NULL)
09797         {
09798             result = __LINE__;
09799         }
09800         else
09801         {
09802             *default_outcome_value = item_value;
09803             result = 0;
09804         }
09805     }
09806 
09807     return result;
09808 }
09809 
09810 int source_set_default_outcome(SOURCE_HANDLE source, AMQP_VALUE default_outcome_value)
09811 {
09812     int result;
09813 
09814     if (source == NULL)
09815     {
09816         result = __LINE__;
09817     }
09818     else
09819     {
09820         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09821         AMQP_VALUE default_outcome_amqp_value = amqpvalue_clone(default_outcome_value);
09822         if (default_outcome_amqp_value == NULL)
09823         {
09824             result = __LINE__;
09825         }
09826         else
09827         {
09828             if (amqpvalue_set_composite_item(source_instance->composite_value, 8, default_outcome_amqp_value) != 0)
09829             {
09830                 result = __LINE__;
09831             }
09832             else
09833             {
09834                 result = 0;
09835             }
09836 
09837             amqpvalue_destroy(default_outcome_amqp_value);
09838         }
09839     }
09840 
09841     return result;
09842 }
09843 
09844 int source_get_outcomes(SOURCE_HANDLE source, AMQP_VALUE* outcomes_value)
09845 {
09846     int result;
09847 
09848     if (source == NULL)
09849     {
09850         result = __LINE__;
09851     }
09852     else
09853     {
09854         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09855         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(source_instance->composite_value, 9);
09856         if (item_value == NULL)
09857         {
09858             result = __LINE__;
09859         }
09860         else
09861         {
09862             if (amqpvalue_get_array(item_value, outcomes_value) != 0)
09863             {
09864                 result = __LINE__;
09865             }
09866             else
09867             {
09868                 result = 0;
09869             }
09870         }
09871     }
09872 
09873     return result;
09874 }
09875 
09876 int source_set_outcomes(SOURCE_HANDLE source, AMQP_VALUE outcomes_value)
09877 {
09878     int result;
09879 
09880     if (source == NULL)
09881     {
09882         result = __LINE__;
09883     }
09884     else
09885     {
09886         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09887         AMQP_VALUE outcomes_amqp_value = amqpvalue_clone(outcomes_value);
09888         if (outcomes_amqp_value == NULL)
09889         {
09890             result = __LINE__;
09891         }
09892         else
09893         {
09894             if (amqpvalue_set_composite_item(source_instance->composite_value, 9, outcomes_amqp_value) != 0)
09895             {
09896                 result = __LINE__;
09897             }
09898             else
09899             {
09900                 result = 0;
09901             }
09902 
09903             amqpvalue_destroy(outcomes_amqp_value);
09904         }
09905     }
09906 
09907     return result;
09908 }
09909 
09910 int source_get_capabilities(SOURCE_HANDLE source, AMQP_VALUE* capabilities_value)
09911 {
09912     int result;
09913 
09914     if (source == NULL)
09915     {
09916         result = __LINE__;
09917     }
09918     else
09919     {
09920         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09921         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(source_instance->composite_value, 10);
09922         if (item_value == NULL)
09923         {
09924             result = __LINE__;
09925         }
09926         else
09927         {
09928             if (amqpvalue_get_array(item_value, capabilities_value) != 0)
09929             {
09930                 result = __LINE__;
09931             }
09932             else
09933             {
09934                 result = 0;
09935             }
09936         }
09937     }
09938 
09939     return result;
09940 }
09941 
09942 int source_set_capabilities(SOURCE_HANDLE source, AMQP_VALUE capabilities_value)
09943 {
09944     int result;
09945 
09946     if (source == NULL)
09947     {
09948         result = __LINE__;
09949     }
09950     else
09951     {
09952         SOURCE_INSTANCE* source_instance = (SOURCE_INSTANCE*)source;
09953         AMQP_VALUE capabilities_amqp_value = amqpvalue_clone(capabilities_value);
09954         if (capabilities_amqp_value == NULL)
09955         {
09956             result = __LINE__;
09957         }
09958         else
09959         {
09960             if (amqpvalue_set_composite_item(source_instance->composite_value, 10, capabilities_amqp_value) != 0)
09961             {
09962                 result = __LINE__;
09963             }
09964             else
09965             {
09966                 result = 0;
09967             }
09968 
09969             amqpvalue_destroy(capabilities_amqp_value);
09970         }
09971     }
09972 
09973     return result;
09974 }
09975 
09976 
09977 /* target */
09978 
09979 typedef struct TARGET_INSTANCE_TAG
09980 {
09981     AMQP_VALUE composite_value;
09982 } TARGET_INSTANCE;
09983 
09984 static TARGET_HANDLE target_create_internal(void)
09985 {
09986     TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)amqpalloc_malloc(sizeof(TARGET_INSTANCE));
09987     if (target_instance != NULL)
09988     {
09989         target_instance->composite_value = NULL;
09990     }
09991 
09992     return target_instance;
09993 }
09994 
09995 TARGET_HANDLE target_create(void)
09996 {
09997     TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)amqpalloc_malloc(sizeof(TARGET_INSTANCE));
09998     if (target_instance != NULL)
09999     {
10000         target_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(41);
10001         if (target_instance->composite_value == NULL)
10002         {
10003             amqpalloc_free(target_instance);
10004             target_instance = NULL;
10005         }
10006     }
10007 
10008     return target_instance;
10009 }
10010 
10011 TARGET_HANDLE target_clone(TARGET_HANDLE value)
10012 {
10013     TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)amqpalloc_malloc(sizeof(TARGET_INSTANCE));
10014     if (target_instance != NULL)
10015     {
10016         target_instance->composite_value = amqpvalue_clone(((TARGET_INSTANCE*)value)->composite_value);
10017         if (target_instance->composite_value == NULL)
10018         {
10019             amqpalloc_free(target_instance);
10020             target_instance = NULL;
10021         }
10022     }
10023 
10024     return target_instance;
10025 }
10026 
10027 void target_destroy(TARGET_HANDLE target)
10028 {
10029     if (target != NULL)
10030     {
10031         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10032         amqpvalue_destroy(target_instance->composite_value);
10033         amqpalloc_free(target_instance);
10034     }
10035 }
10036 
10037 AMQP_VALUE amqpvalue_create_target(TARGET_HANDLE target)
10038 {
10039     AMQP_VALUE result;
10040 
10041     if (target == NULL)
10042     {
10043         result = NULL;
10044     }
10045     else
10046     {
10047         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10048         result = amqpvalue_clone(target_instance->composite_value);
10049     }
10050 
10051     return result;
10052 }
10053 
10054 bool is_target_type_by_descriptor(AMQP_VALUE descriptor)
10055 {
10056     bool result;
10057 
10058     uint64_t descriptor_ulong;
10059     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
10060         (descriptor_ulong == 41))
10061     {
10062         result = true;
10063     }
10064     else
10065     {
10066         result = false;
10067     }
10068 
10069     return result;
10070 }
10071 
10072 
10073 int amqpvalue_get_target(AMQP_VALUE value, TARGET_HANDLE* target_handle)
10074 {
10075     int result;
10076     TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target_create_internal();
10077     *target_handle = target_instance;
10078     if (*target_handle == NULL)
10079     {
10080         result = __LINE__;
10081     }
10082     else
10083     {
10084         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
10085         if (list_value == NULL)
10086         {
10087             target_destroy(*target_handle);
10088             result = __LINE__;
10089         }
10090         else
10091         {
10092             do
10093             {
10094                 AMQP_VALUE item_value;
10095                 /* address */
10096                 item_value = amqpvalue_get_list_item(list_value, 0);
10097                 if (item_value == NULL)
10098                 {
10099                     /* do nothing */
10100                 }
10101                 else
10102                 {
10103                     amqpvalue_destroy(item_value);
10104                 }
10105                 /* durable */
10106                 item_value = amqpvalue_get_list_item(list_value, 1);
10107                 if (item_value == NULL)
10108                 {
10109                     /* do nothing */
10110                 }
10111                 else
10112                 {
10113                     terminus_durability durable;
10114                     if (amqpvalue_get_terminus_durability(item_value, &durable) != 0)
10115                     {
10116                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
10117                         {
10118                             target_destroy(*target_handle);
10119                             result = __LINE__;
10120                             break;
10121                         }
10122                     }
10123 
10124                     amqpvalue_destroy(item_value);
10125                 }
10126                 /* expiry-policy */
10127                 item_value = amqpvalue_get_list_item(list_value, 2);
10128                 if (item_value == NULL)
10129                 {
10130                     /* do nothing */
10131                 }
10132                 else
10133                 {
10134                     terminus_expiry_policy expiry_policy;
10135                     if (amqpvalue_get_terminus_expiry_policy(item_value, &expiry_policy) != 0)
10136                     {
10137                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
10138                         {
10139                             target_destroy(*target_handle);
10140                             result = __LINE__;
10141                             break;
10142                         }
10143                     }
10144 
10145                     amqpvalue_destroy(item_value);
10146                 }
10147                 /* timeout */
10148                 item_value = amqpvalue_get_list_item(list_value, 3);
10149                 if (item_value == NULL)
10150                 {
10151                     /* do nothing */
10152                 }
10153                 else
10154                 {
10155                     seconds timeout;
10156                     if (amqpvalue_get_seconds(item_value, &timeout) != 0)
10157                     {
10158                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
10159                         {
10160                             target_destroy(*target_handle);
10161                             result = __LINE__;
10162                             break;
10163                         }
10164                     }
10165 
10166                     amqpvalue_destroy(item_value);
10167                 }
10168                 /* dynamic */
10169                 item_value = amqpvalue_get_list_item(list_value, 4);
10170                 if (item_value == NULL)
10171                 {
10172                     /* do nothing */
10173                 }
10174                 else
10175                 {
10176                     bool dynamic;
10177                     if (amqpvalue_get_boolean(item_value, &dynamic) != 0)
10178                     {
10179                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
10180                         {
10181                             target_destroy(*target_handle);
10182                             result = __LINE__;
10183                             break;
10184                         }
10185                     }
10186 
10187                     amqpvalue_destroy(item_value);
10188                 }
10189                 /* dynamic-node-properties */
10190                 item_value = amqpvalue_get_list_item(list_value, 5);
10191                 if (item_value == NULL)
10192                 {
10193                     /* do nothing */
10194                 }
10195                 else
10196                 {
10197                     node_properties dynamic_node_properties;
10198                     if (amqpvalue_get_node_properties(item_value, &dynamic_node_properties) != 0)
10199                     {
10200                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
10201                         {
10202                             target_destroy(*target_handle);
10203                             result = __LINE__;
10204                             break;
10205                         }
10206                     }
10207 
10208                     amqpvalue_destroy(item_value);
10209                 }
10210                 /* capabilities */
10211                 item_value = amqpvalue_get_list_item(list_value, 6);
10212                 if (item_value == NULL)
10213                 {
10214                     /* do nothing */
10215                 }
10216                 else
10217                 {
10218                     const char* capabilities;
10219                     AMQP_VALUE capabilities_array;
10220                     if ((amqpvalue_get_array(item_value, &capabilities_array) != 0) &&
10221                         (amqpvalue_get_symbol(item_value, &capabilities) != 0))
10222                     {
10223                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
10224                         {
10225                             target_destroy(*target_handle);
10226                             result = __LINE__;
10227                             break;
10228                         }
10229                     }
10230 
10231                     amqpvalue_destroy(item_value);
10232                 }
10233 
10234                 target_instance->composite_value = amqpvalue_clone(value);
10235 
10236                 result = 0;
10237             } while (0);
10238         }
10239     }
10240 
10241     return result;
10242 }
10243 
10244 int target_get_address(TARGET_HANDLE target, AMQP_VALUE* address_value)
10245 {
10246     int result;
10247 
10248     if (target == NULL)
10249     {
10250         result = __LINE__;
10251     }
10252     else
10253     {
10254         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10255         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(target_instance->composite_value, 0);
10256         if (item_value == NULL)
10257         {
10258             result = __LINE__;
10259         }
10260         else
10261         {
10262             *address_value = item_value;
10263             result = 0;
10264         }
10265     }
10266 
10267     return result;
10268 }
10269 
10270 int target_set_address(TARGET_HANDLE target, AMQP_VALUE address_value)
10271 {
10272     int result;
10273 
10274     if (target == NULL)
10275     {
10276         result = __LINE__;
10277     }
10278     else
10279     {
10280         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10281         AMQP_VALUE address_amqp_value = amqpvalue_clone(address_value);
10282         if (address_amqp_value == NULL)
10283         {
10284             result = __LINE__;
10285         }
10286         else
10287         {
10288             if (amqpvalue_set_composite_item(target_instance->composite_value, 0, address_amqp_value) != 0)
10289             {
10290                 result = __LINE__;
10291             }
10292             else
10293             {
10294                 result = 0;
10295             }
10296 
10297             amqpvalue_destroy(address_amqp_value);
10298         }
10299     }
10300 
10301     return result;
10302 }
10303 
10304 int target_get_durable(TARGET_HANDLE target, terminus_durability* durable_value)
10305 {
10306     int result;
10307 
10308     if (target == NULL)
10309     {
10310         result = __LINE__;
10311     }
10312     else
10313     {
10314         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10315         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(target_instance->composite_value, 1);
10316         if (item_value == NULL)
10317         {
10318             result = __LINE__;
10319         }
10320         else
10321         {
10322             if (amqpvalue_get_terminus_durability(item_value, durable_value) != 0)
10323             {
10324                 result = __LINE__;
10325             }
10326             else
10327             {
10328                 result = 0;
10329             }
10330         }
10331     }
10332 
10333     return result;
10334 }
10335 
10336 int target_set_durable(TARGET_HANDLE target, terminus_durability durable_value)
10337 {
10338     int result;
10339 
10340     if (target == NULL)
10341     {
10342         result = __LINE__;
10343     }
10344     else
10345     {
10346         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10347         AMQP_VALUE durable_amqp_value = amqpvalue_create_terminus_durability(durable_value);
10348         if (durable_amqp_value == NULL)
10349         {
10350             result = __LINE__;
10351         }
10352         else
10353         {
10354             if (amqpvalue_set_composite_item(target_instance->composite_value, 1, durable_amqp_value) != 0)
10355             {
10356                 result = __LINE__;
10357             }
10358             else
10359             {
10360                 result = 0;
10361             }
10362 
10363             amqpvalue_destroy(durable_amqp_value);
10364         }
10365     }
10366 
10367     return result;
10368 }
10369 
10370 int target_get_expiry_policy(TARGET_HANDLE target, terminus_expiry_policy* expiry_policy_value)
10371 {
10372     int result;
10373 
10374     if (target == NULL)
10375     {
10376         result = __LINE__;
10377     }
10378     else
10379     {
10380         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10381         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(target_instance->composite_value, 2);
10382         if (item_value == NULL)
10383         {
10384             result = __LINE__;
10385         }
10386         else
10387         {
10388             if (amqpvalue_get_terminus_expiry_policy(item_value, expiry_policy_value) != 0)
10389             {
10390                 result = __LINE__;
10391             }
10392             else
10393             {
10394                 result = 0;
10395             }
10396         }
10397     }
10398 
10399     return result;
10400 }
10401 
10402 int target_set_expiry_policy(TARGET_HANDLE target, terminus_expiry_policy expiry_policy_value)
10403 {
10404     int result;
10405 
10406     if (target == NULL)
10407     {
10408         result = __LINE__;
10409     }
10410     else
10411     {
10412         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10413         AMQP_VALUE expiry_policy_amqp_value = amqpvalue_create_terminus_expiry_policy(expiry_policy_value);
10414         if (expiry_policy_amqp_value == NULL)
10415         {
10416             result = __LINE__;
10417         }
10418         else
10419         {
10420             if (amqpvalue_set_composite_item(target_instance->composite_value, 2, expiry_policy_amqp_value) != 0)
10421             {
10422                 result = __LINE__;
10423             }
10424             else
10425             {
10426                 result = 0;
10427             }
10428 
10429             amqpvalue_destroy(expiry_policy_amqp_value);
10430         }
10431     }
10432 
10433     return result;
10434 }
10435 
10436 int target_get_timeout(TARGET_HANDLE target, seconds* timeout_value)
10437 {
10438     int result;
10439 
10440     if (target == NULL)
10441     {
10442         result = __LINE__;
10443     }
10444     else
10445     {
10446         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10447         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(target_instance->composite_value, 3);
10448         if (item_value == NULL)
10449         {
10450             result = __LINE__;
10451         }
10452         else
10453         {
10454             if (amqpvalue_get_seconds(item_value, timeout_value) != 0)
10455             {
10456                 result = __LINE__;
10457             }
10458             else
10459             {
10460                 result = 0;
10461             }
10462         }
10463     }
10464 
10465     return result;
10466 }
10467 
10468 int target_set_timeout(TARGET_HANDLE target, seconds timeout_value)
10469 {
10470     int result;
10471 
10472     if (target == NULL)
10473     {
10474         result = __LINE__;
10475     }
10476     else
10477     {
10478         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10479         AMQP_VALUE timeout_amqp_value = amqpvalue_create_seconds(timeout_value);
10480         if (timeout_amqp_value == NULL)
10481         {
10482             result = __LINE__;
10483         }
10484         else
10485         {
10486             if (amqpvalue_set_composite_item(target_instance->composite_value, 3, timeout_amqp_value) != 0)
10487             {
10488                 result = __LINE__;
10489             }
10490             else
10491             {
10492                 result = 0;
10493             }
10494 
10495             amqpvalue_destroy(timeout_amqp_value);
10496         }
10497     }
10498 
10499     return result;
10500 }
10501 
10502 int target_get_dynamic(TARGET_HANDLE target, bool* dynamic_value)
10503 {
10504     int result;
10505 
10506     if (target == NULL)
10507     {
10508         result = __LINE__;
10509     }
10510     else
10511     {
10512         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10513         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(target_instance->composite_value, 4);
10514         if (item_value == NULL)
10515         {
10516             result = __LINE__;
10517         }
10518         else
10519         {
10520             if (amqpvalue_get_boolean(item_value, dynamic_value) != 0)
10521             {
10522                 result = __LINE__;
10523             }
10524             else
10525             {
10526                 result = 0;
10527             }
10528         }
10529     }
10530 
10531     return result;
10532 }
10533 
10534 int target_set_dynamic(TARGET_HANDLE target, bool dynamic_value)
10535 {
10536     int result;
10537 
10538     if (target == NULL)
10539     {
10540         result = __LINE__;
10541     }
10542     else
10543     {
10544         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10545         AMQP_VALUE dynamic_amqp_value = amqpvalue_create_boolean(dynamic_value);
10546         if (dynamic_amqp_value == NULL)
10547         {
10548             result = __LINE__;
10549         }
10550         else
10551         {
10552             if (amqpvalue_set_composite_item(target_instance->composite_value, 4, dynamic_amqp_value) != 0)
10553             {
10554                 result = __LINE__;
10555             }
10556             else
10557             {
10558                 result = 0;
10559             }
10560 
10561             amqpvalue_destroy(dynamic_amqp_value);
10562         }
10563     }
10564 
10565     return result;
10566 }
10567 
10568 int target_get_dynamic_node_properties(TARGET_HANDLE target, node_properties* dynamic_node_properties_value)
10569 {
10570     int result;
10571 
10572     if (target == NULL)
10573     {
10574         result = __LINE__;
10575     }
10576     else
10577     {
10578         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10579         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(target_instance->composite_value, 5);
10580         if (item_value == NULL)
10581         {
10582             result = __LINE__;
10583         }
10584         else
10585         {
10586             if (amqpvalue_get_node_properties(item_value, dynamic_node_properties_value) != 0)
10587             {
10588                 result = __LINE__;
10589             }
10590             else
10591             {
10592                 result = 0;
10593             }
10594         }
10595     }
10596 
10597     return result;
10598 }
10599 
10600 int target_set_dynamic_node_properties(TARGET_HANDLE target, node_properties dynamic_node_properties_value)
10601 {
10602     int result;
10603 
10604     if (target == NULL)
10605     {
10606         result = __LINE__;
10607     }
10608     else
10609     {
10610         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10611         AMQP_VALUE dynamic_node_properties_amqp_value = amqpvalue_create_node_properties(dynamic_node_properties_value);
10612         if (dynamic_node_properties_amqp_value == NULL)
10613         {
10614             result = __LINE__;
10615         }
10616         else
10617         {
10618             if (amqpvalue_set_composite_item(target_instance->composite_value, 5, dynamic_node_properties_amqp_value) != 0)
10619             {
10620                 result = __LINE__;
10621             }
10622             else
10623             {
10624                 result = 0;
10625             }
10626 
10627             amqpvalue_destroy(dynamic_node_properties_amqp_value);
10628         }
10629     }
10630 
10631     return result;
10632 }
10633 
10634 int target_get_capabilities(TARGET_HANDLE target, AMQP_VALUE* capabilities_value)
10635 {
10636     int result;
10637 
10638     if (target == NULL)
10639     {
10640         result = __LINE__;
10641     }
10642     else
10643     {
10644         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10645         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(target_instance->composite_value, 6);
10646         if (item_value == NULL)
10647         {
10648             result = __LINE__;
10649         }
10650         else
10651         {
10652             if (amqpvalue_get_array(item_value, capabilities_value) != 0)
10653             {
10654                 result = __LINE__;
10655             }
10656             else
10657             {
10658                 result = 0;
10659             }
10660         }
10661     }
10662 
10663     return result;
10664 }
10665 
10666 int target_set_capabilities(TARGET_HANDLE target, AMQP_VALUE capabilities_value)
10667 {
10668     int result;
10669 
10670     if (target == NULL)
10671     {
10672         result = __LINE__;
10673     }
10674     else
10675     {
10676         TARGET_INSTANCE* target_instance = (TARGET_INSTANCE*)target;
10677         AMQP_VALUE capabilities_amqp_value = amqpvalue_clone(capabilities_value);
10678         if (capabilities_amqp_value == NULL)
10679         {
10680             result = __LINE__;
10681         }
10682         else
10683         {
10684             if (amqpvalue_set_composite_item(target_instance->composite_value, 6, capabilities_amqp_value) != 0)
10685             {
10686                 result = __LINE__;
10687             }
10688             else
10689             {
10690                 result = 0;
10691             }
10692 
10693             amqpvalue_destroy(capabilities_amqp_value);
10694         }
10695     }
10696 
10697     return result;
10698 }
10699 
10700 
10701 /* annotations */
10702 
10703 AMQP_VALUE amqpvalue_create_annotations(AMQP_VALUE value)
10704 {
10705     return amqpvalue_clone(value);
10706 }
10707 
10708 /* message-id-ulong */
10709 
10710 AMQP_VALUE amqpvalue_create_message_id_ulong(message_id_ulong value)
10711 {
10712     return amqpvalue_create_ulong(value);
10713 }
10714 
10715 /* message-id-uuid */
10716 
10717 AMQP_VALUE amqpvalue_create_message_id_uuid(message_id_uuid value)
10718 {
10719     return amqpvalue_create_uuid(value);
10720 }
10721 
10722 /* message-id-binary */
10723 
10724 AMQP_VALUE amqpvalue_create_message_id_binary(message_id_binary value)
10725 {
10726     return amqpvalue_create_binary(value);
10727 }
10728 
10729 /* message-id-string */
10730 
10731 AMQP_VALUE amqpvalue_create_message_id_string(message_id_string value)
10732 {
10733     return amqpvalue_create_string(value);
10734 }
10735 
10736 /* address-string */
10737 
10738 AMQP_VALUE amqpvalue_create_address_string(address_string value)
10739 {
10740     return amqpvalue_create_string(value);
10741 }
10742 
10743 /* header */
10744 
10745 typedef struct HEADER_INSTANCE_TAG
10746 {
10747     AMQP_VALUE composite_value;
10748 } HEADER_INSTANCE;
10749 
10750 static HEADER_HANDLE header_create_internal(void)
10751 {
10752     HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)amqpalloc_malloc(sizeof(HEADER_INSTANCE));
10753     if (header_instance != NULL)
10754     {
10755         header_instance->composite_value = NULL;
10756     }
10757 
10758     return header_instance;
10759 }
10760 
10761 HEADER_HANDLE header_create(void)
10762 {
10763     HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)amqpalloc_malloc(sizeof(HEADER_INSTANCE));
10764     if (header_instance != NULL)
10765     {
10766         header_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(112);
10767         if (header_instance->composite_value == NULL)
10768         {
10769             amqpalloc_free(header_instance);
10770             header_instance = NULL;
10771         }
10772     }
10773 
10774     return header_instance;
10775 }
10776 
10777 HEADER_HANDLE header_clone(HEADER_HANDLE value)
10778 {
10779     HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)amqpalloc_malloc(sizeof(HEADER_INSTANCE));
10780     if (header_instance != NULL)
10781     {
10782         header_instance->composite_value = amqpvalue_clone(((HEADER_INSTANCE*)value)->composite_value);
10783         if (header_instance->composite_value == NULL)
10784         {
10785             amqpalloc_free(header_instance);
10786             header_instance = NULL;
10787         }
10788     }
10789 
10790     return header_instance;
10791 }
10792 
10793 void header_destroy(HEADER_HANDLE header)
10794 {
10795     if (header != NULL)
10796     {
10797         HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)header;
10798         amqpvalue_destroy(header_instance->composite_value);
10799         amqpalloc_free(header_instance);
10800     }
10801 }
10802 
10803 AMQP_VALUE amqpvalue_create_header(HEADER_HANDLE header)
10804 {
10805     AMQP_VALUE result;
10806 
10807     if (header == NULL)
10808     {
10809         result = NULL;
10810     }
10811     else
10812     {
10813         HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)header;
10814         result = amqpvalue_clone(header_instance->composite_value);
10815     }
10816 
10817     return result;
10818 }
10819 
10820 bool is_header_type_by_descriptor(AMQP_VALUE descriptor)
10821 {
10822     bool result;
10823 
10824     uint64_t descriptor_ulong;
10825     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
10826         (descriptor_ulong == 112))
10827     {
10828         result = true;
10829     }
10830     else
10831     {
10832         result = false;
10833     }
10834 
10835     return result;
10836 }
10837 
10838 
10839 int amqpvalue_get_header(AMQP_VALUE value, HEADER_HANDLE* header_handle)
10840 {
10841     int result;
10842     HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)header_create_internal();
10843     *header_handle = header_instance;
10844     if (*header_handle == NULL)
10845     {
10846         result = __LINE__;
10847     }
10848     else
10849     {
10850         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
10851         if (list_value == NULL)
10852         {
10853             header_destroy(*header_handle);
10854             result = __LINE__;
10855         }
10856         else
10857         {
10858             do
10859             {
10860                 AMQP_VALUE item_value;
10861                 /* durable */
10862                 item_value = amqpvalue_get_list_item(list_value, 0);
10863                 if (item_value == NULL)
10864                 {
10865                     /* do nothing */
10866                 }
10867                 else
10868                 {
10869                     bool durable;
10870                     if (amqpvalue_get_boolean(item_value, &durable) != 0)
10871                     {
10872                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
10873                         {
10874                             header_destroy(*header_handle);
10875                             result = __LINE__;
10876                             break;
10877                         }
10878                     }
10879 
10880                     amqpvalue_destroy(item_value);
10881                 }
10882                 /* priority */
10883                 item_value = amqpvalue_get_list_item(list_value, 1);
10884                 if (item_value == NULL)
10885                 {
10886                     /* do nothing */
10887                 }
10888                 else
10889                 {
10890                     uint8_t priority;
10891                     if (amqpvalue_get_ubyte(item_value, &priority) != 0)
10892                     {
10893                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
10894                         {
10895                             header_destroy(*header_handle);
10896                             result = __LINE__;
10897                             break;
10898                         }
10899                     }
10900 
10901                     amqpvalue_destroy(item_value);
10902                 }
10903                 /* ttl */
10904                 item_value = amqpvalue_get_list_item(list_value, 2);
10905                 if (item_value == NULL)
10906                 {
10907                     /* do nothing */
10908                 }
10909                 else
10910                 {
10911                     milliseconds ttl;
10912                     if (amqpvalue_get_milliseconds(item_value, &ttl) != 0)
10913                     {
10914                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
10915                         {
10916                             header_destroy(*header_handle);
10917                             result = __LINE__;
10918                             break;
10919                         }
10920                     }
10921 
10922                     amqpvalue_destroy(item_value);
10923                 }
10924                 /* first-acquirer */
10925                 item_value = amqpvalue_get_list_item(list_value, 3);
10926                 if (item_value == NULL)
10927                 {
10928                     /* do nothing */
10929                 }
10930                 else
10931                 {
10932                     bool first_acquirer;
10933                     if (amqpvalue_get_boolean(item_value, &first_acquirer) != 0)
10934                     {
10935                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
10936                         {
10937                             header_destroy(*header_handle);
10938                             result = __LINE__;
10939                             break;
10940                         }
10941                     }
10942 
10943                     amqpvalue_destroy(item_value);
10944                 }
10945                 /* delivery-count */
10946                 item_value = amqpvalue_get_list_item(list_value, 4);
10947                 if (item_value == NULL)
10948                 {
10949                     /* do nothing */
10950                 }
10951                 else
10952                 {
10953                     uint32_t delivery_count;
10954                     if (amqpvalue_get_uint(item_value, &delivery_count) != 0)
10955                     {
10956                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
10957                         {
10958                             header_destroy(*header_handle);
10959                             result = __LINE__;
10960                             break;
10961                         }
10962                     }
10963 
10964                     amqpvalue_destroy(item_value);
10965                 }
10966 
10967                 header_instance->composite_value = amqpvalue_clone(value);
10968 
10969                 result = 0;
10970             } while (0);
10971         }
10972     }
10973 
10974     return result;
10975 }
10976 
10977 int header_get_durable(HEADER_HANDLE header, bool* durable_value)
10978 {
10979     int result;
10980 
10981     if (header == NULL)
10982     {
10983         result = __LINE__;
10984     }
10985     else
10986     {
10987         HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)header;
10988         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(header_instance->composite_value, 0);
10989         if (item_value == NULL)
10990         {
10991             result = __LINE__;
10992         }
10993         else
10994         {
10995             if (amqpvalue_get_boolean(item_value, durable_value) != 0)
10996             {
10997                 result = __LINE__;
10998             }
10999             else
11000             {
11001                 result = 0;
11002             }
11003         }
11004     }
11005 
11006     return result;
11007 }
11008 
11009 int header_set_durable(HEADER_HANDLE header, bool durable_value)
11010 {
11011     int result;
11012 
11013     if (header == NULL)
11014     {
11015         result = __LINE__;
11016     }
11017     else
11018     {
11019         HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)header;
11020         AMQP_VALUE durable_amqp_value = amqpvalue_create_boolean(durable_value);
11021         if (durable_amqp_value == NULL)
11022         {
11023             result = __LINE__;
11024         }
11025         else
11026         {
11027             if (amqpvalue_set_composite_item(header_instance->composite_value, 0, durable_amqp_value) != 0)
11028             {
11029                 result = __LINE__;
11030             }
11031             else
11032             {
11033                 result = 0;
11034             }
11035 
11036             amqpvalue_destroy(durable_amqp_value);
11037         }
11038     }
11039 
11040     return result;
11041 }
11042 
11043 int header_get_priority(HEADER_HANDLE header, uint8_t* priority_value)
11044 {
11045     int result;
11046 
11047     if (header == NULL)
11048     {
11049         result = __LINE__;
11050     }
11051     else
11052     {
11053         HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)header;
11054         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(header_instance->composite_value, 1);
11055         if (item_value == NULL)
11056         {
11057             result = __LINE__;
11058         }
11059         else
11060         {
11061             if (amqpvalue_get_ubyte(item_value, priority_value) != 0)
11062             {
11063                 result = __LINE__;
11064             }
11065             else
11066             {
11067                 result = 0;
11068             }
11069         }
11070     }
11071 
11072     return result;
11073 }
11074 
11075 int header_set_priority(HEADER_HANDLE header, uint8_t priority_value)
11076 {
11077     int result;
11078 
11079     if (header == NULL)
11080     {
11081         result = __LINE__;
11082     }
11083     else
11084     {
11085         HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)header;
11086         AMQP_VALUE priority_amqp_value = amqpvalue_create_ubyte(priority_value);
11087         if (priority_amqp_value == NULL)
11088         {
11089             result = __LINE__;
11090         }
11091         else
11092         {
11093             if (amqpvalue_set_composite_item(header_instance->composite_value, 1, priority_amqp_value) != 0)
11094             {
11095                 result = __LINE__;
11096             }
11097             else
11098             {
11099                 result = 0;
11100             }
11101 
11102             amqpvalue_destroy(priority_amqp_value);
11103         }
11104     }
11105 
11106     return result;
11107 }
11108 
11109 int header_get_ttl(HEADER_HANDLE header, milliseconds* ttl_value)
11110 {
11111     int result;
11112 
11113     if (header == NULL)
11114     {
11115         result = __LINE__;
11116     }
11117     else
11118     {
11119         HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)header;
11120         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(header_instance->composite_value, 2);
11121         if (item_value == NULL)
11122         {
11123             result = __LINE__;
11124         }
11125         else
11126         {
11127             if (amqpvalue_get_milliseconds(item_value, ttl_value) != 0)
11128             {
11129                 result = __LINE__;
11130             }
11131             else
11132             {
11133                 result = 0;
11134             }
11135         }
11136     }
11137 
11138     return result;
11139 }
11140 
11141 int header_set_ttl(HEADER_HANDLE header, milliseconds ttl_value)
11142 {
11143     int result;
11144 
11145     if (header == NULL)
11146     {
11147         result = __LINE__;
11148     }
11149     else
11150     {
11151         HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)header;
11152         AMQP_VALUE ttl_amqp_value = amqpvalue_create_milliseconds(ttl_value);
11153         if (ttl_amqp_value == NULL)
11154         {
11155             result = __LINE__;
11156         }
11157         else
11158         {
11159             if (amqpvalue_set_composite_item(header_instance->composite_value, 2, ttl_amqp_value) != 0)
11160             {
11161                 result = __LINE__;
11162             }
11163             else
11164             {
11165                 result = 0;
11166             }
11167 
11168             amqpvalue_destroy(ttl_amqp_value);
11169         }
11170     }
11171 
11172     return result;
11173 }
11174 
11175 int header_get_first_acquirer(HEADER_HANDLE header, bool* first_acquirer_value)
11176 {
11177     int result;
11178 
11179     if (header == NULL)
11180     {
11181         result = __LINE__;
11182     }
11183     else
11184     {
11185         HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)header;
11186         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(header_instance->composite_value, 3);
11187         if (item_value == NULL)
11188         {
11189             result = __LINE__;
11190         }
11191         else
11192         {
11193             if (amqpvalue_get_boolean(item_value, first_acquirer_value) != 0)
11194             {
11195                 result = __LINE__;
11196             }
11197             else
11198             {
11199                 result = 0;
11200             }
11201         }
11202     }
11203 
11204     return result;
11205 }
11206 
11207 int header_set_first_acquirer(HEADER_HANDLE header, bool first_acquirer_value)
11208 {
11209     int result;
11210 
11211     if (header == NULL)
11212     {
11213         result = __LINE__;
11214     }
11215     else
11216     {
11217         HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)header;
11218         AMQP_VALUE first_acquirer_amqp_value = amqpvalue_create_boolean(first_acquirer_value);
11219         if (first_acquirer_amqp_value == NULL)
11220         {
11221             result = __LINE__;
11222         }
11223         else
11224         {
11225             if (amqpvalue_set_composite_item(header_instance->composite_value, 3, first_acquirer_amqp_value) != 0)
11226             {
11227                 result = __LINE__;
11228             }
11229             else
11230             {
11231                 result = 0;
11232             }
11233 
11234             amqpvalue_destroy(first_acquirer_amqp_value);
11235         }
11236     }
11237 
11238     return result;
11239 }
11240 
11241 int header_get_delivery_count(HEADER_HANDLE header, uint32_t* delivery_count_value)
11242 {
11243     int result;
11244 
11245     if (header == NULL)
11246     {
11247         result = __LINE__;
11248     }
11249     else
11250     {
11251         HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)header;
11252         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(header_instance->composite_value, 4);
11253         if (item_value == NULL)
11254         {
11255             result = __LINE__;
11256         }
11257         else
11258         {
11259             if (amqpvalue_get_uint(item_value, delivery_count_value) != 0)
11260             {
11261                 result = __LINE__;
11262             }
11263             else
11264             {
11265                 result = 0;
11266             }
11267         }
11268     }
11269 
11270     return result;
11271 }
11272 
11273 int header_set_delivery_count(HEADER_HANDLE header, uint32_t delivery_count_value)
11274 {
11275     int result;
11276 
11277     if (header == NULL)
11278     {
11279         result = __LINE__;
11280     }
11281     else
11282     {
11283         HEADER_INSTANCE* header_instance = (HEADER_INSTANCE*)header;
11284         AMQP_VALUE delivery_count_amqp_value = amqpvalue_create_uint(delivery_count_value);
11285         if (delivery_count_amqp_value == NULL)
11286         {
11287             result = __LINE__;
11288         }
11289         else
11290         {
11291             if (amqpvalue_set_composite_item(header_instance->composite_value, 4, delivery_count_amqp_value) != 0)
11292             {
11293                 result = __LINE__;
11294             }
11295             else
11296             {
11297                 result = 0;
11298             }
11299 
11300             amqpvalue_destroy(delivery_count_amqp_value);
11301         }
11302     }
11303 
11304     return result;
11305 }
11306 
11307 
11308 /* delivery-annotations */
11309 
11310 AMQP_VALUE amqpvalue_create_delivery_annotations(delivery_annotations value)
11311 {
11312     AMQP_VALUE result;
11313     AMQP_VALUE described_value = amqpvalue_create_annotations(value);
11314     if (described_value == NULL)
11315     {
11316         result = NULL;
11317     }
11318     else
11319     {
11320         AMQP_VALUE descriptor = amqpvalue_create_ulong(113);
11321         if (descriptor == NULL)
11322         {
11323             result = NULL;
11324         }
11325         else
11326         {
11327             result = amqpvalue_create_described(amqpvalue_clone(descriptor), amqpvalue_clone(described_value));
11328 
11329             amqpvalue_destroy(descriptor);
11330         }
11331 
11332         amqpvalue_destroy(described_value);
11333     }
11334 
11335     return result;
11336 }
11337 
11338 bool is_delivery_annotations_type_by_descriptor(AMQP_VALUE descriptor)
11339 {
11340     bool result;
11341 
11342     uint64_t descriptor_ulong;
11343     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
11344         (descriptor_ulong == 113))
11345     {
11346         result = true;
11347     }
11348     else
11349     {
11350         result = false;
11351     }
11352 
11353     return result;
11354 }
11355 
11356 /* message-annotations */
11357 
11358 AMQP_VALUE amqpvalue_create_message_annotations(message_annotations value)
11359 {
11360     AMQP_VALUE result;
11361     AMQP_VALUE described_value = amqpvalue_create_annotations(value);
11362     if (described_value == NULL)
11363     {
11364         result = NULL;
11365     }
11366     else
11367     {
11368         AMQP_VALUE descriptor = amqpvalue_create_ulong(114);
11369         if (descriptor == NULL)
11370         {
11371             result = NULL;
11372         }
11373         else
11374         {
11375             result = amqpvalue_create_described(amqpvalue_clone(descriptor), amqpvalue_clone(described_value));
11376 
11377             amqpvalue_destroy(descriptor);
11378         }
11379 
11380         amqpvalue_destroy(described_value);
11381     }
11382 
11383     return result;
11384 }
11385 
11386 bool is_message_annotations_type_by_descriptor(AMQP_VALUE descriptor)
11387 {
11388     bool result;
11389 
11390     uint64_t descriptor_ulong;
11391     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
11392         (descriptor_ulong == 114))
11393     {
11394         result = true;
11395     }
11396     else
11397     {
11398         result = false;
11399     }
11400 
11401     return result;
11402 }
11403 
11404 /* application-properties */
11405 
11406 AMQP_VALUE amqpvalue_create_application_properties(AMQP_VALUE value)
11407 {
11408     AMQP_VALUE result;
11409     AMQP_VALUE described_value = amqpvalue_clone(value);
11410     if (described_value == NULL)
11411     {
11412         result = NULL;
11413     }
11414     else
11415     {
11416         AMQP_VALUE descriptor = amqpvalue_create_ulong(116);
11417         if (descriptor == NULL)
11418         {
11419             result = NULL;
11420         }
11421         else
11422         {
11423             result = amqpvalue_create_described(amqpvalue_clone(descriptor), amqpvalue_clone(described_value));
11424 
11425             amqpvalue_destroy(descriptor);
11426         }
11427 
11428         amqpvalue_destroy(described_value);
11429     }
11430 
11431     return result;
11432 }
11433 
11434 bool is_application_properties_type_by_descriptor(AMQP_VALUE descriptor)
11435 {
11436     bool result;
11437 
11438     uint64_t descriptor_ulong;
11439     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
11440         (descriptor_ulong == 116))
11441     {
11442         result = true;
11443     }
11444     else
11445     {
11446         result = false;
11447     }
11448 
11449     return result;
11450 }
11451 
11452 /* data */
11453 
11454 AMQP_VALUE amqpvalue_create_data(data value)
11455 {
11456     AMQP_VALUE result;
11457     AMQP_VALUE described_value = amqpvalue_create_binary(value);
11458     if (described_value == NULL)
11459     {
11460         result = NULL;
11461     }
11462     else
11463     {
11464         AMQP_VALUE descriptor = amqpvalue_create_ulong(117);
11465         if (descriptor == NULL)
11466         {
11467             result = NULL;
11468         }
11469         else
11470         {
11471             result = amqpvalue_create_described(amqpvalue_clone(descriptor), amqpvalue_clone(described_value));
11472 
11473             amqpvalue_destroy(descriptor);
11474         }
11475 
11476         amqpvalue_destroy(described_value);
11477     }
11478 
11479     return result;
11480 }
11481 
11482 bool is_data_type_by_descriptor(AMQP_VALUE descriptor)
11483 {
11484     bool result;
11485 
11486     uint64_t descriptor_ulong;
11487     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
11488         (descriptor_ulong == 117))
11489     {
11490         result = true;
11491     }
11492     else
11493     {
11494         result = false;
11495     }
11496 
11497     return result;
11498 }
11499 
11500 /* amqp-sequence */
11501 
11502 AMQP_VALUE amqpvalue_create_amqp_sequence(AMQP_VALUE value)
11503 {
11504     AMQP_VALUE result;
11505     AMQP_VALUE described_value = amqpvalue_clone(value);
11506     if (described_value == NULL)
11507     {
11508         result = NULL;
11509     }
11510     else
11511     {
11512         AMQP_VALUE descriptor = amqpvalue_create_ulong(118);
11513         if (descriptor == NULL)
11514         {
11515             result = NULL;
11516         }
11517         else
11518         {
11519             result = amqpvalue_create_described(amqpvalue_clone(descriptor), amqpvalue_clone(described_value));
11520 
11521             amqpvalue_destroy(descriptor);
11522         }
11523 
11524         amqpvalue_destroy(described_value);
11525     }
11526 
11527     return result;
11528 }
11529 
11530 bool is_amqp_sequence_type_by_descriptor(AMQP_VALUE descriptor)
11531 {
11532     bool result;
11533 
11534     uint64_t descriptor_ulong;
11535     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
11536         (descriptor_ulong == 118))
11537     {
11538         result = true;
11539     }
11540     else
11541     {
11542         result = false;
11543     }
11544 
11545     return result;
11546 }
11547 
11548 /* amqp-value */
11549 
11550 AMQP_VALUE amqpvalue_create_amqp_value(AMQP_VALUE value)
11551 {
11552     AMQP_VALUE result;
11553     AMQP_VALUE described_value = amqpvalue_clone(value);
11554     if (described_value == NULL)
11555     {
11556         result = NULL;
11557     }
11558     else
11559     {
11560         AMQP_VALUE descriptor = amqpvalue_create_ulong(119);
11561         if (descriptor == NULL)
11562         {
11563             result = NULL;
11564         }
11565         else
11566         {
11567             result = amqpvalue_create_described(amqpvalue_clone(descriptor), amqpvalue_clone(described_value));
11568 
11569             amqpvalue_destroy(descriptor);
11570         }
11571 
11572         amqpvalue_destroy(described_value);
11573     }
11574 
11575     return result;
11576 }
11577 
11578 bool is_amqp_value_type_by_descriptor(AMQP_VALUE descriptor)
11579 {
11580     bool result;
11581 
11582     uint64_t descriptor_ulong;
11583     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
11584         (descriptor_ulong == 119))
11585     {
11586         result = true;
11587     }
11588     else
11589     {
11590         result = false;
11591     }
11592 
11593     return result;
11594 }
11595 
11596 /* footer */
11597 
11598 AMQP_VALUE amqpvalue_create_footer(footer value)
11599 {
11600     AMQP_VALUE result;
11601     AMQP_VALUE described_value = amqpvalue_create_annotations(value);
11602     if (described_value == NULL)
11603     {
11604         result = NULL;
11605     }
11606     else
11607     {
11608         AMQP_VALUE descriptor = amqpvalue_create_ulong(120);
11609         if (descriptor == NULL)
11610         {
11611             result = NULL;
11612         }
11613         else
11614         {
11615             result = amqpvalue_create_described(amqpvalue_clone(descriptor), amqpvalue_clone(described_value));
11616 
11617             amqpvalue_destroy(descriptor);
11618         }
11619 
11620         amqpvalue_destroy(described_value);
11621     }
11622 
11623     return result;
11624 }
11625 
11626 bool is_footer_type_by_descriptor(AMQP_VALUE descriptor)
11627 {
11628     bool result;
11629 
11630     uint64_t descriptor_ulong;
11631     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
11632         (descriptor_ulong == 120))
11633     {
11634         result = true;
11635     }
11636     else
11637     {
11638         result = false;
11639     }
11640 
11641     return result;
11642 }
11643 
11644 /* properties */
11645 
11646 typedef struct PROPERTIES_INSTANCE_TAG
11647 {
11648     AMQP_VALUE composite_value;
11649 } PROPERTIES_INSTANCE;
11650 
11651 static PROPERTIES_HANDLE properties_create_internal(void)
11652 {
11653     PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)amqpalloc_malloc(sizeof(PROPERTIES_INSTANCE));
11654     if (properties_instance != NULL)
11655     {
11656         properties_instance->composite_value = NULL;
11657     }
11658 
11659     return properties_instance;
11660 }
11661 
11662 PROPERTIES_HANDLE properties_create(void)
11663 {
11664     PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)amqpalloc_malloc(sizeof(PROPERTIES_INSTANCE));
11665     if (properties_instance != NULL)
11666     {
11667         properties_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(115);
11668         if (properties_instance->composite_value == NULL)
11669         {
11670             amqpalloc_free(properties_instance);
11671             properties_instance = NULL;
11672         }
11673     }
11674 
11675     return properties_instance;
11676 }
11677 
11678 PROPERTIES_HANDLE properties_clone(PROPERTIES_HANDLE value)
11679 {
11680     PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)amqpalloc_malloc(sizeof(PROPERTIES_INSTANCE));
11681     if (properties_instance != NULL)
11682     {
11683         properties_instance->composite_value = amqpvalue_clone(((PROPERTIES_INSTANCE*)value)->composite_value);
11684         if (properties_instance->composite_value == NULL)
11685         {
11686             amqpalloc_free(properties_instance);
11687             properties_instance = NULL;
11688         }
11689     }
11690 
11691     return properties_instance;
11692 }
11693 
11694 void properties_destroy(PROPERTIES_HANDLE properties)
11695 {
11696     if (properties != NULL)
11697     {
11698         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
11699         amqpvalue_destroy(properties_instance->composite_value);
11700         amqpalloc_free(properties_instance);
11701     }
11702 }
11703 
11704 AMQP_VALUE amqpvalue_create_properties(PROPERTIES_HANDLE properties)
11705 {
11706     AMQP_VALUE result;
11707 
11708     if (properties == NULL)
11709     {
11710         result = NULL;
11711     }
11712     else
11713     {
11714         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
11715         result = amqpvalue_clone(properties_instance->composite_value);
11716     }
11717 
11718     return result;
11719 }
11720 
11721 bool is_properties_type_by_descriptor(AMQP_VALUE descriptor)
11722 {
11723     bool result;
11724 
11725     uint64_t descriptor_ulong;
11726     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
11727         (descriptor_ulong == 115))
11728     {
11729         result = true;
11730     }
11731     else
11732     {
11733         result = false;
11734     }
11735 
11736     return result;
11737 }
11738 
11739 
11740 int amqpvalue_get_properties(AMQP_VALUE value, PROPERTIES_HANDLE* properties_handle)
11741 {
11742     int result;
11743     PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties_create_internal();
11744     *properties_handle = properties_instance;
11745     if (*properties_handle == NULL)
11746     {
11747         result = __LINE__;
11748     }
11749     else
11750     {
11751         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
11752         if (list_value == NULL)
11753         {
11754             properties_destroy(*properties_handle);
11755             result = __LINE__;
11756         }
11757         else
11758         {
11759             do
11760             {
11761                 AMQP_VALUE item_value;
11762                 /* message-id */
11763                 item_value = amqpvalue_get_list_item(list_value, 0);
11764                 if (item_value == NULL)
11765                 {
11766                     /* do nothing */
11767                 }
11768                 else
11769                 {
11770                     amqpvalue_destroy(item_value);
11771                 }
11772                 /* user-id */
11773                 item_value = amqpvalue_get_list_item(list_value, 1);
11774                 if (item_value == NULL)
11775                 {
11776                     /* do nothing */
11777                 }
11778                 else
11779                 {
11780                     amqp_binary user_id;
11781                     if (amqpvalue_get_binary(item_value, &user_id) != 0)
11782                     {
11783                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
11784                         {
11785                             properties_destroy(*properties_handle);
11786                             result = __LINE__;
11787                             break;
11788                         }
11789                     }
11790 
11791                     amqpvalue_destroy(item_value);
11792                 }
11793                 /* to */
11794                 item_value = amqpvalue_get_list_item(list_value, 2);
11795                 if (item_value == NULL)
11796                 {
11797                     /* do nothing */
11798                 }
11799                 else
11800                 {
11801                     amqpvalue_destroy(item_value);
11802                 }
11803                 /* subject */
11804                 item_value = amqpvalue_get_list_item(list_value, 3);
11805                 if (item_value == NULL)
11806                 {
11807                     /* do nothing */
11808                 }
11809                 else
11810                 {
11811                     const char* subject;
11812                     if (amqpvalue_get_string(item_value, &subject) != 0)
11813                     {
11814                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
11815                         {
11816                             properties_destroy(*properties_handle);
11817                             result = __LINE__;
11818                             break;
11819                         }
11820                     }
11821 
11822                     amqpvalue_destroy(item_value);
11823                 }
11824                 /* reply-to */
11825                 item_value = amqpvalue_get_list_item(list_value, 4);
11826                 if (item_value == NULL)
11827                 {
11828                     /* do nothing */
11829                 }
11830                 else
11831                 {
11832                     amqpvalue_destroy(item_value);
11833                 }
11834                 /* correlation-id */
11835                 item_value = amqpvalue_get_list_item(list_value, 5);
11836                 if (item_value == NULL)
11837                 {
11838                     /* do nothing */
11839                 }
11840                 else
11841                 {
11842                     amqpvalue_destroy(item_value);
11843                 }
11844                 /* content-type */
11845                 item_value = amqpvalue_get_list_item(list_value, 6);
11846                 if (item_value == NULL)
11847                 {
11848                     /* do nothing */
11849                 }
11850                 else
11851                 {
11852                     const char* content_type;
11853                     if (amqpvalue_get_symbol(item_value, &content_type) != 0)
11854                     {
11855                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
11856                         {
11857                             properties_destroy(*properties_handle);
11858                             result = __LINE__;
11859                             break;
11860                         }
11861                     }
11862 
11863                     amqpvalue_destroy(item_value);
11864                 }
11865                 /* content-encoding */
11866                 item_value = amqpvalue_get_list_item(list_value, 7);
11867                 if (item_value == NULL)
11868                 {
11869                     /* do nothing */
11870                 }
11871                 else
11872                 {
11873                     const char* content_encoding;
11874                     if (amqpvalue_get_symbol(item_value, &content_encoding) != 0)
11875                     {
11876                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
11877                         {
11878                             properties_destroy(*properties_handle);
11879                             result = __LINE__;
11880                             break;
11881                         }
11882                     }
11883 
11884                     amqpvalue_destroy(item_value);
11885                 }
11886                 /* absolute-expiry-time */
11887                 item_value = amqpvalue_get_list_item(list_value, 8);
11888                 if (item_value == NULL)
11889                 {
11890                     /* do nothing */
11891                 }
11892                 else
11893                 {
11894                     timestamp absolute_expiry_time;
11895                     if (amqpvalue_get_timestamp(item_value, &absolute_expiry_time) != 0)
11896                     {
11897                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
11898                         {
11899                             properties_destroy(*properties_handle);
11900                             result = __LINE__;
11901                             break;
11902                         }
11903                     }
11904 
11905                     amqpvalue_destroy(item_value);
11906                 }
11907                 /* creation-time */
11908                 item_value = amqpvalue_get_list_item(list_value, 9);
11909                 if (item_value == NULL)
11910                 {
11911                     /* do nothing */
11912                 }
11913                 else
11914                 {
11915                     timestamp creation_time;
11916                     if (amqpvalue_get_timestamp(item_value, &creation_time) != 0)
11917                     {
11918                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
11919                         {
11920                             properties_destroy(*properties_handle);
11921                             result = __LINE__;
11922                             break;
11923                         }
11924                     }
11925 
11926                     amqpvalue_destroy(item_value);
11927                 }
11928                 /* group-id */
11929                 item_value = amqpvalue_get_list_item(list_value, 10);
11930                 if (item_value == NULL)
11931                 {
11932                     /* do nothing */
11933                 }
11934                 else
11935                 {
11936                     const char* group_id;
11937                     if (amqpvalue_get_string(item_value, &group_id) != 0)
11938                     {
11939                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
11940                         {
11941                             properties_destroy(*properties_handle);
11942                             result = __LINE__;
11943                             break;
11944                         }
11945                     }
11946 
11947                     amqpvalue_destroy(item_value);
11948                 }
11949                 /* group-sequence */
11950                 item_value = amqpvalue_get_list_item(list_value, 11);
11951                 if (item_value == NULL)
11952                 {
11953                     /* do nothing */
11954                 }
11955                 else
11956                 {
11957                     sequence_no group_sequence;
11958                     if (amqpvalue_get_sequence_no(item_value, &group_sequence) != 0)
11959                     {
11960                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
11961                         {
11962                             properties_destroy(*properties_handle);
11963                             result = __LINE__;
11964                             break;
11965                         }
11966                     }
11967 
11968                     amqpvalue_destroy(item_value);
11969                 }
11970                 /* reply-to-group-id */
11971                 item_value = amqpvalue_get_list_item(list_value, 12);
11972                 if (item_value == NULL)
11973                 {
11974                     /* do nothing */
11975                 }
11976                 else
11977                 {
11978                     const char* reply_to_group_id;
11979                     if (amqpvalue_get_string(item_value, &reply_to_group_id) != 0)
11980                     {
11981                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
11982                         {
11983                             properties_destroy(*properties_handle);
11984                             result = __LINE__;
11985                             break;
11986                         }
11987                     }
11988 
11989                     amqpvalue_destroy(item_value);
11990                 }
11991 
11992                 properties_instance->composite_value = amqpvalue_clone(value);
11993 
11994                 result = 0;
11995             } while (0);
11996         }
11997     }
11998 
11999     return result;
12000 }
12001 
12002 int properties_get_message_id(PROPERTIES_HANDLE properties, AMQP_VALUE* message_id_value)
12003 {
12004     int result;
12005 
12006     if (properties == NULL)
12007     {
12008         result = __LINE__;
12009     }
12010     else
12011     {
12012         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12013         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(properties_instance->composite_value, 0);
12014         if (item_value == NULL)
12015         {
12016             result = __LINE__;
12017         }
12018         else
12019         {
12020             *message_id_value = item_value;
12021             result = 0;
12022         }
12023     }
12024 
12025     return result;
12026 }
12027 
12028 int properties_set_message_id(PROPERTIES_HANDLE properties, AMQP_VALUE message_id_value)
12029 {
12030     int result;
12031 
12032     if (properties == NULL)
12033     {
12034         result = __LINE__;
12035     }
12036     else
12037     {
12038         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12039         AMQP_VALUE message_id_amqp_value = amqpvalue_clone(message_id_value);
12040         if (message_id_amqp_value == NULL)
12041         {
12042             result = __LINE__;
12043         }
12044         else
12045         {
12046             if (amqpvalue_set_composite_item(properties_instance->composite_value, 0, message_id_amqp_value) != 0)
12047             {
12048                 result = __LINE__;
12049             }
12050             else
12051             {
12052                 result = 0;
12053             }
12054 
12055             amqpvalue_destroy(message_id_amqp_value);
12056         }
12057     }
12058 
12059     return result;
12060 }
12061 
12062 int properties_get_user_id(PROPERTIES_HANDLE properties, amqp_binary* user_id_value)
12063 {
12064     int result;
12065 
12066     if (properties == NULL)
12067     {
12068         result = __LINE__;
12069     }
12070     else
12071     {
12072         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12073         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(properties_instance->composite_value, 1);
12074         if (item_value == NULL)
12075         {
12076             result = __LINE__;
12077         }
12078         else
12079         {
12080             if (amqpvalue_get_binary(item_value, user_id_value) != 0)
12081             {
12082                 result = __LINE__;
12083             }
12084             else
12085             {
12086                 result = 0;
12087             }
12088         }
12089     }
12090 
12091     return result;
12092 }
12093 
12094 int properties_set_user_id(PROPERTIES_HANDLE properties, amqp_binary user_id_value)
12095 {
12096     int result;
12097 
12098     if (properties == NULL)
12099     {
12100         result = __LINE__;
12101     }
12102     else
12103     {
12104         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12105         AMQP_VALUE user_id_amqp_value = amqpvalue_create_binary(user_id_value);
12106         if (user_id_amqp_value == NULL)
12107         {
12108             result = __LINE__;
12109         }
12110         else
12111         {
12112             if (amqpvalue_set_composite_item(properties_instance->composite_value, 1, user_id_amqp_value) != 0)
12113             {
12114                 result = __LINE__;
12115             }
12116             else
12117             {
12118                 result = 0;
12119             }
12120 
12121             amqpvalue_destroy(user_id_amqp_value);
12122         }
12123     }
12124 
12125     return result;
12126 }
12127 
12128 int properties_get_to(PROPERTIES_HANDLE properties, AMQP_VALUE* to_value)
12129 {
12130     int result;
12131 
12132     if (properties == NULL)
12133     {
12134         result = __LINE__;
12135     }
12136     else
12137     {
12138         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12139         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(properties_instance->composite_value, 2);
12140         if (item_value == NULL)
12141         {
12142             result = __LINE__;
12143         }
12144         else
12145         {
12146             *to_value = item_value;
12147             result = 0;
12148         }
12149     }
12150 
12151     return result;
12152 }
12153 
12154 int properties_set_to(PROPERTIES_HANDLE properties, AMQP_VALUE to_value)
12155 {
12156     int result;
12157 
12158     if (properties == NULL)
12159     {
12160         result = __LINE__;
12161     }
12162     else
12163     {
12164         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12165         AMQP_VALUE to_amqp_value = amqpvalue_clone(to_value);
12166         if (to_amqp_value == NULL)
12167         {
12168             result = __LINE__;
12169         }
12170         else
12171         {
12172             if (amqpvalue_set_composite_item(properties_instance->composite_value, 2, to_amqp_value) != 0)
12173             {
12174                 result = __LINE__;
12175             }
12176             else
12177             {
12178                 result = 0;
12179             }
12180 
12181             amqpvalue_destroy(to_amqp_value);
12182         }
12183     }
12184 
12185     return result;
12186 }
12187 
12188 int properties_get_subject(PROPERTIES_HANDLE properties, const char** subject_value)
12189 {
12190     int result;
12191 
12192     if (properties == NULL)
12193     {
12194         result = __LINE__;
12195     }
12196     else
12197     {
12198         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12199         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(properties_instance->composite_value, 3);
12200         if (item_value == NULL)
12201         {
12202             result = __LINE__;
12203         }
12204         else
12205         {
12206             if (amqpvalue_get_string(item_value, subject_value) != 0)
12207             {
12208                 result = __LINE__;
12209             }
12210             else
12211             {
12212                 result = 0;
12213             }
12214         }
12215     }
12216 
12217     return result;
12218 }
12219 
12220 int properties_set_subject(PROPERTIES_HANDLE properties, const char* subject_value)
12221 {
12222     int result;
12223 
12224     if (properties == NULL)
12225     {
12226         result = __LINE__;
12227     }
12228     else
12229     {
12230         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12231         AMQP_VALUE subject_amqp_value = amqpvalue_create_string(subject_value);
12232         if (subject_amqp_value == NULL)
12233         {
12234             result = __LINE__;
12235         }
12236         else
12237         {
12238             if (amqpvalue_set_composite_item(properties_instance->composite_value, 3, subject_amqp_value) != 0)
12239             {
12240                 result = __LINE__;
12241             }
12242             else
12243             {
12244                 result = 0;
12245             }
12246 
12247             amqpvalue_destroy(subject_amqp_value);
12248         }
12249     }
12250 
12251     return result;
12252 }
12253 
12254 int properties_get_reply_to(PROPERTIES_HANDLE properties, AMQP_VALUE* reply_to_value)
12255 {
12256     int result;
12257 
12258     if (properties == NULL)
12259     {
12260         result = __LINE__;
12261     }
12262     else
12263     {
12264         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12265         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(properties_instance->composite_value, 4);
12266         if (item_value == NULL)
12267         {
12268             result = __LINE__;
12269         }
12270         else
12271         {
12272             *reply_to_value = item_value;
12273             result = 0;
12274         }
12275     }
12276 
12277     return result;
12278 }
12279 
12280 int properties_set_reply_to(PROPERTIES_HANDLE properties, AMQP_VALUE reply_to_value)
12281 {
12282     int result;
12283 
12284     if (properties == NULL)
12285     {
12286         result = __LINE__;
12287     }
12288     else
12289     {
12290         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12291         AMQP_VALUE reply_to_amqp_value = amqpvalue_clone(reply_to_value);
12292         if (reply_to_amqp_value == NULL)
12293         {
12294             result = __LINE__;
12295         }
12296         else
12297         {
12298             if (amqpvalue_set_composite_item(properties_instance->composite_value, 4, reply_to_amqp_value) != 0)
12299             {
12300                 result = __LINE__;
12301             }
12302             else
12303             {
12304                 result = 0;
12305             }
12306 
12307             amqpvalue_destroy(reply_to_amqp_value);
12308         }
12309     }
12310 
12311     return result;
12312 }
12313 
12314 int properties_get_correlation_id(PROPERTIES_HANDLE properties, AMQP_VALUE* correlation_id_value)
12315 {
12316     int result;
12317 
12318     if (properties == NULL)
12319     {
12320         result = __LINE__;
12321     }
12322     else
12323     {
12324         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12325         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(properties_instance->composite_value, 5);
12326         if (item_value == NULL)
12327         {
12328             result = __LINE__;
12329         }
12330         else
12331         {
12332             *correlation_id_value = item_value;
12333             result = 0;
12334         }
12335     }
12336 
12337     return result;
12338 }
12339 
12340 int properties_set_correlation_id(PROPERTIES_HANDLE properties, AMQP_VALUE correlation_id_value)
12341 {
12342     int result;
12343 
12344     if (properties == NULL)
12345     {
12346         result = __LINE__;
12347     }
12348     else
12349     {
12350         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12351         AMQP_VALUE correlation_id_amqp_value = amqpvalue_clone(correlation_id_value);
12352         if (correlation_id_amqp_value == NULL)
12353         {
12354             result = __LINE__;
12355         }
12356         else
12357         {
12358             if (amqpvalue_set_composite_item(properties_instance->composite_value, 5, correlation_id_amqp_value) != 0)
12359             {
12360                 result = __LINE__;
12361             }
12362             else
12363             {
12364                 result = 0;
12365             }
12366 
12367             amqpvalue_destroy(correlation_id_amqp_value);
12368         }
12369     }
12370 
12371     return result;
12372 }
12373 
12374 int properties_get_content_type(PROPERTIES_HANDLE properties, const char** content_type_value)
12375 {
12376     int result;
12377 
12378     if (properties == NULL)
12379     {
12380         result = __LINE__;
12381     }
12382     else
12383     {
12384         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12385         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(properties_instance->composite_value, 6);
12386         if (item_value == NULL)
12387         {
12388             result = __LINE__;
12389         }
12390         else
12391         {
12392             if (amqpvalue_get_symbol(item_value, content_type_value) != 0)
12393             {
12394                 result = __LINE__;
12395             }
12396             else
12397             {
12398                 result = 0;
12399             }
12400         }
12401     }
12402 
12403     return result;
12404 }
12405 
12406 int properties_set_content_type(PROPERTIES_HANDLE properties, const char* content_type_value)
12407 {
12408     int result;
12409 
12410     if (properties == NULL)
12411     {
12412         result = __LINE__;
12413     }
12414     else
12415     {
12416         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12417         AMQP_VALUE content_type_amqp_value = amqpvalue_create_symbol(content_type_value);
12418         if (content_type_amqp_value == NULL)
12419         {
12420             result = __LINE__;
12421         }
12422         else
12423         {
12424             if (amqpvalue_set_composite_item(properties_instance->composite_value, 6, content_type_amqp_value) != 0)
12425             {
12426                 result = __LINE__;
12427             }
12428             else
12429             {
12430                 result = 0;
12431             }
12432 
12433             amqpvalue_destroy(content_type_amqp_value);
12434         }
12435     }
12436 
12437     return result;
12438 }
12439 
12440 int properties_get_content_encoding(PROPERTIES_HANDLE properties, const char** content_encoding_value)
12441 {
12442     int result;
12443 
12444     if (properties == NULL)
12445     {
12446         result = __LINE__;
12447     }
12448     else
12449     {
12450         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12451         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(properties_instance->composite_value, 7);
12452         if (item_value == NULL)
12453         {
12454             result = __LINE__;
12455         }
12456         else
12457         {
12458             if (amqpvalue_get_symbol(item_value, content_encoding_value) != 0)
12459             {
12460                 result = __LINE__;
12461             }
12462             else
12463             {
12464                 result = 0;
12465             }
12466         }
12467     }
12468 
12469     return result;
12470 }
12471 
12472 int properties_set_content_encoding(PROPERTIES_HANDLE properties, const char* content_encoding_value)
12473 {
12474     int result;
12475 
12476     if (properties == NULL)
12477     {
12478         result = __LINE__;
12479     }
12480     else
12481     {
12482         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12483         AMQP_VALUE content_encoding_amqp_value = amqpvalue_create_symbol(content_encoding_value);
12484         if (content_encoding_amqp_value == NULL)
12485         {
12486             result = __LINE__;
12487         }
12488         else
12489         {
12490             if (amqpvalue_set_composite_item(properties_instance->composite_value, 7, content_encoding_amqp_value) != 0)
12491             {
12492                 result = __LINE__;
12493             }
12494             else
12495             {
12496                 result = 0;
12497             }
12498 
12499             amqpvalue_destroy(content_encoding_amqp_value);
12500         }
12501     }
12502 
12503     return result;
12504 }
12505 
12506 int properties_get_absolute_expiry_time(PROPERTIES_HANDLE properties, timestamp* absolute_expiry_time_value)
12507 {
12508     int result;
12509 
12510     if (properties == NULL)
12511     {
12512         result = __LINE__;
12513     }
12514     else
12515     {
12516         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12517         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(properties_instance->composite_value, 8);
12518         if (item_value == NULL)
12519         {
12520             result = __LINE__;
12521         }
12522         else
12523         {
12524             if (amqpvalue_get_timestamp(item_value, absolute_expiry_time_value) != 0)
12525             {
12526                 result = __LINE__;
12527             }
12528             else
12529             {
12530                 result = 0;
12531             }
12532         }
12533     }
12534 
12535     return result;
12536 }
12537 
12538 int properties_set_absolute_expiry_time(PROPERTIES_HANDLE properties, timestamp absolute_expiry_time_value)
12539 {
12540     int result;
12541 
12542     if (properties == NULL)
12543     {
12544         result = __LINE__;
12545     }
12546     else
12547     {
12548         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12549         AMQP_VALUE absolute_expiry_time_amqp_value = amqpvalue_create_timestamp(absolute_expiry_time_value);
12550         if (absolute_expiry_time_amqp_value == NULL)
12551         {
12552             result = __LINE__;
12553         }
12554         else
12555         {
12556             if (amqpvalue_set_composite_item(properties_instance->composite_value, 8, absolute_expiry_time_amqp_value) != 0)
12557             {
12558                 result = __LINE__;
12559             }
12560             else
12561             {
12562                 result = 0;
12563             }
12564 
12565             amqpvalue_destroy(absolute_expiry_time_amqp_value);
12566         }
12567     }
12568 
12569     return result;
12570 }
12571 
12572 int properties_get_creation_time(PROPERTIES_HANDLE properties, timestamp* creation_time_value)
12573 {
12574     int result;
12575 
12576     if (properties == NULL)
12577     {
12578         result = __LINE__;
12579     }
12580     else
12581     {
12582         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12583         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(properties_instance->composite_value, 9);
12584         if (item_value == NULL)
12585         {
12586             result = __LINE__;
12587         }
12588         else
12589         {
12590             if (amqpvalue_get_timestamp(item_value, creation_time_value) != 0)
12591             {
12592                 result = __LINE__;
12593             }
12594             else
12595             {
12596                 result = 0;
12597             }
12598         }
12599     }
12600 
12601     return result;
12602 }
12603 
12604 int properties_set_creation_time(PROPERTIES_HANDLE properties, timestamp creation_time_value)
12605 {
12606     int result;
12607 
12608     if (properties == NULL)
12609     {
12610         result = __LINE__;
12611     }
12612     else
12613     {
12614         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12615         AMQP_VALUE creation_time_amqp_value = amqpvalue_create_timestamp(creation_time_value);
12616         if (creation_time_amqp_value == NULL)
12617         {
12618             result = __LINE__;
12619         }
12620         else
12621         {
12622             if (amqpvalue_set_composite_item(properties_instance->composite_value, 9, creation_time_amqp_value) != 0)
12623             {
12624                 result = __LINE__;
12625             }
12626             else
12627             {
12628                 result = 0;
12629             }
12630 
12631             amqpvalue_destroy(creation_time_amqp_value);
12632         }
12633     }
12634 
12635     return result;
12636 }
12637 
12638 int properties_get_group_id(PROPERTIES_HANDLE properties, const char** group_id_value)
12639 {
12640     int result;
12641 
12642     if (properties == NULL)
12643     {
12644         result = __LINE__;
12645     }
12646     else
12647     {
12648         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12649         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(properties_instance->composite_value, 10);
12650         if (item_value == NULL)
12651         {
12652             result = __LINE__;
12653         }
12654         else
12655         {
12656             if (amqpvalue_get_string(item_value, group_id_value) != 0)
12657             {
12658                 result = __LINE__;
12659             }
12660             else
12661             {
12662                 result = 0;
12663             }
12664         }
12665     }
12666 
12667     return result;
12668 }
12669 
12670 int properties_set_group_id(PROPERTIES_HANDLE properties, const char* group_id_value)
12671 {
12672     int result;
12673 
12674     if (properties == NULL)
12675     {
12676         result = __LINE__;
12677     }
12678     else
12679     {
12680         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12681         AMQP_VALUE group_id_amqp_value = amqpvalue_create_string(group_id_value);
12682         if (group_id_amqp_value == NULL)
12683         {
12684             result = __LINE__;
12685         }
12686         else
12687         {
12688             if (amqpvalue_set_composite_item(properties_instance->composite_value, 10, group_id_amqp_value) != 0)
12689             {
12690                 result = __LINE__;
12691             }
12692             else
12693             {
12694                 result = 0;
12695             }
12696 
12697             amqpvalue_destroy(group_id_amqp_value);
12698         }
12699     }
12700 
12701     return result;
12702 }
12703 
12704 int properties_get_group_sequence(PROPERTIES_HANDLE properties, sequence_no* group_sequence_value)
12705 {
12706     int result;
12707 
12708     if (properties == NULL)
12709     {
12710         result = __LINE__;
12711     }
12712     else
12713     {
12714         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12715         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(properties_instance->composite_value, 11);
12716         if (item_value == NULL)
12717         {
12718             result = __LINE__;
12719         }
12720         else
12721         {
12722             if (amqpvalue_get_sequence_no(item_value, group_sequence_value) != 0)
12723             {
12724                 result = __LINE__;
12725             }
12726             else
12727             {
12728                 result = 0;
12729             }
12730         }
12731     }
12732 
12733     return result;
12734 }
12735 
12736 int properties_set_group_sequence(PROPERTIES_HANDLE properties, sequence_no group_sequence_value)
12737 {
12738     int result;
12739 
12740     if (properties == NULL)
12741     {
12742         result = __LINE__;
12743     }
12744     else
12745     {
12746         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12747         AMQP_VALUE group_sequence_amqp_value = amqpvalue_create_sequence_no(group_sequence_value);
12748         if (group_sequence_amqp_value == NULL)
12749         {
12750             result = __LINE__;
12751         }
12752         else
12753         {
12754             if (amqpvalue_set_composite_item(properties_instance->composite_value, 11, group_sequence_amqp_value) != 0)
12755             {
12756                 result = __LINE__;
12757             }
12758             else
12759             {
12760                 result = 0;
12761             }
12762 
12763             amqpvalue_destroy(group_sequence_amqp_value);
12764         }
12765     }
12766 
12767     return result;
12768 }
12769 
12770 int properties_get_reply_to_group_id(PROPERTIES_HANDLE properties, const char** reply_to_group_id_value)
12771 {
12772     int result;
12773 
12774     if (properties == NULL)
12775     {
12776         result = __LINE__;
12777     }
12778     else
12779     {
12780         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12781         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(properties_instance->composite_value, 12);
12782         if (item_value == NULL)
12783         {
12784             result = __LINE__;
12785         }
12786         else
12787         {
12788             if (amqpvalue_get_string(item_value, reply_to_group_id_value) != 0)
12789             {
12790                 result = __LINE__;
12791             }
12792             else
12793             {
12794                 result = 0;
12795             }
12796         }
12797     }
12798 
12799     return result;
12800 }
12801 
12802 int properties_set_reply_to_group_id(PROPERTIES_HANDLE properties, const char* reply_to_group_id_value)
12803 {
12804     int result;
12805 
12806     if (properties == NULL)
12807     {
12808         result = __LINE__;
12809     }
12810     else
12811     {
12812         PROPERTIES_INSTANCE* properties_instance = (PROPERTIES_INSTANCE*)properties;
12813         AMQP_VALUE reply_to_group_id_amqp_value = amqpvalue_create_string(reply_to_group_id_value);
12814         if (reply_to_group_id_amqp_value == NULL)
12815         {
12816             result = __LINE__;
12817         }
12818         else
12819         {
12820             if (amqpvalue_set_composite_item(properties_instance->composite_value, 12, reply_to_group_id_amqp_value) != 0)
12821             {
12822                 result = __LINE__;
12823             }
12824             else
12825             {
12826                 result = 0;
12827             }
12828 
12829             amqpvalue_destroy(reply_to_group_id_amqp_value);
12830         }
12831     }
12832 
12833     return result;
12834 }
12835 
12836 
12837 /* received */
12838 
12839 typedef struct RECEIVED_INSTANCE_TAG
12840 {
12841     AMQP_VALUE composite_value;
12842 } RECEIVED_INSTANCE;
12843 
12844 static RECEIVED_HANDLE received_create_internal(void)
12845 {
12846     RECEIVED_INSTANCE* received_instance = (RECEIVED_INSTANCE*)amqpalloc_malloc(sizeof(RECEIVED_INSTANCE));
12847     if (received_instance != NULL)
12848     {
12849         received_instance->composite_value = NULL;
12850     }
12851 
12852     return received_instance;
12853 }
12854 
12855 RECEIVED_HANDLE received_create(uint32_t section_number_value, uint64_t section_offset_value)
12856 {
12857     RECEIVED_INSTANCE* received_instance = (RECEIVED_INSTANCE*)amqpalloc_malloc(sizeof(RECEIVED_INSTANCE));
12858     if (received_instance != NULL)
12859     {
12860         received_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(35);
12861         if (received_instance->composite_value == NULL)
12862         {
12863             amqpalloc_free(received_instance);
12864             received_instance = NULL;
12865         }
12866         else
12867         {
12868             AMQP_VALUE section_number_amqp_value;
12869             AMQP_VALUE section_offset_amqp_value;
12870             int result = 0;
12871 
12872             section_number_amqp_value = amqpvalue_create_uint(section_number_value);
12873             if ((result == 0) && (amqpvalue_set_composite_item(received_instance->composite_value, 0, section_number_amqp_value) != 0))
12874             {
12875                 result = __LINE__;
12876             }
12877             section_offset_amqp_value = amqpvalue_create_ulong(section_offset_value);
12878             if ((result == 0) && (amqpvalue_set_composite_item(received_instance->composite_value, 1, section_offset_amqp_value) != 0))
12879             {
12880                 result = __LINE__;
12881             }
12882 
12883             amqpvalue_destroy(section_number_amqp_value);
12884             amqpvalue_destroy(section_offset_amqp_value);
12885         }
12886     }
12887 
12888     return received_instance;
12889 }
12890 
12891 RECEIVED_HANDLE received_clone(RECEIVED_HANDLE value)
12892 {
12893     RECEIVED_INSTANCE* received_instance = (RECEIVED_INSTANCE*)amqpalloc_malloc(sizeof(RECEIVED_INSTANCE));
12894     if (received_instance != NULL)
12895     {
12896         received_instance->composite_value = amqpvalue_clone(((RECEIVED_INSTANCE*)value)->composite_value);
12897         if (received_instance->composite_value == NULL)
12898         {
12899             amqpalloc_free(received_instance);
12900             received_instance = NULL;
12901         }
12902     }
12903 
12904     return received_instance;
12905 }
12906 
12907 void received_destroy(RECEIVED_HANDLE received)
12908 {
12909     if (received != NULL)
12910     {
12911         RECEIVED_INSTANCE* received_instance = (RECEIVED_INSTANCE*)received;
12912         amqpvalue_destroy(received_instance->composite_value);
12913         amqpalloc_free(received_instance);
12914     }
12915 }
12916 
12917 AMQP_VALUE amqpvalue_create_received(RECEIVED_HANDLE received)
12918 {
12919     AMQP_VALUE result;
12920 
12921     if (received == NULL)
12922     {
12923         result = NULL;
12924     }
12925     else
12926     {
12927         RECEIVED_INSTANCE* received_instance = (RECEIVED_INSTANCE*)received;
12928         result = amqpvalue_clone(received_instance->composite_value);
12929     }
12930 
12931     return result;
12932 }
12933 
12934 bool is_received_type_by_descriptor(AMQP_VALUE descriptor)
12935 {
12936     bool result;
12937 
12938     uint64_t descriptor_ulong;
12939     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
12940         (descriptor_ulong == 35))
12941     {
12942         result = true;
12943     }
12944     else
12945     {
12946         result = false;
12947     }
12948 
12949     return result;
12950 }
12951 
12952 
12953 int amqpvalue_get_received(AMQP_VALUE value, RECEIVED_HANDLE* received_handle)
12954 {
12955     int result;
12956     RECEIVED_INSTANCE* received_instance = (RECEIVED_INSTANCE*)received_create_internal();
12957     *received_handle = received_instance;
12958     if (*received_handle == NULL)
12959     {
12960         result = __LINE__;
12961     }
12962     else
12963     {
12964         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
12965         if (list_value == NULL)
12966         {
12967             received_destroy(*received_handle);
12968             result = __LINE__;
12969         }
12970         else
12971         {
12972             do
12973             {
12974                 AMQP_VALUE item_value;
12975                 /* section-number */
12976                 item_value = amqpvalue_get_list_item(list_value, 0);
12977                 if (item_value == NULL)
12978                 {
12979                     {
12980                         received_destroy(*received_handle);
12981                         result = __LINE__;
12982                         break;
12983                     }
12984                 }
12985                 else
12986                 {
12987                     uint32_t section_number;
12988                     if (amqpvalue_get_uint(item_value, &section_number) != 0)
12989                     {
12990                         received_destroy(*received_handle);
12991                         result = __LINE__;
12992                         break;
12993                     }
12994 
12995                     amqpvalue_destroy(item_value);
12996                 }
12997                 /* section-offset */
12998                 item_value = amqpvalue_get_list_item(list_value, 1);
12999                 if (item_value == NULL)
13000                 {
13001                     {
13002                         received_destroy(*received_handle);
13003                         result = __LINE__;
13004                         break;
13005                     }
13006                 }
13007                 else
13008                 {
13009                     uint64_t section_offset;
13010                     if (amqpvalue_get_ulong(item_value, &section_offset) != 0)
13011                     {
13012                         received_destroy(*received_handle);
13013                         result = __LINE__;
13014                         break;
13015                     }
13016 
13017                     amqpvalue_destroy(item_value);
13018                 }
13019 
13020                 received_instance->composite_value = amqpvalue_clone(value);
13021 
13022                 result = 0;
13023             } while (0);
13024         }
13025     }
13026 
13027     return result;
13028 }
13029 
13030 int received_get_section_number(RECEIVED_HANDLE received, uint32_t* section_number_value)
13031 {
13032     int result;
13033 
13034     if (received == NULL)
13035     {
13036         result = __LINE__;
13037     }
13038     else
13039     {
13040         RECEIVED_INSTANCE* received_instance = (RECEIVED_INSTANCE*)received;
13041         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(received_instance->composite_value, 0);
13042         if (item_value == NULL)
13043         {
13044             result = __LINE__;
13045         }
13046         else
13047         {
13048             if (amqpvalue_get_uint(item_value, section_number_value) != 0)
13049             {
13050                 result = __LINE__;
13051             }
13052             else
13053             {
13054                 result = 0;
13055             }
13056         }
13057     }
13058 
13059     return result;
13060 }
13061 
13062 int received_set_section_number(RECEIVED_HANDLE received, uint32_t section_number_value)
13063 {
13064     int result;
13065 
13066     if (received == NULL)
13067     {
13068         result = __LINE__;
13069     }
13070     else
13071     {
13072         RECEIVED_INSTANCE* received_instance = (RECEIVED_INSTANCE*)received;
13073         AMQP_VALUE section_number_amqp_value = amqpvalue_create_uint(section_number_value);
13074         if (section_number_amqp_value == NULL)
13075         {
13076             result = __LINE__;
13077         }
13078         else
13079         {
13080             if (amqpvalue_set_composite_item(received_instance->composite_value, 0, section_number_amqp_value) != 0)
13081             {
13082                 result = __LINE__;
13083             }
13084             else
13085             {
13086                 result = 0;
13087             }
13088 
13089             amqpvalue_destroy(section_number_amqp_value);
13090         }
13091     }
13092 
13093     return result;
13094 }
13095 
13096 int received_get_section_offset(RECEIVED_HANDLE received, uint64_t* section_offset_value)
13097 {
13098     int result;
13099 
13100     if (received == NULL)
13101     {
13102         result = __LINE__;
13103     }
13104     else
13105     {
13106         RECEIVED_INSTANCE* received_instance = (RECEIVED_INSTANCE*)received;
13107         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(received_instance->composite_value, 1);
13108         if (item_value == NULL)
13109         {
13110             result = __LINE__;
13111         }
13112         else
13113         {
13114             if (amqpvalue_get_ulong(item_value, section_offset_value) != 0)
13115             {
13116                 result = __LINE__;
13117             }
13118             else
13119             {
13120                 result = 0;
13121             }
13122         }
13123     }
13124 
13125     return result;
13126 }
13127 
13128 int received_set_section_offset(RECEIVED_HANDLE received, uint64_t section_offset_value)
13129 {
13130     int result;
13131 
13132     if (received == NULL)
13133     {
13134         result = __LINE__;
13135     }
13136     else
13137     {
13138         RECEIVED_INSTANCE* received_instance = (RECEIVED_INSTANCE*)received;
13139         AMQP_VALUE section_offset_amqp_value = amqpvalue_create_ulong(section_offset_value);
13140         if (section_offset_amqp_value == NULL)
13141         {
13142             result = __LINE__;
13143         }
13144         else
13145         {
13146             if (amqpvalue_set_composite_item(received_instance->composite_value, 1, section_offset_amqp_value) != 0)
13147             {
13148                 result = __LINE__;
13149             }
13150             else
13151             {
13152                 result = 0;
13153             }
13154 
13155             amqpvalue_destroy(section_offset_amqp_value);
13156         }
13157     }
13158 
13159     return result;
13160 }
13161 
13162 
13163 /* accepted */
13164 
13165 typedef struct ACCEPTED_INSTANCE_TAG
13166 {
13167     AMQP_VALUE composite_value;
13168 } ACCEPTED_INSTANCE;
13169 
13170 static ACCEPTED_HANDLE accepted_create_internal(void)
13171 {
13172     ACCEPTED_INSTANCE* accepted_instance = (ACCEPTED_INSTANCE*)amqpalloc_malloc(sizeof(ACCEPTED_INSTANCE));
13173     if (accepted_instance != NULL)
13174     {
13175         accepted_instance->composite_value = NULL;
13176     }
13177 
13178     return accepted_instance;
13179 }
13180 
13181 ACCEPTED_HANDLE accepted_create(void)
13182 {
13183     ACCEPTED_INSTANCE* accepted_instance = (ACCEPTED_INSTANCE*)amqpalloc_malloc(sizeof(ACCEPTED_INSTANCE));
13184     if (accepted_instance != NULL)
13185     {
13186         accepted_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(36);
13187         if (accepted_instance->composite_value == NULL)
13188         {
13189             amqpalloc_free(accepted_instance);
13190             accepted_instance = NULL;
13191         }
13192     }
13193 
13194     return accepted_instance;
13195 }
13196 
13197 ACCEPTED_HANDLE accepted_clone(ACCEPTED_HANDLE value)
13198 {
13199     ACCEPTED_INSTANCE* accepted_instance = (ACCEPTED_INSTANCE*)amqpalloc_malloc(sizeof(ACCEPTED_INSTANCE));
13200     if (accepted_instance != NULL)
13201     {
13202         accepted_instance->composite_value = amqpvalue_clone(((ACCEPTED_INSTANCE*)value)->composite_value);
13203         if (accepted_instance->composite_value == NULL)
13204         {
13205             amqpalloc_free(accepted_instance);
13206             accepted_instance = NULL;
13207         }
13208     }
13209 
13210     return accepted_instance;
13211 }
13212 
13213 void accepted_destroy(ACCEPTED_HANDLE accepted)
13214 {
13215     if (accepted != NULL)
13216     {
13217         ACCEPTED_INSTANCE* accepted_instance = (ACCEPTED_INSTANCE*)accepted;
13218         amqpvalue_destroy(accepted_instance->composite_value);
13219         amqpalloc_free(accepted_instance);
13220     }
13221 }
13222 
13223 AMQP_VALUE amqpvalue_create_accepted(ACCEPTED_HANDLE accepted)
13224 {
13225     AMQP_VALUE result;
13226 
13227     if (accepted == NULL)
13228     {
13229         result = NULL;
13230     }
13231     else
13232     {
13233         ACCEPTED_INSTANCE* accepted_instance = (ACCEPTED_INSTANCE*)accepted;
13234         result = amqpvalue_clone(accepted_instance->composite_value);
13235     }
13236 
13237     return result;
13238 }
13239 
13240 bool is_accepted_type_by_descriptor(AMQP_VALUE descriptor)
13241 {
13242     bool result;
13243 
13244     uint64_t descriptor_ulong;
13245     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
13246         (descriptor_ulong == 36))
13247     {
13248         result = true;
13249     }
13250     else
13251     {
13252         result = false;
13253     }
13254 
13255     return result;
13256 }
13257 
13258 
13259 int amqpvalue_get_accepted(AMQP_VALUE value, ACCEPTED_HANDLE* accepted_handle)
13260 {
13261     int result;
13262     ACCEPTED_INSTANCE* accepted_instance = (ACCEPTED_INSTANCE*)accepted_create_internal();
13263     *accepted_handle = accepted_instance;
13264     if (*accepted_handle == NULL)
13265     {
13266         result = __LINE__;
13267     }
13268     else
13269     {
13270         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
13271         if (list_value == NULL)
13272         {
13273             accepted_destroy(*accepted_handle);
13274             result = __LINE__;
13275         }
13276         else
13277         {
13278             do
13279             {
13280 
13281                 accepted_instance->composite_value = amqpvalue_clone(value);
13282 
13283                 result = 0;
13284             } while (0);
13285         }
13286     }
13287 
13288     return result;
13289 }
13290 
13291 
13292 /* rejected */
13293 
13294 typedef struct REJECTED_INSTANCE_TAG
13295 {
13296     AMQP_VALUE composite_value;
13297 } REJECTED_INSTANCE;
13298 
13299 static REJECTED_HANDLE rejected_create_internal(void)
13300 {
13301     REJECTED_INSTANCE* rejected_instance = (REJECTED_INSTANCE*)amqpalloc_malloc(sizeof(REJECTED_INSTANCE));
13302     if (rejected_instance != NULL)
13303     {
13304         rejected_instance->composite_value = NULL;
13305     }
13306 
13307     return rejected_instance;
13308 }
13309 
13310 REJECTED_HANDLE rejected_create(void)
13311 {
13312     REJECTED_INSTANCE* rejected_instance = (REJECTED_INSTANCE*)amqpalloc_malloc(sizeof(REJECTED_INSTANCE));
13313     if (rejected_instance != NULL)
13314     {
13315         rejected_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(37);
13316         if (rejected_instance->composite_value == NULL)
13317         {
13318             amqpalloc_free(rejected_instance);
13319             rejected_instance = NULL;
13320         }
13321     }
13322 
13323     return rejected_instance;
13324 }
13325 
13326 REJECTED_HANDLE rejected_clone(REJECTED_HANDLE value)
13327 {
13328     REJECTED_INSTANCE* rejected_instance = (REJECTED_INSTANCE*)amqpalloc_malloc(sizeof(REJECTED_INSTANCE));
13329     if (rejected_instance != NULL)
13330     {
13331         rejected_instance->composite_value = amqpvalue_clone(((REJECTED_INSTANCE*)value)->composite_value);
13332         if (rejected_instance->composite_value == NULL)
13333         {
13334             amqpalloc_free(rejected_instance);
13335             rejected_instance = NULL;
13336         }
13337     }
13338 
13339     return rejected_instance;
13340 }
13341 
13342 void rejected_destroy(REJECTED_HANDLE rejected)
13343 {
13344     if (rejected != NULL)
13345     {
13346         REJECTED_INSTANCE* rejected_instance = (REJECTED_INSTANCE*)rejected;
13347         amqpvalue_destroy(rejected_instance->composite_value);
13348         amqpalloc_free(rejected_instance);
13349     }
13350 }
13351 
13352 AMQP_VALUE amqpvalue_create_rejected(REJECTED_HANDLE rejected)
13353 {
13354     AMQP_VALUE result;
13355 
13356     if (rejected == NULL)
13357     {
13358         result = NULL;
13359     }
13360     else
13361     {
13362         REJECTED_INSTANCE* rejected_instance = (REJECTED_INSTANCE*)rejected;
13363         result = amqpvalue_clone(rejected_instance->composite_value);
13364     }
13365 
13366     return result;
13367 }
13368 
13369 bool is_rejected_type_by_descriptor(AMQP_VALUE descriptor)
13370 {
13371     bool result;
13372 
13373     uint64_t descriptor_ulong;
13374     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
13375         (descriptor_ulong == 37))
13376     {
13377         result = true;
13378     }
13379     else
13380     {
13381         result = false;
13382     }
13383 
13384     return result;
13385 }
13386 
13387 
13388 int amqpvalue_get_rejected(AMQP_VALUE value, REJECTED_HANDLE* rejected_handle)
13389 {
13390     int result;
13391     REJECTED_INSTANCE* rejected_instance = (REJECTED_INSTANCE*)rejected_create_internal();
13392     *rejected_handle = rejected_instance;
13393     if (*rejected_handle == NULL)
13394     {
13395         result = __LINE__;
13396     }
13397     else
13398     {
13399         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
13400         if (list_value == NULL)
13401         {
13402             rejected_destroy(*rejected_handle);
13403             result = __LINE__;
13404         }
13405         else
13406         {
13407             do
13408             {
13409                 AMQP_VALUE item_value;
13410                 /* error */
13411                 item_value = amqpvalue_get_list_item(list_value, 0);
13412                 if (item_value == NULL)
13413                 {
13414                     /* do nothing */
13415                 }
13416                 else
13417                 {
13418                     ERROR_HANDLE error;
13419                     if (amqpvalue_get_error(item_value, &error) != 0)
13420                     {
13421                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
13422                         {
13423                             rejected_destroy(*rejected_handle);
13424                             result = __LINE__;
13425                             break;
13426                         }
13427                     }
13428 
13429                     amqpvalue_destroy(item_value);
13430                 }
13431 
13432                 rejected_instance->composite_value = amqpvalue_clone(value);
13433 
13434                 result = 0;
13435             } while (0);
13436         }
13437     }
13438 
13439     return result;
13440 }
13441 
13442 int rejected_get_error(REJECTED_HANDLE rejected, ERROR_HANDLE* error_value)
13443 {
13444     int result;
13445 
13446     if (rejected == NULL)
13447     {
13448         result = __LINE__;
13449     }
13450     else
13451     {
13452         REJECTED_INSTANCE* rejected_instance = (REJECTED_INSTANCE*)rejected;
13453         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(rejected_instance->composite_value, 0);
13454         if (item_value == NULL)
13455         {
13456             result = __LINE__;
13457         }
13458         else
13459         {
13460             if (amqpvalue_get_error(item_value, error_value) != 0)
13461             {
13462                 result = __LINE__;
13463             }
13464             else
13465             {
13466                 result = 0;
13467             }
13468         }
13469     }
13470 
13471     return result;
13472 }
13473 
13474 int rejected_set_error(REJECTED_HANDLE rejected, ERROR_HANDLE error_value)
13475 {
13476     int result;
13477 
13478     if (rejected == NULL)
13479     {
13480         result = __LINE__;
13481     }
13482     else
13483     {
13484         REJECTED_INSTANCE* rejected_instance = (REJECTED_INSTANCE*)rejected;
13485         AMQP_VALUE error_amqp_value = amqpvalue_create_error(error_value);
13486         if (error_amqp_value == NULL)
13487         {
13488             result = __LINE__;
13489         }
13490         else
13491         {
13492             if (amqpvalue_set_composite_item(rejected_instance->composite_value, 0, error_amqp_value) != 0)
13493             {
13494                 result = __LINE__;
13495             }
13496             else
13497             {
13498                 result = 0;
13499             }
13500 
13501             amqpvalue_destroy(error_amqp_value);
13502         }
13503     }
13504 
13505     return result;
13506 }
13507 
13508 
13509 /* released */
13510 
13511 typedef struct RELEASED_INSTANCE_TAG
13512 {
13513     AMQP_VALUE composite_value;
13514 } RELEASED_INSTANCE;
13515 
13516 static RELEASED_HANDLE released_create_internal(void)
13517 {
13518     RELEASED_INSTANCE* released_instance = (RELEASED_INSTANCE*)amqpalloc_malloc(sizeof(RELEASED_INSTANCE));
13519     if (released_instance != NULL)
13520     {
13521         released_instance->composite_value = NULL;
13522     }
13523 
13524     return released_instance;
13525 }
13526 
13527 RELEASED_HANDLE released_create(void)
13528 {
13529     RELEASED_INSTANCE* released_instance = (RELEASED_INSTANCE*)amqpalloc_malloc(sizeof(RELEASED_INSTANCE));
13530     if (released_instance != NULL)
13531     {
13532         released_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(38);
13533         if (released_instance->composite_value == NULL)
13534         {
13535             amqpalloc_free(released_instance);
13536             released_instance = NULL;
13537         }
13538     }
13539 
13540     return released_instance;
13541 }
13542 
13543 RELEASED_HANDLE released_clone(RELEASED_HANDLE value)
13544 {
13545     RELEASED_INSTANCE* released_instance = (RELEASED_INSTANCE*)amqpalloc_malloc(sizeof(RELEASED_INSTANCE));
13546     if (released_instance != NULL)
13547     {
13548         released_instance->composite_value = amqpvalue_clone(((RELEASED_INSTANCE*)value)->composite_value);
13549         if (released_instance->composite_value == NULL)
13550         {
13551             amqpalloc_free(released_instance);
13552             released_instance = NULL;
13553         }
13554     }
13555 
13556     return released_instance;
13557 }
13558 
13559 void released_destroy(RELEASED_HANDLE released)
13560 {
13561     if (released != NULL)
13562     {
13563         RELEASED_INSTANCE* released_instance = (RELEASED_INSTANCE*)released;
13564         amqpvalue_destroy(released_instance->composite_value);
13565         amqpalloc_free(released_instance);
13566     }
13567 }
13568 
13569 AMQP_VALUE amqpvalue_create_released(RELEASED_HANDLE released)
13570 {
13571     AMQP_VALUE result;
13572 
13573     if (released == NULL)
13574     {
13575         result = NULL;
13576     }
13577     else
13578     {
13579         RELEASED_INSTANCE* released_instance = (RELEASED_INSTANCE*)released;
13580         result = amqpvalue_clone(released_instance->composite_value);
13581     }
13582 
13583     return result;
13584 }
13585 
13586 bool is_released_type_by_descriptor(AMQP_VALUE descriptor)
13587 {
13588     bool result;
13589 
13590     uint64_t descriptor_ulong;
13591     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
13592         (descriptor_ulong == 38))
13593     {
13594         result = true;
13595     }
13596     else
13597     {
13598         result = false;
13599     }
13600 
13601     return result;
13602 }
13603 
13604 
13605 int amqpvalue_get_released(AMQP_VALUE value, RELEASED_HANDLE* released_handle)
13606 {
13607     int result;
13608     RELEASED_INSTANCE* released_instance = (RELEASED_INSTANCE*)released_create_internal();
13609     *released_handle = released_instance;
13610     if (*released_handle == NULL)
13611     {
13612         result = __LINE__;
13613     }
13614     else
13615     {
13616         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
13617         if (list_value == NULL)
13618         {
13619             released_destroy(*released_handle);
13620             result = __LINE__;
13621         }
13622         else
13623         {
13624             do
13625             {
13626 
13627                 released_instance->composite_value = amqpvalue_clone(value);
13628 
13629                 result = 0;
13630             } while (0);
13631         }
13632     }
13633 
13634     return result;
13635 }
13636 
13637 
13638 /* modified */
13639 
13640 typedef struct MODIFIED_INSTANCE_TAG
13641 {
13642     AMQP_VALUE composite_value;
13643 } MODIFIED_INSTANCE;
13644 
13645 static MODIFIED_HANDLE modified_create_internal(void)
13646 {
13647     MODIFIED_INSTANCE* modified_instance = (MODIFIED_INSTANCE*)amqpalloc_malloc(sizeof(MODIFIED_INSTANCE));
13648     if (modified_instance != NULL)
13649     {
13650         modified_instance->composite_value = NULL;
13651     }
13652 
13653     return modified_instance;
13654 }
13655 
13656 MODIFIED_HANDLE modified_create(void)
13657 {
13658     MODIFIED_INSTANCE* modified_instance = (MODIFIED_INSTANCE*)amqpalloc_malloc(sizeof(MODIFIED_INSTANCE));
13659     if (modified_instance != NULL)
13660     {
13661         modified_instance->composite_value = amqpvalue_create_composite_with_ulong_descriptor(39);
13662         if (modified_instance->composite_value == NULL)
13663         {
13664             amqpalloc_free(modified_instance);
13665             modified_instance = NULL;
13666         }
13667     }
13668 
13669     return modified_instance;
13670 }
13671 
13672 MODIFIED_HANDLE modified_clone(MODIFIED_HANDLE value)
13673 {
13674     MODIFIED_INSTANCE* modified_instance = (MODIFIED_INSTANCE*)amqpalloc_malloc(sizeof(MODIFIED_INSTANCE));
13675     if (modified_instance != NULL)
13676     {
13677         modified_instance->composite_value = amqpvalue_clone(((MODIFIED_INSTANCE*)value)->composite_value);
13678         if (modified_instance->composite_value == NULL)
13679         {
13680             amqpalloc_free(modified_instance);
13681             modified_instance = NULL;
13682         }
13683     }
13684 
13685     return modified_instance;
13686 }
13687 
13688 void modified_destroy(MODIFIED_HANDLE modified)
13689 {
13690     if (modified != NULL)
13691     {
13692         MODIFIED_INSTANCE* modified_instance = (MODIFIED_INSTANCE*)modified;
13693         amqpvalue_destroy(modified_instance->composite_value);
13694         amqpalloc_free(modified_instance);
13695     }
13696 }
13697 
13698 AMQP_VALUE amqpvalue_create_modified(MODIFIED_HANDLE modified)
13699 {
13700     AMQP_VALUE result;
13701 
13702     if (modified == NULL)
13703     {
13704         result = NULL;
13705     }
13706     else
13707     {
13708         MODIFIED_INSTANCE* modified_instance = (MODIFIED_INSTANCE*)modified;
13709         result = amqpvalue_clone(modified_instance->composite_value);
13710     }
13711 
13712     return result;
13713 }
13714 
13715 bool is_modified_type_by_descriptor(AMQP_VALUE descriptor)
13716 {
13717     bool result;
13718 
13719     uint64_t descriptor_ulong;
13720     if ((amqpvalue_get_ulong(descriptor, &descriptor_ulong) == 0) &&
13721         (descriptor_ulong == 39))
13722     {
13723         result = true;
13724     }
13725     else
13726     {
13727         result = false;
13728     }
13729 
13730     return result;
13731 }
13732 
13733 
13734 int amqpvalue_get_modified(AMQP_VALUE value, MODIFIED_HANDLE* modified_handle)
13735 {
13736     int result;
13737     MODIFIED_INSTANCE* modified_instance = (MODIFIED_INSTANCE*)modified_create_internal();
13738     *modified_handle = modified_instance;
13739     if (*modified_handle == NULL)
13740     {
13741         result = __LINE__;
13742     }
13743     else
13744     {
13745         AMQP_VALUE list_value = amqpvalue_get_inplace_described_value(value);
13746         if (list_value == NULL)
13747         {
13748             modified_destroy(*modified_handle);
13749             result = __LINE__;
13750         }
13751         else
13752         {
13753             do
13754             {
13755                 AMQP_VALUE item_value;
13756                 /* delivery-failed */
13757                 item_value = amqpvalue_get_list_item(list_value, 0);
13758                 if (item_value == NULL)
13759                 {
13760                     /* do nothing */
13761                 }
13762                 else
13763                 {
13764                     bool delivery_failed;
13765                     if (amqpvalue_get_boolean(item_value, &delivery_failed) != 0)
13766                     {
13767                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
13768                         {
13769                             modified_destroy(*modified_handle);
13770                             result = __LINE__;
13771                             break;
13772                         }
13773                     }
13774 
13775                     amqpvalue_destroy(item_value);
13776                 }
13777                 /* undeliverable-here */
13778                 item_value = amqpvalue_get_list_item(list_value, 1);
13779                 if (item_value == NULL)
13780                 {
13781                     /* do nothing */
13782                 }
13783                 else
13784                 {
13785                     bool undeliverable_here;
13786                     if (amqpvalue_get_boolean(item_value, &undeliverable_here) != 0)
13787                     {
13788                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
13789                         {
13790                             modified_destroy(*modified_handle);
13791                             result = __LINE__;
13792                             break;
13793                         }
13794                     }
13795 
13796                     amqpvalue_destroy(item_value);
13797                 }
13798                 /* message-annotations */
13799                 item_value = amqpvalue_get_list_item(list_value, 2);
13800                 if (item_value == NULL)
13801                 {
13802                     /* do nothing */
13803                 }
13804                 else
13805                 {
13806                     fields message_annotations;
13807                     if (amqpvalue_get_fields(item_value, &message_annotations) != 0)
13808                     {
13809                         if (amqpvalue_get_type(item_value) != AMQP_TYPE_NULL)
13810                         {
13811                             modified_destroy(*modified_handle);
13812                             result = __LINE__;
13813                             break;
13814                         }
13815                     }
13816 
13817                     amqpvalue_destroy(item_value);
13818                 }
13819 
13820                 modified_instance->composite_value = amqpvalue_clone(value);
13821 
13822                 result = 0;
13823             } while (0);
13824         }
13825     }
13826 
13827     return result;
13828 }
13829 
13830 int modified_get_delivery_failed(MODIFIED_HANDLE modified, bool* delivery_failed_value)
13831 {
13832     int result;
13833 
13834     if (modified == NULL)
13835     {
13836         result = __LINE__;
13837     }
13838     else
13839     {
13840         MODIFIED_INSTANCE* modified_instance = (MODIFIED_INSTANCE*)modified;
13841         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(modified_instance->composite_value, 0);
13842         if (item_value == NULL)
13843         {
13844             result = __LINE__;
13845         }
13846         else
13847         {
13848             if (amqpvalue_get_boolean(item_value, delivery_failed_value) != 0)
13849             {
13850                 result = __LINE__;
13851             }
13852             else
13853             {
13854                 result = 0;
13855             }
13856         }
13857     }
13858 
13859     return result;
13860 }
13861 
13862 int modified_set_delivery_failed(MODIFIED_HANDLE modified, bool delivery_failed_value)
13863 {
13864     int result;
13865 
13866     if (modified == NULL)
13867     {
13868         result = __LINE__;
13869     }
13870     else
13871     {
13872         MODIFIED_INSTANCE* modified_instance = (MODIFIED_INSTANCE*)modified;
13873         AMQP_VALUE delivery_failed_amqp_value = amqpvalue_create_boolean(delivery_failed_value);
13874         if (delivery_failed_amqp_value == NULL)
13875         {
13876             result = __LINE__;
13877         }
13878         else
13879         {
13880             if (amqpvalue_set_composite_item(modified_instance->composite_value, 0, delivery_failed_amqp_value) != 0)
13881             {
13882                 result = __LINE__;
13883             }
13884             else
13885             {
13886                 result = 0;
13887             }
13888 
13889             amqpvalue_destroy(delivery_failed_amqp_value);
13890         }
13891     }
13892 
13893     return result;
13894 }
13895 
13896 int modified_get_undeliverable_here(MODIFIED_HANDLE modified, bool* undeliverable_here_value)
13897 {
13898     int result;
13899 
13900     if (modified == NULL)
13901     {
13902         result = __LINE__;
13903     }
13904     else
13905     {
13906         MODIFIED_INSTANCE* modified_instance = (MODIFIED_INSTANCE*)modified;
13907         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(modified_instance->composite_value, 1);
13908         if (item_value == NULL)
13909         {
13910             result = __LINE__;
13911         }
13912         else
13913         {
13914             if (amqpvalue_get_boolean(item_value, undeliverable_here_value) != 0)
13915             {
13916                 result = __LINE__;
13917             }
13918             else
13919             {
13920                 result = 0;
13921             }
13922         }
13923     }
13924 
13925     return result;
13926 }
13927 
13928 int modified_set_undeliverable_here(MODIFIED_HANDLE modified, bool undeliverable_here_value)
13929 {
13930     int result;
13931 
13932     if (modified == NULL)
13933     {
13934         result = __LINE__;
13935     }
13936     else
13937     {
13938         MODIFIED_INSTANCE* modified_instance = (MODIFIED_INSTANCE*)modified;
13939         AMQP_VALUE undeliverable_here_amqp_value = amqpvalue_create_boolean(undeliverable_here_value);
13940         if (undeliverable_here_amqp_value == NULL)
13941         {
13942             result = __LINE__;
13943         }
13944         else
13945         {
13946             if (amqpvalue_set_composite_item(modified_instance->composite_value, 1, undeliverable_here_amqp_value) != 0)
13947             {
13948                 result = __LINE__;
13949             }
13950             else
13951             {
13952                 result = 0;
13953             }
13954 
13955             amqpvalue_destroy(undeliverable_here_amqp_value);
13956         }
13957     }
13958 
13959     return result;
13960 }
13961 
13962 int modified_get_message_annotations(MODIFIED_HANDLE modified, fields* message_annotations_value)
13963 {
13964     int result;
13965 
13966     if (modified == NULL)
13967     {
13968         result = __LINE__;
13969     }
13970     else
13971     {
13972         MODIFIED_INSTANCE* modified_instance = (MODIFIED_INSTANCE*)modified;
13973         AMQP_VALUE item_value = amqpvalue_get_composite_item_in_place(modified_instance->composite_value, 2);
13974         if (item_value == NULL)
13975         {
13976             result = __LINE__;
13977         }
13978         else
13979         {
13980             if (amqpvalue_get_fields(item_value, message_annotations_value) != 0)
13981             {
13982                 result = __LINE__;
13983             }
13984             else
13985             {
13986                 result = 0;
13987             }
13988         }
13989     }
13990 
13991     return result;
13992 }
13993 
13994 int modified_set_message_annotations(MODIFIED_HANDLE modified, fields message_annotations_value)
13995 {
13996     int result;
13997 
13998     if (modified == NULL)
13999     {
14000         result = __LINE__;
14001     }
14002     else
14003     {
14004         MODIFIED_INSTANCE* modified_instance = (MODIFIED_INSTANCE*)modified;
14005         AMQP_VALUE message_annotations_amqp_value = amqpvalue_create_fields(message_annotations_value);
14006         if (message_annotations_amqp_value == NULL)
14007         {
14008             result = __LINE__;
14009         }
14010         else
14011         {
14012             if (amqpvalue_set_composite_item(modified_instance->composite_value, 2, message_annotations_amqp_value) != 0)
14013             {
14014                 result = __LINE__;
14015             }
14016             else
14017             {
14018                 result = 0;
14019             }
14020 
14021             amqpvalue_destroy(message_annotations_amqp_value);
14022         }
14023     }
14024 
14025     return result;
14026 }
14027 
14028