Changeset 1080


Ignore:
Timestamp:
08/21/11 20:38:30 (9 years ago)
Author:
philsmart
Message:
 
Location:
raptor-mua/trunk/src/main/java/uk/ac/cardiff/raptormua
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • raptor-mua/trunk/src/main/java/uk/ac/cardiff/raptormua/engine/statistics/Statistic.java

    r1040 r1080  
    1717 * 
    1818 */ 
     19 
    1920package uk.ac.cardiff.raptormua.engine.statistics; 
    2021 
     
    2223import java.util.Arrays; 
    2324import java.util.List; 
    24 import java.util.Set; 
    25 import java.util.LinkedHashSet; 
    2625 
    2726import org.joda.time.DateTime; 
     
    3130import org.slf4j.LoggerFactory; 
    3231 
    33 import uk.ac.cardiff.model.event.Event; 
    3432import uk.ac.cardiff.model.report.AggregatorGraphModel; 
    35 import uk.ac.cardiff.model.report.Series; 
    3633import uk.ac.cardiff.model.wsmodel.MethodParameter; 
    3734import uk.ac.cardiff.model.wsmodel.StatisticParameters; 
     
    4239import uk.ac.cardiff.raptormua.engine.statistics.records.Group; 
    4340import uk.ac.cardiff.raptormua.engine.statistics.records.Observation; 
    44 import uk.ac.cardiff.raptormua.runtimeutils.EntryClone; 
    4541 
    4642/** 
    47  * @author philsmart Holds a statistics unit or one statistics operation on one 
    48  *         piece of data 
     43 * @author philsmart Holds a statistics unit or one statistics operation on one piece of data 
    4944 */ 
    5045public abstract class Statistic { 
    5146 
    52         /** Class logger */ 
    53         private final Logger log = LoggerFactory.getLogger(Statistic.class); 
    54  
    55         /** The <code>EntryHandler</code> that allows access to all <code>Event</code>s this 
    56          * statistic works off. 
    57         */ 
    58         private EventHandler entryHandler; 
    59  
    60         /** The parameters used to configure this statistic*/ 
    61         protected StatisticParameters statisticParameters; 
    62  
    63         /** add a preprocessing module to the statistical method */ 
    64         private StatisticsPreProcessor preprocessor; 
    65  
    66         /** add a postprocessing module to the statistical method */ 
    67         private List<StatisticsPostProcessor> postprocessor; 
    68  
    69         /** After each statistic has been invoked, the results of each series 
    70          * are stored as <code>ObservationSeries</code> in this list. 
    71          */ 
    72         private List<ObservationSeries> observationSeries; 
    73  
    74         /**  
    75          * Default constructor. 
    76          */ 
    77         public Statistic() { 
    78                 setObservationSeries(new ArrayList<ObservationSeries>()); 
    79         } 
    80  
    81         /** 
    82          * Method that performs the statistical operation. Overridden by each concrete statistic class. 
    83          *  
    84          * @param methodParams 
    85          * @param sqlWhere 
    86          * @return 
    87          * @throws StatisticalUnitException 
    88          */ 
    89         public abstract Boolean performStatistic(List<MethodParameter> methodParams, String sqlWhere) throws StatisticalUnitException; 
    90  
    91  
    92         /** 
    93          * Important this this method is called during the statistic process lifecycle, so that any state variables 
    94          * e.g. the observationSeries, is reset ready for the next invocation 
    95          */ 
    96         public void reset(){ 
    97             observationSeries.clear(); 
    98         } 
    99  
    100  
    101         public void setEntryHandler(EventHandler entryHandler) { 
    102                 if (preprocessor != null) 
    103                         try { 
    104                                 log.info("Invoking statistical preprocessor " + preprocessor.getClass()); 
    105                                 preprocessor.preProcess(entryHandler); 
    106                         } catch (PreprocessorException e) { 
    107                                 log.error("Could not preprocess entries " + preprocessor.getClass()); 
    108                         } 
    109                 this.entryHandler = entryHandler; 
    110         } 
    111  
    112         /** 
    113         * <p> 
    114          * construct a graph model from the data observations and groupings stored 
    115          * in the buckets 
    116          * </p> 
    117          * 
    118          * @return 
    119          */ 
    120         public AggregatorGraphModel constructGraphModel() { 
    121                 AggregatorGraphModel gmodel = new AggregatorGraphModel(); 
    122                 gmodel.setPresentation(this.getStatisticParameters().getPresentation()); 
    123                 int countGroup = 0; 
    124                 int countBucket = 0; 
    125  
    126                 for (ObservationSeries obsSeries : observationSeries) { 
    127                         if (obsSeries.getObservations() instanceof Group[]) 
    128                                 countGroup++; 
    129                         if (obsSeries.getObservations() instanceof Bucket[]) 
    130                                 countBucket++; 
    131                 } 
    132                 if (countGroup==0 && countBucket==0)return gmodel; 
    133                 log.debug("Statistic has {} series and {} observations",this.getStatisticParameters().getSeries().size(),observationSeries.size()); 
    134                 log.debug("Observation type, GroupType {}, BucketType {}",countGroup, countBucket); 
    135  
    136  
    137                 if (countGroup == observationSeries.size()) { 
    138                         log.info("Constructing graph model for Group type"); 
    139                         //construct the groups from the series with the most groups 
    140                         Observation[] observations = getObservationWithMostGroups(observationSeries); 
    141                         Group[] groups = (Group[]) observations; 
    142                         log.trace("Has {} groups",groups.length); 
    143                         for (Group group : groups) { 
    144                                 log.trace("Group {}",group.getGroupName());                              
    145                                 gmodel.addGroupLabel(group.getGroupName());                              
    146                         } 
    147                          
    148                         //now add each series and their values 
    149                         for (int i=0; i < observationSeries.size(); i++){ 
    150                                 groups = (Group[]) observationSeries.get(i).getObservations(); 
    151                                 gmodel.getSeriesLabels().add(statisticParameters.getSeries().get(i).getSeriesLabel()); 
    152                                 List<Double> values = new ArrayList<Double>(); 
    153                                 for (String label : gmodel.getGroupLabels()){ 
    154                                     Double valueDouble=new Double(0); 
    155                                     for (Group group : groups) { 
    156                                         if (group.getGroupName().equals(label)) 
    157                                             valueDouble = new Double(group.getValue()); 
    158                                     } 
    159                                     values.add(valueDouble); 
    160                                 } 
    161  
    162                                 log.trace("Adding Values {}",Arrays.toString(values.toArray(new Double[0]))); 
    163                                 gmodel.addGroupValue(values); 
    164                         } 
    165  
    166                 } else if (countBucket==observationSeries.size()) { 
    167                         log.info("Constructing graph model for Bucket type"); 
    168  
    169                         //construct the groups from the first series (each series will have the same grouping) 
    170                         Observation[] observations = observationSeries.get(0).getObservations(); 
    171                         Bucket[] buckets = (Bucket[]) observations; 
    172                         String pattern ="yyyy-MM-dd HH:mm"; 
    173                         if (statisticParameters.getPresentation().getDateFormat()!=null) 
    174                             pattern = statisticParameters.getPresentation().getDateFormat(); 
    175                         DateTimeFormatter startParser = DateTimeFormat.forPattern(pattern); 
    176                         DateTimeFormatter endParser = DateTimeFormat.forPattern(pattern); 
    177                         for (Bucket bucket : buckets) { 
    178                                 gmodel.addGroupLabel(startParser.print(bucket.getStart()) + "  " + endParser.print(bucket.getEnd())); 
    179                         } 
    180                         //Buckets are time series, and so are already sorted chronologically. 
    181  
    182                         for (int i=0; i < observationSeries.size(); i++){ 
    183                                 buckets = (Bucket[]) observationSeries.get(i).getObservations(); 
    184                                 gmodel.getSeriesLabels().add(statisticParameters.getSeries().get(i).getSeriesLabel()); 
    185  
    186                                 List<Double> values = new ArrayList(); 
    187                                 for (Bucket bucket : buckets) { 
    188                                         Double valueDouble = new Double(bucket.getValue()); 
    189                                         values.add(valueDouble); 
    190                                 } 
    191                                 log.trace("Adding Values {}",Arrays.toString(values.toArray(new Double[0]))); 
    192                                 gmodel.addGroupValue(values); 
    193                         } 
    194                 } 
    195                 else{ 
    196                         log.error("Statistic had series with mixed observation types, which is currently not supported"); 
    197                 } 
    198  
    199                 return gmodel; 
    200         } 
    201  
    202         private Observation[] getObservationWithMostGroups(List<ObservationSeries> observationSeries){ 
    203             Observation[] maxObs =null; 
    204             int max=0; 
    205             for (ObservationSeries series : observationSeries){ 
    206                   Observation[] obs= series.getObservations(); 
    207                   if (obs.length > max){ 
    208                       max = obs.length; 
    209                       maxObs = obs; 
    210                   } 
    211  
    212             } 
    213             return maxObs; 
    214         } 
    215  
    216         /** 
    217          * <p> 
    218          * pre processing effects the entries that go into the statistical unit post 
    219          * processing effects the observations that result form the statistical unit 
    220          * </p> 
    221          */ 
    222         public void postProcess() { 
    223                 try { 
    224                         if (getPostprocessor() != null) { 
    225                                 for (StatisticsPostProcessor post : postprocessor) { 
    226                                         // perform the same post process on each observationseries 
    227                                         for (ObservationSeries obsSeries : getObservationSeries()) { 
    228                                                 obsSeries.setObservations(post.postProcess(obsSeries.getObservations())); 
    229                                         } 
    230                                 } 
    231                         } 
    232                 } catch (PostprocessorException e) { 
    233                         log.error("Could not post process entries, using " + getPostprocessor().getClass()); 
    234                 } 
    235         } 
    236  
    237  
    238         protected DateTime startingTime() { 
    239                 if (statisticParameters.getStartTimeAsDate() != null) 
    240                         return statisticParameters.getStartTimeAsDate(); 
    241                 DateTime start = (DateTime) this.getEntryHandler().queryUnique("select min(eventTime) from Event"); 
    242                 return start; 
    243         } 
    244  
    245         protected DateTime endingTime() { 
    246                 if (statisticParameters.getEndTimeAsDate() != null) 
    247                         return statisticParameters.getEndTimeAsDate(); 
    248                 DateTime end = (DateTime) this.getEntryHandler().queryUnique("select max(eventTime) from Event"); 
    249                 return end; 
    250         } 
    251  
    252  
    253         public void setField(String field) { 
    254  
    255         } 
    256  
    257         public void setPreprocessor(StatisticsPreProcessor preprocessor) { 
    258                 this.preprocessor = preprocessor; 
    259         } 
    260  
    261         public StatisticsPreProcessor getPreprocessor() { 
    262                 return preprocessor; 
    263         } 
    264  
    265         public List<StatisticsPostProcessor> getPostprocessor() { 
    266                 return postprocessor; 
    267         } 
    268  
    269         public void setPostprocessor(List<StatisticsPostProcessor> postprocessor) { 
    270                 this.postprocessor = postprocessor; 
    271         } 
    272  
    273         public abstract void setStatisticParameters(StatisticParameters statisticParameters) ; 
    274  
    275  
    276         public StatisticParameters getStatisticParameters() { 
    277                 return statisticParameters; 
    278         } 
    279  
    280         public EventHandler getEntryHandler() { 
    281                 return entryHandler; 
    282         } 
    283  
    284         public void setObservationSeries(List<ObservationSeries> observationSeries) { 
    285                 this.observationSeries = observationSeries; 
    286         } 
    287  
    288         public List<ObservationSeries> getObservationSeries() { 
    289                 return observationSeries; 
    290         } 
     47    /** Class logger */ 
     48    private final Logger log = LoggerFactory.getLogger(Statistic.class); 
     49 
     50    /** 
     51     * The <code>EntryHandler</code> that allows access to all <code>Event</code>s this statistic works off. 
     52    */ 
     53    private EventHandler entryHandler; 
     54 
     55    /** The parameters used to configure this statistic */ 
     56    protected StatisticParameters statisticParameters; 
     57 
     58    /** add a preprocessing module to the statistical method */ 
     59    private StatisticsPreProcessor preprocessor; 
     60 
     61    /** add a postprocessing module to the statistical method */ 
     62    private List<StatisticsPostProcessor> postprocessor; 
     63 
     64    /** 
     65     * After each statistic has been invoked, the results of each series are stored as <code>ObservationSeries</code> in 
     66     * this list. 
     67     */ 
     68    private List<ObservationSeries> observationSeries; 
     69 
     70    /** 
     71     * Default constructor. 
     72     */ 
     73    public Statistic() { 
     74        setObservationSeries(new ArrayList<ObservationSeries>()); 
     75    } 
     76 
     77    /** 
     78     * Method that performs the statistical operation. Overridden by each concrete statistic class. 
     79     *  
     80     * @param methodParams 
     81     * @param sqlWhere 
     82     * @return 
     83     * @throws StatisticalUnitException 
     84     */ 
     85    public abstract Boolean performStatistic(List<MethodParameter> methodParams, String sqlWhere) 
     86            throws StatisticalUnitException; 
     87 
     88    /** 
     89     * Important this this method is called during the statistic process lifecycle, so that any state variables e.g. the 
     90     * observationSeries, is reset ready for the next invocation 
     91     */ 
     92    public void reset() { 
     93        observationSeries.clear(); 
     94    } 
     95 
     96    public void setEntryHandler(EventHandler entryHandler) { 
     97        if (preprocessor != null) 
     98            try { 
     99                log.info("Invoking statistical preprocessor " + preprocessor.getClass()); 
     100                preprocessor.preProcess(entryHandler); 
     101            } catch (PreprocessorException e) { 
     102                log.error("Could not preprocess entries " + preprocessor.getClass()); 
     103            } 
     104        this.entryHandler = entryHandler; 
     105    } 
     106 
     107    /** 
     108    * <p> 
     109     * construct a graph model from the data observations and groupings stored in the buckets 
     110     * </p> 
     111     *  
     112     * @return 
     113     */ 
     114    public AggregatorGraphModel constructGraphModel() { 
     115        AggregatorGraphModel gmodel = new AggregatorGraphModel(); 
     116        gmodel.setPresentation(this.getStatisticParameters().getPresentation()); 
     117        int countGroup = 0; 
     118        int countBucket = 0; 
     119 
     120        for (ObservationSeries obsSeries : observationSeries) { 
     121            if (obsSeries.getObservations() instanceof Group[]) 
     122                countGroup++; 
     123            if (obsSeries.getObservations() instanceof Bucket[]) 
     124                countBucket++; 
     125        } 
     126        if (countGroup == 0 && countBucket == 0) 
     127            return gmodel; 
     128        log.debug("Statistic has {} series and {} observations", this.getStatisticParameters().getSeries().size(), 
     129                observationSeries.size()); 
     130        log.debug("Observation type, GroupType {}, BucketType {}", countGroup, countBucket); 
     131 
     132        if (countGroup == observationSeries.size()) { 
     133            log.info("Constructing graph model for Group type"); 
     134            // construct the groups from the series with the most groups 
     135            Observation[] observations = getObservationWithMostGroups(observationSeries); 
     136            Group[] groups = (Group[]) observations; 
     137            log.trace("Has {} groups", groups.length); 
     138            for (Group group : groups) { 
     139                log.trace("Group {}", group.getGroupName()); 
     140                gmodel.addGroupLabel(group.getGroupName()); 
     141            } 
     142 
     143            // now add each series and their values 
     144            for (int i = 0; i < observationSeries.size(); i++) { 
     145                groups = (Group[]) observationSeries.get(i).getObservations(); 
     146                gmodel.getSeriesLabels().add(statisticParameters.getSeries().get(i).getSeriesLabel()); 
     147                List<Double> values = new ArrayList<Double>(); 
     148                for (String label : gmodel.getGroupLabels()) { 
     149                    Double valueDouble = new Double(0); 
     150                    for (Group group : groups) { 
     151                        if (group.getGroupName().equals(label)) 
     152                            valueDouble = new Double(group.getValue()); 
     153                    } 
     154                    values.add(valueDouble); 
     155                } 
     156 
     157                log.trace("Adding Values {}", Arrays.toString(values.toArray(new Double[0]))); 
     158                gmodel.addGroupValue(values); 
     159            } 
     160 
     161        } else if (countBucket == observationSeries.size()) { 
     162            log.info("Constructing graph model for Bucket type"); 
     163 
     164            // construct the groups from the first series (each series will have the same grouping) 
     165            Observation[] observations = observationSeries.get(0).getObservations(); 
     166            Bucket[] buckets = (Bucket[]) observations; 
     167            String pattern = "yyyy-MM-dd HH:mm"; 
     168            if (statisticParameters.getPresentation().getDateFormat() != null) 
     169                pattern = statisticParameters.getPresentation().getDateFormat(); 
     170            DateTimeFormatter startParser = DateTimeFormat.forPattern(pattern); 
     171            DateTimeFormatter endParser = DateTimeFormat.forPattern(pattern); 
     172            for (Bucket bucket : buckets) { 
     173                gmodel.addGroupLabel(startParser.print(bucket.getStart()) + "  " + endParser.print(bucket.getEnd())); 
     174            } 
     175            // Buckets are time series, and so are already sorted chronologically. 
     176 
     177            for (int i = 0; i < observationSeries.size(); i++) { 
     178                buckets = (Bucket[]) observationSeries.get(i).getObservations(); 
     179                gmodel.getSeriesLabels().add(statisticParameters.getSeries().get(i).getSeriesLabel()); 
     180 
     181                List<Double> values = new ArrayList(); 
     182                for (Bucket bucket : buckets) { 
     183                    Double valueDouble = new Double(bucket.getValue()); 
     184                    values.add(valueDouble); 
     185                } 
     186                log.trace("Adding Values {}", Arrays.toString(values.toArray(new Double[0]))); 
     187                gmodel.addGroupValue(values); 
     188            } 
     189        } else { 
     190            log.error("Statistic had series with mixed observation types, which is currently not supported"); 
     191        } 
     192 
     193        return gmodel; 
     194    } 
     195 
     196    private Observation[] getObservationWithMostGroups(List<ObservationSeries> observationSeries) { 
     197        Observation[] maxObs = null; 
     198        int max = 0; 
     199        for (ObservationSeries series : observationSeries) { 
     200            Observation[] obs = series.getObservations(); 
     201            if (obs.length > max) { 
     202                max = obs.length; 
     203                maxObs = obs; 
     204            } 
     205 
     206        } 
     207        return maxObs; 
     208    } 
     209 
     210    /** 
     211     * <p> 
     212     * pre processing effects the entries that go into the statistical unit post processing effects the observations 
     213     * that result form the statistical unit 
     214     * </p> 
     215     */ 
     216    public void postProcess() { 
     217        try { 
     218            if (getPostprocessor() != null) { 
     219                log.info("There are {} post processors to apply, these are {}", getPostprocessor().size(), 
     220                        Arrays.toString(getPostprocessor().toArray(new StatisticsPostProcessor[0]))); 
     221                for (StatisticsPostProcessor post : postprocessor) { 
     222                    // perform the same post process on each observationseries 
     223                    for (ObservationSeries obsSeries : getObservationSeries()) { 
     224                        obsSeries.setObservations(post.postProcess(obsSeries.getObservations())); 
     225                    } 
     226                } 
     227            } else { 
     228                log.info("There are 0 post processors to apply"); 
     229            } 
     230        } catch (PostprocessorException e) { 
     231            log.error("Could not post process entries, using " + getPostprocessor().getClass()); 
     232        } 
     233    } 
     234 
     235    protected DateTime startingTime() { 
     236        if (statisticParameters.getStartTimeAsDate() != null) 
     237            return statisticParameters.getStartTimeAsDate(); 
     238        DateTime start = (DateTime) this.getEntryHandler().queryUnique("select min(eventTime) from Event"); 
     239        return start; 
     240    } 
     241 
     242    protected DateTime endingTime() { 
     243        if (statisticParameters.getEndTimeAsDate() != null) 
     244            return statisticParameters.getEndTimeAsDate(); 
     245        DateTime end = (DateTime) this.getEntryHandler().queryUnique("select max(eventTime) from Event"); 
     246        return end; 
     247    } 
     248 
     249    public void setField(String field) { 
     250 
     251    } 
     252 
     253    public void setPreprocessor(StatisticsPreProcessor preprocessor) { 
     254        this.preprocessor = preprocessor; 
     255    } 
     256 
     257    public StatisticsPreProcessor getPreprocessor() { 
     258        return preprocessor; 
     259    } 
     260 
     261    public List<StatisticsPostProcessor> getPostprocessor() { 
     262        return postprocessor; 
     263    } 
     264 
     265    public void setPostprocessor(List<StatisticsPostProcessor> postprocessor) { 
     266        this.postprocessor = postprocessor; 
     267    } 
     268 
     269    public abstract void setStatisticParameters(StatisticParameters statisticParameters); 
     270 
     271    public StatisticParameters getStatisticParameters() { 
     272        return statisticParameters; 
     273    } 
     274 
     275    public EventHandler getEntryHandler() { 
     276        return entryHandler; 
     277    } 
     278 
     279    public void setObservationSeries(List<ObservationSeries> observationSeries) { 
     280        this.observationSeries = observationSeries; 
     281    } 
     282 
     283    public List<ObservationSeries> getObservationSeries() { 
     284        return observationSeries; 
     285    } 
    291286 
    292287} 
  • raptor-mua/trunk/src/main/java/uk/ac/cardiff/raptormua/engine/statistics/StatisticsHandler.java

    r1078 r1080  
    164164        statistic.setStatisticParameters(statisticalUnitInformation.getStatisticParameters()); 
    165165        // now deal with the post processors 
    166         List<ProcessorInformation> postprocessors = statisticalUnitInformation.getPostprocessors(); 
    167         statisticalUnitInformation.setPostprocessors(postprocessors); 
     166        List<StatisticsPostProcessor> postProcessors = 
     167                initialisePostProcessors(statisticalUnitInformation.getPostprocessors()); 
     168        statistic.setPostprocessor(postProcessors); 
     169    } 
     170 
     171    /** 
     172     *  
     173     * @param postProcessorsInformation 
     174     * @return 
     175     */ 
     176    private List<StatisticsPostProcessor> 
     177            initialisePostProcessors(List<ProcessorInformation> postProcessorsInformation) { 
     178        // TODO could be factory method, need to acquire the bean implementation now. 
     179        List<StatisticsPostProcessor> postprocessors = null; 
     180 
     181        return postprocessors; 
    168182    } 
    169183 
  • raptor-mua/trunk/src/main/java/uk/ac/cardiff/raptormua/wsinterface/impl/MultiUnitAggregatorImpl.java

    r838 r1080  
    1717 * 
    1818 */ 
     19 
    1920package uk.ac.cardiff.raptormua.wsinterface.impl; 
    2021 
     
    2425 
    2526import org.apache.cxf.binding.soap.SoapFault; 
    26  
    2727 
    2828import uk.ac.cardiff.model.AdministrativeFunction; 
     
    3838 
    3939/** 
     40 * The Class MultiUnitAggregatorImpl. 
     41 *  
    4042 * @author philsmart 
    41  * 
    4243 */ 
    4344 
    4445@WebService(endpointInterface = "uk.ac.cardiff.raptor.remoting.server.sei.MultiUnitAggregator") 
    45 public class MultiUnitAggregatorImpl implements MultiUnitAggregator{ 
     46public class MultiUnitAggregatorImpl implements MultiUnitAggregator { 
    4647 
    47         private MUAProcess processService; 
     48    /** The process service. */ 
     49    private MUAProcess processService; 
    4850 
    49         public String getVersion() { 
    50                 return "Alpha"; 
    51         } 
     51    /* 
     52     * (non-Javadoc) 
     53     *  
     54     * @see uk.ac.cardiff.raptor.remoting.server.sei.MultiUnitAggregator#getVersion() 
     55     */ 
     56    public String getVersion() { 
     57        return "Alpha"; 
     58    } 
    5259 
    53         public void setProcessService(MUAProcess processService) { 
    54                 this.processService = processService; 
    55         } 
     60    /** 
     61     * Sets the process service. 
     62     *  
     63     * @param processService the new process service 
     64     */ 
     65    public void setProcessService(MUAProcess processService) { 
     66        this.processService = processService; 
     67    } 
    5668 
    57         public MUAProcess getProcessService() { 
    58                 return processService; 
    59         } 
     69    /** 
     70     * Gets the process service. 
     71     *  
     72     * @return the process service 
     73     */ 
     74    public MUAProcess getProcessService() { 
     75        return processService; 
     76    } 
    6077 
    61         public Capabilities getCapabilities() { 
    62                 // TODO Auto-generated method stub 
    63                 return processService.getCapabilities(); 
    64         } 
     78    /* 
     79     * (non-Javadoc) 
     80     *  
     81     * @see uk.ac.cardiff.raptor.remoting.server.sei.MultiUnitAggregator#getCapabilities() 
     82     */ 
     83    public Capabilities getCapabilities() { 
     84        // TODO Auto-generated method stub 
     85        return processService.getCapabilities(); 
     86    } 
    6587 
     88    /* 
     89     * (non-Javadoc) 
     90     *  
     91     * @see uk.ac.cardiff.raptor.remoting.server.sei.MultiUnitAggregator#invokeStatisticalUnit(java.lang.String) 
     92     */ 
     93    public AggregatorGraphModel invokeStatisticalUnit(String statisticName) throws SoapFault { 
     94        return processService.performStatistic(statisticName); 
     95    } 
    6696 
    67         public AggregatorGraphModel invokeStatisticalUnit(String statisticName) throws SoapFault { 
    68                 return processService.performStatistic(statisticName); 
    69         } 
     97    /* 
     98     * (non-Javadoc) 
     99     *  
     100     * @see 
     101     * uk.ac.cardiff.raptor.remoting.server.sei.MultiUnitAggregator#updateStatisticalUnit(uk.ac.cardiff.model.wsmodel 
     102     * .StatisticalUnitInformation) 
     103     */ 
     104    public void updateStatisticalUnit(StatisticalUnitInformation statisticalUnitInformation) throws SoapFault { 
     105        processService.updateStatisticalUnit(statisticalUnitInformation); 
    70106 
     107    } 
    71108 
    72         public void updateStatisticalUnit(StatisticalUnitInformation statisticalUnitInformation) throws SoapFault { 
    73             processService.updateStatisticalUnit(statisticalUnitInformation); 
     109    /* 
     110     * (non-Javadoc) 
     111     *  
     112     * @see 
     113     * uk.ac.cardiff.raptor.remoting.server.sei.MultiUnitAggregator#performAdministrativeFunction(uk.ac.cardiff.model 
     114     * .AdministrativeFunction) 
     115     */ 
     116    public boolean performAdministrativeFunction(AdministrativeFunction function) throws SoapFault { 
     117        return processService.performAdministrativeFunction(function); 
     118    } 
    74119 
    75         } 
     120    /* 
     121     * (non-Javadoc) 
     122     *  
     123     * @see uk.ac.cardiff.raptor.remoting.server.sei.MultiUnitAggregator#addAuthentications(uk.ac.cardiff.model.wsmodel. 
     124     * EventPushMessage) 
     125     */ 
     126    public void addAuthentications(EventPushMessage pushed) throws SoapFault { 
     127        processService.addAuthentications(pushed); 
    76128 
     129    } 
    77130 
    78         public boolean performAdministrativeFunction(AdministrativeFunction function) throws SoapFault { 
    79             return processService.performAdministrativeFunction(function); 
    80         } 
     131    /* 
     132     * (non-Javadoc) 
     133     *  
     134     * @see 
     135     * uk.ac.cardiff.raptor.remoting.server.sei.MultiUnitAggregator#updateAndInvokeStatisticalUnit(uk.ac.cardiff.model 
     136     * .wsmodel.StatisticalUnitInformation) 
     137     */ 
     138    public AggregatorGraphModel updateAndInvokeStatisticalUnit(StatisticalUnitInformation statisticalUnitInformation) 
     139            throws SoapFault { 
     140        return processService.updateAndInvokeStatisticalUnit(statisticalUnitInformation); 
     141    } 
    81142 
     143    /* 
     144     * (non-Javadoc) 
     145     *  
     146     * @see uk.ac.cardiff.raptor.remoting.server.sei.MultiUnitAggregator#batchUpload(java.util.List) 
     147     */ 
     148    public List<LogFileUploadResult> batchUpload(List<LogFileUpload> uploadFiles) throws SoapFault { 
     149        return processService.batchUpload(uploadFiles); 
     150    } 
    82151 
    83         public void addAuthentications(EventPushMessage pushed) throws SoapFault{ 
    84             processService.addAuthentications(pushed); 
     152    /* 
     153     * (non-Javadoc) 
     154     *  
     155     * @see uk.ac.cardiff.raptor.remoting.server.sei.MultiUnitAggregator#saveResourceMetadata(java.util.List) 
     156     */ 
     157    public void saveResourceMetadata(List<ResourceMetadata> resourceMetadata) { 
     158        processService.saveResourceMetadata(resourceMetadata); 
    85159 
    86         } 
    87  
    88         public AggregatorGraphModel updateAndInvokeStatisticalUnit(StatisticalUnitInformation statisticalUnitInformation) throws SoapFault { 
    89                 return processService.updateAndInvokeStatisticalUnit(statisticalUnitInformation); 
    90         } 
    91  
    92         public List<LogFileUploadResult> batchUpload(List<LogFileUpload> uploadFiles) throws SoapFault{ 
    93                 return processService.batchUpload(uploadFiles); 
    94         } 
    95  
    96         public void saveResourceMetadata(List<ResourceMetadata> resourceMetadata) { 
    97                 processService.saveResourceMetadata(resourceMetadata); 
    98                  
    99         } 
    100  
    101  
     160    } 
    102161 
    103162} 
Note: See TracChangeset for help on using the changeset viewer.