001    package cnslab.cnsnetwork;
002    
003    import java.io.PrintStream;
004    import java.util.TreeSet;
005    import java.util.Iterator;
006    import java.util.Arrays;
007    
008    import edu.jhu.mb.ernst.model.ModelFactory;
009    import edu.jhu.mb.ernst.model.Synapse;
010
011    /***********************************************************************
012    * Implement the tree queue by using Red black queue provided by Java.
013    * 
014    * @version
015    *   $Date: 2012-08-04 13:43:22 -0500 (Sat, 04 Aug 2012) $
016    *   $Rev: 104 $
017    *   $Author: croft $
018    * @author
019    *   Yi Dong
020    * @author
021    *   David Wallace Croft
022    ***********************************************************************/
023    public final class  TreeQueue<T extends Comparable<T>>
024      implements Queue<T>
025    ////////////////////////////////////////////////////////////////////////
026    ////////////////////////////////////////////////////////////////////////
027    {
028    
029    private final ModelFactory  modelFactory;
030    
031    private TreeSet<T> treeQueue = new TreeSet<T>();
032
033    ////////////////////////////////////////////////////////////////////////
034    ////////////////////////////////////////////////////////////////////////
035
036    public  TreeQueue ( final ModelFactory  modelFactory )
037    ////////////////////////////////////////////////////////////////////////
038    {
039      this.modelFactory = modelFactory;
040    }
041    
042    ////////////////////////////////////////////////////////////////////////
043    ////////////////////////////////////////////////////////////////////////
044    
045    /**
046     * @see cnslab.cnsnetwork.Queue#deleteItem(java.lang.Comparable) deleteItem
047     */
048    public synchronized void deleteItem(T item) {
049      if(!treeQueue.isEmpty())
050      {
051        treeQueue.remove(item);
052      }
053    }
054
055    /**
056     * Second item from the queue 
057     * 
058     * @return
059     */
060    public synchronized T secondItem() {
061      if(treeQueue.size()<2) {
062        return null;
063      }
064      else
065      {
066        Iterator<T> iter= treeQueue.iterator();
067        iter.next();
068        return iter.next();
069      }
070    }
071
072    /**
073     * @see cnslab.cnsnetwork.Queue#insertItem(java.lang.Comparable) insertItem
074     */
075    public synchronized void insertItem(T item) {
076      treeQueue.add(item);
077    }
078
079
080    /**
081     * @see cnslab.cnsnetwork.Queue#firstItem() firstItem
082     */
083    public synchronized T firstItem() {
084      if(!treeQueue.isEmpty())
085      {
086        return treeQueue.first();
087      }
088      else
089      {
090        return null;
091      }
092    }
093
094    /**
095     * @see cnslab.cnsnetwork.Queue#lastItem() lastItem
096     */
097    public synchronized T lastItem() {
098      if(!treeQueue.isEmpty())
099      {
100        return treeQueue.last();
101      }
102      else
103      {
104        return null;
105      }
106    }
107
108    /** 
109     * show all the elements in the Queue in order 
110     */
111    public synchronized void show(PrintStream p) {
112      Iterator<T> iter= treeQueue.iterator();
113      while(iter.hasNext())
114      {
115        p.println(iter.next());
116      }
117    }
118
119    /**
120     * {@inheritDoc}
121     * @see Queue#show()
122     */
123    public synchronized String show() {
124      String out="";
125      Iterator<T> iter= treeQueue.iterator();
126      out=out+"<";
127      while(iter.hasNext())
128      {
129        out=out+iter.next();
130      }
131      out=out+">";
132      return out;
133    }
134
135    public synchronized boolean noTillFireEvent(FireEvent event)
136    {
137      Iterator iter= treeQueue.iterator();
138
139      while( iter.hasNext())
140      {
141        InputEvent input= (InputEvent) (iter.next());
142
143        if( input.time > event.time) return false;
144        
145        if ( Arrays.binarySearch (
146          input.branch.synapses,
147          modelFactory.createSynapse (event.index, ( byte ) 0, 0f ) ) >= 0 )
148        {
149          return true;
150        }
151        
152        /*
153      for(int i=0; i< input.branch.synapses.length; i++)
154      {
155        if (input.branch.synapses[i].to == event.index) { return true; }
156      }
157         */
158      }
159      /*
160    treeQueue.iterExit = false;
161    treeQueue.firstFire = event;
162    //return treeQueue.treeNoTillInputEvent(treeQueue.root(),event.time, event.index);
163    return treeQueue.treeNoTillInputEvent(treeQueue.root());
164       */
165      return false;
166    }
167
168    public synchronized boolean noTillInputEvent(InputEvent event)
169    {
170      Iterator iter= treeQueue.iterator();
171
172      while( iter.hasNext())
173      {
174        FireEvent fire= (FireEvent) (iter.next());
175
176        if( fire.time > event.time) return false;
177        
178        
179        if ( Arrays.binarySearch (
180          event.branch.synapses,
181          modelFactory.createSynapse ( fire.index, ( byte ) 0, 0f ) ) >= 0 )
182        {
183          return true;
184        }
185        
186        /*
187      for(int i=0; i< event.branch.synapses.length; i++)
188      {
189        if (event.branch.synapses[i].to == fire.index) { return true; }
190      }
191         */
192      }
193      /*
194    treeQueue.iterExit = false;
195    treeQueue.firstInput = event;
196    treeQueue.flags = flags;
197    return treeQueue.treeNoTillFireEvent(treeQueue.root());
198       */
199      return true;
200    }
201
202    /**
203     * {@inheritDoc}
204     * @see Queue#clear()
205     */
206    public synchronized void clear(){
207      treeQueue.clear();
208    }
209    
210    ////////////////////////////////////////////////////////////////////////
211    ////////////////////////////////////////////////////////////////////////
212    }