 -----
 Maven Skins Parent POM
 -----
 Hervé Boutemy
 -----
 2012-01-22
 -----

~~ 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:
~~ https://maven.apache.org/doxia/references/apt-format.html

Maven Skins Parent POM

    This POM is the common parent of all of the {{{/skins/}Maven Skins}}
    in the Apache Maven project.

History

#if( $project.version.endsWith( "SNAPSHOT" ) )
    trunk: {{{https://svn.apache.org/viewvc/maven/pom/trunk/maven/maven-skins/pom.xml?view=markup}$project.version}} ({{{https://svn.apache.org/viewvc/maven/pom/trunk/maven/maven-skins/pom.xml?r1=HEAD&r2=1632941&diff_format=h}diff}})
#end

*--------------+------------+
|| <<Version>> || <<Release Date>> ||
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/pom/tags/maven-30/maven-skins/pom.xml?view=markup}30}} ({{{https://svn.apache.org/viewvc/maven/pom/tags/maven-30/maven-skins/pom.xml?r1=HEAD&r2=1632941&diff_format=h}diff}}) | 2016-05-26  |
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-10/pom.xml?view=markup}10}} ({{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-10/pom.xml?r1=HEAD&r2=1582517&diff_format=h}diff}}) | 2014-10-22 |
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-9/pom.xml?view=markup}9}} ({{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-9/pom.xml?r1=HEAD&r2=1549585&diff_format=h}diff}}) | 2014-03-27 |
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-8/pom.xml?view=markup}8}} ({{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-8/pom.xml?r1=HEAD&r2=1377628&diff_format=h}diff}}) | 2013-12-09 |
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-7/pom.xml?view=markup}7}} ({{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-7/pom.xml?r1=HEAD&r2=1233017&diff_format=h}diff}}) | 2012-01-18 |
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-6/pom.xml?view=markup}6}} ({{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-6/pom.xml?r1=HEAD&r2=922895&diff_format=h}diff}}) | 2011-01-22 |
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-5/pom.xml?view=markup}5}} ({{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-5/pom.xml?r1=HEAD&r2=730790&diff_format=h}diff}}) | 2010-03-14 |
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-4/pom.xml?view=markup}4}} ({{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-4/pom.xml?r1=HEAD&r2=526733&diff_format=h}diff}}) | 2009-01-02 |
*--------------+------------+
