Telecominfraproject/oopt-tai
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/oopt-tai.git synced 2026-01-27 02:21:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

*: introduce tai_attr_value_list_t

Browse Source 
tai_attr_value_list_t is a list of TAI attribute values

Signed-off-by: Wataru Ishida <ishida@nel-america.com>
This commit is contained in:
Wataru Ishida
2019-01-16 18:00:26 -08:00
committed by Wataru Ishida
parent 410769fcd8
commit d6186cfe8a
4 changed files with 142 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
inc/taitypes.h
View File

@@ -196,6 +196,19 @@ typedef struct _tai_object_map_list_t
tai_object_map_t *list;
} tai_object_map_list_t;
// Forward declaration of tai_attribute_value_t for tai_attr_value_list_t
union _tai_attribute_value_t;
typedef union _tai_attribute_value_t tai_attribute_value_t;
typedef struct _tai_attr_value_list_t
{
/** Number of attribute values in the list */
uint32_t count;
/** Attribute value list */
tai_attribute_value_t *list;
} tai_attr_value_list_t;
/**
* @brief Data Type
*
@@ -228,6 +241,7 @@ typedef union _tai_attribute_value_t
tai_u32_range_t u32range;
tai_s32_range_t s32range;
tai_object_map_list_t objmaplist;
tai_attr_value_list_t attrlist;
} tai_attribute_value_t;

39
meta/main.py
View File

@@ -44,7 +44,7 @@ class TAIDefaultValueType(Enum):
def process_type(header, type_):
ts = [v.strip('#') for v in type_.split(' ')]
t = e = v = None
t = e = v = attrlistvaluetype = None
if len(ts) == 1:
t = ts[0]
elif len(ts) == 2:
@@ -53,6 +53,20 @@ def process_type(header, type_):
e = ts[1]
elif ts[0] == 'tai_pointer_t':
t = ts[0]
elif ts[0] == 'tai_attr_value_list_t':
t = ts[0]
if ts[1] == 'tai_attr_value_list_t':
raise Exception("unsupported type format: {}".format(type_))
attrlistvaluetype = ts[1]
else:
raise Exception("unsupported type format: {}".format(type_))
elif len(ts) == 3:
if ts[0] == 'tai_attr_value_list_t':
t = ts[0]
if ts[1] == 'tai_attr_value_list_t':
raise Exception("unsupported type format: {}".format(type_))
attrlistvaluetype = ts[1]
e = ts[2]
else:
raise Exception("unsupported type format: {}".format(type_))
else:
@@ -66,10 +80,13 @@ def process_type(header, type_):
e = t
v = 's32'
if attrlistvaluetype:
attrlistvaluetype = header.attr_value_map.get(attrlistvaluetype, None)
if e and not header.get_enum(e):
raise Exception("{} not found".format(e))
return t, e, v
return t, e, v, attrlistvaluetype
def process_default_value_type(default):
@@ -126,7 +143,7 @@ class TAIAttribute(object):
self.flags = set()
# process type command
t = self.cmt['type']
self.type, self.enum_type, self.value_field = process_type(self.taiobject.taiheader, t)
self.type, self.enum_type, self.value_field, self.attrlist_value_type = process_type(self.taiobject.taiheader, t)
# process default command
self.default = self.cmt.get('default', '')
@@ -191,8 +208,13 @@ class TAIHeader(object):
return self._get_name(node, name)
def _get_name(self, node, name):
if node.displayname == name:
return node
if node.displayname == name:
# ignore forward declaration
# https://joshpeterson.github.io/identifying-a-forward-declaration-with-libclang
d = node.get_definition()
c = clang.cindex.conf.lib.clang_getNullCursor()
if d != c and d == node:
return node
for child in node.get_children():
n = self._get_name(child, name)
if n:
@@ -266,6 +288,9 @@ const tai_attr_metadata_t tai_metadata_attr_{{ typename }} = {
.attridname = "{{ typename }}",
.attridshortname = "{{ shorttypename }}",
.attrvaluetype = {{ attr_type }},
{%- if attrlist_value_type %}
.attrlistvaluetype = {{ attrlist_value_type }},
{%- endif %}
{%- if attr_flags %}
.flags = {{ attr_flags }},
{%- else %}
@@ -298,6 +323,9 @@ const tai_attr_metadata_t tai_metadata_attr_{{ typename }} = {
raise Exception("invalid attr type name: {}, obj: {}".format(typename, obj))
shorttypename = typename[len(prefix):].lower().replace('_', '-')
attr_type = 'TAI_ATTR_VALUE_TYPE_{}'.format(attr.value_field.upper())
attrlist_value_type = None
if attr.attrlist_value_type:
attrlist_value_type = 'TAI_ATTR_VALUE_TYPE_{}'.format(attr.attrlist_value_type.upper())
is_enum = 'false'
enum_meta_data = None
if attr.enum_type:
@@ -315,6 +343,7 @@ const tai_attr_metadata_t tai_metadata_attr_{{ typename }} = {
'typename': typename,
'shorttypename': shorttypename,
'attr_type': attr_type,
'attrlist_value_type': attrlist_value_type,
'attr_flags': attr_flags,
'value_field': attr.value_field,
'is_enum': is_enum,

15
meta/taimetadatatypes.h
View File

@@ -45,6 +45,11 @@
*/
typedef enum _tai_attr_value_type_t
{
/**
* @brief Attribute value is unspecified
*/
TAI_ATTR_VALUE_TYPE_UNSPECIFIED,
/**
* @brief Attribute value is bool.
*/
@@ -170,6 +175,11 @@ typedef enum _tai_attr_value_type_t
*/
TAI_ATTR_VALUE_TYPE_OBJMAPLIST,
/**
* @brief Attribute value is attr list.
*/
TAI_ATTR_VALUE_TYPE_ATTRLIST,
} tai_attr_value_type_t;
/**
@@ -475,6 +485,11 @@ typedef struct _tai_attr_metadata_t
*/
tai_attr_value_type_t attrvaluetype;
/**
* @brief Specifies internal attribute value type for attr list attribute.
*/
tai_attr_value_type_t attrlistvaluetype;
/**
* @brief Specifies flags for this attribute.
*/

