package org.apache.maven.util;
   
   /* ====================================================================
    *   Licensed to the Apache Software Foundation (ASF) under one or more
    *   contributor license agreements.  See the NOTICE file distributed with
    *   this work for additional information regarding copyright ownership.
    *   The ASF licenses this file to You 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.
   * ====================================================================
   */
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Set;
  
  /**
   * Set class that maintain insertion order (first wins). This is necessary because the only alternatives are
   * LinkedHashSet (JDK 1.4), or SetUtils.orderedSet (commons-collections-3.0), both of which are problematic for
   * Maven to require.
   *
   * @author <a href="mailto:brett@apache.org">Brett Porter</a>
   * @version $Id: InsertionOrderedSet.java 517014 2007-03-11 21:15:50Z ltheussl $
   */
  public class InsertionOrderedSet
      implements Set
  {
      private List order = new ArrayList();
  
      private Set set = new HashSet();
  
      public InsertionOrderedSet()
      {
      }
  
      public InsertionOrderedSet( Collection c )
      {
          addAll( c );
      }
  
      public Iterator iterator()
      {
          return new InsertionOrderedSetIterator();
      }
  
      public boolean isEmpty()
      {
          return set.isEmpty();
      }
  
      public int size()
      {
          return set.size();
      }
  
      public void clear()
      {
          set.clear();
          order.clear();
      }
  
      public boolean add( Object o )
      {
          if ( !set.contains( o ) )
          {
              set.add( o );
              return order.add( o );
          }
          return false;
      }
  
      public boolean containsAll( Collection c )
      {
          return set.containsAll( c );
      }
  
      public boolean addAll( Collection c )
      {
          boolean retVal = false;
  
          for ( Iterator i = c.iterator(); i.hasNext(); )
          {
              boolean result = add( i.next() );
              retVal = retVal || result;
          }
          return retVal;
      }
  
     public boolean removeAll( Collection c )
     {
         order.removeAll( c );
         return set.removeAll( c );
     }
 
     public boolean retainAll( Collection c )
     {
         order.retainAll( c );
         return set.retainAll( c );
     }
 
     public boolean contains( Object o )
     {
         return set.contains( o );
     }
 
     public Object[] toArray()
     {
         return order.toArray();
     }
 
     public Object[] toArray( Object[] a )
     {
         return order.toArray( a );
     }
 
     public boolean remove( Object o )
     {
         if ( set.remove( o ) )
         {
             order.remove( o );
             return true;
         }
         return false;
     }
 
     public String toString()
     {
         return order.toString();
     }
 
     public boolean equals( Object o )
     {
         return set.equals( o );
     }
 
     public int hashCode()
     {
         return set.hashCode();
     }
 
     private class InsertionOrderedSetIterator
         implements Iterator
     {
         private Iterator i;
 
         private Object current = null;
 
         private InsertionOrderedSetIterator()
         {
             i = order.iterator();
         }
 
         public boolean hasNext()
         {
             return i.hasNext();
         }
 
         public Object next()
         {
             current = i.next();
             return current;
         }
 
         public void remove()
         {
             i.remove();
             set.remove( current );
         }
     }
 }