/**** DEPRECATED ****/
pmix_status_t pmix_bfrop_unpack_array(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_info_array_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d info arrays", *num_vals);
ptr = (pmix_info_array_t*) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: init array[%d]", i);
memset(&ptr[i], 0, sizeof(pmix_info_array_t));
/* unpack the size of this array */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_sizet(buffer, &ptr[i].size, &m, PMIX_SIZE))) {
return ret;
}
if (0 < ptr[i].size) {
ptr[i].array = (pmix_info_t*)malloc(ptr[i].size * sizeof(pmix_info_t));
m=ptr[i].size;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_value(buffer, ptr[i].array, &m, PMIX_INFO))) {
return ret;
}
}
}
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_bo(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_byte_object_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d byte_object", *num_vals);
ptr = (pmix_byte_object_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
memset(&ptr[i], 0, sizeof(pmix_byte_object_t));
/* unpack the number of bytes */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_sizet(buffer, &ptr[i].size, &m, PMIX_SIZE))) {
return ret;
}
if (0 < ptr[i].size) {
ptr[i].bytes = (char*)malloc(ptr[i].size * sizeof(char));
m=ptr[i].size;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_byte(buffer, ptr[i].bytes, &m, PMIX_BYTE))) {
return ret;
}
}
}
return PMIX_SUCCESS;
}
int pmix_bfrop_unpack_modex(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_modex_data_t *ptr;
int32_t i, n, m;
int ret;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d modex", *num_vals);
ptr = (pmix_modex_data_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
memset(&ptr[i], 0, sizeof(pmix_modex_data_t));
/* unpack the number of bytes */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_sizet(buffer, &ptr[i].size, &m, PMIX_SIZE))) {
return ret;
}
if (0 < ptr[i].size) {
ptr[i].blob = (uint8_t*)malloc(ptr[i].size * sizeof(uint8_t));
m=ptr[i].size;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_byte(buffer, ptr[i].blob, &m, PMIX_UINT8))) {
return ret;
}
}
}
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_query(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_query_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
int32_t nkeys;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d queries", *num_vals);
ptr = (pmix_query_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
PMIX_QUERY_CONSTRUCT(&ptr[i]);
/* unpack the number of keys */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_int32(buffer, &nkeys, &m, PMIX_INT32))) {
return ret;
}
if (0 < nkeys) {
/* unpack the keys */
if (NULL == (ptr[i].keys = (char**)calloc(nkeys+1, sizeof(char*)))) {
return PMIX_ERR_NOMEM;
}
/* unpack keys */
m=nkeys;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, ptr[i].keys, &m, PMIX_STRING))) {
return ret;
}
}
/* unpack the number of qualifiers */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_sizet(buffer, &ptr[i].nqual, &m, PMIX_SIZE))) {
return ret;
}
if (0 < ptr[i].nqual) {
/* unpack the qualifiers */
PMIX_INFO_CREATE(ptr[i].qualifiers, ptr[i].nqual);
m = ptr[i].nqual;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_info(buffer, ptr[i].qualifiers, &m, PMIX_INFO))) {
return ret;
}
}
}
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_buf(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_buffer_t **ptr;
int32_t i, n, m;
pmix_status_t ret;
size_t nbytes;
ptr = (pmix_buffer_t **) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
/* allocate the new object */
ptr[i] = PMIX_NEW(pmix_buffer_t);
if (NULL == ptr[i]) {
return PMIX_ERR_OUT_OF_RESOURCE;
}
/* unpack the number of bytes */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_sizet(buffer, &nbytes, &m, PMIX_SIZE))) {
return ret;
}
m = nbytes;
/* setup the buffer's data region */
if (0 < nbytes) {
ptr[i]->base_ptr = (char*)malloc(nbytes);
/* unpack the bytes */
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_byte(buffer, ptr[i]->base_ptr, &m, PMIX_BYTE))) {
return ret;
}
}
ptr[i]->pack_ptr = ptr[i]->base_ptr + m;
ptr[i]->unpack_ptr = ptr[i]->base_ptr;
ptr[i]->bytes_allocated = nbytes;
ptr[i]->bytes_used = m;
}
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_app(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_app_t *ptr;
int32_t i, k, n, m;
pmix_status_t ret;
int32_t nval;
char *tmp;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d apps", *num_vals);
ptr = (pmix_app_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
/* initialize the fields */
PMIX_APP_CONSTRUCT(&ptr[i]);
/* unpack cmd */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &ptr[i].cmd, &m, PMIX_STRING))) {
return ret;
}
/* unpack argc */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_int(buffer, &nval, &m, PMIX_INT32))) {
return ret;
}
/* unpack argv */
for (k=0; k < nval; k++) {
m=1;
tmp = NULL;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &tmp, &m, PMIX_STRING))) {
return ret;
}
if (NULL == tmp) {
return PMIX_ERROR;
}
pmix_argv_append_nosize(&ptr[i].argv, tmp);
free(tmp);
}
/* unpack env */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_int32(buffer, &nval, &m, PMIX_INT32))) {
return ret;
}
for (k=0; k < nval; k++) {
m=1;
tmp = NULL;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &tmp, &m, PMIX_STRING))) {
return ret;
}
if (NULL == tmp) {
return PMIX_ERROR;
}
pmix_argv_append_nosize(&ptr[i].env, tmp);
free(tmp);
}
/* unpack cwd */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &ptr[i].cwd, &m, PMIX_STRING))) {
return ret;
}
/* unpack maxprocs */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_int(buffer, &ptr[i].maxprocs, &m, PMIX_INT))) {
return ret;
}
/* unpack info array */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_sizet(buffer, &ptr[i].ninfo, &m, PMIX_SIZE))) {
return ret;
}
if (0 < ptr[i].ninfo) {
PMIX_INFO_CREATE(ptr[i].info, ptr[i].ninfo);
m = ptr[i].ninfo;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_info(buffer, ptr[i].info, &m, PMIX_INFO))) {
return ret;
}
}
}
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_darray(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_data_array_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
size_t nbytes;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d data arrays", *num_vals);
ptr = (pmix_data_array_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
memset(&ptr[i], 0, sizeof(pmix_data_array_t));
/* unpack the type */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_datatype(buffer, &ptr[i].type, &m, PMIX_DATA_TYPE))) {
return ret;
}
/* unpack the number of array elements */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_sizet(buffer, &ptr[i].size, &m, PMIX_SIZE))) {
return ret;
}
if (0 == ptr[i].size || PMIX_UNDEF == ptr[i].type) {
/* nothing else to do */
continue;
}
/* allocate storage for the array and unpack the array elements */
m = ptr[i].size;
switch(ptr[i].type) {
case PMIX_BOOL:
nbytes = sizeof(bool);
break;
case PMIX_BYTE:
case PMIX_INT8:
case PMIX_UINT8:
nbytes = sizeof(int8_t);
break;
case PMIX_INT16:
case PMIX_UINT16:
nbytes = sizeof(int16_t);
break;
case PMIX_INT32:
case PMIX_UINT32:
nbytes = sizeof(int32_t);
break;
case PMIX_INT64:
case PMIX_UINT64:
nbytes = sizeof(int64_t);
break;
case PMIX_STRING:
nbytes = sizeof(char*);
break;
case PMIX_SIZE:
nbytes = sizeof(size_t);
break;
case PMIX_PID:
nbytes = sizeof(pid_t);
break;
case PMIX_INT:
case PMIX_UINT:
nbytes = sizeof(int);
break;
case PMIX_FLOAT:
nbytes = sizeof(float);
break;
case PMIX_DOUBLE:
nbytes = sizeof(double);
break;
case PMIX_TIMEVAL:
nbytes = sizeof(struct timeval);
break;
case PMIX_TIME:
nbytes = sizeof(time_t);
break;
case PMIX_STATUS:
nbytes = sizeof(pmix_status_t);
break;
case PMIX_INFO:
nbytes = sizeof(pmix_info_t);
break;
case PMIX_PROC:
nbytes = sizeof(pmix_proc_t);
break;
case PMIX_BYTE_OBJECT:
case PMIX_COMPRESSED_STRING:
nbytes = sizeof(pmix_byte_object_t);
break;
case PMIX_PERSIST:
nbytes = sizeof(pmix_persistence_t);
break;
case PMIX_SCOPE:
nbytes = sizeof(pmix_scope_t);
break;
case PMIX_DATA_RANGE:
nbytes = sizeof(pmix_data_range_t);
break;
case PMIX_PROC_STATE:
nbytes = sizeof(pmix_proc_state_t);
break;
case PMIX_PROC_INFO:
nbytes = sizeof(pmix_proc_info_t);
break;
case PMIX_QUERY:
nbytes = sizeof(pmix_query_t);
default:
return PMIX_ERR_NOT_SUPPORTED;
}
if (NULL == (ptr[i].array = malloc(m * nbytes))) {
return PMIX_ERR_NOMEM;
}
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_buffer(buffer, ptr[i].array, &m, ptr[i].type))) {
return ret;
}
}
return PMIX_SUCCESS;
}
