Moved all singletons to the DataMiningActivator

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/factories/DataMiningFactory.java

@@ -3,7 +3,6 @@ package com.sap.sailing.datamining.factories;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;
-import java.util.concurrent.ThreadPoolExecutor;
 
 import com.google.gwt.i18n.client.LocaleInfo;
 import com.sap.sailing.datamining.shared.QueryDefinition;
@@ -15,38 +14,44 @@ 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.factories.AggregatorFactory;
-import com.sap.sse.datamining.i18n.DataMiningStringMessages;
 import com.sap.sse.datamining.impl.DataMiningActivator;
 import com.sap.sse.datamining.impl.deprecated.QueryImpl;
 import com.sap.sse.datamining.workers.FiltrationWorker;
 import com.sap.sse.datamining.workers.WorkerBuilder;
 
 public final class DataMiningFactory {
-    
-    private static final DataMiningStringMessages stringMessages = DataMiningStringMessages.Util.getDefaultStringMessages();
-    
+
     private static final String DEFAULT_LOCALE_NAME = "default";
-    private static final Map<String, Locale> supportedLocalesMappedByLocaleInfo = new HashMap<>(); {
+    private static final Map<String, Locale> supportedLocalesMappedByLocaleInfo = new HashMap<>();
+    {
         supportedLocalesMappedByLocaleInfo.put(DEFAULT_LOCALE_NAME, Locale.ENGLISH);
         supportedLocalesMappedByLocaleInfo.put("en", Locale.ENGLISH);
         supportedLocalesMappedByLocaleInfo.put("de", Locale.GERMAN);
     }
-    
-    private DataMiningFactory() { }
 
-    public static <DataType, AggregatedType extends Number> Query<AggregatedType> createQuery(QueryDefinition queryDefinition, RacingEventService racingService) {
+    private DataMiningFactory() {
+    }
+
+    public static <DataType, AggregatedType extends Number> Query<AggregatedType> createQuery(
+            QueryDefinition queryDefinition, RacingEventService racingService) {
         Locale locale = getLocaleFrom(queryDefinition.getLocaleInfo());
-        
-        ParallelDataRetriever<DataType> retriever = DataRetrieverFactory.createDataRetriever(queryDefinition.getDataType(), racingService, getExecutor());
-        
+
+        ParallelDataRetriever<DataType> retriever = DataRetrieverFactory.createDataRetriever(
+                queryDefinition.getDataType(), racingService, DataMiningActivator.getExecutor());
+
         ParallelFilter<DataType> filter = createFilter(queryDefinition);
-        
-        ParallelGrouper<DataType> grouper = GrouperFactory.createGrouper(queryDefinition, getExecutor());
-        ParallelExtractor<DataType, AggregatedType> extractor = ExtractorFactory.createExtractor(stringMessages, locale, queryDefinition.getStatisticType(), getExecutor());
-        ParallelAggregator<AggregatedType, AggregatedType> aggregator = AggregatorFactory.createAggregator(stringMessages, locale, queryDefinition.getStatisticType().getValueType(),
-                                                                                                           queryDefinition.getAggregatorType(), getExecutor());
-        
-        return new QueryImpl<DataType, AggregatedType, AggregatedType>(stringMessages, locale, retriever, filter, grouper, extractor, aggregator);
+
+        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 Locale getLocaleFrom(LocaleInfo localeInfo) {
@@ -58,13 +63,10 @@ public final class DataMiningFactory {
         if (queryDefinition.getSelection().isEmpty()) {
             return FilterFactory.createNonFilteringFilter();
         }
-        
-        WorkerBuilder<FiltrationWorker<DataType>> workerBuilder = FilterFactory.createDimensionFilterBuilder(queryDefinition.getDataType(), queryDefinition.getSelection());
-        return FilterFactory.createParallelFilter(workerBuilder, getExecutor());
-    }
-    
-    public static ThreadPoolExecutor getExecutor() {
-        return DataMiningActivator.getExecutor();
+
+        WorkerBuilder<FiltrationWorker<DataType>> workerBuilder = FilterFactory.createDimensionFilterBuilder(
+                queryDefinition.getDataType(), queryDefinition.getSelection());
+        return FilterFactory.createParallelFilter(workerBuilder, DataMiningActivator.getExecutor());
     }
 
 }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/server/DataMiningServiceImpl.java

@@ -14,6 +14,7 @@ import com.sap.sailing.datamining.shared.DataTypes;
 import com.sap.sailing.datamining.shared.QueryDefinition;
 import com.sap.sailing.gwt.ui.client.DataMiningService;
 import com.sap.sailing.server.RacingEventService;
+import com.sap.sse.datamining.DataMiningServer;
 import com.sap.sse.datamining.Query;
 import com.sap.sse.datamining.functions.Function;
 import com.sap.sse.datamining.shared.DataMiningSerializationDummy;
@@ -25,26 +26,26 @@ public class DataMiningServiceImpl extends RemoteServiceServlet implements DataM
 
     private final BundleContext context;
 
-    private final ServiceTracker<com.sap.sse.datamining.DataMiningService, com.sap.sse.datamining.DataMiningService> dataMiningServiceTracker;
+    private final ServiceTracker<DataMiningServer, DataMiningServer> dataMiningServerTracker;
     private final ServiceTracker<RacingEventService, RacingEventService> racingEventServiceTracker;
     
     public DataMiningServiceImpl() {
         context = Activator.getDefault();
-        dataMiningServiceTracker = createAndOpenDataMiningServiceTracker(context);
+        dataMiningServerTracker = createAndOpenDataMiningServerTracker(context);
         racingEventServiceTracker = createAndOpenRacingEventServiceTracker(context);
     }
 
-    private ServiceTracker<com.sap.sse.datamining.DataMiningService, com.sap.sse.datamining.DataMiningService> createAndOpenDataMiningServiceTracker(
+    private ServiceTracker<DataMiningServer, DataMiningServer> createAndOpenDataMiningServerTracker(
             BundleContext context) {
-        ServiceTracker<com.sap.sse.datamining.DataMiningService, com.sap.sse.datamining.DataMiningService> result = 
-                new ServiceTracker<com.sap.sse.datamining.DataMiningService, com.sap.sse.datamining.DataMiningService>(
-                context, com.sap.sse.datamining.DataMiningService.class.getName(), null);
+        ServiceTracker<com.sap.sse.datamining.DataMiningServer, com.sap.sse.datamining.DataMiningServer> result = 
+                new ServiceTracker<com.sap.sse.datamining.DataMiningServer, com.sap.sse.datamining.DataMiningServer>(
+                context, com.sap.sse.datamining.DataMiningServer.class.getName(), null);
         result.open();
         return result;
     }
     
-    private com.sap.sse.datamining.DataMiningService getService() {
-        return dataMiningServiceTracker.getService();
+    private com.sap.sse.datamining.DataMiningServer getDataMiningServer() {
+        return dataMiningServerTracker.getService();
     }
 
     private ServiceTracker<RacingEventService, RacingEventService> createAndOpenRacingEventServiceTracker(BundleContext context) {
@@ -61,7 +62,7 @@ public class DataMiningServiceImpl extends RemoteServiceServlet implements DataM
     @Override
     public Collection<FunctionDTO> getDimensionsFor(DataTypes dataType) {
         Class<?> dataTypeBaseClass = getBaseClassFor(dataType);
-        Collection<Function<?>> dimensions = getService().getFunctionProvider().getDimensionsFor(dataTypeBaseClass);
+        Collection<Function<?>> dimensions = getDataMiningServer().getFunctionProvider().getDimensionsFor(dataTypeBaseClass);
         return functionsAsFunctionDTOs(dimensions);
     }
     

java/com.sap.sse.datamining/src/com/sap/sse/datamining/DataMiningServer.java

@@ -0,0 +1,12 @@
+package com.sap.sse.datamining;
+
+import com.sap.sse.datamining.functions.FunctionProvider;
+import com.sap.sse.datamining.functions.FunctionRegistry;
+
+public interface DataMiningServer {
+
+    public FunctionRegistry getFunctionRegistry();
+
+    public FunctionProvider getFunctionProvider();
+
+}

java/com.sap.sse.datamining/src/com/sap/sse/datamining/DataMiningService.java

@@ -1,28 +0,0 @@
-package com.sap.sse.datamining;
-
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-
-import com.sap.sse.datamining.functions.FunctionProvider;
-import com.sap.sse.datamining.functions.FunctionRegistry;
-
-public interface DataMiningService {
-
-    public FunctionRegistry getFunctionRegistry();
-
-    public FunctionProvider getFunctionProvider();
-    
-    public static final class Util {
-
-        private static final int THREAD_POOL_SIZE = Math.max(Runtime.getRuntime().availableProcessors(), 3);
-        private static final ThreadPoolExecutor executor = new ThreadPoolExecutor(THREAD_POOL_SIZE, THREAD_POOL_SIZE, 60,
-                TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
-
-        public static ThreadPoolExecutor getExecutor() {
-            return executor;
-        }
-        
-    }
-
-}

java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/DataMiningActivator.java

@@ -1,7 +1,9 @@
 package com.sap.sse.datamining.impl;
 
 import java.util.Collection;
+import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -10,11 +12,12 @@ import org.osgi.framework.BundleContext;
 import org.osgi.framework.InvalidSyntaxException;
 import org.osgi.framework.ServiceReference;
 
-import com.sap.sse.datamining.DataMiningService;
+import com.sap.sse.datamining.DataMiningServer;
 import com.sap.sse.datamining.functions.ClassesWithFunctionsService;
 import com.sap.sse.datamining.functions.FunctionProvider;
 import com.sap.sse.datamining.functions.FunctionRegistry;
 import com.sap.sse.datamining.functions.ParallelFunctionRetriever;
+import com.sap.sse.datamining.i18n.DataMiningStringMessages;
 import com.sap.sse.datamining.impl.functions.PartitionParallelExternalFunctionRetriever;
 import com.sap.sse.datamining.impl.functions.PartitioningParallelMarkedFunctionRetriever;
 import com.sap.sse.datamining.impl.functions.RegistryFunctionsProvider;
@@ -23,24 +26,31 @@ import com.sap.sse.datamining.impl.functions.SimpleFunctionRegistry;
 public class DataMiningActivator implements BundleActivator {
 
     private static final Logger LOGGER = Logger.getLogger(DataMiningActivator.class.getName());
+    private static final int THREAD_POOL_SIZE = Math.max(Runtime.getRuntime().availableProcessors(), 3);
 
     private static BundleContext context;
     
-    private static DataMiningService dataMiningService;
+    private static DataMiningServer dataMiningServer;
+    private static DataMiningStringMessages stringMessages;
+    private static ThreadPoolExecutor executor;
 
     @Override
     public void start(BundleContext context) throws Exception {
         DataMiningActivator.context = context;
+        
+        stringMessages = DataMiningStringMessages.Util.getDefaultStringMessages();
+        executor = new ThreadPoolExecutor(THREAD_POOL_SIZE, THREAD_POOL_SIZE, 60, TimeUnit.SECONDS,
+                                          new LinkedBlockingQueue<Runnable>());
 
         FunctionRegistry functionRegistry = createAndBuildFunctionRegistry();
         FunctionProvider functionProvider = new RegistryFunctionsProvider(functionRegistry, getExecutor());
         
-        dataMiningService = new DataMiningServiceImpl(functionRegistry, functionProvider);
-        registerDataMiningService();
+        dataMiningServer = new DataMiningServerImpl(functionRegistry, functionProvider);
+        registerDataMiningServer();
     }
 
-    private void registerDataMiningService() {
-        context.registerService(DataMiningService.class, dataMiningService, null);
+    private void registerDataMiningServer() {
+        context.registerService(DataMiningServer.class, dataMiningServer, null);
     }
 
     private FunctionRegistry createAndBuildFunctionRegistry() {
@@ -109,11 +119,11 @@ public class DataMiningActivator implements BundleActivator {
     }
 
     public static ThreadPoolExecutor getExecutor() {
-        return DataMiningService.Util.getExecutor();
+        return executor;
     }
-
-    public static FunctionProvider getFunctionProvider() {
-        return dataMiningService.getFunctionProvider();
+    
+    public static DataMiningStringMessages getStringMessages() {
+        return stringMessages;
     }
 
 }

java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/DataMiningServerImpl.java

@@ -1,15 +1,15 @@
 package com.sap.sse.datamining.impl;
 
-import com.sap.sse.datamining.DataMiningService;
+import com.sap.sse.datamining.DataMiningServer;
 import com.sap.sse.datamining.functions.FunctionProvider;
 import com.sap.sse.datamining.functions.FunctionRegistry;
 
-public class DataMiningServiceImpl implements DataMiningService {
+public class DataMiningServerImpl implements DataMiningServer {
 
     private FunctionRegistry functionRegistry;
     private FunctionProvider functionProvider;
 
-    public DataMiningServiceImpl(FunctionRegistry functionRegistry, FunctionProvider functionProvider) {
+    public DataMiningServerImpl(FunctionRegistry functionRegistry, FunctionProvider functionProvider) {
         this.functionRegistry = functionRegistry;
         this.functionProvider = functionProvider;
     }