Example.java

package org.example;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;
import org.example.structs.ClassInfo;
import org.example.structs.MethodInfo;
import org.example.util.InheritanceDepthCalculator;
import org.example.util.OverrideDetector;
import org.example.visitor.ClassPrinter;
import org.objectweb.asm.ClassReader;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

public class Example {

    public static void main(String[] args) throws IOException {
        List<ClassInfo> allClasses = new ArrayList<>();

        try (JarFile sampleJar = new JarFile("src/main/resources/sample.jar")) {
            Enumeration<JarEntry> enumeration = sampleJar.entries();
            while (enumeration.hasMoreElements()) {
                JarEntry entry = enumeration.nextElement();
                if (entry.getName().endsWith(".class")) {
                    ClassPrinter cp = new ClassPrinter(allClasses);
                    InputStream inputStream = sampleJar.getInputStream(entry);
                    ClassReader reader = new ClassReader(inputStream);
                    reader.accept(cp, 0);
                }
            }
        }
        getStats(allClasses);
    }

    private static void getStats(
            List<ClassInfo> allClasses
    )
            throws IOException
    {
        int totalFields = 0;
        int totalA = 0;
        int totalB = 0;
        int totalC = 0;
        int totalOverrideMethods = 0;

        OverrideDetector detector = new OverrideDetector(allClasses);
        InheritanceDepthCalculator calc = new InheritanceDepthCalculator(allClasses);

        Map<String, String> superMap = new HashMap<>();
        for (ClassInfo classInfo : allClasses) {
            superMap.put(classInfo.name, classInfo.superName);
        }

        for (ClassInfo classInfo : allClasses) {
            totalFields += classInfo.fields.size();
            for (MethodInfo m : classInfo.methods) {
                totalA += m.assignments;
                totalB += m.branches;
                totalC += m.conditions;

                if (detector.isOverride(classInfo, m)) {
                    totalOverrideMethods++;
                }
            }
        }

        double abcMetric = Math.sqrt(
                totalA * totalA +
                        totalB * totalB +
                        totalC * totalC
        );

        int maxDepth = calc.getMaxDepth(allClasses);
        int avgDepth = calc.getAverageDepth(allClasses);

        int avgFields = !allClasses.isEmpty() ? (totalFields / allClasses.size()) : 0;
        int avgOverride = !allClasses.isEmpty() ? (totalOverrideMethods / allClasses.size()) : 0;

        System.out.println("Средняя глубина наследования: " + avgDepth);
        System.out.println("Максимальная глубина наследования: " + maxDepth);
        System.out.println("Среднее количество полей в классе: " + avgFields);
        System.out.println("Среднее количество переопределнных методов: " + avgOverride);
        System.out.println("Метрика ABC: " + abcMetric);

        Map<String, Object> metrics = new HashMap<>();
        metrics.put("averageInheritanceDepth", avgDepth);
        metrics.put("maxInheritanceDepth", maxDepth);
        metrics.put("averageFieldsPerClass", avgFields);
        metrics.put("averageOverriddenMethods", avgOverride);
        metrics.put("ABC_metric", Map.of(
                "A", totalA,
                "B", totalB,
                "C", totalC,
                "value", abcMetric
        ));

        ObjectMapper mapper = new ObjectMapper();
        ObjectWriter writer = mapper.writerWithDefaultPrettyPrinter();
        writer.writeValue(new File("results.json"), metrics);
    }
}