ListOfStatProbes.java

/*
 * Class:        ListOfStatProbes
 * Description:  List of statistical probes
 * Environment:  Java
 * Software:     SSJ 
 * Copyright (C) 2001  Pierre L'Ecuyer and Universite de Montreal
 * Organization: DIRO, Universite de Montreal
 * @author       Éric Buist 
 * @since        2007
 *
 *
 * 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 umontreal.ssj.stat.list;
 
import java.util.*;
import umontreal.ssj.stat.StatProbe;

public class ListOfStatProbes<E extends StatProbe> implements Cloneable, List<E>, RandomAccess {
 
   // probes must implement RandomAccess, otherwise this class must not implement
   // RandomAccess.
   private List<E> probes;
   private List<ArrayOfObservationListener> listeners = new ArrayList<ArrayOfObservationListener>();
   protected boolean collect = true;
   protected boolean broadcast = false;
   protected String name;

   public ListOfStatProbes() {
      probes = new ArrayList<E>();
   }

   public ListOfStatProbes(String name) {
      probes = new ArrayList<E>();
      this.name = name;
   }

   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }

   public boolean isModifiable() {
      return probes instanceof ArrayList;
   }

   public void setUnmodifiable() {
      if (isModifiable())
         probes = Collections.unmodifiableList(probes);
   }

   public void init() {
      for (StatProbe probe : probes) {
         if (probe != null)
            probe.init();
      }
   }

   public void sum(double[] s) {
      if (s.length != size())
         throw new IllegalArgumentException(
               "Invalid length of the given array: given length is " + s.length + ", required length is " + size());
      int i = 0;
      for (StatProbe probe : probes)
         s[i++] = probe == null ? Double.NaN : probe.sum();
   }

   public void average(double[] a) {
      if (a.length != size())
         throw new IllegalArgumentException(
               "Invalid length of the given array: given length is " + a.length + ", required length is " + size());
      int i = 0;
      for (StatProbe probe : probes)
         a[i++] = probe == null ? Double.NaN : probe.average();
   }

   public boolean isCollecting() {
      return collect;
   }

   public void setCollecting(boolean c) {
      collect = c;
   }

   public boolean isBroadcasting() {
      return broadcast;
   }

   public void setBroadcasting(boolean b) {
      broadcast = b;
   }

   public void addArrayOfObservationListener(ArrayOfObservationListener l) {
      if (l == null)
         throw new NullPointerException();
      if (!listeners.contains(l))
         listeners.add(l);
   }

   public void removeArrayOfObservationListener(ArrayOfObservationListener l) {
      listeners.remove(l);
   }

   public void clearArrayOfObservationListeners() {
      listeners.clear();
   }

   public void notifyListeners(double[] x) {
      if (!broadcast)
         return;
      // We could also use the enhanced for loop here, but this is less efficient.
      final int nl = listeners.size();
      for (int i = 0; i < nl; i++)
         listeners.get(i).newArrayOfObservations(this, x);
   }

   public String report() {
      return StatProbe.report(name, this);
   }

   public ListOfStatProbes<E> clone() {
      ListOfStatProbes<E> sa;
      try {
         sa = (ListOfStatProbes<E>) super.clone();
      } catch (CloneNotSupportedException cne) {
         throw new IllegalStateException("CloneNotSupportedException for a class implementing Cloneable");
      }
      if (probes != null)
         sa.probes = new ArrayList<E>(probes);
      return sa;
   }
 
   public boolean add(E o) {
      return probes.add(o);
   }
 
   public void add(int index, E o) {
      probes.add(index, o);
   }
 
   public boolean addAll(Collection<? extends E> c) {
      return probes.addAll(c);
   }
 
   public boolean addAll(int index, Collection<? extends E> c) {
      return probes.addAll(index, c);
   }
 
   public void clear() {
      probes.clear();
   }
 
   public boolean contains(Object o) {
      return probes.contains(o);
   }
 
   public boolean containsAll(Collection<?> c) {
      return probes.containsAll(c);
   }
 
   public boolean equals(Object o) {
      return probes.equals(o);
   }
 
   public E get(int index) {
      return probes.get(index);
   }
 
   public int hashCode() {
      return probes.hashCode();
   }
 
   public int indexOf(Object o) {
      return probes.indexOf(o);
   }
 
   public boolean isEmpty() {
      return probes.isEmpty();
   }
 
   public Iterator<E> iterator() {
      return probes.iterator();
   }
 
   public int lastIndexOf(Object o) {
      return probes.lastIndexOf(o);
   }
 
   public ListIterator<E> listIterator() {
      return probes.listIterator();
   }
 
   public ListIterator<E> listIterator(int index) {
      return probes.listIterator();
   }
 
   public E remove(int index) {
      return probes.remove(index);
   }
 
   public boolean remove(Object o) {
      return probes.remove(o);
   }
 
   public boolean removeAll(Collection<?> c) {
      return probes.removeAll(c);
   }
 
   public boolean retainAll(Collection<?> c) {
      return probes.retainAll(c);
   }
 
   public E set(int index, E element) {
      return probes.set(index, element);
   }
 
   public int size() {
      return probes.size();
   }
 
   public List<E> subList(int fromIndex, int toIndex) {
      return probes.subList(fromIndex, toIndex);
   }
 
   public Object[] toArray() {
      return probes.toArray();
   }
 
   public <T> T[] toArray(T[] a) {
      return probes.toArray(a);
   }
 
}