_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q17600 | Spies.spy | train | public static <T1, T2, R> BiFunction<T1, T2, R> spy(BiFunction<T1, T2, R> function, Box<R> result, Box<T1> param1, Box<T2> param2) {
return new BinaryCapturingFunction<>(function, result, param1, param2);
} | java | {
"resource": ""
} |
q17601 | Spies.spy | train | public static <T1, T2, T3, R> TriFunction<T1, T2, T3, R> spy(TriFunction<T1, T2, T3, R> function, Box<R> result, Box<T1> param1, Box<T2> param2, Box<T3> param3) {
return new TernaryCapturingFunction<T1, T2, T3, R>(function, result, param1, param2, param3);
} | java | {
"resource": ""
} |
q17602 | Spies.spy | train | public static <T> Predicate<T> spy(Predicate<T> predicate, Box<Boolean> result, Box<T> param) {
return new CapturingPredicate<T>(predicate, result, param);
} | java | {
"resource": ""
} |
q17603 | Spies.spy | train | public static <T1, T2> BiPredicate<T1, T2> spy(BiPredicate<T1, T2> predicate, Box<Boolean> result, Box<T1> param1, Box<T2> param2) {
return new BinaryCapturingPredicate<T1, T2>(predicate, result, param1, param2);
} | java | {
"resource": ""
} |
q17604 | Spies.spy | train | public static <T1, T2, T3> TriPredicate<T1, T2, T3> spy(TriPredicate<T1, T2, T3> predicate, Box<Boolean> result, Box<T1> param1, Box<T2> param2, Box<T3> param3) {
return new TernaryCapturingPredicate<T1, T2, T3>(predicate, result, param1, param2, param3);
} | java | {
"resource": ""
} |
q17605 | Spies.spy | train | public static <T> Consumer<T> spy(Consumer<T> consumer, Box<T> param) {
return new CapturingConsumer<T>(consumer, param);
} | java | {
"resource": ""
} |
q17606 | Spies.spy | train | public static <T1, T2> BiConsumer<T1, T2> spy(BiConsumer<T1, T2> consumer, Box<T1> param1, Box<T2> param2) {
return new BinaryCapturingConsumer<T1, T2>(consumer, param1, param2);
} | java | {
"resource": ""
} |
q17607 | Spies.spy | train | public static <T1, T2, T3> TriConsumer<T1, T2, T3> spy(TriConsumer<T1, T2, T3> consumer, Box<T1> param1, Box<T2> param2, Box<T3> param3) {
return new TernaryCapturingConsumer<T1, T2, T3>(consumer, param1, param2, param3);
} | java | {
"resource": ""
} |
q17608 | Spies.spyRes | train | public static <T1, T2, T3, R> TriFunction<T1, T2, T3, R> spyRes(TriFunction<T1, T2, T3, R> function, Box<R> result) {
return spy(function, result, Box.<T1>empty(), Box.<T2>empty(), Box.<T3>empty());
} | java | {
"resource": ""
} |
q17609 | Spies.spy1st | train | public static <T1, T2, T3, R> TriFunction<T1, T2, T3, R> spy1st(TriFunction<T1, T2, T3, R> function, Box<T1> param1) {
return spy(function, Box.<R>empty(), param1, Box.<T2>empty(), Box.<T3>empty());
} | java | {
"resource": ""
} |
q17610 | Spies.spy2nd | train | public static <T1, T2, T3, R> TriFunction<T1, T2, T3, R> spy2nd(TriFunction<T1, T2, T3, R> function, Box<T2> param2) {
return spy(function, Box.<R>empty(), Box.<T1>empty(), param2, Box.<T3>empty());
} | java | {
"resource": ""
} |
q17611 | Spies.spy3rd | train | public static <T1, T2, T3, R> TriFunction<T1, T2, T3, R> spy3rd(TriFunction<T1, T2, T3, R> function, Box<T3> param3) {
return spy(function, Box.<R>empty(), Box.<T1>empty(), Box.<T2>empty(), param3);
} | java | {
"resource": ""
} |
q17612 | Spies.spyRes | train | public static <T1, T2, R> BiFunction<T1, T2, R> spyRes(BiFunction<T1, T2, R> function, Box<R> result) {
return spy(function, result, Box.<T1>empty(), Box.<T2>empty());
} | java | {
"resource": ""
} |
q17613 | Spies.spy1st | train | public static <T1, T2, R> BiFunction<T1, T2, R> spy1st(BiFunction<T1, T2, R> function, Box<T1> param1) {
return spy(function, Box.<R>empty(), param1, Box.<T2>empty());
} | java | {
"resource": ""
} |
q17614 | Spies.spy2nd | train | public static <T1, T2, R> BiFunction<T1, T2, R> spy2nd(BiFunction<T1, T2, R> function, Box<T2> param2) {
return spy(function, Box.<R>empty(), Box.<T1>empty(), param2);
} | java | {
"resource": ""
} |
q17615 | Spies.spyRes | train | public static <R, T> Function<T, R> spyRes(Function<T, R> function, Box<R> result) {
return spy(function, result, Box.<T>empty());
} | java | {
"resource": ""
} |
q17616 | Spies.spy1st | train | public static <R, T> Function<T, R> spy1st(Function<T, R> function, Box<T> param) {
return spy(function, Box.<R>empty(), param);
} | java | {
"resource": ""
} |
q17617 | Spies.spy1st | train | public static <T1, T2, T3> TriConsumer<T1, T2, T3> spy1st(TriConsumer<T1, T2, T3> consumer, Box<T1> param1) {
return spy(consumer, param1, Box.<T2>empty(), Box.<T3>empty());
} | java | {
"resource": ""
} |
q17618 | Spies.spy2nd | train | public static <T1, T2, T3> TriConsumer<T1, T2, T3> spy2nd(TriConsumer<T1, T2, T3> consumer, Box<T2> param2) {
return spy(consumer, Box.<T1>empty(), param2, Box.<T3>empty());
} | java | {
"resource": ""
} |
q17619 | Spies.spy3rd | train | public static <T1, T2, T3> TriConsumer<T1, T2, T3> spy3rd(TriConsumer<T1, T2, T3> consumer, Box<T3> param3) {
return spy(consumer, Box.<T1>empty(), Box.<T2>empty(), param3);
} | java | {
"resource": ""
} |
q17620 | Spies.spy2nd | train | public static <T1, T2> BiConsumer<T1, T2> spy2nd(BiConsumer<T1, T2> consumer, Box<T2> param2) {
return spy(consumer, Box.<T1>empty(), param2);
} | java | {
"resource": ""
} |
q17621 | Spies.spyRes | train | public static <T1, T2, T3> TriPredicate<T1, T2, T3> spyRes(TriPredicate<T1, T2, T3> predicate, Box<Boolean> result) {
return spy(predicate, result, Box.<T1>empty(), Box.<T2>empty(), Box.<T3>empty());
} | java | {
"resource": ""
} |
q17622 | Spies.spy1st | train | public static <T1, T2, T3> TriPredicate<T1, T2, T3> spy1st(TriPredicate<T1, T2, T3> predicate, Box<T1> param1) {
return spy(predicate, Box.<Boolean>empty(), param1, Box.<T2>empty(), Box.<T3>empty());
} | java | {
"resource": ""
} |
q17623 | Spies.spy2nd | train | public static <T1, T2, T3> TriPredicate<T1, T2, T3> spy2nd(TriPredicate<T1, T2, T3> predicate, Box<T2> param2) {
return spy(predicate, Box.<Boolean>empty(), Box.<T1>empty(), param2, Box.<T3>empty());
} | java | {
"resource": ""
} |
q17624 | Spies.spy3rd | train | public static <T1, T2, T3> TriPredicate<T1, T2, T3> spy3rd(TriPredicate<T1, T2, T3> predicate, Box<T3> param3) {
return spy(predicate, Box.<Boolean>empty(), Box.<T1>empty(), Box.<T2>empty(), param3);
} | java | {
"resource": ""
} |
q17625 | Spies.spyRes | train | public static <T1, T2> BiPredicate<T1, T2> spyRes(BiPredicate<T1, T2> predicate, Box<Boolean> result) {
return spy(predicate, result, Box.<T1>empty(), Box.<T2>empty());
} | java | {
"resource": ""
} |
q17626 | Spies.spy1st | train | public static <T1, T2> BiPredicate<T1, T2> spy1st(BiPredicate<T1, T2> predicate, Box<T1> param1) {
return spy(predicate, Box.<Boolean>empty(), param1, Box.<T2>empty());
} | java | {
"resource": ""
} |
q17627 | Spies.spy2nd | train | public static <T1, T2> BiPredicate<T1, T2> spy2nd(BiPredicate<T1, T2> predicate, Box<T2> param2) {
return spy(predicate, Box.<Boolean>empty(), Box.<T1>empty(), param2);
} | java | {
"resource": ""
} |
q17628 | Spies.spyRes | train | public static <T> Predicate<T> spyRes(Predicate<T> predicate, Box<Boolean> result) {
return spy(predicate, result, Box.<T>empty());
} | java | {
"resource": ""
} |
q17629 | Spies.spy1st | train | public static <T> Predicate<T> spy1st(Predicate<T> predicate, Box<T> param) {
return spy(predicate, Box.<Boolean>empty(), param);
} | java | {
"resource": ""
} |
q17630 | Spies.monitor | train | public static <T> Consumer<T> monitor(Consumer<T> consumer, AtomicLong calls) {
return new MonitoringConsumer<T>(consumer, calls);
} | java | {
"resource": ""
} |
q17631 | Spies.monitor | train | public static <T, R> Function<T, R> monitor(Function<T, R> function, AtomicLong calls) {
return new MonitoringFunction<>(function, calls);
} | java | {
"resource": ""
} |
q17632 | Spies.monitor | train | public static <T> Predicate<T> monitor(Predicate<T> predicate, AtomicLong calls) {
return new MonitoringPredicate<T>(predicate, calls);
} | java | {
"resource": ""
} |
q17633 | Spies.monitor | train | public static <R> Supplier<R> monitor(Supplier<R> supplier, AtomicLong calls) {
return new MonitoringSupplier<>(supplier, calls);
} | java | {
"resource": ""
} |
q17634 | Spies.monitor | train | public static <T1, T2> BiConsumer<T1, T2> monitor(BiConsumer<T1, T2> consumer, AtomicLong calls) {
return new BinaryMonitoringConsumer<T1, T2>(consumer, calls);
} | java | {
"resource": ""
} |
q17635 | Spies.monitor | train | public static <T1, T2, R> BiFunction<T1, T2, R> monitor(BiFunction<T1, T2, R> function, AtomicLong calls) {
return new BinaryMonitoringFunction<>(function, calls);
} | java | {
"resource": ""
} |
q17636 | Spies.monitor | train | public static <T1, T2> BiPredicate<T1, T2> monitor(BiPredicate<T1, T2> predicate, AtomicLong calls) {
return new BinaryMonitoringPredicate<T1, T2>(predicate, calls);
} | java | {
"resource": ""
} |
q17637 | Spies.monitor | train | public static <T1, T2, T3> TriConsumer<T1, T2, T3> monitor(TriConsumer<T1, T2, T3> consumer, AtomicLong calls) {
return new TernaryMonitoringConsumer<T1, T2, T3>(consumer, calls);
} | java | {
"resource": ""
} |
q17638 | Spies.monitor | train | public static <T1, T2, T3, R> TriFunction<T1, T2, T3, R> monitor(TriFunction<T1, T2, T3, R> function, AtomicLong calls) {
return new TernaryMonitoringFunction<T1, T2, T3, R>(function, calls);
} | java | {
"resource": ""
} |
q17639 | Spies.monitor | train | public static <T1, T2, T3> TriPredicate<T1, T2, T3> monitor(TriPredicate<T1, T2, T3> predicate, AtomicLong calls) {
return new TernaryMonitoringPredicate<T1, T2, T3>(predicate, calls);
} | java | {
"resource": ""
} |
q17640 | DataCollectorList.addDataCollector | train | protected final void addDataCollector(final Class collectorName) {
if (!DataCollector.class.isAssignableFrom(collectorName)) {
throw new RuntimeException("Class must be subclass of DataCollector!");
}
collectors.add(collectorName);
} | java | {
"resource": ""
} |
q17641 | DataCollectorList.getDataCollectors | train | public final Map<String, DataCollector> getDataCollectors() {
final Map<String, DataCollector> collectorsRet = new HashMap<>();
for (final Class<DataCollector> c : collectors) {
DataCollector dc;
try {
dc = c.newInstance();
collectorsRet.put(dc.getName(), dc);
} catch (final InstantiationException e) {
e.printStackTrace();
} catch (final IllegalAccessException e) {
e.printStackTrace();
}
}
return collectorsRet;
} | java | {
"resource": ""
} |
q17642 | PipelinedConsumer.accept | train | @Override
public void accept(E value) {
for (Consumer<E> consumer : consumers) {
consumer.accept(value);
}
} | java | {
"resource": ""
} |
q17643 | GreetingService.getGreeting | train | public Promise<String> getGreeting() {
Promise<String> p = q.all(getSalutation(), getName())
.then(new Continue<String, JSArray<?>>() {
// Formats the greeting when salutation and name are delivered.
@Override
public String call(JSArray<?> value) {
return value.get(0) + ", " + value.get(1) + "!";
}
});
return p;
} | java | {
"resource": ""
} |
q17644 | GreetingService.getSalutation | train | public Promise<String> getSalutation() {
final Deferred<String> d = q.defer();
Timer timer = new Timer() {
@Override
public void run() {
d.progress(new TimerProgress("Loaded salutation", this));
d.resolve("Hello");
}
};
d.progress(new TimerProgress("Loading salutation...", timer));
timer.schedule(1000);
return d.promise();
} | java | {
"resource": ""
} |
q17645 | Ranges.rightHalfOpen | train | public Range<T> rightHalfOpen(T lower, Optional<T> upper) {
return new DenseRange<T>(sequencer, comparator, Endpoint.Include, lower, upper, Endpoint.Exclude);
} | java | {
"resource": ""
} |
q17646 | Ranges.leftHalfOpen | train | public Range<T> leftHalfOpen(T lower, T upper) {
return new DenseRange<T>(sequencer, comparator, Endpoint.Exclude, lower, Optional.of(upper), Endpoint.Include);
} | java | {
"resource": ""
} |
q17647 | Boxing.box | train | public static Boolean[] box(boolean[] array) {
dbc.precondition(array != null, "cannot box a null boolean array");
final Boolean[] result = new Boolean[array.length];
for (int i = 0; i != result.length; ++i) {
result[i] = array[i];
}
return result;
} | java | {
"resource": ""
} |
q17648 | ItextHelper.round | train | public static float round(float f, int decimalPlace) {
return BigDecimal.valueOf((double) f).setScale(decimalPlace, BigDecimal.ROUND_HALF_UP).floatValue();
} | java | {
"resource": ""
} |
q17649 | StyleHelper.getStylers | train | public static <E extends BaseStyler> List<E> getStylers(Collection<? extends BaseStyler> stylers, Class<E> clazz)
throws VectorPrintException {
List<E> st = new ArrayList<>(1);
for (BaseStyler s : stylers) {
if (clazz.isAssignableFrom(s.getClass())) {
st.add((E) s);
}
}
return st;
} | java | {
"resource": ""
} |
q17650 | StyleHelper.delayedStyle | train | public static void delayedStyle(Chunk c, String tag, Collection<? extends Advanced> stylers, EventHelper eventHelper, Image img) {
// add to pagehelper and set generic tag
eventHelper.addDelayedStyler(tag, stylers, c, img);
c.setGenericTag(tag);
} | java | {
"resource": ""
} |
q17651 | Domainname.getLevelDomain | train | public Domainname getLevelDomain(int level) {
String[] parts = this.getCode().split("\\.");
int firstPart = parts.length - level;
if ((firstPart < 0) || (level < 1)) {
throw new LocalizedIllegalArgumentException(level, "level", Range.between(1, parts.length));
}
StringBuilder name = new StringBuilder(parts[firstPart]);
for (int i = firstPart + 1; i < parts.length; i++) {
name.append('.');
name.append(parts[i]);
}
return new Domainname(name.toString());
} | java | {
"resource": ""
} |
q17652 | CompositeNeighbourhood.getAllMoves | train | @Override
public List<Move<? super SolutionType>> getAllMoves(SolutionType solution) {
return neighs.stream()
.flatMap(neigh -> neigh.getAllMoves(solution).stream()) // flatten to one stream of all moves
.collect(Collectors.toList()); // collect in one list
} | java | {
"resource": ""
} |
q17653 | Bruch.multiply | train | public AbstractNumber multiply(Bruch operand) {
BigInteger z = getZaehler().multiply(operand.getZaehler());
BigInteger n = getNenner().multiply(operand.getNenner());
return Bruch.of(z, n).kuerzen();
} | java | {
"resource": ""
} |
q17654 | Bruch.add | train | public AbstractNumber add(Bruch operand) {
BigInteger n = getNenner().multiply(operand.getNenner());
BigInteger z1 = getZaehler().multiply(operand.getNenner());
BigInteger z2 = operand.getZaehler().multiply(getNenner());
return Bruch.of(z1.add(z2), n).kuerzen();
} | java | {
"resource": ""
} |
q17655 | Bruch.compareTo | train | @Override
public int compareTo(Bruch other) {
BigInteger thisZaehlerErweitert = this.zaehler.multiply(other.nenner);
BigInteger otherZaehlerErweitert = other.zaehler.multiply(this.nenner);
return thisZaehlerErweitert.compareTo(otherZaehlerErweitert);
} | java | {
"resource": ""
} |
q17656 | AdvancedImpl.getPreparedCanvas | train | protected final PdfContentByte getPreparedCanvas(float opacity) {
needRestore = false;
PdfContentByte canvas = (tableForeground != null) ? tableForeground : (isBg())
? getWriter().getDirectContentUnder()
: getWriter().getDirectContent();
String layerName = getLayerName();
BLENDMODE blend = getBlend();
if (getWriter().getPDFXConformance() == PdfWriter.PDFX1A2001) {
// check blend, opacity, layers
if (!PdfGState.BM_NORMAL.equals(blend.getBlend()) && !PdfGState.BM_COMPATIBLE.equals(blend.getBlend())) {
throw new VectorPrintRuntimeException("blend not supported in PDF/X-1a: " + blend);
}
if (layerName != null) {
throw new VectorPrintRuntimeException("layers not supported in PDF/X-1a: " + layerName);
}
if (opacity < 1) {
throw new VectorPrintRuntimeException("opacity not supported in PDF/X-1a: " + opacity);
}
}
if (layerName != null) {
layerManager.startLayerInGroup(layerName, canvas);
}
// pgs.setAlphaIsShape(true);
if (opacity <= 1) {
// PdfShading shading = PdfShading.simpleAxial(getWriter(), 0, 0, getDocument().right() - getDocument().getPageSize().getWidth() * 0.6f, getDocument().top() - getDocument().getPageSize().getHeight() * 0.6f, Color.green, Color.orange,true,true);
// canvas.paintShading(shading);
canvas.saveState();
needRestore = true;
PdfGState pgs = new PdfGState();
pgs.setFillOpacity(opacity);
pgs.setStrokeOpacity(opacity);
canvas.setGState(pgs);
}
if (!BLENDMODE.NORMAL.equals(blend)) {
if (!needRestore) {
canvas.saveState();
needRestore = true;
}
PdfGState pgs = new PdfGState();
pgs.setBlendMode(blend.getBlend());
canvas.setGState(pgs);
}
if (getTransform() != null && !(this instanceof Image)) {
canvas.transform(new AffineTransform(getTransform()));
}
return canvas;
} | java | {
"resource": ""
} |
q17657 | Reductions.reduce | train | public static <E, R> R reduce(E[] array, BiFunction<R, E, R> function, R init) {
return new Reductor<>(function, init).apply(new ArrayIterator<E>(array));
} | java | {
"resource": ""
} |
q17658 | Reductions.every | train | public static <E> boolean every(Iterable<E> iterable, Predicate<E> predicate) {
dbc.precondition(iterable != null, "cannot call every with a null iterable");
return new Every<E>(predicate).test(iterable.iterator());
} | java | {
"resource": ""
} |
q17659 | Reductions.every | train | public static <E> boolean every(Iterator<E> iterator, Predicate<E> predicate) {
return new Every<E>(predicate).test(iterator);
} | java | {
"resource": ""
} |
q17660 | Reductions.every | train | public static <E> boolean every(E[] array, Predicate<E> predicate) {
return new Every<E>(predicate).test(new ArrayIterator<E>(array));
} | java | {
"resource": ""
} |
q17661 | Reductions.counti | train | public static <E> int counti(Iterator<E> iterator) {
final long value = reduce(iterator, new Count<E>(), 0l);
dbc.state(value <= Integer.MAX_VALUE, "iterator size overflows an integer");
return (int) value;
} | java | {
"resource": ""
} |
q17662 | SearchRunResults.updateBestSolution | train | public void updateBestSolution(long time, double value, SolutionType newBestSolution){
times.add(time);
values.add(value);
bestSolution = newBestSolution;
} | java | {
"resource": ""
} |
q17663 | Tuples.tupled | train | public static <T, U, R> Function<Pair<T, U>, R> tupled(BiFunction<T, U, R> function) {
dbc.precondition(function != null, "cannot apply a pair to a null function");
return pair -> function.apply(pair.first(), pair.second());
} | java | {
"resource": ""
} |
q17664 | Tuples.tupled | train | public static <T, U> Predicate<Pair<T, U>> tupled(BiPredicate<T, U> predicate) {
dbc.precondition(predicate != null, "cannot apply a pair to a null predicate");
return pair -> predicate.test(pair.first(), pair.second());
} | java | {
"resource": ""
} |
q17665 | Tuples.tupled | train | public static <T, U> Consumer<Pair<T, U>> tupled(BiConsumer<T, U> consumer) {
dbc.precondition(consumer != null, "cannot apply a pair to a null consumer");
return pair -> consumer.accept(pair.first(), pair.second());
} | java | {
"resource": ""
} |
q17666 | Tuples.tupled | train | public static <T, U, V, R> Function<Triple<T, U, V>, R> tupled(TriFunction<T, U, V, R> function) {
dbc.precondition(function != null, "cannot apply a triple to a null function");
return triple -> function.apply(triple.first(), triple.second(), triple.third());
} | java | {
"resource": ""
} |
q17667 | Tuples.tupled | train | public static <T, U, V> Predicate<Triple<T, U, V>> tupled(TriPredicate<T, U, V> predicate) {
dbc.precondition(predicate != null, "cannot apply a triple to a null predicate");
return triple -> predicate.test(triple.first(), triple.second(), triple.third());
} | java | {
"resource": ""
} |
q17668 | Tuples.tupled | train | public static <T, U, V> Consumer<Triple<T, U, V>> tupled(TriConsumer<T, U, V> consumer) {
dbc.precondition(consumer != null, "cannot apply a triple to a null consumer");
return triple -> consumer.accept(triple.first(), triple.second(), triple.third());
} | java | {
"resource": ""
} |
q17669 | ConnectorDescriptorImpl.removeAllNamespaces | train | public ConnectorDescriptor removeAllNamespaces()
{
List<String> nameSpaceKeys = new ArrayList<String>();
java.util.Map<String, String> attributes = model.getAttributes();
for (Entry<String, String> e : attributes.entrySet())
{
final String name = e.getKey();
final String value = e.getValue();
if (value != null && value.startsWith("http://"))
{
nameSpaceKeys.add(name);
}
}
for (String name: nameSpaceKeys)
{
model.removeAttribute(name);
}
return this;
} | java | {
"resource": ""
} |
q17670 | KoPeMeClassFileTransformater.around | train | private void around(final CtMethod m, final String before, final String after, final List<VarDeclarationData> declarations) throws CannotCompileException, NotFoundException {
String signature = Modifier.toString(m.getModifiers()) + " " + m.getReturnType().getName() + " " + m.getLongName();
LOG.info("--- Instrumenting " + signature);
for (VarDeclarationData declaration : declarations) {
m.addLocalVariable(declaration.getName(), pool.get(declaration.getType()));
}
m.insertBefore(before);
m.insertAfter(after);
} | java | {
"resource": ""
} |
q17671 | Iterations.oneTime | train | public static <T> Iterable<T> oneTime(Iterator<T> iterator) {
return new OneTimeIterable<T>(iterator);
} | java | {
"resource": ""
} |
q17672 | Iterations.iterator | train | public static <T> Iterator<T> iterator(T first, T second) {
return ArrayIterator.of(first, second);
} | java | {
"resource": ""
} |
q17673 | Iterations.iterable | train | public static <T> Iterable<T> iterable(T first, T second) {
return ArrayIterable.of(first, second);
} | java | {
"resource": ""
} |
q17674 | BinaryInterceptorAdapter.apply | train | @Override
public R apply(T1 first, T2 second) {
interceptor.before(first, second);
try {
return inner.apply(first, second);
} finally {
interceptor.after(first, second);
}
} | java | {
"resource": ""
} |
q17675 | BLZ.validate | train | @Deprecated
public static String validate(String blz) {
return VALIDATOR.validate(PackedDecimal.of(blz)).toString();
} | java | {
"resource": ""
} |
q17676 | WeightedIndex.evaluate | train | @Override
public WeightedIndexEvaluation evaluate(SolutionType solution, DataType data) {
// initialize evaluation object
WeightedIndexEvaluation eval = new WeightedIndexEvaluation();
// add evaluations produced by contained objectives
weights.keySet().forEach(obj -> {
// evaluate solution using objective
Evaluation objEval = obj.evaluate(solution, data);
// flip weight sign if minimizing
double w = weights.get(obj);
if(obj.isMinimizing()){
w = -w;
}
// register in weighted index evaluation
eval.addEvaluation(obj, objEval, w);
});
// return weighted index evaluation
return eval;
} | java | {
"resource": ""
} |
q17677 | WeightedIndex.evaluate | train | @Override
public <ActualSolutionType extends SolutionType> WeightedIndexEvaluation evaluate(Move<? super ActualSolutionType> move,
ActualSolutionType curSolution,
Evaluation curEvaluation,
DataType data) {
// cast current evaluation object
WeightedIndexEvaluation curEval = (WeightedIndexEvaluation) curEvaluation;
// initialize new evaluation object
WeightedIndexEvaluation newEval = new WeightedIndexEvaluation();
// compute delta evaluation for each contained objective
weights.keySet().forEach(obj -> {
// extract current evaluation
Evaluation objCurEval = curEval.getEvaluation(obj);
// delta evaluation of contained objective
Evaluation objNewEval = obj.evaluate(move, curSolution, objCurEval, data);
// flip weight sign if minimizing
double w = weights.get(obj);
if(obj.isMinimizing()){
w = -w;
}
// register in new weighted index evaluation
newEval.addEvaluation(obj, objNewEval, w);
});
// return new evaluation
return newEval;
} | java | {
"resource": ""
} |
q17678 | ToFachwertSerializer.serialize | train | @Override
public void serialize(Fachwert fachwert, JsonGenerator jgen, SerializerProvider provider) throws IOException {
serialize(fachwert.toMap(), jgen, provider);
} | java | {
"resource": ""
} |
q17679 | Configuration.configurePort | train | void configurePort(String port) {
if (StringUtils.isNotBlank(port)) {
try {
this.port = Integer.parseInt(port);
log.info("Using port {}", this.port);
} catch (NumberFormatException e) {
log.info("Unable to parse server PORT variable ({}). Defaulting to port {}", port, this.port);
}
}
} | java | {
"resource": ""
} |
q17680 | Configuration.configureClasses | train | void configureClasses(String path) {
findClassesInClasspath();
if (StringUtils.isNotBlank(path)) {
// If the path is set, set up class reloading:
configureClassesReloadable(path);
}
packagePrefix = getValue(PACKAGE_PREFIX);
classesReloadable = classesUrl != null && classesInClasspath == null;
// Communicate:
showClassesConfiguration();
} | java | {
"resource": ""
} |
q17681 | Configuration.configureAuthentication | train | private void configureAuthentication(String username, String password, String realm) {
// If the username is set, set up authentication:
if (StringUtils.isNotBlank(username)) {
this.username = username;
this.password = password;
this.realm = StringUtils.defaultIfBlank(realm, "restolino");
authenticationEnabled = true;
}
} | java | {
"resource": ""
} |
q17682 | Configuration.showFilesConfiguration | train | void showFilesConfiguration() {
// Message to communicate the resolved configuration:
String message;
if (filesUrl != null) {
String reload = filesReloadable ? "reloadable" : "non-reloadable";
message = "Files will be served from: " + filesUrl + " (" + reload + ")";
} else {
message = "No static files will be served.";
}
log.info("Files: {}", message);
} | java | {
"resource": ""
} |
q17683 | Configuration.showClassesConfiguration | train | void showClassesConfiguration() {
// Warning about a classes folder present in the classpath:
if (classesInClasspath != null) {
log.warn("Dynamic class reloading is disabled because a classes URL is present in the classpath. P"
+ "lease launch without including your classes directory: {}", classesInClasspath);
}
// Message to communicate the resolved configuration:
String message;
if (classesReloadable) {
if (StringUtils.isNotBlank(packagePrefix)) {
message = "Classes will be reloaded from: " + classesUrl;
} else {
message = "Classes will be reloaded from package " + packagePrefix + " at: " + classesUrl;
}
} else {
message = "Classes will not be dynamically reloaded.";
}
log.info("Classes: {}", message);
} | java | {
"resource": ""
} |
q17684 | Configuration.getValue | train | static String getValue(String key) {
String result = StringUtils.defaultIfBlank(System.getProperty(key), StringUtils.EMPTY);
result = StringUtils.defaultIfBlank(result, System.getenv(key));
return result;
} | java | {
"resource": ""
} |
q17685 | LengthValidator.isValid | train | @Override
public boolean isValid(T wert) {
int length = Objects.toString(wert, "").length();
return (length >= min) && (length <= max);
} | java | {
"resource": ""
} |
q17686 | Analysis.setNumRuns | train | public Analysis<SolutionType> setNumRuns(String searchID, int n){
if(!searches.containsKey(searchID)){
throw new UnknownIDException("No search with ID " + searchID + " has been added.");
}
if(n <= 0){
throw new IllegalArgumentException("Number of runs should be strictly positive.");
}
searchNumRuns.put(searchID, n);
return this;
} | java | {
"resource": ""
} |
q17687 | Analysis.setNumBurnIn | train | public Analysis<SolutionType> setNumBurnIn(String searchID, int n){
if(!searches.containsKey(searchID)){
throw new UnknownIDException("No search with ID " + searchID + " has been added.");
}
if(n <= 0){
throw new IllegalArgumentException("Number of burn-in runs should be strictly positive.");
}
searchNumBurnIn.put(searchID, n);
return this;
} | java | {
"resource": ""
} |
q17688 | Analysis.addProblem | train | public Analysis<SolutionType> addProblem(String ID, Problem<SolutionType> problem){
if(problem == null){
throw new NullPointerException("Problem can not be null.");
}
if(problems.containsKey(ID)){
throw new DuplicateIDException("Duplicate problem ID: " + ID + ".");
}
problems.put(ID, problem);
return this;
} | java | {
"resource": ""
} |
q17689 | Analysis.addSearch | train | public Analysis<SolutionType> addSearch(String ID, SearchFactory<SolutionType> searchFactory){
if(searchFactory == null){
throw new NullPointerException("Search factory can not be null.");
}
if(searches.containsKey(ID)){
throw new DuplicateIDException("Duplicate search ID: " + ID + ".");
}
searches.put(ID, searchFactory);
return this;
} | java | {
"resource": ""
} |
q17690 | Analysis.run | train | public AnalysisResults<SolutionType> run(){
// create results object
AnalysisResults<SolutionType> results = new AnalysisResults<>();
// log
LOGGER.info(ANALYSIS_MARKER,
"Started analysis of {} problems {} using {} searches {}.",
problems.size(),
problems.keySet(),
searches.size(),
searches.keySet());
// analyze each problem
problems.forEach((problemID, problem) -> {
LOGGER.info(ANALYSIS_MARKER, "Analyzing problem {}.", problemID);
// apply all searches
searches.forEach((searchID, searchFactory) -> {
// execute burn-in runs
int nBurnIn = getNumBurnIn(searchID);
for(int burnIn=0; burnIn<nBurnIn; burnIn++){
LOGGER.info(ANALYSIS_MARKER,
"Burn-in of search {} applied to problem {} (burn-in run {}/{}).",
searchID, problemID, burnIn+1, nBurnIn);
// create search
Search<SolutionType> search = searchFactory.create(problem);
// run search
search.start();
// dispose search
search.dispose();
LOGGER.info(ANALYSIS_MARKER,
"Finished burn-in run {}/{} of search {} for problem {}.",
burnIn+1, nBurnIn, searchID, problemID);
}
// perform actual search runs and register results
int nRuns = getNumRuns(searchID);
for(int run=0; run<nRuns; run++){
LOGGER.info(ANALYSIS_MARKER,
"Applying search {} to problem {} (run {}/{}).",
searchID, problemID, run+1, nRuns);
// create search
Search<SolutionType> search = searchFactory.create(problem);
// attach listener
AnalysisListener listener = new AnalysisListener();
search.addSearchListener(listener);
// run search
search.start();
// dispose search
search.dispose();
// register search run in results object
results.registerSearchRun(problemID, searchID, listener.getSearchRunResults());
LOGGER.info(ANALYSIS_MARKER,
"Finished run {}/{} of search {} for problem {}.",
run+1, nRuns, searchID, problemID);
}
});
LOGGER.info(ANALYSIS_MARKER, "Done analyzing problem {}.", problemID);
});
// log
LOGGER.info(ANALYSIS_MARKER, "Analysis complete.");
return results;
} | java | {
"resource": ""
} |
q17691 | ExternalKoPeMeRunner.run | train | public int run() {
try {
if ( compile )
{
compile();
}
String separator = "/";
String cpseperator = ":";
if (System.getProperty("os.name").contains("indows")){
separator = "\\";
cpseperator = ";";
}
String s = fileName.replace(separator, ".");
if ( ".java".equals(s.substring(s.length()-5)))
{
s = s.substring(0, s.length()-5); // .java Entfernen
}
else
{
s = s.substring(0, s.length() - 6); // .class entfernen
}
String localClasspath = classpath;
if (compileFolder != null)
localClasspath = localClasspath + cpseperator + compileFolder;
String command = "java -cp "+localClasspath;
if (libraryPath != null && libraryPath!= "")
command += "-Djava.library.path="+libraryPath;
command = command + " de.kopeme.testrunner.PerformanceTestRunner " + s;
// System.out.println(command);
Process p = Runtime.getRuntime().exec(command);
BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
String line;
BufferedWriter bw = null;
// System.out.println("ExternalOutputFile: " + externalOutputFile);
if ( externalOutputFile != null && externalOutputFile != "")
{
File output = new File(externalOutputFile);
try {
bw = new BufferedWriter( new FileWriter(output));
} catch (IOException e1) {
// TODO Automatisch generierter Erfassungsblock
e1.printStackTrace();
}
}
while ( (line = br.readLine()) != null )
{
if ( bw == null)
{
System.out.println(line);
}
else
{
bw.write(line+"\n");
}
}
br = new BufferedReader(new InputStreamReader(p.getErrorStream()));
while ( (line = br.readLine()) != null )
{
if ( bw == null)
{
System.out.println(line);
}
else
{
bw.write(line+"\n");
}
}
if ( bw != null )
bw.close();
int returnValue = p.waitFor();
// System.out.println("Returnvalue: " + returnValue);
return returnValue;
} catch (IOException e) {
// TODO Automatisch generierter Erfassungsblock
e.printStackTrace();
} catch (InterruptedException e) {
// TODO Automatisch generierter Erfassungsblock
e.printStackTrace();
}
return 1;
} | java | {
"resource": ""
} |
q17692 | GwtImageResource.link | train | @Override
public void link(NGScope scope, JQElement element, JSON attrs) {
ImageResource resource = scope.get(getName());
if (resource == null) {
LOG.log(Level.WARNING, "Mandatory attribute " + getName() + " value is mssing");
return;
}
Image image = new Image(resource);
Element target = image.asWidget().getElement();
String className = element.attr("class");
target.addClassName(className);
String style = element.attr("style");
target.setAttribute("style", style);
element.replaceWith(target);
} | java | {
"resource": ""
} |
q17693 | Bankverbindung.toMap | train | @Override
public Map<String, Object> toMap() {
Map<String, Object> map = new HashMap<>();
map.put("kontoinhaber", getKontoinhaber());
map.put("iban", getIban());
getBic().ifPresent(b -> map.put("bic", b));
return map;
} | java | {
"resource": ""
} |
q17694 | Strings.repeat | train | public static String repeat(char source, int times) {
dbc.precondition(times > -1, "times must be non negative");
final char[] array = new char[times];
Arrays.fill(array, source);
return new String(array);
} | java | {
"resource": ""
} |
q17695 | Strings.repeat | train | public static String repeat(String source, int times) {
dbc.precondition(source != null, "cannot repeat a null source");
dbc.precondition(times > -1, "times must be non negative");
final int srcLen = source.length();
final long longLen = times * (long) srcLen;
final int len = (int) longLen;
dbc.precondition(longLen == len, "resulting String would be too long");
final char[] array = new char[len];
for (int i = 0; i != times; ++i) {
source.getChars(0, srcLen, array, i * srcLen);
}
return new String(array);
} | java | {
"resource": ""
} |
q17696 | Nummer.of | train | public static Nummer of(long code) {
if ((code >= 0) && (code < CACHE.length)) {
return CACHE[(int) code];
} else {
return new Nummer(code);
}
} | java | {
"resource": ""
} |
q17697 | Nummer.validate | train | public static String validate(String nummer) {
try {
return new BigInteger(nummer).toString();
} catch (NumberFormatException nfe) {
throw new InvalidValueException(nummer, "number");
}
} | java | {
"resource": ""
} |
q17698 | OptionalIterator.next | train | @Override
public Optional<E> next() {
if (iterator.hasNext()) {
return Optional.of(iterator.next());
}
return Optional.empty();
} | java | {
"resource": ""
} |
q17699 | Rechnungsmonat.ersterArbeitstag | train | public LocalDate ersterArbeitstag() {
LocalDate tag = ersterTag();
switch (tag.getDayOfWeek()) {
case SATURDAY:
return tag.plusDays(2);
case SUNDAY:
return tag.plusDays(1);
default:
return tag;
}
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.