GameObjectContainer.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2015 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.baseobject;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.gameobject.NotInsideContainerException;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.model.mapmodel.MapSquare;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

@SuppressWarnings("ClassReferencesSubclass")
public abstract class GameObjectContainer<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> implements Cloneable, Iterable<G>, Serializable {

    private static final long serialVersionUID = 1L;

    @NotNull
    private List<G> contents;

    @NotNull
    private transient Iterable<G> recursive;

    @NotNull
    private transient Iterable<G> reverse;

    protected GameObjectContainer() {
        initData();
    }

    private void initData() {
        contents = new ArrayList<>(0);
        recursive = new Iterable<G>() {

            @Override
            public Iterator<G> iterator() {
                return new RecursiveGameObjectIterator<>(GameObjectContainer.this);
            }

        };
        reverse = new Iterable<G>() {

            @Override
            public Iterator<G> iterator() {
                return new ReverseIterator<>(contents);
            }

        };
    }

    @NotNull
    @Override
    public Iterator<G> iterator() {
        // Do not return contents.iterator() directly because otherwise the remove() operation will not properly unlink the removed GameObject from its container.
        return new Iterator<G>() {

            @NotNull
            private final Iterator<G> delegate = contents.iterator();

            @Nullable
            private G current;

            @Override
            public boolean hasNext() {
                return delegate.hasNext();
            }

            @Override
            public G next() {
                current = delegate.next();
                assert current != null;
                return current;
            }

            @Override
            public void remove() {
                final G tmp = current;
                if (tmp == null) {
                    throw new IllegalStateException();
                }
                // keep this in sync with GameObjectContainer#remove(G)
                // we can't simply invoke GameObjectContainer#remove(current) because that would result in a ConcurrentModificationException.
                notifyBeginChange();
                try {
                    if (contents.size() >= 2 && contents.get(0) == tmp) {
                        contents.get(1).propagateElevation(tmp);
                    }
                    delegate.remove();
                    tmp.setContainer(null, 0, 0);
                    current = null;
                } finally {
                    notifyEndChange();
                }
            }
        };
    }

    @NotNull
    public Iterable<G> reverse() {
        return reverse;
    }

    @NotNull
    public Iterable<G> recursive() {
        return recursive;
    }

    public boolean isEmpty() {
        return contents.isEmpty();
    }

    @Nullable
    public G getFirst() {
        return contents.isEmpty() ? null : contents.get(0);
    }

    @Nullable
    public G getPrev(@NotNull final G gameObject) {
        final Iterator<G> it = contents.iterator();
        while (it.hasNext()) {
            if (it.next() == gameObject) {
                return it.hasNext() ? it.next() : null;
            }
        }
        return null;
    }

    @Nullable
    public G getNext(@NotNull final G gameObject) {
        G prevGameObject = null;
        for (final G tmpGameObject : contents) {
            if (tmpGameObject == gameObject) {
                return prevGameObject;
            }
            prevGameObject = tmpGameObject;
        }
        return null;
    }

    @Nullable
    public G getLast() {
        return contents.isEmpty() ? null : contents.get(contents.size() - 1);
    }

    public void remove(@NotNull final G gameObject) {
        // keep this in sync with iterator()
        notifyBeginChange();
        try {
            if (contents.size() >= 2 && contents.get(0) == gameObject) {
                contents.get(1).propagateElevation(gameObject);
            }
            if (!contents.remove(gameObject)) {
                throw new NotInsideContainerException(this, gameObject);
            }
            gameObject.setContainer(null, 0, 0);
        } finally {
            notifyEndChange();
        }
    }

    public void removeAll() {
        if (contents.size() <= 0) {
            return;
        }

        notifyBeginChange();
        try {
            for (final GameObject<G, A, R> gameObject : contents) {
                gameObject.setContainer(null, 0, 0);
            }
            contents.clear();
        } finally {
            notifyEndChange();
        }
    }

    public boolean isTop(@NotNull final G gameObject) {
        return !contents.isEmpty() && contents.get(contents.size() - 1) == gameObject;
    }

    public boolean isBottom(@NotNull final G gameObject) {
        return !contents.isEmpty() && contents.get(0) == gameObject;
    }

