public static synchronized Pair<List<Pair<Function, String>>, Set<String>> getMethodsAndTheirSignatures(Class<?> originalLib) { if (cachedForcedMethodsAndTheirSignatures == null) { cachedForcedMethodsAndTheirSignatures = new LinkedHashMap<Class<?>, Pair<List<Pair<Function, String>>, Set<String>>>(); } Pair<List<Pair<Function, String>>, Set<String>> pair = cachedForcedMethodsAndTheirSignatures.get(originalLib); if (pair == null) { pair = new Pair<List<Pair<Function, String>>, Set<String>>(new ArrayList<Pair<Function, String>>(), new HashSet<String>()); for (Method m : originalLib.getDeclaredMethods()) { Function f = Function.fromMethod(m); String sig = f.computeSignature(Function.SignatureType.JavaStyle); //if (m.getDeclaringClass().equals(NSObject.class) && f.getName().equals("as")) { // Declaration //} pair.getFirst().add(new Pair<Function, String>(f, sig)); pair.getSecond().add(sig); } } return pair; }
@Override public boolean add(Pair<KEY,E> e) { cache.add(e); if(!map.containsKey(e.getKey())){ final CollectionActionDispatcher<E> newCollection = new CollectionActionDispatcher<E>(new ArrayList<E>()); final Pair<KEY,CollectionActionDispatcher<E>> newPair = new Pair<KEY,CollectionActionDispatcher<E>>(e.getKey(),newCollection); map.put(e.getKey(),newPair); delegate.add(newPair); }//end (create new entry) return map.get(e.getKey()).getValue().add(e.getValue()); }//end add()
@Override public Void call() throws Exception { for(Pair<Vector3D,CollectionActionDispatcher<Positionable>> relevancePair:relevancePairs){ Collection<Positionable> newCube = newCube(); newCube.addAll(relevancePair.getValue()); pairBuffer.put(relevancePair.getKey(),newCube); }//end for(relevanceCubes) return null; }}).get();}catch(Exception e){e.printStackTrace();} //Process non-everywhere cubes
Pair<TypeRef, List<Pair<String, String>>> pair = fieldsAndCommentsByTypeStr.get(trStr); if (pair == null) { fieldsAndCommentsByTypeStr.put(trStr, pair = new Pair<TypeRef, List<Pair<String, String>>>(tr, new ArrayList<Pair<String, String>>())); pair.getSecond().add(new Pair<String, String>(vd.getCommentBefore(), name)); for (Pair<String, String> p : pair.getValue()) { if (p.getFirst() != null) { commentBits.add(p.getFirst()); nameBits.add(p.getValue()); TypeRef tr = pair.getFirst(); Function unionValConstr = new Function(Function.Type.JavaMethod, structName.clone(), null, new Arg(name, tr.clone())); if (!result.config.noComments) { for (Pair<String, String> p : pair.getValue()) { assignmentExpr = new Expression.AssignmentOp(memberRef(thisRef(), MemberRefStyle.Dot, ident(p.getValue())), AssignmentOperator.Equal, assignmentExpr); List<Expression> orderedFieldNames = new ArrayList<Expression>(); int iArg = 0; for (VariablesDeclaration vd : new CompoundCollection<VariablesDeclaration>(decls.getFirst(), decls.getSecond())) { String name = chooseJavaArgName(vd.getDeclarators().get(0).resolveName(), iArg, names); namesById.put(vd.getId(), name); for (VariablesDeclaration vd : decls.getFirst()) { String name = vd.getDeclarators().get(0).resolveName(), uname = namesById.get(vd.getId()); Struct parent = (Struct) vd.getParentElement();
public static <U, V> Pair<U, V> create(U u, V v) { return new Pair<U, V>(u, v); } public U getFirst() {
public Expression getFlatArraySizeExpression(TypeRef.Pointer.ArrayRef arrayRef, Identifier callerLibraryName) throws UnsupportedConversionException { Expression mul = null; List<Expression> dims = arrayRef.flattenDimensions(); for (int i = dims.size(); i-- != 0;) { Expression x = dims.get(i); if (x == null || x instanceof Expression.EmptyArraySize) { return null; //javaType = jr = new ArrayRef(typeRef(Pointer.class)); //break; } else { Pair<Expression, TypeRef> c = convertExpressionToJava(x, callerLibraryName, false, true, null); c.getFirst().setParenthesis(dims.size() > 1); if (mul == null) { mul = c.getFirst(); } else { mul = expr(c.getFirst(), Expression.BinaryOperator.Multiply, mul); } } } return mul; }
String name = arg.getName(); if (name == null && !isNamedFunctionType(arg.getValueType())) { missing.add(new Pair<Arg, Integer>(arg, i)); } else if (name != null) { names.add(name); i = 1; String base; if (p.getFirst().isVarArg()) { base = "varArgs"; } else { try { base = chooseArgNameFromType(p.getFirst().getValueType()); } catch (UnsupportedConversionException ex) { base = "arg"; p.getFirst().setName(name);
Pair<Expression, TypeRef> converted = alreadyConverted ? x : result.typeConverter.convertExpressionToJava(x.getFirst(), libraryClassName, true, false, null); JavaPrim prim = result.typeConverter.getPrimitive(converted.getValue()); converted = pair(expr("true".equals(String.valueOf(converted.toString())) ? 1 : 0), typeRef(Integer.TYPE)); if ((prim == null || converted.getValue() == null) && signalErrors) { if (result.config.limitComments) { return null; } else if (prim != JavaPrim.Void && converted.getValue() != null) { String t = converted.toString(); if (t.contains("sizeof")) { converted = alreadyConverted ? x : result.typeConverter.convertExpressionToJava(x.getFirst(), libraryClassName, false, false, null); TypeRef tr = converted.getValue(); Expression value = converted.getFirst(); if (result.config.castConstants && !alreadyConverted) { if (!(value instanceof Constant) && !(value instanceof VariableRef)) {
Element e = result.symbols.getVariable(vr.getName()); if (e != null) { ret.referencedElements.add(new Pair<Element, Integer>(e, e.getId())); Element e = kv.getKey(); Identifier replacedIdentifier = ident(changedName); identifier.replaceBy(replacedIdentifier); ret.referencedElements.add(new Pair<Element, Integer>(replacedIdentifier, replacedIdentifier.getId())); return false; return ret.referencedElements.contains(new Pair<Element, Integer>(e, e.getId()));
public static TypeRef recognizeSizeOf(Expression e) { if (!(e instanceof FunctionCall)) { return null; } FunctionCall fc = (FunctionCall) e; List<Pair<String, Expression>> args = fc.getArguments(); if (args.size() != 1) { return null; } Pair<String, Expression> arg = args.get(0); if (arg == null) { return null; } Expression f = fc.getFunction(); if (!(f instanceof VariableRef)) { return null; } VariableRef vr = (VariableRef) f; if (!"sizeof".equals(String.valueOf(vr.getName()))) { return null; } Expression a = arg.getSecond(); if (!(a instanceof Expression.TypeRefExpression)) { return null; } Expression.TypeRefExpression tr = (Expression.TypeRefExpression) a; return tr.getType(); }
@Override protected CollectionActionDispatcher<Positionable> _adapt( Pair<Vector3D, CollectionActionDispatcher<Positionable>> value) throws UnsupportedOperationException { return value.getValue(); }
/** * Note: Based on the KEY component of Pair<KEY,VALUE> * Different VALUEs have no effect. */ @Override public boolean contains(Object o) { if(! (o instanceof Pair)) return false; final Pair<KEY,CollectionActionDispatcher<E>> pair = (Pair<KEY,CollectionActionDispatcher<E>>)o; return map.containsKey(pair.getKey()); //return cache.contains(o); }
return parsedArgsInclude(a); } else { parsedArgs.add(Pair.create(OptionDef.File, Arrays.asList(a.getFileParam(0).toString()))); if (file.isDirectory() && fn.matches(".*\\.framework")) { config.addFramework(file.toString());
if (alternativesPair != null) { if (result.config.choicesInputFile != null) { for (Function alt : alternativesPair.getValue()) { implementations.addDeclaration(alt.clone()); functionAlternativesByNativeSignature.put( sig, alternativesPair = new Pair<Function, List<Function>>( cleanClone(function), new ArrayList<Function>())); List<Function> alternatives = alternativesPair.getValue(); for (Pair<MessageFormat, MessageFormat> mf : result.config.onlineDocumentationURLFormats) { try { MessageFormat urlFormat = mf.getSecond(); URL url = new URL(urlFormat.format(name)); URLConnection con = url.openConnection(); con.getInputStream().close(); MessageFormat displayFormat = mf.getFirst(); natFunc.addToCommentBefore("@see <a href=\"" + url + "\">" + displayFormat.format(name) + "</a>"); break;
public static <A, B> Pair<A, B> pair(A a, B b) { return new Pair<A, B>(a, b); }
private Identifier getFakePointerName(Identifier name) { String nameStr = name == null ? null : name.toString(); String trimmed = StringUtils.trimUnderscores(nameStr); if (trimmed != null && !nameStr.equals(trimmed)) { String nicerName = trimmed; Pair<TypeDef, Declarator> pair = typeDefs.get(nicerName); if (pair != null) { TypeRef targetType = pair.getFirst().getValueType(); String target = targetType.toString(); if (target.equals(nameStr + "*") || target.equals(nameStr)) { name = ident(nameStr = nicerName); } } } return name; }
void replaceMalloc(TypeRef pointedType, Element toReplace, Expression sizeExpression) { // TODO handle casts and sizeof expressions ! Pair<TypeRef, Expression> typeAndSize = recognizeSizeOfMult(sizeExpression); if (typeAndSize != null && (pointedType == null || pointedType.equals(typeAndSize.getFirst()))) { String tStr = String.valueOf(typeAndSize.getFirst()); try { JavaPrim prim = JavaPrim.getJavaPrim(tStr); if (prim != null && prim.isPrimitive) { String cap = StringUtils.capitalize(tStr); toReplace.replaceBy(staticPtrMethod("allocate" + cap + "s", typeAndSize.getValue())); return; } } catch (Throwable th) { // Do nothing } } toReplace.replaceBy(staticPtrMethod("allocateBytes", sizeExpression)); }