// Path: gdx-lib/src/main/java/com/badlogic/gdx/utils/SnapshotArray.java
// public class SnapshotArray<T> extends Array<T> {
//     private T[] snapshot, recycled;
//     private int snapshots;
// 
//     public SnapshotArray() {
//         super();
//     }
// 
//     public SnapshotArray(Array array) {
//         super(array);
//     }
// 
//     public SnapshotArray(boolean ordered, int capacity, Class arrayType) {
//         super(ordered, capacity, arrayType);
//     }
// 
//     public SnapshotArray(boolean ordered, int capacity) {
//         super(ordered, capacity);
//     }
// 
//     public SnapshotArray(boolean ordered, T[] array, int startIndex, int count) {
//         super(ordered, array, count);
//     }
// 
//     public SnapshotArray(Class arrayType) {
//         super(arrayType);
//     }
// 
//     public SnapshotArray(int capacity) {
//         super(capacity);
//     }
// 
//     public SnapshotArray(T[] array) {
//         super(array);
//     }
// 
//     /**
//      * Returns the backing array, which is guaranteed to not be modified before {@link #end()}.
//      */
//     public T[] begin() {
//         modified();
//         snapshot = items;
//         snapshots++;
//         return items;
//     }
// 
//     /**
//      * Releases the guarantee that the array returned by {@link #begin()} won't be modified.
//      */
//     public void end() {
//         snapshots = Math.max(0, snapshots - 1);
//         if (snapshot == null) {
//             return;
//         }
//         if (snapshot != items && snapshots == 0) {
//             // The backing array was copied, keep around the old array.
//             recycled = snapshot;
//             for (int i = 0, n = recycled.length; i < n; i++) {
//                 recycled[i] = null;
//             }
//         }
//         snapshot = null;
//     }
// 
//     private void modified() {
//         if (snapshot == null || snapshot != items) {
//             return;
//         }
//         // Snapshot is in use, copy backing array to recycled array or create new backing array.
//         if (recycled != null && recycled.length >= size) {
//             System.arraycopy(items, 0, recycled, 0, size);
//             items = recycled;
//             recycled = null;
//         } else {
//             resize(items.length);
//         }
//     }
// 
//     @Override
//     public void set(int index, T value) {
//         modified();
//         super.set(index, value);
//     }
// 
//     @Override
//     public void insert(int index, T value) {
//         modified();
//         super.insert(index, value);
//     }
// 
//     @Override
//     public void swap(int first, int second) {
//         modified();
//         super.swap(first, second);
//     }
// 
//     @Override
//     public boolean removeValue(T value, boolean identity) {
//         modified();
//         return super.removeValue(value, identity);
//     }
// 
//     @Override
//     public T removeIndex(int index) {
//         modified();
//         return super.removeIndex(index);
//     }
// 
//     @Override
//     public void removeRange(int start, int end) {
//         modified();
//         super.removeRange(start, end);
//     }
// 
//     @Override
//     public boolean removeAll(Array<? extends T> array, boolean identity) {
//         modified();
//         return super.removeAll(array, identity);
//     }
// 
//     @Override
//     public T pop() {
//         modified();
//         return super.pop();
//     }
// 
//     @Override
//     public void clear() {
//         modified();
//         super.clear();
//     }
// 
//     @Override
//     public void sort() {
//         modified();
//         super.sort();
//     }
// 
//     @Override
//     public void sort(Comparator<? super T> comparator) {
//         modified();
//         super.sort(comparator);
//     }
// 
//     @Override
//     public void reverse() {
//         modified();
//         super.reverse();
//     }
// 
//     @Override
//     public void shuffle() {
//         modified();
//         super.shuffle();
//     }
// 
//     @Override
//     public void truncate(int newSize) {
//         modified();
//         super.truncate(newSize);
//     }
// 
//     /**
//      * @see #SnapshotArray(Object[])
//      */
//     public static <T> SnapshotArray<T> with(T... array) {
//         return new SnapshotArray(array);
//     }
// }


import com.badlogic.gdx.utils.SnapshotArray;
/*******************************************************************************
 * Copyright 2014 See AUTHORS file.
 *
 * 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 com.badlogic.ashley.signals;


/**
 * A Signal is a basic event class then can dispatch an event to multiple listeners. It uses
 * generics to allow any type of object to be passed around on dispatch.
 *
 * @author Stefan Bachmann
 */
public class Signal<T> {
    private SnapshotArray<Listener<T>> listeners;

