@Override public EolElement create(AST ast, EolElement container, Ast2EolContext context) { Import imp = context.getEolFactory().createImport(); // create an Import this.setAssets(ast, imp, container); AST importedStringAST = ast.getFirstChild(); // obtain the imported string AST if (importedStringAST != null) { String importedString = importedStringAST.getText(); AST importedAst = null; try { importedAst = getAstForFile(importedString, context); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } if (importedAst != null) { imp.setImportedProgram( (Program) context.getEolElementCreatorFactory().createDomElement(importedAst, imp, context)); } imp.setImported( (StringExpression) context .getEolElementCreatorFactory() .createDomElement( importedStringAST, imp, context)); // create an StringExpression for the imported string } return imp; }
private void addStyleTypeSelector(String name, Rule rule, boolean local, int lineNumber) { StyleDef styleDef; if (local) { localStyleTypeNames.add(name); } if (selectors.containsKey(name)) { styleDef = (StyleDef) selectors.get(name); } else { styleDef = new StyleDef( name, true, mxmlDocument, compilationUnit.getSource(), lineNumber, perCompileData); selectors.put(name, styleDef); } styleDef.addRule(rule); if (mxmlDocument != null) { Iterator iterator = styleDef.getImports().iterator(); while (iterator.hasNext()) { Import importObject = (Import) iterator.next(); mxmlDocument.addImport(importObject.getValue(), importObject.getLineNumber()); } } }
public Import getImport(String alias) { for (Import i : getImports()) { if (!i.isAmbiguous() && i.getAlias().equals(alias)) { return i; } } return null; }
public boolean hasImport(Declaration d) { for (Import i : getImports()) { if (!i.isAmbiguous() && i.getDeclaration().equals(d)) { return true; } } return false; }
public static TypeInfo formImport(Import typeName, boolean isArray) { TypeInfo typeInfo = new TypeInfo(); typeInfo.type = TypeInfo.Type.form(typeName.getFullName()); typeInfo.isArray = isArray; if (!typeInfo.type.isBaseType()) { typeInfo.packageName = typeName.getPackageName(); typeInfo.name = typeName.getName(); typeInfo.isInside = typeName.isInside(); } return typeInfo; }
@NotNull private static List<Import> importsToImportList(@NotNull PsiImportStatementBase[] imports) { List<Import> result = new LinkedList<Import>(); for (PsiImportStatementBase i : imports) { Import anImport = importToImport(i); String name = anImport.getName(); if (!name.isEmpty() && !NOT_NULL_ANNOTATIONS.contains(name)) { result.add(anImport); } } return result; }
public String compileGrammar() { String f = header.getHeader(); f = f.concat("grammar " + name + ";\n"); for (Import i : imports) { f = f.concat(i.getString() + "\n"); } for (Rule r : rules) { f = f.concat(r.getRuleString() + "\n"); } return f; }
public Class<?> classNamed(String name) { try { return (name.startsWith(prefix)) ? Import.forName(name) : (name.indexOf(".") == -1) ? Import.forName(prefix + name) : null; } catch (java.lang.SecurityException se) { // Can come back from Netscape. Assume the guessed name doesn't // exist. return null; } catch (Throwable t) { E.warn(this + " " + name + " " + t); return null; } }
public void addImport(String className) { List<Import> imports = getImports(); if (imports.size() == 0) { TokenIterator iter = new TokenIterator(); int offset = 0; boolean insertLF = false; while (iter.hasNext()) { Token token = iter.next(); if (token.type != token.RESERVED_WORD) { insertLF = false; continue; } if (getText(token).equals("package")) { skipToEOL(iter, token); insertLF = true; } else { offset = token.offset; break; } } textArea.insert((insertLF ? "\n" : "") + "import " + className + ";\n\n", offset); return; } String string = "import " + className + ";\n"; Import imp = new Import(0, 0, className); int insert = -1; for (int i = 0; i < imports.size(); i++) { int cmp = imports.get(i).compareTo(imp); if (cmp == 0) return; if (cmp < 0) insert = i; } // 'insert' is the index of the import _after_ which we // want to insert the current import. if (insert >= 0) string = "\n" + string; if (insert >= 0 && !imp.getPackage().equals(imports.get(insert).getPackage())) string = "\n" + string; if (insert + 1 < imports.size() && !imp.getPackage().equals(imports.get(insert + 1).getPackage())) string += "\n"; int startOffset = insert < 0 ? imports.get(0).startOffset : imports.get(insert).endOffset; int endOffset = insert + 1 < imports.size() ? imports.get(insert + 1).startOffset : imports.get(insert).endOffset; textArea.replaceRange(string, startOffset, endOffset); }
public static Imports allOf(@Nonnull final Field field) { Check.notNull(field, "field"); final List<Import> imports = Lists.newArrayList(); imports.add(Import.of(field)); imports.addAll(ofAnnotations(field.getAnnotations()).asList()); return new Imports(imports); }
@Override public Void visit(Import i, Void _) { builder.append("imports "); builder.append(i.getName()); builder.append('\n'); return null; }
public static Imports allOf(@Nonnull final Method method) { Check.notNull(method, "method"); final List<Import> imports = Lists.newArrayList(); imports.add(Import.of(method.getReturnType().getType())); imports.addAll(ofAnnotations(method.getAnnotations()).asList()); return new Imports(imports); }
private static Imports ofFields(@Nonnull final Iterable<Field> fields) { Check.notNull(fields, "fields"); final List<Import> imports = Lists.newArrayList(); for (final Field field : fields) { imports.add(Import.of(field)); } return new Imports(imports); }
private static Imports ofInterfaces(@Nonnull final Iterable<Interface> interfaces) { Check.notNull(interfaces, "interfaces"); final List<Import> imports = Lists.newArrayList(); for (final Interface i : interfaces) { imports.add(Import.of(i)); } return new Imports(imports); }
private static Imports ofAnnotations(@Nonnull final Iterable<Annotation> annotations) { Check.notNull(annotations, "annotations"); final List<Import> imports = Lists.newArrayList(); for (final Annotation annotation : annotations) { imports.add(Import.of(annotation)); } return new Imports(imports); }
private static Imports ofAttributes(@Nonnull final Iterable<Attribute> attributes) { Check.notNull(attributes, "attributes"); final List<Import> imports = Lists.newArrayList(); for (final Attribute attribute : attributes) { imports.add(Import.of(attribute)); } return new Imports(imports); }
/** * Searches the set of imports to find a matching import by type name. * * @param typeName name of type (qualified or simple name allowed) * @return found import or {@code null} */ @Nullable public Import find(@Nonnull final String typeName) { Check.notEmpty(typeName, "typeName"); Import ret = null; final Type type = new Type(typeName); for (final Import imp : imports) { if (imp.getType().getName().equals(type.getName())) { ret = imp; break; } } if (ret == null) { final Type javaLangType = Type.evaluateJavaLangType(typeName); if (javaLangType != null) { ret = Import.of(javaLangType); } } return ret; }
public void sortImports() { List<Import> imports = getImports(); if (imports.size() == 0) return; int start = imports.get(0).startOffset; while (emptyLineAt(start - 2)) start--; int end = imports.get(imports.size() - 1).endOffset; while (eolAt(end)) end++; Collections.sort( imports, new Comparator<Import>() { public int compare(Import i1, Import i2) { return i1.classOrPackage.compareTo(i2.classOrPackage); } public boolean equals(Object o) { return false; } }); StringBuffer buffer = new StringBuffer(); String lastPrefix = null; String lastImport = null; for (Import imp : imports) { if (imp.classOrPackage.equals(lastImport)) continue; lastImport = imp.classOrPackage; String prefix = imp.getPackage(); if (!prefix.equals(lastPrefix)) { buffer.append("\n"); lastPrefix = prefix; } // TODO: honor comments buffer.append(getText(imp.startOffset, imp.endOffset)); buffer.append("\n"); } buffer.append("\n"); textArea.replaceRange(buffer.toString(), start, end); }
private void addImports(PMML pmml, Package aPackage) { String importsFromDelimitedString = ScorecardPMMLUtils.getExtensionValue( pmml.getHeader().getExtensions(), PMMLExtensionNames.SCORECARD_IMPORTS); if (!(importsFromDelimitedString == null || importsFromDelimitedString.isEmpty())) { for (String importStatement : importsFromDelimitedString.split(",")) { Import imp = new Import(); imp.setClassName(importStatement); aPackage.addImport(imp); } } Import defaultScorecardImport = new Import(); defaultScorecardImport.setClassName("org.drools.scorecards.DroolsScorecard"); aPackage.addImport(defaultScorecardImport); defaultScorecardImport = new Import(); defaultScorecardImport.setClassName("org.drools.scorecards.PartialScore"); aPackage.addImport(defaultScorecardImport); defaultScorecardImport = new Import(); defaultScorecardImport.setClassName("org.drools.scorecards.InitialScore"); aPackage.addImport(defaultScorecardImport); defaultScorecardImport = new Import(); defaultScorecardImport.setClassName("org.drools.scorecards.BaselineScore"); aPackage.addImport(defaultScorecardImport); }
protected void addImport(Import imp) { if (imp != NULL_IMPORT && imp.needsImport()) { imports.add(imp); } }
@Override public int compare(@Nonnull final Import left, @Nonnull final Import right) { // NOSONAR return left.getType().toString().compareTo(right.getType().toString()); }
@Override public boolean apply(@Nonnull final Import imp) { // NOSONAR return !Package.UNDEFINED.equals(imp.getType().getPackage()); }
protected void assertImport(Import anImport, String name, boolean isInside) { assertEquals(name, anImport.getFullName()); assertEquals(isInside, anImport.isInside()); }
public DeclarationWithProximity(Import imp, int proximity) { this.declaration = imp.getDeclaration(); this.proximity = proximity; this.name = imp.getAlias(); }