void readVec3(CborValue *it0, Vec3 *vec3) { CborValue it1; CborValue* it = &it1; cbor_value_enter_container(it0, it); cbor_value_get_float(it, &(vec3->x)); cbor_value_advance_fixed(it); cbor_value_get_float(it, &(vec3->y)); cbor_value_advance_fixed(it); cbor_value_get_float(it, &(vec3->z)); cbor_value_advance_fixed(it); cbor_value_leave_container(it0, it); }
CborError sol_oic_decode_cbor_repr_map(CborValue *map, struct sol_vector *reprs) { struct sol_oic_repr_field *repr; CborValue value; CborError err; size_t len; if (!cbor_value_is_map(map)) return CborInvalidType; err = cbor_value_enter_container(map, &value); for (; cbor_value_is_valid(&value) && err == CborNoError; err |= cbor_value_advance(&value)) { repr = sol_vector_append(reprs); if (!repr) return CborErrorOutOfMemory; err |= cbor_value_dup_text_string(&value, (char **)&repr->key, &len, NULL); err |= cbor_value_advance(&value); switch (cbor_value_get_type(&value)) { case CborIntegerType: err |= cbor_value_get_int64(&value, &repr->v_int); repr->type = SOL_OIC_REPR_TYPE_INT; break; case CborTextStringType: err |= cbor_value_dup_text_string(&value, (char **)&repr->v_slice.data, &repr->v_slice.len, NULL); if (err != CborNoError) goto harmless; repr->type = SOL_OIC_REPR_TYPE_TEXT_STRING; break; case CborByteStringType: err |= cbor_value_dup_byte_string(&value, (uint8_t **)&repr->v_slice.data, &repr->v_slice.len, NULL); if (err != CborNoError) goto harmless; repr->type = SOL_OIC_REPR_TYPE_BYTE_STRING; break; case CborDoubleType: err |= cbor_value_get_double(&value, &repr->v_double); repr->type = SOL_OIC_REPR_TYPE_DOUBLE; break; case CborFloatType: err |= cbor_value_get_float(&value, &repr->v_float); repr->type = SOL_OIC_REPR_TYPE_FLOAT; break; case CborHalfFloatType: err |= cbor_value_get_half_float(&value, &repr->v_voidptr); repr->type = SOL_OIC_REPR_TYPE_HALF_FLOAT; break; case CborBooleanType: err |= cbor_value_get_boolean(&value, &repr->v_boolean); repr->type = SOL_OIC_REPR_TYPE_BOOLEAN; break; default: SOL_ERR("While parsing representation map, got unexpected type %d", cbor_value_get_type(&value)); if (err == CborNoError) err = CborErrorUnknownType; harmless: /* Initialize repr with harmless data so cleanup works. */ repr->v_boolean = false; repr->type = SOL_OIC_REPR_TYPE_BOOLEAN; } } return err | cbor_value_leave_container(map, &value); }
static int cbor_internal_read_object(CborValue *root_value, const struct cbor_attr_t *attrs, const struct cbor_array_t *parent, int offset) { const struct cbor_attr_t *cursor, *best_match; char attrbuf[MYNEWT_VAL(CBORATTR_MAX_SIZE) + 1]; void *lptr; CborValue cur_value; CborError err = 0; size_t len; CborType type = CborInvalidType; /* stuff fields with defaults in case they're omitted in the JSON input */ for (cursor = attrs; cursor->attribute != NULL; cursor++) { if (!cursor->nodefault) { lptr = cbor_target_address(cursor, parent, offset); if (lptr != NULL) { switch (cursor->type) { case CborAttrIntegerType: memcpy(lptr, &cursor->dflt.integer, sizeof(long long int)); break; case CborAttrUnsignedIntegerType: memcpy(lptr, &cursor->dflt.integer, sizeof(long long unsigned int)); break; case CborAttrBooleanType: memcpy(lptr, &cursor->dflt.boolean, sizeof(bool)); break; #if FLOAT_SUPPORT case CborAttrFloatType: memcpy(lptr, &cursor->dflt.fval, sizeof(float)); break; case CborAttrDoubleType: memcpy(lptr, &cursor->dflt.real, sizeof(double)); break; #endif default: break; } } } } if (cbor_value_is_map(root_value)) { err |= cbor_value_enter_container(root_value, &cur_value); } else { err |= CborErrorIllegalType; return err; } /* contains key value pairs */ while (cbor_value_is_valid(&cur_value) && !err) { /* get the attribute */ if (cbor_value_is_text_string(&cur_value)) { if (cbor_value_calculate_string_length(&cur_value, &len) == 0) { if (len > MYNEWT_VAL(CBORATTR_MAX_SIZE)) { err |= CborErrorDataTooLarge; break; } err |= cbor_value_copy_text_string(&cur_value, attrbuf, &len, NULL); } /* at least get the type of the next value so we can match the * attribute name and type for a perfect match */ err |= cbor_value_advance(&cur_value); if (cbor_value_is_valid(&cur_value)) { type = cbor_value_get_type(&cur_value); } else { err |= CborErrorIllegalType; break; } } else { attrbuf[0] = '\0'; type = cbor_value_get_type(&cur_value); } /* find this attribute in our list */ best_match = NULL; for (cursor = attrs; cursor->attribute != NULL; cursor++) { if (valid_attr_type(type, cursor->type)) { if (cursor->attribute == CBORATTR_ATTR_UNNAMED && attrbuf[0] == '\0') { best_match = cursor; } else if (strlen(cursor->attribute) == len && !memcmp(cursor->attribute, attrbuf, len)) { break; } } } if (!cursor->attribute && best_match) { cursor = best_match; } /* we found a match */ if (cursor->attribute != NULL) { lptr = cbor_target_address(cursor, parent, offset); switch (cursor->type) { case CborAttrNullType: /* nothing to do */ break; case CborAttrBooleanType: err |= cbor_value_get_boolean(&cur_value, lptr); break; case CborAttrIntegerType: err |= cbor_value_get_int64(&cur_value, lptr); break; case CborAttrUnsignedIntegerType: err |= cbor_value_get_uint64(&cur_value, lptr); break; #if FLOAT_SUPPORT case CborAttrFloatType: err |= cbor_value_get_float(&cur_value, lptr); break; case CborAttrDoubleType: err |= cbor_value_get_double(&cur_value, lptr); break; #endif case CborAttrByteStringType: { size_t len = cursor->len; err |= cbor_value_copy_byte_string(&cur_value, lptr, &len, NULL); *cursor->addr.bytestring.len = len; break; } case CborAttrTextStringType: { size_t len = cursor->len; err |= cbor_value_copy_text_string(&cur_value, lptr, &len, NULL); break; } case CborAttrArrayType: err |= cbor_read_array(&cur_value, &cursor->addr.array); continue; case CborAttrObjectType: err |= cbor_internal_read_object(&cur_value, cursor->addr.obj, NULL, 0); continue; default: err |= CborErrorIllegalType; } } cbor_value_advance(&cur_value); } if (!err) { /* that should be it for this container */ err |= cbor_value_leave_container(root_value, &cur_value); } return err; }