build.xml

<?xml version="1.0"?>
<!--

  Copyright (c) 2004-2011, PostgreSQL Global Development Group

  Build file to allow ant (http://ant.apache.org/) to be used
  to build the PostgreSQL JDBC Driver.

  This file now requires Ant 1.4.1.  2002-04-18


-->

<!DOCTYPE project [
  <!ENTITY jarfiles "fdb-sql-layer-jdbc.jar">
]>

<project name="fdb-sql-layer-JDBC" default="all" basedir="." xmlns:artifact="antlib:org.apache.maven.artifact.ant">

  <!-- set global properties for this build -->
  <property name="srcdir"  value="src/main/java" />
  <property name="testdir" value="src/test/java" />
  <property name="resdir"  value="src/main/resources"/>
  <property name="jardir"  value="jars" />
  <property name="builddir" value="build" />
  <property name="package" value="com/foundationdb/sql/jdbc" />
  <property name="debug" value="on" />

  <!-- default build parameters are in build.properties, these may be
       overridden by local configuration settings in build.local.properties
  -->
  <property file="build.local.properties" />
  <property file="build.properties"/>

 <!-- define artifacts' name, which follows the convention of Maven -->
  <property name="maven.jar" value="${jardir}/${maven.artifact.id}-${maven.artifact.version}.jar"/>
  <property name="maven.javadoc.jar" value="${jardir}/${maven.artifact.id}-${maven.artifact.version}-javadoc.jar"/>
  <property name="maven.sources.jar" value="${jardir}/${maven.artifact.id}-${maven.artifact.version}-sources.jar"/>
  <property name="java.target" value="${java.specification.version}"/>
    
  <patternset id="jdbc.version.src.pattern">
    <!-- This is the core of the driver.  It is common for all versions. -->
    <include name="${package}/*.java" />
    <include name="${package}/core/**" />
    <include name="${package}/copy/**" />
    <include name="${package}/fastpath/**" />
    <include name="${package}/geometric/**" />
    <include name="${package}/largeobject/**" />
    <include name="${package}/util/**" />

    <!--
    Each jdbcN subpackage is used only if the driver supports *at least* that
    revision of JDBC. That is, a JDBC2 build uses only jdbc2, a JDBC3 build
    uses both jdbc2 and jdbc3, etc.

    Within those subpackages, classes beginning with "JdbcN" are assumed to be
    the concrete implementations for JDBC version N and are built only if the
    driver supports *exactly* that version. For example, jdbc2/Jdbc2Statement.java
    is built only if the driver build is a JDBC2 build.
    -->

    <!-- jdbc2 subpackage -->
    <include name="${package}/jdbc2/**"/>

    <!-- jdbc3 subpackage -->
    <include name="${package}/jdbc3/Abstract*.java"/>
    <include name="${package}/jdbc3/PSQLSavepoint.java"/>

    <include name="${package}/jdbc3/Jdbc3Array.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3Blob.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3CallableStatement.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3Clob.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3Connection.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3DatabaseMetaData.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3PreparedStatement.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3ResultSet.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3ResultSetMetaData.java.java" if="jdbc3"/>
    <include name="${package}/jdbc3/Jdbc3Statement.java" if="jdbc3"/>

    <!-- jdbc3g subpackage -->
    <include name="${package}/jdbc3g/*.java" if="jdbc3g"/>
    <exclude name="${package}/jdbc3g/Jdbc3g*.java" unless="jdbc3g"/>

    <!-- jdbc4 subpackage -->
    <include name="${package}/jdbc4/*.java" if="jdbc4any"/>
    <exclude name="${package}/jdcb4/Jdbc4*.java" unless="jdbc4any"/>

    <!-- ssl -->
    <include name="${package}/ssl/jdbc4/*.java" if="jdbc4any"/>
    <include name="${package}/ssl/jdbc3/*.java" if="jdbc3any"/>
    <include name="${package}/ssl/*.java" if="jdbc3any"/>

    <!-- gss -->
    <include name="${package}/gss/*.java"/>

    <!-- datasource stuff -->
    <include name="${package}/jdbc3/Jdbc3ConnectionPool.java" if="jdbc3any"/>
    <include name="${package}/jdbc3/Jdbc3PoolingDataSource.java" if="jdbc3any"/>
    <include name="${package}/jdbc3/Jdbc3SimpleDataSource.java" if="jdbc3any"/>

    <include name="${package}/ds/*.java"/>
    <include name="${package}/ds/common/*.java"/>
    <include name="${package}/ds/jdbc23/*.java"/>
    <include name="${package}/ds/jdbc4/*.java" if="jdbc4any"/>

    <!-- XA stuff -->
    <include name="${package}/xa/*.java"/>
    <include name="${package}/xa/jdbc3/*.java"/>
    <include name="${package}/xa/jdbc4/*.java" if="jdbc4any"/>
  </patternset>

  <target name="check_versions">
    <condition property="jdbc2">
      <or>
        <equals arg1="${java.target}" arg2="1.2"/>
        <equals arg1="${java.target}" arg2="1.3"/>
      </or>
    </condition>
    <condition property="jdbc3">
        <equals arg1="${java.target}" arg2="1.4"/>
    </condition>
    <condition property="jdbc3g">
	<equals arg1="${java.target}" arg2="1.5"/>
    </condition>
    <condition property="jdbc4">
        <equals arg1="${java.target}" arg2="1.6"/>
    </condition>
    <condition property="jdbc41">
      <or>
	<equals arg1="${java.target}" arg2="1.7"/>
        <equals arg1="${java.target}" arg2="1.8"/>
      </or>
    </condition>
    <condition property="jdbc4any">
      <or>
        <isset property="jdbc4" />
	<isset property="jdbc41" />
      </or>
    </condition>
    <condition property="jdbc3any">
      <or>
        <isset property="jdbc3" />
	<isset property="jdbc3g" />
      </or>
    </condition>
    <condition property="jdbc3plus">
      <or>
        <isset property="jdbc3any" />
	<isset property="jdbc4any" />
      </or>
    </condition>

    <condition property="unknownjvm">
      <not>
        <or>
          <isset property="jdbc2" />
          <isset property="jdbc3any" />
          <isset property="jdbc4any" />
        </or>
      </not>
    </condition>

    <fail if="jdbc2" message="1.4 or higher JDK is required to build the JDBC driver." />
    <fail if="unknownjvm" message="Unknown JDK version." />

    <available property="junit" classname="junit.framework.Test"/>
    <available property="junit.task" classname="org.apache.tools.ant.taskdefs.optional.junit.JUnitTask"/>

    <condition property="jdbc4tests">
      <and>
        <isset property="jdbc4any" />
        <isset property="junit" />
      </and>
    </condition>

    <condition property="jdbc.version" value="jdbc3">
      <isset property="jdbc3any" />
    </condition>

    <condition property="jdbc.version" value="jdbc4">
      <isset property="jdbc4" />
    </condition>

    <condition property="jdbc.version" value="jdbc41">
      <isset property="jdbc41" />
    </condition>

    <condition property="jdbc.version.upper" value="JDBC3">
      <isset property="jdbc3any" />
    </condition>

    <condition property="jdbc.version.upper" value="JDBC4">
      <isset property="jdbc4" />
    </condition>

    <condition property="jdbc.version.upper" value="JDBC41">
      <isset property="jdbc41" />
    </condition>
  </target>


  <!-- default target -->
  <target name="all">
    <antcall target="jar" />
  </target>


  <!-- create the jar file -->
  <target name="jar" depends="compile">
    <jar jarfile="${jardir}/fdb-sql-layer-jdbc.jar">
      <fileset dir="${builddir}">
        <include name="${package}/**/*.class" />
      </fileset>

      <fileset dir="${srcdir}">
        <include name="${package}/translation/*.class" />
      </fileset>

      <metainf dir="META-INF">
      </metainf>
    </jar>
  </target>


  <target name="compile" depends="prepare,check_versions,driver">

    <available classname="com.foundationdb.sql.jdbc.Driver" property="old.driver.present" />
    <fail message="Old driver was detected on classpath or in jre/lib/ext, please remove and try again." if="old.driver.present" />

    <javac classpath="${srcdir}" srcdir="${srcdir}" destdir="${builddir}" debug="${debug}" source="${java.target}" target="${java.target}">
      <patternset refid="jdbc.version.src.pattern"/>
    </javac>
  </target>

  <target name="check_driver">
    <uptodate targetfile="${package}/Driver.java" property="driver.uptodate">
      <srcfiles dir="${srcdir}">
      <include name="${package}/Driver.java.in"/>
      <include name="${package}/ds/PGSimpleDataSource.java.in"/>
      <include name="${package}/ds/PGPoolingDataSource.java.in"/>
      <include name="${package}/ds/PGPooledConnection.java.in"/>
      <include name="${package}/ds/PGConnectionPoolDataSource.java.in" />
      <include name="${package}/xa/PGXADataSource.java.in" />
      <include name="build.properties"/>
      <include name="build.local.properties" />
      </srcfiles>
    </uptodate>
  </target>

  <!--
    This generates Driver.java from Driver.java.in
    It's required for importing the driver version properties
  -->
  <target name="driver" depends="prepare,check_versions,check_driver"
          unless="driver.uptodate">
    <!-- determine the edition text -->
    <condition property="edition" value="JDBC3">
        <equals arg1="${jdbc3}" arg2="true"/>
    </condition>
    <condition property="edition" value="JDBC3g">
    	<equals arg1="${jdbc3g}" arg2="true" />
    </condition>
    <condition property="edition" value="JDBC4">
	<equals arg1="${jdbc4}" arg2="true" />
    </condition>
    <condition property="edition" value="JDBC4.1">
	<equals arg1="${jdbc41}" arg2="true" />
    </condition>

    <!-- determine the connection class -->
    <condition property="connectclass" value="com.foundationdb.sql.jdbc.jdbc3.Jdbc3Connection">
        <equals arg1="${jdbc3}" arg2="true"/>
    </condition>
    <condition property="connectclass" value="com.foundationdb.sql.jdbc.jdbc3g.Jdbc3gConnection">
        <equals arg1="${jdbc3g}" arg2="true"/>
    </condition>
    <condition property="connectclass" value="com.foundationdb.sql.jdbc.jdbc4.Jdbc4Connection">
        <equals arg1="${jdbc4any}" arg2="true" />
    </condition>

    <condition property="notimplementedexception" value="java.sql.SQLException">
        <equals arg1="${jdbc3any}" arg2="true" />
    </condition>
    <condition property="notimplementedexception" value="java.sql.SQLFeatureNotSupportedException">
        <equals arg1="${jdbc4any}" arg2="true" />
    </condition>

    <condition property="simpledsclass" value="com.foundationdb.sql.jdbc.ds.jdbc23.AbstractJdbc23SimpleDataSource">
        <equals arg1="${jdbc3any}" arg2="true" />
    </condition>
    <condition property="simpledsclass" value="com.foundationdb.sql.jdbc.ds.jdbc4.AbstractJdbc4SimpleDataSource">
        <equals arg1="${jdbc4any}" arg2="true" />
    </condition>

    <condition property="poolingdsclass" value="com.foundationdb.sql.jdbc.ds.jdbc23.AbstractJdbc23PoolingDataSource">
        <equals arg1="${jdbc3any}" arg2="true" />
    </condition>
    <condition property="poolingdsclass" value="com.foundationdb.sql.jdbc.ds.jdbc4.AbstractJdbc4PoolingDataSource">
        <equals arg1="${jdbc4any}" arg2="true" />
</condition>

    <condition property="pooledconnclass" value="com.foundationdb.sql.jdbc.ds.jdbc23.AbstractJdbc23PooledConnection">
        <equals arg1="${jdbc3any}" arg2="true" />
    </condition>
    <condition property="pooledconnclass" value="com.foundationdb.sql.jdbc.ds.jdbc4.AbstractJdbc4PooledConnection">
        <equals arg1="${jdbc4any}" arg2="true" />
    </condition>

    <condition property="connpooldsclass" value="com.foundationdb.sql.jdbc.ds.jdbc23.AbstractJdbc23ConnectionPoolDataSource">
        <equals arg1="${jdbc3any}" arg2="true" />
    </condition>
    <condition property="connpooldsclass" value="com.foundationdb.sql.jdbc.ds.jdbc4.AbstractJdbc4ConnectionPoolDataSource">
        <equals arg1="${jdbc4any}" arg2="true" />
    </condition>

    <condition property="xadsclass" value="com.foundationdb.sql.jdbc.xa.jdbc3.AbstractJdbc3XADataSource">
        <equals arg1="${jdbc3any}" arg2="true" />
    </condition>
    <condition property="xadsclass" value="com.foundationdb.sql.jdbc.xa.jdbc4.AbstractJdbc4XADataSource">
        <equals arg1="${jdbc4any}" arg2="true" />
    </condition>
    <condition property="makesslclass" value="com.foundationdb.sql.jdbc.ssl.jdbc3.AbstractJdbc3MakeSSL">
        <equals arg1="${jdbc3any}" arg2="true" />
    </condition>
    <condition property="makesslclass" value="com.foundationdb.sql.jdbc.ssl.jdbc4.AbstractJdbc4MakeSSL">
        <equals arg1="${jdbc4any}" arg2="true" />
    </condition>
	
    <!-- Some defaults -->
    <filter token="MAJORVERSION" value="${major}" />
    <filter token="MINORVERSION" value="${minor}" />
    <filter token="NAME" value="PostgreSQL" />
    <filter token="FDBNAME" value="FoundationBD SQL layer"/>
    <filter token="VERSION" value="PostgreSQL ${fullversion} ${edition}" />
    <filter token="FDBVERSION" value="FoundationDB SQL layer ${fullversion} ${edition}" />  
    <filter token="JDBCCONNECTCLASS" value="${connectclass}" />
    <filter token="NOTIMPLEMENTEDEXCEPTION" value="${notimplementedexception}" />
    <filter token="XA_DS_CLASS" value="${xadsclass}" />
    <filter token="POOLING_DS_CLASS" value="${poolingdsclass}" />
    <filter token="SIMPLE_DS_CLASS" value="${simpledsclass}" />
    <filter token="POOLED_CONN_CLASS" value="${pooledconnclass}" />
    <filter token="CONN_POOL_DS_CLASS" value="${connpooldsclass}" />
    <filter token="DEF_PGPORT" value="${def_pgport}" />
    <filter token="DEF_FDBPORT" value="${def_fdbport}" />
    <filter token="MAKE_SSL_CLASS" value="${makesslclass}"/>

     <fail unless="major" message="'major' undefined. Please follow the directions in README."/>
     <fail unless="minor" message="'minor' undefined. Please follow the directions in README."/>
     <fail unless="fullversion" message="'fullversion' undefined. Please follow the directions in README."/>
     <fail unless="def_pgport" message="'def_pgport' undefined. Please follow the directions in README."/>
     <fail unless="def_fdbport" message="'def_fdbport' undefined. Please follow the directions in README."/>
     <fail unless="enable_debug" message="'enable_debug' undefined. Please follow the directions in README."/>
 
    <!-- Put a check for the current version here -->

    <!-- now copy and filter the file -->
    <copy file="${srcdir}/${package}/Driver.java.in"
          overwrite="true"
          tofile="${srcdir}/${package}/Driver.java"
          filtering="yes" />
    <copy file="${srcdir}/${package}/ds/PGPoolingDataSource.java.in"
          overwrite="true"
          tofile="${srcdir}/${package}/ds/PGPoolingDataSource.java"
          filtering="yes" />
    <copy file="${srcdir}/${package}/ds/PGSimpleDataSource.java.in"
          overwrite="true"
          tofile="${srcdir}/${package}/ds/PGSimpleDataSource.java"
          filtering="yes" />
    <copy file="${srcdir}/${package}/ds/PGPooledConnection.java.in"
          overwrite="true"
          tofile="${srcdir}/${package}/ds/PGPooledConnection.java"
          filtering="yes" />
    <copy file="${srcdir}/${package}/ds/PGConnectionPoolDataSource.java.in"
          overwrite="true"
          tofile="${srcdir}/${package}/ds/PGConnectionPoolDataSource.java"
          filtering="yes" />
    <copy file="${srcdir}/${package}/xa/PGXADataSource.java.in"
          overwrite="true"
          tofile="${srcdir}/${package}/xa/PGXADataSource.java"
          filtering="yes" />
    <copy file="${srcdir}/${package}/ssl/MakeSSL.java.in"
          overwrite="true"
          tofile="${srcdir}/${package}/ssl/MakeSSL.java"
          filtering="yes" />
  <echo message="Configured build for the ${edition} edition driver." />
  </target>


  <!-- Prepares the build directory -->
  <target name="prepare">
    <!-- use the enable_debug option from configure -->
    <condition property="debug" value="on">
      <and>
        <equals arg1="${enable_debug}" arg2="yes" />
      </and>
    </condition>
    <mkdir dir="${builddir}" />
    <mkdir dir="${jardir}" />
  </target>


  <!-- This target removes any class files from the build directory -->
  <target name="clean">
    <delete quiet="true" dir="${builddir}" />
    <delete quiet="true" dir="${jardir}" />
    <delete quiet="true" file="${srcdir}/${package}/Driver.java" />
    <delete quiet="true" file="${srcdir}/${package}/ds/PGPoolingDataSource.java" />
    <delete quiet="true" file="${srcdir}/${package}/ds/PGSimpleDataSource.java" />
    <delete quiet="true" file="${srcdir}/${package}/ds/PGPooledConnection.java" />
    <delete quiet="true" file="${srcdir}/${package}/ds/PGConnectionPoolDataSource.java" />
    <delete quiet="true" file="${srcdir}/${package}/xa/PGXADataSource.java" />
    <delete quiet="true" file="${srcdir}/${package}/ssl/MakeSSL.java" />
  </target>

  <!-- This compiles and executes the JUnit tests -->

  <!-- defaults for the tests - override these if required -->
  <property name="server" value="localhost" />
  <property name="port" value="${def_pgport}" />
  <property name="database" value="test" />
  <property name="username" value="test" />
  <!-- Password must be something.  Doesn't matter if trust is used! -->
  <property name="password" value="test" />
  <property name="preparethreshold" value="5" />
  <property name="loglevel" value="0" />
  <property name="protocolVersion" value="0" />
  <property name="ssltest.properties" value="ssltest.properties" />

  <!-- The tests now build to a separate directory and jarfile from the
       driver build, to ensure we're really testing against the jar we just
       built, and not whatever happens to be in builddir. -->

  <!-- This compiles and builds the test jarfile. -->  
  <target name="testjar" depends="jar">
    <fail message="JUnit 3.8.1 could not be found in your classpath.  You must download and install it from http://junit.org to build and run the test suite." unless="junit" />
    <mkdir dir="${builddir}/tests"/>
    <javac srcdir="${testdir}" destdir="${builddir}/tests" debug="${debug}" source="${java.target}" target="${java.target}">
      <include name="${package}/**" />

      <exclude name="${package}/jdbc4/**" unless="jdbc4tests" />
      <exclude name="${package}/ssl/**" unless="jdbc4tests" />

      <classpath>
        <pathelement location="${jardir}/fdb-sql-layer-jdbc.jar"/>
      </classpath>
    </javac>
    <jar jarfile="${jardir}/fdb-sql-layer-jdbc-tests.jar" basedir="${builddir}/tests"/>
  </target>
    
  <!-- This actually runs the tests -->
  <target name="runtest" depends="testjar">
    <fail message="Your version of ant doesn't seem to have the junit task available.  I looked for org.apache.tools.ant.taskdefs.optional.junit.JUnitTask, but I couldn't find it." unless="junit.task" />

    <delete file="postgresql-jdbc-tests.debug.txt"/>

    <property name="testResultsDir" value="${builddir}/testresults" />
    <mkdir dir="${testResultsDir}" />
 
    <junit>
      <formatter type="brief" usefile="false"/>
      <formatter type="xml" usefile="true" />

      <sysproperty key="server" value="${server}" />
      <sysproperty key="port" value="${port}" />
      <sysproperty key="database" value="${database}" />
      <sysproperty key="username" value="${username}" />
      <sysproperty key="password" value="${password}" />
      <sysproperty key="preparethreshold" value="${preparethreshold}" />
      <sysproperty key="loglevel" value="${loglevel}" />
      <sysproperty key="protocolVersion" value="${protocolVersion}" />
      <sysproperty key="ssltest.properties" value="${ssltest.properties}" />
      <sysproperty key="protocol" value="${protocol}"/>

      <classpath>
        <pathelement location="${jardir}/fdb-sql-layer-jdbc.jar" />
        <pathelement location="${jardir}/fdb-sql-layer-jdbc-tests.jar" />
        <pathelement path="${java.class.path}" />
      </classpath>
      <test name="com.foundationdb.sql.jdbc.jdbc2.Jdbc2TestSuite" outfile="${testResultsDir}/jdbc2"/>
      <test name="com.foundationdb.sql.jdbc.jdbc2.optional.OptionalTestSuite" outfile="${testResultsDir}/jdbc2optional"/>
      <test name="com.foundationdb.sql.jdbc.jdbc3.Jdbc3TestSuite" outfile="${testResultsDir}/jdbc3"/>
      <test name="com.foundationdb.sql.jdbc.xa.XATestSuite" outfile="${testResultsDir}/xa"/>
      <test name="com.foundationdb.sql.jdbc.extensions.ExtensionsSuite" outfile="${testResultsDir}/extensions"/>
      <test name="com.foundationdb.sql.jdbc.jdbc4.Jdbc4TestSuite" if="jdbc4tests" outfile="${testResultsDir}/jdbc4"/>
      <test name="com.foundationdb.sql.jdbc.ssl.SslTestSuite" if="jdbc4tests" outfile="${testResultsDir}/ssl"/>
    </junit>
  </target>
    
    <target name="ensure-test-name" unless="test">
        <fail message="You must run this target with -Dtest=TestName"/>
    </target>

    <target name="runsingletest" description="Runs the test you specify on the command 
        line with -Dtest=" depends="testjar, ensure-test-name">
        <delete file="postgresql-jdbc-tests.debug.txt"/>
        <junit> 
            <formatter type="brief" usefile="false"/>
            <formatter type="xml" usefile="true" />
        
            <sysproperty key="server" value="${server}" />
            <sysproperty key="port" value="${port}" />
            <sysproperty key="database" value="${database}" />
            <sysproperty key="username" value="${username}" />
            <sysproperty key="password" value="${password}" />
            <sysproperty key="preparethreshold" value="${preparethreshold}" />
            <sysproperty key="loglevel" value="${loglevel}" />
            <sysproperty key="protocolVersion" value="${protocolVersion}" />
            <sysproperty key="ssltest.properties" value="${ssltest.properties}" />
            <sysproperty key="protocol" value="${protocol}"/>
        
            <classpath>
              <pathelement location="${jardir}/fdb-sql-layer-jdbc.jar" />
              <pathelement location="${jardir}/fdb-sql-layer-jdbc-tests.jar" />
              <pathelement path="${java.class.path}" />
            </classpath>
            <batchtest>
                <fileset dir="${srcdir}">
                    <include name="**/${test}.java"/>
                </fileset>
            </batchtest>
        </junit>
    </target>
  <!-- Build and run the tests. -->
  <target name="test" depends="testjar,runtest"/>

  <!-- Build public javadoc -->
  <target name="publicapi" depends="compile">
    <mkdir dir="${builddir}/publicapi" />
    <javadoc destdir="${builddir}/publicapi" charset="utf-8">
      <classpath>
        <pathelement path="${builddir}" />
        <pathelement path="${java.class.path}" />
      </classpath>
      <fileset dir="${srcdir}/${package}">
        <include name="copy/*.java" />
        <include name="geometric/*.java" />
        <include name="largeobject/*.java" />
        <include name="fastpath/*.java" />
        <include name="PG*.java" />
        <include name="util/PGobject.java" />
        <include name="util/PGmoney.java" />
        <include name="util/PGInterval.java" />
        <include name="util/ServerErrorMessage.java" />
	<include name="ssl/WrappedFactory.java" />
	<include name="ssl/NonValidatingFactory.java" />
	<include name="ds/PG*.java" />
	<include name="ds/common/BaseDataSource.java" />
	<include name="xa/PGXADataSource.java" />
      </fileset>
    </javadoc>
  </target>

  <!-- Build driver-internal javadoc. NB: needs Ant 1.6 & JDK 1.4 for 'breakiterator'. -->
  <target name="privateapi" depends="compile">
    <javadoc destdir="${builddir}/privateapi" breakiterator="yes" charset="utf-8">
      <classpath>
        <pathelement path="${builddir}" />
        <pathelement path="${java.class.path}" />
      </classpath>
      <fileset dir="${srcdir}/${package}">
        <include name="**/*.java"/>
	<exclude name="jdbc3/Jdbc3*.java" unless="jdbc3" />
	<exclude name="jdbc3g/Jdbc3g*.java" unless="jdbc3g" />
	<exclude name="jdbc4/*.java" unless="jdbc4any" />
	<exclude name="ds/jdbc4/*.java" unless="jdbc4any" />
        <exclude name="test/**/*.java"/>
      </fileset>
    </javadoc>
  </target>

  <!-- Build the documentation -->
  <target name="doc" depends="prepare">
   <mkdir dir="${builddir}/doc"/>
   <xslt basedir="doc" destdir="${builddir}/doc" includes="*.xml" force="yes" style="${docbook.stylesheet}">
     <param name="base.dir" expression="${builddir}/doc/"/>
     <param name="use.id.as.filename" expression="1" />
   </xslt>
  </target>

  <!-- Blah. Can't reference an external XML catalog until Ant 1.6.
       So instead we copy the contents of ${docbook.dtd}/catalog.xml
       here, in the form that Ant's xmlcatalog element wants. -->
  <xmlcatalog id="docbook-catalog">  
    <dtd publicId="-//OASIS//DTD DocBook XML V4.2//EN"
      location="${docbook.dtd}/docbookx.dtd"/>
    <entity publicId="-//OASIS//DTD DocBook CALS Table Model V4.2//EN"
      location="${docbook.dtd}/calstblx.dtd"/>
    <entity publicId="-//OASIS//DTD XML Exchange Table Model 19990315//EN"
      location="${docbook.dtd}/soextblx.dtd"/>
    <entity publicId="-//OASIS//ELEMENTS DocBook Information Pool V4.2//EN"
      location="${docbook.dtd}/dbpoolx.mod"/>    
    <entity publicId="-//OASIS//ELEMENTS DocBook Document Hierarchy V4.2//EN"
      location="${docbook.dtd}/dbhierx.mod"/>    
    <entity publicId="-//OASIS//ENTITIES DocBook Additional General Entities V4.2//EN"
      location="${docbook.dtd}/dbgenent.mod"/>    
    <entity publicId="-//OASIS//ENTITIES DocBook Notations V4.2//EN"
      location="${docbook.dtd}/dbnotnx.mod"/>
    <entity publicId="-//OASIS//ENTITIES DocBook Character Entities V4.2//EN"
      location="${docbook.dtd}/dbcentx.mod"/>
  </xmlcatalog>

  <!-- Validate but don't process the documentation.
       This target expects the DocBook XML DTDs, available at
       http://www.docbook.org/xml/4.2/docbook-xml-4.2.zip, to be
       present in ${docbook.dtd}. If they're not present, they will
       be fetched on each validation from www.oasis-open.org.

       Note that if the DTD fetch fails, validation fails with a fairly
       useless error message. Run ant with -verbose to get a more useful
       error. You'll need to set the java properties http.proxyHost and
       http.proxyPort if you need to go via a proxy to fetch the DTDs.
  -->
       
  <target name="validate-doc" depends="prepare">
    <xmlvalidate warn="true">
      <fileset dir="doc" includes="*.xml"/>
      <xmlcatalog refid="docbook-catalog"/>
    </xmlvalidate>
  </target>

  <target name="snapshot-version" description="Sets the version string to a snapshot version">
    <property name="maven.artifact.version.string" value="${maven.artifact.version}-${jdbc.version}-SNAPSHOT" />
    <echo message="Maven version string: ${maven.artifact.version.string}" />
  </target>

  <target name="release-version" description="Sets the version string to a release version">
    <property name="maven.artifact.version.string" value="${maven.artifact.version}-${jdbc.version}" />
    <echo message="Maven version string: ${maven.artifact.version.string}" />
  </target>

  <target name="prepare-pom" depends="prepare,check_versions,snapshot-version" description="Filters the pom depending on the jdbc version being built">
    <mkdir dir="${builddir}/pom"/>
    <!-- Copy the templated pom.xml with version info -->
    <filter token="maven.group.id" value="${maven.group.id}"/>
    <filter token="maven.artifact.id" value="${maven.artifact.id}"/>
    <filter token="maven.artifact.version.string" value="${maven.artifact.version.string}"/>
    <filter token="maven.artifact.description" value="${maven.artifact.description}"/>
    <filter token="jdbc.version.upper" value="${jdbc.version.upper}"/>
    <filter token="maven.snapshots.repository.url" value="${maven.snapshots.repository.url}"/>  
    <copy todir="${builddir}/pom" filtering="true" file="src/pom/pom.xml"/>
  </target>

  <target name="snapshot" depends="maven-jar,snapshot-version,prepare-pom" description="deploy snapshot version to Maven snapshot repository">
    <artifact:mvn>
      <artifact:arg value="org.apache.maven.plugins:maven-deploy-plugin:2.6:deploy-file"/>
      <artifact:arg value="-Durl=${maven.snapshots.repository.url}"/>
      <artifact:arg value="-DrepositoryId=${maven.snapshots.repository.id}"/>
      <artifact:arg value="-DpomFile=${builddir}/pom/pom.xml"/>
      <artifact:arg value="-Dfile=${maven.jar}"/>
    </artifact:mvn>
  </target>

  <!-- before this, update project version (both build.xml and pom.xml) from SNAPSHOT to RELEASE -->
  <target name="release" depends="maven-jar,release-version,prepare-pom" description="deploy release version to Maven staging repository">
    <!-- sign and deploy the main artifact -->
    <artifact:mvn>
      <artifact:arg value="org.apache.maven.plugins:maven-gpg-plugin:1.4:sign-and-deploy-file" />
      <artifact:arg value="-Durl=${maven.staging.repository.url}" />
      <artifact:arg value="-DrepositoryId=${maven.staging.repository.id}" />
      <artifact:arg value="-DpomFile=${builddir}/pom/pom.xml" />
      <artifact:arg value="-Dfile=${maven.jar}" />
      <artifact:arg value="-Pgpg" />
    </artifact:mvn>

    <!-- sign and deploy the sources artifact -->
    <artifact:mvn>
      <artifact:arg value="org.apache.maven.plugins:maven-gpg-plugin:1.4:sign-and-deploy-file" />
      <artifact:arg value="-Durl=${maven.staging.repository.url}" />
      <artifact:arg value="-DrepositoryId=${maven.staging.repository.id}" />
      <artifact:arg value="-DpomFile=${builddir}/pom/pom.xml" />
      <artifact:arg value="-Dfile=${maven.sources.jar}" />
      <artifact:arg value="-Dclassifier=sources" />
      <artifact:arg value="-Pgpg" />
    </artifact:mvn>

    <!-- sign and deploy the javadoc artifact -->
    <artifact:mvn>
      <artifact:arg value="org.apache.maven.plugins:maven-gpg-plugin:1.4:sign-and-deploy-file" />
      <artifact:arg value="-Durl=${maven.staging.repository.url}" />
      <artifact:arg value="-DrepositoryId=${maven.staging.repository.id}" />
      <artifact:arg value="-DpomFile=${builddir}/pom/pom.xml" />
      <artifact:arg value="-Dfile=${maven.javadoc.jar}" />
      <artifact:arg value="-Dclassifier=javadoc" />
      <artifact:arg value="-Pgpg" />
    </artifact:mvn>
  </target>

  <!-- create jar files for distribution to maven central -->
  <target name="maven-jar" depends="jar, publicapi">
    <!-- Copy the built jar into a maven compatible name -->
    <copy file="${jardir}/fdb-sql-layer-jdbc.jar" tofile="${maven.jar}"/>
    <!-- Create a jar of the javadoc public api -->
    <jar jarfile="${maven.javadoc.jar}">
      <fileset dir="${builddir}/publicapi">
        <include name="**/*"/>
      </fileset>
    </jar>
    <!-- Create a jar of the source code -->
    <jar jarfile="${maven.sources.jar}">
      <fileset dir="${srcdir}">
        <patternset refid="jdbc.version.src.pattern"/>
        <include name="META-INF/**/*"/>
      </fileset>
    </jar>
  </target>

</project>