<?xml version="1.0" encoding="UTF-8"?>
<!--
   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.
-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.apache.uima</groupId>
    <artifactId>uima-as-parent</artifactId>
    <version>2.3.1</version>
    <relativePath>../uima-as-parent/pom.xml</relativePath>
  </parent>

  <artifactId>aggregate-uima-as-eclipse-plugins</artifactId>
  <packaging>pom</packaging>
  <version>2.3.1</version>
  <name>UIMA-AS Aggregate: ${project.artifactId}</name>
  <description>The aggregate for building the Eclipse plugins 
    that are part of the UIMA-AS framework</description>
  <url>${uimaWebsiteUrl}</url>

  <!-- Special inheritance note
       even though the <scm> element that follows is exactly the
       same as those in super poms, it cannot be inherited because
       there is some special code that computes the connection elements
       from the chain of parent poms, if this is omitted.

       Keeping this a bit factored allows cutting/pasting the <scm>
       element, and just changing the following two properties -->
  <scm>
    <connection>
      scm:svn:http://svn.apache.org/repos/asf/uima/uima-as/tags/uima-as-2.3.1-rc3/aggregate-uima-as-eclipse-plugins
    </connection>
    <developerConnection>
      scm:svn:https://svn.apache.org/repos/asf/uima/uima-as/tags/uima-as-2.3.1-rc3/aggregate-uima-as-eclipse-plugins
    </developerConnection>
    <url>
      http://svn.apache.org/viewvc/uima/uima-as/tags/uima-as-2.3.1-rc3/aggregate-uima-as-eclipse-plugins
    </url>
  </scm>

  <properties>
    <uimaScmProject>${project.artifactId}</uimaScmProject>
  </properties>

  <modules>
    <module>../uimaj-ep-deployeditor</module>
    <module>../uimaj-ep-runtime-deployeditor</module>
    <module>../uimaj-as-osgi-runtime</module>    
    <module>../uimaj-as-camel</module>
    <module>../uimaj-eclipse-feature-deployeditor</module>
  </modules>
</project>
