ResultViewerPersistence.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2017-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.autopsy.corecomponents;
 
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.TreeMap;
import java.util.prefs.Preferences;
import javax.swing.SortOrder;
import org.openide.nodes.Children;
import org.openide.nodes.Node;
import org.openide.util.NbPreferences;
 
final class ResultViewerPersistence {
 
    private ResultViewerPersistence() {
    }

    static String getColumnPositionKey(TableFilterNode node, String propName) {
        return getColumnKeyBase(node, propName) + ".column";
    }

    static String getColumnSortOrderKey(TableFilterNode node, String propName) {
        return getColumnKeyBase(node, propName) + ".sortOrder";
    }

    static String getColumnSortRankKey(TableFilterNode node, String propName) {
        return getColumnKeyBase(node, propName) + ".sortRank";
    }

    static String getColumnHiddenKey(TableFilterNode node, String propName) {
        return getColumnKeyBase(node, propName) + ".hidden";
    }
 
    private static String getColumnKeyBase(TableFilterNode node, String propName) {
        return stripNonAlphanumeric(node.getColumnOrderKey()) + "." + stripNonAlphanumeric(propName);
    }
 
    private static String stripNonAlphanumeric(String str) {
        return str.replaceAll("[^a-zA-Z0-9_]", "");
    }

    static List<Node.Property<?>> getAllChildProperties(Node node, int maxRows) {
        // This is a set because we add properties of up to 100 child nodes, and we want unique properties
        Set<Node.Property<?>> propertiesAcc = new LinkedHashSet<>();
        getAllChildPropertiesHelper(node, maxRows, propertiesAcc);
        return new ArrayList<>(propertiesAcc);
    }

    static private void getAllChildPropertiesHelper(Node node, int maxRows, Set<Node.Property<?>> propertiesAcc) {
        Children children = node.getChildren();
        int childCount = 0;
        for (Node child : children.getNodes(true)) {
            childCount++;
            if (childCount > maxRows) {
                return;
            }
            for (Node.PropertySet ps : child.getPropertySets()) {
                final Node.Property<?>[] props = ps.getProperties();
                final int propsNum = props.length;
                for (int j = 0; j < propsNum; ++j) {
                    propertiesAcc.add(props[j]);
                }
            }
            getAllChildPropertiesHelper(child, maxRows, propertiesAcc);
        }
    }

    static List< SortCriterion> loadSortCriteria(TableFilterNode node) {
        List<Node.Property<?>> availableProperties = ResultViewerPersistence.getAllChildProperties(node, 100);
        final Preferences preferences = NbPreferences.forModule(DataResultViewerTable.class);
        java.util.SortedMap<Integer, SortCriterion> criteriaMap = new TreeMap<>();
        availableProperties.forEach(prop -> {
            //if the sort rank is undefined, it will be defaulted to 0 => unsorted.
            Integer sortRank = preferences.getInt(ResultViewerPersistence.getColumnSortRankKey(node, prop.getName()), 0);
 
            if (sortRank != 0) {
                final SortOrder sortOrder = preferences.getBoolean(ResultViewerPersistence.getColumnSortOrderKey(node, prop.getName()), true)
                        ? SortOrder.ASCENDING
                        : SortOrder.DESCENDING;
                final SortCriterion sortCriterion = new SortCriterion(prop, sortOrder, sortRank);
                criteriaMap.put(sortRank, sortCriterion);
            }
        });
        return new ArrayList<>(criteriaMap.values());
    }

    static class SortCriterion {
 
        private final Node.Property<?> prop;
        private final SortOrder order;
        private final int rank;
 
        int getSortRank() {
            return rank;
        }
 
        Node.Property<?> getProperty() {
            return prop;
        }
 
        SortOrder getSortOrder() {
            return order;
        }
 
        SortCriterion(Node.Property<?> prop, SortOrder order, int rank) {
            this.prop = prop;
            this.order = order;
            this.rank = rank;
        }
 
        @Override
        public String toString() {
            return getSortRank() + ". "
                    + getProperty().getName() + " "
                    + (getSortOrder() == SortOrder.ASCENDING
                            ? "\u25B2" // /\
                            : "\u25BC");// \/
        }
    }
}