JarFileMetrics.java

package org.example.model;

import lombok.Data;

import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

@Data
public class JarFileMetrics {
    private Map<String, String> classNameToParentName;
    private Map<String, List<String>> classNameToMethodSignatures;
    private Map<String, Integer> classNameToMaxDepth;
    private Map<String, Integer> classNameToOverriddenMethodsCount;
    private Map<String, ClassMetrics> classNameToClassMetrics;

    public JarFileMetrics() {
        this.classNameToParentName = new HashMap<>();
        this.classNameToMethodSignatures = new HashMap<>();
        this.classNameToMaxDepth = new HashMap<>();
        this.classNameToOverriddenMethodsCount = new HashMap<>();
        this.classNameToClassMetrics = new HashMap<>();
    }

    public void addClassNameToParentName(String className, String classParentName) {
        this.classNameToParentName.put(className, classParentName);
    }

    public void addClassNameToMethodsSignatures(String className, List<String> methodSignatures) {
        this.classNameToMethodSignatures.put(className, methodSignatures);
    }

    public void addClassNameToClassMetrics(ClassMetrics classMetrics) {
        this.classNameToClassMetrics.put(classMetrics.getName(), classMetrics);
    }

    public void calculateMetrics() {
        for (var className : classNameToParentName.keySet()) {
            calculateMaxDepth(className);
        }

        for (var className : classNameToMethodSignatures.keySet()) {
            var methods = classNameToMethodSignatures.get(className);
            countOverriddenMethods(className, methods);
        }
    }

    public int getMaxInheritanceDepth() {
        return classNameToMaxDepth.values().stream()
                .max(Integer::compareTo)
                .orElse(0);
    }

    public double getAvgInheritanceDepth() {
        return classNameToMaxDepth.values().stream()
                .mapToInt(Integer::intValue)
                .average()
                .orElse(0.0);
    }

    public double getAvgAbcMetric() {
        return classNameToClassMetrics.values().stream()
                .flatMap(classMetrics -> classMetrics.getMethodMetrics().stream())
                .map(MethodMetrics::getAbcMetric)
                .mapToDouble(ABCMetric::getMetricValue)
                .average()
                .orElse(0.0);
    }

    public double getAvgOverriddenMethods() {
        return classNameToOverriddenMethodsCount.values().stream()
                .mapToInt(Integer::intValue)
                .average()
                .orElse(0.0);
    }

    public double getAvgFieldCount() {
        return classNameToClassMetrics.values().stream()
                .mapToInt(ClassMetrics::getFieldCount)
                .average()
                .orElse(0.0);
    }

    private void calculateMaxDepth(String className) {
        var depth = 0;
        var currentClassName = className;

        while (classNameToParentName.containsKey(currentClassName)) {
            depth++;
            currentClassName = classNameToParentName.get(currentClassName);
        }

        classNameToMaxDepth.put(className, depth);
    }

    private void countOverriddenMethods(String className, List<String> methods) {
        if (!classNameToParentName.containsKey(className)) {
            classNameToOverriddenMethodsCount.put(className, 0);
            return;
        }

        var parent = classNameToParentName.get(className);
        Set<String> inheritedMethods = new HashSet<>();

        // Собираем все методы всех родительских классов
        while (parent != null) {
            var parentMethods = classNameToMethodSignatures.get(parent);
            if (parentMethods != null) {
                inheritedMethods.addAll(parentMethods);
            }
            parent = classNameToParentName.get(parent);
        }

        // Считаем переопределения
        var overriddenCount = methods.stream()
                .filter(inheritedMethods::contains)
                .count();

        classNameToOverriddenMethodsCount.put(className, (int) overriddenCount);
    }
}