@Grab('org.apache.velocity:velocity:1.7')

import org.apache.velocity.app.VelocityEngine

templateDirectory = 'templates'

outputDirectory = 'src'

knownFiles = new java.util.HashSet();

def timestamp(dir, file) {

if (file == null) return Long.MAX_VALUE;

file = new java.io.File(dir, file);

knownFiles.add(file);

return file.lastModified();

}

def processTemplate(engine, context, templateFile, outFilename) {

if (outFilename == null) return; // nothing to do

// create output directory if it does not already exist

outFile = new java.io.File(outputDirectory, outFilename);

knownFiles.add(outFile);

if (outFile.getParentFile() != null) outFile.getParentFile().mkdirs();

// apply the template and write out the result

t = engine.getTemplate(templateFile);

writer = new StringWriter();

t.merge(context, writer);

out = new PrintWriter(outFile, "UTF-8");

out.print(writer.toString());

out.close();

}

def parseValue(sh, translationsFile, key, expression) {

try {

return sh.evaluate(expression);

}

catch (groovy.lang.GroovyRuntimeException e) {

print("[WARNING] $translationsFile: " +

"key '$key' has unparseable value: " + e.getMessage());

}

}

def translate(templateSubdirectory, templateFile, translationsFile) {

// initialize the Velocity engine

engine = new org.apache.velocity.app.VelocityEngine();

p = new java.util.Properties();

// fail if template uses an invalid expression; e.g., an undefined variable

p.setProperty("runtime.references.strict", "true");

// tell Velocity where the templates are located

p.setProperty("file.resource.loader.path", "$templateSubdirectory");

// tell Velocity to log to stderr rather than to a velocity.log file

p.setProperty(org.apache.velocity.runtime.RuntimeConstants.RUNTIME_LOG_LOGSYSTEM_CLASS,

"org.apache.velocity.runtime.log.SystemLogChute");

engine.init(p);

// read translation lines

context = outputFilename = null;

reader = new java.io.BufferedReader(new java.io.FileReader("$templateSubdirectory/$translationsFile"));

// avoid rewriting unchanged code to avoid recompilation

mtime = java.lang.Math.max(

timestamp(templateSubdirectory, translationsFile),

timestamp(templateSubdirectory, templateFile));

sh = new groovy.lang.GroovyShell();

for (;;) {

// read the line

line = reader.readLine();

if (line == null) break;

// check if the line starts a new section

if (line.startsWith("[") && line.endsWith("]")) {

// write out the previous file

if (mtime >= timestamp(outputDirectory, outputFilename)) {

processTemplate(engine, context, templateFile, outputFilename);

}

// start a new file

outputFilename = line.substring(1, line.length() - 1);

if (!templateDirectory.equals(templateSubdirectory)) {

subPath = templateSubdirectory.substring(templateDirectory.length() + 1);

outputFilename = "$subPath/$outputFilename";

}

context = new org.apache.velocity.VelocityContext();

continue;

}

// ignore blank lines

trimmedLine = line.trim();

if (trimmedLine.isEmpty()) continue;

// ignore comments

if (trimmedLine.startsWith("#")) continue;

// parse key/value pair lines separate by equals

if (!line.contains('=')) {

print("[WARNING] $translationsFile: Ignoring spurious line: $line");

continue;

}

int idx = line.indexOf('=');

key = line.substring(0, idx).trim();

value = line.substring(idx + 1);

if (value.trim().equals('```')) {

// multi-line value

builder = new StringBuilder();

for (;;) {

line = reader.readLine();

if (line == null) {

throw new RuntimeException("Unfinished value: " + builder.toString());

}

if (line.equals('```')) {

break;

}

if (builder.length() > 0) {

builder.append("\n");

}

builder.append(line);

}

value = builder.toString();

}

context.put(key, parseValue(sh, translationsFile, key, value));

}

reader.close();

// process the template

if (mtime >= timestamp(outputDirectory, outputFilename)) {

processTemplate(engine, context, templateFile, outputFilename);

}

}

def translateDirectory(templateSubdirectory) {

for (file in new java.io.File(templateSubdirectory).listFiles()) {

if (file.isDirectory()) {

// process subdirectories recursively

translateDirectory(file.getPath());

}

else {

// process Velocity template files only

name = file.getName();

if (!name.endsWith('.vm')) continue;

prefix = name.substring(0, name.lastIndexOf('.'));

translate(templateSubdirectory, name, prefix + '.list');

}

}

}

def cleanStaleFiles(directory) {

list = directory == null ? null : directory.listFiles();

if (list == null) return;

for (File file : list) {

if (file.isDirectory()) {

cleanStaleFiles(file);

} else if (file.isFile() && !knownFiles.contains(file)) {

file.delete();

}

}

}

try {

translateDirectory(templateDirectory);

cleanStaleFiles(new File(outputDirectory));

}

catch (Throwable t) {

t.printStackTrace(System.err);

throw t;

}

[Computers.java]

arities = (0..3).collect()

consumerArity = ```

{ arity ->

arity == 0 ? 'Consumer' :

arity == 1 ? 'BiConsumer' :

"Consumers.Arity${arity+1}"

}

```

