eclipse-sailing-analytics/sailing-analytics
1
0 Fork 0
mirror of https://github.com/eclipse-sailing-analytics/sailing-analytics.git synced 2026-10-24 04:53:54 +00:00
Code Activity

Radically cleaned the server side data mining projects

Browse Source
This commit is contained in:
Lennart Hensler committed 2014-06-05 11:33:07 +02:00
1 parent c9fae07ada
commit 225cacad6e
92 files changed
+18 -2962
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

java/com.sap.sse.datamining/META-INF/MANIFEST.MF
+15 -27
View File
@@ -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
java/com.sap.sse.datamining/src/com/sap/sse/datamining/components/ParallelAggregator.java
-13
View File
@@ -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();
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/components/ParallelComponent.java
-11
View File
@@ -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);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/components/ParallelDataRetriever.java
-8
View File
@@ -1,8 +0,0 @@
package com.sap.sse.datamining.components;
import java.util.Collection;
public interface ParallelDataRetriever<DataType> extends ParallelComponent<Void, Collection<DataType>> {
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/components/ParallelExtractor.java
-18
View File
@@ -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();
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/components/ParallelFilter.java
-7
View File
@@ -1,7 +0,0 @@
package com.sap.sse.datamining.components;
import java.util.Collection;
public interface ParallelFilter<DataType> extends ParallelComponent<Collection<DataType>, Collection<DataType>> {
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/components/ParallelGrouper.java
-10
View File
@@ -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>>> {
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/data/deprecated/Cluster.java
-13
View File
@@ -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);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/data/deprecated/ClusterOfComparable.java
-7
View File
@@ -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);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/data/deprecated/Dimension.java
-9
View File
@@ -1,9 +0,0 @@
package com.sap.sse.datamining.data.deprecated;
public interface Dimension<DataType, ValueType> {
public String getName();
public ValueType getDimensionValueFrom(DataType dataEntry);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/factories/AggregatorFactory.java
-26
View File
@@ -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);
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/components/deprecated/AbstractParallelComponent.java
-103
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/components/deprecated/GroupDividingParallelAggregator.java
-56
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/components/deprecated/GroupDividingParallelExtractor.java
-74
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/components/deprecated/NonFilteringFilter.java
-60
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/components/deprecated/PartitioningParallelFilter.java
-48
View File
@@ -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));
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/components/deprecated/PartitioningParallelGrouper.java
-51
View File
@@ -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));
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/criterias/deprecated/DimensionRegexFilterCriteria.java
-20
View File
@@ -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);
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/criterias/deprecated/DimensionValuesFilterCriteria.java
-34
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/criterias/deprecated/RangeFilterCriteria.java
-25
View File
@@ -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);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/criterias/deprecated/SimpleRangeFilterCriteria.java
-16
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/data/deprecated/AbstractDimension.java
-48
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/data/deprecated/ClusterImpl.java
-39
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/data/deprecated/ClusterOfComparableImpl.java
-17
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/deprecated/QueryImpl.java
-74
View File
@@ -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());
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/AbstractComponentWorker.java
-33
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/AbstractFiltrationWorker.java
-31
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/AbstractGroupingWorker.java
-38
View File
@@ -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);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/CriteriaFiltrationWorker.java
-18
View File
@@ -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);
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/MultiDimensionalGroupingWorker.java
-38
View File
@@ -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));
};
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/aggregators/AbstractAggregationWorker.java
-38
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/aggregators/ArithmeticAverageAggregationWorker.java
-23
View File
@@ -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);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/aggregators/MedianAggregationWorker.java
-33
View File
@@ -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);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/aggregators/SimpleArithmeticAverageAggregationWorker.java
-11
View File
@@ -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);
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/aggregators/SimpleDoubleArithmeticAverageAggregationWorker.java
-17
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/aggregators/SimpleDoubleMedianAggregationWorker.java
-15
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/aggregators/SimpleIntegerArithmeticAverageAggregationWorker.java
-17
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/aggregators/SimpleIntegerMedianAggregationWorker.java
-16
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/aggregators/SimpleMedianAggregationWorker.java
-11
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/aggregators/SumAggregationWorker.java
-21
View File
@@ -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);
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/aggregators/helpers/SimpleDoubleSumAggregationHelper.java
-11
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/aggregators/helpers/SimpleIntegerSumAggregationHelper.java
-11
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/aggregators/helpers/SimpleSumAggregationHelper.java
-11
View File
@@ -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;
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/aggregators/helpers/SumAggregationHelper.java
-21
View File
@@ -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);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/builders/AggregationWorkerBuilder.java
-64
View File
@@ -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());
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/builders/FilterByCriteriaBuilder.java
-21
View File
@@ -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);
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/builders/MultiDimensionalGroupingWorkerBuilder.java
-23
View File
@@ -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);
}
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/extractors/AbstractExtractionWorker.java
-44
View File
@@ -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);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/workers/retrievers/AbstractRetrievalWorker.java
-9
View File
@@ -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> {
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/workers/AggregationWorker.java
-12
View File
@@ -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);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/workers/ComponentWorker.java
-9
View File
@@ -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();
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/workers/DataRetrievalWorker.java
-9
View File
@@ -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);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/workers/ExtractionWorker.java
-12
View File
@@ -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);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/workers/FiltrationWorker.java
-9
View File
@@ -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);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/workers/GroupingWorker.java
-12
View File
@@ -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);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/workers/WorkReceiver.java
-7
View File
@@ -1,7 +0,0 @@
package com.sap.sse.datamining.workers;
public interface WorkReceiver<ResultType> {
public void receiveWork(ResultType result);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/workers/WorkerBuilder.java
-8
View File
@@ -1,8 +0,0 @@
package com.sap.sse.datamining.workers;
public interface WorkerBuilder<WorkerType> {
public WorkerType build();
}