br.com.objectos.code.pojo.InvalidateMethod Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of code-pojo 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.code.pojo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Optional;

import br.com.objectos.code.AccessInfo;
import br.com.objectos.code.MethodInfo;
import br.com.objectos.code.ModifierInfo;
import br.com.objectos.code.SimpleTypePrimitives;
import br.com.objectos.code.TypeInfo;
import br.com.objectos.core.util.MoreCollectors;
import br.com.objectos.lazy.annotation.Invalidate;

import com.squareup.javapoet.MethodSpec;

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

  private static final InvalidateMethod EMPTY = new Empty();

  private InvalidateMethod() {
  }

  public static InvalidateMethod of(TypeInfo typeInfo) {
    List list = typeInfo.methodInfoStream()
        .filter(m -> m.hasAnnotation(Invalidate.class))
        .collect(MoreCollectors.toImmutableList());

    if (list.isEmpty()) {
      return EMPTY;
    }

    if (list.size() > 1) {
      typeInfo.compilationError("Only one @Invalidate method allowed.");
      return EMPTY;
    }

    MethodInfo methodInfo = list.get(0);
    if (!methodInfo.returnTypeInfo().equals(SimpleTypePrimitives.VOID)) {
      methodInfo.compilationError("@Invalidate method must return void.");
      return EMPTY;
    }

    if (!methodInfo.hasParameterInfoListSize(0)) {
      methodInfo.compilationError("@Invalidate method cannot have parameters.");
      return EMPTY;
    }

    AccessInfo accessInfo = methodInfo.accessInfo();
    if (AccessInfo.PRIVATE.equals(accessInfo)) {
      methodInfo.compilationError("@Invalidate method cannot be private");
      return EMPTY;
    }

    boolean isAbstract = methodInfo.hasModifierInfo(ModifierInfo.ABSTRACT);
    return new Present(accessInfo, methodInfo.name(), isAbstract);
  }

  public void add(CanBeInvalidated instance) {
  }

  public void addAll(Collection instances) {
  }

  void clear() {
  }

  Optional method() {
    return Optional.empty();
  }

  private static class Empty extends InvalidateMethod {

  }

  private static class Present extends InvalidateMethod {

    private final List invalidatableList = new ArrayList<>();

    private final AccessInfo accessInfo;
    private final String name;
    private final boolean isAbstract;

    public Present(AccessInfo accessInfo, String name, boolean isAbstract) {
      this.accessInfo = accessInfo;
      this.name = name;
      this.isAbstract = isAbstract;
    }

    @Override
    public void add(CanBeInvalidated instance) {
      invalidatableList.add(instance);
    }

    @Override
    public void addAll(Collection instances) {
      invalidatableList.addAll(instances);
    }

    @Override
    void clear() {
      invalidatableList.clear();
    }

    @Override
    Optional method() {
      return Optional.of(method0());
    }

    private MethodSpec method0() {
      MethodSpec.Builder builder = MethodSpec.methodBuilder(name)
          .addAnnotation(Override.class)
          .addModifiers(accessInfo.modifiers());

      if (!isAbstract) {
        builder.addStatement("super.$L()", name);
      }

      for (CanBeInvalidated invalidatable : invalidatableList) {
        builder.addStatement("$L.unset()", invalidatable.fieldName());
      }

      return builder.build();
    }

  }

}