sensix v0.3.0

00001 
00010 /*
00011  * Copyright 2008. Los Alamos National Security, LLC. This material
00012  * was produced under U.S. Government contract DE-AC52-06NA25396 for
00013  * Los Alamos National Laboratory (LANL), which is operated by Los
00014  * Alamos National Security, LLC, for the Department of Energy. The
00015  * U.S. Government has rights to use, reproduce, and distribute this
00016  * software. NEITHER THE GOVERNMENT NOR LOS ALAMOS NATIONAL SECURITY,
00017  * LLC, MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL
00018  * LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified to
00019  * produce derivative works, such modified software should be clearly
00020  * marked, so as not to confuse it with the version available from LANL.
00021  *
00022  * Additionally, this program is free software; you can redistribute
00023  * it and/or modify it under the terms of the GNU General Public
00024  * License as published by the Free Software Foundation; version 2 of
00025  * the License. Accordingly, this program is distributed in the hope
00026  * it will be useful, but WITHOUT ANY WARRANTY; without even the
00027  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00028  * PURPOSE. See the GNU General Public License for more details.
00029  *
00030  * You should have received a copy of the GNU General Public License
00031  * along with this program; if not, write to the Free Software
00032  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA. 
00033  */
00034 
00035 package sensix.sensing;
00036 
00037 import sensix.*;
00038 
00039 
00040 public class Aggregate extends Sensory
00041 {
00042     protected String name = "";
00043     protected Collection[] series;
00044 
00045 
00046     public Aggregate(String n, byte l, Collection[] c) {
00047         super(l, Sensix.INVALID, (Functor[])c);
00048         name = n;
00049         series = c;
00050         if (series == null)
00051             series = new Collection[0];
00052     }
00053 
00054     public Aggregate(String n, Collection[] c) {
00055         super((Functor[])c);
00056         name = n;
00057         series = c;
00058         if (series == null)
00059             series = new Collection[0];
00060     }
00061 
00062     public Aggregate(String n, byte l, Collection[] c, int seq) {
00063         super(l, Sensix.INVALID, (Functor[])c, seq);
00064         name = n;
00065         series = c;
00066         if (series == null)
00067             series = new Collection[0];
00068     }
00069 
00070 
00071     public Sensory[] senses() {
00072         int num = series.length;
00073         Sensory[] array = new Sensory[num];
00074         for (int i = 0; i < num; i++)
00075             array[i] = series[i].sense();
00076         return array;
00077     }
00078 
00079 
00080     public Collection[] collectors() {
00081         return series;
00082     }
00083 
00084     public void collectors(Collection[] c) {
00085         series = c;
00086     }
00087 
00088 
00089     public byte sensor() {
00090         return Sensix.INVALID;
00091     }
00092 
00093     public Sensory sense() { // TODO: this is meaningless, should go away
00094         return series[0].sense();
00095     }
00096 
00097     public void sense(Sensory s) {}
00098 
00099     public long timeused() {
00100         long max = 0;
00101         for (int i = 0; i < series.length; i++) {
00102             if (series[i].timeused() > max)
00103                 max = series[i].timeused();
00104         }
00105         return max;
00106     }
00107 
00108     public void timeused(long t) {}
00109 
00110     public double energyused() {
00111         double sum = 0.0;
00112         for (int i = 0; i < series.length; i++)
00113             sum += series[i].energyused();
00114         return sum;
00115     }
00116 
00117     public void energyused(double e) {}
00118 
00119     public byte priority() {
00120         byte max = 0;
00121         for (int i = 0; i < series.length; i++) {
00122             if (series[i].priority() > max)
00123                 max = series[i].priority();
00124         }
00125         return max;
00126     }
00127 
00128     public void priority(byte p) {
00129         for (int i = 0; i < series.length; i++)
00130             series[i].priority(p);
00131     }
00132 
00133     public FunctorError[] errors() {
00134         int num = 0, pos = 0;
00135         for (int i = 0; i < series.length; i++) {
00136             if (series[i].errors() != null)
00137                 num += series[i].errors().length;
00138         }
00139         FunctorError[] e = new FunctorError[num];
00140         for (int i = 0; i < series.length; i++) {
00141             if (series[i].errors() != null && series[i].errors().length > 0) {
00142                 System.arraycopy(series[i].errors(), 0, e, pos,
00143                                  series[i].errors().length);
00144                 pos += series[i].errors().length;
00145             }
00146         }
00147         return e;
00148     }
00149 
00150     public void errors(FunctorError[] fe) {}
00151 
00152     public String asString() {
00153         String string_rep = name + "(";
00154         if (level() != Sensix.INVALID)
00155             string_rep += "level=" + (int)level() + ",";
00156         for (int i = 0; i < series.length; i ++) {
00157             string_rep += series[i].asString();
00158             if (i < series.length - 1)
00159                 string_rep += "&&";
00160         }
00161         string_rep += ")";
00162         return string_rep;
00163     }
00164 }
/home/brennan/Software/sensix/source/C^4/sensix/sensing/Aggregate.java
