def java_definition(self):
name = self.java_name()
parameters = [
parameter.java_parameter(final=True)
for parameter in self.parameters
]
parameters = ', '.join(parameters)
if self.return_field is not None:
return_statement = lpad(
"\n", " return %s;" %
self.return_field.type.java_default_value())
return_type_name = self.return_field.type.java_qname()
else:
return_statement = ''
return_type_name = 'void'
throws = \
lpad(
' throws ',
', '.join(field.type.java_qname()
for field in self.throws)
)
return """\
@Override
protected %(return_type_name)s _%(name)s(%(parameters)s)%(throws)s {%(return_statement)s
}""" % locals()
def _cpp_constructor_required(self):
if len(self.fields) == 0:
return None # Will be covered by default constructor
elif len(set([field.required for field in self.fields])) <= 1:
# All fields are optional or all fields are required
return None # Will be covered by total constructor
body = lpad("\n", indent(' ' * 2, self._cpp_constructor_body()))
initializers = []
name = self.cpp_name()
parameters = []
for field in self.fields:
if field.required:
initializers.append(field.cpp_initializer())
parameters.append(field.cpp_parameter())
else:
default_initializer = field.cpp_default_initializer()
if default_initializer is not None:
initializers.append(default_initializer)
initializers = \
lpad("\n : ", ', '.join(initializers))
parameters = ", ".join(parameters)
return """\
%(name)s(%(parameters)s)%(initializers)s {%(body)s
}""" % locals()
def py_add_arguments(self):
name = self.py_name()
add_arguments = []
parse_args = []
for parameter in self.parameters:
parameter_action = parameter.py_argparse_action()
parameter_name = parameter.py_argparse_name()
parameter_required = ', required=True' if parameter.py_argparse_required(
) else ''
parameter_type = ", type=%s" % parameter.py_argparse_type(
) if parameter_action == 'store' else ''
add_arguments.append(
"%(name)s_argument_parser.add_argument('--%(parameter_name)s', action='%(parameter_action)s'%(parameter_required)s%(parameter_type)s)"
% locals())
parse_args.append(parameter.py_argparse_parse())
add_arguments = lpad("\n", "\n".join(add_arguments))
call_kwds = ', '.join("%s=%s" %
(parameter.py_name(), parameter.py_name())
for parameter in self.parameters)
parse_args = lpad("\n", "\n".join(indent(' ' * 4, parse_args)))
return """\
def %(name)s(__args):%(parse_args)s
return cls().%(name)s(%(call_kwds)s)
%(name)s_argument_parser = argument_subparsers.add_parser('%(name)s')%(add_arguments)s
%(name)s_argument_parser.set_defaults(func=%(name)s)
""" % locals()
def java_definitions(self):
annotations = lpad("\n", "\n".join(self.java_annotations()))
name = self.java_name()
public_parameters = \
', '.join(parameter.java_parameter(final=True) for parameter in self.parameters)
public_parameter_names = ', '.join(
parameter.java_name() for parameter in self.parameters)
parameter_validations = []
request_type_name = self.java_request_type().java_name()
service_qname = JavaService.java_qname(self.parent)
for parameter in self.parameters:
parameter_name = parameter.java_name()
parameter_validate_method_name = parameter.java_validate_method_name(
)
parameter_validations.append(
"%(service_qname)s.Messages.%(request_type_name)s.DefaultConstructionValidator.getInstance().%(parameter_validate_method_name)s(%(parameter_name)s);"
% locals())
if len(parameter_validations) > 0:
parameter_validations = \
"\n".join(indent(' ' * 4, parameter_validations))
validate_method_name = '_validate' + upper_camelize(
self.name) + 'Parameters'
validate_method = lpad(
"\n\n", """\
protected void %(validate_method_name)s(%(public_parameters)s) {
%(parameter_validations)s
}""" % locals())
validate_method_call = lpad(
"\n",
indent(
' ' * 4, "%s(%s);" %
(validate_method_name, public_parameter_names)))
else:
validate_method = validate_method_call = ''
delegation = \
"delegate.%s(%s)" % (name, ', '.join(parameter.java_name() for parameter in self.parameters))
if self.return_field is not None:
response_type_name = self.java_response_type().java_name()
return_field_validate_method_name = self.return_field.java_validate_method_name(
)
delegation = "return %(service_qname)s.Messages.%(response_type_name)s.DefaultConstructionValidator.getInstance().%(return_field_validate_method_name)s(%(delegation)s)" % locals(
)
return_type_name = self.return_field.type.java_qname()
else:
return_type_name = 'void'
throws = \
lpad(
' throws ',
', '.join(field.type.java_qname()
for field in self.throws)
)
return [
"""\
@Override%(annotations)s
public final %(return_type_name)s %(name)s(%(public_parameters)s)%(throws)s {%(validate_method_call)s
%(delegation)s;
}%(validate_method)s
""" % locals()
] + self._java_delegating_definitions()
def _cpp_constructor_required(self):
if len(self.fields) == 0:
return None # Will be covered by default constructor
elif len(set([field.required for field in self.fields])) <= 1:
# All fields are optional or all fields are required
return None # Will be covered by total constructor
body = lpad("\n", indent(' ' * 2, self._cpp_constructor_body()))
initializers = []
name = self.cpp_name()
parameters = []
for field in self.fields:
if field.required:
initializers.append(field.cpp_initializer())
parameters.append(field.cpp_parameter())
else:
default_initializer = field.cpp_default_initializer()
if default_initializer is not None:
initializers.append(default_initializer)
initializers = \
lpad("\n : ", ', '.join(initializers))
parameters = ", ".join(parameters)
return """\
%(name)s(%(parameters)s)%(initializers)s {%(body)s
}""" % locals()
def java_repr(self):
class_annotations = []
if len(self._suppress_warnings) > 0:
class_annotations.append(
"@SuppressWarnings({%s})" % \
', '.join('"' + warning + '"'
for warning in sorted(self._suppress_warnings)))
class_annotations = rpad("\n".join(class_annotations), "\n")
class_modifiers = rpad(' '.join(self.__class_modifiers), ' ')
javadoc = self.java_doc()
name = self.java_name()
extends = lpad(' extends ', self._java_extends())
implements = lpad(' implements ', ', '.join(self._java_implements()))
methods = self._java_methods()
sections = []
sections.append(indent(' ' * 4, self._JavaBuilder(self).java_repr()))
sections.append(indent(' ' * 4, self._JavaFactory(self).java_repr()))
field_metadata_enum = self._java_field_metadata_enum()
if field_metadata_enum is not None:
sections.append(indent(' ' * 4, field_metadata_enum))
sections.append(indent(' ' * 4, self._JavaValidator(self).java_repr()))
sections.append("\n\n".join(indent(' ' * 4,
self._java_constructors() + \
[methods[key] for key in sorted(methods.iterkeys())])))
sections.append("\n\n".join(indent(' ' * 4, self._java_member_declarations())))
sections = lpad("\n", "\n\n".join(section for section in sections if len(section) > 0))
return """\
%(javadoc)s%(class_annotations)s%(class_modifiers)sclass %(name)s%(extends)s%(implements)s {%(sections)s
}""" % locals()
def __repr__(self):
class_annotations = []
if len(self.__suppress_warnings) > 0:
class_annotations.append(
"@SuppressWarnings({%s})" % \
', '.join('"' + warning + '"'
for warning in sorted(self.__suppress_warnings)))
class_annotations = rpad("\n".join(class_annotations), "\n")
class_modifiers = rpad(' '.join(self.__class_modifiers), ' ')
javadoc = self.java_doc()
name = self.java_name()
extends = lpad(' extends ', self._java_extends())
implements = lpad(' implements ', ', '.join(self._java_implements()))
methods = self._java_methods()
sections = []
sections.append(indent(' ' * 4, repr(self._JavaBuilder(self))))
sections.append("\n\n".join(indent(' ' * 4,
self._java_constructors() + \
[methods[key] for key in sorted(methods.iterkeys())])))
sections.append("\n\n".join(
indent(' ' * 4, self._java_member_declarations())))
sections = lpad(
"\n",
"\n\n".join(section for section in sections if len(section) > 0))
return """\
%(javadoc)s%(class_annotations)s%(class_modifiers)sclass %(name)s%(extends)s%(implements)s {%(sections)s
}""" % locals()
def py_repr(self):
name = self.py_name()
enumerators = []
enumerator_placeholders = []
enumerator_qnames = []
value_of_statements = []
if len(self.enumerators) > 0:
for enumerator in self.enumerators:
enumerator_name = enumerator.name
enumerator_value = enumerator.value
enumerator_placeholders.append("%(enumerator_name)s = None" %
locals())
enumerators.append(
"%(name)s.%(enumerator_name)s = %(name)s('%(enumerator_name)s', %(enumerator_value)u)"
% locals())
enumerator_qnames.append("%(name)s.%(enumerator_name)s" %
locals())
value_of_statements.append("""\
if name == '%(enumerator_name)s' or name == '%(enumerator_value)u':
return getattr(%(name)s, '%(enumerator_name)s')
""" % locals())
enumerators = \
lpad("\n\n", "\n".join(enumerators))
enumerator_qnames = ', '.join(enumerator_qnames)
enumerator_placeholders = \
pad("\n", "\n".join(indent(' ' * 4,
enumerator_placeholders
)), "\n")
value_of_statements = \
lpad("\n", indent(' ' * 8, 'el'.join(value_of_statements)))
return """\
class %(name)s(object):%(enumerator_placeholders)s
def __init__(self, name, value):
object.__init__(self)
self.__name = name
self.__value = value
def __int__(self):
return self.__value
def __repr__(self):
return self.__name
def __str__(self):
return self.__name
@classmethod
def value_of(cls, name):%(value_of_statements)s
raise ValueError(name)
@classmethod
def values(cls):
return (%(enumerator_qnames)s,)%(enumerators)s""" % locals()
def __repr__(self):
annotations = lpad("\n", "\n".join(self.java_annotations()))
name = self.java_name()
public_parameters = \
', '.join(parameter.java_parameter(final=True) for parameter in self.parameters)
public_parameter_names = ', '.join(parameter.java_name() for parameter in self.parameters)
parameter_validations = []
for parameter in self.parameters:
parameter_validation = parameter.java_validation()
if parameter_validation != parameter.java_name():
parameter_validations.append(parameter_validation + ';')
if len(parameter_validations) > 0:
parameter_validations = \
"\n".join(indent(' ' * 4, parameter_validations))
validate_method_name = '_validate' + upper_camelize(self.name) + 'Parameters'
validate_method = lpad("\n\n", """\
protected void %(validate_method_name)s(%(public_parameters)s) {
%(parameter_validations)s
}""" % locals())
validate_method_call = lpad("\n", indent(' ' * 4, "%s(%s);" % (validate_method_name, public_parameter_names)))
else:
validate_method = validate_method_call = ''
protected_parameters = [parameter.java_parameter(final=True)
for parameter in self.parameters]
protected_parameter_names = [parameter.java_name()
for parameter in self.parameters]
if self.parent.parent.parent._include_current_user:
protected_parameters.insert(0, 'org.apache.shiro.subject.Subject currentUser')
protected_parameter_names.insert(0, 'org.apache.shiro.SecurityUtils.getSubject()')
protected_delegation = \
"_%s(%s)" % (name, ', '.join(protected_parameter_names))
protected_parameters = ', '.join(protected_parameters)
if self.return_field is not None:
protected_delegation = 'return ' + self.return_field.java_validation(value=protected_delegation)
return_type_name = self.return_field.type.java_declaration_name()
else:
return_type_name = 'void'
throws = \
lpad(
' throws ',
', '.join(field.type.java_declaration_name()
for field in self.throws)
)
return """\
@Override%(annotations)s
public %(return_type_name)s %(name)s(%(public_parameters)s)%(throws)s {%(validate_method_call)s
%(protected_delegation)s;
}%(validate_method)s
protected abstract %(return_type_name)s _%(name)s(%(protected_parameters)s)%(throws)s;
""" % locals()
def py_repr(self):
name = self.py_name()
enumerators = []
enumerator_placeholders = []
enumerator_qnames = []
value_of_statements = []
if len(self.enumerators) > 0:
for enumerator in self.enumerators:
enumerator_name = enumerator.name
enumerator_value = enumerator.value
enumerator_placeholders.append("%(enumerator_name)s = None" % locals())
enumerators.append("%(name)s.%(enumerator_name)s = %(name)s('%(enumerator_name)s', %(enumerator_value)u)" % locals())
enumerator_qnames.append("%(name)s.%(enumerator_name)s" % locals())
value_of_statements.append("""\
if name == '%(enumerator_name)s' or name == '%(enumerator_value)u':
return getattr(%(name)s, '%(enumerator_name)s')
""" % locals())
enumerators = \
lpad("\n\n", "\n".join(enumerators))
enumerator_qnames = ', '.join(enumerator_qnames)
enumerator_placeholders = \
pad("\n", "\n".join(indent(' ' * 4,
enumerator_placeholders
)), "\n")
value_of_statements = \
lpad("\n", indent(' ' * 8, 'el'.join(value_of_statements)))
return """\
class %(name)s(object):%(enumerator_placeholders)s
def __init__(self, name, value):
object.__init__(self)
self.__name = name
self.__value = value
def __int__(self):
return self.__value
def __repr__(self):
return self.__name
def __str__(self):
return self.__name
@classmethod
def value_of(cls, name):%(value_of_statements)s
raise ValueError(name)
@classmethod
def values(cls):
return (%(enumerator_qnames)s,)%(enumerators)s""" % locals()
def cpp_repr(self):
name = self.cpp_name()
extends = lpad(' : public ', self._cpp_extends())
template_parameters = rpad(self._cpp_template_parameters(), "\n")
sections = []
# sections.append(indent(' ' * 4, repr(self._CppBuilder(self))))
sections.append(lpad("public:\n", "\n\n".join(indent(' ' * 2,
self._cpp_constructors() + [self._cpp_destructor()] + self._cpp_methods_list()
))))
sections.append(lpad("private:\n", "\n".join(indent(' ' * 2, self._cpp_member_declarations()))))
sections = lpad("\n", "\n\n".join(section for section in sections if len(section) > 0))
return """\
%(template_parameters)sclass %(name)s%(extends)s {%(sections)s
};""" % locals()
def _cpp_constructor_total(self):
if len(self.fields) == 0:
return None # Will be covered by default constructor
body = lpad("\n", indent(' ' * 2, self._cpp_constructor_body()))
initializers = \
lpad("\n : ", ', '.join(
(field.cpp_initializer()
for field in self.fields)
))
name = self.cpp_name()
parameters = ', '.join(field.cpp_parameter() for field in self.fields)
return """\
%(name)s(%(parameters)s)%(initializers)s {%(body)s
}""" % locals()
def _py_method_write_protocol(self):
field_write_protocols = \
lpad("\n\n", "\n\n".join(indent(' ' * 4,
(field.py_write_protocol(depth=0)
for field in self.fields)
)))
name = self.py_name()
qname = self.py_qname()
return {'write': """\
def write(self, oprot):
'''
Write this object to the given output protocol and return self.
:type oprot: thryft.protocol._output_protocol._OutputProtocol
:rtype: %(qname)s
'''
oprot.write_struct_begin('%(name)s')%(field_write_protocols)s
oprot.write_field_stop()
oprot.write_struct_end()
return self
""" % locals()}
def __java_delegation_definition(self, parameters, default=False):
if default:
default = 'default '
name = self.java_name()
if self.return_field is not None:
return_prefix = 'return '
return_type_name = self.return_field.type.java_qname()
else:
return_prefix = ''
return_type_name = 'void'
throws = \
lpad(
' throws ',
', '.join(field.type.java_qname()
for field in self.throws)
)
parameters = [parameter.java_parameter(final=True) for parameter in parameters]
delegate_values = []
for parameter_i, parameter in enumerate(self.parameters):
if parameter.required:
delegate_values.append(parameter.java_name())
elif parameter_i < len(parameters):
delegate_values.append(parameter.java_name())
else:
delegate_values.append(parameter.java_absent_value())
delegate_values = ', '.join(delegate_values)
parameters = ', '.join(parameters)
return """\
public %(default)s%(return_type_name)s %(name)s(%(parameters)s)%(throws)s {
%(return_prefix)s%(name)s(%(delegate_values)s);
}""" % locals()
def _py_method_write_protocol(self):
field_write_protocols = lpad(
"\n\n", "\n\n".join(indent(" " * 4, (field.py_write_protocol(depth=0) for field in self.fields)))
)
name = self.py_name()
qname = self.py_qname()
return {
"write": """\
def write(self, oprot):
'''
Write this object to the given output protocol and return self.
:type oprot: thryft.protocol._output_protocol._OutputProtocol
:rtype: %(qname)s
'''
oprot.write_struct_begin('%(name)s')%(field_write_protocols)s
oprot.write_field_stop()
oprot.write_struct_end()
return self
"""
% locals()
}
def sql_create_table(self):
column_definitions = []
foreign_key_definitions = []
for annotation_i, annotation in enumerate(self.annotations):
if annotation.name == 'sql_column':
column_definitions.append(annotation.value)
elif annotation.name == 'sql_foreign_key':
if annotation_i == 0:
raise ValueError('sql_foreign_key annotation on a struct must follow a sql_column annotation')
elif self.annotations[annotation_i - 1].name != 'sql_column':
raise ValueError("sql_foreign_key annotation on a struct must follow a sql_column annotation, not " + self.annotations[annotation_i - 1].name)
foreign_key_definitions.append(SqlField.sql_foreign_key_definition_static(
column_name=self.annotations[annotation_i - 1].value.split(' ', 1)[0],
foreign_table_name=annotation.value[0],
foreign_column_name=annotation.value[1]
))
for field in self.fields:
column_definition = field.sql_column_definition()
if column_definition is not None:
column_definitions.append(column_definition)
for field in self.fields:
foreign_key_definition = field.sql_foreign_key_definition()
if foreign_key_definition is not None:
foreign_key_definitions.append(foreign_key_definition)
column_definitions.extend(foreign_key_definitions)
column_definitions = lpad(",\n ", ",\n ".join(column_definitions))
name = decamelize(self.name)
return """\
CREATE TABLE IF NOT EXISTS %(name)s(
id INTEGER PRIMARY KEY AUTO_INCREMENT NOT NULL%(column_definitions)s
)""" % locals()
def _java_method_fake(self):
name = self.java_name()
qname = self.java_qname()
setter_calls = []
for field in self.fields:
recursive = False
for type_ in [field.type] + list(field.type.type_parameters):
if qname == type_.java_qname():
assert not field.required, qname + '.' + field.name
recursive = True
break
if not recursive:
setter_calls.append(
"builder.%s(%s);" %
(field.java_setter_name(), field.java_faker()))
setter_calls = \
lpad("\n", "\n".join(indent(' ' * 4, setter_calls)))
return {
'fakeBuilder':
"""\
public static Builder fakeBuilder() {
Builder builder = new Builder();%(setter_calls)s
return builder;
}""" % locals(),
'fake':
"""\
public static %(name)s fake() {
return fakeBuilder().build();
}""" % locals()
}
def logging_cpp_repr(self):
declaration = self.cpp_declaration(override=True)
delegate_call = "impl_->%s(%s)" % (
self.cpp_name(),
", ".join(parameter.cpp_name() for parameter in self.parameters),
)
if self.return_field is not None:
delegate_call = "return " + delegate_call
log_parameters = []
for parameter in self.parameters:
log_parameter = parameter.cpp_name()
if not parameter.required:
log_parameter = "*" + log_parameter
parameter_type = parameter.type
while isinstance(parameter_type, CppTypedef):
parameter_type = parameter_type.type
if not isinstance(parameter_type, _CppBaseType):
log_parameter = "to_string(%s)" % log_parameter
if not parameter.required:
log_parameter = '(%s.present() ? %s : "")' % (parameter.cpp_name(), log_parameter)
log_parameters.append(log_parameter)
log_parameters = lpad(" << ", ' << ", " << '.join(log_parameters))
name = self.cpp_name()
service_name = self.parent.name
return (
"""\
%(declaration)s {
VLOG(VerboseLevel) << "%(service_name)s::%(name)s("%(log_parameters)s << ")";
%(delegate_call)s;
}"""
% locals()
)
def _cpp_constructor_total(self):
if len(self.fields) == 0:
return None # Will be covered by default constructor
body = lpad("\n", indent(' ' * 2, self._cpp_constructor_body()))
initializers = \
lpad("\n : ", ', '.join(
(field.cpp_initializer()
for field in self.fields)
))
name = self.cpp_name()
parameters = ', '.join(field.cpp_parameter()
for field in self.fields)
return """\
%(name)s(%(parameters)s)%(initializers)s {%(body)s
}""" % locals()
def __repr__(self):
extends = self.java_extends()
if extends is None:
extends = ''
else:
extends = ' extends ' + extends
javadoc = self.java_doc()
name = self.java_name()
sections = []
message_types = []
for function in self.functions:
message_types.extend(function.java_message_types())
if len(message_types) > 0:
message_types = \
"\n\n".join(indent(' ' * 4,
(repr(message_type)
for message_type in message_types)
))
sections.append("""\
public static class Messages {
%(message_types)s
}""" % locals())
sections.append("\n\n".join(repr(function) for function in self.functions))
sections = lpad("\n", "\n\n".join(indent(' ' * 4, sections)))
return """\
%(javadoc)spublic interface %(name)s%(extends)s {%(sections)s
}""" % locals()
def java_repr(self):
annotations = pad("\n", "\n".join(self._java_annotations()), "\n")
extends = self._java_extends()
extends = ' extends ' + extends if extends is not None else ''
implements = lpad(' implements ', ', '.join(self._java_implements()))
javadoc = self.java_doc()
name = self.java_name()
sections = lpad("\n", "\n\n".join(indent(' ' * 4, self._java_repr_sections())))
return """\
%(javadoc)s%(annotations)spublic interface %(name)s%(extends)s%(implements)s {%(sections)s
}""" % locals()
def __repr__(self):
name = self.java_name()
parameters = \
', '.join(parameter.java_parameter() for parameter in self.parameters)
if self.return_field is not None:
return_ = 'return '
return_type_name = self.return_field.type.java_declaration_name()
else:
return_ = ''
return_type_name = 'void'
service_call = "service.%s(%s)" % (name, ', '.join(parameter.java_name() for parameter in self.parameters))
throws = \
lpad(
' throws ',
', '.join(field.type.java_declaration_name()
for field in self.throws)
)
return """\
public %(return_type_name)s %(name)s(%(parameters)s)%(throws)s {
%(return_)s%(service_call)s;
}""" % locals()
def cpp_repr(self):
definitions = []
definitions.append(
"\n\n".join(definition.cpp_repr()
for definition in self.definitions)
)
definitions = "\n\n".join(definitions)
if len(definitions) == 0:
return definitions
global_operators = lpad("\n\n", "\n\n".join(self.cpp_global_operators()))
guard = self.cpp_guard()
namespace_block_closes = self.cpp_namespace_block_closes()
namespace_block_opens = self.cpp_namespace_block_opens()
includes = rpad("\n".join(self.cpp_includes_definition()), "\n\n")
repr_ = """\
#ifndef %(guard)s
#define %(guard)s
%(includes)s%(namespace_block_opens)s%(definitions)s%(namespace_block_closes)s%(global_operators)s
#endif // %(guard)s
""" % locals()
return repr_
def logging_cpp_repr(self):
declaration = self.cpp_declaration(override=True)
delegate_call = \
"impl_->%s(%s)" % (
self.cpp_name(),
', '.join(
parameter.cpp_name()
for parameter in self.parameters
)
)
if self.return_field is not None:
delegate_call = 'return ' + delegate_call
log_parameters = []
for parameter in self.parameters:
log_parameter = parameter.cpp_name()
if not parameter.required:
log_parameter = '*' + log_parameter
parameter_type = parameter.type
while isinstance(parameter_type, CppTypedef):
parameter_type = parameter_type.type
if not isinstance(parameter_type, _CppBaseType):
log_parameter = "to_string(%s)" % log_parameter
if not parameter.required:
log_parameter = "(%s.present() ? %s : \"\")" % (
parameter.cpp_name(), log_parameter)
log_parameters.append(log_parameter)
log_parameters = lpad(' << ',
' << \", \" << '.join(log_parameters))
name = self.cpp_name()
service_name = self.parent.name
return """\
%(declaration)s {
VLOG(VerboseLevel) << "%(service_name)s::%(name)s("%(log_parameters)s << ")";
%(delegate_call)s;
}""" % locals()
def cpp_repr(self):
definitions = []
definitions.append("\n\n".join(definition.cpp_repr()
for definition in self.definitions))
definitions = "\n\n".join(definitions)
if len(definitions) == 0:
return definitions
global_operators = lpad("\n\n",
"\n\n".join(self.cpp_global_operators()))
guard = self.cpp_guard()
namespace_block_closes = self.cpp_namespace_block_closes()
namespace_block_opens = self.cpp_namespace_block_opens()
includes = rpad("\n".join(self.cpp_includes_definition()), "\n\n")
repr_ = """\
#ifndef %(guard)s
#define %(guard)s
%(includes)s%(namespace_block_opens)s%(definitions)s%(namespace_block_closes)s%(global_operators)s
#endif // %(guard)s
""" % locals()
return repr_
def _js_class_method_from_thryft_json(self):
qname = self.js_qname()
if len(self.fields) == 0:
return {
'fromThryftJSON':
"""\
fromThryftJSON: function(json) {
return new %(qname)s({});
}""" % locals()
}
fields_from_json = \
lpad("\n", indent(' ' * 8, ' else '.join(
field.js_from_json() for field in self.fields
)))
return {
'fromThryftJSON':
"""\
fromThryftJSON: function(json) {
var fields = {};
for (var fieldName in json) {%(fields_from_json)s
}
return new %(qname)s(fields);
}""" % locals()
}
def __repr__(self):
extends = self.java_extends()
if extends is None:
extends = ''
else:
extends = ' extends ' + extends
javadoc = self.java_doc()
name = self.java_name()
sections = []
message_types = []
for function in self.functions:
message_types.extend(function.java_message_types())
if len(message_types) > 0:
message_types = \
"\n\n".join(indent(' ' * 4,
(repr(message_type)
for message_type in message_types)
))
sections.append("""\
public static class Messages {
%(message_types)s
}""" % locals())
sections.append("\n\n".join(
repr(function) for function in self.functions))
sections = lpad("\n", "\n\n".join(indent(' ' * 4, sections)))
return """\
%(javadoc)spublic interface %(name)s%(extends)s {%(sections)s
}""" % locals()
def java_declarations(self):
javadoc = self.java_doc()
name = self.java_name()
if self.return_field is not None:
return_type_name = self.return_field.type.java_qname()
else:
return_type_name = 'void'
throws = \
lpad(
' throws ',
', '.join(field.type.java_qname()
for field in self.throws)
)
declarations = []
for parameters in self._java_overload_parameter_lists():
if len(parameters) < len(
self.parameters) and self._parent_generator(
).default_methods:
declarations.append(
self.__java_delegation_definition(parameters,
default=True))
else:
parameters = \
', '.join(parameter.java_parameter(final=True) for parameter in parameters)
declarations.append("""\
%(javadoc)spublic %(return_type_name)s %(name)s(%(parameters)s)%(throws)s;""" %
locals())
return declarations
def __java_delegation_definition(self, parameters, default=False):
if default:
default = 'default '
name = self.java_name()
if self.return_field is not None:
return_prefix = 'return '
return_type_name = self.return_field.type.java_qname()
else:
return_prefix = ''
return_type_name = 'void'
throws = \
lpad(
' throws ',
', '.join(field.type.java_qname()
for field in self.throws)
)
parameters = [
parameter.java_parameter(final=True) for parameter in parameters
]
delegate_values = []
for parameter_i, parameter in enumerate(self.parameters):
if parameter.required:
delegate_values.append(parameter.java_name())
elif parameter_i < len(parameters):
delegate_values.append(parameter.java_name())
else:
delegate_values.append(parameter.java_absent_value())
delegate_values = ', '.join(delegate_values)
parameters = ', '.join(parameters)
return """\
public %(default)s%(return_type_name)s %(name)s(%(parameters)s)%(throws)s {
%(return_prefix)s%(name)s(%(delegate_values)s);
}""" % locals()
def _dart_method_to_map(self):
field_puts = []
for field in self.fields:
field_name = field.name
field_dart_name = field.dart_name()
field_to_core_type = field.type.dart_to_core_type(
"this.%(field_dart_name)s" % locals())
field_put = """map["%(field_name)s"] = %(field_to_core_type)s;""" % locals(
)
if not field.required:
field_put = """\
if (this.%(field_dart_name)s != null) {
%(field_put)s
}""" % locals()
field_puts.append(field_put)
field_puts = \
lpad("\n", "\n".join(indent(' ' * 2, field_puts)))
return {
'toMap':
"""\
Map<String, Object> toMap() {
Map<String, Object> map = new Map<String, Object>();%(field_puts)s
return map;
}""" % locals()
}
def _py_method_read_protocol(self):
if len(self.fields) == 0:
return {'read': """\
@classmethod
def read(cls, iprot):
iprot.read_struct_begin()
iprot.read_struct_end()
return cls()
""" % locals()}
field_read_protocols = \
indent(' ' * 8, lpad('el', "el".join(
field.py_read_protocol()
for field in self.fields
)))
name = self.py_name()
return {'read': """\
@classmethod
def read(cls, iprot):
init_kwds = {}
iprot.read_struct_begin()
while True:
ifield_name, ifield_type, _ifield_id = iprot.read_field_begin()
if ifield_type == 0: # STOP
break
%(field_read_protocols)s
iprot.read_field_end()
iprot.read_struct_end()
return cls(**init_kwds)
""" % locals()}
def __repr__(self):
name = self.py_name()
sections = []
sections.append("\n\n".join(indent(' ' * 4, self._py_methods())))
sections = lpad("\n", "\n\n".join(sections))
return """\
class Builder:%(sections)s
""" % locals()
def _js_property_validation(self):
return {'validation': """\
validation: {%s
}
""" % lpad("\n", ",\n\n".join(indent(' ' * 4,
(field.js_validation()
for field in self.fields)
)))}
def java_definitions(self):
annotations = lpad("\n", "\n".join(self.java_annotations()))
name = self.java_name()
public_parameters = \
', '.join(parameter.java_parameter(final=True) for parameter in self.parameters)
public_parameter_names = ', '.join(parameter.java_name() for parameter in self.parameters)
parameter_validations = []
request_type_name = self.java_request_type().java_name()
service_qname = JavaService.java_qname(self.parent)
for parameter in self.parameters:
parameter_name = parameter.java_name()
parameter_validate_method_name = parameter.java_validate_method_name()
parameter_validations.append("%(service_qname)s.Messages.%(request_type_name)s.DefaultConstructionValidator.getInstance().%(parameter_validate_method_name)s(%(parameter_name)s);" % locals())
if len(parameter_validations) > 0:
parameter_validations = \
"\n".join(indent(' ' * 4, parameter_validations))
validate_method_name = '_validate' + upper_camelize(self.name) + 'Parameters'
validate_method = lpad("\n\n", """\
protected void %(validate_method_name)s(%(public_parameters)s) {
%(parameter_validations)s
}""" % locals())
validate_method_call = lpad("\n", indent(' ' * 4, "%s(%s);" % (validate_method_name, public_parameter_names)))
else:
validate_method = validate_method_call = ''
delegation = \
"delegate.%s(%s)" % (name, ', '.join(parameter.java_name() for parameter in self.parameters))
if self.return_field is not None:
response_type_name = self.java_response_type().java_name()
return_field_validate_method_name = self.return_field.java_validate_method_name()
delegation = "return %(service_qname)s.Messages.%(response_type_name)s.DefaultConstructionValidator.getInstance().%(return_field_validate_method_name)s(%(delegation)s)" % locals()
return_type_name = self.return_field.type.java_qname()
else:
return_type_name = 'void'
throws = \
lpad(
' throws ',
', '.join(field.type.java_qname()
for field in self.throws)
)
return ["""\
@Override%(annotations)s
public final %(return_type_name)s %(name)s(%(public_parameters)s)%(throws)s {%(validate_method_call)s
%(delegation)s;
}%(validate_method)s
""" % locals()] + self._java_delegating_definitions()
def __repr__(self):
name = self.py_name()
sections = []
sections.append("\n\n".join(indent(' ' * 4, self._py_methods())))
sections = lpad("\n", "\n\n".join(sections))
return """\
class Builder:%(sections)s
""" % locals()
def _js_property_validation(self):
return {'validation': """\
validation: {%s
}
""" % lpad("\n", ",\n\n".join(indent(' ' * 4,
(field.js_validation()
for field in self.fields)
)))}
def _java_constructor_default(self):
initializers = \
lpad("\n", "\n".join(indent(' ' * 4,
(field.java_null_initializer()
for field in self.fields)
)))
return """\
public Builder() {%(initializers)s
}""" % locals()
def _java_constructor_default(self):
initializers = \
lpad("\n", "\n".join(indent(' ' * 4,
(field.java_null_initializer()
for field in self.fields)
)))
return """\
public Builder() {%(initializers)s
}""" % locals()
def _cpp_constructor_default(self):
body = lpad("\n", indent(' ' * 2, self._cpp_constructor_body()))
name = self.cpp_name()
if len(self.fields) == 0:
return """\
%(name)s() {%(body)s
}""" % locals()
initializers = []
for field in self.fields:
default_initializer = field.cpp_default_initializer()
if default_initializer is not None:
initializers.append(default_initializer)
initializers = lpad("\n : ", ', '.join(initializers))
return """\
%(name)s()%(initializers)s {%(body)s
}""" % locals()
def dart_repr(self):
name = self.dart_name()
sections = []
sections.append(indent(' ' * 2, "\n".join(self._dart_member_declarations())))
sections.append(indent(' ' * 2, "\n\n".join(self._dart_methods())))
sections = lpad("\n", "\n\n".join(section for section in sections if len(section) > 0))
return """\
class %(name)s {%(sections)s
}""" % locals()
def _cpp_constructor_default(self):
body = lpad("\n", indent(' ' * 2, self._cpp_constructor_body()))
name = self.cpp_name()
if len(self.fields) == 0:
return """\
%(name)s() {%(body)s
}""" % locals()
initializers = []
for field in self.fields:
default_initializer = field.cpp_default_initializer()
if default_initializer is not None:
initializers.append(default_initializer)
initializers = lpad("\n : ", ', '.join(initializers))
return """\
%(name)s()%(initializers)s {%(body)s
}""" % locals()
def _java_method_write(self):
case_ttype_void = 'case VOID:'
if len(self.fields) == 1:
field = self.fields[0]
from thryft.generators.java._java_container_type import _JavaContainerType
from thryft.generators.java.java_struct_type import JavaStructType
if isinstance(field.type, _JavaContainerType) or isinstance(field.type, JavaStructType):
field_value_java_write_protocol = \
indent(' ' * 12, field.type.java_write_protocol(field.java_getter_name() + (field.required and '()' or '().get()'), depth=0))
field_thrift_ttype_name = field.type.thrift_ttype_name()
case_ttype_void = """\
%(case_ttype_void)s {
%(field_value_java_write_protocol)s
break;
}
""" % locals()
field_count = len(self.fields)
field_write_protocols = \
lpad("\n\n", "\n\n".join(indent(' ' * 12,
(field.java_write_protocol(depth=0, write_field=True)
for field in self.fields)
)))
field_value_write_protocols = \
pad("\n\n", "\n\n".join(indent(' ' * 12,
(field.java_write_protocol(depth=0, write_field=False)
for field in self.fields)
)), "\n")
name = self.java_name()
return {'write': """\
@Override
public void write(final org.thryft.protocol.OutputProtocol oprot) throws org.thryft.protocol.OutputProtocolException {
write(oprot, org.thryft.protocol.Type.STRUCT);
}
public void write(final org.thryft.protocol.OutputProtocol oprot, final org.thryft.protocol.Type writeAsType) throws org.thryft.protocol.OutputProtocolException {
switch (writeAsType) {
%(case_ttype_void)s
case LIST:
oprot.writeListBegin(org.thryft.protocol.Type.VOID, %(field_count)u);%(field_value_write_protocols)s
oprot.writeListEnd();
break;
case STRUCT:
default:
oprot.writeStructBegin(\"%(name)s\");%(field_write_protocols)s
oprot.writeFieldStop();
oprot.writeStructEnd();
break;
}
}
""" % locals()}
def _java_constructor_protocol(self):
name = self.java_name()
if len(self.fields) > 0:
field = self.fields[0]
field_initializer = lpad("\n", indent(' ' * 4, field.java_protocol_initializer()))
else:
field_initializer = ''
return """\
public %(name)s(final org.thryft.protocol.InputProtocol iprot) throws org.thryft.protocol.InputProtocolException {%(field_initializer)s
}""" % locals()
def _dart_constructor_total(self):
name = self.dart_name()
parameters = pad('{', ', '.join(field.dart_parameter() for field in self.fields), '}')
initializers = \
lpad(' : ', ', '.join(
field.dart_initializer()
for field in self.fields
))
return """\
%(name)s(%(parameters)s)%(initializers)s;""" % locals()
def _java_constructor_protocol(self):
name = self.java_name()
if len(self.fields) > 0:
field = self.fields[0]
field_initializer = lpad("\n", indent(' ' * 4, field.java_protocol_initializer()))
else:
field_initializer = ''
return """\
public %(name)s(final org.thryft.protocol.InputProtocol iprot) throws org.thryft.protocol.InputProtocolException {%(field_initializer)s
}""" % locals()
def ts_repr(self):
methods = \
lpad("\n", "\n\n".join(indent(' ' * 4,
(function.ts_repr()
for function in self.functions)
)))
name = self.ts_name()
return """\
export class %(name)s {%(methods)s
}""" % locals()
def ts_repr(self):
methods = \
lpad("\n", "\n\n".join(indent(' ' * 4,
(function.ts_repr()
for function in self.functions)
)))
name = self.ts_name()
return """\
export class %(name)s {%(methods)s
}""" % locals()
def _cpp_method_write(self):
case_ttype_void = 'case ::thryft::protocol::Type::VOID_:'
if len(self.fields) == 1:
field = self.fields[0]
from thryft.generators.cpp._cpp_container_type import _CppContainerType
from thryft.generators.cpp.cpp_struct_type import CppStructType
if isinstance(field.type, _CppContainerType) or isinstance(field.type, CppStructType):
field_value_cpp_write_protocol = \
indent(' ' * 4, field.type.cpp_write_protocol(field.cpp_getter_name() + (field.required and '()' or '().get()')))
case_ttype_void = """\
%(case_ttype_void)s
%(field_value_cpp_write_protocol)s
break;
""" % locals()
field_count = len(self.fields)
field_write_protocols = \
lpad("\n\n", "\n\n".join(indent(' ' * 4,
(field.cpp_write_protocol(write_field=True)
for field in self.fields)
)))
field_value_write_protocols = \
pad("\n\n", "\n\n".join(indent(' ' * 4,
(field.cpp_write_protocol(write_field=False)
for field in self.fields)
)), "\n")
name = self.cpp_name()
return {'write': """\
void write(::thryft::protocol::OutputProtocol& oprot) const {
write(oprot, ::thryft::protocol::Type::STRUCT);
}
void write(::thryft::protocol::OutputProtocol& oprot, ::thryft::protocol::Type as_type) const {
switch (as_type) {
%(case_ttype_void)s
case ::thryft::protocol::Type::LIST:
oprot.write_list_begin(::thryft::protocol::Type::VOID_, %(field_count)u);%(field_value_write_protocols)s
oprot.write_list_end();
break;
case ::thryft::protocol::Type::STRUCT:
default:
oprot.write_struct_begin();%(field_write_protocols)s
oprot.write_field_stop();
oprot.write_struct_end();
break;
}
}
""" % locals()}
def py_add_arguments(self):
name = self.py_name()
add_arguments = []
parse_args = []
for parameter in self.parameters:
parameter_action = parameter.py_argparse_action()
parameter_name = parameter.py_argparse_name()
parameter_required = ', required=True' if parameter.py_argparse_required() else ''
parameter_type = ", type=%s" % parameter.py_argparse_type() if parameter_action == 'store' else ''
add_arguments.append("%(name)s_argument_parser.add_argument('--%(parameter_name)s', action='%(parameter_action)s'%(parameter_required)s%(parameter_type)s)" % locals())
parse_args.append(parameter.py_argparse_parse())
add_arguments = lpad("\n", "\n".join(add_arguments))
call_kwds = ', '.join("%s=%s" % (parameter.py_name(), parameter.py_name()) for parameter in self.parameters)
parse_args = lpad("\n", "\n".join(indent(' ' * 4, parse_args)))
return """\
def %(name)s(__args):%(parse_args)s
return cls().%(name)s(%(call_kwds)s)
%(name)s_argument_parser = argument_subparsers.add_parser('%(name)s')%(add_arguments)s
%(name)s_argument_parser.set_defaults(func=%(name)s)
""" % locals()
def py_repr(self):
name = self.py_name()
sections = []
sections.append("\n\n".join(indent(" " * 4, self._py_methods())))
sections = lpad("\n", "\n\n".join(sections))
return (
"""\
class Builder(object):%(sections)s
"""
% locals()
)
def _cpp_constructor_protocol(self):
body = lpad("\n", indent(' ' * 2, self._cpp_constructor_body()))
name = self.cpp_name()
return """\
%(name)s(::thryft::protocol::InputProtocol& iprot) {
read(iprot);%(body)s
}
%(name)s(::thryft::protocol::InputProtocol& iprot, const ::thryft::protocol::Type& as_type) {
read(iprot, as_type);%(body)s
}""" % locals()
def _cpp_constructor_protocol(self):
body = lpad("\n", indent(' ' * 2, self._cpp_constructor_body()))
name = self.cpp_name()
return """\
%(name)s(::thryft::protocol::InputProtocol& iprot) {
read(iprot);%(body)s
}
%(name)s(::thryft::protocol::InputProtocol& iprot, const ::thryft::protocol::Type& as_type) {
read(iprot, as_type);%(body)s
}""" % locals()
def __repr__(self):
name = self.java_name()
methods = self._java_methods()
sections = []
sections.append("\n\n".join(indent(' ' * 4,
self._java_constructors() + [methods[key] for key in sorted(methods.iterkeys())]
)))
sections.append("\n".join(indent(' ' * 4, self._java_member_declarations())))
sections = lpad("\n", "\n\n".join(section for section in sections if len(section) > 0))
return """\
public static class Builder {%(sections)s
}""" % locals()
def dart_repr(self):
name = self.dart_name()
sections = []
sections.append(
indent(' ' * 2, "\n".join(self._dart_member_declarations())))
sections.append(indent(' ' * 2, "\n\n".join(self._dart_methods())))
sections = lpad(
"\n",
"\n\n".join(section for section in sections if len(section) > 0))
return """\
class %(name)s {%(sections)s
}""" % locals()
def _dart_constructor_total(self):
name = self.dart_name()
parameters = pad(
'{', ', '.join(field.dart_parameter() for field in self.fields),
'}')
initializers = \
lpad(' : ', ', '.join(
field.dart_initializer()
for field in self.fields
))
return """\
%(name)s(%(parameters)s)%(initializers)s;""" % locals()
def _py_method_read_protocol(self):
qname = self.py_qname()
if len(self.fields) == 0:
return {
"read": """\
@classmethod
def read(cls, iprot):
'''
Read a new object from the given input protocol and return the object.
:type iprot: thryft.protocol._input_protocol._InputProtocol
:rtype: %(qname)s
'''
iprot.read_struct_begin()
iprot.read_struct_end()
return cls()
"""
% locals()
}
ifield_id_prefix = "_"
for field in self.fields:
if field.id is not None:
ifield_id_prefix = ""
break
field_read_protocols = indent(" " * 8, lpad("el", "el".join(field.py_read_protocol() for field in self.fields)))
name = self.py_name()
return {
"read": """\
@classmethod
def read(cls, iprot):
'''
Read a new object from the given input protocol and return the object.
:type iprot: thryft.protocol._input_protocol._InputProtocol
:rtype: %(qname)s
'''
init_kwds = {}
iprot.read_struct_begin()
while True:
ifield_name, ifield_type, %(ifield_id_prefix)sifield_id = iprot.read_field_begin()
if ifield_type == 0: # STOP
break
%(field_read_protocols)s
iprot.read_field_end()
iprot.read_struct_end()
return cls(**init_kwds)
"""
% locals()
}
def _cpp_constructor_body(self):
fields_to_string = \
lpad("\n", indent(' ' * 2, "\n".join(
"oss << \"%s%s=\";\n" % (', ' if field_i > 0 else '', field.cpp_name()) + \
field.cpp_to_string(depth=0, oss='oss')
for field_i, field in enumerate(self.fields)
)))
name = self.cpp_name()
return """\
::std::ostringstream oss;
oss << "%(name)s(";%(fields_to_string)s
oss << ")";
what_ = oss.str();""" % locals()
def cpp_repr(self):
name = self.cpp_name()
extends = lpad(' : public ', self._cpp_extends())
template_parameters = rpad(self._cpp_template_parameters(), "\n")
sections = []
# sections.append(indent(' ' * 4, repr(self._CppBuilder(self))))
sections.append(
lpad(
"public:\n", "\n\n".join(
indent(
' ' * 2,
self._cpp_constructors() + [self._cpp_destructor()] +
self._cpp_methods_list()))))
sections.append(
lpad("private:\n",
"\n".join(indent(' ' * 2, self._cpp_member_declarations()))))
sections = lpad(
"\n",
"\n\n".join(section for section in sections if len(section) > 0))
return """\
%(template_parameters)sclass %(name)s%(extends)s {%(sections)s
};""" % locals()
