breaking: Name are composed by a Type and a String

Before the Name was a couple (Class, String), from now on it's a
couple (Type, String). The string stay the same, but the Class becomes a Type.
Like this we will have a better granularity in order to inject parameterized types.

This commit is breaking because the Name class was having a public constructor with a class, and
the class have been changed to a Type.
WIP: Should we really have a public constructor ?! Personally I think that only private constructors
and public static factories should be enough.

If you want to build a name with a type, there is multiple solutions. If you want to use a simple generic type
(only one depth of generic) like `SomeGeneric<SomeType>`, the easiest way is to use this signature:
```java
Name.of(aStringName, SomeGeneric.class, SomeType.class)
```
This method is using the `Types.newParameterizedType` static factory, which is an easy way to build parameterized types.
An equivalent technique would be to use something like this:
```java
Name.of(Types.newParameterizedType(SomeGeneric.class, SomeType.class), aStringName)
```
(It will be almost equivalent, as the first way will be a little bit more efficient, as the raw type will not be calculated,
it is already given in parameter: `SomeGeneric.class`)

If you need to build a complex generic type, like `One<Two<Three, Four<Five>>>`, the easiest way will be to use the abstract
class `TypeReference` like this:
```java
Name.of(new TypeReference<One<Two<Three, Four<Five>>>() {}, aStringName)
```

restx-common/src/main/java/restx/common/MoreObjects.java