132
meta/taiserialize.c
View File

@@ -553,143 +553,169 @@ int tai_deserialize_enum(
return tai_deserialize_int32(buffer, value);
}
int tai_serialize_attribute(
int tai_serialize_attribute_value(
_Out_ char *buffer,
_In_ const tai_attr_metadata_t *meta,
_In_ const tai_attribute_t *attr,
_In_ const tai_attribute_value_t *value,
_In_ const tai_serialize_option_t *option)
{
int i;
char *ptr = buffer;
if ( option == NULL || !option->valueonly ) {
if ( option != NULL && option->human ) {
ptr += sprintf(ptr, "%s | ", meta->attridshortname);
} else {
ptr += sprintf(ptr, "%s | ", meta->attridname);
}
}
tai_attr_metadata_t m = *meta;
m.attrvaluetype = meta->attrlistvaluetype;
m.attrlistvaluetype = TAI_ATTR_VALUE_TYPE_UNSPECIFIED;
switch ( meta->attrvaluetype ) {
case TAI_ATTR_VALUE_TYPE_BOOLDATA:
return tai_serialize_bool(ptr, attr->value.booldata);
return tai_serialize_bool(ptr, value->booldata);
case TAI_ATTR_VALUE_TYPE_CHARDATA:
return tai_serialize_chardata(ptr, attr->value.chardata);
return tai_serialize_chardata(ptr, value->chardata);
case TAI_ATTR_VALUE_TYPE_U8:
return tai_serialize_uint8(ptr, attr->value.u8);
return tai_serialize_uint8(ptr, value->u8);
case TAI_ATTR_VALUE_TYPE_S8:
return tai_serialize_int8(ptr, attr->value.s8);
return tai_serialize_int8(ptr, value->s8);
case TAI_ATTR_VALUE_TYPE_U16:
return tai_serialize_uint16(ptr, attr->value.u16);
return tai_serialize_uint16(ptr, value->u16);
case TAI_ATTR_VALUE_TYPE_S16:
return tai_serialize_int16(ptr, attr->value.s16);
return tai_serialize_int16(ptr, value->s16);
case TAI_ATTR_VALUE_TYPE_U32:
return tai_serialize_uint32(ptr, attr->value.u32);
return tai_serialize_uint32(ptr, value->u32);
case TAI_ATTR_VALUE_TYPE_S32:
if ( meta->isenum ) {
return tai_serialize_enum(ptr, meta->enummetadata, attr->value.s32, option);
return tai_serialize_enum(ptr, meta->enummetadata, value->s32, option);
}
return tai_serialize_int32(ptr, attr->value.s32);
return tai_serialize_int32(ptr, value->s32);
case TAI_ATTR_VALUE_TYPE_U64:
return tai_serialize_uint64(ptr, attr->value.u64);
return tai_serialize_uint64(ptr, value->u64);
case TAI_ATTR_VALUE_TYPE_S64:
return tai_serialize_int64(ptr, attr->value.s64);
return tai_serialize_int64(ptr, value->s64);
case TAI_ATTR_VALUE_TYPE_FLT:
return tai_serialize_float(ptr, attr->value.flt);
return tai_serialize_float(ptr, value->flt);
case TAI_ATTR_VALUE_TYPE_PTR:
TAI_META_LOG_WARN("pointer serialization is not implemented");
return TAI_SERIALIZE_ERROR;
case TAI_ATTR_VALUE_TYPE_OID:
return tai_serialize_object_id(ptr, attr->value.oid);
return tai_serialize_object_id(ptr, value->oid);
case TAI_ATTR_VALUE_TYPE_OBJLIST:
for ( i = 0; i < attr->value.objlist.count; i++ ) {
ptr += tai_serialize_object_id(ptr, attr->value.objlist.list[i]);
if ( i + 1 < attr->value.objlist.count ) {
for ( i = 0; i < value->objlist.count; i++ ) {
ptr += tai_serialize_object_id(ptr, value->objlist.list[i]);
if ( i + 1 < value->objlist.count ) {
ptr += sprintf(ptr, ",");
}
}
return ptr - buffer;
case TAI_ATTR_VALUE_TYPE_CHARLIST:
memcpy(ptr, attr->value.charlist.list, attr->value.charlist.count);
return ptr - buffer + attr->value.charlist.count;
memcpy(ptr, value->charlist.list, value->charlist.count);
return ptr - buffer + value->charlist.count;
case TAI_ATTR_VALUE_TYPE_U8LIST:
for ( i = 0; i < attr->value.u8list.count; i++ ) {
ptr += tai_serialize_uint8(ptr, attr->value.u8list.list[i]);
if ( i + 1 < attr->value.u8list.count ) {
for ( i = 0; i < value->u8list.count; i++ ) {
ptr += tai_serialize_uint8(ptr, value->u8list.list[i]);
if ( i + 1 < value->u8list.count ) {
ptr += sprintf(ptr, ",");
}
}
return ptr - buffer;
case TAI_ATTR_VALUE_TYPE_S8LIST:
for ( i = 0; i < attr->value.s8list.count; i++ ) {
ptr += tai_serialize_int8(ptr, attr->value.s8list.list[i]);
if ( i + 1 < attr->value.s8list.count ) {
for ( i = 0; i < value->s8list.count; i++ ) {
ptr += tai_serialize_int8(ptr, value->s8list.list[i]);
if ( i + 1 < value->s8list.count ) {
ptr += sprintf(ptr, ",");
}
}
return ptr - buffer;
case TAI_ATTR_VALUE_TYPE_U16LIST:
for ( i = 0; i < attr->value.u16list.count; i++ ) {
ptr += tai_serialize_uint16(ptr, attr->value.u16list.list[i]);
if ( i + 1 < attr->value.u16list.count ) {
for ( i = 0; i < value->u16list.count; i++ ) {
ptr += tai_serialize_uint16(ptr, value->u16list.list[i]);
if ( i + 1 < value->u16list.count ) {
ptr += sprintf(ptr, ",");
}
}
return ptr - buffer;
case TAI_ATTR_VALUE_TYPE_S16LIST:
for ( i = 0; i < attr->value.s16list.count; i++ ) {
ptr += tai_serialize_int16(ptr, attr->value.s16list.list[i]);
if ( i + 1 < attr->value.s16list.count ) {
for ( i = 0; i < value->s16list.count; i++ ) {
ptr += tai_serialize_int16(ptr, value->s16list.list[i]);
if ( i + 1 < value->s16list.count ) {
ptr += sprintf(ptr, ",");
}
}
return ptr - buffer;
case TAI_ATTR_VALUE_TYPE_U32LIST:
for ( i = 0; i < attr->value.u32list.count; i++ ) {
ptr += tai_serialize_uint32(ptr, attr->value.u32list.list[i]);
if ( i + 1 < attr->value.u32list.count ) {
for ( i = 0; i < value->u32list.count; i++ ) {
ptr += tai_serialize_uint32(ptr, value->u32list.list[i]);
if ( i + 1 < value->u32list.count ) {
ptr += sprintf(ptr, ",");
}
}
return ptr - buffer;
case TAI_ATTR_VALUE_TYPE_S32LIST:
if ( meta->isenum ) {
for ( i = 0; i < attr->value.s32list.count; i++ ) {
ptr += tai_serialize_enum(ptr, meta->enummetadata, attr->value.s32list.list[i], option);
if ( i + 1 < attr->value.s32list.count ) {
for ( i = 0; i < value->s32list.count; i++ ) {
ptr += tai_serialize_enum(ptr, meta->enummetadata, value->s32list.list[i], option);
if ( i + 1 < value->s32list.count ) {
ptr += sprintf(ptr, "|");
}
}
return ptr - buffer;
}
for ( i = 0; i < attr->value.s32list.count; i++ ) {
ptr += tai_serialize_int32(ptr, attr->value.s32list.list[i]);
if ( i + 1 < attr->value.s32list.count ) {
for ( i = 0; i < value->s32list.count; i++ ) {
ptr += tai_serialize_int32(ptr, value->s32list.list[i]);
if ( i + 1 < value->s32list.count ) {
ptr += sprintf(ptr, ",");
}
}
return ptr - buffer;
case TAI_ATTR_VALUE_TYPE_FLOATLIST:
for ( i = 0; i < attr->value.floatlist.count; i++ ) {
ptr += tai_serialize_float(ptr, attr->value.floatlist.list[i]);
if ( i + 1 < attr->value.floatlist.count ) {
for ( i = 0; i < value->floatlist.count; i++ ) {
ptr += tai_serialize_float(ptr, value->floatlist.list[i]);
if ( i + 1 < value->floatlist.count ) {
ptr += sprintf(ptr, ",");
}
}
return ptr - buffer;
case TAI_ATTR_VALUE_TYPE_U32RANGE:
ptr += sprintf(ptr, "%u..%u", attr->value.u32range.min, attr->value.u32range.max);
ptr += sprintf(ptr, "%u..%u", value->u32range.min, value->u32range.max);
return ptr - buffer;
case TAI_ATTR_VALUE_TYPE_S32RANGE:
ptr += sprintf(ptr, "%d..%d", attr->value.s32range.min, attr->value.s32range.max);
ptr += sprintf(ptr, "%d..%d", value->s32range.min, value->s32range.max);
return ptr - buffer;
case TAI_ATTR_VALUE_TYPE_OBJMAPLIST:
TAI_META_LOG_WARN("objmaplist serialization is not implemented");
return TAI_SERIALIZE_ERROR;
case TAI_ATTR_VALUE_TYPE_ATTRLIST:
for ( i = 0; i < value->attrlist.count; i++ ) {
ptr += tai_serialize_attribute_value(ptr, &m, &value->attrlist.list[i], option);
if ( i != (value->attrlist.count - 1)) {
ptr += sprintf(ptr, ", ");
}
}
return ptr - buffer;
default:
TAI_META_LOG_WARN("unknown attr value type");
}
return TAI_SERIALIZE_ERROR;
}
int tai_serialize_attribute(
_Out_ char *buffer,
_In_ const tai_attr_metadata_t *meta,
_In_ const tai_attribute_t *attr,
_In_ const tai_serialize_option_t *option)
{
char *ptr = buffer;
int count = 0;
if ( option == NULL || !option->valueonly ) {
if ( option != NULL && option->human ) {
ptr += sprintf(ptr, "%s | ", meta->attridshortname);
} else {
ptr += sprintf(ptr, "%s | ", meta->attridname);
}
count = ptr - buffer;
}
return count + tai_serialize_attribute_value(ptr, meta, &attr->value, option);
}
int tai_deserialize_attribute(
_In_ const char *buffer,
_In_ const tai_attr_metadata_t *meta,