<!--
	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/xsd/maven-4.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>
	<artifactId>org.apache.felix.ipojo.manipulator</artifactId>
	<groupId>org.apache.felix</groupId>
	<version>0.9.0-SNAPSHOT</version>
	<name>Apache Felix iPOJO Manipulator</name>

	<dependencies>
		<dependency>
			<groupId>asm</groupId>
			<artifactId>asm-all</artifactId>
			<version>3.0</version>
			<exclusions>
				<exclusion>
					<groupId>asm</groupId>
					<artifactId>asm-tree</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.apache.felix</groupId>
			<artifactId>org.apache.felix.ipojo.metadata</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.2</version>
				<extensions>true</extensions>
				<configuration>
					<instructions>
						<Bundle-Name>iPOJO Manipulator</Bundle-Name>
						<Bundle-Vendor>
							The Apache Software Foundation
						</Bundle-Vendor>
						<Bundle-Description>
							iPOJO Manipulator
						</Bundle-Description>
						<Export-Package>
							org.apache.felix.ipojo.manipulator
						</Export-Package>
						<Private-Package>
							org.apache.felix.ipojo.manipulation,
							org.apache.felix.ipojo.manipulation.annotations,
							org.apache.felix.ipojo.xml.parser,
							org.objectweb.asm, org.objectweb.asm.commons
						</Private-Package>
						<Include-Resource>
							META-INF/LICENCE=LICENSE,
							META-INF/LICENCE.asm=LICENSE.asm,
							META-INF/NOTICE=NOTICE
						</Include-Resource>
					</instructions>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>