/*
|
* Licensed to the Apache Software Foundation (ASF) under one
|
* or more contributor license agreements. See the NOTICE file
|
* distributed with this work for additional information
|
* regarding copyright ownership. The ASF licenses this file
|
* to you under the Apache License, Version 2.0 (the
|
* "License"); you may not use this file except in compliance
|
* with the License. You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing,
|
* software distributed under the License is distributed on an
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
* KIND, either express or implied. See the License for the
|
* specific language governing permissions and limitations
|
* under the License.
|
*/
|
|
|
#ifndef CBORATTR_H
|
#define CBORATTR_H
|
|
#include <stdbool.h>
|
#include <stdint.h>
|
#include <ctype.h>
|
#include <stdio.h>
|
#include <PanSeries.h>
|
#include "tinycbor/cbor.h"
|
|
#ifdef MYNEWT
|
#include <os/os_mbuf.h>
|
#endif
|
|
#ifdef __cplusplus
|
extern "C" {
|
#endif
|
|
/* This library wraps the tinycbor decoder with a attribute based decoder
|
* suitable for decoding a binary version of json. Specifically, the
|
* contents of the cbor contains pairs of attributes. where the attribute
|
* is a key/value pair. keys are always text strings, but values can be
|
* many different things (enumerated below) */
|
|
typedef enum CborAttrType {
|
CborAttrIntegerType = 1,
|
CborAttrUnsignedIntegerType,
|
CborAttrByteStringType,
|
CborAttrTextStringType,
|
CborAttrBooleanType,
|
CborAttrHalfFloatType,
|
CborAttrFloatType,
|
CborAttrDoubleType,
|
CborAttrArrayType,
|
CborAttrObjectType,
|
CborAttrStructObjectType,
|
CborAttrNullType,
|
} CborAttrType;
|
|
struct cbor_attr_t;
|
|
struct cbor_enum_t {
|
char *name;
|
long long int value;
|
};
|
|
struct cbor_array_t {
|
CborAttrType element_type;
|
union {
|
struct {
|
const struct cbor_attr_t *subtype;
|
char *base;
|
size_t stride;
|
} objects;
|
struct {
|
char **ptrs;
|
char *store;
|
int storelen;
|
} strings;
|
struct {
|
long long int *store;
|
} integers;
|
struct {
|
long long unsigned int *store;
|
} uintegers;
|
struct {
|
double *store;
|
} reals;
|
struct{
|
uint16_t *store;
|
} halffloats;
|
struct {
|
bool *store;
|
} booleans;
|
} arr;
|
int *count;
|
int maxlen;
|
};
|
|
struct cbor_attr_t {
|
char *attribute;
|
CborAttrType type;
|
union {
|
long long int *integer;
|
long long unsigned int *uinteger;
|
uint16_t *halffloat;
|
double *real;
|
float *fval;
|
char *string;
|
bool *boolean;
|
struct byte_string {
|
uint8_t *data;
|
size_t *len;
|
} bytestring;
|
struct cbor_array_t array;
|
size_t offset;
|
struct cbor_attr_t *obj;
|
} addr;
|
union {
|
long long int integer;
|
double real;
|
bool boolean;
|
float fval;
|
uint16_t halffloat;
|
} dflt;
|
size_t len;
|
bool nodefault;
|
};
|
|
#ifndef __ZEPHYR__
|
/** An array value to be encoded as CBOR. */
|
struct cbor_out_arr_val_t {
|
struct cbor_out_val_t *elems;
|
size_t len;
|
};
|
|
/** A single value to be encoded as CBOR. */
|
struct cbor_out_val_t {
|
/** The type of data. */
|
CborAttrType type;
|
|
/** The data value. */
|
union {
|
long long int integer;
|
long long unsigned int uinteger;
|
double real;
|
float fval;
|
uint16_t halffloat;
|
const char *string;
|
bool boolean;
|
struct {
|
const uint8_t *data;
|
size_t len;
|
} bytestring;
|
struct cbor_out_arr_val_t array;
|
struct cbor_out_attr_t *obj; /* Terminated with a type=0 entry. */
|
};
|
};
|
|
/** An object key-value pair to be encoded as CBOR. */
|
struct cbor_out_attr_t {
|
const char *attribute; /** The attribute name (key). */
|
struct cbor_out_val_t val; /** The attribute value. */
|
bool omit; /** Attribute ignored if true. */
|
};
|
#endif
|
|
/*
|
* Use the following macros to declare template initializers for
|
* CborAttrStructObjectType arrays. Writing the equivalents out by hand is
|
* error-prone.
|
*
|
* CBOR_STRUCT_OBJECT takes a structure name s, and a fieldname f in s.
|
*
|
* CBOR_STRUCT_ARRAY takes the name of a structure array, a pointer to a an
|
* initializer defining the subobject type, and the address of an integer to
|
* store the length in.
|
*/
|
#define CBORATTR_STRUCT_OBJECT(s, f) .addr.offset = offsetof(s, f)
|
#define CBORATTR_STRUCT_ARRAY(a, e, n) \
|
.addr.array.element_type = CborAttrStructObjectType, \
|
.addr.array.arr.objects.subtype = e, \
|
.addr.array.arr.objects.base = (char*)a, \
|
.addr.array.arr.objects.stride = sizeof(a[0]), \
|
.addr.array.count = n, \
|
.addr.array.maxlen = (int)(sizeof(a)/sizeof(a[0]))
|
|
#define CBORATTR_ATTR_UNNAMED (char *)(-1)
|
|
int cbor_read_object(struct CborValue *, const struct cbor_attr_t *);
|
int cbor_read_array(struct CborValue *, const struct cbor_array_t *);
|
|
int cbor_read_flat_attrs(const uint8_t *data, int len,
|
const struct cbor_attr_t *attrs);
|
#ifdef MYNEWT
|
int cbor_read_mbuf_attrs(struct os_mbuf *m, uint16_t off, uint16_t len,
|
const struct cbor_attr_t *attrs);
|
|
/**
|
* @brief Encodes a CBOR representation of the specified key-value map.
|
*
|
* @param enc The CBOR encoder to write to.
|
* @param attrs The key-value map to encode.
|
*
|
* @return 0 on success; SYS_E[...] error on failure.
|
*/
|
int cbor_write_object(struct CborEncoder *enc,
|
const struct cbor_out_attr_t *attrs);
|
|
/**
|
* @brief Encodes a CBOR representation of the specified key-value map into an
|
* msys mbuf chain.
|
*
|
* @param attrs The key-value map to encode.
|
* @param out_om On success, points to the populate mbuf chain.
|
*
|
* @return 0 on success; SYS_E[...] error on failure.
|
*/
|
int cbor_write_object_msys(const struct cbor_out_attr_t *attrs,
|
struct os_mbuf **out_om);
|
#endif
|
#ifdef __cplusplus
|
}
|
#endif
|
|
#endif /* CBORATTR_H */
|
