CodeFormatter formatter = ToolFactory.createCodeFormatter(null);
    TextEdit formattedJavaDoc = formatter.format(CodeFormatter.K_JAVA_DOC, source, indentionLevel, source.length(), 0, "\n");

  @Inject
  private IGrammarAccess grammarAccess;
  
  @Override
  public ITokenStream createFormatterStream(String indent, ITokenStream out, boolean preserveWhitespaces) {
    return new DocFormattingConfigBasedStream(out, indent, getConfig(), createMatcher(), getHiddenTokenHelper(),
        preserveWhitespaces, (MyDslGrammarAccess) grammarAccess);
  }

package at.mydsl.formatting;

import java.io.IOException;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.jdt.core.ToolFactory;
import org.eclipse.jdt.core.formatter.CodeFormatter;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.text.edits.TextEdit;
import org.eclipse.xtext.TerminalRule;
import org.eclipse.xtext.formatting.IElementMatcherProvider.IElementMatcher;
import org.eclipse.xtext.formatting.impl.AbstractFormattingConfig.ElementPattern;
import org.eclipse.xtext.formatting.impl.FormattingConfig;
import org.eclipse.xtext.formatting.impl.FormattingConfigBasedStream;
import org.eclipse.xtext.parsetree.reconstr.IHiddenTokenHelper;
import org.eclipse.xtext.parsetree.reconstr.ITokenStream;

/**
 * This stream uses the JDT code formatter for formatting 
 * single-line, multi-line and documentation comments
 * @author Daniel Kuschny
 */
public class DocFormattingConfigBasedStream extends FormattingConfigBasedStream {
  
  private AsgardGrammarAccess grammarAccess;

  // create a formatter for reusage
  private static CodeFormatter formatter = ToolFactory
                                             .createCodeFormatter(null);

  public DocFormattingConfigBasedStream(ITokenStream out, String indentation,
      FormattingConfig cfg, IElementMatcher<ElementPattern> matcher,
      IHiddenTokenHelper hiddenTokenHelper, boolean preserveSpaces, 
      MyDslGrammarAccess grammarAccess) {
    super(out, indentation, cfg, matcher, hiddenTokenHelper, preserveSpaces);
    this.grammarAccess = grammarAccess;
  }

  @Override
  protected void addLineEntry(EObject grammarElement, String value,
      boolean isHidden) throws IOException {
    
    // check for terminal rules
    if(grammarElement instanceof TerminalRule) {
      
      
      TerminalRule rule = (TerminalRule)grammarElement;
      
      // check for our lovely comment rules
      // and trigger the formatter to replace the token value
      
      if(grammarAccess.getDOC_COMMENTRule().equals(rule)) {
        value = formatComment(CodeFormatter.K_JAVA_DOC, value);
      }
      else if(grammarAccess.getML_COMMENTRule().equals(rule)) {
        value = formatComment(CodeFormatter.K_MULTI_LINE_COMMENT, value);
      }
      else if(grammarAccess.getSL_COMMENTRule().equals(rule)) {
        value = formatComment(CodeFormatter.K_SINGLE_LINE_COMMENT, value);
      }
    }

    super.addLineEntry(grammarElement, value, isHidden);
  }

  /**
   * Formats the given code using the JDT code formatter. 
   * @param kind Use to specify the kind of the code snippet to format. It can
   * be any of these:
   * <ul>
   *  <li>{@link CodeFormatter#K_EXPRESSION}</li>
   *  <li>{@link CodeFormatter#K_STATEMENTS}</li>
   *  <li>{@link CodeFormatter#K_CLASS_BODY_DECLARATIONS}</li>
   *  <li>{@link CodeFormatter#K_COMPILATION_UNIT}</li>
   *  <li>{@link CodeFormatter#K_UNKNOWN}</li>
   *  <li>{@link CodeFormatter#K_SINGLE_LINE_COMMENT}</li>
   *  <li>{@link CodeFormatter#K_MULTI_LINE_COMMENT}</li>
   *  <li>{@link CodeFormatter#K_JAVA_DOC}</li>
   * </ul>
   * @param source the source to format
   * @see CodeFormatter#format(int, String, int, int, int, String)
   * @return the formatted code 
   */
  private static String formatComment(int mode, String source) {
    try {
      // get the text diff
      TextEdit formatted = formatter.format(mode, source, 0,
          source.length(), 0, "\n");
      
      // apply the diff to the source  
      IDocument document = new Document(source);
      formatted.apply(document);
      return document.get();
    }
    catch (Exception e) {
      // on failure return the original code
      return source;
    }
  }
}