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      public String apply(final Attribute a) {
155        return BuilderTmpl.this.domainObjectAttributeTmpl.attribute(a, false);
156      }
157    };
158    List<String> _map = ListExtensions.<Attribute, String>map(_builderAttributes, _function);
159    String _join = IterableExtensions.join(_map);
160    _builder.append(_join, "\t");
161    _builder.newLineIfNotEmpty();
162    _builder.newLine();
163    _builder.append("\t");
164    List<Reference> _builderReferences = this.builderHelper.getBuilderReferences(it);
165    final Function1<Reference, Boolean> _function_1 = new Function1<Reference, Boolean>() {
166      public Boolean apply(final Reference r) {
167        boolean _isMany = r.isMany();
168        return Boolean.valueOf((!_isMany));
169      }
170    };
171    Iterable<Reference> _filter = IterableExtensions.<Reference>filter(_builderReferences, _function_1);
172    final Function1<Reference, String> _function_2 = new Function1<Reference, String>() {
173      public String apply(final Reference e) {
174        return BuilderTmpl.this.domainObjectReferenceTmpl.oneReferenceAttribute(e, false);
175      }
176    };
177    Iterable<String> _map_1 = IterableExtensions.<Reference, String>map(_filter, _function_2);
178    String _join_1 = IterableExtensions.join(_map_1);
179    _builder.append(_join_1, "\t");
180    _builder.newLineIfNotEmpty();
181    _builder.append("\t");
182    List<Reference> _builderReferences_1 = this.builderHelper.getBuilderReferences(it);
183    final Function1<Reference, Boolean> _function_3 = new Function1<Reference, Boolean>() {
184      public Boolean apply(final Reference r) {
185        return Boolean.valueOf(r.isMany());
186      }
187    };
188    Iterable<Reference> _filter_1 = IterableExtensions.<Reference>filter(_builderReferences_1, _function_3);
189    final Function1<Reference, String> _function_4 = new Function1<Reference, String>() {
190      public String apply(final Reference e) {
191        return BuilderTmpl.this.domainObjectReferenceTmpl.manyReferenceAttribute(e, false);
192      }
193    };
194    Iterable<String> _map_2 = IterableExtensions.<Reference, String>map(_filter_1, _function_4);
195    String _join_2 = IterableExtensions.join(_map_2);
196    _builder.append(_join_2, "\t");
197    _builder.newLineIfNotEmpty();
198    _builder.newLine();
199    _builder.append("\t");
200    _builder.append("/**");
201    _builder.newLine();
202    _builder.append("\t ");
203    _builder.append("* Static factory method for ");
204    String _builderClassName_1 = this.builderHelper.getBuilderClassName(it);
205    _builder.append(_builderClassName_1, "\t ");
206    _builder.newLineIfNotEmpty();
207    _builder.append("\t ");
208    _builder.append("*/");
209    _builder.newLine();
210    _builder.append("\t");
211    _builder.append("public static ");
212    String _name_1 = it.getName();
213    _builder.append(_name_1, "\t");
214    _builder.append("Builder ");
215    String _name_2 = it.getName();
216    String _firstLower = this.helperBase.toFirstLower(_name_2);
217    _builder.append(_firstLower, "\t");
218    _builder.append("() {");
219    _builder.newLineIfNotEmpty();
220    _builder.append("\t\t");
221    _builder.append("return new ");
222    String _name_3 = it.getName();
223    _builder.append(_name_3, "\t\t");
224    _builder.append("Builder();");
225    _builder.newLineIfNotEmpty();
226    _builder.append("\t");
227    _builder.append("}");
228    _builder.newLine();
229    _builder.newLine();
230    _builder.append("\t");
231    _builder.append("public ");
232    String _name_4 = it.getName();
233    _builder.append(_name_4, "\t");
234    _builder.append("Builder() {");
235    _builder.newLineIfNotEmpty();
236    _builder.append("\t");
237    _builder.append("}");
238    _builder.newLine();
239    _builder.newLine();
240    {
241      List<NamedElement> _builderConstructorParameters = this.builderHelper.getBuilderConstructorParameters(it);
242      boolean _isEmpty = _builderConstructorParameters.isEmpty();
243      boolean _not = (!_isEmpty);
244      if (_not) {
245        _builder.append("\t");
246        _builder.append("public ");
247        String _name_5 = it.getName();
248        _builder.append(_name_5, "\t");
249        _builder.append("Builder(");
250        List<NamedElement> _builderConstructorParameters_1 = this.builderHelper.getBuilderConstructorParameters(it);
251        final Function1<NamedElement, String> _function_5 = new Function1<NamedElement, String>() {
252          public String apply(final NamedElement p) {
253            return BuilderTmpl.this.domainObjectConstructorTmpl.parameterTypeAndName(p);
254          }
255        };
256        List<String> _map_3 = ListExtensions.<NamedElement, String>map(_builderConstructorParameters_1, _function_5);
257        String _join_3 = IterableExtensions.join(_map_3, ",");
258        _builder.append(_join_3, "\t");
259        _builder.append(") {");
260        _builder.newLineIfNotEmpty();
261        _builder.append("\t");
262        _builder.newLine();
263        {
264          List<NamedElement> _builderConstructorParameters_2 = this.builderHelper.getBuilderConstructorParameters(it);
265          for(final NamedElement p : _builderConstructorParameters_2) {
266            _builder.append("\t");
267            _builder.append("\t");
268            String _assignAttributeInConstructor = this.assignAttributeInConstructor(p);
269            _builder.append(_assignAttributeInConstructor, "\t\t");
270            _builder.newLineIfNotEmpty();
271          }
272        }
273        _builder.append("\t");
274        _builder.append("}");
275        _builder.newLine();
276      }
277    }
278    _builder.newLine();
279    _builder.append("\t");
280    List<Attribute> _builderAttributes_1 = this.builderHelper.getBuilderAttributes(it);
281    final Function1<Attribute, String> _function_6 = new Function1<Attribute, String>() {
282      public String apply(final Attribute a) {
283        return BuilderTmpl.this.builderAttributeSetter(a, it);
284      }
285    };
286    List<String> _map_4 = ListExtensions.<Attribute, String>map(_builderAttributes_1, _function_6);
287    String _join_4 = IterableExtensions.join(_map_4);
288    _builder.append(_join_4, "\t");
289    _builder.newLineIfNotEmpty();
290    _builder.newLine();
291    _builder.append("\t");
292    List<Reference> _builderReferences_2 = this.builderHelper.getBuilderReferences(it);
293    final Function1<Reference, Boolean> _function_7 = new Function1<Reference, Boolean>() {
294      public Boolean apply(final Reference r) {
295        boolean _isMany = r.isMany();
296        return Boolean.valueOf((!_isMany));
297      }
298    };
299    Iterable<Reference> _filter_2 = IterableExtensions.<Reference>filter(_builderReferences_2, _function_7);
300    final Function1<Reference, String> _function_8 = new Function1<Reference, String>() {
301      public String apply(final Reference r) {
302        return BuilderTmpl.this.builderSingleReferenceSetter(r, it);
303      }
304    };
305    Iterable<String> _map_5 = IterableExtensions.<Reference, String>map(_filter_2, _function_8);
306    String _join_5 = IterableExtensions.join(_map_5);
307    _builder.append(_join_5, "\t");
308    _builder.newLineIfNotEmpty();
309    _builder.append("\t");
310    List<Reference> _builderReferences_3 = this.builderHelper.getBuilderReferences(it);
311    final Function1<Reference, Boolean> _function_9 = new Function1<Reference, Boolean>() {
312      public Boolean apply(final Reference r) {
313        return Boolean.valueOf(r.isMany());
314      }
315    };
316    Iterable<Reference> _filter_3 = IterableExtensions.<Reference>filter(_builderReferences_3, _function_9);
317    final Function1<Reference, String> _function_10 = new Function1<Reference, String>() {
318      public String apply(final Reference r) {
319        return BuilderTmpl.this.multiReferenceAdd(r, it);
320      }
321    };
322    Iterable<String> _map_6 = IterableExtensions.<Reference, String>map(_filter_3, _function_10);
323    String _join_6 = IterableExtensions.join(_map_6);
324    _builder.append(_join_6, "\t");
325    _builder.newLineIfNotEmpty();
326    _builder.newLine();
327    _builder.append("\t");
328    List<Attribute> _builderAttributes_2 = this.builderHelper.getBuilderAttributes(it);
329    final Function1<Attribute, String> _function_11 = new Function1<Attribute, String>() {
330      public String apply(final Attribute a) {
331        return BuilderTmpl.this.domainObjectAttributeTmpl.propertyGetter(a);
332      }
333    };
334    List<String> _map_7 = ListExtensions.<Attribute, String>map(_builderAttributes_2, _function_11);
335    String _join_7 = IterableExtensions.join(_map_7);
336    _builder.append(_join_7, "\t");
337    _builder.newLineIfNotEmpty();
338    _builder.newLine();
339    _builder.append("\t");
340    List<Reference> _builderReferences_4 = this.builderHelper.getBuilderReferences(it);
341    final Function1<Reference, Boolean> _function_12 = new Function1<Reference, Boolean>() {
342      public Boolean apply(final Reference r) {
343        boolean _isMany = r.isMany();
344        return Boolean.valueOf((!_isMany));
345      }
346    };
347    Iterable<Reference> _filter_4 = IterableExtensions.<Reference>filter(_builderReferences_4, _function_12);
348    final Function1<Reference, String> _function_13 = new Function1<Reference, String>() {
349      public String apply(final Reference r) {
350        return BuilderTmpl.this.domainObjectReferenceTmpl.oneReferenceGetter(r, false);
351      }
352    };
353    Iterable<String> _map_8 = IterableExtensions.<Reference, String>map(_filter_4, _function_13);
354    String _join_8 = IterableExtensions.join(_map_8);
355    _builder.append(_join_8, "\t");
356    _builder.newLineIfNotEmpty();
357    _builder.append("\t");
358    List<Reference> _builderReferences_5 = this.builderHelper.getBuilderReferences(it);
359    final Function1<Reference, Boolean> _function_14 = new Function1<Reference, Boolean>() {
360      public Boolean apply(final Reference r) {
361        return Boolean.valueOf(r.isMany());
362      }
363    };
364    Iterable<Reference> _filter_5 = IterableExtensions.<Reference>filter(_builderReferences_5, _function_14);
365    final Function1<Reference, String> _function_15 = new Function1<Reference, String>() {
366      public String apply(final Reference r) {
367        return BuilderTmpl.this.domainObjectReferenceTmpl.manyReferenceGetter(r, false);
368      }
369    };
370    Iterable<String> _map_9 = IterableExtensions.<Reference, String>map(_filter_5, _function_15);
371    String _join_9 = IterableExtensions.join(_map_9);
372    _builder.append(_join_9, "\t");
373    _builder.newLineIfNotEmpty();
374    _builder.newLine();
375    _builder.append("\t");
376    _builder.append("/**");
377    _builder.newLine();
378    _builder.append("\t ");
379    _builder.append("* @return new ");
380    String _name_6 = it.getName();
381    _builder.append(_name_6, "\t ");
382    _builder.append(" instance constructed based on the values that have been set into this builder");
383    _builder.newLineIfNotEmpty();
384    _builder.append("\t ");
385    _builder.append("*/");
386    _builder.newLine();
387    _builder.append("\t");
388    _builder.append("public ");
389    String _domainPackage = this.helperBase.getDomainPackage(it);
390    String _plus = (_domainPackage + ".");
391    String _name_7 = it.getName();
392    String _plus_1 = (_plus + _name_7);
393    _builder.append(_plus_1, "\t");
394    _builder.append(" build() {");
395    _builder.newLineIfNotEmpty();
396    _builder.append("\t\t");
397    String _domainPackage_1 = this.helperBase.getDomainPackage(it);
398    String _plus_2 = (_domainPackage_1 + ".");
399    String _name_8 = it.getName();
400    String _plus_3 = (_plus_2 + _name_8);
401    _builder.append(_plus_3, "\t\t");
402    _builder.append(" obj = new ");
403    String _name_9 = it.getName();
404    _builder.append(_name_9, "\t\t");
405    _builder.append("(");
406    {
407      List<NamedElement> _builderConstructorParameters_3 = this.builderHelper.getBuilderConstructorParameters(it);
408      boolean _hasElements = false;
409      for(final NamedElement attr : _builderConstructorParameters_3) {
410        if (!_hasElements) {
411          _hasElements = true;
412        } else {
413          _builder.appendImmediate(", ", "\t\t");
414        }
415        String _getAccessor = this.helper.getGetAccessor(attr);
416        _builder.append(_getAccessor, "\t\t");
417        _builder.append("()");
418      }
419    }
420    _builder.append(");");
421    _builder.newLineIfNotEmpty();
422    _builder.append("\t\t");
423    final List<NamedElement> attrs = CollectionLiterals.<NamedElement>newArrayList();
424    _builder.newLineIfNotEmpty();
425    _builder.append("\t\t");
426    String _xblockexpression = null;
427    {
428      List<Attribute> _builderAttributes_3 = this.builderHelper.getBuilderAttributes(it);
429      attrs.addAll(_builderAttributes_3);
430      List<Reference> _builderReferences_6 = this.builderHelper.getBuilderReferences(it);
431      final Function1<Reference, Boolean> _function_16 = new Function1<Reference, Boolean>() {
432        public Boolean apply(final Reference r) {
433          boolean _isMany = r.isMany();
434          return Boolean.valueOf((!_isMany));
435        }
436      };
437      Iterable<Reference> _filter_6 = IterableExtensions.<Reference>filter(_builderReferences_6, _function_16);
438      List<Reference> _list = IterableExtensions.<Reference>toList(_filter_6);
439      attrs.addAll(_list);
440      List<NamedElement> _builderConstructorParameters_4 = this.builderHelper.getBuilderConstructorParameters(it);
441      attrs.removeAll(_builderConstructorParameters_4);
442      _xblockexpression = "";
443    }
444    _builder.append(_xblockexpression, "\t\t");
445    _builder.newLineIfNotEmpty();
446    {
447      for(final NamedElement prop : attrs) {
448        _builder.append("\t\t");
449        _builder.append("obj.set");
450        String _name_10 = prop.getName();
451        String _firstUpper = this.helperBase.toFirstUpper(_name_10);
452        _builder.append(_firstUpper, "\t\t");
453        _builder.append("(");
454        String _name_11 = prop.getName();
455        _builder.append(_name_11, "\t\t");
456        _builder.append(");");
457        _builder.newLineIfNotEmpty();
458      }
459    }
460    _builder.append("\t\t");
461    List<Reference> _builderReferences_6 = this.builderHelper.getBuilderReferences(it);
462    final Function1<Reference, Boolean> _function_16 = new Function1<Reference, Boolean>() {
463      public Boolean apply(final Reference r) {
464        return Boolean.valueOf(r.isMany());
465      }
466    };
467    Iterable<Reference> _filter_6 = IterableExtensions.<Reference>filter(_builderReferences_6, _function_16);
468    final List<Reference> refs = IterableExtensions.<Reference>toList(_filter_6);
469    _builder.newLineIfNotEmpty();
470    _builder.append("\t\t");
471    String _xblockexpression_1 = null;
472    {
473      List<NamedElement> _builderConstructorParameters_4 = this.builderHelper.getBuilderConstructorParameters(it);
474      refs.removeAll(_builderConstructorParameters_4);
475      _xblockexpression_1 = "";
476    }
477    _builder.append(_xblockexpression_1, "\t\t");
478    _builder.newLineIfNotEmpty();
479    {
480      for(final Reference prop_1 : refs) {
481        _builder.append("\t\t");
482        _builder.append("obj.get");
483        String _name_12 = prop_1.getName();
484        String _firstUpper_1 = this.helperBase.toFirstUpper(_name_12);
485        _builder.append(_firstUpper_1, "\t\t");
486        _builder.append("().addAll(");
487        String _name_13 = prop_1.getName();
488        _builder.append(_name_13, "\t\t");
489        _builder.append(");");
490        _builder.newLineIfNotEmpty();
491      }
492    }
493    _builder.newLine();
494    _builder.append("\t\t");
495    _builder.append("return obj;");
496    _builder.newLine();
497    _builder.append("\t");
498    _builder.append("}");
499    _builder.newLine();
500    _builder.append("}");
501    _builder.newLine();
502    _builder.newLine();
503    return _builder.toString();
504  }
505  
506  public String _chained_assignAttributeInConstructor(final NamedElement it) {
507    StringConcatenation _builder = new StringConcatenation();
508    {
509      boolean _and = false;
510      if (!(it instanceof Reference)) {
511        _and = false;
512      } else {
513        boolean _isMany = ((Reference) it).isMany();
514        _and = _isMany;
515      }
516      if (_and) {
517        _builder.append("this.");
518        String _name = it.getName();
519        _builder.append(_name, "");
520        _builder.append(".addAll(");
521        String _name_1 = it.getName();
522        _builder.append(_name_1, "");
523        _builder.append(");");
524        _builder.newLineIfNotEmpty();
525      } else {
526        _builder.append("this.");
527        String _name_2 = it.getName();
528        _builder.append(_name_2, "");
529        _builder.append(" = ");
530        String _name_3 = it.getName();
531        _builder.append(_name_3, "");
532        _builder.append(";");
533        _builder.newLineIfNotEmpty();
534      }
535    }
536    _builder.newLine();
537    return _builder.toString();
538  }
539  
540  public String _chained_multiReferenceAdd(final Reference it, final DomainObject obj) {
541    StringConcatenation _builder = new StringConcatenation();
542    _builder.append("/**");
543    _builder.newLine();
544    _builder.append(" ");
545    _builder.append("* Adds an object to the to-many");
546    _builder.newLine();
547    _builder.append(" ");
548    _builder.append("* association.");
549    _builder.newLine();
550    _builder.append(" ");
551    _builder.append("* It is added the collection {@link #get");
552    String _name = it.getName();
553    String _firstUpper = this.helperBase.toFirstUpper(_name);
554    _builder.append(_firstUpper, " ");
555    _builder.append("}.");
556    _builder.newLineIfNotEmpty();
557    _builder.append(" ");
558    _builder.append("*/");
559    _builder.newLine();
560    _builder.append("public ");
561    String _name_1 = obj.getName();
562    _builder.append(_name_1, "");
563    _builder.append("Builder add");
564    String _name_2 = it.getName();
565    String _firstUpper_1 = this.helperBase.toFirstUpper(_name_2);
566    String _singular = this.helper.singular(_firstUpper_1);
567    _builder.append(_singular, "");
568    _builder.append("(");
569    String _typeName = this.helperBase.getTypeName(it);
570    _builder.append(_typeName, "");
571    _builder.append(" ");
572    String _name_3 = it.getName();
573    String _singular_1 = this.helper.singular(_name_3);
574    _builder.append(_singular_1, "");
575    _builder.append("Element) {");
576    _builder.newLineIfNotEmpty();
577    _builder.append("\t");
578    _builder.append("get");
579    String _name_4 = it.getName();
580    String _firstUpper_2 = this.helperBase.toFirstUpper(_name_4);
581    _builder.append(_firstUpper_2, "\t");
582    _builder.append("().add(");
583    String _name_5 = it.getName();
584    String _singular_2 = this.helper.singular(_name_5);
585    _builder.append(_singular_2, "\t");
586    _builder.append("Element);");
587    _builder.newLineIfNotEmpty();
588    _builder.append("\t");
589    _builder.append("return this;");
590    _builder.newLine();
591    _builder.append("}");
592    _builder.newLine();
593    return _builder.toString();
594  }
595  
596  public String _chained_builderAttribute(final Attribute it) {
597    StringConcatenation _builder = new StringConcatenation();
598    _builder.append("protected ");
599    String _implTypeName = this.helperBase.getImplTypeName(it);
600    _builder.append(_implTypeName, "");
601    _builder.append(" ");
602    String _name = it.getName();
603    _builder.append(_name, "");
604    _builder.append(";");
605    _builder.newLineIfNotEmpty();
606    return _builder.toString();
607  }
608  
609  public String _chained_builderAttributeSetter(final Attribute it, final DomainObject obj) {
610    StringConcatenation _builder = new StringConcatenation();
611    String _formatJavaDoc = this.helper.formatJavaDoc(it);
612    _builder.append(_formatJavaDoc, "");
613    _builder.newLineIfNotEmpty();
614    _builder.append("public ");
615    String _name = obj.getName();
616    _builder.append(_name, "");
617    _builder.append("Builder ");
618    String _name_1 = it.getName();
619    _builder.append(_name_1, "");
620    _builder.append("(");
621    String _typeName = this.helperBase.getTypeName(it);
622    _builder.append(_typeName, "");
623    _builder.append(" val) {");
624    _builder.newLineIfNotEmpty();
625    _builder.append("\t");
626    _builder.append("this.");
627    String _name_2 = it.getName();
628    _builder.append(_name_2, "\t");
629    _builder.append(" = val;");
630    _builder.newLineIfNotEmpty();
631    _builder.append("\t");
632    _builder.append("return this;");
633    _builder.newLine();
634    _builder.append("}");
635    _builder.newLine();
636    return _builder.toString();
637  }
638  
639  public String _chained_builderSingleReferenceSetter(final Reference it, final DomainObject obj) {
640    StringConcatenation _builder = new StringConcatenation();
641    String _formatJavaDoc = this.helper.formatJavaDoc(it);
642    _builder.append(_formatJavaDoc, "");
643    _builder.newLineIfNotEmpty();
644    _builder.append("public ");
645    String _name = obj.getName();
646    _builder.append(_name, "");
647    _builder.append("Builder ");
648    String _name_1 = it.getName();
649    _builder.append(_name_1, "");
650    _builder.append("(");
651    String _typeName = this.helperBase.getTypeName(it);
652    _builder.append(_typeName, "");
653    _builder.append(" ");
654    String _name_2 = it.getName();
655    _builder.append(_name_2, "");
656    _builder.append(") {");
657    _builder.newLineIfNotEmpty();
658    _builder.append("\t");
659    _builder.append("this.");
660    String _name_3 = it.getName();
661    _builder.append(_name_3, "\t");
662    _builder.append(" = ");
663    String _name_4 = it.getName();
664    _builder.append(_name_4, "\t");
665    _builder.append(";");
666    _builder.newLineIfNotEmpty();
667    _builder.append("\t");
668    _builder.append("return this;");
669    _builder.newLine();
670    _builder.append("}");
671    _builder.newLine();
672    return _builder.toString();
673  }
674  
675  public BuilderTmpl[] _getOverridesDispatchArray() {
676    org.sculptor.generator.cartridge.builder.BuilderTmpl[] result = new org.sculptor.generator.cartridge.builder.BuilderTmpl[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.NUM_METHODS];
677    result[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.BUILDER_DOMAINOBJECT] = this; 
678    result[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.BUILDERBODY_DOMAINOBJECT] = this; 
679    result[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.ASSIGNATTRIBUTEINCONSTRUCTOR_NAMEDELEMENT] = this; 
680    result[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.MULTIREFERENCEADD_REFERENCE_DOMAINOBJECT] = this; 
681    result[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.BUILDERATTRIBUTE_ATTRIBUTE] = this; 
682    result[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.BUILDERATTRIBUTESETTER_ATTRIBUTE_DOMAINOBJECT] = this; 
683    result[org.sculptor.generator.cartridge.builder.BuilderTmplMethodIndexes.BUILDERSINGLEREFERENCESETTER_REFERENCE_DOMAINOBJECT] = this; 
684    return result;
685  }
686}