    public void moveTop(@NotNull final G gameObject) {
        final int oldIndex = contents.indexOf(gameObject);
        if (oldIndex != contents.size() - 1) {
            notifyBeginChange();
            try {
                if (!contents.remove(gameObject)) {
                    throw new NotInsideContainerException(this, gameObject);
                }
                if (oldIndex == 0) {
                    assert contents.size() >= 1;
                    contents.get(0).propagateElevation(gameObject);
                }
                contents.add(gameObject);
            } finally {
                notifyEndChange();
            }
        }
    }

    public void moveUp(@NotNull final G gameObject) {
        final int oldIndex = contents.indexOf(gameObject);
        if (oldIndex < contents.size() - 1) {
            notifyBeginChange();
            try {
                if (!contents.remove(gameObject)) {
                    throw new NotInsideContainerException(this, gameObject);
                }
                if (oldIndex == 0) {
                    assert contents.size() >= 1;
                    contents.get(0).propagateElevation(gameObject);
                }
                contents.add(oldIndex + 1, gameObject);
            } finally {
                notifyEndChange();
            }
        }
    }

    public void moveDown(@NotNull final G gameObject) {
        final int oldIndex = contents.indexOf(gameObject);
        if (oldIndex > 0) {
            notifyBeginChange();
            try {
                if (!contents.remove(gameObject)) {
                    throw new NotInsideContainerException(this, gameObject);
                }
                if (oldIndex == 1) {
                    assert contents.size() >= 1;
                    gameObject.propagateElevation(contents.get(0));
                }
                contents.add(oldIndex - 1, gameObject);
            } finally {
                notifyEndChange();
            }
        }
    }

    public void moveBottom(@NotNull final G gameObject) {
        final int oldIndex = contents.indexOf(gameObject);
        if (oldIndex != 0) {
            notifyBeginChange();
            try {
                if (!contents.remove(gameObject)) {
                    throw new NotInsideContainerException(this, gameObject);
                }
                assert contents.size() >= 1;
                gameObject.propagateElevation(contents.get(0));
                contents.add(0, gameObject);
            } finally {
                notifyEndChange();
            }
        }
    }

    public void addLast(@NotNull final G gameObject) {
        if (gameObject.isInContainer()) {
            throw new IllegalArgumentException("Can't add " + gameObject + " to " + this + " because it's already inside " + gameObject.getContainer());
        }

        notifyBeginChange();
        try {
            contents.add(gameObject);
            setThisContainer(gameObject);
            gameObject.markModified();
        } finally {
            notifyEndChange();
        }
    }

    public void addFirst(@NotNull final G gameObject) {
        if (gameObject.isInContainer()) {
            throw new IllegalArgumentException("Can't add " + gameObject + " to " + this + " because it's already inside " + gameObject.getContainer());
        }

        notifyBeginChange();
        try {
            if (!contents.isEmpty()) {
                gameObject.propagateElevation(contents.get(0));
            }
            contents.add(0, gameObject);
            setThisContainer(gameObject);
            gameObject.markModified();
        } finally {
            notifyEndChange();
        }
    }

    public void insertAfter(@Nullable final G previousGameObject, @NotNull final G gameObject) {
        if (gameObject.isInContainer()) {
            throw new IllegalArgumentException("Can't add " + gameObject + " to " + this + " because it's already inside " + gameObject.getContainer());
        }

        if (previousGameObject == null) {
            addLast(gameObject);
            return;
        }

        if (!previousGameObject.isHead()) {
            throw new IllegalArgumentException();
        }

        notifyBeginChange();
        try {
            boolean added = false;
            int index = 0;
            for (final G tmpGameObject : contents) {
                if (tmpGameObject.getHead() == previousGameObject) {
                    if (index == 0) {
                        gameObject.propagateElevation(contents.get(0));
                    }
                    contents.add(index, gameObject);
                    added = true;
                    break;
                }
                index++;
            }
            if (!added) {
                throw new IllegalArgumentException("Can't add " + gameObject + " to " + this + " because " + previousGameObject + " is not inside");
            }
            setThisContainer(gameObject);
            gameObject.markModified();
        } finally {
            notifyEndChange();
        }
    }

