<?xml version="1.0" encoding="UTF-8"?>
<!--#======================================================================= -->
<!--# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) -->
<!--# All rights reserved. This program and the accompanying materials -->
<!--# are made available under the terms of the Eclipse Public License v1.0 -->
<!--# which accompanies this distribution, and is available at -->
<!--# http://www.eclipse.org/legal/epl-v10.html -->
<!--# -->
<!--# Contributors: -->
<!--#     Christophe Loetz (Loetz GmbH&Co.KG) - initial API and implementation -->
<!--#======================================================================= -->

<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">
	<modelVersion>4.0.0</modelVersion>
	<artifactId>org.eclipse.osbp.xtext.datamartdsl.ui</artifactId>
	<packaging>eclipse-plugin</packaging>
	<parent>
		<groupId>org.eclipse.osbp.xtext.datamartdsl</groupId>
		<artifactId>org.eclipse.osbp.xtext.datamartdsl.aggregator</artifactId>
		<version>0.9.0-SNAPSHOT</version>
		<relativePath>..</relativePath>
	</parent>

</project>
