@Override public String getTypeName() { StringBuilder result = new StringBuilder(this.rawType.getTypeName()); if (this.typeArguments.length > 0) { result.append('<'); for (int i = 0; i < this.typeArguments.length; i++) { if (i > 0) { result.append(", "); } result.append(this.typeArguments[i].getTypeName()); } result.append('>'); } return result.toString(); }
private Class<?> getClass(Type type) { if (type instanceof Class) { return (Class<?>) type; } else { throw new RuntimeException( "Oops. That's a strange internal Ninja error.\n" + "Seems someone tried to convert a type into a class that is not a real class. ( " + type.getTypeName() + ")"); } }
@Override public boolean equals(Object obj) { if (this == obj) { return true; } else if (obj == null) { return false; } else if (!(obj instanceof Type)) { return false; } final Type other = (Type) obj; return Objects.equals(typeName, other.getTypeName()); }
/** * Checks if the specified type is a java {@link Optional}. * * @param type the type to check * @return <code>true</code> if Optional, else <code>false</code> */ private boolean isOptional(Type type) { return type.getTypeName().startsWith("java.lang.Optional"); }
/** * Returns the corresponding wrapper type for the specified primitive type. * If the type is not primitive, an exception is thrown. * * @param primitiveType the primitive type * @return the corresponding wrapper type */ public static Class<?> wrapperFor(Type primitiveType) { return requireNonNull(WRAPPERS.get(primitiveType.getTypeName()), "No wrapper found for type '" + primitiveType.getTypeName() + "'." ); }
/** * Returns {@code true} if the specified type is a primitive type. Wrapper * types does <em>not</em> count as primitives. * * @param type the type to check * @return {@code true} if it is primitive, else {@code false} */ public static boolean isPrimitive(Type type) { return WRAPPERS.keySet().contains(type.getTypeName()); }
@Override public String getTypeName() { StringBuilder result = new StringBuilder(this.rawType.getTypeName()); if (this.typeArguments.length > 0) { result.append('<'); for (int i = 0; i < this.typeArguments.length; i++) { if (i > 0) { result.append(", "); } result.append(this.typeArguments[i].getTypeName()); } result.append('>'); } return result.toString(); }
private ProcedureException javaToNeoMappingError( Type cls ) { List<String> types = Iterables.asList( javaToNeo.keySet() ) .stream() .map( Type::getTypeName ) .sorted( String::compareTo ) .collect( Collectors.toList() ); return new ProcedureException( Status.Statement.TypeError, "Don't know how to map `%s` to the Neo4j Type System.%n" + "Please refer to to the documentation for full details.%n" + "For your reference, known types are: %s", cls.getTypeName(), types ); }
@SuppressWarnings("unchecked") static <T extends Type> Class<T> getParameterizedTypeFromArray( TypeReference typeReference) throws ClassNotFoundException { java.lang.reflect.Type type = typeReference.getType(); java.lang.reflect.Type[] typeArguments = ((ParameterizedType) type).getActualTypeArguments(); String parameterizedTypeName = typeArguments[0].getTypeName(); return (Class<T>) Class.forName(parameterizedTypeName); }
/** * Creates a new {@code SimpleParameterizedType} based on the class name of * the specified class and the specified parameters. * * @param mainType the class to get the name from * @param parameters list of generic parameters to this type * @return the created type */ public static SimpleParameterizedType create(Type mainType, Type... parameters) { return create(mainType.getTypeName(), parameters); }
@Override protected String getJavadocRepresentText() { return "The generated base implementation of the {@link " + getSupport().entityType().getTypeName() + "}-interface."; }
@Override protected String getJavadocRepresentText() { return "The SqlAdapter for every {@link " + getSupport().entityType().getTypeName() + "} entity."; }
@Override protected String getJavadocRepresentText() { return "The generated Sql Adapter for a {@link " + getSupport().entityType().getTypeName() + "} entity."; }
@Override protected String getJavadocRepresentText() { return "The default implementation for the manager of every {@link " + getSupport().entityType().getTypeName() + "} entity."; } }
@Override protected String getJavadocRepresentText() { return "The generated base implementation for the manager of every {@link " + getSupport().entityType().getTypeName() + "} entity."; }
@Override protected String getJavadocRepresentText() { return "The default implementation of the {@link " + getSupport().entityType().getTypeName() + "}-interface."; } }
@Override protected String getJavadocRepresentText() { return "The generated base for the {@link " + getSupport().entityType().getTypeName() + "}-interface representing entities of the {@code " + getDocument().getId() + "}-table in the database."; }
@Test public void forClassWithGenerics() throws Exception { ResolvableType elementType = ResolvableType.forClassWithGenerics(Map.class, Integer.class, String.class); ResolvableType listType = ResolvableType.forClassWithGenerics(List.class, elementType); assertThat(listType.toString(), equalTo("java.util.List<java.util.Map<java.lang.Integer, java.lang.String>>")); assertThat(listType.getType().getTypeName(), equalTo("java.util.List<java.util.Map<java.lang.Integer, java.lang.String>>")); assertThat(listType.getType().toString(), equalTo("java.util.List<java.util.Map<java.lang.Integer, java.lang.String>>")); }
/** * Adds an {@link DefaultJavadocTag#SEE}-tag that references the specified * Java type. * * @param type the type to reference in the {@code see}-tag * @return a reference to this */ default T see(final Type type) { return add(DefaultJavadocTag.SEE.setValue("{@link " + Formatting.shortName(type.getTypeName()) + "}")) .add(Import.of(type)); }
@Test public void javaDocSample() throws Exception { ResolvableType t = ResolvableType.forField(getClass().getDeclaredField("myMap")); assertThat(t.toString(), equalTo("java.util.HashMap<java.lang.Integer, java.util.List<java.lang.String>>")); assertThat(t.getType().getTypeName(), equalTo("java.util.HashMap<java.lang.Integer, java.util.List<java.lang.String>>")); assertThat(t.getType().toString(), equalTo("java.util.HashMap<java.lang.Integer, java.util.List<java.lang.String>>")); assertThat(t.getSuperType().toString(), equalTo("java.util.AbstractMap<java.lang.Integer, java.util.List<java.lang.String>>")); assertThat(t.asMap().toString(), equalTo("java.util.Map<java.lang.Integer, java.util.List<java.lang.String>>")); assertThat(t.getGeneric(0).resolve(), equalTo(Integer.class)); assertThat(t.getGeneric(1).resolve(), equalTo(List.class)); assertThat(t.getGeneric(1).toString(), equalTo("java.util.List<java.lang.String>")); assertThat(t.resolveGeneric(1, 0), equalTo(String.class)); }