def _generate_field_type(self, type):
type_dict = {}
unwrapped, nullable, alias = unwrap(type)
if alias:
assert False, 'alias'
if nullable:
type_dict['optional'] = self._generate_field_type(unwrapped)
return type_dict
if is_list_type(unwrapped):
type_dict['list'] = self._generate_field_type(unwrapped.data_type)
elif is_map_type(unwrapped):
if is_primitive_type(unwrapped.key_data_type):
type_dict['key'] = unwrapped.key_data_type.name
else:
assert False, 'non-primitive key'
type_dict['map'] = self._generate_field_type(
unwrapped.value_data_type)
elif is_user_defined_type(unwrapped):
type_dict["namespace"] = unwrapped.namespace.name
type_dict["datatype"] = unwrapped.name
elif is_primitive_type(unwrapped):
type_dict["primitive"] = unwrapped.name
# TODO: validators
else:
assert False, 'unexpected type'
return type_dict
def generate_top_level_data_type(self, datatype, namespace):
# type: (DataType, ApiNamespace) -> None
if is_user_defined_type(datatype):
if isinstance(datatype, Struct):
self.generate_struct_type(datatype, namespace)
elif isinstance(datatype, Union):
self.generate_union_type(datatype, namespace)
else:
print("Found new user defined type: {}".format(datatype.name))
self.emit(self.handle_data_type(datatype))
else:
self.emit(self.handle_data_type(datatype))
def fmt_type_name(self, data_type):
if is_user_defined_type(data_type):
return fmt_pascal('%s%s' %
(data_type.namespace.name, data_type.name))
else:
fmted_type = self._base_type_table.get(data_type.__class__,
'Object')
if is_list_type(data_type):
fmted_type = '[2' + self.fmt_type_name(
data_type.data_type) + ']'
return fmted_type
def handle_data_type(self, datatype):
# type: (DataType) -> Text
if isinstance(datatype, Nullable):
return "Optional[{}]".format(self.handle_data_type(datatype.data_type))
if isinstance(datatype, ListDataType):
return "List[{}]".format(self.handle_data_type(datatype.data_type))
if isinstance(datatype, Alias):
return "{}, alias of {}".format(datatype.name, self.handle_data_type(
datatype.data_type))
if is_user_defined_type(datatype):
return self.get_data_type_link(datatype.name)
return six.text_type(datatype.name)
def _generate_route_datatype(self, datatype, section):
self.emit("### {}".format(section))
while is_nullable_type(datatype) or is_list_type(datatype) or is_alias(
datatype):
datatype = datatype.data_type
if is_void_type(datatype):
self.emit("Void")
elif is_user_defined_type(datatype):
self.generate_examples(datatype, section)
self.emit(self.fmt_type_name(datatype))
self.emit(
'<LinkedTypeExplanation namespace={{"{}"}} datatype={{"{}"}} />'
.format(datatype.namespace.name, datatype.name))
self.emit("")
else:
raise Exception("Unexpected datatype %r" % datatype)
def _generate_route_datatype(self, datatype, section):
self.emit("{}Type: ".format(section))
nullable = False
while is_nullable_type(datatype) or is_alias(datatype):
datatype = datatype.data_type
if is_void_type(datatype):
self.emit(" namespace: Void")
self.emit(" datatype: Void")
elif is_list_type(datatype):
self.emit(" namespace: {}".format(
datatype.data_type.namespace.name))
self.emit(" datatype: {}[]".format(datatype.data_type.name))
self.generate_examples(datatype.data_type, section)
elif is_user_defined_type(datatype):
self.emit(" namespace: {}".format(datatype.namespace.name))
self.emit(" datatype: {}".format(datatype.name))
self.generate_examples(datatype, section)
else:
raise Exception("Unexpected datatype %r" % datatype)