br.com.objectos.schema.info.ColumnMethod Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of compiler Show documentation
There is a newer version: 0.3.0
/*
 * Copyright 2015 Objectos, Fábrica de Software LTDA.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package br.com.objectos.schema.info;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.List;

import javax.lang.model.element.Modifier;

import br.com.objectos.core.util.ImmutableList;
import br.com.objectos.db.ColumnOf;
import br.com.objectos.schema.meta.ColumnAnnotation;
import br.com.objectos.schema.meta.ColumnClass;
import br.com.objectos.schema.meta.ColumnSeq;
import br.com.objectos.schema.meta.Nullable;

import com.squareup.javapoet.AnnotationSpec;
import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.CodeBlock;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.ParameterSpec;
import com.squareup.javapoet.ParameterizedTypeName;
import com.squareup.javapoet.TypeName;
import com.squareup.javapoet.TypeSpec;

/**
 * @author [email protected] (Marcio Endo)
 */
abstract class ColumnMethod {

  private final ColumnInfoMethodInfo columnInfo;
  private final ColumnName columnName;

  public ColumnMethod(ColumnInfoMethodInfo columnInfo, ColumnName columnName) {
    this.columnInfo = columnInfo;
    this.columnName = columnName;
  }

  public void columnListInitializer(CodeBlock.Builder init) {
    init.add("    .add(new $T())\n", columnName().className());
  }

  public abstract TypeSpec innerAnnotation(SchemaName schemaName, TableName tableName);

  public final TypeSpec innerClass() {
    String name = columnClassName().simpleName();
    ClassName enclosingClassName = columnClassName().enclosingClassName();
    ParameterizedTypeName superinterface = ParameterizedTypeName.get(ClassName.get(ColumnOf.class), enclosingClassName);
    return TypeSpec.classBuilder(name)
        .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
        .superclass(columnTypeName())
        .addSuperinterface(superinterface)
        .addMethod(constructor0())
        .addMethod(constructor1())
        .addMethods(innerClassMethodList())
        .addMethods(columnInfo.valueMethodList(columnName.className()))
        .build();
  }

  public void insertValuesBody0(CodeBlock.Builder body) {
    generationInfo().insertValuesBody0(body, columnClassName(), columnName());
  }

  public void insertValuesBody1(CodeBlock.Builder body) {
    generationInfo().insertValuesBody1(body, columnClassName(), columnName());
  }

  public ParameterSpec insertValuesParameterSpec0() {
    TypeName valueTypeName = generationInfo().insertValuesParameterTypeName(valueTypeName());
    return ParameterSpec.builder(valueTypeName, columnName().identifier()).build();
  }

  public ParameterSpec insertValuesParameterSpec1() {
    return ParameterSpec.builder(columnClassName(), columnName().identifier()).build();
  }

  public List method() {
    return ImmutableList. builder()
        .add(method0())
        .add(method1())
        .build();
  }

  ColumnInfoMethodInfo columnInfo() {
    return columnInfo;
  }

  ColumnName columnName() {
    return columnName;
  }

  TypeSpec.Builder innerAnnotationBuilder(SchemaName schemaName, TableName tableName) {
    TypeSpec.Builder innerAnnotation = TypeSpec.annotationBuilder(columnName().identifier())
        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
        .addAnnotation(retention())
        .addAnnotation(target())
        .addAnnotation(ColumnAnnotation.class)
        .addAnnotation(schemaNameAnnotation(schemaName))
        .addAnnotation(tableNameAnnotation(tableName))
        .addAnnotation(columnNameAnnotation())
        .addAnnotation(columnSeqAnnotation())
        .addAnnotation(columnClassAnnotation());

    if (columnInfo.nullable()) {
      innerAnnotation.addAnnotation(Nullable.class);
    }

    generationInfo().generatedValue(innerAnnotation);

    return innerAnnotation;
  }

  List innerClassMethodList() {
    return ImmutableList.of();
  }

  private AnnotationSpec columnClassAnnotation() {
    return AnnotationSpec.builder(ColumnClass.class)
        .addMember("value", "$T.class", columnClassName())
        .build();
  }

  private ClassName columnClassName() {
    return columnName().className();
  }

  private AnnotationSpec columnNameAnnotation() {
    return AnnotationSpec.builder(br.com.objectos.schema.meta.ColumnName.class)
        .addMember("value", "$S", simpleName())
        .build();
  }

  private AnnotationSpec columnSeqAnnotation() {
    return AnnotationSpec.builder(ColumnSeq.class)
        .addMember("value", "$L", columnInfo.tableName().nextIndex())
        .build();
  }

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

  private MethodSpec constructor0() {
    return MethodSpec.constructorBuilder()
        .addModifiers(Modifier.PRIVATE)
        .addStatement("super(INSTANCE, $S)", simpleName())
        .build();
  }

  private MethodSpec constructor1() {
    return MethodSpec.constructorBuilder()
        .addModifiers(Modifier.PRIVATE)
        .addParameter(valueTypeName(), "value")
        .addStatement("super(INSTANCE, $S, value)", simpleName())
        .build();
  }

  private ThisGenerationInfo generationInfo() {
    return columnInfo.generationInfo();
  }

  private MethodSpec method0() {
    ClassName innerClassName = columnClassName();
    return MethodSpec.methodBuilder(columnName().identifier())
        .addAnnotation(Override.class)
        .addModifiers(Modifier.PUBLIC)
        .returns(innerClassName)
        .addStatement("return new $T()", innerClassName)
        .build();
  }

  private MethodSpec method1() {
    ClassName innerClassName = columnClassName();
    return MethodSpec.methodBuilder(columnName().identifier())
        .addModifiers(Modifier.PUBLIC)
        .returns(innerClassName)
        .addParameter(valueTypeName(), "value")
        .addStatement("return new $T(value)", innerClassName)
        .build();
  }

  private AnnotationSpec retention() {
    return AnnotationSpec.builder(Retention.class)
        .addMember("value", "$T.$L", RetentionPolicy.class, RetentionPolicy.RUNTIME)
        .build();
  }

  private AnnotationSpec schemaNameAnnotation(SchemaName schemaName) {
    return AnnotationSpec.builder(br.com.objectos.schema.meta.SchemaName.class)
        .addMember("value", "$S", schemaName.simpleName())
        .build();
  }

  private String simpleName() {
    return columnInfo.simpleName();
  }

  private AnnotationSpec tableNameAnnotation(TableName tableName) {
    return AnnotationSpec.builder(br.com.objectos.schema.meta.TableName.class)
        .addMember("value", "$S", tableName.simpleName())
        .build();
  }

  private AnnotationSpec target() {
    return AnnotationSpec.builder(Target.class)
        .addMember("value", "{ $T.$L, $T.$L }",
            ElementType.class, ElementType.METHOD, ElementType.class, ElementType.PARAMETER)
        .build();
  }

  private TypeName valueTypeName() {
    return columnInfo.valueTypeName();
  }

}