Skip to content

Add option to sort triples numerically. #409

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Oct 15, 2021
Merged

Add option to sort triples numerically. #409

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
867bc96
Add test cases for TripleSort.
blackwinter Oct 14, 2021
5a0d393
Add option to sort triples numerically.
blackwinter Oct 14, 2021
26aeeaf
Improve description
dr0i Oct 15, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
7 changes: 7 additions & 0 deletions metafacture-triples/build.gradle
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,3 +24,10 @@ dependencies {
testImplementation 'junit:junit:4.12'
testImplementation 'org.mockito:mockito-core:2.5.5'
}

test {
testLogging {
showStandardStreams = true
exceptionFormat = 'full'
}
}
93 changes: 40 additions & 53 deletions metafacture-triples/src/main/java/org/metafacture/triples/AbstractTripleSort.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -30,12 +30,14 @@
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;
import java.util.function.Function;

/**
* @author markus geipel
*
*/
public abstract class AbstractTripleSort extends DefaultObjectPipe<Triple, ObjectReceiver<Triple>> implements MemoryWarningSystem.Listener {

/**
* specifies the comparator
*/
Expand Down Expand Up @@ -63,17 +65,16 @@ public int order(final int indicator) {
public abstract int order(int indicator);
}

private final List<Triple> buffer = new ArrayList<Triple>();
private final List<Triple> buffer = new ArrayList<>();
private final List<File> tempFiles;
private Compare compare = Compare.SUBJECT;
private Order order = Order.INCREASING;
private boolean numeric;
private volatile boolean memoryLow;

public AbstractTripleSort() {
MemoryWarningSystem.addListener(this);
tempFiles = new ArrayList<File>(); // Initialized here to let the
// compiler enforce the call to
// super() in subclasses.
tempFiles = new ArrayList<>(); // Initialized here to let the compiler enforce the call to super() in subclasses.
}

@Override
Expand All @@ -93,6 +94,10 @@ protected final void setSortOrder(final Order newOrder) {
order = newOrder;
}

protected final void setSortNumeric(final boolean newNumeric) {
numeric = newNumeric;
}

@Override
public final void process(final Triple namedValue) {
if (memoryLow) {
Expand All @@ -112,47 +117,38 @@ public final void process(final Triple namedValue) {
}

private void nextBatch() throws IOException {
Collections.sort(buffer, createComparator(compare, order));
Collections.sort(buffer, createComparator());
final File tempFile = File.createTempFile("sort", "namedValues", null);
tempFile.deleteOnExit();
final ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(tempFile));

try {
try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(tempFile))) {
for (final Triple triple : buffer) {
triple.write(out);
}
}
finally {
out.close();
}

buffer.clear();
tempFiles.add(tempFile);
}

@Override
public final void onCloseStream() {

if (tempFiles.isEmpty()) {
Collections.sort(buffer, createComparator(compare, order));
Collections.sort(buffer, createComparator());

for (final Triple triple : buffer) {
sortedTriple(triple);
}

onFinished();
}
else {
final Comparator<Triple> comparator = createComparator(compare, order);
final PriorityQueue<SortedTripleFileFacade> queue = new PriorityQueue<SortedTripleFileFacade>(11,
new Comparator<SortedTripleFileFacade>() {
// private final Comparator<Triple> comparator =
// getComparator();

@Override
public int compare(final SortedTripleFileFacade o1, final SortedTripleFileFacade o2) {
return comparator.compare(o1.peek(), o2.peek());
}
});
final Comparator<Triple> comparator = createComparator();
final PriorityQueue<SortedTripleFileFacade> queue = new PriorityQueue<>(11, (o1, o2) -> comparator.compare(o1.peek(), o2.peek()));

try {
nextBatch();

for (final File file : tempFiles) {
queue.add(new SortedTripleFileFacade(file));
}
Expand All @@ -168,6 +164,7 @@ public int compare(final SortedTripleFileFacade o1, final SortedTripleFileFacade
queue.add(sortedFileFacade);
}
}

onFinished();
}
catch (final IOException e) {
Expand All @@ -179,6 +176,7 @@ public int compare(final SortedTripleFileFacade o1, final SortedTripleFileFacade
}
}
}

MemoryWarningSystem.removeListener(this);
}

Expand All @@ -189,58 +187,47 @@ protected void onFinished() {
protected abstract void sortedTriple(Triple namedValue);

public final Comparator<Triple> createComparator() {
return createComparator(compare, order);
return createComparator(compare, order, numeric);
}

public static Comparator<Triple> createComparator(final Compare compare, final Order order) {
return createComparator(compare, order, false);
}

public static Comparator<Triple> createComparator(final Compare compareBy, final Order order) {
final Comparator<Triple> comparator;
switch (compareBy) {
private static Comparator<Triple> createComparator(final Compare compare, final Order order, final boolean numeric) {
final Function<Triple, String> tripleFunction;
switch (compare) {
case ALL:
comparator = new Comparator<Triple>() {
@Override
public int compare(final Triple o1, final Triple o2) {
return order.order(o1.compareTo(o2));
}
};
break;
return (o1, o2) -> order.order(o1.compareTo(o2));
case OBJECT:
comparator = new Comparator<Triple>() {
@Override
public int compare(final Triple o1, final Triple o2) {
return order.order(o1.getObject().compareTo(o2.getObject()));
}
};
tripleFunction = Triple::getObject;
break;
case SUBJECT:
comparator = new Comparator<Triple>() {
@Override
public int compare(final Triple o1, final Triple o2) {
return order.order(o1.getSubject().compareTo(o2.getSubject()));
}
};
tripleFunction = Triple::getSubject;
break;
case PREDICATE:
default:
comparator = new Comparator<Triple>() {
@Override
public int compare(final Triple o1, final Triple o2) {
return order.order(o1.getPredicate().compareTo(o2.getPredicate()));
}
};
tripleFunction = Triple::getPredicate;
break;
}

return comparator;
final Function<Triple, Integer> numericFunction = tripleFunction.andThen(Integer::valueOf);
return numeric ?
(o1, o2) -> order.order(numericFunction.apply(o1).compareTo(numericFunction.apply(o2))) :
(o1, o2) -> order.order(tripleFunction.apply(o1).compareTo(tripleFunction.apply(o2)));
}

@Override
public final void onResetStream() {
buffer.clear();

for (final File file : tempFiles) {
if (file.exists()) {
file.delete();
}
}

tempFiles.clear();
}

}
6 changes: 5 additions & 1 deletion metafacture-triples/src/main/java/org/metafacture/triples/TripleSort.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -27,7 +27,7 @@
* @author markus geipel
*
*/
@Description("Sorts triples")
@Description("Sorts triples. Several options can be combined, e.g. `by=\"object\",numeric=\"true\",order=\"decreasing\"` will numerically sort the Object of the triples in decreasing order (given that all Objects are indeed of numeric type).")
@In(Triple.class)
@Out(Triple.class)
@FluxCommand("sort-triples")
Expand All @@ -49,4 +49,8 @@ public void setOrder(final Order order) {
setSortOrder(order);
}

public void setNumeric(final boolean numeric) {
setSortNumeric(numeric);
}

}
Loading