Radically cleaned the server side data mining projects

2026-09-21 21:25:38 +00:00 · 2014-06-05 11:33:07 +02:00
parent c9fae07ada
commit 225cacad6e
92 changed files with 18 additions and 2962 deletions
@@ -1,4 +1,5 @@
-source.. = src/
+source.. = src/,\
+		   resources/
 output.. = bin/
 bin.includes = META-INF/,\
               .
@@ -1,35 +0,0 @@
-package com.sap.sailing.datamining.test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Test;
-
-import com.sap.sailing.datamining.Clusters;
-import com.sap.sse.datamining.data.deprecated.ClusterOfComparable;
-import com.sap.sse.datamining.impl.data.deprecated.ClusterOfComparableImpl;
-
-public class TestClusters {
-    
-    @Test
-    public void testClusterOfComparable() {
-        ClusterOfComparable<Integer> cluster = new ClusterOfComparableImpl<Integer>("Test", 3, 1); 
-        
-        assertTrue(cluster.isInRange(1)); 
-        assertTrue(cluster.isInRange(2)); 
-        assertTrue(cluster.isInRange(3));
-
-        assertFalse(cluster.isInRange(null));
-        assertFalse(cluster.isInRange(0));
-        assertFalse(cluster.isInRange(4));
-    }
-    
-    @Test
-    public void testWindStrengthClusters() {
-        assertNull(Clusters.WindStrength.getClusterFor(15, Clusters.WindStrength.StandardClusters));
-        assertEquals(Clusters.WindStrength.VeryLight, Clusters.WindStrength.getClusterFor(1, Clusters.WindStrength.StandardClusters));
-    }
-
-}
@@ -7,8 +7,7 @@ Bundle-Vendor: SAP
 Bundle-RequiredExecutionEnvironment: JavaSE-1.7
 Import-Package: com.sap.sailing.server,
 org.osgi.framework;version="1.7.0"
-Export-Package: com.sap.sailing.datamining,
- com.sap.sailing.datamining.data,
+Export-Package: com.sap.sailing.datamining.data,
 com.sap.sailing.datamining.factories
 Require-Bundle: com.sap.sailing.domain;bundle-version="1.0.0",
 com.sap.sailing.domain.common,
@@ -1,46 +0,0 @@
-package com.sap.sailing.datamining;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-
-import com.sap.sailing.datamining.impl.WindStrengthClusterImpl;
-
-public class Clusters {
-    
-    private Clusters() { }
-    
-    public static class WindStrength {
-        
-        public static WindStrengthCluster VeryLight = new WindStrengthClusterImpl("Very Light", 0.0, 2.5);
-        public static WindStrengthCluster Light = new WindStrengthClusterImpl("Very Light", 2.5, 5.0);
-        public static WindStrengthCluster Medium = new WindStrengthClusterImpl("Very Light", 5.0, 7.5);
-        public static WindStrengthCluster Strong = new WindStrengthClusterImpl("Very Light", 7.5, 10.0);
-        public static WindStrengthCluster VeryStrong = new WindStrengthClusterImpl("Very Light", 10.0, 12.0);
-        public static Collection<WindStrengthCluster> StandardClusters = Arrays.asList(VeryLight, Light, Medium, Strong, VeryStrong);
-
-        private WindStrength() { }
-
-        public static WindStrengthCluster getClusterFor(double windStrengthInBeafort, Collection<WindStrengthCluster> clusters) {
-            List<WindStrengthCluster> sortedClusters = new ArrayList<WindStrengthCluster>(clusters);
-            Collections.sort(sortedClusters, new Comparator<WindStrengthCluster>() {
-                @Override
-                public int compare(WindStrengthCluster cluster1, WindStrengthCluster cluster2) {
-                    return cluster1.getUpperRange().compareTo(cluster2.getUpperRange());
-                }
-            });
-            
-            for (WindStrengthCluster cluster : sortedClusters) {
-                if (cluster.isInRange(windStrengthInBeafort)) {
-                    return cluster;
-                }
-            }
-            return null;
-        }
-        
-    }
-
-}
@@ -1,7 +0,0 @@
-package com.sap.sailing.datamining;
-
-import com.sap.sse.datamining.data.deprecated.ClusterOfComparable;
-
-public interface WindStrengthCluster extends ClusterOfComparable<Double> {
-
-}
@@ -1,10 +0,0 @@
-package com.sap.sailing.datamining.dimensions;
-
-import com.sap.sailing.datamining.shared.DimensionIdentifier;
-import com.sap.sse.datamining.data.deprecated.Dimension;
-
-public interface DimensionManager<DataType> {
-
-    public Dimension<DataType, ?> getDimensionFor(DimensionIdentifier sharedDimension);
-
-}
@@ -1,26 +0,0 @@
-package com.sap.sailing.datamining.dimensions;
-
-import com.sap.sailing.datamining.data.GPSFixWithContext;
-import com.sap.sailing.datamining.data.TrackedLegOfCompetitorWithContext;
-import com.sap.sailing.datamining.shared.DataTypes;
-
-public final class DimensionManagerProvider {
-    
-    private DimensionManagerProvider() { }
-    
-    private static final DimensionManager<GPSFixWithContext> GPSFixDimensionManager = new GPSFixDimensionManager();
-    private static final DimensionManager<TrackedLegOfCompetitorWithContext> TrackedLegOfCompetitorDimensionManager = new TrackedLegOfCompetitorDimensionManager();
-
-    @SuppressWarnings("unchecked")
-    public static <DataType> DimensionManager<DataType> getDimensionManagerFor(DataTypes dataType) {
-        switch (dataType) {
-        case GPSFix:
-            return (DimensionManager<DataType>) GPSFixDimensionManager;
-        case TrackedLegOfCompetitor:
-            return (DimensionManager<DataType>) TrackedLegOfCompetitorDimensionManager;
-        }
-        throw new IllegalArgumentException("Not yet implemented for the given data type: "
-                + dataType.toString());
-    }
-
-}
@@ -1,133 +0,0 @@
-package com.sap.sailing.datamining.dimensions;
-
-import com.sap.sailing.datamining.data.GPSFixWithContext;
-import com.sap.sailing.datamining.shared.DimensionIdentifier;
-import com.sap.sailing.domain.common.LegType;
-import com.sap.sse.datamining.data.deprecated.Dimension;
-import com.sap.sse.datamining.impl.data.deprecated.AbstractDimension;
-
-public final class GPSFixDimensionManager implements DimensionManager<GPSFixWithContext> {
-
-    public GPSFixDimensionManager() { }
-
-    /**
-     * @return The dimension for the given dimension type. Throws an exception, if the used <code>ValueType</code> doesn't match the <code>ValueType</code> of the returning dimension.
-     */
-    @Override
-    public Dimension<GPSFixWithContext, ?> getDimensionFor(DimensionIdentifier dimension) {
-        switch (dimension) {
-        case BoatClassName:
-            return BoatClassNameDimension;
-        case CompetitorName:
-            return CompetitorNameDimension;
-        case CourseAreaName:
-            return CourseAreaNameDimension;
-        case FleetName:
-            return FleetNameDimension;
-        case LegNumber:
-            return LegNumberDimension;
-        case LegType:
-            return LegTypeDimension;
-        case Nationality:
-            return NationalityDimension;
-        case RaceName:
-            return RaceNameDimension;
-        case RegattaName:
-            return RegattaNameDimension;
-        case SailID:
-            return SailIDDimension;
-        case WindStrength:
-            return WindStrengthDimension;
-        case Year:
-            return YearDimension;
-        }
-        throw new IllegalArgumentException("Not yet implemented for the given dimension: "
-                + dimension.toString());
-    }
-
-    public final static Dimension<GPSFixWithContext, String> RegattaNameDimension = new AbstractDimension<GPSFixWithContext, String>("Regatta") {
-        @Override
-        public String getDimensionValueFrom(GPSFixWithContext data) {
-            return data.getRegattaName();
-        }
-    };
-
-    public final static Dimension<GPSFixWithContext, String> RaceNameDimension = new AbstractDimension<GPSFixWithContext, String>("Race") {
-        @Override
-        public String getDimensionValueFrom(GPSFixWithContext data) {
-            return data.getRaceName();
-        }
-    };
-
-    public final static Dimension<GPSFixWithContext, Integer> LegNumberDimension = new AbstractDimension<GPSFixWithContext, Integer>("Leg Number") {
-        @Override
-        public Integer getDimensionValueFrom(GPSFixWithContext data) {
-            return data.getLegNumber();
-        }
-    };
-
-    public final static Dimension<GPSFixWithContext, String> CourseAreaNameDimension = new AbstractDimension<GPSFixWithContext, String>("Course Area") {
-        @Override
-        public String getDimensionValueFrom(GPSFixWithContext data) {
-            return data.getCourseAreaName();
-        }
-    };
-
-    public final static Dimension<GPSFixWithContext, String> FleetNameDimension = new AbstractDimension<GPSFixWithContext, String>("Fleet") {
-        @Override
-        public String getDimensionValueFrom(GPSFixWithContext data) {
-            return data.getFleetName();
-        }
-    };
-
-    public final static Dimension<GPSFixWithContext, String> BoatClassNameDimension = new AbstractDimension<GPSFixWithContext, String>("Boat Class") {
-        @Override
-        public String getDimensionValueFrom(GPSFixWithContext data) {
-            return data.getBoatClassName();
-        }
-    };
-
-    public final static Dimension<GPSFixWithContext, Integer> YearDimension = new AbstractDimension<GPSFixWithContext, Integer>("Year") {
-        @Override
-        public Integer getDimensionValueFrom(GPSFixWithContext data) {
-            return data.getYear();
-        }
-    };
-
-    public final static Dimension<GPSFixWithContext, LegType> LegTypeDimension = new AbstractDimension<GPSFixWithContext, LegType>("Leg Type") {
-        @Override
-        public LegType getDimensionValueFrom(GPSFixWithContext data) {
-            return data.getLegType();
-        }
-    };
-
-    public final static Dimension<GPSFixWithContext, String> CompetitorNameDimension = new AbstractDimension<GPSFixWithContext, String>("Competitor") {
-        @Override
-        public String getDimensionValueFrom(GPSFixWithContext data) {
-            return data.getCompetitorName();
-        }
-    };
-
-    public final static Dimension<GPSFixWithContext, String> SailIDDimension = new AbstractDimension<GPSFixWithContext, String>("Sail ID") {
-        @Override
-        public String getDimensionValueFrom(GPSFixWithContext data) {
-            return data.getCompetitorSailID();
-        }
-    };
-
-    public final static Dimension<GPSFixWithContext, String> NationalityDimension = new AbstractDimension<GPSFixWithContext, String>("Nationality") {
-        @Override
-        public String getDimensionValueFrom(GPSFixWithContext data) {
-            return data.getCompetitorNationality();
-        }
-    };
-
-    //TODO after new clusters
-    public final static Dimension<GPSFixWithContext, String> WindStrengthDimension = new AbstractDimension<GPSFixWithContext, String>("Wind Strength") {
-        @Override
-        public String getDimensionValueFrom(GPSFixWithContext data) {
-            return data.getWindStrength().getName();
-        }
-    };
-
-}
@@ -1,132 +0,0 @@
-package com.sap.sailing.datamining.dimensions;
-
-import com.sap.sailing.datamining.data.TrackedLegOfCompetitorWithContext;
-import com.sap.sailing.datamining.shared.DimensionIdentifier;
-import com.sap.sailing.domain.common.LegType;
-import com.sap.sse.datamining.data.deprecated.Dimension;
-import com.sap.sse.datamining.impl.data.deprecated.AbstractDimension;
-
-public final class TrackedLegOfCompetitorDimensionManager implements DimensionManager<TrackedLegOfCompetitorWithContext> {
-
-    public TrackedLegOfCompetitorDimensionManager() { }
-
-    /**
-     * @return The dimension for the given dimension type. Throws an exception, if the used <code>ValueType</code> doesn't match the <code>ValueType</code> of the returning dimension.
-     */
-    public Dimension<TrackedLegOfCompetitorWithContext, ?> getDimensionFor(DimensionIdentifier dimension) {
-        switch (dimension) {
-        case BoatClassName:
-            return BoatClassNameDimension;
-        case CompetitorName:
-            return CompetitorNameDimension;
-        case CourseAreaName:
-            return CourseAreaNameDimension;
-        case FleetName:
-            return FleetNameDimension;
-        case LegNumber:
-            return LegNumberDimension;
-        case LegType:
-            return LegTypeDimension;
-        case Nationality:
-            return NationalityDimension;
-        case RaceName:
-            return RaceNameDimension;
-        case RegattaName:
-            return RegattaNameDimension;
-        case SailID:
-            return SailIDDimension;
-        case WindStrength:
-            return WindStrengthDimension;
-        case Year:
-            return YearDimension;
-        }
-        throw new IllegalArgumentException("Not yet implemented for the given dimension: "
-                + dimension.toString());
-    }
-
-    public final static Dimension<TrackedLegOfCompetitorWithContext, String> RegattaNameDimension = new AbstractDimension<TrackedLegOfCompetitorWithContext, String>("Regatta") {
-        @Override
-        public String getDimensionValueFrom(TrackedLegOfCompetitorWithContext data) {
-            return data.getRegattaName();
-        }
-    };
-
-    public final static Dimension<TrackedLegOfCompetitorWithContext, String> RaceNameDimension = new AbstractDimension<TrackedLegOfCompetitorWithContext, String>("Race") {
-        @Override
-        public String getDimensionValueFrom(TrackedLegOfCompetitorWithContext data) {
-            return data.getRaceName();
-        }
-    };
-
-    public final static Dimension<TrackedLegOfCompetitorWithContext, Integer> LegNumberDimension = new AbstractDimension<TrackedLegOfCompetitorWithContext, Integer>("Leg Number") {
-        @Override
-        public Integer getDimensionValueFrom(TrackedLegOfCompetitorWithContext data) {
-            return data.getLegNumber();
-        }
-    };
-
-    public final static Dimension<TrackedLegOfCompetitorWithContext, String> CourseAreaNameDimension = new AbstractDimension<TrackedLegOfCompetitorWithContext, String>("Course Area") {
-        @Override
-        public String getDimensionValueFrom(TrackedLegOfCompetitorWithContext data) {
-            return data.getCourseAreaName();
-        }
-    };
-
-    public final static Dimension<TrackedLegOfCompetitorWithContext, String> FleetNameDimension = new AbstractDimension<TrackedLegOfCompetitorWithContext, String>("Fleet") {
-        @Override
-        public String getDimensionValueFrom(TrackedLegOfCompetitorWithContext data) {
-            return data.getFleetName();
-        }
-    };
-
-    public final static Dimension<TrackedLegOfCompetitorWithContext, String> BoatClassNameDimension = new AbstractDimension<TrackedLegOfCompetitorWithContext, String>("Boat Class") {
-        @Override
-        public String getDimensionValueFrom(TrackedLegOfCompetitorWithContext data) {
-            return data.getBoatClassName();
-        }
-    };
-
-    public final static Dimension<TrackedLegOfCompetitorWithContext, Integer> YearDimension = new AbstractDimension<TrackedLegOfCompetitorWithContext, Integer>("Year") {
-        @Override
-        public Integer getDimensionValueFrom(TrackedLegOfCompetitorWithContext data) {
-            return data.getYear();
-        }
-    };
-
-    public final static Dimension<TrackedLegOfCompetitorWithContext, LegType> LegTypeDimension = new AbstractDimension<TrackedLegOfCompetitorWithContext, LegType>("Leg Type") {
-        @Override
-        public LegType getDimensionValueFrom(TrackedLegOfCompetitorWithContext data) {
-            return data.getLegType();
-        }
-    };
-
-    public final static Dimension<TrackedLegOfCompetitorWithContext, String> CompetitorNameDimension = new AbstractDimension<TrackedLegOfCompetitorWithContext, String>("Competitor") {
-        @Override
-        public String getDimensionValueFrom(TrackedLegOfCompetitorWithContext data) {
-            return data.getCompetitorName();
-        }
-    };
-
-    public final static Dimension<TrackedLegOfCompetitorWithContext, String> SailIDDimension = new AbstractDimension<TrackedLegOfCompetitorWithContext, String>("Sail ID") {
-        @Override
-        public String getDimensionValueFrom(TrackedLegOfCompetitorWithContext data) {
-            return data.getCompetitorSailID();
-        }
-    };
-
-    public final static Dimension<TrackedLegOfCompetitorWithContext, String> NationalityDimension = new AbstractDimension<TrackedLegOfCompetitorWithContext, String>("Nationality") {
-        @Override
-        public String getDimensionValueFrom(TrackedLegOfCompetitorWithContext data) {
-            return data.getCompetitorNationality();
-        }
-    };
-
-    //TODO after new clusters
-    public final static Dimension<TrackedLegOfCompetitorWithContext, String> WindStrengthDimension = new AbstractDimension<TrackedLegOfCompetitorWithContext, String>("Wind Strength") {
-        @Override
-        public String getDimensionValueFrom(TrackedLegOfCompetitorWithContext data) {
-            return data.getWindStrength().getName();
-        }
-    };
-
-}
@@ -2,7 +2,6 @@ package com.sap.sailing.datamining.factories;

 import java.util.ArrayList;
 import java.util.List;
