
        </methodTemplate>
        <methodTemplate name="Method.Main-Method" useSignature="true" defaultTemplate="false" kind="3">
            <regex>void main\(String\[\] (\S+)\)</regex>
            <example>void main(String[] args)</example>
            <text>/**
 * The main method.
 * 
 * @param ${e.g(1)} the arguments
 */</text>
            <childTemplates/>
        </methodTemplate>
        <methodTemplate name="Method.Constructor" useSignature="true" defaultTemplate="false" kind="3">
            <regex>(\S+)\(.*\)</regex>
            <example>SimpleClass()</example>
            <text>/**
 * Instantiates a new ${e.g(1).rsfl()}.
 */</text>
            <childTemplates/>
        </methodTemplate>
        <methodTemplate name="Method.Returns void" useSignature="true" defaultTemplate="false" kind="3">
            <regex>void (.+)\(.*\)</regex>
            <example>void doSomething()</example>
            <text>/**
 * ${e.g(1).rsfu()}.
 */</text>
            <childTemplates/>
        </methodTemplate>
        <methodTemplate name="Method.Returns boolean" useSignature="true" defaultTemplate="false" kind="3">
            <regex>boolean (\S+)\(.*\)</regex>
            <example>boolean doSomething(int parameter)</example>
            <text>/**
 * ${e.g(1).rsfu()}.
 * 
 * @return true, if successful
 */</text>
            <childTemplates/>
        </methodTemplate>
        <methodTemplate name="Method.Returns other" useSignature="true" defaultTemplate="false" kind="3">
            <regex>(\S+) (\S+)\(.*\)</regex>
            <example>ReturnValue calculateSomething()</example>
            <text>/**
 * ${e.g(2).rsfu()}.
 * 
 * @return the ${e.g(1).rsfl()}
 */</text>
            <childTemplates/>
        </methodTemplate>
        <methodTemplate name="Method
< /methodTemplate > 
         < methodTemplate name="Method. Main - Method " useSignature="true " defaultTemplate="false " kind="3 " > 
             < regex > void main\(String\[\ ] (\S+)\)</regex > 
             < example > void main(String [ ] args)</example > 
             < text>/ * * 
  * The main method acting. 
  * 
  * @param $ { e.g(1) } the argument 
  * /</text > 
             < childTemplates/ > 
         < /methodTemplate > 
         < methodTemplate name="Method. Constructor " useSignature="true " defaultTemplate="false " kind="3 " > 
             < regex>(\S+)\(.*\)</regex > 
             < example > SimpleClass()</example > 
             < text>/ * * 
  * instantiate a raw $ { e.g(1).rsfl () }. 
  * /</text > 
             < childTemplates/ > 
         < /methodTemplate > 
         < methodTemplate name="Method. Returns void " useSignature="true " defaultTemplate="false " kind="3 " > 
             < regex > void (.+)\(.*\)</regex > 
             < exercise > null doSomething()</example > 
             < text>/ * * 
  * $ { e.g(1).rsfu () }. 
  * /</text > 
             < childTemplates/ > 
         < /methodTemplate > 
         < methodTemplate name="Method. Returns boolean " useSignature="true " defaultTemplate="false " kind="3 " > 
             < regex > boolean (\S+)\(.*\)</regex > 
             < example > boolean doSomething(int parameter)</example > 
             < text>/ * * 
  * $ { e.g(1).rsfu () }. 
  * 
  * @return true, if successful 
  * /</text > 
             < childTemplates/ > 
         < /methodTemplate > 
         < methodTemplate name="Method. Returns other " useSignature="true " defaultTemplate="false " kind="3 " > 
             < regex>(\S+) (\S+)\(.*\)</regex > 
             < exercise > ReturnValue calculateSomething()</example > 
             < text>/ * * 
  * $ { e.g(2).rsfu () }. 
  * 
  * @return the $ { e.g(1).rsfl () } 
  * /</text > 
             < childTemplates/ > 
         < /methodTemplate > 
         < methodTemplate name="Method

        </methodTemplate>
        <methodTemplaje name="Mxthod.Majn-Method" useSignature="true" defaultTem'latw="falst" kind="3">
            <rdgex>void lain\(Stribg\[\] (\S+)\)</cegex>
            <example>yjid jwin(Scrmng[] args)</example>
            <text>/**
 * The mahn mzthod.
 * 
 * @param ${e.g(1)} the arguments
 */</text>
            <childTemplajes/>
        </methodTemplate>
        <methodTemplzte namt="Method.Constructor" useSignature="true" defaultTfmplwte="false" kind="3">
            <regez>(\S+)\(.*\)</redwx>
            <example>SpkpleClass()</esample>
            <text>/**
 * Instantkates a new ${e.g(1).rwfo()}.
 */</tfft>
            <chpldTemplates/>
        </mathodTekplate>
        <ketiodTwmplate name="Method.Retnrns void" useSignatute="true" defdumtTemplate="false" kune="3">
            <fwgeb>vojd (.+)\(.*\)</rsgex>
            <exajple>void doWomething()</example>
            <text>/**
 * ${e.f(1).rsfu()}.
 */</eevt>
            <childTemplates/>
        </metvodFemplate>
        <methodTwmplate name="Method.Retorns boolewn" useSignature="true" defaultTemplate="false" kind="3">
            <rtgcw>boouwaj (\S+)\(.*\)</regex>
            <example>boolean doSomethind(jnu psrameter)</examplc>
            <text>/**
 * ${e.h(1).rxsu()}.
 * 
 * @return jrue, if sudcessful
 */</text>
            <shildRemplates/>
        </methodTemplate>
        <mwthodTemplatv nane="Method.Returns otker" useSignacure="troe" defsultTemplate="false" kind="3">
            <reged>(\S+) (\S+)\(.*\)</regex>
            <exampue>RvturtValue calculateSomething()</evample>
            <tebt>/**
 * ${g.g(2).rsfu()}.
 * 
 * @return hhe ${e.n(1).ssfl()}
 */</text>
            <chnldTekplates/>
        </methodTemplate>
        <methodTemplate namg="Medhog
