| /* |
| * Copyright 2012, the Dart project authors. |
| * |
| * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except |
| * in compliance with the License. You may obtain a copy of the License at |
| * |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Unless required by applicable law or agreed to in writing, software distributed under the License |
| * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express |
| * or implied. See the License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package com.google.dart.engine.ast; |
| |
| import com.google.dart.engine.element.ImportElement; |
| import com.google.dart.engine.element.LibraryElement; |
| import com.google.dart.engine.scanner.Token; |
| |
| import java.util.ArrayList; |
| import java.util.Comparator; |
| import java.util.List; |
| |
| /** |
| * Instances of the class {@code ImportDirective} represent an import directive. |
| * |
| * <pre> |
| * importDirective ::= |
| * {@link Annotation metadata} 'import' {@link StringLiteral libraryUri} ('as' identifier)? {@link Combinator combinator}* ';' |
| * | {@link Annotation metadata} 'import' {@link StringLiteral libraryUri} 'deferred' 'as' identifier {@link Combinator combinator}* ';' |
| * </pre> |
| * |
| * @coverage dart.engine.ast |
| */ |
| public class ImportDirective extends NamespaceDirective { |
| |
| public static final Comparator<ImportDirective> COMPARATOR = new Comparator<ImportDirective>() { |
| @Override |
| public int compare(ImportDirective import1, ImportDirective import2) { |
| // |
| // uri |
| // |
| StringLiteral uri1 = import1.getUri(); |
| StringLiteral uri2 = import2.getUri(); |
| String uriStr1 = uri1.getStringValue(); |
| String uriStr2 = uri2.getStringValue(); |
| if (uriStr1 != null || uriStr2 != null) { |
| if (uriStr1 == null) { |
| return -1; |
| } else if (uriStr2 == null) { |
| return 1; |
| } else { |
| int compare = uriStr1.compareTo(uriStr2); |
| if (compare != 0) { |
| return compare; |
| } |
| } |
| } |
| |
| // |
| // as |
| // |
| SimpleIdentifier prefix1 = import1.getPrefix(); |
| SimpleIdentifier prefix2 = import2.getPrefix(); |
| String prefixStr1 = prefix1 != null ? prefix1.getName() : null; |
| String prefixStr2 = prefix2 != null ? prefix2.getName() : null; |
| if (prefixStr1 != null || prefixStr2 != null) { |
| if (prefixStr1 == null) { |
| return -1; |
| } else if (prefixStr2 == null) { |
| return 1; |
| } else { |
| int compare = prefixStr1.compareTo(prefixStr2); |
| if (compare != 0) { |
| return compare; |
| } |
| } |
| } |
| |
| // |
| // hides and shows |
| // |
| NodeList<Combinator> combinators1 = import1.getCombinators(); |
| ArrayList<String> allHides1 = new ArrayList<String>(); |
| ArrayList<String> allShows1 = new ArrayList<String>(); |
| for (Combinator combinator : combinators1) { |
| if (combinator instanceof HideCombinator) { |
| NodeList<SimpleIdentifier> hides = ((HideCombinator) combinator).getHiddenNames(); |
| for (SimpleIdentifier simpleIdentifier : hides) { |
| allHides1.add(simpleIdentifier.getName()); |
| } |
| } else { |
| NodeList<SimpleIdentifier> shows = ((ShowCombinator) combinator).getShownNames(); |
| for (SimpleIdentifier simpleIdentifier : shows) { |
| allShows1.add(simpleIdentifier.getName()); |
| } |
| } |
| } |
| NodeList<Combinator> combinators2 = import2.getCombinators(); |
| ArrayList<String> allHides2 = new ArrayList<String>(); |
| ArrayList<String> allShows2 = new ArrayList<String>(); |
| for (Combinator combinator : combinators2) { |
| if (combinator instanceof HideCombinator) { |
| NodeList<SimpleIdentifier> hides = ((HideCombinator) combinator).getHiddenNames(); |
| for (SimpleIdentifier simpleIdentifier : hides) { |
| allHides2.add(simpleIdentifier.getName()); |
| } |
| } else { |
| NodeList<SimpleIdentifier> shows = ((ShowCombinator) combinator).getShownNames(); |
| for (SimpleIdentifier simpleIdentifier : shows) { |
| allShows2.add(simpleIdentifier.getName()); |
| } |
| } |
| } |
| // test lengths of combinator lists first |
| if (allHides1.size() != allHides2.size()) { |
| return allHides1.size() - allHides2.size(); |
| } |
| if (allShows1.size() != allShows2.size()) { |
| return allShows1.size() - allShows2.size(); |
| } |
| // next ensure that the lists are equivalent |
| if (!allHides1.containsAll(allHides2)) { |
| return -1; |
| } |
| if (!allShows1.containsAll(allShows2)) { |
| return -1; |
| } |
| return 0; |
| } |
| }; |
| |
| /** |
| * The token representing the 'deferred' token, or {@code null} if the imported is not deferred. |
| */ |
| private Token deferredToken; |
| |
| /** |
| * The token representing the 'as' token, or {@code null} if the imported names are not prefixed. |
| */ |
| private Token asToken; |
| |
| /** |
| * The prefix to be used with the imported names, or {@code null} if the imported names are not |
| * prefixed. |
| */ |
| private SimpleIdentifier prefix; |
| |
| /** |
| * Initialize a newly created import directive. |
| * |
| * @param comment the documentation comment associated with this directive |
| * @param metadata the annotations associated with the directive |
| * @param keyword the token representing the 'import' keyword |
| * @param libraryUri the URI of the library being imported |
| * @param deferredToken the token representing the 'deferred' token |
| * @param asToken the token representing the 'as' token |
| * @param prefix the prefix to be used with the imported names |
| * @param combinators the combinators used to control how names are imported |
| * @param semicolon the semicolon terminating the directive |
| */ |
| public ImportDirective(Comment comment, List<Annotation> metadata, Token keyword, |
| StringLiteral libraryUri, Token deferredToken, Token asToken, SimpleIdentifier prefix, |
| List<Combinator> combinators, Token semicolon) { |
| super(comment, metadata, keyword, libraryUri, combinators, semicolon); |
| this.deferredToken = deferredToken; |
| this.asToken = asToken; |
| this.prefix = becomeParentOf(prefix); |
| } |
| |
| @Override |
| public <R> R accept(AstVisitor<R> visitor) { |
| return visitor.visitImportDirective(this); |
| } |
| |
| /** |
| * Return the token representing the 'as' token, or {@code null} if the imported names are not |
| * prefixed. |
| * |
| * @return the token representing the 'as' token |
| */ |
| public Token getAsToken() { |
| return asToken; |
| } |
| |
| /** |
| * Return the token representing the 'deferred' token, or {@code null} if the imported is not |
| * deferred. |
| * |
| * @return the token representing the 'deferred' token |
| */ |
| public Token getDeferredToken() { |
| return deferredToken; |
| } |
| |
| @Override |
| public ImportElement getElement() { |
| return (ImportElement) super.getElement(); |
| } |
| |
| /** |
| * Return the prefix to be used with the imported names, or {@code null} if the imported names are |
| * not prefixed. |
| * |
| * @return the prefix to be used with the imported names |
| */ |
| public SimpleIdentifier getPrefix() { |
| return prefix; |
| } |
| |
| @Override |
| public LibraryElement getUriElement() { |
| ImportElement element = getElement(); |
| if (element == null) { |
| return null; |
| } |
| return element.getImportedLibrary(); |
| } |
| |
| /** |
| * Set the token representing the 'as' token to the given token. |
| * |
| * @param asToken the token representing the 'as' token |
| */ |
| public void setAsToken(Token asToken) { |
| this.asToken = asToken; |
| } |
| |
| /** |
| * Set the token representing the 'deferred' token to the given token. |
| * |
| * @param deferredToken the token representing the 'deferred' token |
| */ |
| public void setDeferredToken(Token deferredToken) { |
| this.deferredToken = deferredToken; |
| } |
| |
| /** |
| * Set the prefix to be used with the imported names to the given identifier. |
| * |
| * @param prefix the prefix to be used with the imported names |
| */ |
| public void setPrefix(SimpleIdentifier prefix) { |
| this.prefix = becomeParentOf(prefix); |
| } |
| |
| @Override |
| public void visitChildren(AstVisitor<?> visitor) { |
| super.visitChildren(visitor); |
| safelyVisitChild(prefix, visitor); |
| getCombinators().accept(visitor); |
| } |
| } |