1 /* 2 * Copyright (C) 2014 Google, Inc. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 package dagger.internal.codegen.writer; 17 18 import com.google.common.base.Optional; 19 import com.google.common.collect.FluentIterable; 20 import com.google.common.collect.ImmutableList; 21 import com.google.common.collect.Iterables; 22 import com.google.common.collect.Lists; 23 import com.google.common.collect.Maps; 24 import java.io.IOException; 25 import java.util.List; 26 import java.util.Map; 27 import java.util.Set; 28 import javax.lang.model.element.TypeElement; 29 30 import static com.google.common.base.Preconditions.checkArgument; 31 32 public final class MethodWriter extends Modifiable implements HasClassReferences, Writable { 33 private final TypeName returnType; 34 private final String name; 35 private final Map<String, VariableWriter> parameterWriters; 36 private final List<TypeVariableName> typeParameters; 37 private Optional<BlockWriter> body; 38 39 MethodWriter(TypeName returnType, String name) { 40 this.returnType = returnType; 41 this.name = name; 42 this.parameterWriters = Maps.newLinkedHashMap(); 43 this.typeParameters = Lists.newArrayList(); 44 this.body = Optional.absent(); 45 } 46 47 public String name() { 48 return name; 49 } 50 51 public TypeName returnType() { 52 return returnType; 53 } 54 55 public void addTypeParameter(TypeVariableName typeVariableName) { 56 this.typeParameters.add(typeVariableName); 57 } 58 59 public void addTypeParameters(Iterable<TypeVariableName> typeVariableNames) { 60 Iterables.addAll(typeParameters, typeVariableNames); 61 } 62 63 public VariableWriter addParameter(Class<?> type, String name) { 64 return addParameter(ClassName.fromClass(type), name); 65 } 66 67 public VariableWriter addParameter(TypeElement type, String name) { 68 return addParameter(ClassName.fromTypeElement(type), name); 69 } 70 71 public VariableWriter addParameter(TypeWriter type, String name) { 72 return addParameter(type.name, name); 73 } 74 75 public VariableWriter addParameter(TypeName type, String name) { 76 checkArgument(!parameterWriters.containsKey(name)); 77 VariableWriter parameterWriter = new VariableWriter(type, name); 78 parameterWriters.put(name, parameterWriter); 79 return parameterWriter; 80 } 81 82 public BlockWriter body() { 83 if (body.isPresent()) { 84 return body.get(); 85 } else { 86 BlockWriter blockWriter = new BlockWriter(); 87 body = Optional.of(blockWriter); 88 return blockWriter; 89 } 90 } 91 92 @Override 93 public Appendable write(Appendable appendable, Context context) throws IOException { 94 writeAnnotations(appendable, context); 95 writeModifiers(appendable); 96 Writables.join(", ", typeParameters, "<", "> ", appendable, context); 97 returnType.write(appendable, context); 98 appendable.append(' ').append(name).append('('); 99 Writables.join(", ", parameterWriters.values(), appendable, context); 100 appendable.append(")"); 101 if (body.isPresent()) { 102 appendable.append(" {"); 103 body.get().write(new IndentingAppendable(appendable), context); 104 appendable.append("}\n"); 105 } else { 106 appendable.append(";\n"); 107 } 108 return appendable; 109 } 110 111 @Override 112 public Set<ClassName> referencedClasses() { 113 return FluentIterable.from(ImmutableList.<HasClassReferences>of()) 114 .append(parameterWriters.values()) 115 .append(returnType) 116 .append(body.asSet()) 117 .append(annotations) 118 .transformAndConcat(HasClassReferences.COMBINER) 119 .toSet(); 120 } 121 } 122