svn commit: r764106 - in /tapestry/tapestry5/trunk/tapestry-ioc/src/main/java/org/apache/tapestry5/ioc/internal/util: IdToDependencyNode.java idToDependencyNode.java

[hl...@apache.org]

Author: hlship
Date: Fri Apr 10 23:38:40 2009
New Revision: 764106

URL: http://svn.apache.org/viewvc?rev=764106&view=rev
Log:
Correct case of class name.

Added:
    tapestry/tapestry5/trunk/tapestry-ioc/src/main/java/org/apache/tapestry5/ioc/internal/util/IdToDependencyNode.java
      - copied, changed from r764094, tapestry/tapestry5/trunk/tapestry-ioc/src/main/java/org/apache/tapestry5/ioc/internal/util/idToDependencyNode.java
Removed:
    tapestry/tapestry5/trunk/tapestry-ioc/src/main/java/org/apache/tapestry5/ioc/internal/util/idToDependencyNode.java

Copied: tapestry/tapestry5/trunk/tapestry-ioc/src/main/java/org/apache/tapestry5/ioc/internal/util/IdToDependencyNode.java (from r764094, tapestry/tapestry5/trunk/tapestry-ioc/src/main/java/org/apache/tapestry5/ioc/internal/util/idToDependencyNode.java)
URL: http://svn.apache.org/viewvc/tapestry/tapestry5/trunk/tapestry-ioc/src/main/java/org/apache/tapestry5/ioc/internal/util/IdToDependencyNode.java?p2=tapestry/tapestry5/trunk/tapestry-ioc/src/main/java/org/apache/tapestry5/ioc/internal/util/IdToDependencyNode.java&p1=tapestry/tapestry5/trunk/tapestry-ioc/src/main/java/org/apache/tapestry5/ioc/internal/util/idToDependencyNode.java&r1=764094&r2=764106&rev=764106&view=diff
==============================================================================
--- tapestry/tapestry5/trunk/tapestry-ioc/src/main/java/org/apache/tapestry5/ioc/internal/util/idToDependencyNode.java (original)
+++ tapestry/tapestry5/trunk/tapestry-ioc/src/main/java/org/apache/tapestry5/ioc/internal/util/IdToDependencyNode.java Fri Apr 10 23:38:40 2009
@@ -29,214 +29,214 @@
  * Used to order objects into an "execution" order. Each object must have a unique id. It may specify a list of
  * constraints which identify the ordering of the objects.
  */
-public class idToDependencyNode<T>
+public class IdToDependencyNode<T>
 {
-    private final OneShotLock lock = new OneShotLock();
+  private final OneShotLock lock = new OneShotLock();
 
-    private final Logger logger;
+  private final Logger logger;
 
-    private final List<Orderable> orderables = CollectionFactory.newList();
+  private final List<Orderable> orderables = CollectionFactory.newList();
 
-    private final Map<String, Orderable<T>> idToOrderable = CollectionFactory.newCaseInsensitiveMap();
+  private final Map<String, Orderable<T>> idToOrderable = CollectionFactory.newCaseInsensitiveMap();
 
-    private final Map<String, DependencyNode<T>> idToDependencyNode = CollectionFactory.newCaseInsensitiveMap();
+  private final Map<String, DependencyNode<T>> idToDependencyNode = CollectionFactory.newCaseInsensitiveMap();
 
-    // Special node that is always dead last: all other nodes are a dependency
-    // of the trailer.
+  // Special node that is always dead last: all other nodes are a dependency
+  // of the trailer.
 
-    private DependencyNode<T> trailer;
+  private DependencyNode<T> trailer;
 
-    interface DependencyLinker<T>
+  interface DependencyLinker<T>
+  {
+    void link(DependencyNode<T> source, DependencyNode<T> target);
+  }
+
+  // before: source is added as a dependency of target, so source will
+  // appear before target.
+
+  final DependencyLinker<T> before = new DependencyLinker<T>()
+  {
+    public void link(DependencyNode<T> source, DependencyNode<T> target)
     {
-        void link(DependencyNode<T> source, DependencyNode<T> target);
+      target.addDependency(source);
     }
+  };
 
-    // before: source is added as a dependency of target, so source will
-    // appear before target.
+  // after: target is added as a dependency of source, so source will appear
+  // after target.
 
-    final DependencyLinker<T> before = new DependencyLinker<T>()
+  final DependencyLinker<T> after = new DependencyLinker<T>()
+  {
+    public void link(DependencyNode<T> source, DependencyNode<T> target)
     {
-        public void link(DependencyNode<T> source, DependencyNode<T> target)
-        {
-            target.addDependency(source);
-        }
-    };
+      source.addDependency(target);
+    }
+  };
 
