FileGroup.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2019 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.autopsy.filequery;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.openide.util.NbBundle.Messages;
import org.sleuthkit.autopsy.filequery.FileSearch.GroupKey;

class FileGroup implements Comparable<FileGroup> {

    private final FileGroup.GroupSortingAlgorithm groupSortingType;
    private final GroupKey groupKey;
    private final List<ResultFile> files;
    private final String displayName;

    FileGroup(FileGroup.GroupSortingAlgorithm groupSortingType, GroupKey groupKey) {
        this.groupSortingType = groupSortingType;
        this.groupKey = groupKey;
        files = new ArrayList<>();
        this.displayName = groupKey.getDisplayName();
    }

    void addFile(ResultFile file) {
        if (files.contains(file)) {
            ResultFile existingCopy = files.get(files.indexOf(file)); //get the copy of this which exists in the list
            existingCopy.addDuplicate(file.getFirstInstance());
        } else {
            files.add(file);
        }
    }

    String getDisplayName() {
        return displayName; // NON-NLS
    }

    GroupKey getGroupKey() {
        return groupKey;
    }

    void sortFiles(FileSorter sorter) {
        Collections.sort(files, sorter);
    }

    @Override
    public int compareTo(FileGroup otherGroup) {

        switch (groupSortingType) {
            case BY_GROUP_SIZE:
                return compareGroupsBySize(this, otherGroup);
            case BY_GROUP_NAME:
            default:
                return compareGroupsByGroupKey(this, otherGroup);
        }
    }

    private static int compareGroupsByGroupKey(FileGroup group1, FileGroup group2) {
        return group1.getGroupKey().compareTo(group2.getGroupKey());
    }

    private static int compareGroupsBySize(FileGroup group1, FileGroup group2) {
        if (group1.getFiles().size() != group2.getFiles().size()) {
            return -1 * Long.compare(group1.getFiles().size(), group2.getFiles().size()); // High to low
        } else {
            // If the groups have the same size, fall through to the BY_GROUP_NAME sorting
            return compareGroupsByGroupKey(group1, group2);
        }
    }

    @Messages({"FileGroup.groupSortingAlgorithm.groupSize.text=Group Size",
        "FileGroup.groupSortingAlgorithm.groupName.text=Group Name"})
    enum GroupSortingAlgorithm {
        BY_GROUP_NAME(Bundle.FileGroup_groupSortingAlgorithm_groupName_text()), // Sort using the group key (for example, if grouping by size sort from largest to smallest value)
        BY_GROUP_SIZE(Bundle.FileGroup_groupSortingAlgorithm_groupSize_text());  // Sort from largest to smallest group

        private final String displayName;

        GroupSortingAlgorithm(String name) {
            displayName = name;
        }

        @Override
        public String toString() {
            return displayName;
        }

    }

    List<ResultFile> getFiles() {
        return Collections.unmodifiableList(files);
    }

}