How to use

DeclaredTypeName

in

com.yahoo.aptutils.model

@Override
public DeclaredTypeName getPropertyType() {
  DeclaredTypeName jsonProperty = JSONTypes.JSON_PROPERTY.clone();
  jsonProperty.setTypeArgs(Collections.singletonList(fieldType));
  return jsonProperty;
}

  private boolean checkFirstArgType(TypeMirror type, DeclaredTypeName generatedClassName) {
    if (type instanceof ErrorType) {
      return true;
    }
    if (!(type instanceof DeclaredType)) {
      return false;
    }

    DeclaredTypeName typeName = (DeclaredTypeName) utils.getTypeNameFromTypeMirror(type);

    return typeName.equals(generatedClassName) || typeName.equals(TypeConstants.ABSTRACT_MODEL);
  }
}

  @Override
  protected PropertyGenerator getPropertyGenerator(VariableElement field, DeclaredTypeName fieldType) {
    // We know it's an EnumProperty, so extract the type arg
    List<? extends TypeName> typeArgs = fieldType.getTypeArgs();
    if (typeArgs != null && typeArgs.size() == 1 && typeArgs.get(0) instanceof DeclaredTypeName) {
      return new EnumPropertyGenerator(modelSpec, field, utils, (DeclaredTypeName) typeArgs.get(0));
    }
    utils.getMessager().printMessage(Kind.WARNING,
        "EnumProperty must use a declared type argument; it cannot be raw or use a generic type argument",
        field);
    return null;
  }
}

private DeclaredTypeName extractGetAndSetType() {
  String basicType = propertyType.toString().replace(TypeConstants.PROPERTY.toString(), "")
      .replace("Property", "")
      .replace(".", "");
  if ("Blob".equals(basicType)) {
    return TypeConstants.BYTE_ARRAY;
  } else {
    return new DeclaredTypeName("java.lang", basicType);
  }
}

@Override
protected void registerAdditionalImports(Set<DeclaredTypeName> imports) {
  super.registerAdditionalImports(imports);
  imports.add(JSONTypes.JSON_PROPERTY_SUPPORT);
  imports.add(JSONTypes.JSON_PROPERTY);
  if (!AptUtils.isEmpty(fieldType.getTypeArgs())) {
    imports.add(JSONTypes.PARAMETERIZED_TYPE_BUILDER);
  }
  fieldType.accept(new ImportGatheringTypeNameVisitor(), imports);
}