-    // after: target is added as a dependency of source, so source will appear
-    // after target.
+  public IdToDependencyNode(Logger logger)
+  {
+    this.logger = logger;
+  }
 
-    final DependencyLinker<T> after = new DependencyLinker<T>()
-    {
-        public void link(DependencyNode<T> source, DependencyNode<T> target)
-        {
-            source.addDependency(target);
-        }
-    };
+  /**
+   * Adds an object to be ordered.
+   *
+   * @param orderable
+   */
+  public void add(Orderable<T> orderable)
+  {
+    lock.check();
 
-    public idToDependencyNode(Logger logger)
+    String id = orderable.getId();
+
+    if (idToOrderable.containsKey(id))
     {
-        this.logger = logger;
+      logger.warn(UtilMessages.duplicateOrderer(id));
+      return;
     }
 
-    /**
-     * Adds an object to be ordered.
-     *
-     * @param orderable
-     */
-    public void add(Orderable<T> orderable)
-    {
-        lock.check();
+    orderables.add(orderable);
 
-        String id = orderable.getId();
+    idToOrderable.put(id, orderable);
+  }
 
-        if (idToOrderable.containsKey(id))
-        {
-            logger.warn(UtilMessages.duplicateOrderer(id));
-            return;
-        }
+  /**
+   * Adds an object to be ordered.
+   *
+   * @param id          unique, qualified id for the target
+   * @param target      the object to be ordered (or null as a placeholder)
+   * @param constraints optional, variable constraints
+   * @see #add(org.apache.tapestry5.ioc.Orderable)
+   */
 
-        orderables.add(orderable);
+  public void add(String id, T target, String... constraints)
+  {
+    lock.check();
 
-        idToOrderable.put(id, orderable);
-    }
+    add(new Orderable<T>(id, target, constraints));
+  }
 
-    /**
-     * Adds an object to be ordered.
-     *
-     * @param id          unique, qualified id for the target
-     * @param target      the object to be ordered (or null as a placeholder)
-     * @param constraints optional, variable constraints
-     * @see #add(org.apache.tapestry5.ioc.Orderable)
-     */
+  public List<T> getOrdered()
+  {
+    lock.lock();
 
-    public void add(String id, T target, String... constraints)
-    {
-        lock.check();
+    initializeGraph();
 
-        add(new Orderable<T>(id, target, constraints));
-    }
+    List<T> result = newList();
 
-    public List<T> getOrdered()
+    for (Orderable<T> orderable : trailer.getOrdered())
     {
-        lock.lock();
+      T target = orderable.getTarget();
 
-        initializeGraph();
+      // Nulls are placeholders that are skipped.
 
-        List<T> result = newList();
+      if (target != null) result.add(target);
+    }
 
-        for (Orderable<T> orderable : trailer.getOrdered())
-        {
-            T target = orderable.getTarget();
+    return result;
+  }
 
-            // Nulls are placeholders that are skipped.
+  private void initializeGraph()
+  {
+    trailer = new DependencyNode<T>(logger, new Orderable<T>("*-trailer-*", null));
 
-            if (target != null) result.add(target);
-        }
+    addNodes();
 
-        return result;
-    }
+    addDependencies();
+  }
 
-    private void initializeGraph()
+  private void addNodes()
+  {
+    for (Orderable<T> orderable : orderables)
     {
-        trailer = new DependencyNode<T>(logger, new Orderable<T>("*-trailer-*", null));
+      DependencyNode<T> node = new DependencyNode<T>(logger, orderable);
 
-        addNodes();
+      idToDependencyNode.put(orderable.getId(), node);
 
-        addDependencies();
+      trailer.addDependency(node);
     }
+  }
 
-    private void addNodes()
+  private void addDependencies()
+  {
+    for (Orderable<T> orderable : orderables)
     {
-        for (Orderable<T> orderable : orderables)
-        {
-            DependencyNode<T> node = new DependencyNode<T>(logger, orderable);
-
-            idToDependencyNode.put(orderable.getId(), node);
-
-            trailer.addDependency(node);
-        }
+      addDependencies(orderable);
     }
+  }
 
