tree b0cf421bf7c00d14fe848d4790815ce3fd50f058
parent afaeb3db29702ea496276f88cbade21fcf4d05d4
author Clement Escoffier <clement@apache.org> 1230038518 +0000
committer Clement Escoffier <clement@apache.org> 1230038518 +0000

Fix issue Felix-846.
Despite the provided approach is not the cleanest (due to a maven issue), this patch allows setting iPOJO metadata in the pom file inside a CDATA block such as in:
	<plugin>
		<groupId>org.apache.felix</groupId>
		<artifactId>maven-ipojo-plugin</artifactId>
		<version>1.1.0-SNAPSHOT</version>
		<executions>
			<execution>
				<goals>
					<goal>ipojo-bundle</goal>
				</goals>
				<configuration>
					<ignoreAnnotations>true</ignoreAnnotations>
					<metadata>
   					<![CDATA[
   					<ipojo 
    					xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
						xsi:schemaLocation="org.apache.felix.ipojo http://felix.apache.org/ipojo/schemas/1.1.0-SNAPSHOT/core.xsd 
	 					org.apache.felix.ipojo.whiteboard http://felix.apache.org/ipojo/schemas/1.1.0-SNAPSHOT/whiteboard-pattern.xsd"
						xmlns="org.apache.felix.ipojo"
						xmlns:wbp="org.apache.felix.ipojo.whiteboard">
						<component classname="org.apache.felix.ipojo.test.FooProvider" name="fooprovider">
							<provides>
								<property field="foo" value="foo"/>
							</provides>
						</component>
	
						<component classname="org.apache.felix.ipojo.test.FooWhiteBoardPattern" name="under-providers">
								<wbp:wbp 
									filter="(objectclass=org.apache.felix.ipojo.test.FooService)" 
									onArrival="onArrival" onDeparture="onDeparture" onModification="onModification"
								/>
								<provides/>
						</component>
	
						<component classname="org.apache.felix.ipojo.test.FooWhiteBoardPattern" name="under-properties">
								<wbp:wbp filter="(foo=foo)" onArrival="onArrival" onDeparture="onDeparture" 
									onModification="onModification"
								/>
								<provides/>
						</component>
					</ipojo>
					]]>
					</metadata>
				</configuration>
			</execution>
		</executions>
	</plugin>
	
	
So, the metadata attribute can be either absent (only annotations), or can contain the name of the metadata file or can contain iPOJO metadata in a CDATA block.

git-svn-id: https://svn.apache.org/repos/asf/felix/trunk@728951 13f79535-47bb-0310-9956-ffa450edef68
