@Override
@SuppressWarnings("unchecked")
public synchronized void write(ArchivePacket packet) throws IOException {
if (!isOpen()) {
throw new IOException("not open");
}
if (out == null) {
throw new IOException("no output stream found");
}
if (packet == null || packet.payload() == null) {
throw new IOException("no payload to write for entry");
}
byte[] buf = packet.payload().toString().getBytes();
String name = ArchiveUtils.encodeArchiveEntryName(packet);
ArchiveEntry entry = out.newArchiveEntry();
entry.setName(name);
entry.setLastModified(new Date());
entry.setEntrySize(buf.length);
out.putArchiveEntry(entry);
out.write(buf);
out.closeArchiveEntry();
packetCounter++;
if (watcher.getBytesToTransfer() != 0
&& watcher.getBytesTransferred() > watcher.getBytesToTransfer()) {
logger.debug(
"bytes watcher: transferred = {}, rate {}",
watcher.getBytesTransferred(),
watcher.getRecentByteRatePerSecond());
switchToNextArchive();
watcher.resetWatcher();
}
}
/**
* Maps the OSG request type to the Walrus type, including BaseMessage handling for 'regarding'
* and correlationId mapping
*
* @param outputClass
* @param request
* @return
*/
public <O extends WalrusRequestType, I extends ObjectStorageRequestType> O proxyWalrusRequest(
Class<O> outputClass, I request) {
O outputRequest = (O) Classes.newInstance(outputClass);
outputRequest = (O) (MessageProxy.mapExcludeNulls(request, outputRequest));
outputRequest.regardingUserRequest(request);
return outputRequest;
}
@Override
public O serve(ServiceRequestContext ctx, I req) throws Exception {
final TraceData traceData = getTraceData(ctx, req);
final String method = req instanceof RpcRequest ? ((RpcRequest) req).method() : ctx.method();
final ServerRequestAdapter requestAdapter = new InternalServerRequestAdapter(method, traceData);
final ServerSpan serverSpan = serverInterceptor.openSpan(requestAdapter);
final boolean sampled;
if (serverSpan != null) {
ctx.onEnter(() -> serverInterceptor.setSpan(serverSpan));
ctx.onExit(serverInterceptor::clearSpan);
sampled = serverSpan.getSample();
} else {
sampled = false;
}
try {
final O res = delegate().serve(ctx, req);
if (sampled) {
ctx.requestLogFuture()
.thenAcceptBoth(
res.closeFuture(), (log, unused) -> closeSpan(ctx, serverSpan, log, res))
.exceptionally(CompletionActions::log);
}
return res;
} finally {
serverInterceptor.clearSpan();
}
}
@SuppressWarnings("unchecked")
private O createArchiveOutputStream(boolean overwrite) throws IOException {
O archiveOut;
FileOutputStream out;
if (!file.exists() || file.length() == 0 || overwrite) {
out = new FileOutputStream(file);
} else {
throw new FileNotFoundException(
"can't open for output, check existence or access rights: " + file.getAbsolutePath());
}
String pathStr = path.toString();
Set<String> streamCodecs = CompressCodecService.getCodecs();
for (String codec : streamCodecs) {
if (pathStr.endsWith("." + codec)) {
archiveOut =
(O)
archiveService
.getCodec(getName())
.createArchiveOutputStream(codecService.getCodec(codec).encode(out));
archiveOut.setWatcher(watcher);
return archiveOut;
}
}
archiveOut = (O) archiveService.getCodec(getName()).createArchiveOutputStream(out);
archiveOut.setWatcher(watcher);
return archiveOut;
}
/**
* A utility function that duplicates a set of objects.
*
* @param objects The set of object to be duplicated
* @return The set of duplicated objects
*/
@SuppressWarnings("unchecked")
private <O extends OWLObject> Set<O> duplicateSet(Set<O> objects) {
Set<O> dup = new HashSet<O>();
for (O o : objects) {
o.accept(this);
dup.add((O) obj);
}
return dup;
}
@Override
public O compute(I x, O output) {
if (constant == 0) {
output.setReal(dbzVal);
} else { // not dividing by zero
double value = x.getRealDouble() / constant;
output.setReal(value);
}
return output;
}
/**
* toString methode: creates a String representation of the object
*
* @return the String representation
* @author info.vancauwenberge.tostring plugin
*/
public String toString() {
StringBuffer buffer = new StringBuffer();
ArrayList keys = new ArrayList(hashtable.keySet());
Collections.sort(keys);
for (K key : (List<K>) keys) {
ArrayList<O> vals = get(key);
buffer.append(key.toString()).append("(").append(vals.size()).append(")").append(":\n");
for (O val : vals) {
buffer.append("\t").append(val.toString()).append("\n");
}
}
return buffer.toString();
}
@Override
public void addConnection(O connection, int direction) {
if (this.connections[direction] != connection) {
if (this.connections[direction] == null && this.canConnect(connection)) {
this.connections[direction] = connection;
connection.addConnection(this, ForgeDirection.OPPOSITES[direction]);
if (this.worldObj.isRemote) {
this.markDirty();
return;
}
if (connection.getNetwork() == null && this.network == null) {
this.makeNewNetwork();
this.network.addNode(connection);
} else {
if (connection.getNetwork() == null) {
this.network.addNode(connection);
} else if (this.network == null) {
connection.getNetwork().addNode(this);
}
}
} else this.verifyConnections();
this.markDirty();
}
/*int index = direction.getIndex();
if(this.connections[index] != connection){
if(this.connections[index] == null && this.canConnect(connection)) {
this.connections[index] = connection;
connection.addConnection(this, direction.getOpposite());
if(this.worldObj.isRemote) {
this.markDirty();
return;
}
if (connection.getNetwork() == null && this.network == null){
this.makeNewNetwork();
this.network.addNode(connection);
}
else{
if(connection.getNetwork() == null) {
this.network.addNode(connection);
}
else if (this.network == null){
connection.getNetwork().addNode(this);
}
}
}
else
this.verifyConnections();
this.markDirty();
}
*/
}
@Override
public void stop() {
try {
O killer = createO();
Pilot pilot = new Pilot();
pilot.setExtinguisher(true);
killer.setPilot(pilot);
for (Link<O> exit : exits) {
exit.getQueue().putFirst(killer);
}
} catch (Exception e) {
logger.log(Level.SEVERE, "Impossible to instanciate O", e);
}
this.stop = true;
}
@Override
public O compute(I x, O output) {
double xt = x.getRealDouble();
double value = 0.5 * Math.log((1 + xt) / (1 - xt));
output.setReal(value);
return output;
}
@Override
public O compute(I1 z1, I2 z2, O output) {
/*
optimized version (fewer multiplies) : from mathworld.com
seems to exhibit some rounding differences from textbook algorithm
double a = z1.getRealDouble();
double b = z1.getImaginaryDouble();
double c = z2.getRealDouble();
double d = z2.getImaginaryDouble();
double ac = a*c;
double bd = b*d;
double x = ac - bd;
double y = (a + b)*(c + d) - ac - bd;
*/
// textbook version : works
double x =
z1.getRealDouble() * z2.getRealDouble() - z1.getImaginaryDouble() * z2.getImaginaryDouble();
double y =
z1.getImaginaryDouble() * z2.getRealDouble() + z1.getRealDouble() * z2.getImaginaryDouble();
output.setComplexNumber(x, y);
return output;
}
/**
* Attaches the current local operation to the global operation so that operation runner can
* execute local operation post response later on.
*
* @param <O> subtype of Operation
* @param <L> subtype of LocalBackendOperation
* @param globalOperation the global operation to which local operation should be attached to
* @param currentLocalOperation the local operation to attach to the global operation
*/
@SuppressWarnings("unchecked")
public static <O extends Operation, L> void attachLocalOperation(
O globalOperation, L currentLocalOperation) {
List<?> existingAttachment =
(List<?>) globalOperation.getAttachment(Operation.LOCALBACKENDOPERATIONS);
List<L> newAttachment = new ArrayList<L>();
if (existingAttachment != null) {
// This line raises an unchecked conversion warning.
// There is nothing we can do to prevent this warning
// so let's get rid of it since we know the cast is safe.
newAttachment.addAll((List<L>) existingAttachment);
}
newAttachment.add(currentLocalOperation);
globalOperation.setAttachment(Operation.LOCALBACKENDOPERATIONS, newAttachment);
}
/**
* Get the verified id value for an object
*
* @param object for which to fetch the id
* @return the id
* @throws IllegalStateException if the id value could not be extracted
*/
protected final String getIdValueForObject(O object) {
String idValue = getIdValue(object);
if (idValue == null) {
throw new IllegalStateException(
"A call to idValue(Object) returned an illegal value: null for object: "
+ object.toString());
}
return idValue;
}
/*@ ensures \result != "";*/
public String toString() {
return leftNode.toString(Node.Placement.RIGHT)
+ "("
+ key.toString()
+ ","
+ obj.toString()
+ ")"
+ rightNode.toString(Node.Placement.LEFT);
}
@SuppressWarnings("unchecked")
<O, R> R convert(O input, Class<R> type) {
Class<O> inputType = (Class<O>) input.getClass();
if (inputType == type) {
return (R) input;
}
ETransformer<O, R> transformer = transformerManager.getTransformerSafe(inputType, type);
return transformer.from(input);
}
@Override
public void removeConnection(O connection) {
for (int i = 0; i < this.connections.length; i++) {
if (this.connections[i] == connection) {
this.connections[i] = null;
connection.removeConnection(this);
}
}
this.markDirty();
}
@Override
public O compute(I input, O output) {
double x = input.getRealDouble();
double value;
if (x == 0) value = 1;
else value = Math.sin(x) / x;
output.setReal(value);
return output;
}
@SuppressWarnings("unchecked")
<O, R> List<R> convert(Iterable<O> inputs, Class<R> type) {
Iterator<O> iterator = inputs.iterator();
if (!iterator.hasNext()) {
return Collections.emptyList();
}
List<R> results = new ArrayList<R>();
ETransformer<O, R> transformer = null;
for (O t : inputs) {
if (transformer == null) {
Class<O> inputType = (Class<O>) t.getClass();
transformer = transformerManager.getTransformerSafe(inputType, type);
}
results.add(transformer.from(t));
}
return results;
}
private static <I extends StreamSourceChannel, O extends StreamSinkChannel> void done(
I source,
O sink,
ChannelListener<? super I> sourceListener,
ChannelListener<? super O> sinkListener) {
Channels.setReadListener(source, sourceListener);
if (sourceListener == null) {
source.suspendReads();
} else {
source.wakeupReads();
}
Channels.setWriteListener(sink, sinkListener);
if (sinkListener == null) {
sink.suspendWrites();
} else {
sink.wakeupWrites();
}
}
/**
* Get and check proper text value
*
* @param object object for which to get the text value
* @return return the verified text value
* @throws IllegalStateException if the text value could not be extracted
*/
protected final String getTextValueForObject(O object) {
String textValue = getTextValue(object);
textValue = textValue.replaceAll("\\\"", """);
if (textValue == null) {
throw new IllegalStateException(
"A call to textValue(Object) returned an illegal value: null for object: "
+ object.toString());
}
return textValue;
}
public void addOperation(O operation) {
operations.add(operation);
// put it in our properties so it gets stored properly in inventory
final String opsPropName = "operations";
List<Map<String, Object>> ops = (List<Map<String, Object>>) getProperties().get(opsPropName);
if (ops == null) {
ops = new ArrayList<>();
addProperty(opsPropName, ops);
}
ops.add(operation.getProperties());
}
public final void save(File target) {
if (target == null) {
throw new IllegalArgumentException("A reflected cannot be saved without a valid file!");
}
O os = null;
try {
os = getCodec().newOutput(target);
this.save(os);
this.onSaved(target);
} catch (IOException e) {
throw new InvalidReflectedObjectException("File to save into cannot be accessed!", e);
} finally {
if (os != null) {
try {
os.close();
} catch (IOException e) {
Reflector.LOGGER.log(WARNING, "Failed to close the output stream", e);
}
}
}
}
/**
* Begin traversing the graph.
*
* @param visitor Visitor this walker is being used by.
* @throws VisitorException if an error is encountered while walking.
*/
@SuppressWarnings("unchecked")
public void walk(PlanVisitor<O, P> visitor) throws VisitorException {
// This is highly inefficient, but our graphs are small so it should be okay.
// The algorithm works by starting at any node in the graph, finding it's
// predecessors and calling itself for each of those predecessors. When it
// finds a node that has no unfinished predecessors it puts that node in the
// list. It then unwinds itself putting each of the other nodes in the list.
// It keeps track of what nodes it's seen as it goes so it doesn't put any
// nodes in the graph twice.
List<O> fifo = new ArrayList<O>();
Set<O> seen = new HashSet<O>();
List<O> leaves = mPlan.getLeaves();
if (leaves == null) return;
for (O op : leaves) {
doAllPredecessors(op, seen, fifo);
}
for (O op : fifo) {
op.visit(visitor);
}
}
public CrossReference toCrossReference(O cvObject) {
if (cvObject == null) {
throw new IllegalArgumentException("CvObject must not be null. ");
}
// name of the cv is the fullname
String text =
cvObject.getFullName() != null ? cvObject.getFullName() : cvObject.getShortLabel();
String identity = cvObject.getIdentifier();
if (identity == null) {
throw new NullPointerException(
cvObject.getClass().getSimpleName() + "(" + text + ") didn't have an identity");
}
final CvObjectXref idXref =
findMatchingIdentityXref(
cvObject.getXrefs(),
identity); // XrefUtils.getIdentityXref(cvObject, CvDatabase.PSI_MI_MI_REF);
if (idXref != null) {
try {
CrossReference ref = crossRefConverter.createCrossReference(idXref, false);
ref.setText(text);
return ref;
} catch (Exception e) {
throw new RuntimeException("An exception occured while building a cv object : " + text, e);
}
} else {
CrossReference ref =
new CrossReferenceImpl(CrossReferenceConverter.DATABASE_UNKNOWN, identity, text);
return ref;
}
}
@SuppressWarnings({
"unchecked",
"rawtypes"
}) // OK, because type.isEnum() is checked before casting to Enum
private static <O> void applySetters(
final O instance, final Map<String, Method> methodMap, final Map<String, String> attributes) {
for (Map.Entry<String, String> attribute : attributes.entrySet()) {
final String methodName = attribute.getKey().toLowerCase();
final Method method = methodMap.get(methodName);
if (null == method) {
throw new MetafactureException(
"Method '"
+ methodName
+ "' does not exist in '"
+ instance.getClass().getSimpleName()
+ "'!");
}
final Class<?> type = method.getParameterTypes()[0];
try {
if (type == boolean.class) {
method.invoke(instance, Boolean.valueOf(attribute.getValue()));
} else if (type == int.class) {
method.invoke(instance, Integer.valueOf(attribute.getValue()));
} else if (type.isEnum()) {
method.invoke(
instance, Enum.valueOf((Class<Enum>) type, attribute.getValue().toUpperCase()));
} else {
method.invoke(instance, attribute.getValue());
}
} catch (IllegalArgumentException e) {
setMethodError(methodName, instance.getClass().getSimpleName(), e);
} catch (IllegalAccessException e) {
setMethodError(methodName, instance.getClass().getSimpleName(), e);
} catch (InvocationTargetException e) {
setMethodError(methodName, instance.getClass().getSimpleName(), e);
}
}
}
@Override
public synchronized void close() throws IOException {
if (!isOpen) {
return;
}
if (out != null) {
out.close();
}
if (in != null) {
in.close();
}
this.isOpen = false;
}
public Pair(O anOWLObject, O anotherOWLObject) {
if (anOWLObject == null) {
throw new NullPointerException("The first memebr of this pair cannot be null");
}
if (anotherOWLObject == null) {
throw new NullPointerException("The second memebr of this pair cannot be null");
}
if (anotherOWLObject.equals(anOWLObject)) {
throw new IllegalArgumentException("The pair is meant to be made of two distic entities");
}
this.members.add(anOWLObject);
this.members.add(anotherOWLObject);
}
/**
* Pass one turn. This invokes the tick() method for all Organisms, and invokes general death and
* replication rules.
*/
public void tick() {
this.time++;
// Make time pass for Organisms
for (O o : this.getPopulation()) o.tick(this);
// Kill dying Organisms
for (SelectionRule<O> rule : this.settings.getDeathRules())
for (O o : rule.select(this)) this.new Kill(o);
// Split splitting Organisms
for (SelectionRule<O> rule : this.settings.getSplittingRules())
for (O o : rule.select(this)) this.new Split(o);
// Reproduce sexy Organisms
for (PairSelectionRule<O> rule : this.settings.getSexyRules())
for (Pair<O, O> p : rule.select(this)) this.new Hump(p.left, p.right);
// Execute Actions
for (Action a : this.actions) a.execute();
this.actions.clear();
}
@Override
public void compute1(final IterableInterval<I> input, final O output) {
double moment10 = 0;
final Cursor<I> cur = input.localizingCursor();
while (cur.hasNext()) {
cur.fwd();
double x = cur.getDoublePosition(0);
double val = cur.get().getRealDouble();
moment10 += x * val;
}
output.setReal(moment10);
}
/**
* Append the given object to the given array, returning a new array consisting of the input array
* contents plus the given object.
*
* @param array the array to append to (can be {@code null})
* @param obj the object to append
* @return the new array (of the same component type; never {@code null})
*/
public static <A, O extends A> A[] addObjectToArray(A[] array, O obj) {
Class<?> compType = Object.class;
if (array != null) {
compType = array.getClass().getComponentType();
} else if (obj != null) {
compType = obj.getClass();
}
int newArrLength = (array != null ? array.length + 1 : 1);
@SuppressWarnings("unchecked")
A[] newArr = (A[]) Array.newInstance(compType, newArrLength);
if (array != null) {
System.arraycopy(array, 0, newArr, 0, array.length);
}
newArr[newArr.length - 1] = obj;
return newArr;
}
