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)