  ---
  Multi-Module Examples
  ---
  Edwin Punzalan
  ---
  24-July-2006
  ---

~~ Copyright 2006 The Apache Software Foundation.
~~
~~ Licensed 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/guides/mini/guide-apt-format.html

Multi-Module Examples

  Multimodule Projects use \<moduleSets\> in their assemblies.

  The examples below may be able to help you when creating assemblies for your
  multimodule project.

    * {{{module-source-inclusion-simple.html}Adding Module Sources to the Assembly}}

    * {{{module-binary-inclusion-simple.html}Adding Module Binaries to the Assembly}}