    public Signal() {
// Path: gdx-lib/src/main/java/com/badlogic/gdx/utils/SnapshotArray.java
// public class SnapshotArray<T> extends Array<T> {
//     private T[] snapshot, recycled;
//     private int snapshots;
// 
//     public SnapshotArray() {
//         super();
//     }
// 
//     public SnapshotArray(Array array) {
//         super(array);
//     }
// 
//     public SnapshotArray(boolean ordered, int capacity, Class arrayType) {
//         super(ordered, capacity, arrayType);
//     }
// 
//     public SnapshotArray(boolean ordered, int capacity) {
//         super(ordered, capacity);
//     }
// 
//     public SnapshotArray(boolean ordered, T[] array, int startIndex, int count) {
//         super(ordered, array, count);
//     }
// 
//     public SnapshotArray(Class arrayType) {
//         super(arrayType);
//     }
// 
//     public SnapshotArray(int capacity) {
//         super(capacity);
//     }
// 
//     public SnapshotArray(T[] array) {
//         super(array);
//     }
// 
//     /**
//      * Returns the backing array, which is guaranteed to not be modified before {@link #end()}.
//      */
//     public T[] begin() {
//         modified();
//         snapshot = items;
//         snapshots++;
//         return items;
//     }
// 
//     /**
//      * Releases the guarantee that the array returned by {@link #begin()} won't be modified.
//      */
//     public void end() {
//         snapshots = Math.max(0, snapshots - 1);
//         if (snapshot == null) {
//             return;
//         }
//         if (snapshot != items && snapshots == 0) {
//             // The backing array was copied, keep around the old array.
//             recycled = snapshot;
//             for (int i = 0, n = recycled.length; i < n; i++) {
//                 recycled[i] = null;
//             }
//         }
//         snapshot = null;
//     }
// 
//     private void modified() {
//         if (snapshot == null || snapshot != items) {
//             return;
//         }
//         // Snapshot is in use, copy backing array to recycled array or create new backing array.
//         if (recycled != null && recycled.length >= size) {
//             System.arraycopy(items, 0, recycled, 0, size);
//             items = recycled;
//             recycled = null;
//         } else {
//             resize(items.length);
//         }
//     }
// 
//     @Override
//     public void set(int index, T value) {
//         modified();
//         super.set(index, value);
//     }
// 
//     @Override
//     public void insert(int index, T value) {
//         modified();
//         super.insert(index, value);
//     }
// 
//     @Override
//     public void swap(int first, int second) {
//         modified();
//         super.swap(first, second);
//     }
// 
//     @Override
//     public boolean removeValue(T value, boolean identity) {
//         modified();
//         return super.removeValue(value, identity);
//     }
// 
//     @Override
//     public T removeIndex(int index) {
//         modified();
//         return super.removeIndex(index);
//     }
// 
//     @Override
//     public void removeRange(int start, int end) {
//         modified();
//         super.removeRange(start, end);
//     }
// 
//     @Override
//     public boolean removeAll(Array<? extends T> array, boolean identity) {
//         modified();
//         return super.removeAll(array, identity);
//     }
// 
//     @Override
//     public T pop() {
//         modified();
//         return super.pop();
//     }
// 
//     @Override
//     public void clear() {
//         modified();
//         super.clear();
//     }
// 
//     @Override
//     public void sort() {
//         modified();
//         super.sort();
//     }
// 
//     @Override
//     public void sort(Comparator<? super T> comparator) {
//         modified();
//         super.sort(comparator);
//     }
// 
//     @Override
//     public void reverse() {
//         modified();
//         super.reverse();
//     }
// 
//     @Override
//     public void shuffle() {
//         modified();
//         super.shuffle();
//     }
// 
//     @Override
//     public void truncate(int newSize) {
//         modified();
//         super.truncate(newSize);
//     }
// 
//     /**
//      * @see #SnapshotArray(Object[])
//      */
//     public static <T> SnapshotArray<T> with(T... array) {
//         return new SnapshotArray(array);
//     }
// }


// Path: ashley/src/main/java/com/badlogic/ashley/signals/Signal.java
import com.badlogic.gdx.utils.SnapshotArray;

/*******************************************************************************
 * Copyright 2014 See AUTHORS file.
 *
 * 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 com.badlogic.ashley.signals;


/**
 * A Signal is a basic event class then can dispatch an event to multiple listeners. It uses
 * generics to allow any type of object to be passed around on dispatch.
 *
 * @author Stefan Bachmann
 */
public class Signal<T> {
    private SnapshotArray<Listener<T>> listeners;

    public Signal() {
        listeners = new SnapshotArray<Listener<T>>(Listener.class);