-import java.util.Locale;

 import com.sap.sailing.datamining.data.HasGPSFixContext;
 import com.sap.sailing.datamining.data.HasTrackedLegOfCompetitorContext;
@@ -10,25 +9,13 @@ import com.sap.sailing.datamining.impl.DeprecatedToFunctionConverter;
 import com.sap.sailing.datamining.impl.QueryDefinitionConverter;
 import com.sap.sailing.datamining.shared.QueryDefinition;
 import com.sap.sailing.datamining.shared.QueryDefinitionDeprecated;
-import com.sap.sailing.server.RacingEventService;
 import com.sap.sse.datamining.Query;
-import com.sap.sse.datamining.components.ParallelAggregator;
-import com.sap.sse.datamining.components.ParallelDataRetriever;
-import com.sap.sse.datamining.components.ParallelExtractor;
-import com.sap.sse.datamining.components.ParallelFilter;
-import com.sap.sse.datamining.components.ParallelGrouper;
 import com.sap.sse.datamining.components.Processor;
-import com.sap.sse.datamining.factories.AggregatorFactory;
 import com.sap.sse.datamining.factories.ProcessorFactory;
 import com.sap.sse.datamining.functions.Function;
-import com.sap.sse.datamining.i18n.DataMiningStringMessages;
-import com.sap.sse.datamining.impl.DataMiningActivator;
 import com.sap.sse.datamining.impl.ProcessorQuery;
 import com.sap.sse.datamining.impl.components.GroupedDataEntry;
-import com.sap.sse.datamining.impl.deprecated.QueryImpl;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
-import com.sap.sse.datamining.workers.FiltrationWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;

 public final class DataMiningFactory {
    
@@ -84,37 +71,4 @@ public final class DataMiningFactory {
        return SailingDataRetrievalLevels.GPSFix;
    }

-    @Deprecated
-    public static <DataType, AggregatedType extends Number> Query<AggregatedType> createQuery(
-            QueryDefinitionDeprecated queryDefinition, RacingEventService racingService) {
-        Locale locale = DataMiningStringMessages.Util.getLocaleFrom(queryDefinition.getLocaleInfoName());
-
-        ParallelDataRetriever<DataType> retriever = DataRetrieverFactory.createDataRetriever(
-                queryDefinition.getDataType(), racingService, DataMiningActivator.getExecutor());
-
-        ParallelFilter<DataType> filter = createFilter(queryDefinition);
-
-        ParallelGrouper<DataType> grouper = GrouperFactory.createGrouper(queryDefinition,
-                DataMiningActivator.getExecutor());
-        ParallelExtractor<DataType, AggregatedType> extractor = ExtractorFactory.createExtractor(
-                DataMiningActivator.getStringMessages(), locale, queryDefinition.getStatisticType(),
-                DataMiningActivator.getExecutor());
-        ParallelAggregator<AggregatedType, AggregatedType> aggregator = AggregatorFactory.createAggregator(
-                DataMiningActivator.getStringMessages(), locale, queryDefinition.getStatisticType().getValueType(),
-                queryDefinition.getAggregatorType(), DataMiningActivator.getExecutor());
-
-        return new QueryImpl<DataType, AggregatedType, AggregatedType>(DataMiningActivator.getStringMessages(), locale,
-                retriever, filter, grouper, extractor, aggregator);
-    }
-
-    private static <DataType> ParallelFilter<DataType> createFilter(QueryDefinitionDeprecated queryDefinition) {
-        if (queryDefinition.getSelection().isEmpty()) {
-            return FilterFactory.createNonFilteringFilter();
-        }
-
-        WorkerBuilder<FiltrationWorker<DataType>> workerBuilder = FilterFactory.createDimensionFilterBuilder(
-                queryDefinition.getDataType(), queryDefinition.getSelection());
-        return FilterFactory.createParallelFilter(workerBuilder, DataMiningActivator.getExecutor());
-    }
-
 }
@@ -16,14 +16,9 @@ import com.sap.sailing.datamining.impl.components.LeaderboardGroupRetrievalProce
 import com.sap.sailing.datamining.impl.components.RegattaLeaderboardFilteringRetrievalProcessor;
 import com.sap.sailing.datamining.impl.components.TrackedLegFilteringRetrievalProcessor;
 import com.sap.sailing.datamining.impl.components.TrackedLegOfCompetitorFilteringRetrievalProcessor;
-import com.sap.sailing.datamining.impl.components.deprecated.GroupDividingParallelDataRetriever;
-import com.sap.sailing.datamining.impl.workers.builders.deprecated.DataRetrieverWorkerBuilder;
-import com.sap.sailing.datamining.shared.DataTypes;
 import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
 import com.sap.sailing.domain.leaderboard.RegattaLeaderboard;
-import com.sap.sailing.server.RacingEventService;
 import com.sap.sse.datamining.components.FilterCriteria;
-import com.sap.sse.datamining.components.ParallelDataRetriever;
 import com.sap.sse.datamining.components.Processor;
 import com.sap.sse.datamining.functions.Function;
 import com.sap.sse.datamining.impl.DataMiningActivator;
@@ -32,8 +27,6 @@ import com.sap.sse.datamining.impl.criterias.CompoundFilterCriteria;
 import com.sap.sse.datamining.impl.criterias.NonFilteringFilterCriteria;
 import com.sap.sse.datamining.impl.criterias.NullaryFunctionValuesFilterCriteria;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
-import com.sap.sse.datamining.workers.DataRetrievalWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;

 public final class DataRetrieverFactory {

@@ -103,13 +96,4 @@ public final class DataRetrieverFactory {
        return criteria != null ? criteria : new NonFilteringFilterCriteria<BaseDataType>();
    }

-    /**
-     * Creates a retriever for the given data type. Throws an exception, if the used <code>DataType</code> doesn't match
-     * the <code>DataType</code> of the returning retriever.
-     */
-    public static <DataType> ParallelDataRetriever<DataType> createDataRetriever(DataTypes dataType, RacingEventService racingService, ThreadPoolExecutor executor) {
-        WorkerBuilder<DataRetrievalWorker<LeaderboardGroup, DataType>> workerBuilder = new DataRetrieverWorkerBuilder<DataType>(dataType);
-        return new GroupDividingParallelDataRetriever<DataType>(racingService, workerBuilder, executor);
-    }
-
 }
