Dépôt officiel du code source de l'ERP OpenConcerto

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.
 * 
 * The contents of this file are subject to the terms of the GNU General Public License Version 3
 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each file.
 */
 
 package org.openconcerto.ui.group;

import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;

import net.jcip.annotations.GuardedBy;

public class Item {

    public static Item copy(final Item item, final Group newParent) {
        return item instanceof Group ? Group.copy((Group) item, newParent) : new Item(item, newParent);
    }

    private String id;
    @GuardedBy("this")
    private boolean frozen;
    private Group parent;
    private LayoutHints localHint;

    public Item(final String id) {
        this(id, null);
    }

    public Item(final String id, final LayoutHints hint) {
        this.id = id.trim();
        this.frozen = false;
        this.setLocalHint(hint);
    }

    public Item(final Item item, final Group newParent) {
        this.id = item.id;
        // no need to copy if frozen
        this.frozen = false;
        this.parent = newParent;
        this.setLocalHint(item.localHint);
    }

    public final String getId() {
        return this.id;
    }

    public final void setId(final String id) {
        checkFrozen("setId");
        this.id = id;
    }

    public final synchronized boolean isFrozen() {
        return this.frozen;
    }

    protected final void checkFrozen(String op) {
        if (this.isFrozen())
            throw new IllegalStateException("Frozen cannot " + op);
    }

    public synchronized final void freeze() {
        if (this.getParent() != null)
            throw new IllegalStateException("Can only freeze from the root down");
        this._freeze();
    }

    protected synchronized void _freeze() {
        this.frozen = true;
    }

    public final Item getChildFromID(final String id) {
        return this.getDescFromID(id, 1);
    }

    /**
     * Get all descendant leaves, including this.
     * 
     * @return the descendant non-group.
     */
    public Collection<Item> getDescendantItems() {
        return Collections.singletonList(this);
    }

    protected void getDescendantItems(final Collection<Item> res) {
        res.add(this);
    }

    public final Item getDescFromID(final String id) {
        return this.getDescFromID(id, -1);
    }

    public Item getDescFromID(final String id, final int maxLevel) {
        return this.getId().equals(id) ? this : null;
    }

    public Group getParent() {
        return this.parent;
    }

    final void setParent(Group parent) {
        checkFrozen("setParent");
        this.parent = parent;
    }

    public LayoutHints getLocalHint() {
        return this.localHint;
    }

    public void setLocalHint(final LayoutHints localHint) {
        checkFrozen("setLocalHint");
        this.localHint = new LayoutHints(localHint == null ? LayoutHints.DEFAULT_FIELD_HINTS : localHint);
    }

    public final void applyUntilRoot(final Consumer<Item> cons) {
        Item current = this;
        while (current != null) {
            cons.accept(current);
            current = current.getParent();
        }
    }

    public final List<String> getAbsolutePath() {
        final LinkedList<String> res = new LinkedList<>();
        this.applyUntilRoot((item) -> res.addFirst(item.getId()));
        return res;
    }

    public final Group getRoot() {
        final AtomicReference<Item> current = new AtomicReference<>();
        this.applyUntilRoot((item) -> current.set(item));
        return current.get() instanceof Group ? (Group) current.get() : null;
    }

    protected void printTree(final StringBuilder builder, final int localOrder, final int level) {
        for (int i = 0; i < level - 1; i++) {
            builder.append("  ");
        }

        builder.append("+-- ");
        builder.append(localOrder + " " + this.getId() + " [" + this.localHint + "]\n");
    }

    protected int printColumns(final StringBuilder builder, final int width, int x, final int localOrder, final int level) {
        if (this.localHint.largeWidth() && x > 0) {
            builder.append("\n");
            x = 0;
        }
        // print a leaf
        builder.append(" (" + x + ")");
        builder.append(localOrder + " " + this.getId() + "[" + this.localHint + "]");

        x++;
        if (x >= width || this.localHint.largeWidth()) {
            builder.append("\n");
            x = 0;
        }
        return x;
    }

    @Override
    public String toString() {
        return this.getClass().getSimpleName() + " '" + this.getId() + "'";
    }

    public boolean equalsDesc(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        final Item other = (Item) obj;
        return this.id.equals(other.id) && this.localHint.equals(other.localHint);
    }
}