def java_write_protocol(self, value, depth=0):
key_ttype = self.key_type.thrift_ttype_name()
key_type_name = self.key_type.java_declaration_name(boxed=True)
key_write_protocol = \
indent(' ' * 4,
self.key_type.java_write_protocol(
"_iter%(depth)u.getKey()" % locals(),
depth=depth + 1
)
)
value_ttype = self.value_type.thrift_ttype_name()
value_type_name = self.value_type.java_declaration_name(boxed=True)
value_write_protocol = \
indent(' ' * 4,
self.value_type.java_write_protocol(
"_iter%(depth)u.getValue()" % locals(),
depth=depth + 1
)
)
return """\
oprot.writeMapBegin(org.thryft.protocol.Type.%(key_ttype)s, org.thryft.protocol.Type.%(value_ttype)s, %(value)s.size());
for (com.google.common.collect.ImmutableMap.Entry<%(key_type_name)s, %(value_type_name)s> _iter%(depth)u : %(value)s.entrySet()) {
%(key_write_protocol)s
%(value_write_protocol)s
}
oprot.writeMapEnd();""" % locals()
def js_validation(self):
try:
validation = self.annotations['validation'].copy()
except KeyError:
validation = {}
validation['required'] = self.required
name = self.js_name()
qname = self.js_qname()
validation.update(self.type.js_validation(depth=0, value='value', value_name=qname))
type_validation = validation.pop('type')
if not self.required:
type_validation = indent(' ' * 4, type_validation)
type_validation = """\
if (typeof attr !== "undefined" && attr !== "null") {
%(type_validation)s
}
""" % locals()
type_validation = indent(' ' * 8, type_validation)
validation = json.dumps(validation).lstrip('{').rstrip('}')
return """\
%(name)s: {
"fn": function(value, attr, computedState) {
%(type_validation)s
},
%(validation)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 __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 __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 java_write_protocol(self, value, depth=0):
key_ttype = self.key_type.thrift_ttype_name()
key_type_name = self.key_type.java_boxed_qname()
key_write_protocol = \
indent(' ' * 4,
self.key_type.java_write_protocol(
"_iter%(depth)u.getKey()" % locals(),
depth=depth + 1
)
)
value_ttype = self.value_type.thrift_ttype_name()
value_type_name = self.value_type.java_boxed_qname()
value_write_protocol = \
indent(' ' * 4,
self.value_type.java_write_protocol(
"_iter%(depth)u.getValue()" % locals(),
depth=depth + 1
)
)
return """\
oprot.writeMapBegin(org.thryft.protocol.Type.%(key_ttype)s, org.thryft.protocol.Type.%(value_ttype)s, %(value)s.size());
for (com.google.common.collect.ImmutableMap.Entry<%(key_type_name)s, %(value_type_name)s> _iter%(depth)u : %(value)s.entrySet()) {
%(key_write_protocol)s
%(value_write_protocol)s
}
oprot.writeMapEnd();""" % locals()
def js_validation(self):
validation = {}
for annotation in self.annotations:
if annotation.name == 'validation':
validation = annotation.value.copy()
break
validation.pop('blank', None)
validation['required'] = self.required
name = self.js_name()
qname = self.js_qname()
validation.update(
self.type.js_validation(depth=0, value='value', value_name=qname))
type_validation = validation.pop('type')
if not self.required:
type_validation = indent(' ' * 4, type_validation)
type_validation = """\
if (typeof attr !== "undefined" && attr !== "null") {
%(type_validation)s
}
""" % locals()
type_validation = indent(' ' * 8, type_validation)
validation = json.dumps(validation).lstrip('{').rstrip('}')
return """\
%(name)s: {
"fn": function(value, attr, computedState) {
%(type_validation)s
},
%(validation)s
}""" % locals()
def cpp_to_string(self, depth, oss, value):
key_to_string = \
indent(' ' * 2,
self.key_type.cpp_to_string(
depth=depth+1,
oss=oss,
value="i%(depth)u->first" % locals()
)
)
value_to_string = \
indent(' ' * 2,
self.value_type.cpp_to_string(
depth=depth+1,
oss=oss,
value="i%(depth)u->second" % locals()
)
)
qname = self.cpp_qname()
return """\
oss << "{";
for (%(qname)s::const_iterator i%(depth)u = %(value)s.begin(); i%(depth)u != %(value)s.end(); ++i%(depth)u) {
if (i%(depth)u != %(value)s.begin()) {
oss << ", ";
}
%(key_to_string)s
oss << ": ";
%(value_to_string)s
}
oss << "]";""" % locals()
def cpp_sync_handler(self):
name = self.cpp_name()
response_name = upper_camelize(self.__parent_function.cpp_name()) + 'Response'
if self.__parent_function.return_field is not None:
call_prefix = "request.respond(%(response_name)s(" % locals()
call_suffix = "))"
else:
call_prefix = ''
call_suffix = """;
request.respond(%(response_name)s())""" % locals()
call_parameters = \
', '.join("request.%s()" % parameter.cpp_getter_name()
for parameter in self.fields)
call_method_name = self.__parent_function.name
call = "%(call_prefix)simpl_->%(call_method_name)s(%(call_parameters)s)%(call_suffix)s;" % locals()
if len(self.__parent_function.throws) > 0:
catches = []
for exception in self.__parent_function.throws:
exception_name = exception.cpp_name()
exception_type_qname = exception.type.cpp_qname()
catches.append("""\
} catch (const %(exception_type_qname)s& %(exception_name)s) {
request.respond(%(exception_name)s);""" % locals())
catches = "\n".join(catches) + "\n}"
call = indent(' ' * 2, call)
call = """\
try {
%(call)s
%(catches)s""" % locals()
call = indent(' ' * 2, call)
return """\
virtual void handle(const %(name)s& request) {
%(call)s
}""" % locals()
def __java_markers(self):
service_marker_variable_name = service_marker_name = decamelize(
self.name).upper()
add_function_markers = []
function_markers = []
for function in self.functions:
function_marker_variable_name = function.java_marker_variable_name(
)
function_markers.append(
"public final static org.slf4j.Marker %s = org.slf4j.MarkerFactory.getMarker(\"%s\");"
% (function_marker_variable_name,
function.java_marker_name()))
add_function_markers.append(
"%(service_marker_variable_name)s.add(%(function_marker_variable_name)s);"
% locals())
add_function_markers = "\n".join(
indent(' ' * 8, add_function_markers))
function_markers = "\n".join(indent(' ' * 4, function_markers))
return """\
public static class Markers {
%(function_markers)s
public final static org.slf4j.Marker %(service_marker_variable_name)s = org.slf4j.MarkerFactory.getMarker("%(service_marker_name)s");
static {
%(add_function_markers)s
}
}""" % locals()
def js_validation(self, value, value_name, depth=0):
key_type_validation = \
indent(' ' * 4,
self.key_type.js_validation(
depth=depth + 1,
value="__key" % locals(),
value_name=value_name + " key" % locals()
)['type']
)
value_type_validation = \
indent(' ' * 4,
self.value_type.js_validation(
depth=depth + 1,
value="__value" % locals(),
value_name=value_name + " value" % locals()
)['type']
)
return {'type': """\
if (typeof %(value)s !== "object") {
return "expected %(value_name)s to be an object";
}
for (var __key in %(value)s) {
var __value = %(value)s[__key];
%(key_type_validation)s
%(value_type_validation)s
}""" % locals()}
def _py_constructor(self):
assert len(self.fields) > 0
doc = indent(' ' * 4, "\n".join(field.py_sphinx_doc()
for field in self.fields))
required_parameters = []
optional_parameters = []
for field in self.fields:
parameter = field.py_parameter()
if '=' in parameter:
optional_parameters.append(parameter)
else:
required_parameters.append(parameter)
parameters = "\n".join(indent(' ' * 4, required_parameters + optional_parameters))
initializers = \
"\n\n".join(indent(' ' * 4,
(field.py_initializer()
for field in self.fields)
))
return """\
def __init__(
self,
%(parameters)s
):
'''
%(doc)s
'''
%(initializers)s
""" % locals()
def _py_constructor(self):
if len(self.fields) == 0:
return None
doc = indent(' ' * 4, "\n".join(field.py_sphinx_doc()
for field in self.fields))
parameters = \
"\n".join(indent(' ' * 4, (
field.py_parameter(default_value='None')
for field in self.fields
)))
initializers = \
"\n".join(indent(' ' * 4,
('self.__%s = %s' % (field.py_name(), field.py_name())
for field in self.fields)
))
return """\
def __init__(
self,
%(parameters)s
):
'''
%(doc)s
'''
%(initializers)s
""" % locals()
def js_validation(self):
validation = {}
for annotation in self.annotations:
if annotation.name == 'validation':
validation = annotation.value.copy()
break
validation.pop('blank', None)
validation['required'] = self.required
name = self.js_name()
qname = self.js_qname()
validation.update(self.type.js_validation(depth=0, value='value', value_name=qname))
type_validation = validation.pop('type')
if not self.required:
type_validation = indent(' ' * 4, type_validation)
type_validation = """\
if (typeof attr !== "undefined" && attr !== "null") {
%(type_validation)s
}
""" % locals()
type_validation = indent(' ' * 8, type_validation)
validation = json.dumps(validation).lstrip('{').rstrip('}')
return """\
%(name)s: {
"fn": function(value, attr, computedState) {
%(type_validation)s
},
%(validation)s
}""" % locals()
def _py_method_update(self):
if len(self.fields) == 0:
return {}
doc = indent(' ' * 4, "\n".join(field.py_sphinx_doc()
for field in self.fields))
name = self.py_name()
other_name = decamelize(self.py_name())
object_updates = \
"\n".join(indent(' ' * 8,
("self.%s(%s.%s)" % (field.py_setter_name(), other_name, field.py_getter_call())
for field in self.fields)
))
return {'update': """\
def update(self, %(other_name)s):
'''
%(doc)s
'''
if isinstance(%(other_name)s, %(name)s):
%(object_updates)s
elif isinstance(%(other_name)s, dict):
for key, value in %(other_name)s.iteritems():
getattr(self, 'set_' + key)(value)
else:
raise TypeError(%(other_name)s)
return self
""" % locals()}
def _py_method_update(self):
if len(self.fields) == 0:
return {}
doc = indent(" " * 4, "\n".join(field.py_sphinx_doc() for field in self.fields))
name = self.py_name()
other_name = decamelize(self.py_name())
object_updates = "\n".join(
indent(
" " * 8,
(
"self.%s(%s.%s)" % (field.py_setter_name(), other_name, field.py_getter_call())
for field in self.fields
),
)
)
return {
"update": """\
def update(self, %(other_name)s):
'''
%(doc)s
'''
if isinstance(%(other_name)s, %(name)s):
%(object_updates)s
elif isinstance(%(other_name)s, dict):
for key, value in %(other_name)s.iteritems():
getattr(self, 'set_' + key)(value)
else:
raise TypeError(%(other_name)s)
return self
"""
% locals()
}
def _py_constructor(self):
assert len(self.fields) > 0
doc = indent(" " * 4, "\n".join(field.py_sphinx_doc() for field in self.fields))
required_parameters = []
optional_parameters = []
for field in self.fields:
parameter = field.py_parameter()
if "=" in parameter:
optional_parameters.append(parameter)
else:
required_parameters.append(parameter)
parameters = "\n".join(indent(" " * 4, required_parameters + optional_parameters))
initializers = "\n\n".join(indent(" " * 4, (field.py_initializer() for field in self.fields)))
return (
"""\
def __init__(
self,
%(parameters)s
):
'''
%(doc)s
'''
%(initializers)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 js_validation(self, value, value_name, depth=0):
key_type_validation = \
indent(' ' * 4,
self.key_type.js_validation(
depth=depth + 1,
value="__key" % locals(),
value_name=value_name + " key" % locals()
)['type']
)
value_type_validation = \
indent(' ' * 4,
self.value_type.js_validation(
depth=depth + 1,
value="__value" % locals(),
value_name=value_name + " value" % locals()
)['type']
)
return {
'type':
"""\
if (typeof %(value)s !== "object") {
return "expected %(value_name)s to be an object";
}
for (var __key in %(value)s) {
var __value = %(value)s[__key];
%(key_type_validation)s
%(value_type_validation)s
}""" % locals()
}
def js_write_protocol(self, value, depth=0):
key_ttype_id = self.key_type.thrift_ttype_id()
key_write_protocol = \
indent(' ' * 4,
self.key_type.js_write_protocol(
"__key%(depth)u" % locals(),
depth=depth + 1
)
)
value_ttype_id = self.value_type.thrift_ttype_id()
value_write_protocol = \
indent(' ' * 4,
self.value_type.js_write_protocol(
"__map%(depth)u[__key%(depth)u]" % locals(),
depth=depth + 1
)
)
return """\
var __map%(depth)u = %(value)s;
var __mapSize%(depth)u = 0;
for (var __key%(depth)u in __map%(depth)u) {
__mapSize%(depth)u++;
}
oprot.writeMapBegin(%(key_ttype_id)u, %(value_ttype_id)u, __mapSize%(depth)u);
for (var __key%(depth)u in __map%(depth)u) {
%(key_write_protocol)s
%(value_write_protocol)s
}
oprot.writeMapEnd();""" % 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 _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 __repr__(self):
extends = ', '.join(self._py_extends())
sections = []
sections.append(indent(' ' * 4, repr(self._PyBuilder(self))))
sections.append(indent(' ' * 4, "\n".join(self._py_methods())))
sections = "\n\n".join(sections)
name = self.py_name()
return """\
class %(name)s(%(extends)s):
%(sections)s""" % locals()
def __repr__(self):
extends = ', '.join(self._py_extends())
sections = []
sections.append(indent(' ' * 4, repr(self._PyBuilder(self))))
sections.append(indent(' ' * 4, "\n".join(self._py_methods())))
sections = "\n\n".join(sections)
name = self.py_name()
return """\
class %(name)s(%(extends)s):
%(sections)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_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 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 __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 __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 java_repr(self):
final = 'final ' if self.__java_compound_type._java_is_final() else ''
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 %(final)sstatic class Builder {%(sections)s
}""" % locals()
def js_repr(self):
class_properties = ",\n\n".join(indent(' ' * 8, self._js_class_properties()))
properties = ",\n\n".join(indent(' ' * 8, self._js_properties()))
qname = self.js_qname()
return """\
%(qname)s = Backbone.Model.extend(
{
%(properties)s
},
{
%(class_properties)s
}
);""" % locals()
def ts_repr(self):
accessors = indent(' ' * 4, "\n\n".join(field.ts_accessors() for field in self.fields))
constructor = indent(' ' * 4, self.__ts_constructor())
methods = "\n\n".join(indent(' ' * 4, self.__ts_methods()))
name = self.ts_name()
return """\
export class %(name)s extends Backbone.Model {
%(constructor)s
%(accessors)s
%(methods)s
}""" % locals()
def js_repr(self):
class_properties = ",\n\n".join(
indent(' ' * 8, self._js_class_properties()))
properties = ",\n\n".join(indent(' ' * 8, self._js_properties()))
qname = self.js_qname()
return """\
%(qname)s = Backbone.Model.extend(
{
%(properties)s
},
{
%(class_properties)s
}
);""" % locals()
def java_read_protocol(self):
def try_catch(statement, throws):
if len(throws) == 0:
return statement
statement = indent(' ' * 4, statement)
return """\
try {
%s
}%s
""" % (statement, ''.join("""\
catch (final %(exception_type_name)s e) {
throw new org.thryft.protocol.InputProtocolException(e);
}""" % locals()
for exception_type_name in throws))
key_read_protocol = \
indent(' ' * 16, try_catch(
'key = ' + self.key_type.java_read_protocol() + ';',
self.key_type.java_read_protocol_throws_checked() + self.key_type.java_read_protocol_throws_unchecked()
))
key_type_name = self.key_type.java_boxed_qname()
value_read_protocol = \
indent(' ' * 16, try_catch(
'value = ' + self.value_type.java_read_protocol() + ';',
self.value_type.java_read_protocol_throws_checked() + self.value_type.java_read_protocol_throws_unchecked()
))
value_type_name = self.value_type.java_boxed_qname()
return """\
(new com.google.common.base.Function<org.thryft.protocol.InputProtocol, com.google.common.collect.ImmutableMap<%(key_type_name)s, %(value_type_name)s>>() {
@Override
public com.google.common.collect.ImmutableMap<%(key_type_name)s, %(value_type_name)s> apply(final org.thryft.protocol.InputProtocol iprot) {
try {
final org.thryft.protocol.MapBegin mapBegin = iprot.readMapBegin();
final com.google.common.collect.ImmutableMap.Builder<%(key_type_name)s, %(value_type_name)s> map = com.google.common.collect.ImmutableMap.builder();
for (int entryI = 0; entryI < mapBegin.getSize(); entryI++) {
final %(key_type_name)s key;
%(key_read_protocol)s
final %(value_type_name)s value;
%(value_read_protocol)s
map.put(key, value);
}
iprot.readMapEnd();
return map.build();
} catch (final org.thryft.protocol.InputProtocolException e) {
throw new org.thryft.protocol.UncheckedInputProtocolException(e);
}
}
}).apply(iprot)""" % locals()
def _java_method_do_post(self):
read_http_servlet_request_body = indent(
' ' * 4, self._java_read_http_servlet_request_body())
function_dispatches = []
if len(self.functions) == 0:
function_dispatches = """\
__doPostError(httpServletRequest, httpServletResponse, new org.thryft.protocol.JsonRpcErrorResponse(-32601, String.format("the method '%s' does not exist / is not available", messageBegin.getName())), messageBegin.getId());
return;
"""
else:
function_dispatches = \
indent(' ' * 8, ' else '.join(
["""\
if (messageBegin.getName().equals("%s")) {
__doPost%s(httpServletRequest, httpServletResponse, iprot, messageBegin.getId());
}""" % (function.name, upper_camelize(function.name))
for function in self.functions
] + ['''\
{
__doPostError(httpServletRequest, httpServletResponse, new org.thryft.protocol.JsonRpcErrorResponse(-32601, String.format("the method '%s' does not exist / is not available", messageBegin.getName())), messageBegin.getId());
return;
}''']
))
return """\
@Override
protected void doPost(final javax.servlet.http.HttpServletRequest httpServletRequest, final javax.servlet.http.HttpServletResponse httpServletResponse) throws java.io.IOException, javax.servlet.ServletException {
%(read_http_servlet_request_body)s
org.thryft.protocol.MessageBegin messageBegin = null;
try {
final org.thryft.protocol.JsonRpcInputProtocol iprot;
try {
iprot = new org.thryft.protocol.JsonRpcInputProtocol(new org.thryft.protocol.JacksonJsonInputProtocol(httpServletRequestBody));
messageBegin = iprot.readMessageBegin();
} catch (final org.thryft.protocol.JsonRpcInputProtocolException e) {
throw e;
} catch (final org.thryft.protocol.InputProtocolException e) {
throw new org.thryft.protocol.JsonRpcInputProtocolException(e, -32600);
}
if (messageBegin.getType() != org.thryft.protocol.MessageType.CALL) {
throw new org.thryft.protocol.JsonRpcInputProtocolException(-32600, "expected request");
}
%(function_dispatches)s
} catch (final org.thryft.protocol.JsonRpcInputProtocolException e) {
__doPostError(httpServletRequest, httpServletResponse, new org.thryft.protocol.JsonRpcErrorResponse(e), messageBegin != null ? messageBegin.getId() : null);
return;
}
}
""" % 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 java_repr(self):
javadoc = self.java_doc()
name = self.java_bean_name()
methods = self._java_methods()
sections = []
sections.append(indent(' ' * 4, self._java_field_metadata_enum()))
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)spublic class %(name)s implements org.thryft.StructBean {%(sections)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 java_read_protocol(self):
element_read_protocol = self.element_type.java_read_protocol()
add_element = "sequenceBuilder.add(%(element_read_protocol)s);" % locals()
element_read_protocol_throws = (
self.element_type.java_read_protocol_throws_checked()
+ self.element_type.java_read_protocol_throws_unchecked()
)
if len(element_read_protocol_throws) > 0:
add_element = indent(" " * 4, add_element)
add_element = """\
try {
%s
}%s
""" % (
add_element,
"".join(
"""\
catch (final %(exception_type_name)s e) {
throw new org.thryft.protocol.InputProtocolException(e);
}"""
% locals()
for exception_type_name in element_read_protocol_throws
),
)
add_element = indent(" " * 16, add_element)
element_type_name = self.element_type.java_boxed_qname()
interface_simple_name = self._java_interface_simple_name()
return (
"""\
(new com.google.common.base.Function<org.thryft.protocol.InputProtocol, com.google.common.collect.Immutable%(interface_simple_name)s<%(element_type_name)s>>() {
@Override
public com.google.common.collect.Immutable%(interface_simple_name)s<%(element_type_name)s> apply(final org.thryft.protocol.InputProtocol iprot) {
try {
final org.thryft.protocol.%(interface_simple_name)sBegin sequenceBegin = iprot.read%(interface_simple_name)sBegin();
final com.google.common.collect.Immutable%(interface_simple_name)s.Builder<%(element_type_name)s> sequenceBuilder = com.google.common.collect.Immutable%(interface_simple_name)s.builder();
for (int elementI = 0; elementI < sequenceBegin.getSize(); elementI++) {
%(add_element)s
}
iprot.read%(interface_simple_name)sEnd();
return sequenceBuilder.build();
} catch (final org.thryft.protocol.InputProtocolException e) {
throw new org.thryft.protocol.UncheckedInputProtocolException(e);
}
}
}).apply(iprot)"""
% locals()
)
def _java_method_do_post(self):
read_http_servlet_request_body = indent(' ' * 4, self._java_read_http_servlet_request_body())
function_dispatches = []
if len(self.functions) == 0:
function_dispatches = """\
__doPostError(httpServletRequest, httpServletResponse, new org.thryft.protocol.JsonRpcErrorResponse(-32601, String.format("the method '%s' does not exist / is not available", messageBegin.getName())), messageBegin.getId());
return;
"""
else:
function_dispatches = \
indent(' ' * 8, ' else '.join(
["""\
if (messageBegin.getName().equals("%s")) {
__doPost%s(httpServletRequest, httpServletResponse, iprot, messageBegin.getId());
}""" % (function.name, upper_camelize(function.name))
for function in self.functions
] + ['''\
{
__doPostError(httpServletRequest, httpServletResponse, new org.thryft.protocol.JsonRpcErrorResponse(-32601, String.format("the method '%s' does not exist / is not available", messageBegin.getName())), messageBegin.getId());
return;
}''']
))
return """\
@Override
protected void doPost(final javax.servlet.http.HttpServletRequest httpServletRequest, final javax.servlet.http.HttpServletResponse httpServletResponse) throws java.io.IOException, javax.servlet.ServletException {
%(read_http_servlet_request_body)s
org.thryft.protocol.MessageBegin messageBegin = null;
try {
final org.thryft.protocol.JsonRpcInputProtocol iprot;
try {
iprot = new org.thryft.protocol.JsonRpcInputProtocol(new org.thryft.protocol.JacksonJsonInputProtocol(httpServletRequestBody));
messageBegin = iprot.readMessageBegin();
} catch (final org.thryft.protocol.JsonRpcInputProtocolException e) {
throw e;
} catch (final org.thryft.protocol.InputProtocolException e) {
throw new org.thryft.protocol.JsonRpcInputProtocolException(e, -32600);
}
if (messageBegin.getType() != org.thryft.protocol.MessageType.CALL) {
throw new org.thryft.protocol.JsonRpcInputProtocolException(-32600, "expected request");
}
%(function_dispatches)s
} catch (final org.thryft.protocol.JsonRpcInputProtocolException e) {
__doPostError(httpServletRequest, httpServletResponse, new org.thryft.protocol.JsonRpcErrorResponse(e), messageBegin != null ? messageBegin.getId() : null);
return;
}
}
""" % locals()
def py_repr(self):
extends = ', '.join(self._py_extends())
sections = []
builder = self._py_builder()
if builder is not None:
sections.append(indent(' ' * 4, builder))
field_metadata_enum = self._py_field_metadata_enum()
if field_metadata_enum is not None:
sections.append(indent(' ' * 4, field_metadata_enum))
sections.append(indent(' ' * 4, "\n".join(self._py_methods())))
sections = "\n\n".join(sections)
name = self.py_name()
return """\
class %(name)s(%(extends)s):
%(sections)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 cpp_declaration(self, line_ending="\n", override=False):
override = ' override' if override else ''
name = self.cpp_name()
parameters = \
', '.join(parameter.cpp_parameter()
for parameter in self.parameters)
if self.return_field is not None:
return_type_name = self.return_field.type.cpp_qname()
else:
return_type_name = 'void'
declaration = """\
%(return_type_name)s %(name)s(%(parameters)s)%(override)s""" % locals()
if len(declaration) < 80:
return declaration
parameters = indent(' ' * 2, (',' + line_ending).join(
parameter.cpp_parameter() for parameter in self.parameters))
return """\
%(return_type_name)s%(line_ending)s%(name)s(%(line_ending)s%(parameters)s%(line_ending)s)%(override)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 cpp_declaration(self, line_ending="\n", override=False):
override = ' override' if override else ''
name = self.cpp_name()
parameters = \
', '.join(parameter.cpp_parameter()
for parameter in self.parameters)
if self.return_field is not None:
return_type_name = self.return_field.type.cpp_qname()
else:
return_type_name = 'void'
declaration = """\
%(return_type_name)s %(name)s(%(parameters)s)%(override)s""" % locals()
if len(declaration) < 80:
return declaration
parameters = indent(' ' * 2,
(',' + line_ending).join(parameter.cpp_parameter()
for parameter in self.parameters))
return """\
%(return_type_name)s%(line_ending)s%(name)s(%(line_ending)s%(parameters)s%(line_ending)s)%(override)s""" % locals()
def cpp_write_protocol(self, write_field=True):
id_ = self.id if self.id is not None else 0
name = self.name
getter_name = self.cpp_getter_name()
ttype = self.type.thrift_ttype_name()
value = getter_name + "()"
if not self.required:
value += '.get()'
write_protocol = self.type.cpp_write_protocol(value)
if write_field:
write_protocol = """\
oprot.write_field_begin("%(name)s", ::thryft::protocol::Type::%(ttype)s, static_cast<int16_t>(%(id_)d));
%(write_protocol)s
oprot.write_field_end();
""" % locals()
if not self.required:
write_protocol = indent(' ' * 4, write_protocol)
write_protocol = """\
if (%(getter_name)s().present()) {
%(write_protocol)s
}""" % locals()
if not write_field:
write_protocol += """\
else {
oprot.write_null();
}"""
return write_protocol
def _py_method_repr(self, method_name='__repr__'):
name = self.name
if len(self.fields) == 0:
return {
method_name:
"""\
def %(method_name)s(self):
return '%(name)s()'
""" % locals()
}
field_reprs = []
for field in self.fields:
field_name = field.name
field_getter_call = field.py_getter_call()
field_repr = field.type.py_repr('self.' + field.py_getter_call())
field_repr = "field_reprs.append('%(field_name)s=' + %(field_repr)s)" % locals(
)
if not field.required:
field_repr = """\
if self.%(field_getter_call)s is not None:
%(field_repr)s
""" % locals()
field_reprs.append(field_repr)
field_reprs = "\n".join(indent(' ' * 4, field_reprs))
return {
method_name:
"""\
def %(method_name)s(self):
field_reprs = []
%(field_reprs)s
return '%(name)s(' + ', '.join(field_reprs) + ')'
""" % locals()
}
def __repr__(self):
return "service %s%s {%s}" % (
self.name, self.extends is not None and (' ' + self.extends) or '',
pad(
"\n", "\n".join(
indent(' ' * 4, (repr(function) + ';'
for function in self.functions))), "\n"))
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 js_validation(self, value, value_name, depth=0):
if isinstance(self.element_type, _JsCompoundType):
element_type_qname = self.element_type.js_qname()
return {'type': """\
if (!(%(value)s instanceof Backbone.Collection)) {
return "expected %(value_name)s to be a Backbone.Collection";
}
if (%(value)s.model !== %(element_type_qname)s) {
return "expected %(value_name)s to be a Backbone.Collection with model=%(element_type_qname)s";
}
if (!%(value)s.isValid(true)) {
return %(value)s.validationError;
}""" % locals()}
else:
element_validate = \
indent(' ' * 4,
self.element_type.js_validation(
depth=depth + 1,
value=value + "[__i%(depth)u]" % locals(),
value_name=value_name + "[i]" % locals()
)['type']
)
return {'type': """\
if (!Array.isArray(%(value)s)) {
return "expected %(value_name)s to be an Array";
}
for (var __i%(depth)u = 0; __i%(depth)u < %(value)s.length; __i%(depth)u++) {
%(element_validate)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 java_write_protocol(self, write_field=True, depth=0):
id_ = self.id if self.id is not None else 0
name = self.name
getter_name = self.java_getter_name()
ttype = self.type.thrift_ttype_name()
value = getter_name + "()"
if not self.required:
value += '.get()'
write_protocol = \
self.type.java_write_protocol(value, depth=depth)
if write_field:
write_protocol = """\
oprot.writeFieldBegin("%(name)s", org.thryft.protocol.Type.%(ttype)s, (short)%(id_)d);
%(write_protocol)s
oprot.writeFieldEnd();
""" % locals()
if not self.required:
write_protocol = indent(' ' * 4, write_protocol)
write_protocol = """\
if (%(getter_name)s().isPresent()) {
%(write_protocol)s
}""" % locals()
if not write_field:
write_protocol += """\
else {
oprot.writeNull();
}"""
return write_protocol
def _cpp_declaration(self):
name = self.cpp_name()
parameters = \
', '.join(parameter.cpp_parameter()
for parameter in self.parameters)
if self.return_field is not None:
return_type_name = self.return_field.type.cpp_qname()
else:
return_type_name = 'void'
declaration = """\
%(return_type_name)s %(name)s(%(parameters)s)""" % locals()
if len(declaration) < 80:
return declaration
parameters = indent(
' ' * 2, ',\n'.join(parameter.cpp_parameter()
for parameter in self.parameters))
return """\
%(return_type_name)s
%(name)s(
%(parameters)s
)""" % locals()
def _java_method_do_post_response(self):
write_http_servlet_response_body = indent(' ' * 4, self._java_write_http_servlet_response_body())
return """\
private void __doPostResponse(final javax.servlet.http.HttpServletRequest httpServletRequest, final javax.servlet.http.HttpServletResponse httpServletResponse, final String httpServletResponseBody) throws java.io.IOException {
%(write_http_servlet_response_body)s
}
""" % locals()
def _java_method_do_post_response(self):
write_http_servlet_response_body = indent(
' ' * 4, self._java_write_http_servlet_response_body())
return """\
private void __doPostResponse(final javax.servlet.http.HttpServletRequest httpServletRequest, final javax.servlet.http.HttpServletResponse httpServletResponse, final Object jsonRpcRequestId, final Object jsonRpcResult) throws java.io.IOException {
final java.io.StringWriter httpServletResponseBodyWriter = new java.io.StringWriter();
try {
final org.thryft.protocol.JsonRpcOutputProtocol oprot = new org.thryft.protocol.JsonRpcOutputProtocol(new org.thryft.protocol.JacksonJsonOutputProtocol(httpServletResponseBodyWriter));
oprot.writeMessageBegin("", org.thryft.protocol.MessageType.REPLY, jsonRpcRequestId);
if (jsonRpcResult != null) {
oprot.writeMixed(jsonRpcResult);
} else {
oprot.writeStructBegin("response");
oprot.writeStructEnd();
}
oprot.writeMessageEnd();
oprot.flush();
} catch (final org.thryft.protocol.OutputProtocolException e) {
logger.error("error serializing service error response: ", e);
throw new IllegalStateException(e);
}
__doPostResponse(httpServletRequest, httpServletResponse, httpServletResponseBodyWriter.toString());
}
private void __doPostResponse(final javax.servlet.http.HttpServletRequest httpServletRequest, final javax.servlet.http.HttpServletResponse httpServletResponse, final String httpServletResponseBody) throws java.io.IOException {
%(write_http_servlet_response_body)s
}
""" % locals()
def js_validation(self, value, value_name, depth=0):
if isinstance(self.element_type, _JsCompoundType):
element_type_qname = self.element_type.js_qname()
return {
'type':
"""\
if (!(%(value)s instanceof Backbone.Collection)) {
return "expected %(value_name)s to be a Backbone.Collection";
}
if (%(value)s.model !== %(element_type_qname)s) {
return "expected %(value_name)s to be a Backbone.Collection with model=%(element_type_qname)s";
}
if (!%(value)s.isValid(true)) {
return %(value)s.validationError;
}""" % locals()
}
else:
element_validate = \
indent(' ' * 4,
self.element_type.js_validation(
depth=depth + 1,
value=value + "[__i%(depth)u]" % locals(),
value_name=value_name + "[i]" % locals()
)['type']
)
return {
'type':
"""\
if (!Array.isArray(%(value)s)) {
return "expected %(value_name)s to be an Array";
}
for (var __i%(depth)u = 0; __i%(depth)u < %(value)s.length; __i%(depth)u++) {
%(element_validate)s
}""" % locals()
}