@Override
public boolean processVariableElement(VariableElement field, DeclaredTypeName fieldType) {
  boolean isViewProperty = TypeConstants.isBasicPropertyType(fieldType);
  ViewQuery isViewQuery = field.getAnnotation(ViewQuery.class);
  if (TypeConstants.isVisibleConstant(field)) {
    if (isViewQuery != null) {
      if (!TypeConstants.QUERY.equals(fieldType)) {
        modelSpec.logError("ViewQuery must be an instance of " + TypeConstants.QUERY.toString(), field);
      } else if (modelSpec.hasMetadata(ViewModelSpecWrapper.METADATA_KEY_QUERY_ELEMENT)) {
        modelSpec.logError("Only one ViewQuery can be declared per spec", field);
      } else {
        modelSpec.putMetadata(ViewModelSpecWrapper.METADATA_KEY_VIEW_QUERY, isViewQuery);
        modelSpec.putMetadata(ViewModelSpecWrapper.METADATA_KEY_QUERY_ELEMENT, field);
      }
      return true;
    } else {
      return super.processVariableElement(field, fieldType);
    }
  } else if (isViewProperty) {
    modelSpec.logError("View properties must be static final and non-private", field);
  }
  return false;
}

      utils.getAnnotationValueFromMirror(spec, "interfaceTypeArgNames"), String.class);
  for (String typeArgName : typeArgNames) {
    typeArgs.add(new DeclaredTypeName(typeArgName));
interfaceClass.setTypeArgs(typeArgs);
interfaces.add(interfaceClass);

public ModelSpec(TypeElement modelSpecElement, Class<T> modelSpecClass,
    PluginEnvironment pluginEnv, AptUtils utils) {
  this.utils = utils;
  this.modelSpecElement = modelSpecElement;
  this.modelSpecName = new DeclaredTypeName(modelSpecElement.getQualifiedName().toString());
  this.modelSpecAnnotation = modelSpecElement.getAnnotation(modelSpecClass);
  this.generatedClassName = new DeclaredTypeName(modelSpecName.getPackageName(), getGeneratedClassNameString());
  this.pluginEnvironment = pluginEnv;
  this.pluginBundle = pluginEnv.getPluginBundleForModelSpec(this);
  processVariableElements();
  pluginBundle.afterProcessVariableElements();
  modelSuperclass = initializeModelSuperclass();
}

@Override
public void afterEmitSchema(JavaFileWriter writer) throws IOException {
  writer.writeComment("--- constants");
  for (VariableElement constant : constantElements) {
    writeConstantField(writer, modelSpec.getModelSpecName(), constant);
  }
  for (Map.Entry<String, List<VariableElement>> innerClassConstant : innerClassConstants.entrySet()) {
    String classNameString = innerClassConstant.getKey();
    DeclaredTypeName constClassName = new DeclaredTypeName(null,
        modelSpec.getModelSpecName().getSimpleName() + "." + classNameString);
    for (VariableElement element : innerClassConstant.getValue()) {
      writeConstantField(writer, constClassName, element);
    }
  }
  writer.writeNewline();
}

@Override
protected DeclaredTypeName getDefaultModelSuperclass() {
  if (superclass == null) {
    return new DeclaredTypeName(getSpecAnnotation().inheritsFrom());
  }
  return superclass;
}

public static boolean isPrimitiveType(DeclaredTypeName type) {
  return AptUtils.isEmpty(type.getPackageName());
}

@Override
public void emitAdditionalJava(JavaFileWriter writer) throws IOException {
  List<ErrorInfo> errors = modelSpec.getLoggedErrors();
  if (errors.size() > 0) {
    writer.writeExpression(new ModelGenErrorsExpression(errors))
        .writeNewline();
    TypeDeclarationParameters dummyErrorClass = new TypeDeclarationParameters()
        .setModifiers(Modifier.STATIC, Modifier.FINAL)
        .setName(new DeclaredTypeName(modelSpec.getGeneratedClassName().toString(), "LoggedErrors"))
        .setKind(JavaFileWriter.Type.CLASS);
    writer.beginTypeDefinition(dummyErrorClass);
    writer.writeComment("Dummy class for holding logged error annotations");
    writer.finishTypeDefinition();
  }
}

@Override
public boolean processVariableElement(VariableElement field, DeclaredTypeName fieldType) {
  boolean isViewProperty = TypeConstants.isBasicPropertyType(fieldType);
  ViewQuery isViewQuery = field.getAnnotation(ViewQuery.class);
  if (TypeConstants.isVisibleConstant(field)) {
    if (isViewQuery != null) {
      if (!TypeConstants.QUERY.equals(fieldType)) {
        modelSpec.logError("ViewQuery must be an instance of " + TypeConstants.QUERY.toString(), field);
      } else if (modelSpec.hasMetadata(ViewModelSpecWrapper.METADATA_KEY_QUERY_ELEMENT)) {
        modelSpec.logError("Only one ViewQuery can be declared per spec", field);
      } else {
        modelSpec.putMetadata(ViewModelSpecWrapper.METADATA_KEY_VIEW_QUERY, isViewQuery);
        modelSpec.putMetadata(ViewModelSpecWrapper.METADATA_KEY_QUERY_ELEMENT, field);
      }
      return true;
    } else {
      return super.processVariableElement(field, fieldType);
    }
  } else if (isViewProperty) {
    modelSpec.logError("View properties must be static final and non-private", field);
  }
  return false;
}

      utils.getAnnotationValueFromMirror(spec, "interfaceTypeArgNames"), String.class);
  for (String typeArgName : typeArgNames) {
    typeArgs.add(new DeclaredTypeName(typeArgName));
interfaceClass.setTypeArgs(typeArgs);
interfaces.add(interfaceClass);

public ModelSpec(TypeElement modelSpecElement, Class<T> modelSpecClass,
    PluginEnvironment pluginEnv, AptUtils utils) {
  this.utils = utils;
  this.modelSpecElement = modelSpecElement;
  this.modelSpecName = new DeclaredTypeName(modelSpecElement.getQualifiedName().toString());
  this.modelSpecAnnotation = modelSpecElement.getAnnotation(modelSpecClass);
  this.generatedClassName = new DeclaredTypeName(modelSpecName.getPackageName(), getGeneratedClassNameString());
  this.pluginEnvironment = pluginEnv;
  this.pluginBundle = pluginEnv.getPluginBundleForModelSpec(this);
  processVariableElements();
  pluginBundle.afterProcessVariableElements();
  modelSuperclass = initializeModelSuperclass();
}

@Override
public void afterEmitSchema(JavaFileWriter writer) throws IOException {
  writer.writeComment("--- constants");
  for (VariableElement constant : constantElements) {
    writeConstantField(writer, modelSpec.getModelSpecName(), constant);
  }
  for (Map.Entry<String, List<VariableElement>> innerClassConstant : innerClassConstants.entrySet()) {
    String classNameString = innerClassConstant.getKey();
    DeclaredTypeName constClassName = new DeclaredTypeName(null,
        modelSpec.getModelSpecName().getSimpleName() + "." + classNameString);
    for (VariableElement element : innerClassConstant.getValue()) {
      writeConstantField(writer, constClassName, element);
    }
  }
  writer.writeNewline();
}

public InheritedModelSpecWrapper(TypeElement modelSpecElement, PluginEnvironment pluginEnv, AptUtils utils) {
  super(modelSpecElement, InheritedModelSpec.class, pluginEnv, utils);
  this.superclass = new DeclaredTypeName(getSpecAnnotation().inheritsFrom());
}

private void emitPackage() throws IOException {
  writer.writePackage(modelSpec.getGeneratedClassName().getPackageName());
}

@Override
public DeclaredTypeName getPropertyType() {
  DeclaredTypeName enumProperty = ENUM_PROPERTY.clone();
  enumProperty.setTypeArgs(Collections.singletonList(enumType));
  return enumProperty;
}

private DeclaredTypeName extractGetAndSetType() {
  String basicType = propertyType.toString().replace(TypeConstants.PROPERTY.toString(), "")
      .replace("Property", "")
      .replace(".", "");
  if ("Blob".equals(basicType)) {
    return TypeConstants.BYTE_ARRAY;
  } else {
    return new DeclaredTypeName("java.lang", basicType);
  }
}