/* $Id: DependencyResolver.java 18318 2010-04-20 21:52:26Z euluis $

  *****************************************************************************

  * Copyright (c) 2010 Contributors - see below

  * All rights reserved. This program and the accompanying materials

  * are made available under the terms of the Eclipse Public License v1.0

  * which accompanies this distribution, and is available at

  * http://www.eclipse.org/legal/epl-v10.html

  *

  * Contributors:

  *    Luis Sergio Oliveira (euluis)

  *****************************************************************************

  */

 package org.argouml.profile.internal;

 import java.util.Collections;

 import java.util.HashSet;

 import java.util.Collection;

 import org.apache.log4j.Logger;

 /**

  * A dependency resolver for items of type T. It implements a state-full

  * dependency resolution algorithm.

  *

  * @author Luis Sergio Oliveira (euluis)

  * @param <T> the type of items for which dependencies will be resolved.

  */

 class DependencyResolver<T> {

     private static final Logger LOG = Logger.getLogger(

             DependencyResolver.class);

     private DependencyChecker<T> checker;

     /**

      * WARNING: only to be used from outside classes by tests.

      * This is the state-full part of the algorithm, storing the unresolved

      * items between resolve methods calls.

      */

     Collection<T> unresolvedItems;

     /**

      * Create a dependency resolver and initialize it with the associated

      * dependency checker.

      *

      * @param checker the object that will be invoked to check if for a certain

      *                item all dependencies are resolved.

      */

     DependencyResolver(DependencyChecker<T> checker) {

         this.checker = checker;

         unresolvedItems = new HashSet<T>();

     }

     /**

      * Attempt to resolve the dependencies of the items already handed over to

      * the resolver instance.

      */

     void resolve() {

         if (unresolvedItems.isEmpty()) {

             return;

         }

         final Collection<T> items = Collections.emptyList();

         resolve(items);

     }

     /**

      * Attempt to resolve the dependencies of the items already handed over to

      * the resolver instance and the additional items handed over now.

      *

      * @param items additional items to resolve.

      */

     void resolve(Collection<T> items) {

         if (unresolvedItems.isEmpty() && items.isEmpty()) {

             return;

         }

         Collection<T> allUnresolvedItems = new HashSet<T>();

         allUnresolvedItems.addAll(items);

         allUnresolvedItems.addAll(unresolvedItems);

         if (LOG.isDebugEnabled()) {

             LOG.debug(items2Msg("Attempt to resolve the following items:",

                 allUnresolvedItems));

         }

         Collection<T> resolved = internalResolve(allUnresolvedItems);

         allUnresolvedItems.removeAll(resolved);

         unresolvedItems.clear();

         unresolvedItems.addAll(allUnresolvedItems);

         if (!unresolvedItems.isEmpty()) {

             LOG.warn(items2Msg(

                 "The following items were left unresolved after attempt:\n",

                 unresolvedItems));

         }

     }

     private String items2Msg(String preface, Collection<T> items) {

         StringBuffer msg = new StringBuffer(preface);

         for (T item : items) {

             msg.append("\t");

             msg.append(item.toString());

             msg.append("\n");

         }

         return msg.toString();

     }

     /**

      * Recursively resolve all dependencies. Stops when an iteration through

      * all unresolved items didn't manage to resolve any.

      * 

      * @param items items to resolve.

      * @return the items that were resolved.

      */

     private Collection<T> internalResolve(Collection<T> items) {

         Collection<T> resolved = new HashSet<T>();

         for (T item : items) {

             if (checker.check(item)) {

                 resolved.add(item);

             }

         }

         HashSet<T> toResolveItems = new HashSet<T>(items);

         toResolveItems.removeAll(resolved);

         if (!resolved.isEmpty()) {

             resolved.addAll(internalResolve(toResolveItems));

         }

         return resolved;

     }

 }