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])