-    private void addDependencies()
-    {
-        for (Orderable<T> orderable : orderables)
-        {
-            addDependencies(orderable);
-        }
-    }
+  private void addDependencies(Orderable<T> orderable)
+  {
+    String sourceId = orderable.getId();
 
-    private void addDependencies(Orderable<T> orderable)
+    for (String constraint : orderable.getConstraints())
     {
-        String sourceId = orderable.getId();
-
-        for (String constraint : orderable.getConstraints())
-        {
-            addDependencies(sourceId, constraint);
-        }
+      addDependencies(sourceId, constraint);
     }
+  }
 
-    private void addDependencies(String sourceId, String constraint)
-    {
-        int colonx = constraint.indexOf(':');
-
-        String type = colonx > 0 ? constraint.substring(0, colonx) : null;
+  private void addDependencies(String sourceId, String constraint)
+  {
+    int colonx = constraint.indexOf(':');
 
-        DependencyLinker<T> linker = null;
+    String type = colonx > 0 ? constraint.substring(0, colonx) : null;
 
-        if ("after".equals(type))
-            linker = after;
-        else if ("before".equals(type)) linker = before;
+    DependencyLinker<T> linker = null;
 
-        if (linker == null)
-        {
-            logger.warn(UtilMessages.constraintFormat(constraint, sourceId));
-            return;
-        }
+    if ("after".equals(type))
+      linker = after;
+    else if ("before".equals(type)) linker = before;
 
-        String patternList = constraint.substring(colonx + 1);
-
-        linkNodes(sourceId, patternList, linker);
+    if (linker == null)
+    {
+      logger.warn(UtilMessages.constraintFormat(constraint, sourceId));
+      return;
     }
 
-    private void linkNodes(String sourceId, String patternList, DependencyLinker<T> linker)
-    {
-        Collection<DependencyNode<T>> nodes = findDependencies(sourceId, patternList);
+    String patternList = constraint.substring(colonx + 1);
 
-        DependencyNode<T> source = idToDependencyNode.get(sourceId);
+    linkNodes(sourceId, patternList, linker);
+  }
 
-        for (DependencyNode<T> target : nodes)
-        {
-            linker.link(source, target);
-        }
-    }
+  private void linkNodes(String sourceId, String patternList, DependencyLinker<T> linker)
+  {
+    Collection<DependencyNode<T>> nodes = findDependencies(sourceId, patternList);
+
+    DependencyNode<T> source = idToDependencyNode.get(sourceId);
 
-    private Collection<DependencyNode<T>> findDependencies(String sourceId, String patternList)
+    for (DependencyNode<T> target : nodes)
     {
-        IdMatcher matcher = buildMatcherForPattern(patternList);
+      linker.link(source, target);
+    }
+  }
 
-        Collection<DependencyNode<T>> result = newList();
+  private Collection<DependencyNode<T>> findDependencies(String sourceId, String patternList)
+  {
+    IdMatcher matcher = buildMatcherForPattern(patternList);
 
-        for (String id : idToDependencyNode.keySet())
-        {
-            if (sourceId.equals(id)) continue;
+    Collection<DependencyNode<T>> result = newList();
 
-            if (matcher.matches(id)) result.add(idToDependencyNode.get(id));
-        }
+    for (String id : idToDependencyNode.keySet())
+    {
+      if (sourceId.equals(id)) continue;
 
-        return result;
+      if (matcher.matches(id)) result.add(idToDependencyNode.get(id));
     }
 
-    private IdMatcher buildMatcherForPattern(String patternList)
-    {
-        List<IdMatcher> matchers = newList();
+    return result;
+  }
 
-        for (String pattern : patternList.split(","))
-        {
-            IdMatcher matcher = new IdMatcherImpl(pattern.trim());
+  private IdMatcher buildMatcherForPattern(String patternList)
+  {
+    List<IdMatcher> matchers = newList();
 
-            matchers.add(matcher);
-        }
+    for (String pattern : patternList.split(","))
+    {
+      IdMatcher matcher = new IdMatcherImpl(pattern.trim());
 
-        return matchers.size() == 1 ? matchers.get(0) : new OrIdMatcher(matchers);
+      matchers.add(matcher);
     }
+
+    return matchers.size() == 1 ? matchers.get(0) : new OrIdMatcher(matchers);
+  }
 }