Score.java

Go to the documentation of this file.

/*
 * Sleuth Kit Data Model
 *
 * Copyright 2020-2021 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.sleuthkit.datamodel;

import java.util.Arrays;
import java.util.Comparator;
import java.util.ResourceBundle;

public class Score implements Comparable<Score> {

        private static final ResourceBundle bundle = ResourceBundle.getBundle("org.sleuthkit.datamodel.Bundle");
        public enum Significance {

                // Enum name must not have any spaces.

        /* Notes on the ordinal numbers: We defined these so that we could easily
         * compare values while also have some concept of grouping. 
         * The 1x values are a higher confidence than the 0x files.
         * NOTABLE (x9) has priority over NOT NOTABLE (x8). 
         * If we need to make this more complicated in the future, we can add
         * other groupings, such as 14 and 15. 
         */
                
                UNKNOWN(0, "Unknown", "Significance.Unknown.displayName.text"), 
                
                LIKELY_NONE(8, "LikelyNone", "Significance.LikelyNone.displayName.text"),
                
                LIKELY_NOTABLE(9, "LikelyNotable", "Significance.LikelyNotable.displayName.text"),      
                
                NONE(18, "None", "Significance.None.displayName.text"),         
                
                NOTABLE(19, "Notable", "Significance.Notable.displayName.text");                                
                
                private final int id;
                private final String name;      // name must not have spaces
                private final String displayNameKey; // display name is loaded from resource bundle using this key.

                private Significance(int id, String name, String displayNameKey) {
                        this.id = id;
                        this.name = name;
                        this.displayNameKey = displayNameKey;
                }

                public static Significance fromString(String name) {
                        return Arrays.stream(values())
                                        .filter(val -> val.getName().equals(name))
                                        .findFirst().orElse(NONE);
                }

                static public Significance fromID(int id) {
                        return Arrays.stream(values())
                                        .filter(val -> val.getId() == id)
                                        .findFirst().orElse(NONE);
                }

                public int getId() {
                        return id;
                }

                public String getName() {
                        return name;
                }

                public String getDisplayName() {
                        return  bundle.getString(displayNameKey);
                }
                        
                @Override
                public String toString() {
                        return name;
                }
        }

        public enum Priority {

                // Name must not have any spaces.
                NORMAL(0, "Normal",  "Score.Priority.Normal.displayName.text"),
                OVERRIDE(10, "Override", "Score.Priority.Override.displayName.text"); 

                private final int id;
                private final String name; 
                private final String displayNameKey; // display name is loaded from resource bundle using this key.
                
                private Priority(int id, String name, String displayNameKey) {
                        this.id = id;
                        this.name = name;
                        this.displayNameKey = displayNameKey;
                }

                public static Priority fromString(String name) {
                        return Arrays.stream(values())
                                        .filter(val -> val.getName().equals(name))
                                        .findFirst().orElse(NORMAL);
                }

                static public Priority fromID(int id) {
                        return Arrays.stream(values())
                                        .filter(val -> val.getId() == id)
                                        .findFirst().orElse(NORMAL);
                }

                public int getId() {
                        return id;
                }

                public String getName() {
                        return name;
                }

                public String getDisplayName() {
                        return bundle.getString(displayNameKey);
                }
                
                @Override
                public String toString() {
                        return name;
                }
        }

        public static final Score SCORE_NOTABLE = new Score(Significance.NOTABLE, Priority.NORMAL);
        public static final Score SCORE_LIKELY_NOTABLE = new Score(Significance.LIKELY_NOTABLE, Priority.NORMAL);       
        public static final Score SCORE_LIKELY_NONE = new Score(Significance.LIKELY_NONE, Priority.NORMAL);
        public static final Score SCORE_NONE= new Score(Significance.NONE, Priority.NORMAL);
        
        public static final Score SCORE_UNKNOWN = new Score(Significance.UNKNOWN, Priority.NORMAL);
        
        // Score is a combination of significance and priority.
        private final Significance significance;
        private final Priority priority;

        public Score(Significance significance, Priority priority) {
                this.significance = significance;
                this.priority = priority;
        }

        public Significance getSignificance() {
                return significance;
        }

        public Priority getPriority() {
                return priority;
        }

        @Override
        public int compareTo(Score other) {
                // A score is a combination of significance & priority.
                // Priority Override overrides Normal.
                // If two results have same priority, then the higher significance wins.
                if (this.getPriority() != other.getPriority()) {
                        return this.getPriority().ordinal() - other.getPriority().ordinal();
                } else {
                        return this.getSignificance().ordinal() - other.getSignificance().ordinal();
                }
        }
        
         public static final Comparator<Score> getScoreComparator() {
        return (Score score1, Score score2) -> {
                        return score1.compareTo(score2);
        };
    }
}