def parse_schema(schema_info, schema, prefix):
"""
Description: generate c language for parse json map string object
Interface: None
History: 2019-06-17
"""
required = None
if 'type' not in schema:
return handle_type_not_in_schema(schema_info, schema, prefix)
if 'object' in schema['type']:
if 'required' in schema:
required = schema['required']
return helpers.Unite(
helpers.CombinateName(prefix), 'object',
parse_properties(schema_info, \
helpers.CombinateName(""), \
schema, schema, schema_info.name.name), \
None, None, None, required)
elif 'array' in schema['type']:
item_type, _ = resolve_type(schema_info, helpers.CombinateName(""), \
schema['items'], schema['items'], schema_info.name.name)
return helpers.Unite(helpers.CombinateName(prefix), 'array', None, item_type.typ, \
item_type.children, None, item_type.required)
else:
print("Not supported type '%s'") % schema['type']
return prefix, None
def gen_type_arr_typnode(node_info, src, typ, refname):
"""
Description: generate c language for parse json map string object
Interface: None
History: 2019-06-17
"""
schema_info = node_info.schema_info
name = node_info.name
cur = node_info.cur
curfile = node_info.curfile
item_type, src = resolve_type(schema_info, name, src, cur["items"], curfile)
if typ == 'array' and typ == item_type.typ and not helpers.valid_basic_map_name(item_type.subtyp):
return helpers.Unite(name,
typ,
None,
subtyp=item_type.subtyp,
subtypobj=item_type.subtypobj,
subtypname=item_type.subtypname,
required=item_type.required, doublearray=True), src
else:
return helpers.Unite(name,
typ,
None,
subtyp=item_type.typ,
subtypobj=item_type.children,
subtypname=refname,
required=item_type.required), src
def handle_type_not_in_schema(schema_info, schema, prefix):
"""
Description: generate c language for parse json map string object
Interface: None
History: 2019-06-17
"""
required = None
if 'definitions' in schema:
return helpers.Unite( \
helpers.CombinateName("definitions"), 'definitions', \
parse_properties(schema_info, helpers.CombinateName(""), schema, schema, \
schema_info.name.name), None, None, None, None)
else:
if len(schema) > 1:
print('More than one element found in schema')
return None
value_nodes = []
for value in schema:
if 'required' in schema[value]:
required = schema[value]['required']
childrens = parse_properties(schema_info, helpers.CombinateName(""), \
schema[value], schema[value], \
schema_info.name.name)
value_node = helpers.Unite(helpers.CombinateName(prefix), \
'object', childrens, None, None, \
None, required)
value_nodes.append(value_node)
return helpers.Unite(helpers.CombinateName("definitions"), \
'definitions', value_nodes, None, None, \
None, None)
def expand(tree, structs, visited):
"""
Description: generate c language for parse json map string object
Interface: None
History: 2019-06-17
"""
if tree.children is not None:
for i in tree.children:
if tree.subtypname:
i.subtypname = "from_ref"
expand(i, structs, visited=visited)
if tree.subtypobj is not None:
for i in tree.subtypobj:
expand(i, structs, visited=visited)
if tree.typ == 'array' and helpers.valid_basic_map_name(tree.subtyp):
name = helpers.CombinateName(tree.name + "_element")
node = helpers.Unite(name, tree.subtyp, None)
expand(node, structs, visited)
id_ = "%s:%s" % (tree.name, tree.typ)
if id_ not in visited.keys():
structs.append(tree)
visited[id_] = tree
return structs
def gen_ref_arr_typnode(node_info, src, typ, refname):
"""
Description: generate c language for parse json map string object
Interface: None
History: 2019-06-17
"""
schema_info = node_info.schema_info
name = node_info.name
cur = node_info.cur
curfile = node_info.curfile
item_type, src = resolve_type(schema_info, name, src, cur["items"], curfile)
ref_file, subref = splite_ref_name(cur['items']['$ref'])
if ref_file == "":
src, dummy_subcur, subrefname = get_ref_subref(src, subref)
refname = make_ref_name(subrefname, curfile)
else:
refname = item_type.subtypname
return helpers.Unite(name,
typ,
None,
subtyp=item_type.typ,
subtypobj=item_type.children,
subtypname=refname,
required=item_type.required), src
def gen_any_arr_typnode(node_info, src, typ, refname):
"""
Description: generate c language for parse json map string object
Interface: None
History: 2019-06-17
"""
schema_info = node_info.schema_info
name = node_info.name
cur = node_info.cur
curfile = node_info.curfile
subtyp = None
subtypobj = None
required = None
anychildren = resolve_list(schema_info, name, src, cur["items"]['anyOf'], curfile)
subtyp = anychildren[0].typ
children = anychildren[0].children
subtypobj = children
refname = anychildren[0].subtypname
return helpers.Unite(name,
typ,
children,
subtyp=subtyp,
subtypobj=subtypobj,
subtypname=refname,
required=required), src
def resolve_type(schema_info, name, src, cur, curfile):
"""
Description: generate c language for parse json map string object
Interface: None
History: 2019-06-17
"""
children = None
subtyp = None
subtypobj = None
required = None
refname = None
if '$ref' in cur:
src, cur, curfile, refname = get_ref_root(schema_info, src,
cur['$ref'], curfile)
if "oneOf" in cur:
cur = cur['oneOf'][0]
if '$ref' in cur:
return resolve_type(schema_info, name, src, cur, curfile)
else:
typ = cur['type']
else:
typ = get_typ_notoneof(schema_info, src, cur, curfile)
node_info = GenerateNodeInfo(schema_info, name, cur, curfile)
if helpers.valid_basic_map_name(typ):
pass
elif typ == 'array':
return gen_arr_typnode(node_info, src, typ, refname)
elif typ == 'object' or typ == 'mapStringObject':
return gen_obj_typnode(node_info, src, typ, refname)
elif typ == 'ArrayOfStrings':
typ = 'array'
subtyp = 'string'
children = subtypobj = None
else:
if not judge_support_type(typ):
raise RuntimeError("Invalid schema type: %s" % typ)
children = None
return helpers.Unite(name,
typ,
children,
subtyp=subtyp,
subtypobj=subtypobj,
subtypname=refname,
required=required), src
def gen_type_arr_typnode(node_info, src, typ, refname):
"""
Description: generate c language for parse json map string object
Interface: None
History: 2019-06-17
"""
schema_info = node_info.schema_info
name = node_info.name
cur = node_info.cur
curfile = node_info.curfile
item_type, src = resolve_type(schema_info, name, src, cur["items"], curfile)
return helpers.Unite(name,
typ,
None,
subtyp=item_type.typ,
subtypobj=item_type.children,
subtypname=refname,
required=item_type.required), src
def gen_obj_typnode(node_info, src, typ, refname):
"""
Description: generate c language for parse json map string object
Interface: None
History: 2019-06-17
"""
schema_info = node_info.schema_info
name = node_info.name
cur = node_info.cur
curfile = node_info.curfile
children = None
subtyp = None
subtypobj = None
required = None
if 'allOf' in cur:
children = merge(
resolve_list(schema_info, name, src, cur['allOf'], curfile))
elif 'anyOf' in cur:
children = resolve_list(schema_info, name, src, cur['anyOf'], curfile)
elif 'patternProperties' in cur:
children = parse_properties(schema_info, name, src, cur, curfile)
children[0].name = children[0].name.replace('_{1,}', 'element').replace('_{2,}', \
'element')
children[0].fixname = "values"
if helpers.valid_basic_map_name(children[0].typ):
children[0].name = helpers.make_basic_map_name(children[0].typ)
else:
children = parse_properties(schema_info, name, src, cur, curfile) \
if 'properties' in cur else None
if 'required' in cur:
required = cur['required']
return helpers.Unite(name,\
typ,\
children,\
subtyp=subtyp,\
subtypobj=subtypobj,\
subtypname=refname,\
required=required), src