@@ -1,29 +0,0 @@
-package com.sap.sailing.datamining.factories;
-
-import java.util.Locale;
-import java.util.concurrent.ThreadPoolExecutor;
-
-import com.sap.sailing.datamining.impl.workers.builders.deprecated.ExtractionWorkerBuilder;
-import com.sap.sailing.datamining.shared.StatisticType;
-import com.sap.sse.datamining.components.ParallelExtractor;
-import com.sap.sse.datamining.i18n.DataMiningStringMessages;
-import com.sap.sse.datamining.impl.components.deprecated.GroupDividingParallelExtractor;
-import com.sap.sse.datamining.shared.Message;
-import com.sap.sse.datamining.shared.Unit;
-import com.sap.sse.datamining.workers.ExtractionWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;
-
-public final class ExtractorFactory {
-    
-    private ExtractorFactory() { }
-    
-    public static <DataType, ExtractedType extends Number> ParallelExtractor<DataType, ExtractedType> createExtractor(DataMiningStringMessages stringMessages, Locale locale,
-                                                                                                                      StatisticType statisticType, ThreadPoolExecutor executor) {
-        WorkerBuilder<ExtractionWorker<DataType, ExtractedType>> workerBuilder = new ExtractionWorkerBuilder<DataType, ExtractedType>(statisticType);
-        String signifier = statisticType.getUnit() == Unit.None ? stringMessages.get(locale, statisticType.getSignifierMessage()) : 
-                                                                  stringMessages.get(locale, Message.SignifierInUnit, statisticType.getSignifierMessage(), statisticType.getUnitMessage());
-        return new GroupDividingParallelExtractor<DataType, ExtractedType>(signifier, statisticType.getUnit(), statisticType.getValueDecimals(),
-                                                                           workerBuilder, executor);
-    }
-
-}
@@ -1,64 +0,0 @@
-package com.sap.sailing.datamining.factories;
-
-import java.util.Collection;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.concurrent.ThreadPoolExecutor;
-
-import com.sap.sailing.datamining.dimensions.DimensionManager;
-import com.sap.sailing.datamining.dimensions.DimensionManagerProvider;
-import com.sap.sailing.datamining.shared.DataTypes;
-import com.sap.sailing.datamining.shared.DimensionIdentifier;
-import com.sap.sse.datamining.components.FilterCriteria;
-import com.sap.sse.datamining.components.ParallelFilter;
-import com.sap.sse.datamining.data.deprecated.Dimension;
-import com.sap.sse.datamining.impl.components.deprecated.NonFilteringFilter;
-import com.sap.sse.datamining.impl.components.deprecated.PartitioningParallelFilter;
-import com.sap.sse.datamining.impl.criterias.AndCompoundFilterCriteria;
-import com.sap.sse.datamining.impl.criterias.CompoundFilterCriteria;
-import com.sap.sse.datamining.impl.criterias.deprecated.DimensionValuesFilterCriteria;
-import com.sap.sse.datamining.impl.workers.builders.FilterByCriteriaBuilder;
-import com.sap.sse.datamining.workers.FiltrationWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;
-
-public final class FilterFactory {
-
-    private FilterFactory() { }
-    
-    public static <DataType> ParallelFilter<DataType> createParallelFilter(WorkerBuilder<FiltrationWorker<DataType>> workerBuilder, ThreadPoolExecutor executor) {
-        return new PartitioningParallelFilter<DataType>(workerBuilder, executor);
-    }
-
-    public static <DataType> WorkerBuilder<FiltrationWorker<DataType>> createDimensionFilterBuilder(DataTypes dataType, Map<DimensionIdentifier, Iterable<?>> selection) {
-        FilterCriteria<DataType> criteria = createAndCompoundDimensionFilterCritera(dataType, selection);
-        WorkerBuilder<FiltrationWorker<DataType>> builder = new FilterByCriteriaBuilder<DataType>(criteria); 
-        return builder;
-    }
-
-    /**
-     * @return A filter that filters nothing. So the returning collection is the same as the given one.
-     */
-    public static <DataType> ParallelFilter<DataType> createNonFilteringFilter() {
-        return new NonFilteringFilter<DataType>();
-    }
-
-    private static <DataType> FilterCriteria<DataType> createAndCompoundDimensionFilterCritera(DataTypes dataType, Map<DimensionIdentifier, Iterable<?>> selection) {
-        DimensionManager<DataType> dimensionManager = DimensionManagerProvider.getDimensionManagerFor(dataType);
-        CompoundFilterCriteria<DataType> compoundCriteria = new AndCompoundFilterCriteria<DataType>();
-
-        for (Entry<DimensionIdentifier, Iterable<?>> entry : selection.entrySet()) {
-            Dimension<DataType, ?> dimension = dimensionManager.getDimensionFor(entry.getKey());
-            if (dimension != null) {
-                FilterCriteria<DataType> criteria = createDimensionFilterCriteria(dimension, entry.getValue());
-                compoundCriteria.addCriteria(criteria);
-            }
-        }
-        return compoundCriteria;
-    }
-    
-    @SuppressWarnings("unchecked")
-    private static <DataType, ValueType> FilterCriteria<DataType> createDimensionFilterCriteria(Dimension<DataType, ValueType> dimension, Iterable<?> values) {
-        return new DimensionValuesFilterCriteria<DataType, ValueType>(dimension, (Collection<ValueType>) values);
-    }
-
-}
@@ -1,49 +0,0 @@
-package com.sap.sailing.datamining.factories;
-
-import java.util.Collection;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.concurrent.ThreadPoolExecutor;
-
-import com.sap.sailing.datamining.dimensions.DimensionManager;
-import com.sap.sailing.datamining.dimensions.DimensionManagerProvider;
-import com.sap.sailing.datamining.shared.DataTypes;
-import com.sap.sailing.datamining.shared.DimensionIdentifier;
-import com.sap.sailing.datamining.shared.QueryDefinitionDeprecated;
-import com.sap.sse.datamining.components.ParallelGrouper;
-import com.sap.sse.datamining.data.deprecated.Dimension;
-import com.sap.sse.datamining.impl.components.deprecated.PartitioningParallelGrouper;
-import com.sap.sse.datamining.impl.workers.builders.MultiDimensionalGroupingWorkerBuilder;
-import com.sap.sse.datamining.workers.GroupingWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;
-
-public final class GrouperFactory {
-    
-    private GrouperFactory() { }
-
-    public static <DataType> ParallelGrouper<DataType> createGrouper(QueryDefinitionDeprecated queryDefinition, ThreadPoolExecutor executor) {
-        WorkerBuilder<GroupingWorker<DataType>> workerBuilder = createGroupingWorkerBuilder(queryDefinition);
-        return new PartitioningParallelGrouper<DataType>(workerBuilder, executor);
-    }
-
-    private static <DataType> WorkerBuilder<GroupingWorker<DataType>> createGroupingWorkerBuilder(QueryDefinitionDeprecated queryDefinition) {
-        switch (queryDefinition.getGrouperType()) {
-        case Dimensions:
-            return createMultiDimensionalGroupingWorkerBuilder(queryDefinition.getDataType(), queryDefinition.getDimensionsToGroupBy());
-        }
-        throw new IllegalArgumentException("Not yet implemented for the given grouper type: "
-                + queryDefinition.getGrouperType().toString());
-    }
-
-    @SuppressWarnings("unchecked")
-    private static <DataType, ValueType> WorkerBuilder<GroupingWorker<DataType>> createMultiDimensionalGroupingWorkerBuilder(DataTypes dataType, List<DimensionIdentifier> dimensionsToGroupBy) {
-        DimensionManager<DataType> dimensionManager = DimensionManagerProvider.getDimensionManagerFor(dataType);
-        Collection<Dimension<DataType, ValueType>> dimensions = new LinkedHashSet<Dimension<DataType, ValueType>>();
-        for (DimensionIdentifier sharedDimension : dimensionsToGroupBy) {
-            Dimension<DataType, ValueType> dimension = (Dimension<DataType, ValueType>) dimensionManager.getDimensionFor(sharedDimension);
-            dimensions.add(dimension);
-        }
-        return new MultiDimensionalGroupingWorkerBuilder<DataType, ValueType>(dimensions);
-    }
-
-}
@@ -1,13 +0,0 @@
-package com.sap.sailing.datamining.impl;
-
-
-import com.sap.sailing.datamining.WindStrengthCluster;
-import com.sap.sse.datamining.impl.data.deprecated.ClusterOfComparableImpl;
-
-public class WindStrengthClusterImpl extends ClusterOfComparableImpl<Double> implements WindStrengthCluster {
-
-    public WindStrengthClusterImpl(String name, Double lowerRangeInBeaufort, Double upperRangeInBeaufort) {
-        super(name, upperRangeInBeaufort, lowerRangeInBeaufort);
-    }
-
-}
@@ -1,82 +0,0 @@
-package com.sap.sailing.datamining.impl.components.deprecated;
-
-import java.util.ArrayList;
-import java.util.Collection;
-
-import com.sap.sailing.datamining.data.HasTrackedLegContext;
-import com.sap.sailing.datamining.data.HasTrackedLegOfCompetitorContext;
-import com.sap.sailing.datamining.impl.data.TrackedLegWithContext;
-import com.sap.sailing.datamining.impl.data.TrackedLegOfCompetitorWithContext;
-import com.sap.sailing.domain.base.Competitor;
-import com.sap.sailing.domain.base.CourseArea;
-import com.sap.sailing.domain.base.Fleet;
-import com.sap.sailing.domain.base.Leg;
-import com.sap.sailing.domain.base.RaceColumn;
-import com.sap.sailing.domain.common.impl.Util.Pair;
-import com.sap.sailing.domain.leaderboard.Leaderboard;
-import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
-import com.sap.sailing.domain.tracking.TrackedLeg;
-import com.sap.sailing.domain.tracking.TrackedLegOfCompetitor;
-import com.sap.sailing.domain.tracking.TrackedRace;
-import com.sap.sse.datamining.impl.workers.retrievers.AbstractRetrievalWorker;
-import com.sap.sse.datamining.workers.DataRetrievalWorker;
-
-public abstract class AbstractLeaderboardGroupDataRetrievalWorker<DataType>
-                      extends AbstractRetrievalWorker<Collection<DataType>> 
-                      implements DataRetrievalWorker<LeaderboardGroup, DataType> {
-
-    private LeaderboardGroup group;
-
-    @Override
-    public void setSource(LeaderboardGroup source) {
-        this.group = source;
-    }
-
-    protected LeaderboardGroup getGroup() {
-        return group;
-    }
-
-    private static Collection<Pair<TrackedLeg, HasTrackedLegContext>> retrieveDataTillTrackedLeg(LeaderboardGroup group) {
-        Collection<Pair<TrackedLeg, HasTrackedLegContext>> data = new ArrayList<Pair<TrackedLeg, HasTrackedLegContext>>();
-        for (Leaderboard leaderboard : group.getLeaderboards()) {
-            CourseArea courseArea = leaderboard.getDefaultCourseArea();
-            for (RaceColumn raceColumn : leaderboard.getRaceColumns()) {
-                for (Fleet fleet : raceColumn.getFleets()) {
-                    TrackedRace trackedRace = raceColumn.getTrackedRace(fleet);
-                    if (trackedRace != null) {
-                        int legNumber = 1;
-                        for (Leg leg : trackedRace.getRace().getCourse().getLegs()) {
-                            TrackedLeg trackedLeg = trackedRace.getTrackedLeg(leg);
-                            if (trackedLeg != null) {
-                                HasTrackedLegContext dataContext = new TrackedLegWithContext(group, leaderboard,
-                                        courseArea, fleet, trackedRace, trackedLeg, legNumber);
-                                data.add(new Pair<TrackedLeg, HasTrackedLegContext>(trackedLeg, dataContext));
-                                legNumber++;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return data;
-    }
-
-    protected static Collection<Pair<TrackedLegOfCompetitor, HasTrackedLegOfCompetitorContext>> retrieveDataTillTrackedLegOfCompetitor(
-            LeaderboardGroup group) {
-        Collection<Pair<TrackedLegOfCompetitor, HasTrackedLegOfCompetitorContext>> data = new ArrayList<Pair<TrackedLegOfCompetitor, HasTrackedLegOfCompetitorContext>>();
-        Collection<Pair<TrackedLeg, HasTrackedLegContext>> baseData = retrieveDataTillTrackedLeg(group);
-        for (Pair<TrackedLeg, HasTrackedLegContext> baseDataEntry : baseData) {
-            TrackedLeg trackedLeg = baseDataEntry.getA();
-            HasTrackedLegContext trackedLegContext = baseDataEntry.getB();
-            for (Competitor competitor : trackedLegContext.getRace().getCompetitors()) {
-                TrackedLegOfCompetitor trackedLegOfCompetitor = trackedLeg.getTrackedLeg(competitor);
-                HasTrackedLegOfCompetitorContext dataContext = new TrackedLegOfCompetitorWithContext(trackedLegContext,
-                        competitor);
-                data.add(new Pair<TrackedLegOfCompetitor, HasTrackedLegOfCompetitorContext>(trackedLegOfCompetitor,
-                        dataContext));
-            }
-        }
-        return data;
-    }
-
-}
@@ -1,48 +0,0 @@
-package com.sap.sailing.datamining.impl.components.deprecated;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-import com.sap.sailing.datamining.data.HasGPSFixContext;
-import com.sap.sailing.datamining.data.GPSFixWithContext;
-import com.sap.sailing.datamining.data.HasTrackedLegOfCompetitorContext;
-import com.sap.sailing.datamining.impl.data.GPSFixWithContext;
-import com.sap.sailing.datamining.impl.gps_fix.GPSFixWithContextImpl;
-import com.sap.sailing.domain.base.Competitor;
-import com.sap.sailing.domain.common.impl.Util.Pair;
-import com.sap.sailing.domain.tracking.GPSFixMoving;
-import com.sap.sailing.domain.tracking.GPSFixTrack;
-import com.sap.sailing.domain.tracking.TrackedLegOfCompetitor;
-
-public class GPSFixLeaderboardGroupDataRetrievalWorker extends AbstractLeaderboardGroupDataRetrievalWorker<GPSFixWithContext> {
-    
-    @Override
-    public Collection<GPSFixWithContext> doWork() {
-        Collection<GPSFixWithContext> data = new ArrayList<GPSFixWithContext>();
-        Collection<Pair<TrackedLegOfCompetitor, HasTrackedLegOfCompetitorContext>> baseData = retrieveDataTillTrackedLegOfCompetitor(getGroup());
-        for (Pair<TrackedLegOfCompetitor, HasTrackedLegOfCompetitorContext> baseDataEntry : baseData) {
-            HasGPSFixContext context = new GPSFixWithContext(baseDataEntry.getB());
-            data.addAll(retrieveDataFor(context));
-        }
-        return data;
-    }
-
-    private Collection<GPSFixWithContext> retrieveDataFor(HasGPSFixContext context) {
-        List<GPSFixWithContext> data = new ArrayList<GPSFixWithContext>();
-        TrackedLegOfCompetitor trackedLegOfCompetitor = context.getTrackedLeg().getTrackedLeg(context.getCompetitor());
-        GPSFixTrack<Competitor, GPSFixMoving> competitorTrack = context.getTrackedRace().getTrack(context.getCompetitor());
-        competitorTrack.lockForRead();
-        try {
-            if (trackedLegOfCompetitor.getStartTime() != null && trackedLegOfCompetitor.getFinishTime() != null) {
-                for (GPSFixMoving gpsFix : competitorTrack.getFixes(trackedLegOfCompetitor.getStartTime(), true, trackedLegOfCompetitor.getFinishTime(), true)) {
-                    data.add(new GPSFixWithContextImpl(gpsFix, context));
-                }
-            }
-        } finally {
-            competitorTrack.unlockAfterRead();
-        }
-        return data;
-    }
-
-}
@@ -1,54 +0,0 @@
-package com.sap.sailing.datamining.impl.components.deprecated;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.concurrent.ThreadPoolExecutor;
-
-import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
-import com.sap.sailing.server.RacingEventService;
-import com.sap.sse.datamining.components.ParallelDataRetriever;
-import com.sap.sse.datamining.impl.components.deprecated.AbstractParallelComponent;
-import com.sap.sse.datamining.workers.DataRetrievalWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;
-
-/**
- * Retrieves elements of type <code>DataType</code> from all {@link LeaderboardGroup}s known to the
- * {@link RacingEventSErvice} passed to this object's constructor. See also
- * {@link RacingEventService#getLeaderboardGroups()}.
- * 
- * @param <DataType>
- */
-public class GroupDividingParallelDataRetriever<DataType> extends AbstractParallelComponent<Void, Collection<DataType>>
-                                                          implements ParallelDataRetriever<DataType> {
-
-    private RacingEventService racingService;
-    private WorkerBuilder<DataRetrievalWorker<LeaderboardGroup, DataType>> workerBuilder;
-
-    public GroupDividingParallelDataRetriever(RacingEventService racingService, WorkerBuilder<DataRetrievalWorker<LeaderboardGroup, DataType>> workerBuilder, ThreadPoolExecutor executor) {
-        super(executor);
-        this.racingService = racingService;
-        this.workerBuilder = workerBuilder;
-    }
-    
-    @Override
-    protected void setUpWorkersFor(Void v) {
-        for (LeaderboardGroup group : racingService.getLeaderboardGroups().values()) {
-            DataRetrievalWorker<LeaderboardGroup, DataType> worker = workerBuilder.build();
-            worker.setReceiver(this);
-            worker.setSource(group);
-            addWorker(worker);
-        }
-    }
-
-    @Override
-    protected Collection<DataType> finalizeData() {
-        Collection<DataType> data = new ArrayList<DataType>();
-        for (Collection<DataType> results : getResults()) {
-            data.addAll(results);
-        }
-        return Collections.unmodifiableCollection(new CopyOnWriteArrayList<DataType>(data));
-    }
-
-}
@@ -1,13 +0,0 @@
-package com.sap.sailing.datamining.impl.components.deprecated;
-
-import com.sap.sailing.domain.base.Moving;
-import com.sap.sse.datamining.impl.workers.extractors.AbstractExtractionWorker;
-
-public class SpeedInKnotsExtractionWorker extends AbstractExtractionWorker<Moving, Double> {
-
-    @Override
-    public Double extract(Moving dataEntry) {
-        return dataEntry.getSpeed().getKnots();
-    }
-
-}
@@ -1,24 +0,0 @@
-package com.sap.sailing.datamining.impl.components.deprecated;
-
-import java.util.ArrayList;
-import java.util.Collection;
-
-import com.sap.sailing.datamining.data.HasTrackedLegOfCompetitorContext;
-import com.sap.sailing.datamining.data.TrackedLegOfCompetitorWithContext;
-import com.sap.sailing.datamining.impl.tracked_leg_of_competitor.TrackedLegOfCompetitorWithContextImpl;
-import com.sap.sailing.domain.common.impl.Util.Pair;
-import com.sap.sailing.domain.tracking.TrackedLegOfCompetitor;
-
-public class TrackedLegOfCompetitorLeaderboardGroupDataRetrievalWorker extends AbstractLeaderboardGroupDataRetrievalWorker<TrackedLegOfCompetitorWithContext> {
-
-    @Override
-    public Collection<TrackedLegOfCompetitorWithContext> doWork() {
-        Collection<TrackedLegOfCompetitorWithContext> data = new ArrayList<TrackedLegOfCompetitorWithContext>();
-        Collection<Pair<TrackedLegOfCompetitor, HasTrackedLegOfCompetitorContext>> baseData = retrieveDataTillTrackedLegOfCompetitor(getGroup());
-        for (Pair<TrackedLegOfCompetitor, HasTrackedLegOfCompetitorContext> baseDataEntry : baseData) {
-            data.add(new TrackedLegOfCompetitorWithContextImpl(baseDataEntry.getA(), baseDataEntry.getB()));
-        }
-        return data;
-    }
-
-}
@@ -1,118 +0,0 @@
-package com.sap.sailing.datamining.impl.gps_fix;
-
-import com.sap.sailing.datamining.Clusters.WindStrength;
-import com.sap.sailing.datamining.WindStrengthCluster;
-import com.sap.sailing.datamining.data.HasGPSFixContext;
-import com.sap.sailing.datamining.data.GPSFixWithContext;
-import com.sap.sailing.domain.common.LegType;
-import com.sap.sailing.domain.common.Position;
-import com.sap.sailing.domain.common.SpeedWithBearing;
-import com.sap.sailing.domain.common.TimePoint;
-import com.sap.sailing.domain.common.impl.DegreePosition;
-import com.sap.sailing.domain.common.impl.KnotSpeedWithBearingImpl;
-import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
-import com.sap.sailing.domain.tracking.GPSFixMoving;
-import com.sap.sailing.domain.tracking.Wind;
-import com.sap.sailing.domain.tracking.impl.GPSFixMovingImpl;
-
-public class GPSFixWithContextImpl extends GPSFixMovingImpl implements GPSFixWithContext {
-    private static final long serialVersionUID = -5551381302809417831L;
-
-    private HasGPSFixContext context;
-    private Wind wind;
-
-    private boolean windHasBeenInitialized;
-
-    public GPSFixWithContextImpl(GPSFixMoving gpsFix, HasGPSFixContext context) {
-        super(copyPosition(gpsFix), copyTimePoint(gpsFix), copySpeed(gpsFix));
-        this.context = context;
-        
-        windHasBeenInitialized= false;
-    }
-
-    private static SpeedWithBearing copySpeed(GPSFixMoving gpsFix) {
-        return new KnotSpeedWithBearingImpl(gpsFix.getSpeed().getKnots(), gpsFix.getSpeed().getBearing());
-    }
-
-    private static TimePoint copyTimePoint(GPSFixMoving gpsFix) {
-        return new MillisecondsTimePoint(gpsFix.getTimePoint().asMillis());
-    }
-
-    private static Position copyPosition(GPSFixMoving gpsFix) {
-        return new DegreePosition(gpsFix.getPosition().getLatDeg(), gpsFix.getPosition().getLngDeg());
-    }
-
-    @Override
-    public String getRegattaName() {
-        return context.getRegatta().getName();
-    }
-
-    @Override
-    public String getRaceName() {
-        return context.getRace().getName();
-    }
-
-    @Override
-    public int getLegNumber() {
-        return context.getLegNumber();
-    }
-
-    @Override
-    public String getCourseAreaName() {
-        return context.getCourseArea().getName();
-    }
-
-    @Override
-    public String getFleetName() {
-        return context.getFleet().getName();
-    }
-
-    @Override
-    public String getBoatClassName() {
-        return context.getBoatClass().getName();
-    }
-
-    @Override
-    public Integer getYear() {
-        return context.getYear();
-    }
-
-    @Override
-    public LegType getLegType() {
-        return context.getLegType();
-    }
-
-    @Override
-    public String getCompetitorName() {
-        return context.getCompetitor().getName();
-    }
-
-    @Override
-    public String getCompetitorSailID() {
-        return context.getCompetitor().getBoat().getSailID();
-    }
-
-    @Override
-    public String getCompetitorNationality() {
-        return context.getCompetitor().getTeam().getNationality().getThreeLetterIOCAcronym();
-    }
-
-    @Override
-    public WindStrengthCluster getWindStrength() {
-        if (getWind() == null) {
-            return null;
-        }
-
-        return WindStrength.getClusterFor(getWind().getBeaufort(), WindStrength.StandardClusters);
-    }
-
-    public Wind getWind() {
-        if (!windHasBeenInitialized) {
-            wind = context.getTrackedRace().getWind(getPosition(), getTimePoint());
-            windHasBeenInitialized = true;
-        }
-        
-        return wind;
-    }
-
-}
@@ -1,15 +0,0 @@
-package com.sap.sailing.datamining.impl.tracked_leg_of_competitor;
-
-import com.sap.sailing.datamining.data.TrackedLegOfCompetitorWithContext;
-import com.sap.sailing.domain.common.Distance;
-import com.sap.sse.datamining.impl.workers.extractors.AbstractExtractionWorker;
-
-public class DistanceTraveledExtractionWorker extends AbstractExtractionWorker<TrackedLegOfCompetitorWithContext, Double> {
-
-    @Override
-    public Double extract(TrackedLegOfCompetitorWithContext dataEntry) {
-        Distance distanceTraveled = dataEntry.getDistanceTraveled();
-        return distanceTraveled != null ? distanceTraveled.getMeters() : 0;
-    }
-
-}
@@ -1,88 +0,0 @@
-package com.sap.sailing.datamining.impl.tracked_leg_of_competitor;
-
-import com.sap.sailing.datamining.WindStrengthCluster;
-import com.sap.sailing.datamining.data.HasTrackedLegOfCompetitorContext;
-import com.sap.sailing.datamining.data.TrackedLegOfCompetitorWithContext;
-import com.sap.sailing.domain.common.Distance;
-import com.sap.sailing.domain.common.LegType;
-import com.sap.sailing.domain.common.TimePoint;
-import com.sap.sailing.domain.tracking.TrackedLegOfCompetitor;
-
-public class TrackedLegOfCompetitorWithContextImpl implements TrackedLegOfCompetitorWithContext {
-
-    private TrackedLegOfCompetitor trackedLegOfCompetitor;
-    private HasTrackedLegOfCompetitorContext context;
-
-    public TrackedLegOfCompetitorWithContextImpl(TrackedLegOfCompetitor trackedLegOfCompetitor, HasTrackedLegOfCompetitorContext context) {
-        this.trackedLegOfCompetitor = trackedLegOfCompetitor;
-        this.context = context;
-    }
-
-    @Override
-    public String getRegattaName() {
-        return context.getRegatta().getName();
-    }
-
-    @Override
-    public String getRaceName() {
-        return context.getRace().getName();
-    }
-
-    @Override
-    public int getLegNumber() {
-        return context.getLegNumber();
-    }
-
-    @Override
-    public String getCourseAreaName() {
-        return context.getCourseArea().getName();
-    }
-
-    @Override
-    public String getFleetName() {
-        return context.getFleet().getName();
-    }
-
-    @Override
-    public String getBoatClassName() {
-        return context.getCompetitor().getBoat().getBoatClass().getName();
-    }
-
-    @Override
-    public Integer getYear() {
-        return context.getYear();
-    }
-
-    @Override
-    public LegType getLegType() {
-        return context.getLegType();
-    }
-
-    @Override
-    public String getCompetitorName() {
-        return context.getCompetitor().getName();
-    }
-
-    @Override
-    public String getCompetitorSailID() {
-        return context.getCompetitor().getBoat().getSailID();
-    }
-
-    @Override
-    public String getCompetitorNationality() {
-        return context.getCompetitor().getTeam().getNationality().getThreeLetterIOCAcronym();
-    }
-
-    @Override
-    public WindStrengthCluster getWindStrength() {
-        // TODO Auto-generated method stub
-        return null;
-    }
-    
-    @Override
-    public Distance getDistanceTraveled() {
-        TimePoint finishTime = trackedLegOfCompetitor.getFinishTime();
-        return finishTime != null ? trackedLegOfCompetitor.getDistanceTraveled(finishTime) : null;
-    }
-
-}
@@ -1,30 +0,0 @@
-package com.sap.sailing.datamining.impl.workers.builders.deprecated;
-
-import com.sap.sailing.datamining.impl.components.deprecated.GPSFixLeaderboardGroupDataRetrievalWorker;
-import com.sap.sailing.datamining.impl.components.deprecated.TrackedLegOfCompetitorLeaderboardGroupDataRetrievalWorker;
-import com.sap.sailing.datamining.shared.DataTypes;
-import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
-import com.sap.sse.datamining.workers.DataRetrievalWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;
-
-public class DataRetrieverWorkerBuilder<DataType> implements WorkerBuilder<DataRetrievalWorker<LeaderboardGroup, DataType>> {
-
-    private final DataTypes dataType;
-
-    public DataRetrieverWorkerBuilder(DataTypes dataType) {
-        this.dataType = dataType;
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public DataRetrievalWorker<LeaderboardGroup, DataType> build() {
-        switch (dataType) {
-        case GPSFix:
-            return (DataRetrievalWorker<LeaderboardGroup, DataType>) new GPSFixLeaderboardGroupDataRetrievalWorker();
-        case TrackedLegOfCompetitor:
-            return (DataRetrievalWorker<LeaderboardGroup, DataType>) new TrackedLegOfCompetitorLeaderboardGroupDataRetrievalWorker();
-        }
-        throw new IllegalArgumentException("Not yet implemented for the given data type: " + dataType.toString());
-    }
-
-}
@@ -1,30 +0,0 @@
-package com.sap.sailing.datamining.impl.workers.builders.deprecated;
-
-import com.sap.sailing.datamining.impl.components.deprecated.SpeedInKnotsExtractionWorker;
-import com.sap.sailing.datamining.impl.tracked_leg_of_competitor.DistanceTraveledExtractionWorker;
-import com.sap.sailing.datamining.shared.StatisticType;
-import com.sap.sse.datamining.workers.ExtractionWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;
-
-public class ExtractionWorkerBuilder<DataType, ExtractedType> implements WorkerBuilder<ExtractionWorker<DataType, ExtractedType>> {
-
-    private StatisticType statisticType;
-
-    public ExtractionWorkerBuilder(StatisticType statisticType) {
-        this.statisticType = statisticType;
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public ExtractionWorker<DataType, ExtractedType> build() {
-        switch (statisticType) {
-        case Speed:
-            return (ExtractionWorker<DataType, ExtractedType>) new SpeedInKnotsExtractionWorker();
-        case Distance:
-            return (ExtractionWorker<DataType, ExtractedType>) new DistanceTraveledExtractionWorker();
-        }
-        throw new IllegalArgumentException("Not yet implemented for the given statistic type: "
-                + statisticType.toString());
-    }
-
-}
@@ -1,16 +0,0 @@
-package com.sap.sse.datamining.shared.annotations;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-@Target(ElementType.TYPE)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface BaseDataType {
-    
-    public String groupKey();
-    
-    public int level();
-
-}
@@ -1,16 +0,0 @@
-package com.sap.sse.datamining.shared.annotations;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-@Target(ElementType.TYPE)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface DataRetriever {
-    
-    public String groupKey();
-    
-    public int level();
-
-}
@@ -11,11 +11,8 @@ import java.util.Collection;
 import org.junit.Test;

 import com.sap.sse.datamining.components.FilterCriteria;
-import com.sap.sse.datamining.data.deprecated.ClusterOfComparable;
 import com.sap.sse.datamining.factories.FunctionFactory;
 import com.sap.sse.datamining.functions.Function;
-import com.sap.sse.datamining.impl.criterias.deprecated.SimpleRangeFilterCriteria;
-import com.sap.sse.datamining.impl.data.deprecated.ClusterOfComparableImpl;
 import com.sap.sse.datamining.test.functions.test_classes.DataTypeWithContext;
 import com.sap.sse.datamining.test.functions.test_classes.DataTypeWithContextImpl;
 import com.sap.sse.datamining.test.util.FunctionTestsUtil;
@@ -44,19 +41,6 @@ public class TestFilterCriterias {
        assertFalse("'Regatta (29ER)' shouldn't be matched", regexFilterCriteria.matches("Regatta (29ER)"));
    }
    
-    @Test
-    public void testRangeFilterCriteria() {
-        ClusterOfComparable<Integer> cluster = new ClusterOfComparableImpl<Integer>("Test", 3, 1);
-        FilterCriteria<Integer> rangeFilterCriteria = new SimpleRangeFilterCriteria<Integer>(cluster);
-
-        assertTrue(rangeFilterCriteria.matches(1));
-        assertTrue(rangeFilterCriteria.matches(2));
-        assertTrue(rangeFilterCriteria.matches(3));
-
-        assertFalse(rangeFilterCriteria.matches(0));
-        assertFalse(rangeFilterCriteria.matches(4));
-    }
-    
    @Test
    public void testCompoundFilterCriterias() {
        StringRegexFilterCriteria startsWithBar = new StringRegexFilterCriteria("Bar.*");
@@ -1,144 +0,0 @@
-package com.sap.sse.datamining.impl.workers;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import org.junit.Test;
-
-import com.sap.sse.datamining.data.deprecated.Dimension;
-import com.sap.sse.datamining.impl.data.deprecated.AbstractDimension;
-import com.sap.sse.datamining.shared.GroupKey;
-import com.sap.sse.datamining.shared.impl.CompoundGroupKey;
-import com.sap.sse.datamining.shared.impl.GenericGroupKey;
-import com.sap.sse.datamining.test.util.OpenDataReceiver;
-import com.sap.sse.datamining.test.util.OpenGrouper;
-import com.sap.sse.datamining.workers.GroupingWorker;
-
-public class TestDimensionGroupers {
-
-    @Test
-    public void testGroupByDimension() {
-        Dimension<Integer, String> crossSum = createCrossSumDimension();
-        GroupingWorker<Integer> groupByDimension = new OpenGrouper<Integer>(Arrays.asList(crossSum));
-        
-        OpenDataReceiver<Map<GroupKey, Collection<Integer>>> receiver = new OpenDataReceiver<>();
-        groupByDimension.setReceiver(receiver);
-        
-        Collection<Integer> data = Arrays.asList(11, 2, 13, 4, 22, 3, 21, 111);
-        groupByDimension.setDataToGroup(data);
-        
-        Map<GroupKey, Collection<Integer>> expectedGroups = new HashMap<GroupKey, Collection<Integer>>();
-        Collection<Integer> group = new ArrayList<Integer>();
-        group.add(11);
-        group.add(2);
-        expectedGroups.put(new GenericGroupKey<String>("2"), group);
-        group = new ArrayList<Integer>();
-        group.add(3);
-        group.add(21);
-        group.add(111);
-        expectedGroups.put(new GenericGroupKey<String>("3"), group);
-        group = new ArrayList<Integer>();
-        group.add(13);
-        group.add(4);
-        group.add(22);
-        expectedGroups.put(new GenericGroupKey<String>("4"), group);
-        
-        groupByDimension.run();
-        assertEquals(expectedGroups, receiver.result);
-    }
-    
-    @Test
-    public void testGroupKeyGeneration() {
-        Dimension<Integer, String> first = new AbstractDimension<Integer, String>("First") {
-            @Override
-            public String getDimensionValueFrom(Integer data) {
-                return "First";
-            }
-        };
-        Dimension<Integer, String> second = new AbstractDimension<Integer, String>("Second") {
-            @Override
-            public String getDimensionValueFrom(Integer data) {
-                return "Second";
-            }
-        };
-        Dimension<Integer, String> third = new AbstractDimension<Integer, String>("Third") {
-            @Override
-            public String getDimensionValueFrom(Integer data) {
-                return "Third";
-            }
-        };
-        
-        OpenGrouper<Integer> grouper = new OpenGrouper<Integer>(Arrays.asList(first, second, third));
-        GroupKey expectedGroupKey = new CompoundGroupKey(new GenericGroupKey<String>("First"), new CompoundGroupKey(new GenericGroupKey<String>("Second"), new GenericGroupKey<String>("Third")));
-        assertEquals(expectedGroupKey, grouper.getGroupKey(1));
-    }
-    
-    @Test
-    public void testGroupByMultipleDimensions() {
-        Dimension<Integer, String> crossSum = createCrossSumDimension();
-        Dimension<Integer, String> signum = createSignumDimension();
-        GroupingWorker<Integer> groupByDimensions = new OpenGrouper<Integer>(Arrays.asList(crossSum, signum));
-        
-        OpenDataReceiver<Map<GroupKey, Collection<Integer>>> receiver = new OpenDataReceiver<>();
-        groupByDimensions.setReceiver(receiver);
-        
-        Collection<Integer> data = Arrays.asList(13, -4, 22, -3, 21, -111);
-        groupByDimensions.setDataToGroup(data);
-
-        Map<GroupKey, Collection<Integer>> expectedGroups = new HashMap<GroupKey, Collection<Integer>>();
-        Collection<Integer> expectedGroup = new ArrayList<Integer>();
-        expectedGroup.add(-3);
-        expectedGroup.add(-111);
-        expectedGroups.put(new CompoundGroupKey(new GenericGroupKey<String>("3"), new GenericGroupKey<String>("-1")), expectedGroup);
-        expectedGroup = new ArrayList<Integer>();
-        expectedGroup.add(13);
-        expectedGroup.add(22);
-        expectedGroups.put(new CompoundGroupKey(new GenericGroupKey<String>("4"), new GenericGroupKey<String>("1")), expectedGroup);
-        expectedGroup = new ArrayList<Integer>();
-        expectedGroup.add(21);
-        expectedGroups.put(new CompoundGroupKey(new GenericGroupKey<String>("3"), new GenericGroupKey<String>("1")), expectedGroup);
-        expectedGroup = new ArrayList<Integer>();
-        expectedGroup.add(-4);
-        expectedGroups.put(new CompoundGroupKey(new GenericGroupKey<String>("4"), new GenericGroupKey<String>("-1")), expectedGroup);
-        
-        groupByDimensions.run();
-        Map<GroupKey, Collection<Integer>> groups = receiver.result;
-        for (Entry<GroupKey, Collection<Integer>> expectedGroupEntry : expectedGroups.entrySet()) {
-            Collection<Integer> group = groups.get(expectedGroupEntry.getKey());
-            assertNotNull("No group for key: " + expectedGroupEntry.getKey().asString(), group);
-            assertEquals(expectedGroupEntry.getValue(), group);
-        }
-    }
-
-    private Dimension<Integer, String> createCrossSumDimension() {
-        return new AbstractDimension<Integer, String>("Cross Sum") {
-            @Override
-            public String getDimensionValueFrom(Integer data) {
-                int crossSum = 0;
-                int value = Math.abs(data);
-                while (value > 0) {
-                    crossSum += value % 10;
-                    value /= 10;
-                }
-                return crossSum + "";
-            }
-        };
-    }
-
-    private AbstractDimension<Integer, String> createSignumDimension() {
-        return new AbstractDimension<Integer, String>("Signum") {
-            @Override
-            public String getDimensionValueFrom(Integer data) {
-                return ((int) Math.signum(data)) + "";
-            }
-        };
-    }
-
-}
@@ -1,39 +0,0 @@
-package com.sap.sse.datamining.impl.workers;
-
-import static org.junit.Assert.assertEquals;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-
-import org.junit.Test;
-
-import com.sap.sse.datamining.shared.GroupKey;
-import com.sap.sse.datamining.shared.impl.GenericGroupKey;
-import com.sap.sse.datamining.test.util.OpenDataReceiver;
-import com.sap.sse.datamining.test.util.StringLengthExtractor;
-import com.sap.sse.datamining.workers.ExtractionWorker;
-
-public class TestExtractors {
-
-    @Test
-    public void testAbstractExtractor() {
-        ExtractionWorker<String, Integer> lengthExtractor = new StringLengthExtractor();
-        OpenDataReceiver<Map<GroupKey, Collection<Integer>>> receiver = new OpenDataReceiver<Map<GroupKey, Collection<Integer>>>();
-        lengthExtractor.setReceiver(receiver);
-        
-        Collection<String> dataEntries = Arrays.asList("Fu", "Bar", "Blub");
-        Map<GroupKey, Collection<String>> data = new HashMap<GroupKey, Collection<String>>();
-        data.put(new GenericGroupKey<Integer>(100), dataEntries);
-        lengthExtractor.setDataToExtractFrom(data);
-        
-
-        Collection<Integer> expectedExtractedDataEntries = Arrays.asList(2, 3, 4);
-        Map<GroupKey, Collection<Integer>> expectedExtractedData = new HashMap<GroupKey, Collection<Integer>>();
-        expectedExtractedData.put(new GenericGroupKey<Integer>(100), expectedExtractedDataEntries);
-        lengthExtractor.run();
-        assertEquals(expectedExtractedData, receiver.result);
-    }
-
-}
@@ -1,37 +0,0 @@
-package com.sap.sse.datamining.impl.workers;
-
-import static org.junit.Assert.assertEquals;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-
-import org.junit.Test;
-
-import com.sap.sse.datamining.components.FilterCriteria;
-import com.sap.sse.datamining.data.deprecated.ClusterOfComparable;
-import com.sap.sse.datamining.impl.criterias.deprecated.SimpleRangeFilterCriteria;
-import com.sap.sse.datamining.impl.data.deprecated.ClusterOfComparableImpl;
-import com.sap.sse.datamining.test.util.OpenDataReceiver;
-import com.sap.sse.datamining.workers.FiltrationWorker;
-
-public class TestFilters {
-
-    @Test
-    public void testFilterByCriteria() {
-        List<Integer> data = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
-        
-        ClusterOfComparable<Integer> cluster = new ClusterOfComparableImpl<Integer>("Test", 5, 1);
-        FilterCriteria<Integer> criteria = new SimpleRangeFilterCriteria<Integer>(cluster);
-        FiltrationWorker<Integer> filter = new CriteriaFiltrationWorker<Integer>(criteria);
-        filter.setDataToFilter(data);
-
-        OpenDataReceiver<Collection<Integer>> receiver = new OpenDataReceiver<>();
-        filter.setReceiver(receiver);
-        
-        filter.run();
-        Collection<Integer> expectedFilteredData = Arrays.asList(1, 2, 3, 4, 5);
-        assertEquals(expectedFilteredData, receiver.result);
-    }
-
-}
@@ -1,65 +0,0 @@
-package com.sap.sse.datamining.impl.workers.aggregators;
-
-import static org.junit.Assert.assertEquals;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-
-import org.junit.Test;
-
-import com.sap.sse.datamining.impl.workers.aggregators.helpers.SimpleIntegerSumAggregationHelper;
-import com.sap.sse.datamining.shared.GroupKey;
-import com.sap.sse.datamining.shared.impl.GenericGroupKey;
-import com.sap.sse.datamining.test.util.OpenDataReceiver;
-import com.sap.sse.datamining.workers.AggregationWorker;
-
-public class TestAggregators {
-
-    @Test
-    public void testSumAggregator() {
-        AggregationWorker<Integer, Integer> sumAggregator = new SumAggregationWorker<Integer, Integer>(new SimpleIntegerSumAggregationHelper());
-        Map<GroupKey, Collection<Integer>> data = asDataToAggregate(1, 7, 6, 3);
-        sumAggregator.setDataToAggregate(data);
-        OpenDataReceiver<Map<GroupKey, Integer>> receiver = new OpenDataReceiver<>();
-        sumAggregator.setReceiver(receiver);
-        
-        sumAggregator.run();
-        Map<GroupKey, Integer> expectedAggregation = asAggregatedData(17);
-        assertEquals(expectedAggregation, receiver.result);
-        
-        data = asDataToAggregate(7);
-        sumAggregator.setDataToAggregate(data);
-        sumAggregator.run();
-        expectedAggregation = asAggregatedData(7);
-        assertEquals(expectedAggregation, receiver.result);
-    }
-    
-    @Test
-    public void testAverageAggregator() {
-        AggregationWorker<Integer, Integer> averageAggregator = new SimpleIntegerArithmeticAverageAggregationWorker();
-        Map<GroupKey, Collection<Integer>> data = asDataToAggregate(1, 7, 6, 3);
-        averageAggregator.setDataToAggregate(data);
-        OpenDataReceiver<Map<GroupKey, Integer>> receiver = new OpenDataReceiver<>();
-        averageAggregator.setReceiver(receiver);
-
-        averageAggregator.run();
-        Map<GroupKey, Integer> expectedAggregation = asAggregatedData(4);
-        assertEquals(expectedAggregation, receiver.result);
-    }
-    
-    private Map<GroupKey, Collection<Integer>> asDataToAggregate(Integer... values) {
-        Collection<Integer> dataEntries = Arrays.asList(values);
-        Map<GroupKey, Collection<Integer>> data = new HashMap<GroupKey, Collection<Integer>>();
-        data.put(new GenericGroupKey<Integer>(100), dataEntries);
-        return data;
-    }
-    
-    private Map<GroupKey, Integer> asAggregatedData(Integer value) {
-        Map<GroupKey,Integer> data = new HashMap<GroupKey, Integer>();
-        data.put(new GenericGroupKey<Integer>(100), value);
-        return data;
-    }
-
-}
@@ -1,14 +0,0 @@
-package com.sap.sse.datamining.test.util;
-
-import com.sap.sse.datamining.workers.WorkReceiver;
-
-public class OpenDataReceiver<ResultType> implements WorkReceiver<ResultType> {
-    
-    public ResultType result;
-
-    @Override
-    public void receiveWork(ResultType result) {
-        this.result = result;
-    }
-    
-}
@@ -1,25 +0,0 @@
-package com.sap.sse.datamining.test.util;
-
-import java.util.Collection;
-
-import com.sap.sse.datamining.data.deprecated.Dimension;
-import com.sap.sse.datamining.impl.workers.MultiDimensionalGroupingWorker;
-import com.sap.sse.datamining.shared.GroupKey;
-import com.sap.sse.datamining.shared.impl.GenericGroupKey;
-
-public class OpenGrouper<DataType> extends MultiDimensionalGroupingWorker<DataType, String> {
-
-    public OpenGrouper(Collection<Dimension<DataType, String>> dimensions) {
-        super(dimensions);
-    }
-
-    @Override
-    protected GroupKey createGroupKeyFor(DataType dataEntry, Dimension<DataType, String> dimension) {
-        return new GenericGroupKey<String>(dimension.getDimensionValueFrom(dataEntry));
-    }
-    
-    public GroupKey getGroupKey(DataType dataEntry) {
-        return getGroupKeyFor(dataEntry);
-    }
-    
-}
@@ -1,12 +0,0 @@
-package com.sap.sse.datamining.test.util;
-
-import com.sap.sse.datamining.impl.workers.extractors.AbstractExtractionWorker;
-
-public class StringLengthExtractor extends AbstractExtractionWorker<String, Integer> {
-
-    @Override
-    public Integer extract(String dataEntry) {
-        return dataEntry.length();
-    }
-
-}
@@ -6,32 +6,20 @@ Bundle-Version: 1.0.0.qualifier
 Bundle-Vendor: SAP
 Bundle-RequiredExecutionEnvironment: JavaSE-1.7
 Import-Package: org.osgi.framework;version="1.7.0"
-Export-Package: com.sap.sse.datamining;uses:="com.sap.sse.datamining.functions,com.sap.sse.datamining.shared",
- com.sap.sse.datamining.components;uses:="com.sap.sse.datamining.shared",
- com.sap.sse.datamining.data.deprecated,
- com.sap.sse.datamining.factories;uses:="com.sap.sse.datamining.impl.functions",
- com.sap.sse.datamining.functions;uses:="com.sap.sse.datamining.shared.dto,com.sap.sse.datamining.i18n,com.sap.sse.datamining.components",
- com.sap.sse.datamining.i18n;uses:="com.sap.sse.datamining.shared",
- com.sap.sse.datamining.impl;
-  uses:="com.sap.sse.datamining,
-   com.sap.sse.datamining.functions,
-   org.osgi.framework,
-   com.sap.sse.datamining.shared,
-   com.sap.sse.datamining.i18n,
-   com.sap.sse.datamining.components",
- com.sap.sse.datamining.impl.components;uses:="com.sap.sse.datamining.workers,com.sap.sse.datamining.shared,com.sap.sse.datamining.components",
- com.sap.sse.datamining.impl.components.deprecated,
- com.sap.sse.datamining.impl.criterias;uses:="com.sap.sse.datamining.data,com.sap.sse.datamining.functions,com.sap.sse.datamining.components",
- com.sap.sse.datamining.impl.criterias.deprecated,
- com.sap.sse.datamining.impl.data.deprecated;uses:="com.sap.sse.datamining.data",
- com.sap.sse.datamining.impl.deprecated,
- com.sap.sse.datamining.impl.i18n;uses:="com.sap.sse.datamining.shared,com.sap.sse.datamining.i18n",
- com.sap.sse.datamining.impl.workers,
- com.sap.sse.datamining.impl.workers.aggregators,
- com.sap.sse.datamining.impl.workers.aggregators.helpers,
- com.sap.sse.datamining.impl.workers.builders;uses:="com.sap.sse.datamining.workers,com.sap.sse.datamining.components",
- com.sap.sse.datamining.impl.workers.extractors,
- com.sap.sse.datamining.impl.workers.retrievers,
- com.sap.sse.datamining.workers
+Export-Package: com.sap.sse.datamining,
+ com.sap.sse.datamining.components,
+ com.sap.sse.datamining.data,
+ com.sap.sse.datamining.factories,
+ com.sap.sse.datamining.functions,
+ com.sap.sse.datamining.i18n,
+ com.sap.sse.datamining.impl,
+ com.sap.sse.datamining.impl.components,
+ com.sap.sse.datamining.impl.components.aggregators,
+ com.sap.sse.datamining.impl.criterias,
+ com.sap.sse.datamining.impl.data,
+ com.sap.sse.datamining.impl.functions,
+ com.sap.sse.datamining.impl.functions.components,
+ com.sap.sse.datamining.impl.functions.criterias,
+ com.sap.sse.datamining.impl.i18n
 Require-Bundle: com.sap.sse.datamining.shared;bundle-version="1.0.0"
 Bundle-Activator: com.sap.sse.datamining.impl.DataMiningActivator
@@ -1,13 +0,0 @@
-package com.sap.sse.datamining.components;
-
-import java.util.Collection;
-import java.util.Map;
-
-import com.sap.sse.datamining.shared.GroupKey;
-
-public interface ParallelAggregator<ExtractedType, AggregatedType> extends ParallelComponent<Map<GroupKey, Collection<ExtractedType>>,
-                                                                                             Map<GroupKey, AggregatedType>> {
-
-    public String getName();
-
-}
@@ -1,11 +0,0 @@
-package com.sap.sse.datamining.components;
-
-import java.util.concurrent.Future;
-
-public interface ParallelComponent<WorkingType, ResultType> extends Future<ResultType> {
-    /**
-     * @return <code>this</code> object
-     */
-    public ParallelComponent<WorkingType, ResultType> start(WorkingType data);
-
-}
@@ -1,8 +0,0 @@
-package com.sap.sse.datamining.components;
-
-import java.util.Collection;
-
-
-public interface ParallelDataRetriever<DataType> extends ParallelComponent<Void, Collection<DataType>> {
-    
-}
@@ -1,18 +0,0 @@
-package com.sap.sse.datamining.components;
-
-import java.util.Collection;
-import java.util.Map;
-
-import com.sap.sse.datamining.shared.GroupKey;
-import com.sap.sse.datamining.shared.Unit;
-
-public interface ParallelExtractor<DataType, ExtractedType> extends ParallelComponent<Map<GroupKey, Collection<DataType>>,
-                                                                                      Map<GroupKey, Collection<ExtractedType>>> {
-
-    public Unit getUnit();
-
-    public int getValueDecimals();
-
-    public String getSignifier();
-
-}
@@ -1,7 +0,0 @@
-package com.sap.sse.datamining.components;
-
-import java.util.Collection;
-
-public interface ParallelFilter<DataType> extends ParallelComponent<Collection<DataType>, Collection<DataType>> {
-    
-}
@@ -1,10 +0,0 @@
-package com.sap.sse.datamining.components;
-
-import java.util.Collection;
-import java.util.Map;
-
-import com.sap.sse.datamining.shared.GroupKey;
-
-public interface ParallelGrouper<DataType> extends ParallelComponent<Collection<DataType>, Map<GroupKey, Collection<DataType>>> {
-
-}
@@ -1,13 +0,0 @@
-package com.sap.sse.datamining.data.deprecated;
-
-import java.util.Comparator;
-
-public interface Cluster<ValueType> {
-    
-    public String getName();
-    public ValueType getUpperRange();
-    public ValueType getLowerRange();
-    
-    public boolean isInRange(ValueType value, Comparator<ValueType> comparator);
-
-}
@@ -1,7 +0,0 @@
-package com.sap.sse.datamining.data.deprecated;
-
-public interface ClusterOfComparable<ValueType extends Comparable<ValueType>> extends Cluster<ValueType> {
-    
-    public boolean isInRange(ValueType value);
-
-}
@@ -1,9 +0,0 @@
-package com.sap.sse.datamining.data.deprecated;
-
-public interface Dimension<DataType, ValueType> {
-    
-    public String getName();
-
-    public ValueType getDimensionValueFrom(DataType dataEntry);
-
-}
@@ -1,26 +0,0 @@
-package com.sap.sse.datamining.factories;
-
-import java.util.Locale;
-import java.util.concurrent.ThreadPoolExecutor;
-
-import com.sap.sse.datamining.components.ParallelAggregator;
-import com.sap.sse.datamining.i18n.DataMiningStringMessages;
-import com.sap.sse.datamining.impl.components.deprecated.GroupDividingParallelAggregator;
-import com.sap.sse.datamining.impl.workers.builders.AggregationWorkerBuilder;
-import com.sap.sse.datamining.shared.components.AggregatorType;
-import com.sap.sse.datamining.shared.components.ElementType;
-import com.sap.sse.datamining.workers.AggregationWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;
-
-public final class AggregatorFactory {
-    
-    private AggregatorFactory() { }
-
-    public static <ExtractedType, AggregatedType> ParallelAggregator<ExtractedType, AggregatedType> createAggregator(DataMiningStringMessages stringMessages,
-                                                                                                                    Locale locale,
-                                                                                                                    ElementType valueType, AggregatorType aggregatorType, ThreadPoolExecutor executor) {
-        WorkerBuilder<AggregationWorker<ExtractedType, AggregatedType>> workerBuilder = new AggregationWorkerBuilder<ExtractedType, AggregatedType>(valueType, aggregatorType);
-        return new GroupDividingParallelAggregator<ExtractedType, AggregatedType>(stringMessages.get(locale, aggregatorType.getNameMessage()), workerBuilder, executor);
-    }
-
-}
@@ -1,103 +0,0 @@
-package com.sap.sse.datamining.impl.components.deprecated;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-import com.sap.sse.datamining.components.ParallelComponent;
-import com.sap.sse.datamining.workers.ComponentWorker;
-import com.sap.sse.datamining.workers.WorkReceiver;
-
-public abstract class AbstractParallelComponent<WorkingType, ResultType> implements ParallelComponent<WorkingType, ResultType>,
-                                                                                    WorkReceiver<ResultType> {
-
-    private ThreadPoolExecutor executor;
-    private Collection<ComponentWorker<ResultType>> workers;
-    private Set<ResultType> results;
-    
-    public AbstractParallelComponent(ThreadPoolExecutor executor) {
-        this.executor = executor;
-        workers = new HashSet<ComponentWorker<ResultType>>();
-        results = Collections.newSetFromMap(new ConcurrentHashMap<ResultType, Boolean>());
-    }
-
-    @Override
-    public ParallelComponent<WorkingType, ResultType> start(WorkingType data) {
-        setUpWorkersFor(data);
-        for (ComponentWorker<ResultType> worker : workers) {
-            executor.execute(worker);
-        }
-        return this;
-    }
-
-    protected abstract void setUpWorkersFor(WorkingType data);
-    
-    @Override
-    public void receiveWork(ResultType result) {
-        results.add(result);
-    }
-    
-    protected Collection<ResultType> getResults() {
-        return results;
-    }
-
-    @Override
-    public ResultType get() throws InterruptedException, ExecutionException {
-        while (!isDone()) {
-            Thread.sleep(100);
-        }
-        return finalizeData();
-    }
-
-    @Override
-    public ResultType get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException,
-            TimeoutException {
-        long timeRun = 0;
-        long timeoutInMillis = unit.toMillis(timeout);
-        while (!isDone() && timeRun < timeoutInMillis) {
-            Thread.sleep(100);
-            timeRun = timeRun + 100;
-        }
-        if (timeRun >= timeoutInMillis) {
-            throw new TimeoutException();
-        }
-        return finalizeData();
-    }
-
-    protected abstract ResultType finalizeData();
-
-    @Override
-    public boolean isDone() {
-        for (ComponentWorker<ResultType> worker : workers) {
-            if (!worker.isDone()) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    protected ThreadPoolExecutor getExecutor() {
-        return executor;
-    }
-
-    protected void addWorker(ComponentWorker<ResultType> worker) {
-        workers.add(worker);
-    }
-
-    @Override
-    public boolean cancel(boolean mayInterruptIfRunning) {
-        return false;
-    }
-
-    @Override
-    public boolean isCancelled() {
-        return false;
-    }
-
-}
@@ -1,56 +0,0 @@
-package com.sap.sse.datamining.impl.components.deprecated;
-
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.concurrent.ThreadPoolExecutor;
-
-import com.sap.sse.datamining.components.ParallelAggregator;
-import com.sap.sse.datamining.shared.GroupKey;
-import com.sap.sse.datamining.workers.AggregationWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;
-
-public class GroupDividingParallelAggregator<ExtractedType, AggregatedType> extends AbstractParallelComponent<Map<GroupKey, Collection<ExtractedType>>,
-                                                                                                              Map<GroupKey, AggregatedType>>
-                                                                            implements ParallelAggregator<ExtractedType, AggregatedType> {
-
-    private String name;
-    
-    private WorkerBuilder<AggregationWorker<ExtractedType, AggregatedType>> workerBuilder;
-
-    public GroupDividingParallelAggregator(String name, WorkerBuilder<AggregationWorker<ExtractedType, AggregatedType>> workerBuilder, ThreadPoolExecutor executor) {
-        super(executor);
-        this.name = name;
-        this.workerBuilder = workerBuilder;
-    }
-
-    @Override
-    public String getName() {
-        return name;
-    }
-
-    @Override
-    protected void setUpWorkersFor(Map<GroupKey, Collection<ExtractedType>> data) {
-        for (Entry<GroupKey, Collection<ExtractedType>> entry : data.entrySet()) {
-            AggregationWorker<ExtractedType, AggregatedType> worker = workerBuilder.build();
-            worker.setReceiver(this);
-            
-            Map<GroupKey, Collection<ExtractedType>> dataToExtractFrom = new HashMap<GroupKey, Collection<ExtractedType>>();
-            dataToExtractFrom.put(entry.getKey(), entry.getValue());
-            worker.setDataToAggregate(dataToExtractFrom);
-            
-            addWorker(worker);
-        }
-    }
-
-    @Override
-    protected Map<GroupKey, AggregatedType> finalizeData() {
-        Map<GroupKey, AggregatedType> data = new HashMap<GroupKey, AggregatedType>();
-        for (Map<GroupKey, AggregatedType> result : getResults()) {
-            data.putAll(result);
-        }
-        return data;
-    }
-
-}
@@ -1,74 +0,0 @@
-package com.sap.sse.datamining.impl.components.deprecated;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ThreadPoolExecutor;
-
-import com.sap.sse.datamining.components.ParallelExtractor;
-import com.sap.sse.datamining.shared.GroupKey;
-import com.sap.sse.datamining.shared.Unit;
-import com.sap.sse.datamining.workers.ExtractionWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;
-
-public class GroupDividingParallelExtractor<DataType, ExtractedType> extends AbstractParallelComponent<Map<GroupKey, Collection<DataType>>,
-                                                                                                       Map<GroupKey, Collection<ExtractedType>>>
-                                                                     implements ParallelExtractor<DataType, ExtractedType> {
-
-    private String signifier;
-    private Unit unit;
-    private int valueDecimals;
-    
-    private WorkerBuilder<ExtractionWorker<DataType, ExtractedType>> workerBuilder;
-
-    public GroupDividingParallelExtractor(String signifier, Unit unit, int valueDecimals,
-                                          WorkerBuilder<ExtractionWorker<DataType, ExtractedType>> workerBuilder, ThreadPoolExecutor executor) {
-        super(executor);
-        this.signifier = signifier;
-        this.unit = unit;
-        this.valueDecimals = valueDecimals;
-        this.workerBuilder = workerBuilder;
-    }
-
-    @Override
-    protected void setUpWorkersFor(Map<GroupKey, Collection<DataType>> data) {
-        for (Entry<GroupKey, Collection<DataType>> entry : data.entrySet()) {
-            ExtractionWorker<DataType, ExtractedType> worker = workerBuilder.build();
-            worker.setReceiver(this);
-            
-            Map<GroupKey, Collection<DataType>> dataToExtractFrom = new HashMap<GroupKey, Collection<DataType>>();
-            dataToExtractFrom.put(entry.getKey(), entry.getValue());
-            worker.setDataToExtractFrom(dataToExtractFrom);
-            
-            addWorker(worker);
-        }
-    }
-
-    @Override
-    protected Map<GroupKey, Collection<ExtractedType>> finalizeData() {
-        Map<GroupKey, Collection<ExtractedType>> data = new HashMap<GroupKey, Collection<ExtractedType>>();
-        for (Map<GroupKey, Collection<ExtractedType>> result : getResults()) {
-            data.putAll(result);
-        }
-        return Collections.unmodifiableMap(new ConcurrentHashMap<GroupKey, Collection<ExtractedType>>(data));
-    }
-
-    @Override
-    public String getSignifier() {
-        return signifier;
-    }
-
-    @Override
-    public Unit getUnit() {
-        return unit;
-    }
-
-    @Override
-    public int getValueDecimals() {
-        return valueDecimals;
-    }
-
-}
@@ -1,60 +0,0 @@
-package com.sap.sse.datamining.impl.components.deprecated;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-import com.sap.sse.datamining.components.ParallelFilter;
-
-public class NonFilteringFilter<DataType> implements ParallelFilter<DataType> {
-
-    private Collection<DataType> data;
-    
-    public NonFilteringFilter() {
-        data = new ArrayList<DataType>();
-    }
-
-    @Override
-    public boolean cancel(boolean mayInterruptIfRunning) {
-        return false;
-    }
-
-    @Override
-    public boolean isCancelled() {
-        return false;
-    }
-
-    @Override
-    public boolean isDone() {
-        return true;
-    }
-
-    @Override
-    public Collection<DataType> get() {
-        return data;
-    }
-
-    @Override
-    public Collection<DataType> get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException,
-            TimeoutException {
-        long timeRun = 0;
-        long timeoutInMillis = unit.toMillis(timeout);
-        while (!isDone() && timeRun < timeoutInMillis) {
-            Thread.sleep(100);
-            timeRun = timeRun + 100;
-        }
-        if (timeRun >= timeoutInMillis) {
-            throw new TimeoutException();
-        }
-        return data;
-    }
-
-    @Override
-    public ParallelFilter<DataType> start(Collection<DataType> data) {
-        this.data = data;
-        return this;
-    }
-
-}
@@ -1,48 +0,0 @@
-package com.sap.sse.datamining.impl.components.deprecated;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.concurrent.ThreadPoolExecutor;
-
-import com.sap.sse.datamining.components.ParallelFilter;
-import com.sap.sse.datamining.workers.FiltrationWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;
-
-public class PartitioningParallelFilter<DataType> extends AbstractParallelComponent<Collection<DataType>, Collection<DataType>>
-                                                  implements ParallelFilter<DataType> {
-
-    private final WorkerBuilder<FiltrationWorker<DataType>> workerBuilder;
-
-    public PartitioningParallelFilter(WorkerBuilder<FiltrationWorker<DataType>> workerBuilder, ThreadPoolExecutor executor) {
-        super(executor);
-        this.workerBuilder = workerBuilder;
-    }
-
-    @Override
-    protected void setUpWorkersFor(Collection<DataType> data) {
-        List<DataType> dataAsList = new ArrayList<DataType>(data);
-        final int workerAmount = (int) (getExecutor().getCorePoolSize() * 0.5);
-        final int partitionSize = (int) Math.ceil((double) dataAsList.size() / workerAmount);
-        for (int i = 0; i < dataAsList.size(); i += partitionSize) {
-            List<DataType> partition = dataAsList.subList(i, i + Math.min(partitionSize, dataAsList.size() - i));
-            
-            FiltrationWorker<DataType> worker = workerBuilder.build();
-            worker.setReceiver(this);
-            worker.setDataToFilter(partition);
-            addWorker(worker);
-        }
-    }
-
-    @Override
-    protected Collection<DataType> finalizeData() {
-        Collection<DataType> data = new ArrayList<DataType>();
-        for (Collection<DataType> results : getResults()) {
-            data.addAll(results);
-        }
-        return Collections.unmodifiableCollection(new CopyOnWriteArrayList<DataType>(data));
-    }
-
-}
@@ -1,51 +0,0 @@
-package com.sap.sse.datamining.impl.components.deprecated;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ThreadPoolExecutor;
-
-import com.sap.sse.datamining.components.ParallelGrouper;
-import com.sap.sse.datamining.shared.GroupKey;
-import com.sap.sse.datamining.workers.GroupingWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;
-
-public class PartitioningParallelGrouper<DataType> extends AbstractParallelComponent<Collection<DataType>, Map<GroupKey, Collection<DataType>>>
-                                                   implements ParallelGrouper<DataType> {
-
-    private WorkerBuilder<GroupingWorker<DataType>> workerBuilder;
-
-    public PartitioningParallelGrouper(WorkerBuilder<GroupingWorker<DataType>> workerBuilder, ThreadPoolExecutor executor) {
-        super(executor);
-        this.workerBuilder = workerBuilder;
-    }
-
-    @Override
-    protected void setUpWorkersFor(Collection<DataType> data) {
-        List<DataType> dataAsList = new ArrayList<DataType>(data);
-        final int workerAmount = (int) (getExecutor().getCorePoolSize() * 0.5);
-        final int partitionSize = (int) Math.ceil((double) dataAsList.size() / workerAmount);
-        for (int i = 0; i < dataAsList.size(); i += partitionSize) {
-            List<DataType> partition = dataAsList.subList(i, i + Math.min(partitionSize, dataAsList.size() - i));
-            
-            GroupingWorker<DataType> worker = workerBuilder.build();
-            worker.setReceiver(this);
-            worker.setDataToGroup(partition);
-            addWorker(worker);
-        }
-    }
-
-    @Override
-    protected Map<GroupKey, Collection<DataType>> finalizeData() {
-        Map<GroupKey, Collection<DataType>> data = new HashMap<GroupKey, Collection<DataType>>();
-        for (Map<GroupKey, Collection<DataType>> result : getResults()) {
-            data.putAll(result);
-        }
-        return Collections.unmodifiableMap(new ConcurrentHashMap<GroupKey, Collection<DataType>>(data));
-    }
-
-}
@@ -1,20 +0,0 @@
-package com.sap.sse.datamining.impl.criterias.deprecated;
-
-import com.sap.sse.datamining.data.deprecated.Dimension;
-import com.sap.sse.datamining.impl.criterias.RegexFilterCriteria;
-
-public class DimensionRegexFilterCriteria<DataType> extends RegexFilterCriteria<DataType> {
-    
-    private Dimension<DataType, String> dimension;
-
-    public DimensionRegexFilterCriteria(String regex, Dimension<DataType, String> dimension) {
-        super(regex);
-        this.dimension = dimension;
-    }
-
-    @Override
-    protected String getValueToMatch(DataType data) {
-        return dimension.getDimensionValueFrom(data);
-    }
-
-}
@@ -1,34 +0,0 @@
-package com.sap.sse.datamining.impl.criterias.deprecated;
-
-import java.util.Collection;
-import java.util.HashSet;
-
-import com.sap.sse.datamining.components.FilterCriteria;
-import com.sap.sse.datamining.data.deprecated.Dimension;
-
-public class DimensionValuesFilterCriteria<DataType, ValueType> implements FilterCriteria<DataType> {
-    
-    private Dimension<DataType, ValueType> dimension;
-    private Collection<ValueType> values;
-
-    public DimensionValuesFilterCriteria(Dimension<DataType, ValueType> dimension, Collection<ValueType> values) {
-        this.dimension = dimension;
-        this.values = new HashSet<ValueType>(values);
-    }
-
-    @Override
-    public boolean matches(DataType data) {
-        ValueType dataValue = dimension.getDimensionValueFrom(data);
-        if (dataValue == null) {
-            return false;
-        }
-        
-        for (ValueType value : values) {
-            if (value.equals(dataValue)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-}
@@ -1,25 +0,0 @@
-package com.sap.sse.datamining.impl.criterias.deprecated;
-
-import com.sap.sse.datamining.components.FilterCriteria;
-import com.sap.sse.datamining.data.deprecated.ClusterOfComparable;
-
-public abstract class RangeFilterCriteria<DataType, ValueType extends Comparable<ValueType>> implements FilterCriteria<DataType> {
-    
-    private ClusterOfComparable<ValueType> cluster;
-
-    public RangeFilterCriteria(ClusterOfComparable<ValueType> cluster) {
-        this.cluster = cluster;
-    }
-
-    @Override
-    public boolean matches(DataType data) {
-        return isInRange(data);
-    }
-
-    protected boolean isInRange(DataType data) {
-        return cluster.isInRange(getValue(data));
-    }
-
-    public abstract ValueType getValue(DataType data);
-
-}
@@ -1,16 +0,0 @@
-package com.sap.sse.datamining.impl.criterias.deprecated;
-
-import com.sap.sse.datamining.data.deprecated.ClusterOfComparable;
-
-public class SimpleRangeFilterCriteria<DataType extends Comparable<DataType>> extends RangeFilterCriteria<DataType, DataType> {
-
-    public SimpleRangeFilterCriteria(ClusterOfComparable<DataType> cluster) {
-        super(cluster);
-    }
-
-    @Override
-    public DataType getValue(DataType data) {
-        return data;
-    }
-
-}
@@ -1,48 +0,0 @@
-package com.sap.sse.datamining.impl.data.deprecated;
-
-import com.sap.sse.datamining.data.deprecated.Dimension;
-
-public abstract class AbstractDimension<DataType, ValueType> implements Dimension<DataType, ValueType> {
-
-    private String name;
-    
-    public AbstractDimension(String name) {
-        this.name = name;
-    }
-    
-    @Override
-    public String getName() {
-        return name;
-    }
-
-    @Override
-    public String toString() {
-        return getName();
-    }
-
-    @Override
-    public int hashCode() {
-        final int prime = 31;
-        int result = 1;
-        result = prime * result + ((name == null) ? 0 : name.hashCode());
-        return result;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (this == obj)
-            return true;
-        if (obj == null)
-            return false;
-        if (getClass() != obj.getClass())
-            return false;
-        AbstractDimension<?, ?> other = (AbstractDimension<?, ?>) obj;
-        if (name == null) {
-            if (other.name != null)
-                return false;
-        } else if (!name.equals(other.name))
-            return false;
-        return true;
-    }
-
-}
@@ -1,39 +0,0 @@
-package com.sap.sse.datamining.impl.data.deprecated;
-
-import java.util.Comparator;
-
-import com.sap.sse.datamining.data.deprecated.Cluster;
-
-public class ClusterImpl<ValueType> implements Cluster<ValueType> {
-
-    private String name;
-    private ValueType upperRange;
-    private ValueType lowerRange;
-
-    public ClusterImpl(String name, ValueType upperRange, ValueType lowerRange) {
-        this.name = name;
-        this.upperRange = upperRange;
-        this.lowerRange = lowerRange;
-    }
-
-    @Override
-    public String getName() {
-        return name;
-    }
-
-    @Override
-    public ValueType getUpperRange() {
-        return upperRange;
-    }
-
-    @Override
-    public ValueType getLowerRange() {
-        return lowerRange;
-    }
-
-    @Override
-    public boolean isInRange(ValueType value, Comparator<ValueType> comparator) {
-        return comparator.compare(value, getLowerRange()) >= 0 && comparator.compare(value, getUpperRange()) <= 0;
-    }
-
-}
@@ -1,17 +0,0 @@
-package com.sap.sse.datamining.impl.data.deprecated;
-
-import com.sap.sse.datamining.data.deprecated.ClusterOfComparable;
-
-public class ClusterOfComparableImpl<ValueType extends Comparable<ValueType>> extends ClusterImpl<ValueType> implements
-        ClusterOfComparable<ValueType> {
-
-    public ClusterOfComparableImpl(String name, ValueType upperRange, ValueType lowerRange) {
-        super(name, upperRange, lowerRange);
-    }
-
-    @Override
-    public boolean isInRange(ValueType value) {
-        return value != null && value.compareTo(getLowerRange()) >= 0 && value.compareTo(getUpperRange()) <= 0;
-    }
-
-}
@@ -1,74 +0,0 @@
-package com.sap.sse.datamining.impl.deprecated;
-
-import java.util.Collection;
-import java.util.Locale;
-import java.util.Map;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-import com.sap.sse.datamining.Query;
-import com.sap.sse.datamining.components.ParallelAggregator;
-import com.sap.sse.datamining.components.ParallelDataRetriever;
-import com.sap.sse.datamining.components.ParallelExtractor;
-import com.sap.sse.datamining.components.ParallelFilter;
-import com.sap.sse.datamining.components.ParallelGrouper;
-import com.sap.sse.datamining.i18n.DataMiningStringMessages;
-import com.sap.sse.datamining.shared.AdditionalResultData;
-import com.sap.sse.datamining.shared.GroupKey;
-import com.sap.sse.datamining.shared.Message;
-import com.sap.sse.datamining.shared.QueryResult;
-import com.sap.sse.datamining.shared.impl.AdditionalResultDataImpl;
-import com.sap.sse.datamining.shared.impl.QueryResultImpl;
-
-public class QueryImpl<DataType, ExtractedType, AggregatedType> implements Query<AggregatedType> {
-
-    private DataMiningStringMessages stringMessages;
-    private Locale locale;
-
-    private ParallelDataRetriever<DataType> retriever;
-    private ParallelFilter<DataType> filter;
-    private ParallelGrouper<DataType> grouper;
-
-    private ParallelExtractor<DataType, ExtractedType> extractor;
-    private ParallelAggregator<ExtractedType, AggregatedType> aggregator;
-    
-    public QueryImpl(DataMiningStringMessages stringMessages, Locale locale, ParallelDataRetriever<DataType> retriever, ParallelFilter<DataType> filter,
-                     ParallelGrouper<DataType> grouper, ParallelExtractor<DataType, ExtractedType> extractor, ParallelAggregator<ExtractedType, AggregatedType> aggregator) {
-        this.stringMessages = stringMessages;
-        this.locale = locale;
-        this.retriever = retriever;
-        this.filter = filter;
-        this.grouper = grouper;
-        this.extractor = extractor;
-        this.aggregator = aggregator;
-    }
-
-    @Override
-    public QueryResult<AggregatedType> run() throws InterruptedException, ExecutionException {
-        final long startTime = System.nanoTime();
-        Collection<DataType> retrievedData = retriever.start(null).get();
-        Collection<DataType> filteredData = filter.start(retrievedData).get();
-        Map<GroupKey, Collection<DataType>> groupedData = grouper.start(filteredData).get();
-        Map<GroupKey, Collection<ExtractedType>> extractedData = extractor.start(groupedData).get();
-        Map<GroupKey, AggregatedType> aggregatedData = aggregator.start(extractedData).get();
-        final long endTime = System.nanoTime();
-
-        long calculationTimeInNanos = endTime - startTime;
-        AdditionalResultData additionalData = new AdditionalResultDataImpl(retrievedData.size(), filteredData.size(),
-                createResultSignifier(), extractor.getUnit(), extractor.getValueDecimals(), calculationTimeInNanos);
-        QueryResult<AggregatedType> result = new QueryResultImpl<AggregatedType>(aggregatedData, additionalData);
-        
-        return result;
-    }
-    
-    @Override
-    public QueryResult<AggregatedType> run(long timeout, TimeUnit unit) throws TimeoutException {
-        throw new UnsupportedOperationException("This query implementation is deprecated.");
-    }
-
-    private String createResultSignifier() {
-        return stringMessages.get(locale, Message.ResultSignifier, extractor.getSignifier(), aggregator.getName());
-    }
-
-}
@@ -1,33 +0,0 @@
-package com.sap.sse.datamining.impl.workers;
-
-import com.sap.sse.datamining.workers.ComponentWorker;
-import com.sap.sse.datamining.workers.WorkReceiver;
-
-public abstract class AbstractComponentWorker<ResultType> implements ComponentWorker<ResultType> {
-
-    private WorkReceiver<ResultType> receiver;
-    private boolean done;
-
-    @Override
-    public void run() {
-        receiver.receiveWork(doWork());
-        done = true;
-    }
-
-    protected abstract ResultType doWork();
-
-    @Override
-    public void setReceiver(WorkReceiver<ResultType> receiver) {
-        this.receiver = receiver;
-    }
-
-    @Override
-    public boolean isDone() {
-        return done;
-    }
-
-    protected WorkReceiver<ResultType> getReceiver() {
-        return receiver;
-    }
-
-}
@@ -1,31 +0,0 @@
-package com.sap.sse.datamining.impl.workers;
-
-import java.util.ArrayList;
-import java.util.Collection;
-
-import com.sap.sse.datamining.workers.FiltrationWorker;
-
-public abstract class AbstractFiltrationWorker<DataType> extends AbstractComponentWorker<Collection<DataType>>
-                                                         implements FiltrationWorker<DataType> {
-
-    private Collection<DataType> data;
-
-    @Override
-    protected Collection<DataType> doWork() {
-        Collection<DataType> filteredData = new ArrayList<DataType>();
-        for (DataType dataEntry : data) {
-            if (matches(dataEntry)) {
-                filteredData.add(dataEntry);
-            }
-        }
-        return filteredData;
-    }
-
-    protected abstract boolean matches(DataType dataEntry);
-
-    @Override
-    public void setDataToFilter(Collection<DataType> data) {
-        this.data = data;
-    }
-
-}
@@ -1,38 +0,0 @@
-package com.sap.sse.datamining.impl.workers;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-
-import com.sap.sse.datamining.shared.GroupKey;
-import com.sap.sse.datamining.workers.GroupingWorker;
-
-public abstract class AbstractGroupingWorker<DataType> extends AbstractComponentWorker<Map<GroupKey, Collection<DataType>>>
-                                                       implements GroupingWorker<DataType> {
-
-    private Collection<DataType> data;
-
-    @Override
-    public void setDataToGroup(Collection<DataType> data) {
-        this.data = data;
-    }
-    
-    @Override
-    protected Map<GroupKey, Collection<DataType>> doWork() {
-        Map<GroupKey, Collection<DataType>> groupedData = new HashMap<GroupKey, Collection<DataType>>();
-        for (DataType dataEntry : data) {
-            GroupKey key = getGroupKeyFor(dataEntry);
-            if (key != null) {
-                if (!groupedData.containsKey(key)) {
-                    groupedData.put(key, new ArrayList<DataType>());
-                }
-                groupedData.get(key).add(dataEntry);
-            }
-        }
-        return groupedData;
-    }
-
-    protected abstract GroupKey getGroupKeyFor(DataType dataEntry);
-
-}
@@ -1,18 +0,0 @@
-package com.sap.sse.datamining.impl.workers;
-
-import com.sap.sse.datamining.components.FilterCriteria;
-
-public class CriteriaFiltrationWorker<DataType> extends AbstractFiltrationWorker<DataType> {
-    
-    private FilterCriteria<DataType> criteria;
-
-    public CriteriaFiltrationWorker(FilterCriteria<DataType> criteria) {
-        this.criteria = criteria;
-    }
-
-    @Override
-    protected boolean matches(DataType dataEntry) {
-        return criteria.matches(dataEntry);
-    }
-
-}
@@ -1,38 +0,0 @@
-package com.sap.sse.datamining.impl.workers;
-
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.LinkedHashSet;
-
-import com.sap.sse.datamining.data.deprecated.Dimension;
-import com.sap.sse.datamining.shared.GroupKey;
-import com.sap.sse.datamining.shared.impl.CompoundGroupKey;
-import com.sap.sse.datamining.shared.impl.GenericGroupKey;
-
-public class MultiDimensionalGroupingWorker<DataType, ValueType> extends AbstractGroupingWorker<DataType> {
-    
-    private Collection<Dimension<DataType, ValueType>> dimensions;
-
-    public MultiDimensionalGroupingWorker(Collection<Dimension<DataType, ValueType>> dimensions) {
-        this.dimensions = new LinkedHashSet<Dimension<DataType, ValueType>>(dimensions);
-    }
-
-    @Override
-    protected GroupKey getGroupKeyFor(DataType dataEntry) {
-        return createCompoundGroupKey(dataEntry, dimensions.iterator());
-    }
-
-    private GroupKey createCompoundGroupKey(DataType dataEntry, Iterator<Dimension<DataType, ValueType>> iterator) {
-        Dimension<DataType, ValueType> mainDimension = iterator.next();
-        if (iterator.hasNext()) {
-            return new CompoundGroupKey(createGroupKeyFor(dataEntry, mainDimension), createCompoundGroupKey(dataEntry, iterator));
-        } else {
-            return createGroupKeyFor(dataEntry, mainDimension);
-        }
-    }
-
-    protected GroupKey createGroupKeyFor(DataType dataEntry, Dimension<DataType, ValueType> dimension){
-        return new GenericGroupKey<ValueType>(dimension.getDimensionValueFrom(dataEntry));
-    };
-
-}
@@ -1,38 +0,0 @@
-package com.sap.sse.datamining.impl.workers.aggregators;
-
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import com.sap.sse.datamining.impl.workers.AbstractComponentWorker;
-import com.sap.sse.datamining.shared.GroupKey;
-import com.sap.sse.datamining.workers.AggregationWorker;
-
-public abstract class AbstractAggregationWorker<ExtractedType, AggregatedType> extends AbstractComponentWorker<Map<GroupKey, AggregatedType>>
-                                                                               implements AggregationWorker<ExtractedType, AggregatedType> {
-
-    private Map<GroupKey, Collection<ExtractedType>> data;
-    
-    @Override
-    protected Map<GroupKey, AggregatedType> doWork() {
-        Map<GroupKey, AggregatedType> aggregatedData = new HashMap<GroupKey, AggregatedType>();
-        for (Entry<GroupKey, Collection<ExtractedType>> dataEntry : getData().entrySet()) {
-            AggregatedType aggregation = aggregate(dataEntry.getValue());
-            aggregatedData.put(dataEntry.getKey(), aggregation);
-        }
-        return aggregatedData;
-    }
-
-    protected abstract AggregatedType aggregate(Collection<ExtractedType> value);
-
-    @Override
-    public void setDataToAggregate(Map<GroupKey, Collection<ExtractedType>> data) {
-        this.data = data;
-    }
-    
-    public Map<GroupKey, Collection<ExtractedType>> getData() {
-        return data;
-    }
-    
-}
@@ -1,23 +0,0 @@
-package com.sap.sse.datamining.impl.workers.aggregators;
-
-import java.util.Collection;
-
-import com.sap.sse.datamining.impl.workers.aggregators.helpers.SumAggregationHelper;
-
-public abstract class ArithmeticAverageAggregationWorker<ExtractedType, AggregatedType> 
-					  extends AbstractAggregationWorker<ExtractedType, AggregatedType>  {
-    
-    private SumAggregationHelper<ExtractedType, AggregatedType> sumAggregator;
-
-    public ArithmeticAverageAggregationWorker(SumAggregationHelper<ExtractedType, AggregatedType> sumAggregator) {
-        this.sumAggregator = sumAggregator;
-    }
-    
-    @Override
-    protected AggregatedType aggregate(Collection<ExtractedType> data) {
-        return divide(sumAggregator.aggregate(data), data.size());
-    }
-
-    protected abstract AggregatedType divide(AggregatedType sum, int dataAmount);
-
-}
@@ -1,33 +0,0 @@
-package com.sap.sse.datamining.impl.workers.aggregators;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-
-public abstract class MedianAggregationWorker<ExtractedType extends Comparable<? super ExtractedType>, AggregatedType>
-                      extends AbstractAggregationWorker<ExtractedType, AggregatedType> {
-
-    @Override
-    protected AggregatedType aggregate(Collection<ExtractedType> data) {
-        List<ExtractedType> dataAsList = new ArrayList<ExtractedType>(data);
-        Collections.sort(dataAsList);
-        
-        if (lengthIsEven(dataAsList)) {
-            AggregatedType value1 = getAggregatedValueFor(dataAsList.get((dataAsList.size() - 1) / 2));
-            AggregatedType value2 = getAggregatedValueFor(dataAsList.get(((dataAsList.size() - 1) / 2) + 1));
-            return divideByTwo(add(value1, value2));
-        } else {
-            return getAggregatedValueFor(dataAsList.get((dataAsList.size()) / 2));
-        }
-    }
-
-    private boolean lengthIsEven(Collection<ExtractedType> data) {
-        return data.size() % 2 == 0;
-    }
-
-    protected abstract AggregatedType getAggregatedValueFor(ExtractedType extractedType);
-    protected abstract AggregatedType add(AggregatedType value1, AggregatedType value2);
-    protected abstract AggregatedType divideByTwo(AggregatedType value);
-
-}
@@ -1,11 +0,0 @@
-package com.sap.sse.datamining.impl.workers.aggregators;
-
-import com.sap.sse.datamining.impl.workers.aggregators.helpers.SumAggregationHelper;
-
-public abstract class SimpleArithmeticAverageAggregationWorker<T> extends ArithmeticAverageAggregationWorker<T, T> {
-
-    public SimpleArithmeticAverageAggregationWorker(SumAggregationHelper<T, T> sumAggregator) {
-        super(sumAggregator);
-    }
-
-}
@@ -1,17 +0,0 @@
-package com.sap.sse.datamining.impl.workers.aggregators;
-
-import com.sap.sse.datamining.impl.workers.aggregators.helpers.SimpleDoubleSumAggregationHelper;
-import com.sap.sse.datamining.impl.workers.aggregators.helpers.SumAggregationHelper;
-
-public class SimpleDoubleArithmeticAverageAggregationWorker extends SimpleArithmeticAverageAggregationWorker<Double> {
-
-    public SimpleDoubleArithmeticAverageAggregationWorker() {
-        super((SumAggregationHelper<Double, Double>) new SimpleDoubleSumAggregationHelper());
-    }
-
-    @Override
-    protected Double divide(Double sum, int dataAmount) {
-        return sum / dataAmount;
-    }
-
-}
@@ -1,15 +0,0 @@
-package com.sap.sse.datamining.impl.workers.aggregators;
-
-public class SimpleDoubleMedianAggregationWorker extends SimpleMedianAggregationWorker<Double> {
-
-    @Override
-    protected Double add(Double value1, Double value2) {
-        return value1 + value2;
-    }
-
-    @Override
-    protected Double divideByTwo(Double value) {
-        return value / 2.0;
-    }
-
-}
@@ -1,17 +0,0 @@
-package com.sap.sse.datamining.impl.workers.aggregators;
-
-import com.sap.sse.datamining.impl.workers.aggregators.helpers.SimpleIntegerSumAggregationHelper;
-import com.sap.sse.datamining.impl.workers.aggregators.helpers.SumAggregationHelper;
-
-public class SimpleIntegerArithmeticAverageAggregationWorker extends SimpleArithmeticAverageAggregationWorker<Integer> {
-
-    public SimpleIntegerArithmeticAverageAggregationWorker() {
-        super((SumAggregationHelper<Integer, Integer>) new SimpleIntegerSumAggregationHelper());
-    }
-
-    @Override
-    protected Integer divide(Integer sum, int dataAmount) {
-        return sum / dataAmount;
-    }
-
-}
@@ -1,16 +0,0 @@
-package com.sap.sse.datamining.impl.workers.aggregators;
-
-
-public class SimpleIntegerMedianAggregationWorker extends SimpleMedianAggregationWorker<Integer> {
-
-    @Override
-    protected Integer add(Integer value1, Integer value2) {
-        return value1 + value2;
-    }
-
-    @Override
-    protected Integer divideByTwo(Integer value) {
-        return value / 2;
-    }
-
-}
@@ -1,11 +0,0 @@
-package com.sap.sse.datamining.impl.workers.aggregators;
-
-public abstract class SimpleMedianAggregationWorker<T extends Comparable<? super T>>
-					  extends MedianAggregationWorker<T, T> {
-
-    @Override
-    protected T getAggregatedValueFor(T extractedType) {
-        return extractedType;
-    }
-
-}
@@ -1,21 +0,0 @@
-package com.sap.sse.datamining.impl.workers.aggregators;
-
-import java.util.Collection;
-
-import com.sap.sse.datamining.impl.workers.aggregators.helpers.SumAggregationHelper;
-
-public class SumAggregationWorker<ExtractedType, AggregatedType>
-			 extends AbstractAggregationWorker<ExtractedType, AggregatedType> {
-    
-    private SumAggregationHelper<ExtractedType, AggregatedType> aggregator;
-    
-    public SumAggregationWorker(SumAggregationHelper<ExtractedType, AggregatedType> aggregator) {
-        this.aggregator = aggregator;
-    }
-
-    @Override
-    protected AggregatedType aggregate(Collection<ExtractedType> data) {
-        return aggregator.aggregate(data);
-    }
-
-}
@@ -1,11 +0,0 @@
-package com.sap.sse.datamining.impl.workers.aggregators.helpers;
-
-
-public class SimpleDoubleSumAggregationHelper extends SimpleSumAggregationHelper<Double> {
-
-    @Override
-    protected Double add(Double value1, Double value2) {
-        return value1 + value2;
-    }
-
-}
@@ -1,11 +0,0 @@
-package com.sap.sse.datamining.impl.workers.aggregators.helpers;
-
-
-public class SimpleIntegerSumAggregationHelper extends SimpleSumAggregationHelper<Integer> {
-
-    @Override
-    protected Integer add(Integer value1, Integer value2) {
-        return value1 + value2;
-    }
-
-}
@@ -1,11 +0,0 @@
-package com.sap.sse.datamining.impl.workers.aggregators.helpers;
-
-
-public abstract class SimpleSumAggregationHelper<T> extends SumAggregationHelper<T, T> {
-
-    @Override
-    protected T getValueFor(T extractedValue) {
-        return extractedValue;
-    }
-
-}
@@ -1,21 +0,0 @@
-package com.sap.sse.datamining.impl.workers.aggregators.helpers;
-
-import java.util.Collection;
-import java.util.Iterator;
-
-public abstract class SumAggregationHelper<ExtractedType, AggregatedType> {
-
-    public AggregatedType aggregate(Collection<ExtractedType> data) {
-        Iterator<ExtractedType> dataIterator = data.iterator();
-        AggregatedType sum = dataIterator.hasNext() ? getValueFor(dataIterator.next()) : null;
-
-        while (dataIterator.hasNext()) {
-            sum = add(sum, getValueFor(dataIterator.next()));
-        }
-        return sum;
-    }
-
-    protected abstract AggregatedType add(AggregatedType value1, AggregatedType value2);
-    protected abstract AggregatedType getValueFor(ExtractedType extractedValue);
-
-}
@@ -1,64 +0,0 @@
-package com.sap.sse.datamining.impl.workers.builders;
-
-import com.sap.sse.datamining.impl.workers.aggregators.SimpleDoubleArithmeticAverageAggregationWorker;
-import com.sap.sse.datamining.impl.workers.aggregators.SimpleDoubleMedianAggregationWorker;
-import com.sap.sse.datamining.impl.workers.aggregators.SimpleIntegerArithmeticAverageAggregationWorker;
-import com.sap.sse.datamining.impl.workers.aggregators.SimpleIntegerMedianAggregationWorker;
-import com.sap.sse.datamining.impl.workers.aggregators.SumAggregationWorker;
-import com.sap.sse.datamining.impl.workers.aggregators.helpers.SimpleDoubleSumAggregationHelper;
-import com.sap.sse.datamining.impl.workers.aggregators.helpers.SimpleIntegerSumAggregationHelper;
-import com.sap.sse.datamining.shared.components.AggregatorType;
-import com.sap.sse.datamining.shared.components.ElementType;
-import com.sap.sse.datamining.workers.AggregationWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;
-
-public class AggregationWorkerBuilder<ExtractedType, AggregatedType> implements WorkerBuilder<AggregationWorker<ExtractedType, AggregatedType>> {
-
-    private ElementType valueType;
-    private AggregatorType aggregatorType;
-
-    public AggregationWorkerBuilder(ElementType valueType, AggregatorType aggregatorType) {
-        this.valueType = valueType;
-        this.aggregatorType = aggregatorType;
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public AggregationWorker<ExtractedType, AggregatedType> build() {
-        switch (valueType) {
-        case Double:
-            return (AggregationWorker<ExtractedType, AggregatedType>) createDoubleAggregationWorker(aggregatorType);
-        case Integer:
-            return (AggregationWorker<ExtractedType, AggregatedType>) createIntegerAggregationWorker(aggregatorType);
-        }
-        throw new IllegalArgumentException("Not yet implemented for the given statistics value type: "
-                + valueType.toString());
-    }
-    
-    public static AggregationWorker<Integer, Integer> createIntegerAggregationWorker(AggregatorType aggregatorType) {
-        switch (aggregatorType) {
-        case Average:
-            return new SimpleIntegerArithmeticAverageAggregationWorker();
-        case Sum:
-            return new SumAggregationWorker<Integer, Integer>(new SimpleIntegerSumAggregationHelper());
-        case Median:
-            return new SimpleIntegerMedianAggregationWorker();
-        }
-        throw new IllegalArgumentException("Not yet implemented for the given aggregator type: "
-                + aggregatorType.toString());
-    }
-    
-    public static AggregationWorker<Double, Double> createDoubleAggregationWorker(AggregatorType aggregatorType) {
-        switch (aggregatorType) {
-        case Average:
-            return new SimpleDoubleArithmeticAverageAggregationWorker();
-        case Sum:
-            return new SumAggregationWorker<Double, Double>(new SimpleDoubleSumAggregationHelper());
-        case Median:
-            return new SimpleDoubleMedianAggregationWorker();
-        }
-        throw new IllegalArgumentException("Not yet implemented for the given aggregator type: "
-                + aggregatorType.toString());
-    }
-
-}
@@ -1,21 +0,0 @@
-package com.sap.sse.datamining.impl.workers.builders;
-
-import com.sap.sse.datamining.components.FilterCriteria;
-import com.sap.sse.datamining.impl.workers.CriteriaFiltrationWorker;
-import com.sap.sse.datamining.workers.FiltrationWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;
-
-public class FilterByCriteriaBuilder<DataType> implements WorkerBuilder<FiltrationWorker<DataType>> {
-
-    private FilterCriteria<DataType> criteria;
-
-    public FilterByCriteriaBuilder(FilterCriteria<DataType> criteria) {
-        this.criteria = criteria;
-    }
-
-    @Override
-    public FiltrationWorker<DataType> build() {
-        return new CriteriaFiltrationWorker<DataType>(criteria);
-    }
-
-}
@@ -1,23 +0,0 @@
-package com.sap.sse.datamining.impl.workers.builders;
-
-import java.util.Collection;
-
-import com.sap.sse.datamining.data.deprecated.Dimension;
-import com.sap.sse.datamining.impl.workers.MultiDimensionalGroupingWorker;
-import com.sap.sse.datamining.workers.GroupingWorker;
-import com.sap.sse.datamining.workers.WorkerBuilder;
-
-public class MultiDimensionalGroupingWorkerBuilder<DataType, ValueType> implements WorkerBuilder<GroupingWorker<DataType>> {
-
-    private Collection<Dimension<DataType, ValueType>> dimensions;
-
-    public MultiDimensionalGroupingWorkerBuilder(Collection<Dimension<DataType, ValueType>> dimensions) {
-        this.dimensions = dimensions;
-    }
-
-    @Override
-    public GroupingWorker<DataType> build() {
-        return new MultiDimensionalGroupingWorker<DataType, ValueType>(dimensions);
-    }
-
-}
@@ -1,44 +0,0 @@
-package com.sap.sse.datamining.impl.workers.extractors;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import com.sap.sse.datamining.impl.workers.AbstractComponentWorker;
-import com.sap.sse.datamining.shared.GroupKey;
-import com.sap.sse.datamining.workers.ExtractionWorker;
-
-public abstract class AbstractExtractionWorker<DataType, ExtractedType> extends AbstractComponentWorker<Map<GroupKey, Collection<ExtractedType>>>
-                                                                        implements ExtractionWorker<DataType, ExtractedType> {
-
-    private Map<GroupKey, Collection<DataType>> data;
-
-    @Override
-    public void setDataToExtractFrom(Map<GroupKey, Collection<DataType>> data) {
-        this.data = data;
-    }
-
-    @Override
-    protected Map<GroupKey, Collection<ExtractedType>> doWork() {
-        Map<GroupKey, Collection<ExtractedType>> extractedData = new HashMap<GroupKey, Collection<ExtractedType>>();
-        for (Entry<GroupKey, Collection<DataType>> dataEntry : data.entrySet()) {
-            GroupKey key = dataEntry.getKey();
-            if (!extractedData.containsKey(key)) {
-                extractedData.put(key, new ArrayList<ExtractedType>());
-            };
-            
-            for (DataType dateElement : dataEntry.getValue()) {
-                ExtractedType extractedDataElement = extract(dateElement);
-                if (extractedDataElement != null) {
-                    extractedData.get(key).add(extractedDataElement);
-                }
-            }
-        }
-        return extractedData;
-    }
-
-    protected abstract ExtractedType extract(DataType dataEntry);
-
-}
@@ -1,9 +0,0 @@
-package com.sap.sse.datamining.impl.workers.retrievers;
-
-import com.sap.sse.datamining.impl.workers.AbstractComponentWorker;
-
-//Empty class to decouple the specific domain bundles from the domain independent sse bundle
-public abstract class AbstractRetrievalWorker<ResultType>
-					  extends AbstractComponentWorker<ResultType> {
-
-}
@@ -1,12 +0,0 @@
-package com.sap.sse.datamining.workers;
-
-import java.util.Collection;
-import java.util.Map;
-
-import com.sap.sse.datamining.shared.GroupKey;
-
-public interface AggregationWorker<ExtractedType, AggregatedType> extends ComponentWorker<Map<GroupKey, AggregatedType>> {
-    
-    public void setDataToAggregate(Map<GroupKey, Collection<ExtractedType>> data);
-
-}
@@ -1,9 +0,0 @@
-package com.sap.sse.datamining.workers;
-
-public interface ComponentWorker<ResultType> extends Runnable {
-
-    public void setReceiver(WorkReceiver<ResultType> receiver);
-
-    public boolean isDone();
-
-}
@@ -1,9 +0,0 @@
-package com.sap.sse.datamining.workers;
-
-import java.util.Collection;
-
-public interface DataRetrievalWorker<SourceType, DataType> extends ComponentWorker<Collection<DataType>> {
-
-    public void setSource(SourceType source);
-
-}
@@ -1,12 +0,0 @@
-package com.sap.sse.datamining.workers;
-
-import java.util.Collection;
-import java.util.Map;
-
-import com.sap.sse.datamining.shared.GroupKey;
-
-public interface ExtractionWorker<DataType, ExtractedType> extends ComponentWorker<Map<GroupKey, Collection<ExtractedType>>> {
-
-    public void setDataToExtractFrom(Map<GroupKey, Collection<DataType>> data);
-
-}
@@ -1,9 +0,0 @@
-package com.sap.sse.datamining.workers;
-
-import java.util.Collection;
-
-public interface FiltrationWorker<DataType> extends ComponentWorker<Collection<DataType>> {
-    
-    public void setDataToFilter(Collection<DataType> data);
-
-}
@@ -1,12 +0,0 @@
-package com.sap.sse.datamining.workers;
-
-import java.util.Collection;
-import java.util.Map;
-
-import com.sap.sse.datamining.shared.GroupKey;
-
-public interface GroupingWorker<DataType> extends ComponentWorker<Map<GroupKey, Collection<DataType>>> {
-
-    public void setDataToGroup(Collection<DataType> data);
-    
-}
@@ -1,7 +0,0 @@
-package com.sap.sse.datamining.workers;
-
-public interface WorkReceiver<ResultType> {
-    
-    public void receiveWork(ResultType result);
-
-}
@@ -1,8 +0,0 @@
-package com.sap.sse.datamining.workers;
-
-
-public interface WorkerBuilder<WorkerType> {
-
-    public WorkerType build();
-
-}