 -----
 Anchors / Links in APT
 -----
 Lukas Theussl
 -----
 May 2008
 -----

~~ Licensed to the Apache Software Foundation (ASF) under one
~~ or more contributor license agreements.  See the NOTICE file
~~ distributed with this work for additional information
~~ regarding copyright ownership.  The ASF licenses this file
~~ to you under the Apache License, Version 2.0 (the
~~ "License"); you may not use this file except in compliance
~~ with the License.  You may obtain a copy of the License at
~~
~~   http://www.apache.org/licenses/LICENSE-2.0
~~
~~ Unless required by applicable law or agreed to in writing,
~~ software distributed under the License is distributed on an
~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~~ KIND, either express or implied.  See the License for the
~~ specific language governing permissions and limitations
~~ under the License.

~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/doxia/references/apt-format.html

Links

  {Anchor}
  {cdc.html}
  Link to {{Anchor}}.
  Link to anchor {{{Anchor}showing alternate text}}.
  {Anchor with space} and {{{Anchor_with_space}link to it}}.
  Link to {{http://maven.apache.org/}}.
  Link to {{{http://maven.apache.org/}Maven home page}}.
  Link to {{{./cdc.html}other document}} and within {{{cdc.html}same document}}.
  Link to {{{/index.html}root document}}.

TOC Macro

%{toc}

Echo Macro

%{echo|param1=value1|param2=value2}

Snippet Macro

%{snippet|id=macrotest|file=src/test/resources/site/site.xml}
