root/opal/mca/pmix/pmix4x/pmix/src/mca/bfrops/v12/print.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. pmix12_bfrop_print
  2. pmix12_bfrop_print_bool
  3. pmix12_bfrop_print_byte
  4. pmix12_bfrop_print_string
  5. pmix12_bfrop_print_size
  6. pmix12_bfrop_print_pid
  7. pmix12_bfrop_print_int
  8. pmix12_bfrop_print_uint
  9. pmix12_bfrop_print_uint8
  10. pmix12_bfrop_print_uint16
  11. pmix12_bfrop_print_uint32
  12. pmix12_bfrop_print_int8
  13. pmix12_bfrop_print_int16
  14. pmix12_bfrop_print_int32
  15. pmix12_bfrop_print_uint64
  16. pmix12_bfrop_print_int64
  17. pmix12_bfrop_print_float
  18. pmix12_bfrop_print_double
  19. pmix12_bfrop_print_time
  20. pmix12_bfrop_print_timeval
  21. pmix12_bfrop_print_value
  22. pmix12_bfrop_print_info
  23. pmix12_bfrop_print_pdata
  24. pmix12_bfrop_print_buf
  25. pmix12_bfrop_print_app
  26. pmix12_bfrop_print_proc
  27. pmix12_bfrop_print_kval
  28. pmix12_bfrop_print_array
  29. pmix12_bfrop_print_modex
  30. pmix12_bfrop_print_persist
  31. pmix12_bfrop_print_bo
  32. pmix12_bfrop_print_scope
  33. pmix12_bfrop_print_status
  34. pmix12_bfrop_print_ptr
  35. pmix12_bfrop_print_cmd
  36. pmix12_bfrop_print_info_directives
  37. pmix12_bfrop_print_datatype
  38. pmix12_bfrop_print_proc_state
  39. pmix12_bfrop_print_darray
  40. pmix12_bfrop_print_proc_info
  41. pmix12_bfrop_print_query
  42. pmix12_bfrop_print_rank
   1 /*
   2  * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
   3  *                         University Research and Technology
   4  *                         Corporation.  All rights reserved.
   5  * Copyright (c) 2004-2006 The University of Tennessee and The University
   6  *                         of Tennessee Research Foundation.  All rights
   7  *                         reserved.
   8  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
   9  *                         University of Stuttgart.  All rights reserved.
  10  * Copyright (c) 2004-2005 The Regents of the University of California.
  11  *                         All rights reserved.
  12  * Copyright (c) 2012      Los Alamos National Security, Inc.  All rights reserved.
  13  * Copyright (c) 2014-2017 Intel, Inc. All rights reserved.
  14  * Copyright (c) 2016      Mellanox Technologies, Inc.
  15  *                         All rights reserved.
  16  * Copyright (c) 2016      IBM Corporation.  All rights reserved.
  17  * $COPYRIGHT$
  18  *
  19  * Additional copyrights may follow
  20  *
  21  * $HEADER$
  22  */
  23 
  24 #include <src/include/pmix_config.h>
  25 
  26 #include <src/include/pmix_stdint.h>
  27 
  28 #include <stdio.h>
  29 #ifdef HAVE_TIME_H
  30 #include <time.h>
  31 #endif
  32 
  33 #include "src/mca/bfrops/base/base.h"
  34 #include "bfrop_v12.h"
  35 #include "internal.h"
  36 
  37 pmix_status_t pmix12_bfrop_print(char **output, char *prefix, void *src, pmix_data_type_t type)
  38 {
  39     pmix_bfrop_type_info_t *info;
  40 
  41     /* check for error */
  42     if (NULL == output) {
  43         return PMIX_ERR_BAD_PARAM;
  44     }
  45 
  46     /* Lookup the print function for this type and call it */
  47 
  48     if(NULL == (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(&mca_bfrops_v12_component.types, type))) {
  49         return PMIX_ERR_UNKNOWN_DATA_TYPE;
  50     }
  51 
  52     return info->odti_print_fn(output, prefix, src, type);
  53 }
  54 
  55 /*
  56  * STANDARD PRINT FUNCTIONS FOR SYSTEM TYPES
  57  */
  58 pmix_status_t pmix12_bfrop_print_bool(char **output, char *prefix, bool *src, pmix_data_type_t type)
  59 {
  60     char *prefx;
  61 
  62     /* deal with NULL prefix */
  63     if (NULL == prefix) {
  64         if (0 > asprintf(&prefx, " ")) {
  65             return PMIX_ERR_NOMEM;
  66         }
  67     }
  68     else {
  69         prefx = prefix;
  70     }
  71 
  72     /* if src is NULL, just print data type and return */
  73     if (NULL == src) {
  74         if (0 > asprintf(output, "%sData type: PMIX_BOOL\tValue: NULL pointer", prefx)) {
  75             return PMIX_ERR_NOMEM;
  76         }
  77         if (prefx != prefix) {
  78             free(prefx);
  79         }
  80         return PMIX_SUCCESS;
  81     }
  82 
  83     if (0 > asprintf(output, "%sData type: PMIX_BOOL\tValue: %s", prefix,
  84              (*src) ? "TRUE" : "FALSE")) {
  85         return PMIX_ERR_NOMEM;
  86     }
  87     if (prefx != prefix) {
  88         free(prefx);
  89     }
  90 
  91     return PMIX_SUCCESS;
  92 }
  93 
  94 pmix_status_t pmix12_bfrop_print_byte(char **output, char *prefix, uint8_t *src, pmix_data_type_t type)
  95 {
  96     char *prefx;
  97 
  98     /* deal with NULL prefix */
  99     if (NULL == prefix) {
 100         if (0 > asprintf(&prefx, " ")) {
 101             return PMIX_ERR_NOMEM;
 102         }
 103     } else {
 104         prefx = prefix;
 105     }
 106 
 107     /* if src is NULL, just print data type and return */
 108     if (NULL == src) {
 109         if (0 > asprintf(output, "%sData type: PMIX_BYTE\tValue: NULL pointer", prefx)) {
 110             return PMIX_ERR_NOMEM;
 111         }
 112         if (prefx != prefix) {
 113             free(prefx);
 114         }
 115         return PMIX_SUCCESS;
 116     }
 117 
 118     if (0 > asprintf(output, "%sData type: PMIX_BYTE\tValue: %x", prefix, *src)) {
 119         return PMIX_ERR_NOMEM;
 120     }
 121     if (prefx != prefix) {
 122         free(prefx);
 123     }
 124 
 125     return PMIX_SUCCESS;
 126 }
 127 
 128 pmix_status_t pmix12_bfrop_print_string(char **output, char *prefix, char *src, pmix_data_type_t type)
 129 {
 130     char *prefx;
 131 
 132     /* deal with NULL prefix */
 133     if (NULL == prefix) {
 134         if (0 > asprintf(&prefx, " ")) {
 135             return PMIX_ERR_NOMEM;
 136         }
 137     } else {
 138         prefx = prefix;
 139     }
 140 
 141     /* if src is NULL, just print data type and return */
 142     if (NULL == src) {
 143         if (0 > asprintf(output, "%sData type: PMIX_STRING\tValue: NULL pointer", prefx)) {
 144             return PMIX_ERR_NOMEM;
 145         }
 146         if (prefx != prefix) {
 147             free(prefx);
 148         }
 149         return PMIX_SUCCESS;
 150     }
 151 
 152     if (0 > asprintf(output, "%sData type: PMIX_STRING\tValue: %s", prefx, src)) {
 153         return PMIX_ERR_NOMEM;
 154     }
 155     if (prefx != prefix) {
 156         free(prefx);
 157     }
 158 
 159     return PMIX_SUCCESS;
 160 }
 161 
 162 pmix_status_t pmix12_bfrop_print_size(char **output, char *prefix, size_t *src, pmix_data_type_t type)
 163 {
 164     char *prefx;
 165 
 166     /* deal with NULL prefix */
 167     if (NULL == prefix) {
 168         if (0 > asprintf(&prefx, " ")) {
 169             return PMIX_ERR_NOMEM;
 170         }
 171     } else {
 172         prefx = prefix;
 173     }
 174 
 175     /* if src is NULL, just print data type and return */
 176     if (NULL == src) {
 177         if (0 > asprintf(output, "%sData type: PMIX_SIZE\tValue: NULL pointer", prefx)) {
 178             return PMIX_ERR_NOMEM;
 179         }
 180         if (prefx != prefix) {
 181             free(prefx);
 182         }
 183         return PMIX_SUCCESS;
 184     }
 185 
 186     if (0 > asprintf(output, "%sData type: PMIX_SIZE\tValue: %lu", prefx, (unsigned long) *src)) {
 187         return PMIX_ERR_NOMEM;
 188     }
 189     if (prefx != prefix) {
 190         free(prefx);
 191     }
 192 
 193     return PMIX_SUCCESS;
 194 }
 195 
 196 pmix_status_t pmix12_bfrop_print_pid(char **output, char *prefix, pid_t *src, pmix_data_type_t type)
 197 {
 198     char *prefx;
 199 
 200     /* deal with NULL prefix */
 201     if (NULL == prefix) {
 202         if (0 > asprintf(&prefx, " ")) {
 203             return PMIX_ERR_NOMEM;
 204         }
 205     } else {
 206         prefx = prefix;
 207     }
 208 
 209     /* if src is NULL, just print data type and return */
 210     if (NULL == src) {
 211         if (0 > asprintf(output, "%sData type: PMIX_PID\tValue: NULL pointer", prefx)) {
 212             return PMIX_ERR_NOMEM;
 213         }
 214         if (prefx != prefix) {
 215             free(prefx);
 216         }
 217         return PMIX_SUCCESS;
 218     }
 219 
 220     if (0 > asprintf(output, "%sData type: PMIX_PID\tValue: %lu", prefx, (unsigned long) *src)) {
 221         return PMIX_ERR_NOMEM;
 222     }
 223     if (prefx != prefix) {
 224         free(prefx);
 225     }
 226     return PMIX_SUCCESS;
 227 }
 228 
 229 pmix_status_t pmix12_bfrop_print_int(char **output, char *prefix, int *src, pmix_data_type_t type)
 230 {
 231     char *prefx;
 232 
 233     /* deal with NULL prefix */
 234     if (NULL == prefix) {
 235         if (0 > asprintf(&prefx, " ")) {
 236             return PMIX_ERR_NOMEM;
 237         }
 238     } else {
 239         prefx = prefix;
 240     }
 241 
 242     /* if src is NULL, just print data type and return */
 243     if (NULL == src) {
 244         if (0 > asprintf(output, "%sData type: PMIX_INT\tValue: NULL pointer", prefx)) {
 245             return PMIX_ERR_NOMEM;
 246         }
 247         if (prefx != prefix) {
 248             free(prefx);
 249         }
 250         return PMIX_SUCCESS;
 251     }
 252 
 253     if (0 > asprintf(output, "%sData type: PMIX_INT\tValue: %ld", prefx, (long) *src)) {
 254         return PMIX_ERR_NOMEM;
 255     }
 256     if (prefx != prefix) {
 257         free(prefx);
 258     }
 259 
 260     return PMIX_SUCCESS;
 261 }
 262 
 263 pmix_status_t pmix12_bfrop_print_uint(char **output, char *prefix, uint *src, pmix_data_type_t type)
 264 {
 265     char *prefx;
 266 
 267     /* deal with NULL prefix */
 268     if (NULL == prefix) {
 269         if (0 > asprintf(&prefx, " ")) {
 270             return PMIX_ERR_NOMEM;
 271         }
 272     } else {
 273         prefx = prefix;
 274     }
 275 
 276     /* if src is NULL, just print data type and return */
 277     if (NULL == src) {
 278         if (0 > asprintf(output, "%sData type: PMIX_UINT\tValue: NULL pointer", prefx)) {
 279             return PMIX_ERR_NOMEM;
 280         }
 281         if (prefx != prefix) {
 282             free(prefx);
 283         }
 284         return PMIX_SUCCESS;
 285     }
 286 
 287     if (0 > asprintf(output, "%sData type: PMIX_UINT\tValue: %lu", prefx, (unsigned long) *src)) {
 288         return PMIX_ERR_NOMEM;
 289     }
 290     if (prefx != prefix) {
 291         free(prefx);
 292     }
 293 
 294     return PMIX_SUCCESS;
 295 }
 296 
 297 pmix_status_t pmix12_bfrop_print_uint8(char **output, char *prefix, uint8_t *src, pmix_data_type_t type)
 298 {
 299     char *prefx;
 300 
 301     /* deal with NULL prefix */
 302     if (NULL == prefix) {
 303         if (0 > asprintf(&prefx, " ")) {
 304             return PMIX_ERR_NOMEM;
 305         }
 306     } else {
 307         prefx = prefix;
 308     }
 309 
 310     /* if src is NULL, just print data type and return */
 311     if (NULL == src) {
 312         if (0 > asprintf(output, "%sData type: PMIX_UINT8\tValue: NULL pointer", prefx)) {
 313             return PMIX_ERR_NOMEM;
 314         }
 315         if (prefx != prefix) {
 316             free(prefx);
 317         }
 318         return PMIX_SUCCESS;
 319     }
 320 
 321     if (0 > asprintf(output, "%sData type: PMIX_UINT8\tValue: %u", prefx, (unsigned int) *src)) {
 322         return PMIX_ERR_NOMEM;
 323     }
 324     if (prefx != prefix) {
 325         free(prefx);
 326     }
 327 
 328     return PMIX_SUCCESS;
 329 }
 330 
 331 pmix_status_t pmix12_bfrop_print_uint16(char **output, char *prefix, uint16_t *src, pmix_data_type_t type)
 332 {
 333     char *prefx;
 334 
 335     /* deal with NULL prefix */
 336     if (NULL == prefix) {
 337         if (0 > asprintf(&prefx, " ")) {
 338             return PMIX_ERR_NOMEM;
 339         }
 340     } else {
 341         prefx = prefix;
 342     }
 343 
 344     /* if src is NULL, just print data type and return */
 345     if (NULL == src) {
 346         if (0 > asprintf(output, "%sData type: PMIX_UINT16\tValue: NULL pointer", prefx)) {
 347             return PMIX_ERR_NOMEM;
 348         }
 349         if (prefx != prefix) {
 350             free(prefx);
 351         }
 352         return PMIX_SUCCESS;
 353     }
 354 
 355     if (0 > asprintf(output, "%sData type: PMIX_UINT16\tValue: %u", prefx, (unsigned int) *src)) {
 356         return PMIX_ERR_NOMEM;
 357     }
 358     if (prefx != prefix) {
 359         free(prefx);
 360     }
 361 
 362     return PMIX_SUCCESS;
 363 }
 364 
 365 pmix_status_t pmix12_bfrop_print_uint32(char **output, char *prefix,
 366                             uint32_t *src, pmix_data_type_t type)
 367 {
 368     char *prefx;
 369 
 370     /* deal with NULL prefix */
 371     if (NULL == prefix) {
 372         if (0 > asprintf(&prefx, " ")) {
 373             return PMIX_ERR_NOMEM;
 374         }
 375     } else {
 376         prefx = prefix;
 377     }
 378 
 379     /* if src is NULL, just print data type and return */
 380     if (NULL == src) {
 381         if (0 > asprintf(output, "%sData type: PMIX_UINT32\tValue: NULL pointer", prefx)) {
 382             return PMIX_ERR_NOMEM;
 383         }
 384         if (prefx != prefix) {
 385             free(prefx);
 386         }
 387         return PMIX_SUCCESS;
 388     }
 389 
 390     if (0 > asprintf(output, "%sData type: PMIX_UINT32\tValue: %u", prefx, (unsigned int) *src)) {
 391         return PMIX_ERR_NOMEM;
 392     }
 393     if (prefx != prefix) {
 394         free(prefx);
 395     }
 396 
 397     return PMIX_SUCCESS;
 398 }
 399 
 400 pmix_status_t pmix12_bfrop_print_int8(char **output, char *prefix,
 401                           int8_t *src, pmix_data_type_t type)
 402 {
 403     char *prefx;
 404 
 405     /* deal with NULL prefix */
 406     if (NULL == prefix) {
 407         if (0 > asprintf(&prefx, " ")) {
 408             return PMIX_ERR_NOMEM;
 409         }
 410     } else {
 411         prefx = prefix;
 412     }
 413 
 414     /* if src is NULL, just print data type and return */
 415     if (NULL == src) {
 416         if (0 > asprintf(output, "%sData type: PMIX_INT8\tValue: NULL pointer", prefx)) {
 417             return PMIX_ERR_NOMEM;
 418         }
 419         if (prefx != prefix) {
 420             free(prefx);
 421         }
 422         return PMIX_SUCCESS;
 423     }
 424 
 425     if (0 > asprintf(output, "%sData type: PMIX_INT8\tValue: %d", prefx, (int) *src)) {
 426         return PMIX_ERR_NOMEM;
 427     }
 428     if (prefx != prefix) {
 429         free(prefx);
 430     }
 431 
 432     return PMIX_SUCCESS;
 433 }
 434 
 435 pmix_status_t pmix12_bfrop_print_int16(char **output, char *prefix,
 436                            int16_t *src, pmix_data_type_t type)
 437 {
 438     char *prefx;
 439 
 440     /* deal with NULL prefix */
 441     if (NULL == prefix) {
 442         if (0 > asprintf(&prefx, " ")) {
 443             return PMIX_ERR_NOMEM;
 444         }
 445     } else {
 446         prefx = prefix;
 447     }
 448 
 449     /* if src is NULL, just print data type and return */
 450     if (NULL == src) {
 451         if (0 > asprintf(output, "%sData type: PMIX_INT16\tValue: NULL pointer", prefx)) {
 452             return PMIX_ERR_NOMEM;
 453         }
 454         if (prefx != prefix) {
 455             free(prefx);
 456         }
 457         return PMIX_SUCCESS;
 458     }
 459 
 460     if (0 > asprintf(output, "%sData type: PMIX_INT16\tValue: %d", prefx, (int) *src)) {
 461         return PMIX_ERR_NOMEM;
 462     }
 463     if (prefx != prefix) {
 464         free(prefx);
 465     }
 466 
 467     return PMIX_SUCCESS;
 468 }
 469 
 470 pmix_status_t pmix12_bfrop_print_int32(char **output, char *prefix, int32_t *src, pmix_data_type_t type)
 471 {
 472     char *prefx;
 473 
 474     /* deal with NULL prefix */
 475     if (NULL == prefix) {
 476         if (0 > asprintf(&prefx, " ")) {
 477             return PMIX_ERR_NOMEM;
 478         }
 479     } else {
 480         prefx = prefix;
 481     }
 482 
 483     /* if src is NULL, just print data type and return */
 484     if (NULL == src) {
 485         if (0 > asprintf(output, "%sData type: PMIX_INT32\tValue: NULL pointer", prefx)) {
 486             return PMIX_ERR_NOMEM;
 487         }
 488         if (prefx != prefix) {
 489             free(prefx);
 490         }
 491         return PMIX_SUCCESS;
 492     }
 493 
 494     if (0 > asprintf(output, "%sData type: PMIX_INT32\tValue: %d", prefx, (int) *src)) {
 495         return PMIX_ERR_NOMEM;
 496     }
 497     if (prefx != prefix) {
 498         free(prefx);
 499     }
 500 
 501     return PMIX_SUCCESS;
 502 }
 503 pmix_status_t pmix12_bfrop_print_uint64(char **output, char *prefix,
 504                             uint64_t *src,
 505                             pmix_data_type_t type)
 506 {
 507     char *prefx;
 508 
 509     /* deal with NULL prefix */
 510     if (NULL == prefix) {
 511         if (0 > asprintf(&prefx, " ")) {
 512             return PMIX_ERR_NOMEM;
 513         }
 514     } else {
 515         prefx = prefix;
 516     }
 517 
 518     /* if src is NULL, just print data type and return */
 519     if (NULL == src) {
 520         if (0 > asprintf(output, "%sData type: PMIX_UINT64\tValue: NULL pointer", prefx)) {
 521             return PMIX_ERR_NOMEM;
 522         }
 523         if (prefx != prefix) {
 524             free(prefx);
 525         }
 526         return PMIX_SUCCESS;
 527     }
 528 
 529     if (0 > asprintf(output, "%sData type: PMIX_UINT64\tValue: %lu", prefx, (unsigned long) *src)) {
 530         return PMIX_ERR_NOMEM;
 531     }
 532     if (prefx != prefix) {
 533         free(prefx);
 534     }
 535 
 536     return PMIX_SUCCESS;
 537 }
 538 
 539 pmix_status_t pmix12_bfrop_print_int64(char **output, char *prefix,
 540                            int64_t *src,
 541                            pmix_data_type_t type)
 542 {
 543     char *prefx;
 544 
 545     /* deal with NULL prefix */
 546     if (NULL == prefix) {
 547         if (0 > asprintf(&prefx, " ")) {
 548             return PMIX_ERR_NOMEM;
 549         }
 550     } else {
 551         prefx = prefix;
 552     }
 553 
 554     /* if src is NULL, just print data type and return */
 555     if (NULL == src) {
 556         if (0 > asprintf(output, "%sData type: PMIX_INT64\tValue: NULL pointer", prefx)) {
 557             return PMIX_ERR_NOMEM;
 558         }
 559         if (prefx != prefix) {
 560             free(prefx);
 561         }
 562         return PMIX_SUCCESS;
 563     }
 564 
 565     if (0 > asprintf(output, "%sData type: PMIX_INT64\tValue: %ld", prefx, (long) *src)) {
 566         return PMIX_ERR_NOMEM;
 567     }
 568     if (prefx != prefix) {
 569         free(prefx);
 570     }
 571 
 572     return PMIX_SUCCESS;
 573 }
 574 
 575 pmix_status_t pmix12_bfrop_print_float(char **output, char *prefix,
 576                            float *src, pmix_data_type_t type)
 577 {
 578     char *prefx;
 579 
 580     /* deal with NULL prefix */
 581     if (NULL == prefix) {
 582         if (0 > asprintf(&prefx, " ")) {
 583             return PMIX_ERR_NOMEM;
 584         }
 585     } else {
 586         prefx = prefix;
 587     }
 588 
 589     /* if src is NULL, just print data type and return */
 590     if (NULL == src) {
 591         if (0 > asprintf(output, "%sData type: PMIX_FLOAT\tValue: NULL pointer", prefx)) {
 592             return PMIX_ERR_NOMEM;
 593         }
 594         if (prefx != prefix) {
 595             free(prefx);
 596         }
 597         return PMIX_SUCCESS;
 598     }
 599 
 600     if (0 > asprintf(output, "%sData type: PMIX_FLOAT\tValue: %f", prefx, *src)) {
 601         return PMIX_ERR_NOMEM;
 602     }
 603     if (prefx != prefix) {
 604         free(prefx);
 605     }
 606 
 607     return PMIX_SUCCESS;
 608 }
 609 
 610 pmix_status_t pmix12_bfrop_print_double(char **output, char *prefix,
 611                             double *src, pmix_data_type_t type)
 612 {
 613     char *prefx;
 614 
 615     /* deal with NULL prefix */
 616     if (NULL == prefix) {
 617         if (0 > asprintf(&prefx, " ")) {
 618             return PMIX_ERR_NOMEM;
 619         }
 620     } else {
 621         prefx = prefix;
 622     }
 623 
 624     /* if src is NULL, just print data type and return */
 625     if (NULL == src) {
 626         if (0 > asprintf(output, "%sData type: PMIX_DOUBLE\tValue: NULL pointer", prefx)) {
 627             return PMIX_ERR_NOMEM;
 628         }
 629         if (prefx != prefix) {
 630             free(prefx);
 631         }
 632         return PMIX_SUCCESS;
 633     }
 634 
 635     if (0 > asprintf(output, "%sData type: PMIX_DOUBLE\tValue: %f", prefx, *src)) {
 636         return PMIX_ERR_NOMEM;
 637     }
 638     if (prefx != prefix) {
 639         free(prefx);
 640     }
 641 
 642     return PMIX_SUCCESS;
 643 }
 644 
 645 pmix_status_t pmix12_bfrop_print_time(char **output, char *prefix,
 646                           time_t *src, pmix_data_type_t type)
 647 {
 648     char *prefx;
 649     char *t;
 650 
 651     /* deal with NULL prefix */
 652     if (NULL == prefix) {
 653         if (0 > asprintf(&prefx, " ")) {
 654             return PMIX_ERR_NOMEM;
 655         }
 656     } else {
 657         prefx = prefix;
 658     }
 659 
 660     /* if src is NULL, just print data type and return */
 661     if (NULL == src) {
 662         if (0 > asprintf(output, "%sData type: PMIX_TIME\tValue: NULL pointer", prefx)) {
 663             return PMIX_ERR_NOMEM;
 664         }
 665         if (prefx != prefix) {
 666             free(prefx);
 667         }
 668         return PMIX_SUCCESS;
 669     }
 670 
 671     t = ctime(src);
 672     t[strlen(t)-1] = '\0';  // remove trailing newline
 673 
 674     if (0 > asprintf(output, "%sData type: PMIX_TIME\tValue: %s", prefx, t)) {
 675         return PMIX_ERR_NOMEM;
 676     }
 677     if (prefx != prefix) {
 678         free(prefx);
 679     }
 680 
 681     return PMIX_SUCCESS;
 682 }
 683 
 684 pmix_status_t pmix12_bfrop_print_timeval(char **output, char *prefix,
 685                              struct timeval *src, pmix_data_type_t type)
 686 {
 687     char *prefx;
 688 
 689     /* deal with NULL prefix */
 690     if (NULL == prefix) {
 691         if (0 > asprintf(&prefx, " ")) {
 692             return PMIX_ERR_NOMEM;
 693         }
 694     } else {
 695         prefx = prefix;
 696     }
 697 
 698     /* if src is NULL, just print data type and return */
 699     if (NULL == src) {
 700         if (0 > asprintf(output, "%sData type: PMIX_TIMEVAL\tValue: NULL pointer", prefx)) {
 701             return PMIX_ERR_NOMEM;
 702         }
 703         if (prefx != prefix) {
 704             free(prefx);
 705         }
 706         return PMIX_SUCCESS;
 707     }
 708 
 709     if (0 > asprintf(output, "%sData type: PMIX_TIMEVAL\tValue: %ld.%06ld", prefx,
 710                     (long)src->tv_sec, (long)src->tv_usec)) {
 711         return PMIX_ERR_NOMEM;
 712     }
 713     if (prefx != prefix) {
 714         free(prefx);
 715     }
 716 
 717     return PMIX_SUCCESS;
 718 }
 719 
 720 /* PRINT FUNCTIONS FOR GENERIC PMIX TYPES */
 721 
 722 /*
 723  * PMIX_VALUE
 724  */
 725 pmix_status_t pmix12_bfrop_print_value(char **output, char *prefix,
 726                            pmix_value_t *src, pmix_data_type_t type)
 727 {
 728     char *prefx;
 729     int rc;
 730 
 731     /* deal with NULL prefix */
 732     if (NULL == prefix) {
 733         if (0 > asprintf(&prefx, " ")) {
 734             return PMIX_ERR_NOMEM;
 735         }
 736     } else {
 737         prefx = prefix;
 738     }
 739 
 740     /* if src is NULL, just print data type and return */
 741     if (NULL == src) {
 742         if (0 > asprintf(output, "%sData type: PMIX_VALUE\tValue: NULL pointer", prefx)) {
 743             return PMIX_ERR_NOMEM;
 744         }
 745         if (prefx != prefix) {
 746             free(prefx);
 747         }
 748         return PMIX_SUCCESS;
 749     }
 750 
 751     switch (src->type) {
 752         case PMIX_BYTE:
 753         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_BYTE\tValue: %x",
 754                       prefx, src->data.byte);
 755         break;
 756         case PMIX_STRING:
 757         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_STRING\tValue: %s",
 758                       prefx, src->data.string);
 759         break;
 760         case PMIX_SIZE:
 761         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_SIZE\tValue: %lu",
 762                       prefx, (unsigned long)src->data.size);
 763         break;
 764         case PMIX_PID:
 765         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_PID\tValue: %lu",
 766                       prefx, (unsigned long)src->data.pid);
 767         break;
 768         case PMIX_INT:
 769         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_INT\tValue: %d",
 770                       prefx, src->data.integer);
 771         break;
 772         case PMIX_INT8:
 773         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_INT8\tValue: %d",
 774                       prefx, (int)src->data.int8);
 775         break;
 776         case PMIX_INT16:
 777         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_INT16\tValue: %d",
 778                       prefx, (int)src->data.int16);
 779         break;
 780         case PMIX_INT32:
 781         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_INT32\tValue: %d",
 782                       prefx, src->data.int32);
 783         break;
 784         case PMIX_INT64:
 785         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_INT64\tValue: %ld",
 786                       prefx, (long)src->data.int64);
 787         break;
 788         case PMIX_UINT:
 789         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UINT\tValue: %u",
 790                       prefx, src->data.uint);
 791         break;
 792         case PMIX_UINT8:
 793         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UINT8\tValue: %u",
 794                       prefx, (unsigned int)src->data.uint8);
 795         break;
 796         case PMIX_UINT16:
 797         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UINT16\tValue: %u",
 798                       prefx, (unsigned int)src->data.uint16);
 799         break;
 800         case PMIX_UINT32:
 801         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UINT32\tValue: %u",
 802                       prefx, src->data.uint32);
 803         break;
 804         case PMIX_UINT64:
 805         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UINT64\tValue: %lu",
 806                       prefx, (unsigned long)src->data.uint64);
 807         break;
 808         case PMIX_FLOAT:
 809         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_FLOAT\tValue: %f",
 810                       prefx, src->data.fval);
 811         break;
 812         case PMIX_DOUBLE:
 813         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_DOUBLE\tValue: %f",
 814                       prefx, src->data.dval);
 815         break;
 816         case PMIX_TIMEVAL:
 817         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_TIMEVAL\tValue: %ld.%06ld", prefx,
 818                      (long)src->data.tv.tv_sec, (long)src->data.tv.tv_usec);
 819         break;
 820 
 821         default:
 822         rc = asprintf(output, "%sPMIX_VALUE: Data type: UNKNOWN\tValue: UNPRINTABLE", prefx);
 823         break;
 824     }
 825     if (prefx != prefix) {
 826         free(prefx);
 827     }
 828     if (0 > rc) {
 829         return PMIX_ERR_NOMEM;
 830     }
 831     return PMIX_SUCCESS;
 832 }
 833 
 834 pmix_status_t pmix12_bfrop_print_info(char **output, char *prefix,
 835                           pmix_info_t *src, pmix_data_type_t type)
 836 {
 837     char *tmp;
 838     int rc;
 839 
 840     pmix12_bfrop_print_value(&tmp, NULL, &src->value, PMIX_VALUE);
 841     rc = asprintf(output, "%sKEY: %s %s", prefix, src->key,
 842                   (NULL == tmp) ? "PMIX_VALUE: NULL" : tmp);
 843     if (NULL != tmp) {
 844         free(tmp);
 845     }
 846     if (0 > rc) {
 847         return PMIX_ERR_NOMEM;
 848     }
 849     return PMIX_SUCCESS;
 850 }
 851 
 852 pmix_status_t pmix12_bfrop_print_pdata(char **output, char *prefix,
 853                           pmix_pdata_t *src, pmix_data_type_t type)
 854 {
 855     char *tmp1, *tmp2;
 856     int rc;
 857 
 858     pmix12_bfrop_print_proc(&tmp1, NULL, &src->proc, PMIX_PROC);
 859     pmix12_bfrop_print_value(&tmp2, NULL, &src->value, PMIX_VALUE);
 860     rc = asprintf(output, "%s  %s  KEY: %s %s", prefix, tmp1, src->key,
 861                  (NULL == tmp2) ? "NULL" : tmp2);
 862     if (NULL != tmp1) {
 863         free(tmp1);
 864     }
 865     if (NULL != tmp2) {
 866         free(tmp2);
 867     }
 868     if (0 > rc) {
 869         return PMIX_ERR_NOMEM;
 870     }
 871     return PMIX_SUCCESS;
 872 }
 873 
 874 pmix_status_t pmix12_bfrop_print_buf(char **output, char *prefix,
 875                          pmix_buffer_t *src, pmix_data_type_t type)
 876 {
 877     return PMIX_SUCCESS;
 878 }
 879 
 880 pmix_status_t pmix12_bfrop_print_app(char **output, char *prefix,
 881                          pmix_app_t *src, pmix_data_type_t type)
 882 {
 883     return PMIX_SUCCESS;
 884 }
 885 
 886 pmix_status_t pmix12_bfrop_print_proc(char **output, char *prefix,
 887                            pmix_proc_t *src, pmix_data_type_t type)
 888 {
 889     char *prefx;
 890 
 891     /* deal with NULL prefix */
 892     if (NULL == prefix) {
 893         if (0 > asprintf(&prefx, " ")) {
 894             return PMIX_ERR_NOMEM;
 895         }
 896     } else {
 897         prefx = prefix;
 898     }
 899 
 900     if (0 > asprintf(output, "%sPROC: %s:%d", prefx, src->nspace, src->rank)) {
 901         return PMIX_ERR_NOMEM;
 902     }
 903     return PMIX_SUCCESS;
 904 }
 905 
 906 pmix_status_t pmix12_bfrop_print_kval(char **output, char *prefix,
 907                           pmix_kval_t *src, pmix_data_type_t type)
 908 {
 909     return PMIX_SUCCESS;
 910 }
 911 
 912 pmix_status_t pmix12_bfrop_print_array(char **output, char *prefix,
 913                            pmix_info_array_t *src, pmix_data_type_t type)
 914 {
 915     size_t j;
 916     char *tmp, *tmp2, *tmp3, *pfx;
 917     pmix_info_t *s1;
 918 
 919     if (0 > asprintf(&tmp, "%sARRAY SIZE: %ld", prefix, (long)src->size)) {
 920         return PMIX_ERR_NOMEM;
 921     }
 922     if (0 > asprintf(&pfx, "\n%s\t",  (NULL == prefix) ? "" : prefix)) {
 923         free(tmp);
 924         return PMIX_ERR_NOMEM;
 925     }
 926     s1 = (pmix_info_t*)src->array;
 927 
 928     for (j=0; j < src->size; j++) {
 929         pmix12_bfrop_print_info(&tmp2, pfx, &s1[j], PMIX_INFO);
 930         if (0 > asprintf(&tmp3, "%s%s", tmp, tmp2)) {
 931             free(tmp);
 932             free(tmp2);
 933             return PMIX_ERR_NOMEM;
 934         }
 935         free(tmp);
 936         free(tmp2);
 937         tmp = tmp3;
 938     }
 939     *output = tmp;
 940     return PMIX_SUCCESS;
 941 }
 942 
 943 pmix_status_t pmix12_bfrop_print_modex(char **output, char *prefix,
 944                            pmix_modex_data_t *src, pmix_data_type_t type)
 945 {
 946     return PMIX_SUCCESS;
 947 }
 948 
 949 pmix_status_t pmix12_bfrop_print_persist(char **output, char *prefix, pmix_persistence_t *src, pmix_data_type_t type)
 950 {
 951     char *prefx;
 952 
 953     /* deal with NULL prefix */
 954     if (NULL == prefix) {
 955         if (0 > asprintf(&prefx, " ")) {
 956             return PMIX_ERR_NOMEM;
 957         }
 958     } else {
 959         prefx = prefix;
 960     }
 961 
 962     /* if src is NULL, just print data type and return */
 963     if (NULL == src) {
 964         if (0 > asprintf(output, "%sData type: PMIX_PERSIST\tValue: NULL pointer", prefx)) {
 965             return PMIX_ERR_NOMEM;
 966         }
 967         if (prefx != prefix) {
 968             free(prefx);
 969         }
 970         return PMIX_SUCCESS;
 971     }
 972 
 973     if (0 > asprintf(output, "%sData type: PMIX_PERSIST\tValue: %ld", prefx, (long) *src)) {
 974         return PMIX_ERR_NOMEM;
 975     }
 976     if (prefx != prefix) {
 977         free(prefx);
 978     }
 979 
 980     return PMIX_SUCCESS;
 981 }
 982 
 983 pmix_status_t pmix12_bfrop_print_bo(char **output, char *prefix,
 984                                   pmix_byte_object_t *src, pmix_data_type_t type)
 985 {
 986     char *prefx;
 987 
 988     /* deal with NULL prefix */
 989     if (NULL == prefix) {
 990         if (0 > asprintf(&prefx, " ")) {
 991             return PMIX_ERR_NOMEM;
 992         }
 993     } else {
 994         prefx = prefix;
 995     }
 996 
 997     /* if src is NULL, just print data type and return */
 998     if (NULL == src) {
 999         if (0 > asprintf(output, "%sData type: PMIX_BYTE_OBJECT\tValue: NULL pointer", prefx)) {
1000             return PMIX_ERR_NOMEM;
1001         }
1002         if (prefx != prefix) {
1003             free(prefx);
1004         }
1005         return PMIX_SUCCESS;
1006     }
1007 
1008     if (0 > asprintf(output, "%sData type: PMIX_BYTE_OBJECT\tSize: %ld", prefx, (long)src->size)) {
1009         return PMIX_ERR_NOMEM;
1010     }
1011     if (prefx != prefix) {
1012         free(prefx);
1013     }
1014 
1015     return PMIX_SUCCESS;
1016 }
1017 
1018 pmix_status_t pmix12_bfrop_print_scope(char **output, char *prefix,
1019                                       pmix_scope_t *src, pmix_data_type_t type)
1020 {
1021     return PMIX_ERR_NOT_SUPPORTED;
1022 }
1023 
1024 pmix_status_t pmix12_bfrop_print_status(char **output, char *prefix,
1025                                        pmix_status_t *src, pmix_data_type_t type)
1026 {
1027     return PMIX_ERR_NOT_SUPPORTED;
1028 }
1029 
1030 pmix_status_t pmix12_bfrop_print_ptr(char **output, char *prefix,
1031                                     void *src, pmix_data_type_t type)
1032 {
1033     return PMIX_ERR_NOT_SUPPORTED;
1034 }
1035 
1036 pmix_status_t pmix12_bfrop_print_cmd(char **output, char *prefix,
1037                                     void *src, pmix_data_type_t type)
1038 {
1039     return PMIX_ERR_NOT_SUPPORTED;
1040 }
1041 
1042 pmix_status_t pmix12_bfrop_print_info_directives(char **output, char *prefix,
1043                                                 void *src, pmix_data_type_t type)
1044 {
1045     return PMIX_ERR_NOT_SUPPORTED;
1046 }
1047 
1048 pmix_status_t pmix12_bfrop_print_datatype(char **output, char *prefix,
1049                                          pmix_data_type_t *src, pmix_data_type_t type)
1050 {
1051     return PMIX_ERR_NOT_SUPPORTED;
1052 }
1053 
1054 pmix_status_t pmix12_bfrop_print_proc_state(char **output, char *prefix,
1055                                            pmix_data_type_t *src, pmix_data_type_t type)
1056 {
1057     return PMIX_ERR_NOT_SUPPORTED;
1058 }
1059 
1060 pmix_status_t pmix12_bfrop_print_darray(char **output, char *prefix,
1061                                        pmix_data_array_t *src, pmix_data_type_t type)
1062 {
1063     return PMIX_ERR_NOT_SUPPORTED;
1064 }
1065 
1066 pmix_status_t pmix12_bfrop_print_proc_info(char **output, char *prefix,
1067                                           pmix_proc_info_t *src, pmix_data_type_t type)
1068 {
1069     return PMIX_ERR_NOT_SUPPORTED;
1070 }
1071 
1072 pmix_status_t pmix12_bfrop_print_query(char **output, char *prefix,
1073                                       pmix_query_t *src, pmix_data_type_t type)
1074 {
1075     return PMIX_ERR_NOT_SUPPORTED;
1076 }
1077 
1078 pmix_status_t pmix12_bfrop_print_rank(char **output, char *prefix,
1079                                      pmix_rank_t *src, pmix_data_type_t type)
1080 {
1081     return PMIX_ERR_NOT_SUPPORTED;
1082 }
/* [<][>][^][v][top][bottom][index][help] */