    public void insertBefore(@NotNull final G gameObject, @Nullable final G nextGameObject) {
        if (gameObject.isInContainer()) {
            throw new IllegalArgumentException("Can't add " + gameObject + " to " + this + " because it's already inside " + gameObject.getContainer());
        }

        if (nextGameObject == null) {
            addFirst(gameObject);
            return;
        }

        if (!nextGameObject.isHead()) {
            throw new IllegalArgumentException();
        }

        notifyBeginChange();
        try {
            final int insertIndex = contents.indexOf(nextGameObject);
            if (insertIndex == -1) {
                throw new IllegalArgumentException("Can't insert " + gameObject + " before " + nextGameObject + " because that isn't inside " + this);
            }
            contents.add(insertIndex + 1, gameObject);
            setThisContainer(gameObject);
            gameObject.markModified();
        } finally {
            notifyEndChange();
        }
    }

    public void replace(@NotNull final G oldGameObject, @NotNull final G newGameObject) {
        if (oldGameObject.isMulti()) {
            throw new IllegalArgumentException();
        }

        notifyBeginChange();
        try {
            final int insertIndex = contents.indexOf(oldGameObject);
            if (insertIndex == -1) {
                throw new NotInsideContainerException(this, oldGameObject);
            }
            if (insertIndex == 0) {
                newGameObject.propagateElevation(oldGameObject);
            }
            contents.remove(oldGameObject);
            oldGameObject.setContainer(null, 0, 0);
            contents.add(insertIndex, newGameObject);
            setThisContainer(newGameObject);
            newGameObject.markModified();
        } finally {
            notifyEndChange();
        }
    }

    @Nullable
    public abstract MapSquare<G, A, R> getMapSquare();

    protected abstract void notifyBeginChange();

    protected abstract void notifyEndChange();

    @NotNull
    @Override
    @SuppressWarnings("unchecked")
    protected Object clone() {
        try {
            //noinspection OverriddenMethodCallDuringObjectConstruction
            final GameObjectContainer<G, A, R> clone = (GameObjectContainer<G, A, R>) super.clone();
            clone.initData();
            for (final BaseObject<G, A, R, G> gameObject : contents) {
                final G clonedGameObject = gameObject.clone();
                clone.contents.add(clonedGameObject);
                clone.setThisContainer(clonedGameObject);
            }
            return clone;
        } catch (final CloneNotSupportedException e) {
            assert false : "This class must be cloneable" + e;
            throw new AssertionError(e);
        }
    }

    // writeObject() is not required because this class doesn't require special handling during serialization.

    private void readObject(@NotNull final ObjectInputStream stream) throws IOException, ClassNotFoundException {
        stream.defaultReadObject();
        // initialize transients
        initData();
    }

    public boolean hasSameContents(@NotNull final GameObjectContainer<?, ?, ?> gameObjectContainer) {
        if (gameObjectContainer.contents.size() != contents.size()) {
            return false;
        }

        for (int i = 0; i < contents.size(); i++) {
            if (!gameObjectContainer.contents.get(i).isEqual(contents.get(i))) {
                return false;
            }
        }

        return true;
    }

    protected abstract void setThisContainer(@NotNull G gameObject);

    @Nullable
    public abstract G asGameObject();

    @NotNull
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append("(");
        final Iterator<G> it = contents.iterator();
        if (it.hasNext()) {
            sb.append(it.next());
            while (it.hasNext()) {
                sb.append(",");
                sb.append(it.next());
            }
        }
        sb.append(")");
        return sb.toString();
    }

    private static class ReverseIterator<T extends GameObject<?, ?, ?>> implements Iterator<T> {

        @NotNull
        private final ListIterator<T> delegate;

        @NotNull
        private final List<T> list;

        private ReverseIterator(@NotNull final List<T> list) {
            this.list = list;
            delegate = list.listIterator(list.size());
        }

        @Override
        public boolean hasNext() {
            return delegate.hasPrevious();
        }

        // previous can throw NoSuchElementException but InspectionGadgets doesn't know about that.
        @SuppressWarnings("IteratorNextCanNotThrowNoSuchElementException")
        @NotNull
        @Override
        public T next() {
            return delegate.previous();
        }

        @Override
        public void remove() {
            if (delegate.nextIndex() == 0 && list.size() >= 2) {
                list.get(1).propagateElevation(list.get(0));
            }
            delegate.remove();
        }

    }

}