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.builder;
 
 import static com.google.common.collect.Lists.newArrayList;
 import static com.google.common.collect.Sets.newHashSet;
 
 import java.util.List;
 import java.util.Set;
 
 

Author(s):
marcio.endo@objectos.com.br (Marcio Endo)
 
 
   @Override
   protected Class<? extends AnnotationannotationType() {
     return AutoBuilder.class;
   }
 
   @Override
   protected boolean shouldProcessMethods() {
     return false;
   }
 
   @Override
   protected boolean shouldProcessTypes() {
     return true;
   }
 
   @Override
   protected List<CodeCanvasArtifacttoArtifactList(TypeInfo typeInfo) {
     List<CodeCanvasArtifactartifactList = ImmutableList.of();
 
     Optional<InterfaceInfomaybeInterfaceInfo = typeInfo.toInterfaceInfo();
     if (maybeInterfaceInfo.isPresent()) {
       InterfaceInfo interfaceInfo = maybeInterfaceInfo.get();
       artifactList = toArtifactList(interfaceInfo);
     }
 
     return artifactList;
   }
 
   private List<CodeCanvasArtifacttoArtifactList(InterfaceInfo interfaceInfo) {
     CodeCanvasArtifact artifact = CodeCanvasWriter.forTemplate("/way-auto-builder/Builder.mustache")
         .namedAfter(interfaceInfo"Pojo")
         .toCodeCanvasArtifact(.context(interfaceInfo));
 
     return ImmutableList.of(artifact);
   }
 
   private MustacheObject context(InterfaceInfo interfaceInfo) {
     final ImportInfoSet importInfoSet = ImportInfoSet.setOf();
     final List<IndexedInterfaceInfoinnerInterfaces = newArrayList();
    final Set<SimpleTypeInfosimpleTypeInfoSet = newHashSet();
    final List<IndexedMethodInfomethods = newArrayList();
    Size size = WayIterables.newSize();
    interfaceInfo.getDeclaredTypeInfoIterable()
        .transform(TypeInfoToInterfaceInfo.get())
        .presentInstancesOf(InterfaceInfo.class)
        .toListAndStore(InterfaceInfo.classsize)
        .transformAndConcat(InterfaceInfoToImportInfo.get())
        .execute(new IterableAction<ImportInfo>() {
          @Override
          public void execute(Iterable<? extends ImportInfolist) {
            importInfoSet.addAll(list);
          }
        })
        .restore(InterfaceInfo.class)
        .transform(InterfaceInfoToIndexedInterfaceInfo.get(size.get()))
        .appendTo(innerInterfaces)
        .restore(InterfaceInfo.class)
        .transform(InterfaceInfoToSimpleTypeInfo.get())
        .appendTo(simpleTypeInfoSet)
        .restore(InterfaceInfo.class)
        .transformAndConcat(InterfaceInfoGetMethodInfoList.get())
        .prependAll(InterfaceInfoGetMethodInfoList.get().apply(interfaceInfo))
        .filter(Predicates.or(MethodInfoHasParameterInfoListSize.get(0), MethodInfoHasParameterInfoListSize.get(1)))
        .filter(new Predicate<MethodInfo>() {
          @Override
          public boolean apply(MethodInfo input) {
            SimpleTypeInfo returnTypeInfo = input.returnTypeInfo();
            return simpleTypeInfoSet.contains(returnTypeInfo);
          }
        })
        .filter(new MethodSignaturePredicate())
        .toListAndSize(size)
        .transform(MethodInfoToIndexedMethodInfo.get(size.get()))
        .appendTo(methods);
    for (IndexedMethodInfo method : methods) {
      method.addTo(importInfoSet);
    }
    List<ImportInfoimports = importInfoSet.toImportInfoList(interfaceInfo);
    return Mustaches.toMustacheHelper()
        .add("imports"imports)
        .add("emptyImports"imports.isEmpty())
        .add("superClass"interfaceInfo)
        .add("innerInterfaces"innerInterfaces)
        .add("methods"methods)
        .toMustache();
  }
  private class MethodSignaturePredicate implements Predicate<MethodInfo> {
    private final Set<MethodSignatureEqualsset = newHashSet();
    @Override
    public boolean apply(MethodInfo input) {
      MethodSignatureEquals equals = new MethodSignatureEquals(input);
      return .add(equals);
    }
  }
New to GrepCode? Check out our FAQ X