BaseChildFactory.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.datamodel;
 
import com.google.common.collect.Lists;
import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Predicate;
import java.util.logging.Level;
import org.sleuthkit.autopsy.coreutils.Logger;
import java.util.prefs.PreferenceChangeEvent;
import java.util.stream.Collectors;
import org.openide.nodes.ChildFactory;
import org.openide.util.NbBundle.Messages;
import org.sleuthkit.autopsy.core.UserPreferences;
import org.sleuthkit.datamodel.Content;

public abstract class BaseChildFactory<T extends Content> extends ChildFactory.Detachable<T> {
 
    private static final Logger logger = Logger.getLogger(BaseChildFactory.class.getName());
 
    private Predicate<T> filter;
    private boolean isPageChangeEvent;
    private boolean isPageSizeChangeEvent;
 
    private final PagingSupport pagingSupport;

    private static Map<String, EventBus> nodeNameToEventBusMap = new ConcurrentHashMap<>();
 
    @Messages({
        "# {0} - node name", "BaseChildFactory.NoSuchEventBusException.message=No event bus for node: {0}"
    })
    public static class NoSuchEventBusException extends Exception {
 
        public NoSuchEventBusException(String nodeName) {
            super(Bundle.BaseChildFactory_NoSuchEventBusException_message(nodeName));
        }
    }

    public static void register(String nodeName, Object subscriber) {
        EventBus bus = nodeNameToEventBusMap.get(nodeName);
        if (bus == null) {
            bus = new EventBus(nodeName);
            nodeNameToEventBusMap.put(nodeName, bus);
        }
        bus.register(subscriber);
    }

    public static void post(String nodeName, Object event) throws NoSuchEventBusException {
        EventBus bus = nodeNameToEventBusMap.get(nodeName);
        if (bus == null) {
            throw new NoSuchEventBusException(nodeName);
        }
        bus.post(event);
    }
 
    public BaseChildFactory(String nodeName) {
        this(nodeName, x -> true);
    }
 
    public BaseChildFactory(String nodeName, Predicate<T> filter) {
        pagingSupport = new PagingSupport(nodeName);
        pagingSupport.initialize();
        isPageChangeEvent = false;
        isPageSizeChangeEvent = false;
        this.filter = filter;
    }
    
    @Override
    protected void addNotify() {
        onAdd();
    }
 
    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        onRemove();
    }

    protected abstract List<T> makeKeys();

    protected abstract void onAdd();

    protected abstract void onRemove();
 
    @Override
    protected boolean createKeys(List<T> toPopulate) {
        if (!isPageChangeEvent && !isPageSizeChangeEvent) {
            List<T> allKeys = makeKeys();
 
            pagingSupport.splitKeysIntoPages(allKeys.stream().filter(filter).collect(Collectors.toList()));
        }
 
        toPopulate.addAll(pagingSupport.getCurrentPage());
 
        // Reset page change and page size change event flags
        isPageChangeEvent = false;
        isPageSizeChangeEvent = false;
 
        return true;
    }

    public static class RefreshKeysEvent {
    }

    public static class PageChangeEvent {
 
        private final int pageNumber;
 
        public PageChangeEvent(int newPageNumber) {
            pageNumber = newPageNumber;
        }
 
        public int getPageNumber() {
            return pageNumber;
        }
    }

    public static class PageCountChangeEvent {
 
        private final int pageCount;
 
        public PageCountChangeEvent(int newPageCount) {
            pageCount = newPageCount;
        }
 
        public int getPageCount() {
            return pageCount;
        }
    }

    public static class PageSizeChangeEvent {
 
        private final int pageSize;
 
        public PageSizeChangeEvent(int newPageSize) {
            pageSize = newPageSize;
        }
 
        public int getPageSize() {
            return pageSize;
        }
    }

    private class PagingSupport {
 
        private final String nodeName;
        private int pageSize;
        private int currentPage;
        private List<List<T>> pages;

        PagingSupport(String nodeName) {
            currentPage = 1;
            pageSize = UserPreferences.getResultsTablePageSize();
            pages = new ArrayList<>();
            this.nodeName = nodeName;
        }
 
        void initialize() {
            UserPreferences.addChangeListener((PreferenceChangeEvent evt) -> {
                if (evt.getKey().equals(UserPreferences.RESULTS_TABLE_PAGE_SIZE)) {
                    pageSize = UserPreferences.getResultsTablePageSize();
                }
            });
 
            register(nodeName, this);
        }

        List<T> getCurrentPage() {
            if (!pages.isEmpty()) {
                return pages.get(currentPage - 1);
            }
 
            return Collections.emptyList();
        }

        void splitKeysIntoPages(List<T> keys) {
            int oldPageCount = pages.size();

            if (keys.isEmpty() && !pages.isEmpty()) {
                pages = new ArrayList<>();
            } else {
                pages = Lists.partition(keys, pageSize > 0 ? pageSize : keys.size());
            }
 
            if (pages.size() != oldPageCount) {
                try {
                    // Number of pages has changed so we need to send out a notification.
                    post(nodeName, new PageCountChangeEvent(pages.size()));
                } catch (NoSuchEventBusException ex) {
                    logger.log(Level.WARNING, "Failed to post page change event.", ex);
                }
            }
        }

        @Subscribe
        private void subscribeToPageChange(PageChangeEvent event) {
            if (event != null) {
                currentPage = event.getPageNumber();
                isPageChangeEvent = true;
                refresh(true);
            }
        }

        @Subscribe
        private void subscribeToPageSizeChange(PageSizeChangeEvent event) {
            if (event != null) {
                int newPageSize = event.getPageSize();
                if (pageSize == newPageSize) {
                    // No change...nothing to do.
                    return;
                }
 
                pageSize = newPageSize;
                splitKeysIntoPages(pages.stream().flatMap(List::stream).collect(Collectors.toList()));
 
                currentPage = 1;
                isPageSizeChangeEvent = true;
                refresh(true);
            }
        }
 
        @Subscribe
        private void subscribeToRefreshKeys(RefreshKeysEvent event) {
            if (event != null) {
                refresh(true);
            }
        }
    }
}