br.com.objectos.sql.Level Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of boot Show documentation
The newest version!
/*
 * 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.sql;

import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.JavaFile;
import com.squareup.javapoet.ParameterizedTypeName;
import com.squareup.javapoet.TypeName;
import com.squareup.javapoet.TypeSpec;

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

  private final String packageName;
  private final int level;

  private final List stepList;

  private final TypeName abstractSimpleSelectWhereTypeName;
  private final TypeName rowTypeName;
  private final TypeName selectNodeTypeName;
  private final TypeName simpleSelectOrderByTypeName;
  private final ClassName simpleSelectWhereClassName;
  private final TypeName simpleSelectWhereTypeName;
  private final ClassName simpleSelectWhereIntClassName;
  private final ClassName simpleSelectWhereLocalDateClassName;
  private final ClassName simpleSelectWhereStringClassName;

  private Level(String packageName, int level, List stepList) {
    this.packageName = packageName;
    this.level = level;
    this.stepList = stepList;

    abstractSimpleSelectWhereTypeName = parameterizedTypeNameLevel("AbstractSimpleSelectWhere");
    rowTypeName = parameterizedTypeNameLevel("Row");
    selectNodeTypeName = ParameterizedTypeName.get(Naming.SelectNode, rowTypeName);
    simpleSelectOrderByTypeName = parameterizedTypeNameLevel("SimpleSelectOrderBy");
    simpleSelectWhereClassName = classNameLevel("SimpleSelectWhere");
    simpleSelectWhereTypeName = parameterizedTypeNameLevel("SimpleSelectWhere");
    simpleSelectWhereIntClassName = classNameLevel("SimpleSelectWhere", "Int");
    simpleSelectWhereLocalDateClassName = classNameLevel("SimpleSelectWhere", "LocalDate");
    simpleSelectWhereStringClassName = classNameLevel("SimpleSelectWhere", "String");
  }

  public static Level of(String packageName, int level) {
    return new Level(
        packageName,
        level,
        range(level)
            .mapToObj(Step::of)
            .collect(Collectors.toList()));
  }

  public static IntStream range(int level) {
    return IntStream.rangeClosed(1, level);
  }

  public TypeName abstractSimpleSelectWhereTypeName() {
    return abstractSimpleSelectWhereTypeName;
  }

  public ClassName className(String simpleName) {
    return ClassName.get(packageName, simpleName);
  }

  public ClassName className(String simpleName, String simpleName2) {
    return ClassName.get(packageName, simpleName, simpleName2);
  }

  public ClassName classNameLevel(String simpleName) {
    return ClassName.get(packageName, simpleName + level);
  }

  public ClassName classNameLevel(String simpleName, String suffix) {
    return ClassName.get(packageName, simpleName + level + suffix);
  }

  public boolean filter(int development) {
    return level != development;
  }

  public Stream generate() {
    return Stream.of(
        AbstractSimpleSelectWhereType.of(this).generate(),
        InsertType.of(this).generate(),
        InsertableRowType.of(this).generate(),
        InsertValuesType.of(this).generate(),
        RowType.of(this).generate(),
        SelectType.of(this).generate(),
        SelectFromType.of(this).generate(),
        SimpleSelectOrderByType.of(this).generate(),
        SimpleSelectQueryType.of(this).generate(),
        SimpleSelectWhereType.of(this).generate(),
        SimpleSelectWhereIntType.of(this).generate(),
        SimpleSelectWhereLocalDateType.of(this).generate(),
        SimpleSelectWhereStringType.of(this).generate());
  }

  public JavaFile generate(TypeSpec type) {
    return JavaFile.builder(packageName, type)
        .skipJavaLangImports(true)
        .build();
  }

  public ParameterizedTypeName parameterizedTypeName(ClassName className, TypeName... more) {
    Stream stepStream = stepList.stream().map(Step::t);
    Stream moreStream = Stream.of(more);
    TypeName[] types = Stream.concat(stepStream, moreStream).toArray(TypeName[]::new);
    return ParameterizedTypeName.get(className, types);
  }

  public ParameterizedTypeName parameterizedTypeNameLevel(String simpleName) {
    return parameterizedTypeName(classNameLevel(simpleName));
  }

  public ParameterizedTypeName parameterizedTypeNameLevel(String simpleName, String suffix) {
    return parameterizedTypeName(classNameLevel(simpleName, suffix));
  }

  public IntStream range() {
    return range(level);
  }

  public TypeName rowTypeName() {
    return rowTypeName;
  }

  public TypeName selectNodeTypeName() {
    return selectNodeTypeName;
  }

  public TypeName simpleSelectOrderByTypeName() {
    return simpleSelectOrderByTypeName;
  }

  public ClassName simpleSelectWhereClassName() {
    return simpleSelectWhereClassName;
  }

  public TypeName simpleSelectWhereTypeName() {
    return simpleSelectWhereTypeName;
  }

  public ClassName simpleSelectWhereIntClassName() {
    return simpleSelectWhereIntClassName;
  }

  public ClassName simpleSelectWhereLocalDateClassName() {
    return simpleSelectWhereLocalDateClassName;
  }

  public ClassName simpleSelectWhereStringClassName() {
    return simpleSelectWhereStringClassName;
  }

  public List stepList() {
    return stepList;
  }

  public  List stepList(Function mapper) {
    return stepList.stream().map(mapper).collect(Collectors.toList());
  }

  public  Stream stepStream(Function mapper) {
    return stepList.stream().map(mapper);
  }

}