/*

  * 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.

  */

 package org.apache.commons.classscan.util;

 import java.lang.reflect.Array;

 import java.util.Arrays;

 import java.util.Collection;

 import java.util.Comparator;

 import org.apache.commons.classscan.HasName;

 import org.apache.commons.classscan.spi.model.HasResolve;

 public class NameSet<V extends HasName & HasResolve> extends ResolveSet<V> {

     private final static Comparator<HasName> REVERSE_COMPARE = new Comparator<HasName>() {

         @Override

         public int compare(HasName l, HasName r) {

             String left = l.getName();

             String right = r.getName();

             // "quick" compare

             int diff = left.length() - right.length();

             if (diff != 0) {

                 return diff;

             }

             // compare from end of strings - the names probably have long equivalent prefixes

             for (int i = left.length(); --i > 0;) {

                 int d = left.charAt(i) - right.charAt(i);

                 if (d != 0) {

                     return d;

                 }

             }

             return 0;

         }

     };

     public NameSet(V[] values) {

         super(values);

         if(values!=null && values.length>0) {

             Arrays.sort(values, REVERSE_COMPARE);

         }

     }

     public NameSet(Class<V> clss, Collection<? extends V> workValues) {

         this(collectionToArray(clss, workValues));

      }

     private static <D extends HasName> D[] collectionToArray(Class<D> collectionType, Collection<? extends D> workValues) {

         if(workValues.isEmpty()) {

             return null;

         }

         @SuppressWarnings("unchecked")

         D[] newInstance = (D[]) Array.newInstance(collectionType, workValues.size());

         return workValues.toArray(newInstance);

     }

     public V getValue(final String name) {

         int idx= Arrays.binarySearch(values, new HasName() {

             @Override

             public String getName() {

                 return name;

             }

         }, REVERSE_COMPARE);

         return idx<0 ? null : values[idx];

     }

     private static interface NameResolve extends HasName, HasResolve {};

         private static NameSet<NameResolve> EMPTY_SET = new NameSet<NameResolve>(new NameResolve[0]);

         public static <V extends  HasName & HasResolve> NameSet<V> emptyNameSet() {

                 NameSet<?> qrc = (NameSet<?>) EMPTY_SET;

                 @SuppressWarnings("unchecked")

                 NameSet<V> rc = (NameSet<V>) qrc;

                 return rc;

         }

 }