NamedTreeNode.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2023 The Gridarta Developers.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
package net.sf.gridarta.model.data;
 
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.SortedMap;
import java.util.TreeMap;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class NamedTreeNode<E extends NamedObject> implements TreeNode, Comparable<NamedTreeNode<E>>, Serializable {
 
    private static final long serialVersionUID = 1L;
 
    @NotNull
    private final SortedMap<String, NamedTreeNode<E>> childNodes = new TreeMap<>();
 
    private NamedTreeNode<?> @Nullable [] childNodeArray;
 
    @Nullable
    private final NamedTreeNode<E> parent;
 
    @NotNull
    private final String name;
 
    @Nullable
    private final NamedObject namedObject;
 
    private final boolean dir;
 
    public NamedTreeNode() {
        this(true, null, "/");
    }
 
    private NamedTreeNode(final boolean dir, @Nullable final NamedTreeNode<E> parent, @NotNull final String name) {
        this.dir = dir;
        this.parent = parent;
        this.name = name;
        namedObject = null;
    }
 
    private NamedTreeNode(final boolean dir, @Nullable final NamedTreeNode<E> parent, @NotNull final NamedObject namedObject) {
        this.dir = dir;
        this.parent = parent;
        name = namedObject.getName();
        this.namedObject = namedObject;
    }
 
    public void append(@NotNull final NamedObject namedObject) throws IllegalNamedObjectException {
        if (parent != null) {
            throw new IllegalNamedObjectException("node '" + namedObject.getPath() + "' is not a root node");
        }
        append(namedObject.getPath(), namedObject);
    }
 
    private void append(@NotNull final String path, @NotNull final NamedObject namedObject) throws IllegalNamedObjectException {
        childNodeArray = null;
        if (!dir) {
            throw new IllegalNamedObjectException("cannot insert '" + path + "' into non-directory node for '" + namedObject.getPath() + "'");
        }
        String realName = path.startsWith("/") ? path.substring(1) : path;
        // Now we have the child node name in realName
        if (realName.contains("/")) {
            // Find directory node and append there
            final String dirName = realName.substring(0, realName.indexOf('/'));
            realName = realName.substring(realName.indexOf('/'));
            NamedTreeNode<E> dirNode = childNodes.get(dirName);
            if (dirNode == null) {
                dirNode = new NamedTreeNode<>(true, this, dirName);
                childNodes.put(dirName, dirNode);
            }
            dirNode.append(realName, namedObject);
        } else {
            // Append face node to this
            //realName = realName.substring(0, realName.length() - 4);
            final NamedTreeNode<E> faceNode = new NamedTreeNode<>(false, this, namedObject);
            childNodes.put(realName, faceNode);
        }
    }
 
    private void initLazyArray() {
        if (childNodeArray == null) {
            childNodeArray = childNodes.values().toArray(new NamedTreeNode<?>[0]);
        }
    }
 
    // --Commented out by Inspection START (09.06.05 04:00):
    //    /** Check whether this is a directory node.
    //     * @return {@code true} for directory nodes, {@code false} for face nodes
    //     */
    //    public final boolean isDir() {
    //        return dir;
    //    }
    // --Commented out by Inspection STOP (09.06.05 04:00)
 
    @Nullable
    public NamedObject getNamedObject() {
        return namedObject;
    }
 
    @NotNull
    public String getName() {
        return name;
    }
 
    @NotNull
    @Override
    public Enumeration<NamedTreeNode<E>> children() {
        return Collections.enumeration(childNodes.values());
    }
 
    @Override
    public boolean getAllowsChildren() {
        return dir;
    }
 
    @NotNull
    @Override
    public TreeNode getChildAt(final int childIndex) {
        initLazyArray();
        assert childNodeArray != null;
        return childNodeArray[childIndex];
    }
 
    @Override
    public int getChildCount() {
        return childNodes.size();
    }
 
    @Override
    public int getIndex(@NotNull final TreeNode node) {
        initLazyArray();
        final int result = Arrays.binarySearch(childNodeArray, node);
        return result < 0 ? -1 : result;
    }
 
    @Nullable
    @Override
    public NamedTreeNode<E> getParent() {
        return parent;
    }
 
    @Override
    public boolean isLeaf() {
        return !dir;
    }
 
    @Override
    public boolean equals(@Nullable final Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj == null || obj.getClass() != getClass()) {
            return false;
        }
        final NamedTreeNode<?> namedTreeNode = (NamedTreeNode<?>) obj;
        return dir == namedTreeNode.dir && name.equals(namedTreeNode.name);
    }
 
    @Override
    public int hashCode() {
        return (dir ? 1 : 0) ^ name.hashCode();
    }
 
    @Override
    public int compareTo(@NotNull final NamedTreeNode<E> o) {
        return dir ^ !o.dir ? name.compareTo(o.name) : dir ? -1 : 1;
    }
 
    @NotNull
    public TreePath getPathFor(@NotNull final String path) {
        final Collection<NamedTreeNode<E>> nodes = new ArrayList<>();
        String currentPath = path;
        // XXX This is ugly but it works, no time to think about it now.
        String dirPart;
        for (NamedTreeNode<E> currentNode = this; currentNode != null; currentNode = currentNode.childNodes.get(dirPart)) {
            nodes.add(currentNode);
            if (currentPath.indexOf('/', 1) >= 0) {
                dirPart = currentPath.substring(1, currentPath.indexOf('/', 1));
                currentPath = currentPath.substring(currentPath.indexOf('/', 1));
            } else if (currentPath.indexOf('/') >= 0) {
                dirPart = currentPath.substring(1);
                currentPath = "";
            } else {
                break;
            }
        }
        return new TreePath(nodes.toArray());
    }
 
    @NotNull
    @Override
    public String toString() {
        return name;
    }
 
}