Klasse.java

package de._82grfl1bif.kpiVisualizer.data;

import java.time.Duration;
import java.time.LocalDateTime;
import java.util.ArrayList;

public class Klasse {
    public String name;
    public String path;

    public int qloc;
    public static int qlocMin = Integer.MAX_VALUE;
    public static int qlocMax;
    public int loc;
    public static int locMin= Integer.MAX_VALUE;
    public static int locMax;
    public int commits;
    public static int commitsMin= Integer.MAX_VALUE;
    public static int commitsMax;
    public int depth;
    public static int depthMax;
    public int complexity;
    public static int complexityMax;
    public static int complexityMin= Integer.MAX_VALUE;

    public final int id;

    public int functions;
    public static int functionsMin= Integer.MAX_VALUE;
    public static int functionsMax;
    public int variables;
    public static int variablesMin= Integer.MAX_VALUE;
    public static int variablesMax;

    public Duration existingTime;
    public static Duration existingTimeMin;
    public static Duration existingTimeMax;
    public Duration lastEditingTime;
    public static Duration lastEditingTimeMin;
    public static Duration lastEditingTimeMax;
    public Duration firstCommitTime;
    public static Duration firstCommitTimeMin;
    public static Duration firstCommitTimeMax;
    ArrayList<LocalDateTime> commitTimes;

    public Klasse(int id, String name, String path, int qloc, int loc, int commits, int functions, int variables,int complexity, ArrayList<LocalDateTime> commitTimes){
        this.id = id;
        this.commits = commits;
        commitsMax = Math.max(commitsMax,commits);
        commitsMin = Math.min(commitsMin,commits);
        this.depth = getDepthOfPath(path);
        depthMax = Math.max(depthMax,depth);
        this.loc = loc;
        locMax = Math.max(locMax,loc);
        locMin = Math.min(locMin,loc);
        this.qloc = qloc;
        qlocMax = Math.max(qlocMax,qloc);
        qlocMin = Math.min(qlocMin,qloc);
        this.functions = functions;
        functionsMax = Math.max(functionsMax,functions);
        functionsMin = Math.min(functionsMin,functions);
        this.variables = variables;
        variablesMax = Math.max(variablesMax,variables);
        variablesMin = Math.min(variablesMin,variables);
        this.complexity = complexity;
        complexityMax = Math.max(complexityMax,complexity);
        complexityMin = Math.min(complexityMin,complexity);
        this.name = name;
        this.path = path;
        this.commitTimes = commitTimes;
        this.existingTime = (commitTimes.isEmpty()) ? null:Duration.between(commitTimes.get(commitTimes.size()-1), commitTimes.get(0));
        if (existingTime != null) {
            if(existingTimeMax == null) existingTimeMax = Duration.ofMillis(Long.MIN_VALUE);
            if(existingTimeMin == null) existingTimeMin = Duration.ofMillis((Long.MAX_VALUE));
            existingTimeMax = (existingTimeMax.toMillis() >= existingTime.toMillis()) ? existingTimeMax : existingTime;
            existingTimeMin = (existingTimeMin.toMillis() <= existingTime.toMillis()) ? existingTimeMin : existingTime;
        }
        this.lastEditingTime = (commitTimes.isEmpty()) ? null:Duration.between(commitTimes.get(0),LocalDateTime.now());
        if (lastEditingTime != null) {
            if(lastEditingTimeMax == null) lastEditingTimeMax = Duration.ofMillis(Long.MIN_VALUE);
            if(lastEditingTimeMin == null) lastEditingTimeMin = Duration.ofMillis(Long.MAX_VALUE);
            lastEditingTimeMax = (lastEditingTimeMax.toMillis() >= lastEditingTime.toMillis()) ? lastEditingTimeMax : lastEditingTime;
            lastEditingTimeMin = (lastEditingTimeMin.toMillis() <= lastEditingTime.toMillis()) ? lastEditingTimeMin : lastEditingTime;
        }
        this.firstCommitTime = (commitTimes.isEmpty()) ? null:Duration.between(commitTimes.get(commitTimes.size()-1),LocalDateTime.now());
        if (firstCommitTime != null) {
            if(firstCommitTimeMax == null) firstCommitTimeMax = Duration.ofMillis(Long.MIN_VALUE);
            if(firstCommitTimeMin == null) firstCommitTimeMin = Duration.ofMillis(Long.MAX_VALUE);
            firstCommitTimeMax = (firstCommitTimeMax.toMillis() >= firstCommitTime.toMillis()) ? firstCommitTimeMax : firstCommitTime;
            firstCommitTimeMin = (firstCommitTimeMin.toMillis() <= firstCommitTime.toMillis()) ? firstCommitTimeMin : firstCommitTime;
        }
    }

    private int getDepthOfPath(String path){
        int result = -1;
        if(path.contains("tmp")){
            result = path.split("/").length-2;
        }
        return result;
    }

}