ResultsController.cs

Go to the documentation of this file.

// TraceLab Component Library
// Copyright © 2012-2013 SEMERU
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using TraceLab.Components.DevelopmentKit.Metrics;
using TraceLabSDK;
using TraceLabSDK.Types.Contests;

namespace TraceLab.Components.Library.Metrics.Controller
{
    public sealed class ResultsController
    {
        #region Singleton utilities

        private static readonly ResultsController _instance;

        static ResultsController()
        {
            _instance = new ResultsController();
        }

        public static ResultsController Instance
        {
            get
            {
                return _instance;
            }
        }

        public static ResultsController CreatePrivateInstance()
        {
            return new ResultsController();
        }

        #endregion

        #region Class definition

        #region Members

        private Object _lock = new Object();

        private ResultsController()
        {
            _techniques = new HashSet<string>();
            _datasets = new HashSet<string>();
            _results = new Dictionary<string, List<IMetricComputation>>();
        }

        private HashSet<string> _techniques;
        private HashSet<string> _datasets;
        private Dictionary<string, List<IMetricComputation>> _results;

        public IEnumerable<string> Techniques
        {
            get
            {
                lock (_lock)
                {
                    return new HashSet<string>(_techniques);
                }
            }
        }

        public IEnumerable<string> Datasets
        {
            get
            {
                lock (_lock)
                {
                    return new HashSet<string>(_datasets);
                }
            }
        }

        #endregion

        public void AddResult(string technique, string dataset, IMetricComputation computation)
        {
            if (String.IsNullOrWhiteSpace(technique))
            {
                throw new ComponentException("Technique name cannot be empty.");
            }
            if (String.IsNullOrWhiteSpace(dataset))
            {
                throw new ComponentException("Dataset name cannot be empty.");
            }
            if (computation == null)
            {
                throw new ComponentException("Computation cannot be null.");
            }
            lock (_lock)
            {
                _techniques.Add(technique);
                _datasets.Add(dataset);
                string key = ComputeKey(technique, dataset);
                if (!_results.ContainsKey(key))
                {
                    _results.Add(key, new List<IMetricComputation>());
                }
                _results[key].Add(computation);
            }
        }

        public IEnumerable<IMetricComputation> GetResults(string technique, string dataset)
        {
            if (String.IsNullOrWhiteSpace(technique))
            {
                throw new ComponentException("Technique name cannot be empty.");
            }
            if (String.IsNullOrWhiteSpace(dataset))
            {
                throw new ComponentException("Dataset name cannot be empty.");
            }
            lock (_lock)
            {
                if (!_techniques.Contains(technique))
                {
                    throw new ComponentException("Collection does not contain technique \"" + technique + "\"");
                }
                if (!_datasets.Contains(dataset))
                {
                    throw new ComponentException("Collection does not contain dataset \"" + dataset + "\"");
                }
                List<IMetricComputation> list = null;
                string key = ComputeKey(technique, dataset);
                _results.TryGetValue(key, out list);
                if (list == null)
                {
                    throw new ComponentException("Could not retrieve data from collection: (" + technique + ", " + dataset + ")");
                }
                return new List<IMetricComputation>(list);
            }
        }

        public TLExperimentsResultsCollection GenerateSummaryResults()
        {
            lock (_lock)
            {
                TLExperimentsResultsCollection ExperimentsResultsCollection = new TLExperimentsResultsCollection();
                // iterate over techniques
                foreach (string technique in _techniques)
                {
                    TLExperimentResults TechniqueResults = new TLExperimentResults(technique);
                    // iterate over datasets
                    foreach (string dataset in _datasets)
                    {
                        // get list of results for technique + dataset
                        List<IMetricComputation> list = null;
                        string key = ComputeKey(technique, dataset);
                        _results.TryGetValue(key, out list);
                        if (list != null)
                        {
                            DatasetResults data = new DatasetResults(dataset);
                            // add results to dataset
                            foreach (IMetricComputation computation in list)
                            {
                                if (!computation.HasRun)
                                {
                                    computation.Compute();
                                }
                                data.AddMetric(computation.GenerateSummary());
                            }
                            // add dataset to technique
                            if (data.Metrics.Count() > 0)
                            {
                                TechniqueResults.AddDatasetResult(data);
                            }
                        }
                    }
                    // add technique to collection
                    if (TechniqueResults.DatasetsResults.Count() > 0)
                    {
                        ExperimentsResultsCollection.Add(TechniqueResults);
                    }
                }
                return ExperimentsResultsCollection;
            }
        }

        private string ComputeKey(string technique, string dataset)
        {
            return technique + "_" + dataset;
        }

        #endregion
    }
}