Python yutil.lpad函数代码示例

        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 __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 _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.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 _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 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 __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 _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 _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()
            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 __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 _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()
        }