Coverage Report - com.lexicalscope.fluentreflection.TypeHierarchyCalculation
 
Classes in this File Line Coverage Branch Coverage Complexity
TypeHierarchyCalculation
96%
24/25
90%
9/10
2.2
 
 1  
 package com.lexicalscope.fluentreflection;
 2  
 
 3  
 /*
 4  
  * Copyright 2011 Tim Wood
 5  
  *
 6  
  * Licensed under the Apache License, Version 2.0 (the "License");
 7  
  * you may not use this file except in compliance with the License.
 8  
  * You may obtain a copy of the License at
 9  
  *
 10  
  * http://www.apache.org/licenses/LICENSE-2.0
 11  
  *
 12  
  * Unless required by applicable law or agreed to in writing, software
 13  
  * distributed under the License is distributed on an "AS IS" BASIS,
 14  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15  
  * See the License for the specific language governing permissions and
 16  
  * limitations under the License.
 17  
  */
 18  
 
 19  
 import java.util.ArrayList;
 20  
 import java.util.LinkedList;
 21  
 import java.util.List;
 22  
 
 23  
 import com.google.inject.TypeLiteral;
 24  
 
 25  
 final class TypeHierarchyCalculation {
 26  1588
     private final List<TypeLiteral<?>> done = new ArrayList<TypeLiteral<?>>();
 27  1588
     private final List<FluentClass<?>> result = new ArrayList<FluentClass<?>>();
 28  1588
     private final List<TypeLiteral<?>> pending = new LinkedList<TypeLiteral<?>>();
 29  
     private final ReflectedTypeFactory reflectedTypeFactory;
 30  
 
 31  1588
     public TypeHierarchyCalculation(final ReflectedTypeFactory reflectedTypeFactory) {
 32  1588
         this.reflectedTypeFactory = reflectedTypeFactory;
 33  1588
     }
 34  
 
 35  
     List<FluentClass<?>> interfacesAndSuperClass(final TypeLiteral<?> typeLiteral) {
 36  1588
         queueSuperclassAndInterfaces(typeLiteral);
 37  1492
         processesPendingTypes();
 38  1380
         return result;
 39  
     }
 40  
 
 41  
     private void processesPendingTypes() {
 42  3332
         while (!pending.isEmpty()) {
 43  460
             processClass(pending.remove(0));
 44  
         }
 45  1380
     }
 46  
 
 47  
     private void processClass(final TypeLiteral<?> klassToReflect) {
 48  460
         queueSuperclassAndInterfaces(klassToReflect);
 49  348
         if (done.contains(klassToReflect)) {
 50  0
             return;
 51  
         }
 52  348
         done.add(klassToReflect);
 53  348
         result.add(reflectedTypeFactory.reflect(klassToReflect));
 54  348
     }
 55  
 
 56  
     private void queueSuperclassAndInterfaces(final TypeLiteral<?> typeLiteralToReflect) {
 57  2048
         final Class<?> rawSuperclass = typeLiteralToReflect.getRawType().getSuperclass();
 58  2048
         if (rawSuperclass != null && !rawSuperclass.equals(Object.class)) {
 59  304
             pending.add(typeLiteralToReflect.getSupertype(rawSuperclass));
 60  
         }
 61  2048
         final Class<?>[] interfaces = typeLiteralToReflect.getRawType().getInterfaces();
 62  2412
         for (final Class<?> interfac3 : interfaces) {
 63  572
             pending.add(typeLiteralToReflect.getSupertype(interfac3));
 64  
         }
 65  1840
     }
 66  
 }