content: /*
   * Created on Jun 5, 2008
   * 
   * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
   * 
   * 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.
   * 
   * Copyright @2008-2013 the original author or authors.
   */
  package org.fest.swing.core;
  
  import static org.fest.swing.edt.GuiActionRunner.execute;
  import static org.fest.util.Preconditions.checkNotNull;
  import static org.fest.util.Sets.newLinkedHashSet;
  
  import java.awt.Component;
  import java.util.Collection;
  import java.util.Set;
  
  import javax.annotation.Nonnull;
  
  import org.fest.swing.annotation.RunsInEDT;
  import org.fest.swing.edt.GuiQuery;
  import org.fest.swing.hierarchy.ComponentHierarchy;
  
  /**
   * Finds all the AWT and Swing {@code Components} in a {@link ComponentHierarchy} that match the search criteria
   * specified in a {@link ComponentMatcher}.
   * 
   * @author Alex Ruiz
   */
  final class FinderDelegate {
    @RunsInEDT
    @Nonnull Collection<Component> find(@Nonnull ComponentHierarchy h, @Nonnull ComponentMatcher m) {
      Set<Component> found = newLinkedHashSet();
      for (Component c : rootsOf(h)) {
        find(h, m, checkNotNull(c), found);
      }
      return found;
    }
  
    @RunsInEDT
    private void find(@Nonnull ComponentHierarchy h, @Nonnull ComponentMatcher m, @Nonnull Component root,
        @Nonnull Set<Component> found) {
      for (Component c : childrenOfComponent(root, h)) {
        find(h, m, checkNotNull(c), found);
      }
      if (isMatching(root, m)) {
        found.add(root);
      }
    }
  
    @RunsInEDT
    private static @Nonnull Collection<Component> childrenOfComponent(
        final @Nonnull Component c, final @Nonnull ComponentHierarchy h) {
      Collection<Component> children = execute(new GuiQuery<Collection<Component>>() {
        @Override
        protected Collection<Component> executeInEDT() {
          return h.childrenOf(c);
        }
      });
      return checkNotNull(children);
    }
  
    @RunsInEDT
    private static boolean isMatching(@Nonnull final Component c, @Nonnull final ComponentMatcher m) {
      Boolean matching = execute(new GuiQuery<Boolean>() {
        @Override
        protected Boolean executeInEDT() {
          return m.matches(c);
        }
      });
      return checkNotNull(matching);
    }
  
    @RunsInEDT
    @Nonnull <T extends Component> Collection<T> find(@Nonnull ComponentHierarchy h, @Nonnull GenericTypeMatcher<T> m) {
      Set<T> found = newLinkedHashSet();
      for (Component c : rootsOf(h)) {
        find(h, m, checkNotNull(c), found);
      }
      return found;
    }
  
    @RunsInEDT
    private static @Nonnull Collection<? extends Component> rootsOf(final @Nonnull ComponentHierarchy h) {
      Collection<? extends Component> roots = execute(new GuiQuery<Collection<? extends Component>>() {
        @Override
        protected Collection<? extends Component> executeInEDT() {
          return h.roots();
        }
      });
      return checkNotNull(roots);
    }
  
    @RunsInEDT
    private <T extends Component> void find(@Nonnull ComponentHierarchy h, @Nonnull GenericTypeMatcher<T> m,
        @Nonnull Component root, Set<T> found) {
      for (Component c : childrenOfComponent(root, h)) {
        find(h, m, checkNotNull(c), found);
      }
      if (isMatching(root, m)) {
        found.add(m.supportedType().cast(root));
      }
    }
  
    @RunsInEDT
    private static <T extends Component> boolean isMatching(final @Nonnull Component c,
        final @Nonnull GenericTypeMatcher<T> m) {
      Boolean matching = execute(new GuiQuery<Boolean>() {
        @Override
        protected Boolean executeInEDT() {
          return m.matches(c);
        }
      });
      return checkNotNull(matching);
    }
  }
  