@@ -1,5 +1,8 @@
 package restx.common;
 
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
 /**
  * Date: 29/11/13
  * Time: 11:13
@@ -12,6 +15,24 @@ public static String toString(Class clazz) {
         return clazz.getName() + "[" + toString(clazz.getClassLoader()) + "]";
     }
 
+	public static String toString(Type type) {
+		if (type == null) {
+			return "null";
+		}
+        String typeString;
+        /*
+            in jse8 another case should be done, using type.getTypeName() if
+            type is an instanceof ParameterizedType
+         */
+        if (type instanceof Class) {
+            typeString = ((Class) type).getName();
+        } else {
+            typeString = String.valueOf(type);
+        }
+
+		return  typeString + "[" + toString(Types.getRawType(type).getClassLoader()) + "]";
+	}
+
     public static String toString(ClassLoader classLoader) {
         if (classLoader == null) {
             return "";

restx-factory/src/main/java/restx/factory/Name.java

@@ -1,56 +1,90 @@
 package restx.factory;
 
-import restx.common.MoreObjects;
-
 import static com.google.common.base.Preconditions.checkNotNull;
 
+
+import java.lang.reflect.Type;
+import restx.common.MoreObjects;
+import restx.common.TypeReference;
+import restx.common.Types;
+
 /**
  * User: xavierhanin
  * Date: 1/31/13
  * Time: 5:40 PM
  */
 public final class Name<T> {
     private final String name;
-    private final Class<T> clazz;
+	private final Type type;
+	private final Class<T> rawType;
 
     public static <T> Name<T> of(Class<T> clazz, String name) {
-        return new Name<>(clazz, name);
+        return new Name<>(clazz, clazz, name);
     }
 
     public static <T> Name<T> of(Class<T> clazz) {
-        return new Name<>(clazz, clazz.getSimpleName());
+        return new Name<>(clazz, clazz, clazz.getSimpleName());
     }
 
-    public Name(Class<T> clazz, String name) {
+	public static <T> Name<T> of(Type type, String name) {
+		return new Name<>(type, name);
+	}
+
+	@SuppressWarnings("unchecked")
+	public static <T> Name<T> of(Type type) {
+		Class<T> rawType = (Class<T>) Types.getRawType(type);
+		return new Name<>(type, rawType, rawType.getSimpleName());
+	}
+
+	@SuppressWarnings("unchecked")
+	public static <T> Name<T> of(String name, Class<?> rawType, Type... arguments) {
+		return (Name<T>) new Name<>(Types.newParameterizedType(rawType, arguments), rawType, name);
+	}
+
+	public static <T> Name<T> of(TypeReference<T> typeReference, String name) {
+		return new Name<>(checkNotNull(typeReference).getType(), name);
+	}
+
+	@SuppressWarnings("unchecked")
+	public Name(Type type, String name) {
+		this(type,  (Class<T>) Types.getRawType(type), name);
+	}
+
+    private Name(Type type, Class<T> rawType, String name) {
         this.name = checkNotNull(name);
-        this.clazz = checkNotNull(clazz);
+		this.type = checkNotNull(type);
+		this.rawType = checkNotNull(rawType);
     }
 
     public String getSimpleName() {
-        String simpleName = clazz.getSimpleName();
+        String simpleName = String.valueOf(type);
         if (!simpleName.equalsIgnoreCase(name)) {
             simpleName = name + "[" + simpleName + "]";
         }
         return simpleName;
     }
 
     public String asId() {
-        return "[" + clazz.getName() + "]" + name;
+        return "[" + String.valueOf(type) + "]" + name;
     }
 
     public String getName() {
         return name;
     }
 
+	public Type getType() {
+		return type;
+	}
+
     public Class<T> getClazz() {
-        return clazz;
-    }
+		return rawType;
+	}
 
     @Override
     public String toString() {
         return "Name{" +
                 "name='" + name + '\'' +
-                ", clazz=" + MoreObjects.toString(clazz) +
+                ", type=" + MoreObjects.toString(type) +
                 '}';
     }
 
@@ -61,7 +95,8 @@ public boolean equals(Object o) {
 
         Name name1 = (Name) o;
 
-        if (!clazz.equals(name1.clazz)) return false;
+        if (!rawType.equals(name1.rawType)) return false;
+        if (!type.equals(name1.type)) return false;
         if (!name.equals(name1.name)) return false;
 
         return true;
@@ -70,7 +105,8 @@ public boolean equals(Object o) {
     @Override
     public int hashCode() {
         int result = name.hashCode();
-        result = 31 * result + clazz.hashCode();
+        result = 31 * result + rawType.hashCode();
+		result = 31 * result + type.hashCode();
         return result;
     }
 }

restx-factory/src/main/java/restx/factory/NamedComponent.java

@@ -1,8 +1,11 @@
 package restx.factory;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+
+
 import com.google.common.base.Function;
 
-import static com.google.common.base.Preconditions.checkNotNull;
+import java.lang.reflect.Type;
 
 /**
  * User: xavierhanin
@@ -29,13 +32,23 @@ public T apply(NamedComponent<T> namedComponent) {
     }
 
     public static <T> NamedComponent<T> of(Class<T> clazz, String name, T component) {
-        return new NamedComponent<>(new Name<>(clazz, name), component);
+        return new NamedComponent<>(Name.of(clazz, name), component);
     }
 
     public static <T> NamedComponent<T> of(Class<T> clazz, String name, int priority, T component) {
-        return new NamedComponent<>(new Name<>(clazz, name), priority, component);
+        return new NamedComponent<>(Name.of(clazz, name), priority, component);
     }
 
+	@SuppressWarnings("unchecked")
+	public static <T> NamedComponent<T> of(Type type, String name, T component) {
+		return new NamedComponent<>((Name<T>) Name.of(type, name), component);
+	}
+
+	@SuppressWarnings("unchecked")
+	public static <T> NamedComponent<T> of(Type type, String name, int priority, T component) {
+		return new NamedComponent<>((Name<T>) Name.of(type, name), priority, component);
+	}
+
     private final Name<T> name;
     private final int priority;
     private final T component;

restx-factory/src/test/java/restx/factory/FactoryTest.java

@@ -1,15 +1,17 @@
 package restx.factory;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+import static restx.factory.Factory.LocalMachines.threadLocal;
+
+
 import com.google.common.base.Optional;
 import com.google.common.collect.ImmutableMap;
 import org.junit.After;
 import org.junit.Test;
 
 import java.util.Set;
 
-import static org.assertj.core.api.Assertions.*;
-import static restx.factory.Factory.LocalMachines.threadLocal;
-
 /**
  * User: xavierhanin
  * Date: 1/31/13
@@ -179,12 +181,12 @@ public void should_fail_with_missing_deps() throws Exception {
             assertThat(e)
                 .hasMessageStartingWith(
                     "\n" +
-                            "  QueryByName{name=Name{name='test', clazz=java.lang.String[]}}\n" +
-                            "    |       \\__=> Name{name='test', clazz=java.lang.String[]}\n" +
+                            "  QueryByName{name=Name{name='test', type=class java.lang.String[]}}\n" +
+                            "    |       \\__=> Name{name='test', type=class java.lang.String[]}\n" +
                             "    |\n" +
-                            "    +-> QueryByName{name=Name{name='missing', clazz=java.lang.String[]}}\n" +
+                            "    +-> QueryByName{name=Name{name='missing', type=class java.lang.String[]}}\n" +
                             "          |\n" +
-                            "          +--: Name{name='missing', clazz=java.lang.String[]} can't be satisfied")
+                            "          +--: Name{name='missing', type=class java.lang.String[]} can't be satisfied")
             ;
         }
     }
@@ -217,9 +219,9 @@ public void should_find_one_when_multiple_available_fail() throws Exception {
                             " Please select which one you want with a more specific query,\n" +
                             " or by deactivating one of the available components.\n" +
                             " Available components:\n" +
-                            " - NamedComponent{name=Name{name='test', clazz=java.lang.String[]}, priority=0, component=value1}\n" +
+                            " - NamedComponent{name=Name{name='test', type=class java.lang.String[]}, priority=0, component=value1}\n" +
                             "         [Activation key: 'restx.activation::java.lang.String::test']\n" +
-                            " - NamedComponent{name=Name{name='test2', clazz=java.lang.String[]}, priority=0, component=value1}\n" +
+                            " - NamedComponent{name=Name{name='test2', type=class java.lang.String[]}, priority=0, component=value1}\n" +
                             "         [Activation key: 'restx.activation::java.lang.String::test2']\n")
             ;
         }