Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2014 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.way.auto.optional;
 
 import java.util.List;
 import java.util.Set;
 
 

Author(s):
marcio.endo@objectos.com.br (Marcio Endo)
 
 
   @Override
   protected Class<? extends AnnotationannotationType() {
     return AutoOptional.class;
   }
 
   @Override
   protected boolean shouldProcessMethods() {
     return false;
   }
 
   @Override
   protected boolean shouldProcessTypes() {
     return true;
   }
 
   @Override
   protected List<CodeCanvasArtifacttoArtifactList(TypeInfo typeInfo) {
     List<CodeCanvasArtifactartifactList = ImmutableList.of();
 
     Optional<ClassInfomaybeClassInfo = typeInfo.toClassInfo();
     if (maybeClassInfo.isPresent()) {
       ClassInfo classInfo = maybeClassInfo.get();
       artifactList = toArtifactList(classInfo);
     }
 
     return artifactList;
   }
 
   private List<CodeCanvasArtifacttoArtifactList(ClassInfo classInfo) {
     MustacheObject pojoCtx = new PojoContext(classInfo).get();
     MustacheObject builderCtx = new BuilderContext(classInfo).get();
     MustacheObject builderPojoCtx = new DefaultContext(classInfo).get();
 
     CodeCanvasArtifact pojo = CodeCanvasWriter.forTemplate("/way-auto-optional/Pojo.mustache")
         .namedAfter(classInfo"Pojo")
         .toCodeCanvasArtifact(.pojoCtx);
 
     CodeCanvasArtifact builder = CodeCanvasWriter.forTemplate("/way-auto-optional/PojoBuilder.mustache")
         .namedAfter(classInfo"Builder")
        .toCodeCanvasArtifact(.builderCtx);
    CodeCanvasArtifact builderPojo = CodeCanvasWriter.forTemplate("/way-auto-optional/PojoBuilderPojo.mustache")
        .namedAfter(classInfo"BuilderPojo")
        .toCodeCanvasArtifact(.builderPojoCtx);
    return ImmutableList.of(pojobuilderbuilderPojo);
  }
  private class PojoContext extends DefaultContext {
    public PojoContext(ClassInfo classInfo) {
      super(classInfo);
    }
    @Override
      Optional<InterfaceInfomaybeTestable = .getInterface(Testable.class);
      if (!maybeTestable.isPresent()) {
        return super.toMustacheHelper();
      }
          .filter(MethodInfoHasName.get("isEqual"))
          .filter(MethodInfoHasModifierInfo.not(.))
          .first();
      if (isEqual.isPresent()) {
        return super.toMustacheHelper();
      }
      .add(Testables.class);
      TestableAutoWrapper testable = TestableAutoWrapper.wrapperOf(maybeTestable);
      testable.addImport();
      return super.toMustacheHelper()
          .add("isTestable"testable);
    }
  }
  private class BuilderContext extends DefaultContext {
    public BuilderContext(ClassInfo classInfo) {
      super(classInfo);
    }
    @Override
      return super.toMustacheHelper()
          .add("builderInterfaces", BuilderInterface.listOf());
    }
  }
  private class DefaultContext implements Supplier<MustacheObject> {
    final ImportInfoSet importInfoSet = ImportInfoSet.setOf();
    final ClassInfo classInfo;
    public DefaultContext(ClassInfo classInfo) {
      this. = classInfo;
    }
    @Override
    public MustacheObject get() {
      List<ConstructorInfoconstructorInfoList = WayIterables.from(.getConstructorInfoMap())
          .filter(ConstructorInfoHasAccessInfo.not(.))
          .toImmutableList();
      Set<ImportInfoconstructorImportSet = WayIterables.from(constructorInfoList)
          .transformAndConcat(ConstructorInfoToImportInfoSet.get())
          .toImmutableSet();
      .addAll(constructorImportSet);
       = constructorInfoList;
      List<MethodInfomethodInfoList = .getMethodInfoIterable()
          .filter(MethodInfoHasModifierInfo.get(.))
          .filter(MethodInfoHasReturnTypeInfo.not(.))
          .filter(MethodInfoHasParameterInfoListSize.get(0))
          .toImmutableList();
      Set<ImportInfomethodImportSet = WayIterables.from(methodInfoList)
          .transformAndConcat(MethodInfoToImportInfoSet.get())
          .toImmutableSet();
      .addAll(methodImportSet);
       = WayIterables.from(methodInfoList)
          .transform(MethodInfoToMethodWrapper.get(methodInfoList.size()))
          .toImmutableList();
      return toMustacheHelper()
          .toMustache();
    }
      return Mustaches.toMustacheHelper()
          .add("imports".toImportInfoList())
          .add("superClass")
          .add("constructors")
          .add("methods");
    }
  }
New to GrepCode? Check out our FAQ X