def eval(self): if self.operator == '+': return BasicType(self.left.eval().value + self.right.eval().value) elif self.operator == '-': return BasicType(self.left.eval().value - self.right.eval().value) elif self.operator == '*': return BasicType(self.left.eval().value * self.right.eval().value) elif self.operator == '/': return BasicType(self.left.eval().value / self.right.eval().value) elif self.operator == '%': return BasicType(self.left.eval().value % self.right.eval().value)
def from_reflected_args(reflected_args, ctor_for=None, docs=None): # type: (Any, Any, Optional[OverloadSetDoc]) -> Overload if ctor_for is not None: return_type = ctor_for else: return_type = reflected_args.method.getReturnType() return_type = BasicType.from_type(return_type) argument_types = map(BasicType.from_type, reflected_args.method.getParameterTypes()) argument_names = get_argument_names(argument_types, docs) docstring = '' if docs: overload_docs = docs.get_overload(argument_types) if overload_docs: docstring = overload_docs.javadoc argument_types = [param.type for param in overload_docs.params] return_type = get_return_type(return_type, overload_docs) return Overload(return_type=return_type, argument_types=argument_types, argument_names=argument_names, is_static=reflected_args.isStatic, docstring=docstring)
def from_beanproperty(beanproperty, name): if beanproperty.setMethod: setter_type = beanproperty.setMethod.getParameterTypes()[0] setter_type = BasicType.from_type(setter_type) else: setter_type = None if beanproperty.getMethod: getter_type = beanproperty.getMethod.getReturnType() getter_type = BasicType.from_type(getter_type) else: getter_type = None return Property(name=name, setter_type=setter_type, getter_type=getter_type)
def get_overload(self, param_types): # type: (List[BasicType]) -> Optional[MethodDoc] for overload in self.overloads_jsondoc: doc_param_types = [ BasicType.from_java(param['type_long']) for param in overload['params'] ] if self.is_matching_overload(doc_param_types, param_types): return MethodDoc(overload) return None
def from_package(package): packages = [] classes = [] for name, attr_ in get_members(package).iteritems(): if name == '__name__': continue typename = BasicType.from_type(type(attr_)).proper_name if typename == 'javapackage': packages.append(Package.from_package(attr_)) elif typename == 'java.lang.Class': try: docs = ClassDoc('{}.{}'.format(package.__name__, name)) except KeyError: docs = None classes.append(Class.from_class(attr_, docs=docs)) return Package(name=package.__name__, classes=classes, packages=packages)
def from_reflectedfield(reflectedfield, name, cls): name = name my_type = reflectedfield.field.getType() modifiers = Modifier(reflectedfield.field.getModifiers()) value_repr = None has_value = False if modifiers.is_static and modifiers.is_final: try: value = getattr(cls, name) value_repr = pretty_repr(value) has_value = True except java.lang.IllegalArgumentException: pass return Field( name=name, my_type=BasicType.from_type(my_type), modifiers=modifiers, value_repr=value_repr, has_value=has_value, )
def return_type(self): return BasicType.from_java(self.jsondoc['return']['type_long'])
def p_number(p): ''' number : INT | DOUBLE ''' p[0] = BasicType(p[1])
def p_string(p): ''' string : STRVALUE ''' p[0] = BasicType(p[1])