Esempio n. 1
0
    def _compute_package_match(self, actual_params, formal_params):
        matches = 0
        size = len(actual_params)

        if size != formal_params.count():
            matches = 0
        else:
            actuals = [je.get_package_name(actual_param, True)
                    for actual_param in actual_params]
            formals = [je.get_package_name(formal_param.type_fqn, True)
                    for formal_param in formal_params]
            for (actual, formal) in zip(actuals, formals):
                if actual is None or formal is None:
                    continue
                elif actual == formal:
                    matches += 1
                else:
                    matches = self._compute_partial_pkg_match(actual, formal)

        return matches
Esempio n. 2
0
    def _compute_package_match(self, actual_params, formal_params):
        matches = 0
        size = len(actual_params)

        if size != formal_params.count():
            matches = 0
        else:
            actuals = [
                je.get_package_name(actual_param, True)
                for actual_param in actual_params
            ]
            formals = [
                je.get_package_name(formal_param.type_fqn, True)
                for formal_param in formal_params
            ]
            for (actual, formal) in zip(actuals, formals):
                if actual is None or formal is None:
                    continue
                elif actual == formal:
                    matches += 1
                else:
                    matches = self._compute_partial_pkg_match(actual, formal)

        return matches
Esempio n. 3
0
    def _get_field_name(self, scode_reference):
        field_name = fqn_container = None

        if scode_reference.snippet != None:
            parts = scode_reference.content.split(HANDLE_SEPARATOR)
            (field_name, fqn_container) = \
                    self._get_field_name_from_snippet(parts)
        else:
            content = je.get_clean_name(scode_reference.content)
            (field_name, fqn) = je.clean_java_name(content)
            if fqn != field_name:
                fqn = je.get_package_name(fqn)
                fqn_container = je.clean_potential_annotation(fqn)

        return (su.safe_strip(field_name), su.safe_strip(fqn_container))
Esempio n. 4
0
    def _get_field_name(self, scode_reference):
        field_name = fqn_container = None

        if scode_reference.snippet != None:
            parts = scode_reference.content.split(HANDLE_SEPARATOR)
            (field_name, fqn_container) = \
                    self._get_field_name_from_snippet(parts)
        else:
            content = je.get_clean_name(scode_reference.content)
            (field_name, fqn) = je.clean_java_name(content)
            if fqn != field_name:
                fqn = je.get_package_name(fqn)
                fqn_container = je.clean_potential_annotation(fqn)

        return (su.safe_strip(field_name), su.safe_strip(fqn_container))
Esempio n. 5
0
    def _process_tuples(self, class_tuples, progress_monitor):
        method_tuples = []
        field_tuples = []
        count = 0

        for (reference, simple, fqn, class_elements, method_elements,
             field_elements) in class_tuples:
            if len(class_elements) > 0:
                log = gl.LinkerLog(self, 'generic-' + self.class_kind.kind)
                (code_element, potentials) = \
                        self.class_linker.get_code_element(reference,
                                class_elements, simple, fqn, log, True)
                if code_element is not None:
                    count += gl.save_link(reference, code_element, potentials,
                                          self)
                else:
                    method_tuples.append((reference, simple, fqn,
                                          method_elements, field_elements))
                log.close()
            else:
                method_tuples.append(
                    (reference, simple, fqn, method_elements, field_elements))

        for (reference, simple, fqn, method_elements,
             field_elements) in method_tuples:
            if len(method_elements) > 0:
                fqn_container = je.get_package_name(fqn)
                if fqn_container == simple:
                    fqn_container = None
                log = gl.LinkerLog(self, 'generic-' + self.method_kind.kind)
                method_info = MethodInfo(simple, fqn_container, None, None)
                (code_element, potentials) =\
                        self.method_linker.get_code_element(reference,
                                method_elements, method_info, log)
                if code_element is not None:
                    count += gl.save_link(reference, code_element, potentials,
                                          self)
                else:
                    field_tuples.append(
                        (reference, simple, fqn, field_elements))
                log.close()
            else:
                field_tuples.append((reference, simple, fqn, field_elements))

        for (reference, simple, fqn, field_elements) in field_tuples:
            if len(field_elements) > 0:
                fqn_container = je.get_package_name(fqn)
                if fqn_container == simple:
                    fqn_container = None
                log = gl.LinkerLog(self, 'generic-' + self.field_kind.kind)
                (code_element, potentials) =\
                        self.field_linker.get_code_element(reference,
                                field_elements, simple, fqn_container, log)
                if code_element is not None:
                    count += gl.save_link(reference, code_element, potentials,
                                          self)
                else:
                    field_tuples.append(
                        (reference, simple, fqn, field_elements))
                log.close()

        return count
Esempio n. 6
0
    def _process_tuples(self, class_tuples, progress_monitor):
        method_tuples = []
        field_tuples = []
        count = 0

        for (reference, simple, fqn, class_elements, method_elements,
                field_elements) in class_tuples:
            if len(class_elements) > 0:
                log = gl.LinkerLog(self, 'generic-' + self.class_kind.kind)
                (code_element, potentials) = \
                        self.class_linker.get_code_element(reference,
                                class_elements, simple, fqn, log, True)
                if code_element is not None:
                    count += gl.save_link(reference, code_element,
                            potentials, self)
                else:
                    method_tuples.append((reference, simple, fqn,
                        method_elements, field_elements))
                log.close()
            else:
                method_tuples.append((reference, simple, fqn,
                    method_elements, field_elements))

        for (reference, simple, fqn, method_elements,
                field_elements) in method_tuples:
            if len(method_elements) > 0:
                fqn_container = je.get_package_name(fqn)
                if fqn_container == simple:
                    fqn_container = None
                log = gl.LinkerLog(self, 'generic-' + self.method_kind.kind)
                method_info = MethodInfo(simple, fqn_container, None, None)
                (code_element, potentials) =\
                        self.method_linker.get_code_element(reference,
                                method_elements, method_info, log)
                if code_element is not None:
                    count += gl.save_link(reference, code_element,
                            potentials, self)
                else:
                    field_tuples.append((reference, simple, fqn,
                        field_elements))
                log.close()
            else:
                field_tuples.append((reference, simple, fqn, field_elements))

        for (reference, simple, fqn, field_elements) in field_tuples:
            if len(field_elements) > 0:
                fqn_container = je.get_package_name(fqn)
                if fqn_container == simple:
                    fqn_container = None
                log = gl.LinkerLog(self, 'generic-' + self.field_kind.kind)
                (code_element, potentials) =\
                        self.field_linker.get_code_element(reference,
                                field_elements, simple, fqn_container, log)
                if code_element is not None:
                    count += gl.save_link(reference, code_element,
                            potentials, self)
                else:
                    field_tuples.append((reference, simple, fqn,
                        field_elements))
                log.close()

        return count