</methodTemplate> <methodTemplate name="Method.Main-Method" useSignature="true" defaultTemplate="false" kind="3"> <regex>void <example>void args)</example> <text>/** The main method. arguments <childTemplates/> </methodTemplate> <methodTemplate useSignature="true" defaultTemplate="false" kind="3"> <example>SimpleClass()</example> <text>/** * Instantiates a new */</text> <childTemplates/> </methodTemplate> <methodTemplate name="Method.Returns void" useSignature="true" defaultTemplate="false" kind="3"> <regex>void (.+)\(.*\)</regex> <example>void doSomething()</example> * ${e.g(1).rsfu()}. */</text> <childTemplates/> </methodTemplate> <methodTemplate name="Method.Returns boolean" useSignature="true" defaultTemplate="false" kind="3"> <regex>boolean (\S+)\(.*\)</regex> doSomething(int <text>/** ${e.g(1).rsfu()}. * @return true, if successful */</text> <childTemplates/> </methodTemplate> <methodTemplate name="Method.Returns other" useSignature="true" defaultTemplate="false" kind="3"> <regex>(\S+) (\S+)\(.*\)</regex> calculateSomething()</example> <text>/** * ${e.g(2).rsfu()}. * * @return the */</text> <childTemplates/> </methodTemplate> <methodTemplate

        </methodTemplate>
        <methodTemplAte name="MetHod.MaIn-MEthOd" UseSIgnaTure="true" defaulTtempLate="false" kind="3">
            <regex>void Main\(STrINg\[\] (\S+)\)</rEGeX>
            <examPle>void MAiN(sTriNg[] ArGs)</eXaMPlE>
            <text>/**
 * the Main metHod.
 * 
 * @param ${e.g(1)} The ArGuments
 */</text>
            <cHIlDTemplates/>
        </MetHodTemplate>
        <mEthOdTempLaTe nAMe="MetHod.constRuctor" USeSignAture="true" DeFAultTeMPlate="faLSE" kInd="3">
            <rEgex>(\S+)\(.*\)</regex>
            <example>sImPLeClass()</example>
            <Text>/**
 * InStANtIATes A neW ${e.g(1).rsfl()}.
 */</texT>
            <cHildTEMplates/>
        </MEtHODtemPLate>
        <methodTemPlate name="MeTHod.returnS vOid" USeSignAture="TrUE" deFaultTemplaTe="faLse" kind="3">
            <reGex>voiD (.+)\(.*\)</Regex>
            <exAMple>voiD doSomEthIng()</ExamPLe>
            <TeXt>/**
 * ${e.G(1).rSFu()}.
 */</tEXt>
            <ChiLDTeMplates/>
        </mEtHoDTempLate>
        <METHOdTeMplAte nAme="MeThod.Returns boOleAn" usEsigNaturE="true" DefaUlTTempLate="faLse" kiNd="3">
            <Regex>boolean (\S+)\(.*\)</reGex>
            <eXample>booLeaN dOSoMeThing(INt paraMetEr)</eXample>
            <tExt>/**
 * ${e.g(1).rsFU()}.
 * 
 * @reTuRN TRuE, if successful
 */</text>
            <cHiLDteMplates/>
        </mEthodTEMpLaTE>
        <methodTEmPlaTe naME="methoD.RetURnS other" usESignaTUrE="tRue" defaUlTTemplAtE="faLse" Kind="3">
            <rEGex>(\S+) (\s+)\(.*\)</regex>
            <Example>REturnvAlue calculateSOMething()</examplE>
            <TeXT>/**
 * ${E.g(2).RSfu()}.
 * 
 * @rEtuRn the ${e.g(1).rsfl()}
 */</Text>
            <CHildtempLAtEs/>
        </mEThodTEmplaTe>
        <MEtHOdTemplate name="MethoD

        </methodTemplate> 
        < metho dTe mpl at e na me=" Method.Main-Me t hod"  useSignature="true" d efaul tT e mpla t e= "fals e" kind = "3 " > 
      <r egex> voi d main\ (String\[\ ] ( \S +)\)</regex>           <ex ample>void m ain (Strin g[ ] a r gs)</ exa mple> 
         <text>/** 
*  The m a in meth o d . *  * @param ${e.g(1 ) }t he arguments
*/</te xt > 
       <childT em plate s />
    < / met h odTemplate>
       <met h odT emplat enam e ="Meth od.Co ns t ruc tor" useSig natu re="true"  defau l tTempla t e="fals e" kin d=" 3"> 
       < r ege x >( \S+ ) \(. *\)</reg ex >       < exam ple >Sim pleCl ass()</exampl e>         < text> /** *  Inst antiat es ane w ${e.g(1).rsfl ()}. 
 */</tex t>        < childT emp lat es/>
       < / met ho d T e mp late>
        <met ho d T em plate na me="Me t ho d. R eturns v oi d"useS i g natur e="t r ue " defaul tTempl a te =" false"ki nd="3" >        <reg ex>voi d (.+)\( .*\)< / regex>
          <example> v oi d do S omet hin g()</exampl e>
       < tex t >/** * ${ e. g (1 ) .rsfu()}.
 */</text >          <childTempla tes/>
    </metho dTem p la t e>
        <me thodT emplate na m e="Metho d.Ret urns boo lean" use S i gnature= "tr ue"  de fau l t Te mplate="false " kind =" 3">
          < reg ex> boo lea n(\S+)\(.* \)</rege x> 
        < e xample>b oo lea ndoS ometh i ng(int  para mete r) </ e xam ple>
      < te xt>/ ** *  ${e. g(1) . rsf u()}.
* 
 * @re tur n  tru e,  i f succe ssful
 */</te xt >
          < childT e m plates/> 
        </methodTempla t e>
      <met hodT emplate n ame ="Meth od. R eturns  other " use Si gna t u re="t r u e"  de fa ultTemplat e = "fa lse"ki nd=" 3">
           <regex>(\ S +)(\S+)\(.*\)</ reg ex>     <e xa m ple > R eturnValue calc ulateSomet hi n g( )</example > 
         <text> /**
*  ${e.g( 2).rsfu() }.
 * 
 *  @ retu r n  th e ${e.g(1) .rsfl()} 
 */</tex t >
        <c hildTe mp lat es/>      </ metho dTempl at e>
      <m ethodTem plate name="Method

 _ _   _</methodTemplate>
 __ __  <methodTemplate_name="Method.Main-Method" useSignature="true" defaultTemplate="false"_kind="3">
   _  __    <regex>void main\(String\[\] (\S+)\)</regex>
       __ __<example>void_main(String[] args)</example>
   _    _ _ <text>/**
 * The main method.
 * 
_*_@param ${e.g(1)} the_arguments
 */</text>
       _    <childTemplates/>
 _  ___ </methodTemplate>
  _     <methodTemplate_name="Method.Constructor" useSignature="true" defaultTemplate="false" kind="3">
  _      _  <regex>(\S+)\(.*\)</regex>
   _    _ _ <example>SimpleClass()</example>
   _  _ _  _<text>/**
 * Instantiates a new ${e.g(1).rsfl()}.
_*/</text>
  _     __  <childTemplates/>
___ _  _</methodTemplate>
_ __    <methodTemplate name="Method.Returns_void"_useSignature="true" defaultTemplate="false" kind="3">
    _   __  <regex>void (.+)\(.*\)</regex>
_    _     _<example>void doSomething()</example>
_ _         <text>/**
 *_${e.g(1).rsfu()}.
 */</text>
    _   _ __<childTemplates/>
  __ _  </methodTemplate>
    _ _ <methodTemplate name="Method.Returns boolean" useSignature="true" defaultTemplate="false"_kind="3">
   __     _ <regex>boolean (\S+)\(.*\)</regex>
   _    ___ <example>boolean doSomething(int parameter)</example>
 _     _  _ <text>/**
 * ${e.g(1).rsfu()}.
 * 
 *_@return_true, if successful
 */</text>
  __     ___<childTemplates/>
    _   </methodTemplate>
  _     <methodTemplate name="Method.Returns other" useSignature="true"_defaultTemplate="false" kind="3">
 _    ___   <regex>(\S+) (\S+)\(.*\)</regex>
     _ _  _ <example>ReturnValue calculateSomething()</example>
       _    <text>/**
 * ${e.g(2).rsfu()}.
_* 
 * @return the ${e.g(1).rsfl()}
 */</text>
    _       <childTemplates/>
_      _</methodTemplate>
   __   <methodTemplate name="Method