generics = ```

{ arity ->

arity == 0 ? '<O>' :

arity == 1 ? '<I, O>' :

'<' + String.join(', ', (1..arity).stream().map{a -> "I$a"}.collect()) + ', O>'

}

```

matchParams = ```

{ arity ->

arity == 0 ? 'final Nil<O> outType' :

arity == 1 ? 'final Nil<I> inType, final Nil<O> outType' :

String.join(', ', (1..arity).stream().map{a -> "final Nil<I$a> in${a}Type"}.collect()) + ', final Nil<O> outType'

}

```

typeArgs = ```

{ arity ->

arity == 0 ? 'outType.getType()' :

arity == 1 ? 'inType.getType(), outType.getType()' :

String.join(', ', (1..arity).stream().map{a -> "in${a}Type.getType()"}.collect()) + ', outType.getType()'

}

```

nilArgs = ```

{ arity ->

arity == 0 ? 'outType' :

arity == 1 ? 'inType, outType' :

String.join(', ', (1..arity).stream().map{a -> "in${a}Type"}.collect()) + ', outType'

}

```

computeParams = ```

{ arity ->

arity == 0 ? '@Mutable O out' :

arity == 1 ? 'I in, @Mutable O out' :

String.join(', ', (1..arity).stream().map{a -> "I$a in$a"}.collect()) + ', @Mutable O out'

}

```

acceptParams = ```

{ arity ->

arity == 0 ? 'final O out' :

arity == 1 ? 'final I in, final O out' :

String.join(', ', (1..arity).stream().map{a -> "final I$a in$a"}.collect()) + ', final O out'

}

```

computeArgs = ```

{ arity ->

arity == 0 ? 'out' :

arity == 1 ? 'in, out' :

String.join(', ', (1..arity).stream().map{a -> "in$a"}.collect()) + ', out'

}

```

/*

* This is autogenerated source code -- DO NOT EDIT. Instead, edit the

* corresponding template in templates/ and rerun bin/generate.groovy.

*/

package org.scijava.ops.function;

import com.google.common.collect.BiMap;

import com.google.common.collect.ImmutableBiMap;

import java.lang.reflect.Type;

import java.util.HashMap;

import java.util.Map;

import java.util.function.BiConsumer;

import java.util.function.Consumer;

import org.scijava.ops.OpService;

import org.scijava.ops.types.Nil;

import org.scijava.param.Mutable;

import org.scijava.util.Types;

/**

* Container class for computer-style functional interfaces at various

* <a href="https://en.wikipedia.org/wiki/Arity">arities</a>.

* <p>

* A computer has functional method {@code compute} with a number of arguments

* corresponding to the arity, plus an additional argument for the preallocated

* output to be populated by the computation.

* </p>

* <p>

* Each computer interface implements a corresponding {@link Consumer}-style

* interface (see {@link Consumers}) with arity+1; the consumer's {@code accept}

* method simply delegates to {@code compute}. This pattern allows computer ops

* to be used directly as consumers as needed.

* </p>

*

* @author Curtis Rueden

* @author Gabriel Selzer

*/

public final class Computers {

private Computers() {

// NB: Prevent instantiation of utility class.

}

// -- BEGIN TEMP --

/**

* All known computer types and their arities. The entries are sorted by

* arity, i.e., the {@code i}-th entry has an arity of {@code i}.

*/

public static final BiMap<Class<?>, Integer> ALL_COMPUTERS;

static {

final Map<Class<?>, Integer> computers = new HashMap<>();

#foreach($arity in $arities)

computers.put(Arity${arity}.class, $arity);

#end

ALL_COMPUTERS = ImmutableBiMap.copyOf(computers);

}

/**

* @return {@code true} if the given type is a {@link #ALL_COMPUTERS known}

* computer type, {@code false} otherwise. <br>

* Note that only the type itself and not its type hierarchy is

* considered.

* @throws NullPointerException If {@code type} is {@code null}.

*/

public static boolean isComputer(Type type) {

return ALL_COMPUTERS.containsKey(Types.raw(type));

}

#foreach($arity in $arities)

#set($rawClass = "Arity$arity")

#set($genericParams = $generics.call($arity))

#set($gClass = "$rawClass$genericParams")

public static $genericParams $gClass match(final OpService ops, final String opName,

$matchParams.call($arity))

{

final Nil<$gClass> specialType =

new Nil<$gClass>()

{

@Override

public Type getType() {

return Types.parameterize(${rawClass}.class, //

new Type[] { $typeArgs.call($arity) });

}

};

return ops.findOp( //

opName, //

specialType, //

new Nil<?>[] { $nilArgs.call($arity) }, //

outType);

}

#end##foreach($arity)

// -- END TEMP --

#foreach($arity in $arities)

#set($rawClass = "Arity$arity")

#set($genericParams = $generics.call($arity))

#set($gClass = "$rawClass$genericParams")

@FunctionalInterface

public interface $gClass extends $consumerArity.call($arity)$genericParams {

void compute($computeParams.call($arity));

@Override

default void accept($acceptParams.call($arity)) {

compute($computeArgs.call($arity));

}

}

#end##foreach($arity)

}