Source code

001/**
002 * Copyright 2014 The Sculptor Project Team, including the original
003 * author or authors.
004 * 
005 * Licensed under the Apache License, Version 2.0 (the "License");
006 * you may not use this file except in compliance with the License.
007 * You may obtain a copy of the License at
008 * 
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 * 
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.sculptor.generator.cartridge.builder;
018
019import java.util.List;
020import javax.inject.Inject;
021import org.eclipse.xtend2.lib.StringConcatenation;
022import org.eclipse.xtext.xbase.lib.CollectionLiterals;
023import org.eclipse.xtext.xbase.lib.Extension;
024import org.eclipse.xtext.xbase.lib.Functions.Function1;
025import org.eclipse.xtext.xbase.lib.IterableExtensions;
026import org.eclipse.xtext.xbase.lib.ListExtensions;
027import org.sculptor.generator.cartridge.builder.BuilderHelper;
028import org.sculptor.generator.chain.ChainLink;
029import org.sculptor.generator.chain.ChainOverridable;
030import org.sculptor.generator.ext.Helper;
031import org.sculptor.generator.ext.Properties;
032import org.sculptor.generator.template.domain.DomainObjectAttributeTmpl;
033import org.sculptor.generator.template.domain.DomainObjectConstructorTmpl;
034import org.sculptor.generator.template.domain.DomainObjectReferenceTmpl;
035import org.sculptor.generator.util.HelperBase;
036import org.sculptor.generator.util.OutputSlot;
037import sculptormetamodel.Attribute;
038import sculptormetamodel.DomainObject;
039import sculptormetamodel.NamedElement;
040import sculptormetamodel.Reference;
041
042@ChainOverridable
043@SuppressWarnings("all")
044public class BuilderTmpl extends ChainLink<BuilderTmpl> {
045  @Inject
046  @Extension
047  private BuilderHelper builderHelper;
048  
049  @Inject
050  @Extension
051  private HelperBase helperBase;
052  
053  @Inject
054  @Extension
055  private Helper helper;
056  
057  @Inject
058  @Extension
059  private Properties properties;
060  
061  @Inject
062  private DomainObjectAttributeTmpl domainObjectAttributeTmpl;
063  
064  @Inject
065  private DomainObjectReferenceTmpl domainObjectReferenceTmpl;
066  
067  @Inject
068  private DomainObjectConstructorTmpl domainObjectConstructorTmpl;
069  
070  public String builder(final DomainObject it) {
071    BuilderTmpl headObj = getMethodsDispatchHead()[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.BUILDER_DOMAINOBJECT];
072    return headObj._chained_builder(it);
073  }
074  
075  public String builderBody(final DomainObject it) {
076    BuilderTmpl headObj = getMethodsDispatchHead()[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.BUILDERBODY_DOMAINOBJECT];
077    return headObj._chained_builderBody(it);
078  }
079  
080  public String assignAttributeInConstructor(final NamedElement it) {
081    BuilderTmpl headObj = getMethodsDispatchHead()[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.ASSIGNATTRIBUTEINCONSTRUCTOR_NAMEDELEMENT];
082    return headObj._chained_assignAttributeInConstructor(it);
083  }
084  
085  public String multiReferenceAdd(final Reference it, final DomainObject obj) {
086    BuilderTmpl headObj = getMethodsDispatchHead()[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.MULTIREFERENCEADD_REFERENCE_DOMAINOBJECT];
087    return headObj._chained_multiReferenceAdd(it, obj);
088  }
089  
090  public String builderAttribute(final Attribute it) {
091    BuilderTmpl headObj = getMethodsDispatchHead()[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.BUILDERATTRIBUTE_ATTRIBUTE];
092    return headObj._chained_builderAttribute(it);
093  }
094  
095  public String builderAttributeSetter(final Attribute it, final DomainObject obj) {
096    BuilderTmpl headObj = getMethodsDispatchHead()[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.BUILDERATTRIBUTESETTER_ATTRIBUTE_DOMAINOBJECT];
097    return headObj._chained_builderAttributeSetter(it, obj);
098  }
099  
100  public String builderSingleReferenceSetter(final Reference it, final DomainObject obj) {
101    BuilderTmpl headObj = getMethodsDispatchHead()[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.BUILDERSINGLEREFERENCESETTER_REFERENCE_DOMAINOBJECT];
102    return headObj._chained_builderSingleReferenceSetter(it, obj);
103  }
104  
105  public BuilderTmpl(final BuilderTmpl next) {
106    super(next);
107  }
108  
109  public String _chained_builder(final DomainObject it) {
110    String _builderFqn = this.builderHelper.getBuilderFqn(it);
111    String _javaFileName = this.helper.javaFileName(_builderFqn);
112    StringConcatenation _builder = new StringConcatenation();
113    String _javaHeader = this.properties.javaHeader();
114    _builder.append(_javaHeader, "");
115    _builder.newLineIfNotEmpty();
116    _builder.append("package ");
117    String _builderPackage = this.builderHelper.getBuilderPackage(it);
118    _builder.append(_builderPackage, "");
119    _builder.append(";");
120    _builder.newLineIfNotEmpty();
121    _builder.newLine();
122    _builder.append("/// Sculptor code formatter imports ///");
123    _builder.newLine();
124    _builder.newLine();
125    String _builderBody = this.builderBody(it);
126    _builder.append(_builderBody, "");
127    _builder.newLineIfNotEmpty();
128    return this.helper.fileOutput(_javaFileName, OutputSlot.TO_GEN_SRC, _builder.toString());
129  }
130  
131  public String _chained_builderBody(final DomainObject it) {
132    StringConcatenation _builder = new StringConcatenation();
133    _builder.newLine();
134    _builder.append("/**");
135    _builder.newLine();
136    _builder.append(" ");
137    _builder.append("* Builder for ");
138    String _name = it.getName();
139    _builder.append(_name, " ");
140    _builder.append(" class.");
141    _builder.newLineIfNotEmpty();
142    _builder.append(" ");
143    _builder.append("*/");
144    _builder.newLine();
145    _builder.append("public class ");
146    String _builderClassName = this.builderHelper.getBuilderClassName(it);
147    _builder.append(_builderClassName, "");
148    _builder.append(" {");
149    _builder.newLineIfNotEmpty();
150    _builder.newLine();
151    _builder.append("\t");
152    List<Attribute> _builderAttributes = this.builderHelper.getBuilderAttributes(it);
153    final Function1<Attribute, String> _function = new Function1<Attribute, String>() {
154      @Override
155      public String apply(final Attribute a) {
156        return BuilderTmpl.this.domainObjectAttributeTmpl.attribute(a, false);
157      }
158    };
159    List<String> _map = ListExtensions.<Attribute, String>map(_builderAttributes, _function);
160    String _join = IterableExtensions.join(_map);
161    _builder.append(_join, "\t");
162    _builder.newLineIfNotEmpty();
163    _builder.newLine();
164    _builder.append("\t");
165    List<Reference> _builderReferences = this.builderHelper.getBuilderReferences(it);
166    final Function1<Reference, Boolean> _function_1 = new Function1<Reference, Boolean>() {
167      @Override
168      public Boolean apply(final Reference r) {
169        boolean _isMany = r.isMany();
170        return Boolean.valueOf((!_isMany));
171      }
172    };
173    Iterable<Reference> _filter = IterableExtensions.<Reference>filter(_builderReferences, _function_1);
174    final Function1<Reference, String> _function_2 = new Function1<Reference, String>() {
175      @Override
176      public String apply(final Reference e) {
177        return BuilderTmpl.this.domainObjectReferenceTmpl.oneReferenceAttribute(e, false);
178      }
179    };
180    Iterable<String> _map_1 = IterableExtensions.<Reference, String>map(_filter, _function_2);
181    String _join_1 = IterableExtensions.join(_map_1);
182    _builder.append(_join_1, "\t");
183    _builder.newLineIfNotEmpty();
184    _builder.append("\t");
185    List<Reference> _builderReferences_1 = this.builderHelper.getBuilderReferences(it);
186    final Function1<Reference, Boolean> _function_3 = new Function1<Reference, Boolean>() {
187      @Override
188      public Boolean apply(final Reference r) {
189        return Boolean.valueOf(r.isMany());
190      }
191    };
192    Iterable<Reference> _filter_1 = IterableExtensions.<Reference>filter(_builderReferences_1, _function_3);
193    final Function1<Reference, String> _function_4 = new Function1<Reference, String>() {
194      @Override
195      public String apply(final Reference e) {
196        return BuilderTmpl.this.domainObjectReferenceTmpl.manyReferenceAttribute(e, false);
197      }
198    };
199    Iterable<String> _map_2 = IterableExtensions.<Reference, String>map(_filter_1, _function_4);
200    String _join_2 = IterableExtensions.join(_map_2);
201    _builder.append(_join_2, "\t");
202    _builder.newLineIfNotEmpty();
203    _builder.newLine();
204    _builder.append("\t");
205    _builder.append("/**");
206    _builder.newLine();
207    _builder.append("\t ");
208    _builder.append("* Static factory method for ");
209    String _builderClassName_1 = this.builderHelper.getBuilderClassName(it);
210    _builder.append(_builderClassName_1, "\t ");
211    _builder.newLineIfNotEmpty();
212    _builder.append("\t ");
213    _builder.append("*/");
214    _builder.newLine();
215    _builder.append("\t");
216    _builder.append("public static ");
217    String _name_1 = it.getName();
218    _builder.append(_name_1, "\t");
219    _builder.append("Builder ");
220    String _name_2 = it.getName();
221    String _firstLower = this.helperBase.toFirstLower(_name_2);
222    _builder.append(_firstLower, "\t");
223    _builder.append("() {");
224    _builder.newLineIfNotEmpty();
225    _builder.append("\t\t");
226    _builder.append("return new ");
227    String _name_3 = it.getName();
228    _builder.append(_name_3, "\t\t");
229    _builder.append("Builder();");
230    _builder.newLineIfNotEmpty();
231    _builder.append("\t");
232    _builder.append("}");
233    _builder.newLine();
234    _builder.newLine();
235    _builder.append("\t");
236    _builder.append("public ");
237    String _name_4 = it.getName();
238    _builder.append(_name_4, "\t");
239    _builder.append("Builder() {");
240    _builder.newLineIfNotEmpty();
241    _builder.append("\t");
242    _builder.append("}");
243    _builder.newLine();
244    _builder.newLine();
245    {
246      List<NamedElement> _builderConstructorParameters = this.builderHelper.getBuilderConstructorParameters(it);
247      boolean _isEmpty = _builderConstructorParameters.isEmpty();
248      boolean _not = (!_isEmpty);
249      if (_not) {
250        _builder.append("\t");
251        _builder.append("public ");
252        String _name_5 = it.getName();
253        _builder.append(_name_5, "\t");
254        _builder.append("Builder(");
255        List<NamedElement> _builderConstructorParameters_1 = this.builderHelper.getBuilderConstructorParameters(it);
256        final Function1<NamedElement, String> _function_5 = new Function1<NamedElement, String>() {
257          @Override
258          public String apply(final NamedElement p) {
259            return BuilderTmpl.this.domainObjectConstructorTmpl.parameterTypeAndName(p);
260          }
261        };
262        List<String> _map_3 = ListExtensions.<NamedElement, String>map(_builderConstructorParameters_1, _function_5);
263        String _join_3 = IterableExtensions.join(_map_3, ",");
264        _builder.append(_join_3, "\t");
265        _builder.append(") {");
266        _builder.newLineIfNotEmpty();
267        _builder.append("\t");
268        _builder.newLine();
269        {
270          List<NamedElement> _builderConstructorParameters_2 = this.builderHelper.getBuilderConstructorParameters(it);
271          for(final NamedElement p : _builderConstructorParameters_2) {
272            _builder.append("\t");
273            _builder.append("\t");
274            String _assignAttributeInConstructor = this.assignAttributeInConstructor(p);
275            _builder.append(_assignAttributeInConstructor, "\t\t");
276            _builder.newLineIfNotEmpty();
277          }
278        }
279        _builder.append("\t");
280        _builder.append("}");
281        _builder.newLine();
282      }
283    }
284    _builder.newLine();
285    _builder.append("\t");
286    List<Attribute> _builderAttributes_1 = this.builderHelper.getBuilderAttributes(it);
287    final Function1<Attribute, String> _function_6 = new Function1<Attribute, String>() {
288      @Override
289      public String apply(final Attribute a) {
290        return BuilderTmpl.this.builderAttributeSetter(a, it);
291      }
292    };
293    List<String> _map_4 = ListExtensions.<Attribute, String>map(_builderAttributes_1, _function_6);
294    String _join_4 = IterableExtensions.join(_map_4);
295    _builder.append(_join_4, "\t");
296    _builder.newLineIfNotEmpty();
297    _builder.newLine();
298    _builder.append("\t");
299    List<Reference> _builderReferences_2 = this.builderHelper.getBuilderReferences(it);
300    final Function1<Reference, Boolean> _function_7 = new Function1<Reference, Boolean>() {
301      @Override
302      public Boolean apply(final Reference r) {
303        boolean _isMany = r.isMany();
304        return Boolean.valueOf((!_isMany));
305      }
306    };
307    Iterable<Reference> _filter_2 = IterableExtensions.<Reference>filter(_builderReferences_2, _function_7);
308    final Function1<Reference, String> _function_8 = new Function1<Reference, String>() {
309      @Override
310      public String apply(final Reference r) {
311        return BuilderTmpl.this.builderSingleReferenceSetter(r, it);
312      }
313    };
314    Iterable<String> _map_5 = IterableExtensions.<Reference, String>map(_filter_2, _function_8);
315    String _join_5 = IterableExtensions.join(_map_5);
316    _builder.append(_join_5, "\t");
317    _builder.newLineIfNotEmpty();
318    _builder.append("\t");
319    List<Reference> _builderReferences_3 = this.builderHelper.getBuilderReferences(it);
320    final Function1<Reference, Boolean> _function_9 = new Function1<Reference, Boolean>() {
321      @Override
322      public Boolean apply(final Reference r) {
323        return Boolean.valueOf(r.isMany());
324      }
325    };
326    Iterable<Reference> _filter_3 = IterableExtensions.<Reference>filter(_builderReferences_3, _function_9);
327    final Function1<Reference, String> _function_10 = new Function1<Reference, String>() {
328      @Override
329      public String apply(final Reference r) {
330        return BuilderTmpl.this.multiReferenceAdd(r, it);
331      }
332    };
333    Iterable<String> _map_6 = IterableExtensions.<Reference, String>map(_filter_3, _function_10);
334    String _join_6 = IterableExtensions.join(_map_6);
335    _builder.append(_join_6, "\t");
336    _builder.newLineIfNotEmpty();
337    _builder.newLine();
338    _builder.append("\t");
339    List<Attribute> _builderAttributes_2 = this.builderHelper.getBuilderAttributes(it);
340    final Function1<Attribute, String> _function_11 = new Function1<Attribute, String>() {
341      @Override
342      public String apply(final Attribute a) {
343        return BuilderTmpl.this.domainObjectAttributeTmpl.propertyGetter(a);
344      }
345    };
346    List<String> _map_7 = ListExtensions.<Attribute, String>map(_builderAttributes_2, _function_11);
347    String _join_7 = IterableExtensions.join(_map_7);
348    _builder.append(_join_7, "\t");
349    _builder.newLineIfNotEmpty();
350    _builder.newLine();
351    _builder.append("\t");
352    List<Reference> _builderReferences_4 = this.builderHelper.getBuilderReferences(it);
353    final Function1<Reference, Boolean> _function_12 = new Function1<Reference, Boolean>() {
354      @Override
355      public Boolean apply(final Reference r) {
356        boolean _isMany = r.isMany();
357        return Boolean.valueOf((!_isMany));
358      }
359    };
360    Iterable<Reference> _filter_4 = IterableExtensions.<Reference>filter(_builderReferences_4, _function_12);
361    final Function1<Reference, String> _function_13 = new Function1<Reference, String>() {
362      @Override
363      public String apply(final Reference r) {
364        return BuilderTmpl.this.domainObjectReferenceTmpl.oneReferenceGetter(r, false);
365      }
366    };
367    Iterable<String> _map_8 = IterableExtensions.<Reference, String>map(_filter_4, _function_13);
368    String _join_8 = IterableExtensions.join(_map_8);
369    _builder.append(_join_8, "\t");
370    _builder.newLineIfNotEmpty();
371    _builder.append("\t");
372    List<Reference> _builderReferences_5 = this.builderHelper.getBuilderReferences(it);
373    final Function1<Reference, Boolean> _function_14 = new Function1<Reference, Boolean>() {
374      @Override
375      public Boolean apply(final Reference r) {
376        return Boolean.valueOf(r.isMany());
377      }
378    };
379    Iterable<Reference> _filter_5 = IterableExtensions.<Reference>filter(_builderReferences_5, _function_14);
380    final Function1<Reference, String> _function_15 = new Function1<Reference, String>() {
381      @Override
382      public String apply(final Reference r) {
383        return BuilderTmpl.this.domainObjectReferenceTmpl.manyReferenceGetter(r, false);
384      }
385    };
386    Iterable<String> _map_9 = IterableExtensions.<Reference, String>map(_filter_5, _function_15);
387    String _join_9 = IterableExtensions.join(_map_9);
388    _builder.append(_join_9, "\t");
389    _builder.newLineIfNotEmpty();
390    _builder.newLine();
391    _builder.append("\t");
392    _builder.append("/**");
393    _builder.newLine();
394    _builder.append("\t ");
395    _builder.append("* @return new ");
396    String _name_6 = it.getName();
397    _builder.append(_name_6, "\t ");
398    _builder.append(" instance constructed based on the values that have been set into this builder");
399    _builder.newLineIfNotEmpty();
400    _builder.append("\t ");
401    _builder.append("*/");
402    _builder.newLine();
403    _builder.append("\t");
404    _builder.append("public ");
405    String _domainPackage = this.helperBase.getDomainPackage(it);
406    String _plus = (_domainPackage + ".");
407    String _name_7 = it.getName();
408    String _plus_1 = (_plus + _name_7);
409    _builder.append(_plus_1, "\t");
410    _builder.append(" build() {");
411    _builder.newLineIfNotEmpty();
412    _builder.append("\t\t");
413    String _domainPackage_1 = this.helperBase.getDomainPackage(it);
414    String _plus_2 = (_domainPackage_1 + ".");
415    String _name_8 = it.getName();
416    String _plus_3 = (_plus_2 + _name_8);
417    _builder.append(_plus_3, "\t\t");
418    _builder.append(" obj = new ");
419    String _name_9 = it.getName();
420    _builder.append(_name_9, "\t\t");
421    _builder.append("(");
422    {
423      List<NamedElement> _builderConstructorParameters_3 = this.builderHelper.getBuilderConstructorParameters(it);
424      boolean _hasElements = false;
425      for(final NamedElement attr : _builderConstructorParameters_3) {
426        if (!_hasElements) {
427          _hasElements = true;
428        } else {
429          _builder.appendImmediate(", ", "\t\t");
430        }
431        String _getAccessor = this.helper.getGetAccessor(attr);
432        _builder.append(_getAccessor, "\t\t");
433        _builder.append("()");
434      }
435    }
436    _builder.append(");");
437    _builder.newLineIfNotEmpty();
438    _builder.append("\t\t");
439    final List<NamedElement> attrs = CollectionLiterals.<NamedElement>newArrayList();
440    _builder.newLineIfNotEmpty();
441    _builder.append("\t\t");
442    String _xblockexpression = null;
443    {
444      List<Attribute> _builderAttributes_3 = this.builderHelper.getBuilderAttributes(it);
445      attrs.addAll(_builderAttributes_3);
446      List<Reference> _builderReferences_6 = this.builderHelper.getBuilderReferences(it);
447      final Function1<Reference, Boolean> _function_16 = new Function1<Reference, Boolean>() {
448        @Override
449        public Boolean apply(final Reference r) {
450          boolean _isMany = r.isMany();
451          return Boolean.valueOf((!_isMany));
452        }
453      };
454      Iterable<Reference> _filter_6 = IterableExtensions.<Reference>filter(_builderReferences_6, _function_16);
455      List<Reference> _list = IterableExtensions.<Reference>toList(_filter_6);
456      attrs.addAll(_list);
457      List<NamedElement> _builderConstructorParameters_4 = this.builderHelper.getBuilderConstructorParameters(it);
458      attrs.removeAll(_builderConstructorParameters_4);
459      _xblockexpression = "";
460    }
461    _builder.append(_xblockexpression, "\t\t");
462    _builder.newLineIfNotEmpty();
463    {
464      for(final NamedElement prop : attrs) {
465        _builder.append("\t\t");
466        _builder.append("obj.set");
467        String _name_10 = prop.getName();
468        String _firstUpper = this.helperBase.toFirstUpper(_name_10);
469        _builder.append(_firstUpper, "\t\t");
470        _builder.append("(");
471        String _name_11 = prop.getName();
472        _builder.append(_name_11, "\t\t");
473        _builder.append(");");
474        _builder.newLineIfNotEmpty();
475      }
476    }
477    _builder.append("\t\t");
478    List<Reference> _builderReferences_6 = this.builderHelper.getBuilderReferences(it);
479    final Function1<Reference, Boolean> _function_16 = new Function1<Reference, Boolean>() {
480      @Override
481      public Boolean apply(final Reference r) {
482        return Boolean.valueOf(r.isMany());
483      }
484    };
485    Iterable<Reference> _filter_6 = IterableExtensions.<Reference>filter(_builderReferences_6, _function_16);
486    final List<Reference> refs = IterableExtensions.<Reference>toList(_filter_6);
487    _builder.newLineIfNotEmpty();
488    _builder.append("\t\t");
489    String _xblockexpression_1 = null;
490    {
491      List<NamedElement> _builderConstructorParameters_4 = this.builderHelper.getBuilderConstructorParameters(it);
492      refs.removeAll(_builderConstructorParameters_4);
493      _xblockexpression_1 = "";
494    }
495    _builder.append(_xblockexpression_1, "\t\t");
496    _builder.newLineIfNotEmpty();
497    {
498      for(final Reference prop_1 : refs) {
499        _builder.append("\t\t");
500        _builder.append("obj.get");
501        String _name_12 = prop_1.getName();
502        String _firstUpper_1 = this.helperBase.toFirstUpper(_name_12);
503        _builder.append(_firstUpper_1, "\t\t");
504        _builder.append("().addAll(");
505        String _name_13 = prop_1.getName();
506        _builder.append(_name_13, "\t\t");
507        _builder.append(");");
508        _builder.newLineIfNotEmpty();
509      }
510    }
511    _builder.newLine();
512    _builder.append("\t\t");
513    _builder.append("return obj;");
514    _builder.newLine();
515    _builder.append("\t");
516    _builder.append("}");
517    _builder.newLine();
518    _builder.append("}");
519    _builder.newLine();
520    _builder.newLine();
521    return _builder.toString();
522  }
523  
524  public String _chained_assignAttributeInConstructor(final NamedElement it) {
525    StringConcatenation _builder = new StringConcatenation();
526    {
527      boolean _and = false;
528      if (!(it instanceof Reference)) {
529        _and = false;
530      } else {
531        boolean _isMany = ((Reference) it).isMany();
532        _and = _isMany;
533      }
534      if (_and) {
535        _builder.append("this.");
536        String _name = it.getName();
537        _builder.append(_name, "");
538        _builder.append(".addAll(");
539        String _name_1 = it.getName();
540        _builder.append(_name_1, "");
541        _builder.append(");");
542        _builder.newLineIfNotEmpty();
543      } else {
544        _builder.append("this.");
545        String _name_2 = it.getName();
546        _builder.append(_name_2, "");
547        _builder.append(" = ");
548        String _name_3 = it.getName();
549        _builder.append(_name_3, "");
550        _builder.append(";");
551        _builder.newLineIfNotEmpty();
552      }
553    }
554    _builder.newLine();
555    return _builder.toString();
556  }
557  
558  public String _chained_multiReferenceAdd(final Reference it, final DomainObject obj) {
559    StringConcatenation _builder = new StringConcatenation();
560    _builder.append("/**");
561    _builder.newLine();
562    _builder.append(" ");
563    _builder.append("* Adds an object to the to-many");
564    _builder.newLine();
565    _builder.append(" ");
566    _builder.append("* association.");
567    _builder.newLine();
568    _builder.append(" ");
569    _builder.append("* It is added the collection {@link #get");
570    String _name = it.getName();
571    String _firstUpper = this.helperBase.toFirstUpper(_name);
572    _builder.append(_firstUpper, " ");
573    _builder.append("}.");
574    _builder.newLineIfNotEmpty();
575    _builder.append(" ");
576    _builder.append("*/");
577    _builder.newLine();
578    _builder.append("public ");
579    String _name_1 = obj.getName();
580    _builder.append(_name_1, "");
581    _builder.append("Builder add");
582    String _name_2 = it.getName();
583    String _firstUpper_1 = this.helperBase.toFirstUpper(_name_2);
584    String _singular = this.helper.singular(_firstUpper_1);
585    _builder.append(_singular, "");
586    _builder.append("(");
587    String _typeName = this.helperBase.getTypeName(it);
588    _builder.append(_typeName, "");
589    _builder.append(" ");
590    String _name_3 = it.getName();
591    String _singular_1 = this.helper.singular(_name_3);
592    _builder.append(_singular_1, "");
593    _builder.append("Element) {");
594    _builder.newLineIfNotEmpty();
595    _builder.append("\t");
596    _builder.append("get");
597    String _name_4 = it.getName();
598    String _firstUpper_2 = this.helperBase.toFirstUpper(_name_4);
599    _builder.append(_firstUpper_2, "\t");
600    _builder.append("().add(");
601    String _name_5 = it.getName();
602    String _singular_2 = this.helper.singular(_name_5);
603    _builder.append(_singular_2, "\t");
604    _builder.append("Element);");
605    _builder.newLineIfNotEmpty();
606    _builder.append("\t");
607    _builder.append("return this;");
608    _builder.newLine();
609    _builder.append("}");
610    _builder.newLine();
611    return _builder.toString();
612  }
613  
614  public String _chained_builderAttribute(final Attribute it) {
615    StringConcatenation _builder = new StringConcatenation();
616    _builder.append("protected ");
617    String _implTypeName = this.helperBase.getImplTypeName(it);
618    _builder.append(_implTypeName, "");
619    _builder.append(" ");
620    String _name = it.getName();
621    _builder.append(_name, "");
622    _builder.append(";");
623    _builder.newLineIfNotEmpty();
624    return _builder.toString();
625  }
626  
627  public String _chained_builderAttributeSetter(final Attribute it, final DomainObject obj) {
628    StringConcatenation _builder = new StringConcatenation();
629    String _formatJavaDoc = this.helper.formatJavaDoc(it);
630    _builder.append(_formatJavaDoc, "");
631    _builder.newLineIfNotEmpty();
632    _builder.append("public ");
633    String _name = obj.getName();
634    _builder.append(_name, "");
635    _builder.append("Builder ");
636    String _name_1 = it.getName();
637    _builder.append(_name_1, "");
638    _builder.append("(");
639    String _typeName = this.helperBase.getTypeName(it);
640    _builder.append(_typeName, "");
641    _builder.append(" val) {");
642    _builder.newLineIfNotEmpty();
643    _builder.append("\t");
644    _builder.append("this.");
645    String _name_2 = it.getName();
646    _builder.append(_name_2, "\t");
647    _builder.append(" = val;");
648    _builder.newLineIfNotEmpty();
649    _builder.append("\t");
650    _builder.append("return this;");
651    _builder.newLine();
652    _builder.append("}");
653    _builder.newLine();
654    return _builder.toString();
655  }
656  
657  public String _chained_builderSingleReferenceSetter(final Reference it, final DomainObject obj) {
658    StringConcatenation _builder = new StringConcatenation();
659    String _formatJavaDoc = this.helper.formatJavaDoc(it);
660    _builder.append(_formatJavaDoc, "");
661    _builder.newLineIfNotEmpty();
662    _builder.append("public ");
663    String _name = obj.getName();
664    _builder.append(_name, "");
665    _builder.append("Builder ");
666    String _name_1 = it.getName();
667    _builder.append(_name_1, "");
668    _builder.append("(");
669    String _typeName = this.helperBase.getTypeName(it);
670    _builder.append(_typeName, "");
671    _builder.append(" ");
672    String _name_2 = it.getName();
673    _builder.append(_name_2, "");
674    _builder.append(") {");
675    _builder.newLineIfNotEmpty();
676    _builder.append("\t");
677    _builder.append("this.");
678    String _name_3 = it.getName();
679    _builder.append(_name_3, "\t");
680    _builder.append(" = ");
681    String _name_4 = it.getName();
682    _builder.append(_name_4, "\t");
683    _builder.append(";");
684    _builder.newLineIfNotEmpty();
685    _builder.append("\t");
686    _builder.append("return this;");
687    _builder.newLine();
688    _builder.append("}");
689    _builder.newLine();
690    return _builder.toString();
691  }
692  
693  public BuilderTmpl[] _getOverridesDispatchArray() {
694    org.sculptor.generator.cartridge.builder.BuilderTmpl[] result = new org.sculptor.generator.cartridge.builder.BuilderTmpl[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.NUM_METHODS];
695    result[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.BUILDER_DOMAINOBJECT] = this; 
696    result[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.BUILDERBODY_DOMAINOBJECT] = this; 
697    result[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.ASSIGNATTRIBUTEINCONSTRUCTOR_NAMEDELEMENT] = this; 
698    result[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.MULTIREFERENCEADD_REFERENCE_DOMAINOBJECT] = this; 
699    result[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.BUILDERATTRIBUTE_ATTRIBUTE] = this; 
700    result[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.BUILDERATTRIBUTESETTER_ATTRIBUTE_DOMAINOBJECT] = this; 
701    result[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.BUILDERSINGLEREFERENCESETTER_REFERENCE_DOMAINOBJECT] = this; 
702    return result;
703  }
704}