<!--
	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">
	<parent>
		<groupId>org.apache.felix</groupId>
		<artifactId>felix</artifactId>
		<version>1.0.2</version>
		<relativePath>../../pom/pom.xml</relativePath>
	</parent>
	<modelVersion>4.0.0</modelVersion>
	<packaging>bundle</packaging>
	<name>Apache Felix iPOJO Composite</name>
	<artifactId>org.apache.felix.ipojo.composite</artifactId>
	<groupId>org.apache.felix</groupId>
	<version>0.9.0-SNAPSHOT</version>
	<dependencies>
		<dependency>
			<groupId>org.apache.felix</groupId>
			<artifactId>org.osgi.core</artifactId>
			<version>1.0.0</version>
		</dependency>
		<dependency>
			<groupId>org.apache.felix</groupId>
			<artifactId>org.osgi.compendium</artifactId>
			<version>1.0.0</version>
		</dependency>
		<dependency>
			<groupId>org.apache.felix</groupId>
			<artifactId>org.apache.felix.ipojo.metadata</artifactId>
			<version>0.9.0-SNAPSHOT</version>
		</dependency>
		<dependency>
			<groupId>org.apache.felix</groupId>
			<artifactId>org.apache.felix.ipojo.manipulator</artifactId>
			<version>0.9.0-SNAPSHOT</version>
		</dependency>
		<dependency>
			<groupId>org.apache.felix</groupId>
			<artifactId>org.apache.felix.ipojo</artifactId>
			<version>0.9.0-SNAPSHOT</version>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.felix</groupId>
				<artifactId>maven-bundle-plugin</artifactId>
				<version>1.4.0</version>
				<extensions>true</extensions>
				<configuration>
					<instructions>
						<Bundle-Name>iPOJO Composite</Bundle-Name>
						<Bundle-Vendor>
							The Apache Software Foundation
						</Bundle-Vendor>
						<Bundle-Description>
							iPOJO Composititon Framework
						</Bundle-Description>
						<Import-Package>
							org.apache.felix.ipojo,
							org.apache.felix.ipojo.architecture,
							org.apache.felix.ipojo.context,
							org.apache.felix.ipojo.metadata,
							org.apache.felix.ipojo.parser,
							org.apache.felix.ipojo.util,
							org.osgi.framework
						</Import-Package>
						<Private-Package>
							org.apache.felix.ipojo.manipulation,
							org.apache.felix.ipojo.composite.architecture,
							org.apache.felix.ipojo.composite.service*,
							org.apache.felix.ipojo.composite.instance,
							org.apache.felix.ipojo.composite.util,
							!org.objectweb.asm.xml*,
							org.objectweb.asm*;-split-package:=merge-first
						</Private-Package>
						<Export-Package>
							org.apache.felix.ipojo.composite;
							version="0.8.0"
						</Export-Package>
						<Include-Resource>
							META-INF/LICENCE=LICENSE,
							META-INF/NOTICE=NOTICE
						</Include-Resource>
						<IPOJO-Extension>
							composite:org.apache.felix.ipojo.composite.CompositeFactory
						</IPOJO-Extension>
						<_donotcopy>
							(CVS|.svn|.+.bak|~.+|metadata.xml)
						</_donotcopy>
					</instructions>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.felix</groupId>
				<artifactId>maven-ipojo-plugin</artifactId>
				<version>0.9.0-SNAPSHOT</version>
				<executions>
					<execution>
						<goals>
							<goal>ipojo-bundle</goal>
						</goals>
						<configuration>
							<metadata>metadata.xml</metadata>
							<ignoreAnnotations>true</ignoreAnnotations>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>
</project>
