text: <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  <jautodoc-preferences>
      <options>
          <completeExistingJavadoc>true</completeExistingJavadoc>
          <keepExistingJavadoc>false</keepExistingJavadoc>
          <replaceExistingJavadoc>false</replaceExistingJavadoc>
          <includePublic>true</includePublic>
          <includeProtected>true</includeProtected>
          <includePackage>true</includePackage>
          <includePrivate>true</includePrivate>
          <includeTypes>true</includeTypes>
          <includeFields>true</includeFields>
          <includeMethods>true</includeMethods>
          <getterSetterOnly>false</getterSetterOnly>
          <excludeGetterSetter>false</excludeGetterSetter>
          <addTodoForAutodoc>false</addTodoForAutodoc>
          <createDummyComment>true</createDummyComment>
          <singleLineComment>true</singleLineComment>
          <useEclipseFormatter>false</useEclipseFormatter>
          <getterSetterFromField>false</getterSetterFromField>
          <includeSubPackages>false</includeSubPackages>
          <addHeader>false</addHeader>
          <replaceHeader>false</replaceHeader>
          <multiCommentHeader>false</multiCommentHeader>
          <usePackageInfo>false</usePackageInfo>
      </options>
      <properties/>
      <replacements>
          <replacement mode="0" scope="1" shortcut="get">Gets the</replacement>
          <replacement mode="0" scope="1" shortcut="set">Sets the</replacement>
          <replacement mode="0" scope="1" shortcut="add">Adds the</replacement>
          <replacement mode="0" scope="1" shortcut="edit">Edits the</replacement>
          <replacement mode="0" scope="1" shortcut="remove">Removes the</replacement>
          <replacement mode="0" scope="1" shortcut="init">Inits the</replacement>
          <replacement mode="0" scope="1" shortcut="parse">Parses the</replacement>
          <replacement mode="0" scope="1" shortcut="create">Creates the</replacement>
          <replacement mode="0" scope="1" shortcut="build">Builds the</replacement>
          <replacement mode="0" scope="1" shortcut="is">Checks if is</replacement>
          <replacement mode="0" scope="1" shortcut="print">Prints the</replacement>
          <replacement mode="0" scope="1" shortcut="has">Checks for</replacement>
      </replacements>
      <templates>
          <typeTemplate name="Type.Factory" useSignature="false" defaultTemplate="false" kind="1">
              <regex>(.+)Factory</regex>
              <example>MessageFactory</example>
              <text>/**
   * A factory for creating ${e.g(1)} objects.
   */</text>
              <childTemplates>
                  <methodTemplate name="Type.Factory.Method.create" useSignature="false" defaultTemplate="false" kind="3">
                      <regex>create(.+)</regex>
                      <example>createMessage</example>
                      <text>/**
   * Creates a new ${e.p().g(1)} object.
   */</text>
                      <childTemplates/>
                  </methodTemplate>
              </childTemplates>
          </typeTemplate>
          <typeTemplate name="Type.Observer" useSignature="false" defaultTemplate="false" kind="1">
              <regex>(.+)Observer</regex>
              <example>ImageObserver</example>
              <text>/**
   * An asynchronous update interface for receiving notifications
   * about ${e.g(1)} information as the ${e.g(1)} is constructed.
   */</text>
              <childTemplates>
                  <methodTemplate name="Type.Observer.Method.update" useSignature="false" defaultTemplate="false" kind="3">
                      <regex>.*</regex>
                      <example>imageUpdate</example>
                      <text>/**
   * This method is called when information about an ${e.p().g(1)}
   * which was previously requested using an asynchronous
   * interface becomes available.
   */</text>
                      <childTemplates/>
                  </methodTemplate>
              </childTemplates>
          </typeTemplate>
          <typeTemplate name="Type.Listener" useSignature="false" defaultTemplate="false" kind="1">
              <regex>(.+)Listener</regex>
              <example>AutodocListener</example>
              <text>/**
   * The listener interface for receiving ${e.g(1).fl()} events.
   * The class that is interested in processing a ${e.g(1).fl()}
   * event implements this interface, and the object created
   * with that class is registered with a component using the
   * component's &lt;code&gt;add${e.g(1)}Listener&lt;code&gt; method. When
   * the ${e.g(1).fl()} event occurs, that object's appropriate
   * method is invoked.
   *
   * @see ${e.g(1)}Event
   */</text>
              <childTemplates>
                  <methodTemplate name="Type.Listener.Method.created" useSignature="false" defaultTemplate="false" kind="3">
                      <regex>(.*)Created</regex>
                      <example>autodocCreated</example>
                      <text>/**
   * Invoked when ${e.g(1).rs()} is created.
   */</text>
                      <childTemplates/>
                  </methodTemplate>
                  <methodTemplate name="Type.Listener.Method.updated" useSignature="false" defaultTemplate="false" kind="3">
                      <regex>(.*)Updated</regex>
                      <example>autodocUpdated</example>
                      <text>/**
   * Invoked when ${e.g(1).rs()} update occurs.
   */</text>
                      <childTemplates/>
                  </methodTemplate>
              </childTemplates>
          </typeTemplate>
          <typeTemplate name="Type.Default" useSignature="false" defaultTemplate="true" kind="1">
              <regex>.+</regex>
              <example>ExampleType</example>
              <text>/**
  ## type: class|interface|enum
   * The ${e.getType().fu()} ${e}.
   */</text>
              <childTemplates/>
          </typeTemplate>
          <fieldTemplate name="Field.fPrefix" useSignature="false" defaultTemplate="false" kind="2">
              <regex>f([A-Z].+)</regex>
              <example>fExampleMember</example>
              <text>/**
   * The ${e.g(1).rsfl()}.
   */</text>
              <childTemplates/>
          </fieldTemplate>
          <fieldTemplate name="Field.thePrefix" useSignature="false" defaultTemplate="false" kind="2">
              <regex>the[A-Z].+</regex>
              <example>theNumberOfQuestions</example>
              <text>/**
   * ${e.rsfu()}.
   */</text>
              <childTemplates/>
          </fieldTemplate>
          <fieldTemplate name="Field.Default" useSignature="false" defaultTemplate="true" kind="2">
              <regex>.+</regex>
              <example>numberOfQuestions</example>
              <text>/**
  #if(${e.isStatic()} &amp;&amp; ${e.isFinal()})
   * The Constant ${e}.
  #else
   * The ${e.rs()}.
  #end
   */</text>
              <childTemplates/>
          </fieldTemplate>
          <methodTemplate name="Method.getInstance" useSignature="false" defaultTemplate="false" kind="3">
              <regex>getInstance</regex>
              <example>getInstance</example>
              <text>/**
   * Gets the single instance of ${e.getDeclaringType()}.
   * 
   * @return single instance of ${e.getDeclaringType()}
   */</text>
              <childTemplates/>
          </methodTemplate>
          <methodTemplate name="Method.Getter" useSignature="true" defaultTemplate="false" kind="3">
              <regex>\S+ get(\S+)\(.*\)</regex>
              <example>int getNumberOfQuestions()</example>
              <text>/**
   * Gets the ${e.g(1).rsfl()}.
   * 
   * @return the ${e.g(1).rsfl()}
   */</text>
              <childTemplates/>
          </methodTemplate>
          <methodTemplate name="Method.Setter" useSignature="true" defaultTemplate="false" kind="3">
              <regex>void set(\S+)\([^,]+ ([^,]+)\)</regex>
              <example>void setNumberOfQuestions(int number)</example>
              <text>/**
   * Sets the ${e.g(1).rsfl()}.
   * 
   * @param ${e.g(2)} the new ${e.g(1).rsfl()}
   */</text>
              <childTemplates/>
          </methodTemplate>
          <methodTemplate name="Method.boolean Getter" useSignature="true" defaultTemplate="false" kind="3">
              <regex>boolean is(.+)\(.*\)</regex>
              <example>boolean isBlue()</example>
              <text>/**
   * Checks if is ${e.g(1).rsfl()}.
   * 
   * @return true, if is ${e.g(1).rsfl()}
   */</text>
              <childTemplates/>
          </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.Default" useSignature="false" defaultTemplate="true" kind="3">
              <regex>.+</regex>
              <example>doSomething</example>
              <text>/**
  ## Actually this is not used, because there
  ## are templates for different return types
   * ${e.rsfu()}.
   */</text>
              <childTemplates/>
          </methodTemplate>
          <parameterTemplate name="Parameter.Generic Type Parameter" useSignature="false" defaultTemplate="false" kind="4">
              <regex>&lt;(.+)&gt;</regex>
              <example>&lt;E&gt;</example>
              <text>/**
  #if(${e.g(1)} == 'E')
   * @param ${e} the element type
  #elseif(${e.g(1)} == 'K')
   * @param ${e} the key type
  #elseif(${e.g(1)} == 'N')
   * @param ${e} the number type
  #elseif(${e.g(1)} == 'V')
   * @param ${e} the value type
  #else
   * @param ${e} the generic type
  #end
   */</text>
              <childTemplates/>
          </parameterTemplate>
          <parameterTemplate name="Parameter.compUnit" useSignature="false" defaultTemplate="false" kind="4">
              <regex>compUnit</regex>
              <example>compUnit</example>
              <text>/**
  ## Example for shortcuts
   * @param ${e} the compilation unit
   */</text>
              <childTemplates/>
          </parameterTemplate>
          <parameterTemplate name="Parameter.pPrefix" useSignature="false" defaultTemplate="false" kind="4">
              <regex>p([A-Z].+)</regex>
              <example>pField</example>
              <text>/**
   * @param ${e} the ${e.g(1).rsfl()} 
   */</text>
              <childTemplates/>
          </parameterTemplate>
          <parameterTemplate name="Parameter.Default" useSignature="false" defaultTemplate="true" kind="4">
              <regex>.+</regex>
              <example>simpleParameter</example>
              <text>/**
   * @param ${e} the ${e.rsfl()}
   */</text>
              <childTemplates/>
          </parameterTemplate>
          <exceptionTemplate name="Exception.IOException" useSignature="false" defaultTemplate="false" kind="5">
              <regex>IOException</regex>
              <example>IOException</example>
              <text>/**
   * @throws ${e} Signals that an I/O exception has occurred.
   */</text>
              <childTemplates/>
          </exceptionTemplate>
          <exceptionTemplate name="Exception.Default" useSignature="false" defaultTemplate="true" kind="5">
              <regex>.+</regex>
              <example>ExampleException</example>
              <text>/**
   * @throws ${e} the ${e.sfl()}
   */</text>
              <childTemplates/>
          </exceptionTemplate>
      </templates>
      <headerText>/*
   * 
   */</headerText>
      <packageDocText>&lt;!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"&gt;
  &lt;html&gt;
  &lt;head&gt;&lt;/head&gt;
  &lt;body&gt;
    Provides...
  &lt;/body&gt;
  &lt;/html&gt;</packageDocText>
      <packageInfoText>/**
   * Provides...
   */
  package ${package_name};</packageInfoText>
  </jautodoc-preferences>
  