code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
public void cleanDatabase() {
lockingMechanism.writeLock().lock();
try {
for (ODocument edge : graph.browseEdges()) {
edge.delete();
}
for (ODocument node : graph.browseVertices()) {
node.delete();
}
} finally {
lockingMechanism.writeLock().unlock();
}
} | java |
private void checkTransformationDescriptionId(TransformationDescription description) {
if (description.getId() == null) {
description.setId("EKBInternal-" + counter.incrementAndGet());
}
} | java |
private List<ODocument> getEdgesBetweenModels(String source, String target) {
ODocument from = getModel(source);
ODocument to = getModel(target);
String query = "select from E where out = ? AND in = ?";
return graph.query(new OSQLSynchQuery<ODocument>(query), from, to);
} | java |
private List<ODocument> getNeighborsOfModel(String model) {
String query = String.format("select from Models where in.out.%s in [?]", OGraphDatabase.LABEL);
List<ODocument> neighbors = graph.query(new OSQLSynchQuery<ODocument>(query), model);
return neighbors;
} | java |
private ODocument getOrCreateModel(String model) {
ODocument node = getModel(model);
if (node == null) {
node = graph.createVertex("Models");
OrientModelGraphUtils.setIdFieldValue(node, model.toString());
OrientModelGraphUtils.setActiveFieldValue(node, false);
node.save();
}
return node;
} | java |
private ODocument getModel(String model) {
String query = String.format("select from Models where %s = ?", OGraphDatabase.LABEL);
List<ODocument> from = graph.query(new OSQLSynchQuery<ODocument>(query), model);
if (from.size() > 0) {
return from.get(0);
} else {
return null;
}
} | java |
private List<ODocument> recursivePathSearch(String start, String end, List<String> ids, ODocument... steps) {
List<ODocument> neighbors = getNeighborsOfModel(start);
for (ODocument neighbor : neighbors) {
if (alreadyVisited(neighbor, steps) || !OrientModelGraphUtils.getActiveFieldValue(neighbor)) {
continue;
}
ODocument nextStep = getEdgeWithPossibleId(start, OrientModelGraphUtils.getIdFieldValue(neighbor), ids);
if (nextStep == null) {
continue;
}
if (OrientModelGraphUtils.getIdFieldValue(neighbor).equals(end)) {
List<ODocument> result = new ArrayList<ODocument>();
List<String> copyIds = new ArrayList<String>(ids);
for (ODocument step : steps) {
String id = OrientModelGraphUtils.getIdFieldValue(step);
if (id != null && copyIds.contains(id)) {
copyIds.remove(id);
}
result.add(step);
}
String id = OrientModelGraphUtils.getIdFieldValue(nextStep);
if (id != null && copyIds.contains(id)) {
copyIds.remove(id);
}
result.add(nextStep);
if (copyIds.isEmpty()) {
return result;
}
}
ODocument[] path = Arrays.copyOf(steps, steps.length + 1);
path[path.length - 1] = nextStep;
List<ODocument> check =
recursivePathSearch(OrientModelGraphUtils.getIdFieldValue(neighbor), end, ids, path);
if (check != null) {
return check;
}
}
return null;
} | java |
private ODocument getEdgeWithPossibleId(String start, String end, List<String> ids) {
List<ODocument> edges = getEdgesBetweenModels(start, end);
for (ODocument edge : edges) {
if (ids.contains(OrientModelGraphUtils.getIdFieldValue(edge))) {
return edge;
}
}
return edges.size() != 0 ? edges.get(0) : null;
} | java |
private boolean alreadyVisited(ODocument neighbor, ODocument[] steps) {
for (ODocument step : steps) {
ODocument out = graph.getOutVertex(step);
if (out.equals(neighbor)) {
return true;
}
}
return false;
} | java |
public boolean isModelActive(ModelDescription model) {
lockingMechanism.readLock().lock();
try {
ODocument node = getModel(model.toString());
return OrientModelGraphUtils.getActiveFieldValue(node);
} finally {
lockingMechanism.readLock().unlock();
}
} | java |
protected com.sun.jersey.api.client.Client getJerseyClient() {
final ClientConfig clientConfig = new DefaultClientConfig();
clientConfig.getFeatures().put(JSONConfiguration.FEATURE_POJO_MAPPING, Boolean.TRUE);
com.sun.jersey.api.client.Client client = com.sun.jersey.api.client.Client.create(clientConfig);
if(this.debug) {
client.addFilter(new LoggingFilter(System.out));
}
return client;
} | java |
public static boolean isEmpty(final Collection<String> c) {
if (c == null || c.isEmpty()) {
return false;
}
for (final String text : c) {
if (isNotEmpty(text)) {
return false;
}
}
return true;
} | java |
public static boolean isBlank(final Collection<String> c) {
if (c == null || c.isEmpty()) {
return false;
}
for (final String text : c) {
if (isNotBlank(text)) {
return false;
}
}
return true;
} | java |
private boolean hello(InetAddress broadcast) {
if (socket == null) return false;
Command hello = new Command();
byte[] helloMsg = hello.create();
DatagramPacket packet;
if (ip == null){
if (this.acceptableModels == null) return false;
packet = new DatagramPacket(helloMsg, helloMsg.length, broadcast, PORT);
} else {
packet = new DatagramPacket(helloMsg, helloMsg.length, ip, PORT);
}
try {
socket.send(packet);
} catch (IOException e) {
return false;
}
packet = new DatagramPacket(rcv, rcv.length);
try {
socket.receive(packet);
} catch (IOException e) {
return false;
}
if (ip == null){
ip = packet.getAddress();
}
byte[] worker = new byte[2];
System.arraycopy(rcv, 2, worker, 0, 2);
int length = (int)ByteArray.fromBytes(worker);
worker = new byte[length];
System.arraycopy(rcv, 0, worker, 0, length);
Response response;
try {
response = new Response(worker, null);
} catch (CommandExecutionException e) {
return false;
}
if (token == null){
if (!(response.getToken().equals(new Token("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",16)) || response.getToken().equals(new Token("00000000000000000000000000000000",16)))) {
token = response.getToken();
} else {
return false;
}
}
if (!((response.getDeviceID() == -1) || (response.getTimeStamp() == -1))){
deviceID = response.getDeviceID();
timeStamp = response.getTimeStamp();
methodID = timeStamp & 0b1111111111111; // Possible collision about every 2 hours > acceptable
if (this.acceptableModels != null){
boolean modelOk = false;
for (String s: this.acceptableModels) {
try {
if (s.equals(model())) modelOk = true;
} catch (CommandExecutionException ignored) {
}
}
return modelOk;
}
return true;
}
return false;
} | java |
public boolean discover(){
boolean helloResponse = false;
for (int helloRetries = this.retries; helloRetries >= 0; helloRetries--) {
List<InetAddress> broadcast = listAllBroadcastAddresses();
if (broadcast == null) return false;
for (InetAddress i : broadcast) {
if (hello(i)) {
helloResponse = true;
break;
}
}
if (helloResponse) break;
}
return helloResponse;
} | java |
public String send(String payload) throws CommandExecutionException {
if (payload == null) throw new CommandExecutionException(CommandExecutionException.Error.INVALID_PARAMETERS);
if (deviceID == -1 || timeStamp == -1 || token == null || ip == null) {
if (!discover()) throw new CommandExecutionException(CommandExecutionException.Error.DEVICE_NOT_FOUND);
}
if (methodID >= 10000) methodID = 1;
if (ip == null || token == null) throw new CommandExecutionException(CommandExecutionException.Error.IP_OR_TOKEN_UNKNOWN);
if (socket == null) return null;
timeStamp++;
Command msg = new Command(this.token,this.deviceID,timeStamp,this.methodID,"", null);
methodID++;
int retriesLeft = this.retries;
while (true) {
try {
byte[] resp = send(msg.create(payload));
if (!Response.testMessage(resp, this.token)) throw new CommandExecutionException(CommandExecutionException.Error.INVALID_RESPONSE);
if (resp.length > 0x20) {
byte[] pl = new byte[resp.length - 0x20];
System.arraycopy(resp, 0x20, pl, 0, pl.length);
String payloadString = Response.decryptPayload(pl, this.token);
if (payloadString == null) throw new CommandExecutionException(CommandExecutionException.Error.INVALID_RESPONSE);
return payloadString;
}
} catch (CommandExecutionException e) {
if (retriesLeft > 0){
retriesLeft--;
continue;
}
throw e;
}
}
} | java |
public boolean update(String url, String md5) throws CommandExecutionException {
if (url == null || md5 == null) throw new CommandExecutionException(CommandExecutionException.Error.INVALID_PARAMETERS);
if (md5.length() != 32) throw new CommandExecutionException(CommandExecutionException.Error.INVALID_PARAMETERS);
JSONObject params = new JSONObject();
params.put("mode","normal");
params.put("install", "1");
params.put("app_url", url);
params.put("file_md5", md5);
params.put("proc", "dnld install");
return sendOk("miIO.ota", params);
} | java |
public int updateProgress() throws CommandExecutionException {
int resp = sendToArray("miIO.get_ota_progress").optInt(0, -1);
if ((resp < 0) || (resp > 100)) throw new CommandExecutionException(CommandExecutionException.Error.INVALID_RESPONSE);
return resp;
} | java |
public String updateStatus() throws CommandExecutionException {
String resp = sendToArray("miIO.get_ota_state").optString(0, null);
if (resp == null) throw new CommandExecutionException(CommandExecutionException.Error.INVALID_RESPONSE);
return resp;
} | java |
public String model() throws CommandExecutionException {
JSONObject in = info();
if (in == null) throw new CommandExecutionException(CommandExecutionException.Error.INVALID_RESPONSE);
return in.optString("model");
} | java |
public static byte[] hexToBytes(String s) {
try {
if (s == null) return new byte[0];
s = s.toUpperCase();
int len = s.length();
byte[] data = new byte[len / 2];
for (int i = 0; i < len; i += 2) {
data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
+ Character.digit(s.charAt(i + 1), 16));
}
return data;
} catch (StringIndexOutOfBoundsException e) {
return null;
}
} | java |
public static byte[] append(byte[] first, byte[] second) {
if ((first == null) || (second == null)) return null;
byte[] output = new byte[first.length + second.length];
System.arraycopy(first, 0, output, 0, first.length);
System.arraycopy(second, 0, output, first.length, second.length);
return output;
} | java |
public static byte[] toBytes(long value, int length) {
if (length <= 0) return new byte[0];
if (length > 8) length = 8;
byte[] out = new byte[length];
for (int i = length - 1; i >= 0; i--){
out[i] = (byte)(value & 0xFFL);
value = value >> 8;
}
return out;
} | java |
public static long fromBytes(byte[] value){
if (value == null) return 0;
long out = 0;
int length = value.length;
if (length > 8) length = 8;
for (int i = 0; i < length; i++){
out = (out << 8) + (value[i] & 0xff);
}
return out;
} | java |
protected final void acceptAnnotations(final MethodVisitor mv) {
int n = visibleTypeAnnotations == null ? 0 : visibleTypeAnnotations
.size();
for (int i = 0; i < n; ++i) {
TypeAnnotationNode an = visibleTypeAnnotations.get(i);
an.accept(mv.visitInsnAnnotation(an.typeRef, an.typePath, an.desc,
true));
}
n = invisibleTypeAnnotations == null ? 0 : invisibleTypeAnnotations
.size();
for (int i = 0; i < n; ++i) {
TypeAnnotationNode an = invisibleTypeAnnotations.get(i);
an.accept(mv.visitInsnAnnotation(an.typeRef, an.typePath, an.desc,
false));
}
} | java |
protected final AbstractInsnNode cloneAnnotations(
final AbstractInsnNode insn) {
if (insn.visibleTypeAnnotations != null) {
this.visibleTypeAnnotations = new ArrayList<TypeAnnotationNode>();
for (int i = 0; i < insn.visibleTypeAnnotations.size(); ++i) {
TypeAnnotationNode src = insn.visibleTypeAnnotations.get(i);
TypeAnnotationNode ann = new TypeAnnotationNode(src.typeRef,
src.typePath, src.desc);
src.accept(ann);
this.visibleTypeAnnotations.add(ann);
}
}
if (insn.invisibleTypeAnnotations != null) {
this.invisibleTypeAnnotations = new ArrayList<TypeAnnotationNode>();
for (int i = 0; i < insn.invisibleTypeAnnotations.size(); ++i) {
TypeAnnotationNode src = insn.invisibleTypeAnnotations.get(i);
TypeAnnotationNode ann = new TypeAnnotationNode(src.typeRef,
src.typePath, src.desc);
src.accept(ann);
this.invisibleTypeAnnotations.add(ann);
}
}
return this;
} | java |
public String getDebugInfo() {
StringBuilder sb = new StringBuilder("\r\n========BeanBox Debug for " + this + "===========\r\n");
sb.append("target=" + this.target).append("\r\n");
sb.append("pureValue=" + this.pureValue).append("\r\n");
sb.append("type=" + this.type).append("\r\n");
sb.append("required=" + this.required).append("\r\n");
sb.append("beanClass=" + this.beanClass).append("\r\n");
sb.append("singleton=" + this.singleton).append("\r\n");
sb.append("methodAops=" + this.methodAops).append("\r\n");
sb.append("methodAopRules=" + this.aopRules).append("\r\n");
sb.append("constructor=" + this.constructor).append("\r\n");
sb.append("constructorParams=" + this.constructorParams).append("\r\n");
sb.append("postConstructs=" + this.postConstruct).append("\r\n");
sb.append("preDestorys=" + this.preDestroy).append("\r\n");
sb.append("fieldInjects=" + this.fieldInjects).append("\r\n");
sb.append("methodInjects=" + this.methodInjects).append("\r\n");
sb.append("createMethod=" + this.createMethod).append("\r\n");
sb.append("configMethod=" + this.configMethod).append("\r\n");
sb.append("========BeanBox Debug Info End===========");
return sb.toString();
} | java |
public synchronized BeanBox addBeanAop(Object aop, String methodNameRegex) {
checkOrCreateMethodAopRules();
aopRules.add(new Object[] { BeanBoxUtils.checkAOP(aop), methodNameRegex });
return this;
} | java |
public BeanBox injectField(String fieldName, Object inject) {
BeanBox box = BeanBoxUtils.wrapParamToBox(inject);
checkOrCreateFieldInjects();
Field f = ReflectionUtils.findField(beanClass, fieldName);
box.setType(f.getType());
ReflectionUtils.makeAccessible(f);
this.getFieldInjects().put(f, box);
return this;
} | java |
public BeanBox injectValue(String fieldName, Object constValue) {
checkOrCreateFieldInjects();
Field f = ReflectionUtils.findField(beanClass, fieldName);
BeanBox inject = new BeanBox();
inject.setTarget(constValue);
inject.setType(f.getType());
inject.setPureValue(true);
ReflectionUtils.makeAccessible(f);
this.getFieldInjects().put(f, inject);
return this;
} | java |
public void updateIndex(final int index) {
int newTypeRef = 0x42000000 | (index << 8);
if (visibleTypeAnnotations != null) {
for (TypeAnnotationNode tan : visibleTypeAnnotations) {
tan.typeRef = newTypeRef;
}
}
if (invisibleTypeAnnotations != null) {
for (TypeAnnotationNode tan : invisibleTypeAnnotations) {
tan.typeRef = newTypeRef;
}
}
} | java |
public void accept(final MethodVisitor mv) {
mv.visitTryCatchBlock(start.getLabel(), end.getLabel(),
handler == null ? null : handler.getLabel(), type);
int n = visibleTypeAnnotations == null ? 0 : visibleTypeAnnotations
.size();
for (int i = 0; i < n; ++i) {
TypeAnnotationNode an = visibleTypeAnnotations.get(i);
an.accept(mv.visitTryCatchAnnotation(an.typeRef, an.typePath,
an.desc, true));
}
n = invisibleTypeAnnotations == null ? 0 : invisibleTypeAnnotations
.size();
for (int i = 0; i < n; ++i) {
TypeAnnotationNode an = invisibleTypeAnnotations.get(i);
an.accept(mv.visitTryCatchAnnotation(an.typeRef, an.typePath,
an.desc, false));
}
} | java |
@Override
public void visitFormalTypeParameter(final String name) {
if (type == TYPE_SIGNATURE
|| (state != EMPTY && state != FORMAL && state != BOUND)) {
throw new IllegalStateException();
}
CheckMethodAdapter.checkIdentifier(name, "formal type parameter");
state = FORMAL;
if (sv != null) {
sv.visitFormalTypeParameter(name);
}
} | java |
static void appendConstant(final StringBuffer buf, final Object cst) {
if (cst == null) {
buf.append("null");
} else if (cst instanceof String) {
appendString(buf, (String) cst);
} else if (cst instanceof Type) {
buf.append("Type.getType(\"");
buf.append(((Type) cst).getDescriptor());
buf.append("\")");
} else if (cst instanceof Handle) {
buf.append("new Handle(");
Handle h = (Handle) cst;
buf.append("Opcodes.").append(HANDLE_TAG[h.getTag()])
.append(", \"");
buf.append(h.getOwner()).append("\", \"");
buf.append(h.getName()).append("\", \"");
buf.append(h.getDesc()).append("\")");
} else if (cst instanceof Byte) {
buf.append("new Byte((byte)").append(cst).append(')');
} else if (cst instanceof Boolean) {
buf.append(((Boolean) cst).booleanValue() ? "Boolean.TRUE"
: "Boolean.FALSE");
} else if (cst instanceof Short) {
buf.append("new Short((short)").append(cst).append(')');
} else if (cst instanceof Character) {
int c = ((Character) cst).charValue();
buf.append("new Character((char)").append(c).append(')');
} else if (cst instanceof Integer) {
buf.append("new Integer(").append(cst).append(')');
} else if (cst instanceof Float) {
buf.append("new Float(\"").append(cst).append("\")");
} else if (cst instanceof Long) {
buf.append("new Long(").append(cst).append("L)");
} else if (cst instanceof Double) {
buf.append("new Double(\"").append(cst).append("\")");
} else if (cst instanceof byte[]) {
byte[] v = (byte[]) cst;
buf.append("new byte[] {");
for (int i = 0; i < v.length; i++) {
buf.append(i == 0 ? "" : ",").append(v[i]);
}
buf.append('}');
} | java |
public static void verify(final ClassReader cr, final ClassLoader loader,
final boolean dump, final PrintWriter pw) {
ClassNode cn = new ClassNode();
cr.accept(new CheckClassAdapter(cn, false), ClassReader.SKIP_DEBUG);
Type syperType = cn.superName == null ? null : Type
.getObjectType(cn.superName);
List<MethodNode> methods = cn.methods;
List<Type> interfaces = new ArrayList<Type>();
for (Iterator<String> i = cn.interfaces.iterator(); i.hasNext();) {
interfaces.add(Type.getObjectType(i.next()));
}
for (int i = 0; i < methods.size(); ++i) {
MethodNode method = methods.get(i);
SimpleVerifier verifier = new SimpleVerifier(
Type.getObjectType(cn.name), syperType, interfaces,
(cn.access & Opcodes.ACC_INTERFACE) != 0);
Analyzer<BasicValue> a = new Analyzer<BasicValue>(verifier);
if (loader != null) {
verifier.setClassLoader(loader);
}
try {
a.analyze(cn.name, method);
if (!dump) {
continue;
}
} catch (Exception e) {
e.printStackTrace(pw);
}
printAnalyzerResult(method, a, pw);
}
pw.flush();
} | java |
public static void verify(final ClassReader cr, final boolean dump,
final PrintWriter pw) {
verify(cr, null, dump, pw);
} | java |
static void checkAccess(final int access, final int possibleAccess) {
if ((access & ~possibleAccess) != 0) {
throw new IllegalArgumentException("Invalid access flags: "
+ access);
}
int pub = (access & Opcodes.ACC_PUBLIC) == 0 ? 0 : 1;
int pri = (access & Opcodes.ACC_PRIVATE) == 0 ? 0 : 1;
int pro = (access & Opcodes.ACC_PROTECTED) == 0 ? 0 : 1;
if (pub + pri + pro > 1) {
throw new IllegalArgumentException(
"public private and protected are mutually exclusive: "
+ access);
}
int fin = (access & Opcodes.ACC_FINAL) == 0 ? 0 : 1;
int abs = (access & Opcodes.ACC_ABSTRACT) == 0 ? 0 : 1;
if (fin + abs > 1) {
throw new IllegalArgumentException(
"final and abstract are mutually exclusive: " + access);
}
} | java |
public static void checkClassSignature(final String signature) {
// ClassSignature:
// FormalTypeParameters? ClassTypeSignature ClassTypeSignature*
int pos = 0;
if (getChar(signature, 0) == '<') {
pos = checkFormalTypeParameters(signature, pos);
}
pos = checkClassTypeSignature(signature, pos);
while (getChar(signature, pos) == 'L') {
pos = checkClassTypeSignature(signature, pos);
}
if (pos != signature.length()) {
throw new IllegalArgumentException(signature + ": error at index "
+ pos);
}
} | java |
public static void checkMethodSignature(final String signature) {
// MethodTypeSignature:
// FormalTypeParameters? ( TypeSignature* ) ( TypeSignature | V ) (
// ^ClassTypeSignature | ^TypeVariableSignature )*
int pos = 0;
if (getChar(signature, 0) == '<') {
pos = checkFormalTypeParameters(signature, pos);
}
pos = checkChar('(', signature, pos);
while ("ZCBSIFJDL[T".indexOf(getChar(signature, pos)) != -1) {
pos = checkTypeSignature(signature, pos);
}
pos = checkChar(')', signature, pos);
if (getChar(signature, pos) == 'V') {
++pos;
} else {
pos = checkTypeSignature(signature, pos);
}
while (getChar(signature, pos) == '^') {
++pos;
if (getChar(signature, pos) == 'L') {
pos = checkClassTypeSignature(signature, pos);
} else {
pos = checkTypeVariableSignature(signature, pos);
}
}
if (pos != signature.length()) {
throw new IllegalArgumentException(signature + ": error at index "
+ pos);
}
} | java |
public static void checkFieldSignature(final String signature) {
int pos = checkFieldTypeSignature(signature, 0);
if (pos != signature.length()) {
throw new IllegalArgumentException(signature + ": error at index "
+ pos);
}
} | java |
static void checkTypeRefAndPath(int typeRef, TypePath typePath) {
int mask = 0;
switch (typeRef >>> 24) {
case TypeReference.CLASS_TYPE_PARAMETER:
case TypeReference.METHOD_TYPE_PARAMETER:
case TypeReference.METHOD_FORMAL_PARAMETER:
mask = 0xFFFF0000;
break;
case TypeReference.FIELD:
case TypeReference.METHOD_RETURN:
case TypeReference.METHOD_RECEIVER:
case TypeReference.LOCAL_VARIABLE:
case TypeReference.RESOURCE_VARIABLE:
case TypeReference.INSTANCEOF:
case TypeReference.NEW:
case TypeReference.CONSTRUCTOR_REFERENCE:
case TypeReference.METHOD_REFERENCE:
mask = 0xFF000000;
break;
case TypeReference.CLASS_EXTENDS:
case TypeReference.CLASS_TYPE_PARAMETER_BOUND:
case TypeReference.METHOD_TYPE_PARAMETER_BOUND:
case TypeReference.THROWS:
case TypeReference.EXCEPTION_PARAMETER:
mask = 0xFFFFFF00;
break;
case TypeReference.CAST:
case TypeReference.CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
case TypeReference.METHOD_INVOCATION_TYPE_ARGUMENT:
case TypeReference.CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:
case TypeReference.METHOD_REFERENCE_TYPE_ARGUMENT:
mask = 0xFF0000FF;
break;
default:
throw new IllegalArgumentException("Invalid type reference sort 0x"
+ Integer.toHexString(typeRef >>> 24));
}
if ((typeRef & ~mask) != 0) {
throw new IllegalArgumentException("Invalid type reference 0x"
+ Integer.toHexString(typeRef));
}
if (typePath != null) {
for (int i = 0; i < typePath.getLength(); ++i) {
int step = typePath.getStep(i);
if (step != TypePath.ARRAY_ELEMENT
&& step != TypePath.INNER_TYPE
&& step != TypePath.TYPE_ARGUMENT
&& step != TypePath.WILDCARD_BOUND) {
throw new IllegalArgumentException(
"Invalid type path step " + i + " in " + typePath);
}
if (step != TypePath.TYPE_ARGUMENT
&& typePath.getStepArgument(i) != 0) {
throw new IllegalArgumentException(
"Invalid type path step argument for step " + i
+ " in " + typePath);
}
}
}
} | java |
private static int checkFormalTypeParameters(final String signature, int pos) {
// FormalTypeParameters:
// < FormalTypeParameter+ >
pos = checkChar('<', signature, pos);
pos = checkFormalTypeParameter(signature, pos);
while (getChar(signature, pos) != '>') {
pos = checkFormalTypeParameter(signature, pos);
}
return pos + 1;
} | java |
private static int checkFormalTypeParameter(final String signature, int pos) {
// FormalTypeParameter:
// Identifier : FieldTypeSignature? (: FieldTypeSignature)*
pos = checkIdentifier(signature, pos);
pos = checkChar(':', signature, pos);
if ("L[T".indexOf(getChar(signature, pos)) != -1) {
pos = checkFieldTypeSignature(signature, pos);
}
while (getChar(signature, pos) == ':') {
pos = checkFieldTypeSignature(signature, pos + 1);
}
return pos;
} | java |
private static int checkFieldTypeSignature(final String signature, int pos) {
// FieldTypeSignature:
// ClassTypeSignature | ArrayTypeSignature | TypeVariableSignature
//
// ArrayTypeSignature:
// [ TypeSignature
switch (getChar(signature, pos)) {
case 'L':
return checkClassTypeSignature(signature, pos);
case '[':
return checkTypeSignature(signature, pos + 1);
default:
return checkTypeVariableSignature(signature, pos);
}
} | java |
private static int checkClassTypeSignature(final String signature, int pos) {
// ClassTypeSignature:
// L Identifier ( / Identifier )* TypeArguments? ( . Identifier
// TypeArguments? )* ;
pos = checkChar('L', signature, pos);
pos = checkIdentifier(signature, pos);
while (getChar(signature, pos) == '/') {
pos = checkIdentifier(signature, pos + 1);
}
if (getChar(signature, pos) == '<') {
pos = checkTypeArguments(signature, pos);
}
while (getChar(signature, pos) == '.') {
pos = checkIdentifier(signature, pos + 1);
if (getChar(signature, pos) == '<') {
pos = checkTypeArguments(signature, pos);
}
}
return checkChar(';', signature, pos);
} | java |
private static int checkTypeArguments(final String signature, int pos) {
// TypeArguments:
// < TypeArgument+ >
pos = checkChar('<', signature, pos);
pos = checkTypeArgument(signature, pos);
while (getChar(signature, pos) != '>') {
pos = checkTypeArgument(signature, pos);
}
return pos + 1;
} | java |
private static int checkTypeArgument(final String signature, int pos) {
// TypeArgument:
// * | ( ( + | - )? FieldTypeSignature )
char c = getChar(signature, pos);
if (c == '*') {
return pos + 1;
} else if (c == '+' || c == '-') {
pos++;
}
return checkFieldTypeSignature(signature, pos);
} | java |
private static int checkTypeVariableSignature(final String signature,
int pos) {
// TypeVariableSignature:
// T Identifier ;
pos = checkChar('T', signature, pos);
pos = checkIdentifier(signature, pos);
return checkChar(';', signature, pos);
} | java |
private static int checkTypeSignature(final String signature, int pos) {
// TypeSignature:
// Z | C | B | S | I | F | J | D | FieldTypeSignature
switch (getChar(signature, pos)) {
case 'Z':
case 'C':
case 'B':
case 'S':
case 'I':
case 'F':
case 'J':
case 'D':
return pos + 1;
default:
return checkFieldTypeSignature(signature, pos);
}
} | java |
private static int checkIdentifier(final String signature, int pos) {
if (!Character.isJavaIdentifierStart(getChar(signature, pos))) {
throw new IllegalArgumentException(signature
+ ": identifier expected at index " + pos);
}
++pos;
while (Character.isJavaIdentifierPart(getChar(signature, pos))) {
++pos;
}
return pos;
} | java |
private static int checkChar(final char c, final String signature, int pos) {
if (getChar(signature, pos) == c) {
return pos + 1;
}
throw new IllegalArgumentException(signature + ": '" + c
+ "' expected at index " + pos);
} | java |
private static char getChar(final String signature, int pos) {
return pos < signature.length() ? signature.charAt(pos) : (char) 0;
} | java |
public void accept(final MethodVisitor mv, boolean visible) {
Label[] start = new Label[this.start.size()];
Label[] end = new Label[this.end.size()];
int[] index = new int[this.index.size()];
for (int i = 0; i < start.length; ++i) {
start[i] = this.start.get(i).getLabel();
end[i] = this.end.get(i).getLabel();
index[i] = this.index.get(i);
}
accept(mv.visitLocalVariableAnnotation(typeRef, typePath, start, end,
index, desc, true));
} | java |
public static void appendString(final StringBuffer buf, final String s) {
buf.append('\"');
for (int i = 0; i < s.length(); ++i) {
char c = s.charAt(i);
if (c == '\n') {
buf.append("\\n");
} else if (c == '\r') {
buf.append("\\r");
} else if (c == '\\') {
buf.append("\\\\");
} else if (c == '"') {
buf.append("\\\"");
} else if (c < 0x20 || c > 0x7f) {
buf.append("\\u");
if (c < 0x10) {
buf.append("000");
} else if (c < 0x100) {
buf.append("00");
} else if (c < 0x1000) {
buf.append('0');
}
buf.append(Integer.toString(c, 16));
} else {
buf.append(c);
}
}
buf.append('\"');
} | java |
static void printList(final PrintWriter pw, final List<?> l) {
for (int i = 0; i < l.size(); ++i) {
Object o = l.get(i);
if (o instanceof List) {
printList(pw, (List<?>) o);
} else {
pw.print(o.toString());
}
}
} | java |
public JettyBootstrap startServer(Boolean join) throws JettyBootstrapException {
LOG.info("Starting Server...");
IJettyConfiguration iJettyConfiguration = getInitializedConfiguration();
initServer(iJettyConfiguration);
try {
server.start();
} catch (Exception e) {
throw new JettyBootstrapException(e);
}
// display server addresses
if (iJettyConfiguration.getJettyConnectors().contains(JettyConnector.HTTP)) {
LOG.info("http://{}:{}", iJettyConfiguration.getHost(), iJettyConfiguration.getPort());
}
if (iJettyConfiguration.getJettyConnectors().contains(JettyConnector.HTTPS)) {
LOG.info("https://{}:{}", iJettyConfiguration.getHost(), iJettyConfiguration.getSslPort());
}
if ((join != null && join) || (join == null && iJettyConfiguration.isAutoJoinOnStart())) {
joinServer();
}
return this;
} | java |
public JettyBootstrap joinServer() throws JettyBootstrapException {
try {
if (isServerStarted()) {
LOG.debug("Joining Server...");
server.join();
} else {
LOG.warn("Can't join Server. Not started");
}
} catch (InterruptedException e) {
throw new JettyBootstrapException(e);
}
return this;
} | java |
public JettyBootstrap stopServer() throws JettyBootstrapException {
LOG.info("Stopping Server...");
try {
if (isServerStarted()) {
handlers.stop();
server.stop();
LOG.info("Server stopped.");
} else {
LOG.warn("Can't stop server. Already stopped");
}
} catch (Exception e) {
throw new JettyBootstrapException(e);
}
return this;
} | java |
public WebAppContext addWarApp(String war, String contextPath) throws JettyBootstrapException {
WarAppJettyHandler warAppJettyHandler = new WarAppJettyHandler(getInitializedConfiguration());
warAppJettyHandler.setWar(war);
warAppJettyHandler.setContextPath(contextPath);
WebAppContext webAppContext = warAppJettyHandler.getHandler();
handlers.addHandler(webAppContext);
return webAppContext;
} | java |
public WebAppContext addWarAppFromClasspath(String warFromClasspath, String contextPath) throws JettyBootstrapException {
WarAppFromClasspathJettyHandler warAppFromClasspathJettyHandler = new WarAppFromClasspathJettyHandler(getInitializedConfiguration());
warAppFromClasspathJettyHandler.setWarFromClasspath(warFromClasspath);
warAppFromClasspathJettyHandler.setContextPath(contextPath);
WebAppContext webAppContext = warAppFromClasspathJettyHandler.getHandler();
handlers.addHandler(webAppContext);
return webAppContext;
} | java |
private void createShutdownHook() {
LOG.trace("Creating Jetty ShutdownHook...");
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
try {
LOG.debug("Shutting Down...");
stopServer();
} catch (Exception e) {
LOG.error("Shutdown", e);
}
}));
} | java |
public static Method[] getAllDeclaredMethods(Class<?> leafClass) {
final List<Method> methods = new ArrayList<Method>(32);
doWithMethods(leafClass, new MethodCallback() {
public void doWith(Method method) {
methods.add(method);
}
});
return methods.toArray(new Method[methods.size()]);
} | java |
public static List<Field> getSelfAndSuperClassFields(Class<?> clazz) {//YongZ added this method
List<Field> fields = new ArrayList<Field>();
for (Field field : clazz.getDeclaredFields())
fields.add(field);
Class<?> superclass = clazz.getSuperclass();
while (superclass != null) {
if (Object.class.equals(superclass)) {
break;
}
for (Field field : superclass.getDeclaredFields())
fields.add(field);
superclass = superclass.getSuperclass();
}
return fields;
} | java |
public void check(final int api) {
if (api == Opcodes.ASM4) {
if (visibleTypeAnnotations != null
&& visibleTypeAnnotations.size() > 0) {
throw new RuntimeException();
}
if (invisibleTypeAnnotations != null
&& invisibleTypeAnnotations.size() > 0) {
throw new RuntimeException();
}
int n = tryCatchBlocks == null ? 0 : tryCatchBlocks.size();
for (int i = 0; i < n; ++i) {
TryCatchBlockNode tcb = tryCatchBlocks.get(i);
if (tcb.visibleTypeAnnotations != null
&& tcb.visibleTypeAnnotations.size() > 0) {
throw new RuntimeException();
}
if (tcb.invisibleTypeAnnotations != null
&& tcb.invisibleTypeAnnotations.size() > 0) {
throw new RuntimeException();
}
}
for (int i = 0; i < instructions.size(); ++i) {
AbstractInsnNode insn = instructions.get(i);
if (insn.visibleTypeAnnotations != null
&& insn.visibleTypeAnnotations.size() > 0) {
throw new RuntimeException();
}
if (insn.invisibleTypeAnnotations != null
&& insn.invisibleTypeAnnotations.size() > 0) {
throw new RuntimeException();
}
if (insn instanceof MethodInsnNode) {
boolean itf = ((MethodInsnNode) insn).itf;
if (itf != (insn.opcode == Opcodes.INVOKEINTERFACE)) {
throw new RuntimeException();
}
}
}
if (visibleLocalVariableAnnotations != null
&& visibleLocalVariableAnnotations.size() > 0) {
throw new RuntimeException();
}
if (invisibleLocalVariableAnnotations != null
&& invisibleLocalVariableAnnotations.size() > 0) {
throw new RuntimeException();
}
}
} | java |
public void accept(final ClassVisitor cv) {
String[] exceptions = new String[this.exceptions.size()];
this.exceptions.toArray(exceptions);
MethodVisitor mv = cv.visitMethod(access, name, desc, signature,
exceptions);
if (mv != null) {
accept(mv);
}
} | java |
public void accept(final AnnotationVisitor av) {
if (av != null) {
if (values != null) {
for (int i = 0; i < values.size(); i += 2) {
String name = (String) values.get(i);
Object value = values.get(i + 1);
accept(av, name, value);
}
}
av.visitEnd();
}
} | java |
static void accept(final AnnotationVisitor av, final String name,
final Object value) {
if (av != null) {
if (value instanceof String[]) {
String[] typeconst = (String[]) value;
av.visitEnum(name, typeconst[0], typeconst[1]);
} else if (value instanceof AnnotationNode) {
AnnotationNode an = (AnnotationNode) value;
an.accept(av.visitAnnotation(name, an.desc));
} else if (value instanceof List) {
AnnotationVisitor v = av.visitArray(name);
List<?> array = (List<?>) value;
for (int j = 0; j < array.size(); ++j) {
accept(v, null, array.get(j));
}
v.visitEnd();
} else {
av.visit(name, value);
}
}
} | java |
public static String getJarDir(Class<?> clazz) {
return decodeUrl(new File(clazz.getProtectionDomain().getCodeSource().getLocation().getPath()).getParent());
} | java |
public void accept(final MethodVisitor mv) {
mv.visitLocalVariable(name, desc, signature, start.getLabel(),
end.getLabel(), index);
} | java |
public List<SherdogBaseObject> parse(String url) throws IOException {
Document document = ParserUtils.parseDocument(url);
Elements select = document.select(".fightfinder_result tr");
//removing the first one as it's the header
if (select.size() > 0) {
select.remove(0);
}
return select.stream()
.map(e ->
Optional.ofNullable(e.select("td"))
//second element is the fighter name
.filter(t -> t.size() > 1)
.map(td -> td.get(1))
.map(t -> t.select("a"))
.filter(t -> t.size() == 1)
.map(t -> {
return t.get(0);
})
.map(t -> {
//this could be either fighter or event
SherdogBaseObject sherdogObject = new SherdogBaseObject();
sherdogObject.setName(t.text());
sherdogObject.setSherdogUrl(Constants.BASE_URL + t.attr("href"));
return sherdogObject;
})
.filter(f -> f.getName() != null && f.getSherdogUrl() != null)
.orElse(null)
)
.filter(f -> f != null)
.collect(Collectors.toList());
} | java |
@Override
public Promise<Void> undeploy(String deploymentID) {
return adapter.toPromise(handler -> vertx.undeploy(deploymentID, handler));
} | java |
protected File transformInputFile(File from) throws MojoExecutionException {
// create a temp file
File tempFile;
try {
tempFile = File.createTempFile("dotml-tmp", ".xml");
} catch (IOException e) {
throw new MojoExecutionException(
"error creating temp file to hold DOTML to DOT translation", e);
}
// perform an XSLT transform from the input file to the temp file
Source xml = new StreamSource(from);
Result result = new StreamResult(tempFile);
try {
Source xslt = new StreamSource(
getClass().getClassLoader().getResourceAsStream("dotml/dotml2dot.xsl"));
transformerFactory.newTransformer(xslt).transform(xml, result);
} catch (TransformerException e) {
throw new MojoExecutionException(
String.format("error transforming %s from DOTML to DOT file", from), e);
}
// return the temp file
return tempFile;
} | java |
public static ConstraintSecurityHandler getConstraintSecurityHandlerConfidential() {
Constraint constraint = new Constraint();
constraint.setDataConstraint(Constraint.DC_CONFIDENTIAL);
ConstraintMapping constraintMapping = new ConstraintMapping();
constraintMapping.setConstraint(constraint);
constraintMapping.setPathSpec("/*");
ConstraintSecurityHandler constraintSecurityHandler = new ConstraintSecurityHandler();
constraintSecurityHandler.addConstraintMapping(constraintMapping);
return constraintSecurityHandler;
} | java |
@Override
public <T> Promise<Message<T>> send(String address, Object message) {
return adapter.toPromise(handler -> eventBus.send(address, message, handler));
} | java |
void set(final String name, final String desc, final Handle bsm,
final Object[] bsmArgs) {
this.type = 'y';
this.strVal1 = name;
this.strVal2 = desc;
this.objVal3 = bsm;
this.objVals = bsmArgs;
int hashCode = 'y' + name.hashCode() * desc.hashCode() * bsm.hashCode();
for (int i = 0; i < bsmArgs.length; i++) {
hashCode *= bsmArgs[i].hashCode();
}
this.hashCode = 0x7FFFFFFF & hashCode;
} | java |
void checkFrameValue(final Object value) {
if (value == Opcodes.TOP || value == Opcodes.INTEGER
|| value == Opcodes.FLOAT || value == Opcodes.LONG
|| value == Opcodes.DOUBLE || value == Opcodes.NULL
|| value == Opcodes.UNINITIALIZED_THIS) {
return;
}
if (value instanceof String) {
checkInternalName((String) value, "Invalid stack frame value");
return;
}
if (!(value instanceof Label)) {
throw new IllegalArgumentException("Invalid stack frame value: "
+ value);
} else {
usedLabels.add((Label) value);
}
} | java |
static void checkOpcode(final int opcode, final int type) {
if (opcode < 0 || opcode > 199 || TYPE[opcode] != type) {
throw new IllegalArgumentException("Invalid opcode: " + opcode);
}
} | java |
static void checkSignedByte(final int value, final String msg) {
if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
throw new IllegalArgumentException(msg
+ " (must be a signed byte): " + value);
}
} | java |
static void checkSignedShort(final int value, final String msg) {
if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
throw new IllegalArgumentException(msg
+ " (must be a signed short): " + value);
}
} | java |
static void checkUnqualifiedName(int version, final String name,
final String msg) {
if ((version & 0xFFFF) < Opcodes.V1_5) {
checkIdentifier(name, msg);
} else {
for (int i = 0; i < name.length(); ++i) {
if (".;[/".indexOf(name.charAt(i)) != -1) {
throw new IllegalArgumentException("Invalid " + msg
+ " (must be a valid unqualified name): " + name);
}
}
}
} | java |
static void checkIdentifier(final String name, final int start,
final int end, final String msg) {
if (name == null || (end == -1 ? name.length() <= start : end <= start)) {
throw new IllegalArgumentException("Invalid " + msg
+ " (must not be null or empty)");
}
if (!Character.isJavaIdentifierStart(name.charAt(start))) {
throw new IllegalArgumentException("Invalid " + msg
+ " (must be a valid Java identifier): " + name);
}
int max = end == -1 ? name.length() : end;
for (int i = start + 1; i < max; ++i) {
if (!Character.isJavaIdentifierPart(name.charAt(i))) {
throw new IllegalArgumentException("Invalid " + msg
+ " (must be a valid Java identifier): " + name);
}
}
} | java |
static void checkMethodIdentifier(int version, final String name,
final String msg) {
if (name == null || name.length() == 0) {
throw new IllegalArgumentException("Invalid " + msg
+ " (must not be null or empty)");
}
if ((version & 0xFFFF) >= Opcodes.V1_5) {
for (int i = 0; i < name.length(); ++i) {
if (".;[/<>".indexOf(name.charAt(i)) != -1) {
throw new IllegalArgumentException("Invalid " + msg
+ " (must be a valid unqualified name): " + name);
}
}
return;
}
if (!Character.isJavaIdentifierStart(name.charAt(0))) {
throw new IllegalArgumentException(
"Invalid "
+ msg
+ " (must be a '<init>', '<clinit>' or a valid Java identifier): "
+ name);
}
for (int i = 1; i < name.length(); ++i) {
if (!Character.isJavaIdentifierPart(name.charAt(i))) {
throw new IllegalArgumentException(
"Invalid "
+ msg
+ " (must be '<init>' or '<clinit>' or a valid Java identifier): "
+ name);
}
}
} | java |
static void checkInternalName(final String name, final String msg) {
if (name == null || name.length() == 0) {
throw new IllegalArgumentException("Invalid " + msg
+ " (must not be null or empty)");
}
if (name.charAt(0) == '[') {
checkDesc(name, false);
} else {
checkInternalName(name, 0, -1, msg);
}
} | java |
static void checkInternalName(final String name, final int start,
final int end, final String msg) {
int max = end == -1 ? name.length() : end;
try {
int begin = start;
int slash;
do {
slash = name.indexOf('/', begin + 1);
if (slash == -1 || slash > max) {
slash = max;
}
checkIdentifier(name, begin, slash, null);
begin = slash + 1;
} while (slash != max);
} catch (IllegalArgumentException unused) {
throw new IllegalArgumentException(
"Invalid "
+ msg
+ " (must be a fully qualified class name in internal form): "
+ name);
}
} | java |
static void checkDesc(final String desc, final boolean canBeVoid) {
int end = checkDesc(desc, 0, canBeVoid);
if (end != desc.length()) {
throw new IllegalArgumentException("Invalid descriptor: " + desc);
}
} | java |
static int checkDesc(final String desc, final int start,
final boolean canBeVoid) {
if (desc == null || start >= desc.length()) {
throw new IllegalArgumentException(
"Invalid type descriptor (must not be null or empty)");
}
int index;
switch (desc.charAt(start)) {
case 'V':
if (canBeVoid) {
return start + 1;
} else {
throw new IllegalArgumentException("Invalid descriptor: "
+ desc);
}
case 'Z':
case 'C':
case 'B':
case 'S':
case 'I':
case 'F':
case 'J':
case 'D':
return start + 1;
case '[':
index = start + 1;
while (index < desc.length() && desc.charAt(index) == '[') {
++index;
}
if (index < desc.length()) {
return checkDesc(desc, index, false);
} else {
throw new IllegalArgumentException("Invalid descriptor: "
+ desc);
}
case 'L':
index = desc.indexOf(';', start);
if (index == -1 || index - start < 2) {
throw new IllegalArgumentException("Invalid descriptor: "
+ desc);
}
try {
checkInternalName(desc, start + 1, index, null);
} catch (IllegalArgumentException unused) {
throw new IllegalArgumentException("Invalid descriptor: "
+ desc);
}
return index + 1;
default:
throw new IllegalArgumentException("Invalid descriptor: " + desc);
}
} | java |
static void checkMethodDesc(final String desc) {
if (desc == null || desc.length() == 0) {
throw new IllegalArgumentException(
"Invalid method descriptor (must not be null or empty)");
}
if (desc.charAt(0) != '(' || desc.length() < 3) {
throw new IllegalArgumentException("Invalid descriptor: " + desc);
}
int start = 1;
if (desc.charAt(start) != ')') {
do {
if (desc.charAt(start) == 'V') {
throw new IllegalArgumentException("Invalid descriptor: "
+ desc);
}
start = checkDesc(desc, start, false);
} while (start < desc.length() && desc.charAt(start) != ')');
}
start = checkDesc(desc, start + 1, true);
if (start != desc.length()) {
throw new IllegalArgumentException("Invalid descriptor: " + desc);
}
} | java |
void checkLabel(final Label label, final boolean checkVisited,
final String msg) {
if (label == null) {
throw new IllegalArgumentException("Invalid " + msg
+ " (must not be null)");
}
if (checkVisited && labels.get(label) == null) {
throw new IllegalArgumentException("Invalid " + msg
+ " (must be visited first)");
}
} | java |
private static void checkNonDebugLabel(final Label label) {
Field f = getLabelStatusField();
int status = 0;
try {
status = f == null ? 0 : ((Integer) f.get(label)).intValue();
} catch (IllegalAccessException e) {
throw new Error("Internal error");
}
if ((status & 0x01) != 0) {
throw new IllegalArgumentException(
"Labels used for debug info cannot be reused for control flow");
}
} | java |
private static Field getLabelStatusField() {
if (labelStatusField == null) {
labelStatusField = getLabelField("a");
if (labelStatusField == null) {
labelStatusField = getLabelField("status");
}
}
return labelStatusField;
} | java |
private static Field getLabelField(final String name) {
try {
Field f = Label.class.getDeclaredField(name);
f.setAccessible(true);
return f;
} catch (NoSuchFieldException e) {
return null;
}
} | java |
public void loadStoreFile() {
try {
BufferedInputStream bis = new BufferedInputStream(
new FileInputStream(this.storeFile)
);
JSONTokener jsonTokener = new JSONTokener(new InputStreamReader(bis));
JSONArray array = new JSONArray(jsonTokener);
bis.close();
// Init our keys array with the correct size.
this.keys = new ConcurrentHashMap<String, Key>(array.length());
for (int i = 0, j = array.length(); i < j; i += 1) {
JSONObject obj = array.getJSONObject(i);
Key key = new Key(obj.getString("name"), obj.getString("data"));
log.debug("Adding {} key to keystore.", key.name());
this.addKey(key);
}
} catch (FileNotFoundException e) {
log.error("Could not find JSONKeystore file!");
log.debug(e.toString());
} catch (JSONException e) {
log.error("Error parsing JSON!");
log.debug(e.toString());
} catch (IOException e) {
log.error("Could not close JSONKeystore file!");
log.debug(e.toString());
}
} | java |
private void search() throws IOException {
String url = String.format(SEARCH_URL,
term,
(weightClass != null) ? weightClass.getValue() : "",
page
);
dryEvents = new ArrayList<>();
dryFighters = new ArrayList<>();
List<SherdogBaseObject> parse = new SearchParser().parse(url);
parse.forEach(r -> {
if (r.getSherdogUrl().startsWith(Constants.BASE_URL + "/events/")) {
dryEvents.add(r);
} else if (r.getSherdogUrl().startsWith(Constants.BASE_URL + "/fighter/")) {
dryFighters.add(r);
}
});
} | java |
public List<Fighter> getFightersWithCompleteData() {
return dryFighters.stream()
.map(f -> {
try {
return sherdog.getFighter(f.getSherdogUrl());
} catch (IOException | ParseException | SherdogParserException e) {
return null;
}
})
.filter(Objects::nonNull)
.collect(Collectors.toList());
} | java |
public List<Event> getEventsWithCompleteData() {
return dryEvents.stream()
.map(f -> {
try {
return sherdog.getEvent(f.getSherdogUrl());
} catch (IOException | ParseException | SherdogParserException e) {
return null;
}
})
.filter(Objects::nonNull)
.collect(Collectors.toList());
} | java |
public Frame<V> init(final Frame<? extends V> src) {
returnValue = src.returnValue;
System.arraycopy(src.values, 0, values, 0, values.length);
top = src.top;
return this;
} | java |
public void setLocal(final int i, final V value)
throws IndexOutOfBoundsException {
if (i >= locals) {
throw new IndexOutOfBoundsException(
"Trying to access an inexistant local variable " + i);
}
values[i] = value;
} | java |
public void push(final V value) throws IndexOutOfBoundsException {
if (top + locals >= values.length) {
throw new IndexOutOfBoundsException(
"Insufficient maximum stack size.");
}
values[top++ + locals] = value;
} | java |
public boolean merge(final Frame<? extends V> frame,
final Interpreter<V> interpreter) throws AnalyzerException {
if (top != frame.top) {
throw new AnalyzerException(null, "Incompatible stack heights");
}
boolean changes = false;
for (int i = 0; i < locals + top; ++i) {
V v = interpreter.merge(values[i], frame.values[i]);
if (!v.equals(values[i])) {
values[i] = v;
changes = true;
}
}
return changes;
} | java |
public byte[] decrypt(byte[] msg) {
if (msg == null) return null;
try {
Cipher cipher = Cipher.getInstance(ENCRYPTION_ALGORITHM_IMPLEMENTATION);
SecretKeySpec key = new SecretKeySpec(getMd5(), ENCRYPTION_ALGORITHM);
IvParameterSpec iv = new IvParameterSpec(getIv());
cipher.init(Cipher.DECRYPT_MODE, key, iv);
return cipher.doFinal(msg);
} catch (Exception e) {
return null;
}
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.