How to use

SimpleTypeInfo

in

br.com.objectos.way.code

private TypeName returnType() {
 return methodInfo
   .returnTypeInfo()
   .typeName();
}

public static FieldMethod code(Property property, AnnotationInfo fieldAnnotation) {
 SimpleTypeInfo returnTypeInfo = property.returnTypeInfo();
 return returnTypeInfo.isInfoOf(Optional.class)
   ? OptionalMethod.code(property, fieldAnnotation, returnTypeInfo)
   : StandardMethod.code(property, fieldAnnotation, returnTypeInfo);
}

public String getGetterPrefix() {
 return kind().getGetterPrefix(nameInfo());
}

@Override
public final int hashCode() {
 return Objects.hashCode(packageInfo(), simpleName());
}

public boolean isSubType(Class<?> maybeSuperType) {
 try {
  String qualifiedName = qualifiedName();
  Class<?> theClass = Class.forName(qualifiedName);
  return maybeSuperType.isAssignableFrom(theClass);
 } catch (ClassNotFoundException e) {
  return isInfoOf(maybeSuperType);
 }
}

@Override
public MustacheObject toMustache() {
 return Mustaches.toMustacheHelper()
   .add("package", packageInfo().orNull())
   .add("name", getDeclaredName())
   .add("simpleName", simpleName())
   .add("qualifiedName", toString())
   .add("rawName", getRawName())
   .add("varName", varName())
   .add("primitive", isPrimitive())
   .toMustache();
}

public Set<ImportInfo> toImportInfo() {
 Set<ImportInfo> importInfoSet = newHashSet();
 PackageInfoToImportInfo toImportInfo = new PackageInfoToImportInfo(nameInfo());
 Optional<ImportInfo> maybeImportInfo = packageInfo()
   .transform(toImportInfo);
 if (maybeImportInfo.isPresent()) {
  ImportInfo importInfo = maybeImportInfo.get();
  importInfoSet.add(importInfo);
 }
 List<TypeParameterInfo> typeParameterInfoList = typeParameterInfoList();
 for (TypeParameterInfo typeParameterInfo : typeParameterInfoList) {
  Set<ImportInfo> importInfo = typeParameterInfo.toSimpleTypeInfo()
    .toImportInfo();
  importInfoSet.addAll(importInfo);
 }
 return importInfoSet;
}

@Override
public boolean isEqual(SimpleTypeInfo that) {
 return Testables.isEqualHelper()
   .equal(packageInfo(), that.packageInfo())
   .equal(nameInfo(), that.nameInfo())
   .equal(typeParameterInfoList(), that.typeParameterInfoList())
   .result();
}

void recordBuilderCode(Body body) {
 SimpleTypeInfo returnTypeInfo = property.returnTypeInfo();
 if (returnTypeInfo.isPrimitive()) {
  body.add(".$L(record.$LValue())", property.name(), returnTypeInfo.simpleName());
 } else {
  body.add(".$L(record.<$T> get())", property.name(), returnTypeInfo.typeName());
 }
}

@Override
NameInfo nameInfo() {
 return delegate.nameInfo();
}

private TypeName toTypeName0(SimpleTypeInfo simpleTypeInfo, Function<TypeParameterInfo, TypeName> f) {
 NameInfo nameInfo = simpleTypeInfo.nameInfo();
 Optional<PackageInfo> packageInfo = simpleTypeInfo.packageInfo();
 ClassName className = nameInfo.toClassName(packageInfo.get());
 TypeName[] genericTypeNameArray = simpleTypeInfo.getTypeParameterInfoIterable()
   .transform(f)
   .toImmutableList()
   .toArray(new TypeName[] {});
 return genericTypeNameArray.length == 0
   ? className
   : ParameterizedTypeName.get(className, genericTypeNameArray);
}

public String getRawName() {
 String simpleName = nameInfo().getSimpleName();
 StringBuilder name = new StringBuilder(simpleName);
 List<TypeParameterInfo> typeParameterInfoList = typeParameterInfoList();
 TypeParameterInfoMap map = TypeParameterInfoMap.mapOf(typeParameterInfoList);
 name.append(map.toStringRaw());
 return name.toString();
}

public String qualifiedName() {
 String res = nameInfo().toString();
 Optional<? extends PackageInfo> packageInfo = packageInfo();
 if (packageInfo.isPresent()) {
  PackageInfo pkg = packageInfo.get();
  res = pkg.toImportInfo(nameInfo())
    .toString();
 }
 return res;
}

@Override
SimpleTypeInfoKind kind() {
 return delegate.kind();
}

@AutoFunctional
public boolean hasReturnTypeInfo(SimpleTypeInfo typeInfo) {
 return returnTypeInfo().equals(typeInfo);
}

@Override
public SimpleTypeInfo build() {
 SimpleTypeInfo simpleTypeInfo = SimpleTypeInfo.newType()
   .packageInfo(Optional.fromNullable(packageInfo))
   .nameInfo(name)
   .typeParameterInfoList(typeParameterInfoList)
   .build();
 if (primitive) {
  simpleTypeInfo = SimpleTypeInfo.newPrimitive()
    .packageInfo(Optional.fromNullable(packageInfo))
    .nameInfo(name)
    .typeParameterInfoList(typeParameterInfoList)
    .build();
 }
 if (typeVariable) {
  simpleTypeInfo = SimpleTypeInfo.newTypeVariable()
    .packageInfo(Optional.fromNullable(packageInfo))
    .nameInfo(name)
    .typeParameterInfoList(typeParameterInfoList)
    .build();
 }
 return new ForwardingSimpleTypeInfo(simpleTypeInfo, typeInfo);
}

@Override
List<TypeParameterInfo> typeParameterInfoList() {
 return delegate.typeParameterInfoList();
}

private static SimpleTypeInfo named(String name) {
 return SimpleTypeInfo.newPrimitive()
   .packageInfo(Optional.<PackageInfo> absent())
   .nameInfo(NameInfo.of(name))
   .typeParameterInfoList(ImmutableList.<TypeParameterInfo> of())
   .build();
}

@Override
Optional<PackageInfo> packageInfo() {
 return component.packageInfo();
}

@Override
public SimpleTypeInfo toSimpleTypeInfo() {
 return component.toSimpleTypeInfo().toArray();
}