ListWithStat.java

/*
 * Class:        ListWithStat
 * Description:  Implements a list with integrated statistical probes to
                 provide automatic collection of statistics on the sojourn
                 times of objects in the list and on the size of the list
 * Environment:  Java
 * Software:     SSJ
 * Copyright (C) 2001  Pierre L'Ecuyer and Universite de Montreal
 * Organization: DIRO, Universite de Montreal
 * @author
 * @since
 *
 *
 * 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.simevents;
 
import java.util.Collection;
import java.util.List;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import umontreal.ssj.stat.Tally;
import umontreal.ssj.util.TransformingList;
import umontreal.ssj.util.PrintfFormat;

public class ListWithStat<E> extends TransformingList<E, ListWithStat.Node<E>> {
   private boolean stats; // true si on a appele setStatCollecting
   private double initTime; // temps de la derniere initialisation
   private Accumulate blockSize; // block stat. sur la longueur de la liste
   private Tally blockSojourn; // block stat. sur les durees de sejour
   private String name;
   private Simulator sim;

   public ListWithStat(List<Node<E>> nodeList) {
      super(nodeList);
      nodeList.clear();
      sim = Simulator.getDefaultSimulator();
      stats = false;
   }

   public ListWithStat(Simulator inSim, List<Node<E>> nodeList) {
      super(nodeList);
      if (inSim == null || nodeList == null)
         throw new NullPointerException();
      nodeList.clear();
      sim = inSim;
      stats = false;
   }

   public ListWithStat(List<Node<E>> nodeList, Collection<? extends E> c) {
      this(Simulator.getDefaultSimulator(), nodeList);
      addAll(c);
   }

   public ListWithStat(Simulator inSim, List<Node<E>> nodeList, Collection<? extends E> c) {
      this(inSim, nodeList);
      addAll(c);
   }

   public ListWithStat(List<Node<E>> nodeList, String name) {
      this(Simulator.getDefaultSimulator(), nodeList);
      this.name = name;
   }

   public ListWithStat(Simulator inSim, List<Node<E>> nodeList, String name) {
      this(inSim, nodeList);
      this.name = name;
   }

   public ListWithStat(List<Node<E>> nodeList, Collection<? extends E> c, String name) {
      this(Simulator.getDefaultSimulator(), nodeList);
      this.name = name;
      addAll(c);
   }

   public ListWithStat(Simulator inSim, List<Node<E>> nodeList, Collection<? extends E> c, String name) {
      this(inSim, nodeList);
      this.name = name;
      addAll(c);
   }
 
   public E convertFromInnerType(Node<E> node) {
      return node.getElement();
   }
 
   public Node<E> convertToInnerType(E element) {
      return new Node<E>(element, sim.time());
   }

   public Simulator simulator() {
      return sim;
   }

   public void setSimulator(Simulator sim) {
      if (sim == null)
         throw new NullPointerException();
      this.sim = sim;
      if (blockSize != null)
         blockSize.setSimulator(sim);
   }
 
   @Override
   public void clear() {
      if (stats)
         initStat();
      super.clear();
   }
 
   @Override
   public void add(int index, E obj) {
      super.add(index, obj);
      if (stats)
         blockSize.update(size());
   }
 
   @Override
   public E remove(int index) {
      Node<E> node = getInnerList().get(index);
      if (stats)
         blockSojourn.add(sim.time() - node.getInsertionTime());
      E e = super.remove(index);
      if (stats)
         blockSize.update(size());
      return e;
   }
 
   @Override
   public Iterator<E> iterator() {
      return new IteratorWithStat(getInnerList().iterator());
   }
 
   @Override
   public ListIterator<E> listIterator() {
      return new ListIteratorWithStat(getInnerList().listIterator());
   }
 
   @Override
   public ListIterator<E> listIterator(int index) {
      return new ListIteratorWithStat(getInnerList().listIterator(index));
   }
 
   @Override
   public E set(int index, E element) {
      Node<E> oldNode = getInnerList().get(index);
      E oldElement = oldNode.getElement();
      boolean equal;
      if (oldElement == null || element == null)
         equal = oldElement == element;
      else
         equal = oldElement.equals(element);
      if (equal) {
         getInnerList().set(index, new Node<E>(element, oldNode.getInsertionTime()));
         return oldElement;
      } else {
         if (stats)
            blockSojourn.add(sim.time() - oldNode.getInsertionTime());
         getInnerList().set(index, new Node<E>(element, sim.time()));
         return oldElement;
      }
   }
 
   private class IteratorWithStat implements Iterator<E> {
      private Iterator<Node<E>> itr;
      private Node<E> lastRet;
 
      public IteratorWithStat(Iterator<Node<E>> itr) {
         this.itr = itr;
      }
 
      public boolean hasNext() {
         return itr.hasNext();
      }
 
      public E next() {
         lastRet = itr.next();
         return lastRet.getElement();
      }
 
      public void remove() {
         itr.remove();
         if (stats) {
            blockSize.update(size());
            blockSojourn.add(sim.time() - lastRet.getInsertionTime());
         }
         lastRet = null;
      }
   }
 
   private class ListIteratorWithStat implements ListIterator<E> {
      private ListIterator<Node<E>> itr;
      private Node<E> lastRet;
 
      public ListIteratorWithStat(ListIterator<Node<E>> itr) {
         this.itr = itr;
      }
 
      public void add(E o) {
         itr.add(new Node<E>(o, sim.time()));
         lastRet = null;
         if (stats)
            blockSize.update(size());
      }
 
      public boolean hasNext() {
         return itr.hasNext();
      }
 
      public boolean hasPrevious() {
         return itr.hasPrevious();
      }
 
      public E next() {
         lastRet = itr.next();
         return lastRet.getElement();
      }
 
      public int nextIndex() {
         return itr.nextIndex();
      }
 
      public E previous() {
         lastRet = itr.previous();
         return lastRet.getElement();
      }
 
      public int previousIndex() {
         return itr.previousIndex();
      }
 
      public void remove() {
         itr.remove();
         if (stats) {
            blockSize.update(size());
            blockSojourn.add(sim.time() - lastRet.getInsertionTime());
         }
         lastRet = null;
      }
 
      public void set(E element) {
         if (lastRet == null)
            throw new NoSuchElementException();
         Node<E> oldNode = lastRet;
         E oldElement = oldNode.getElement();
         boolean equal;
         if (oldElement == null || element == null)
            equal = oldElement == element;
         else
            equal = oldElement.equals(element);
         if (equal) {
            lastRet = new Node<E>(element, oldNode.getInsertionTime());
            itr.set(lastRet);
         } else {
            if (stats)
               blockSojourn.add(sim.time() - oldNode.getInsertionTime());
            lastRet = new Node<E>(element, sim.time());
            itr.set(lastRet);
         }
      }
   }


   public boolean getStatCollecting() {
      return stats;
   }

   public void setStatCollecting(boolean b) {
      if (b && !stats) {
         if (blockSize == null)
            blockSize = new Accumulate(sim, "List Size " + name);
         if (blockSojourn == null)
            blockSojourn = new Tally("List Sojourn " + name);
         blockSize.update(size());
         stats = true;
         initStat();
      } else
         stats = false;
   }

   public void initStat() {
      if (!stats)
         throw new IllegalStateException("initStat for a list that did not call setStatCollecting (true).");
      blockSize.init();
      blockSojourn.init();
      blockSize.update(size());
      initTime = sim.time();
   }

   public double getInitTime() {
      return initTime;
   }

   public Accumulate statSize() {
      return blockSize;
   }

   public Tally statSojourn() {
      return blockSojourn;
   }

   public String report() {
      if (blockSojourn == null || blockSize == null)
         throw new IllegalStateException("Calling report when no statistics were collected");
 
      PrintfFormat str = new PrintfFormat();
      str.append(PrintfFormat.NEWLINE + "REPORT ON LIST : ").append(name).append(PrintfFormat.NEWLINE);
      str.append("   From time: ").append(7, 2, 2, initTime);
      str.append(" to time: ").append(10, 2, 2, sim.time());
      str.append("                  min        max      average  ");
      str.append("standard dev.  nb. Obs");
 
      str.append("   Size    ");
      str.append(9, (int) (blockSize.min() + 0.5));
      str.append(11, (int) (blockSize.max() + 0.5));
      str.append(14, 3, 2, blockSize.average()).append(PrintfFormat.NEWLINE);
 
      str.append("   Sojourn ");
      str.append(12, 3, 2, blockSojourn.min()).append(" ");
      str.append(10, 3, 2, blockSojourn.max()).append(" ");
      str.append(10, 3, 2, blockSojourn.average()).append(" ");
      str.append(10, 3, 2, blockSojourn.standardDeviation()).append(" ");
      str.append(11, blockSojourn.numberObs()).append(PrintfFormat.NEWLINE);
 
      return str.toString();
   }

   public String getName() {
      return name;
   }



   public static class Node<E> {
      private E element;
      private double insertionTime;


      public Node(E element, double insertionTime) {
         this.element = element;
         this.insertionTime = insertionTime;
      }

      public E getElement() {
         return element;
      }

      public double getInsertionTime() {
         return insertionTime;
      }
 
      public String toString() {
         String str = element == null ? "null" : element.toString();
         str += " (inserted at time " + insertionTime + ")";
         return str;
      }
   }
 
}