build.gradle

/*
 * Copyright 2013-2019 Real Logic Ltd.
 *
 * Licensed 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
 *
 * https://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.
 */
buildscript {
    repositories {
        mavenCentral()
    }
}

plugins {
    id 'java'
    id 'idea'
    id 'io.freefair.javadoc-links' version '4.1.5' apply false
    id 'com.github.johnrengelman.shadow' version '5.2.0' apply false
    id "com.github.ben-manes.versions" version "0.27.0"
}

defaultTasks 'clean', 'build', 'shadowJar', 'install'

def checkstyleVersion = '8.26'
def hamcrestVersion = '2.2'
def mockitoVersion = '3.1.0'
def junitVersion = '4.12'
def jmhVersion = '1.22'
def agronaVersion = '1.1.0'

def sbeGroup = 'uk.co.real-logic'
def sbeVersion = file('version.txt').text.trim()

group = sbeGroup
version = sbeVersion
ext.isReleaseVersion = !version.endsWith("SNAPSHOT")

ext {
    if (!project.hasProperty('ossrhUsername')) {
        ossrhUsername = ''
    }

    if (!project.hasProperty('ossrhPassword')) {
        ossrhPassword = ''
    }
}

def projectPom = {
    name = 'sbe'
    packaging = 'pom'
    description = 'FIX/SBE - OSI layer 6 presentation for encoding and decoding application messages' +
        ' in binary format for low-latency applications'
    url = 'https://github.com/real-logic/simple-binary-encoding'

    scm {
        connection = 'scm:git:github.com/real-logic/simple-binary-encoding.git'
        developerConnection = 'scm:git:github.com/real-logic/simple-binary-encoding.git'
        url = 'github.com/real-logic/simple-binary-encoding.git'
    }

    licenses {
        license {
            name = 'The Apache License, Version 2.0'
            url = 'https://www.apache.org/licenses/LICENSE-2.0.txt'
        }
    }

    developers {
        developer {
            id = 'tmontgomery'
            name = 'Todd L. Montgomery'
            email = 'tmont@nard.net'
            url = 'https://github.com/tmontgomery'
        }
        developer {
            id = 'mjpt777'
            name = 'Martin Thompson'
            email = 'mjpt777@gmail.com'
            url = 'https://github.com/mjpt777'
        }
        developer {
            id = 'odeheurles'
            name = 'Olivier Deheurles'
            email = 'olivier@weareadaptive.com'
            url = 'https://github.com/odeheurles'
        }
        developer {
            id = 'RichardWarburton'
            name = 'Richard Warburton'
            email = 'richard.warburton@gmail.com'
            url = 'https://github.com/RichardWarburton'
        }
        developer {
            id = 'BillSegall'
            name = 'Bill Segall'
            email = 'bill.segall@gmail.com'
            url = 'https://github.com/BillSegall'
        }
    }
}

allprojects {
    repositories {
        mavenLocal()
        mavenCentral()
    }
}

configurations {
    shadow
}

jar.enabled = false

subprojects {
    apply plugin: 'java'
    apply plugin: 'maven'
    apply plugin: 'signing'
    apply plugin: 'checkstyle'
    apply plugin: 'eclipse'
    apply plugin: 'io.freefair.javadoc-links'

    group = sbeGroup
    version = sbeVersion

    jar.enabled = true

    dependencies {
        checkstyle "com.puppycrawl.tools:checkstyle:${checkstyleVersion}"

        compile "org.agrona:agrona:${agronaVersion}"

        testCompile "org.hamcrest:hamcrest:${hamcrestVersion}"
        testCompile "org.mockito:mockito-core:${mockitoVersion}"
        testCompile "junit:junit:${junitVersion}"
    }

    checkstyle.toolVersion = "${checkstyleVersion}"

    compileJava {
        if (JavaVersion.current().ordinal() >= JavaVersion.VERSION_1_9.ordinal()) {
            options.compilerArgs.addAll(['--add-exports', 'java.base/java.lang.reflect=ALL-UNNAMED'])
            options.compilerArgs.addAll(['--add-exports', 'jdk.unsupported/sun.misc=ALL-UNNAMED'])
        }
        options.encoding = 'UTF-8'
        options.deprecation = true
    }

    compileTestJava {
        if (JavaVersion.current().ordinal() >= JavaVersion.VERSION_1_9.ordinal()) {
            options.compilerArgs.addAll(['--add-exports', 'java.base/java.lang.reflect=ALL-UNNAMED'])
            options.compilerArgs.addAll(['--add-exports', 'jdk.unsupported/sun.misc=ALL-UNNAMED'])
        }
        options.encoding = 'UTF-8'
        options.deprecation = true
    }

    test {
        if (JavaVersion.current().ordinal() >= JavaVersion.VERSION_1_9.ordinal()) {
            jvmArgs('--add-opens', 'java.base/java.lang.reflect=ALL-UNNAMED')
            jvmArgs('--add-exports', 'jdk.unsupported/sun.misc=ALL-UNNAMED')
        }

        testLogging {
            showStandardStreams = true
            exceptionFormat = 'full'
        }
    }

    javadoc {
        title = '<h1>Simple Binary Encoding</h1>'
        options.bottom = '<i>Copyright &#169; 2014-2019 Real Logic Ltd. All Rights Reserved.</i>'
        options.encoding = 'UTF-8'
        options.docEncoding = 'UTF-8'
        options.charSet = 'UTF-8'
        if (JavaVersion.current().ordinal() >= JavaVersion.VERSION_1_10.ordinal()) {
            options.addBooleanOption 'html5', true
        }
    }

    signing {
        required { isReleaseVersion && gradle.taskGraph.hasTask("uploadArchives") }
        sign configurations.archives
    }

    install {
        repositories.mavenInstaller.pom.project(projectPom)
    }
}

def validationXsdPath = project(':sbe-tool').projectDir.toString() + '/src/main/resources/fpl/sbe.xsd'

project(':sbe-tool') {
    dependencies {
        testCompile files('build/classes/java/generated')
    }

    jar {
        manifest.attributes(
            'Main-Class': 'uk.co.real_logic.sbe.SbeTool',
            'Specification-Title': 'Simple Binary Encoding',
            'Specification-Version': '1.0',
            'Implementation-Title': 'SBE',
            'Implementation-Version': "${sbeVersion}",
            'Implementation-Vendor': 'Real Logic Limited',
            'Automatic-Module-Name': 'uk.co.real_logic.sbe.tool'
        )
    }

    sourceSets {
        generated.java.srcDir 'build/generated-src'
    }

    compileGeneratedJava {
        dependsOn 'generateCodecs'
        if (JavaVersion.current().ordinal() >= JavaVersion.VERSION_1_9.ordinal()) {
            options.compilerArgs.addAll(['--add-exports', 'java.base/java.lang.reflect=ALL-UNNAMED'])
            options.compilerArgs.addAll(['--add-exports', 'jdk.unsupported/sun.misc=ALL-UNNAMED'])
        }
        options.encoding = 'UTF-8'
        options.deprecation = true
        classpath += sourceSets.main.runtimeClasspath
    }

    compileTestJava.dependsOn 'compileGeneratedJava'

    task generateCodecs(dependsOn: 'compileJava', type: JavaExec) {
        main = 'uk.co.real_logic.sbe.SbeTool'
        classpath = sourceSets.main.runtimeClasspath
        systemProperties(
            'sbe.output.dir': 'build/generated-src',
            'sbe.target.language': 'Java',
            'sbe.validation.stop.on.error': 'true',
            'sbe.validation.xsd': validationXsdPath)
        args = ['src/test/resources/json-printer-test-schema.xml',
                'src/test/resources/composite-elements-schema.xml']
    }

    uploadArchives {
        repositories {
            mavenDeployer {
                beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }

                repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
                    authentication(userName: ossrhUsername, password: ossrhPassword)
                }

                snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
                    authentication(userName: ossrhUsername, password: ossrhPassword)
                }

                pom.project(projectPom)
            }
        }
    }

    task copyCppFiles(type: Copy) {
        from 'src/main/cpp/sbe'
        from 'src/main/cpp/otf'
        into 'build/generated/cpp/cpp'
    }

    task sourcesJar(type: Jar) {
        archiveClassifier = 'sources'
        from sourceSets.main.allSource

        dependsOn 'copyCppFiles'
        from 'build/generated/cpp'
    }

    task javadocJar(type: Jar, dependsOn: javadoc) {
        archiveClassifier = 'javadoc'
        from javadoc.destinationDir
    }

    artifacts {
        archives sourcesJar
        archives javadocJar
    }
}

project(':sbe-all') {
    apply plugin: 'com.github.johnrengelman.shadow'

    dependencies {
        compile project(':sbe-tool')
    }

    task sourcesJar(type: Jar) {
        archiveClassifier = 'sources'
        from project(':sbe-tool').sourceSets.main.allSource
    }

    javadoc {
        source += project(':sbe-tool').sourceSets.main.allJava
    }

    task javadocJar(type: Jar, dependsOn: javadoc) {
        archiveClassifier = 'javadoc'
        from javadoc.destinationDir
    }

    shadowJar {
        archiveClassifier = ''
        manifest.attributes(
            'Main-Class': 'uk.co.real_logic.sbe.SbeTool',
            'Specification-Title': 'Simple Binary Encoding',
            'Specification-Version': '1.0',
            'Implementation-Title': 'SBE',
            'Implementation-Version': "${sbeVersion}",
            'Implementation-Vendor': 'Real Logic Limited',
            'Automatic-Module-Name': 'uk.co.real_logic.sbe.all'
        )
    }

    uploadArchives {
        repositories {
            mavenDeployer {
                beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }

                repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
                    authentication(userName: ossrhUsername, password: ossrhPassword)
                }

                snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
                    authentication(userName: ossrhUsername, password: ossrhPassword)
                }

                pom.project(projectPom)
            }
        }
    }

    uploadShadow {
        repositories {
            mavenDeployer {
                beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }

                repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
                    authentication(userName: ossrhUsername, password: ossrhPassword)
                }

                snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
                    authentication(userName: ossrhUsername, password: ossrhPassword)
                }

                pom.project(projectPom)
            }
        }

        mustRunAfter 'uploadArchives'
    }

    artifacts {
        archives sourcesJar
        archives javadocJar
    }

    signing {
        required { isReleaseVersion && gradle.taskGraph.hasTask("uploadArchives") }
        sign configurations.shadow
    }
}

project(':sbe-samples') {
    dependencies {
        compile project(':sbe-tool')
        compile files('build/classes/java/generated')
    }

    sourceSets {
        generated.java.srcDir 'build/generated-src'
    }

    compileGeneratedJava {
        dependsOn 'generateCodecs'
        if (JavaVersion.current().ordinal() >= JavaVersion.VERSION_1_9.ordinal()) {
            options.compilerArgs.addAll(['--add-exports', 'java.base/java.lang.reflect=ALL-UNNAMED'])
            options.compilerArgs.addAll(['--add-exports', 'jdk.unsupported/sun.misc=ALL-UNNAMED'])
        }
        options.encoding = 'UTF-8'
        options.deprecation = true
        classpath += project(':sbe-all').sourceSets.main.runtimeClasspath
    }

    compileJava {
        dependsOn 'compileGeneratedJava'
    }

    task generateCodecs(type: JavaExec) {
        main = 'uk.co.real_logic.sbe.SbeTool'
        classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
        systemProperties(
            'sbe.output.dir': 'build/generated-src',
            'sbe.target.language': 'Java',
            'sbe.java.generate.interfaces': 'true',
            'sbe.validation.stop.on.error': 'true',
            'sbe.xinclude.aware': 'true',
            'sbe.validation.xsd': validationXsdPath)
        args = ['src/main/resources/example-schema.xml', 'src/main/resources/example-extension-schema.xml']
    }

    task runExampleUsingGeneratedStub(dependsOn: 'compileJava', type: JavaExec) {
        classpath = sourceSets.main.runtimeClasspath
        main = 'uk.co.real_logic.sbe.examples.ExampleUsingGeneratedStub'
        systemProperties System.getProperties()
    }

    task runExampleUsingGeneratedStubExtension(dependsOn: 'compileJava', type: JavaExec) {
        classpath = sourceSets.main.runtimeClasspath
        main = 'uk.co.real_logic.sbe.examples.ExampleUsingGeneratedStubExtension'
        systemProperties System.getProperties()
    }

    task runOtfExample(dependsOn: 'compileJava', type: JavaExec) {
        classpath = sourceSets.main.runtimeClasspath
        main = 'uk.co.real_logic.sbe.examples.OtfExample'
        workingDir = 'src/main/resources'
    }

    task runJavaExamples {
        dependsOn 'runExampleUsingGeneratedStub', 'runExampleUsingGeneratedStubExtension', 'runOtfExample'
    }

    uploadArchives {
        repositories {
            mavenDeployer {
                beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }

                repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
                    authentication(userName: ossrhUsername, password: ossrhPassword)
                }

                snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
                    authentication(userName: ossrhUsername, password: ossrhPassword)
                }

                pom.project(projectPom)
            }
        }
    }

    task sourcesJar(type: Jar) {
        archiveClassifier = 'sources'
        from sourceSets.main.allSource
    }

    task javadocJar(type: Jar, dependsOn: javadoc) {
        archiveClassifier = 'javadoc'
        from javadoc.destinationDir
    }

    artifacts {
        archives sourcesJar
        archives javadocJar
    }
}

project(':sbe-benchmarks') {
    apply plugin: 'com.github.johnrengelman.shadow'

    dependencies {
        compile "org.openjdk.jmh:jmh-core:${jmhVersion}"
        annotationProcessor "org.openjdk.jmh:jmh-generator-annprocess:${jmhVersion}"
        compile project(':sbe-tool')
        compile files('build/classes/java/generated')
    }

    sourceSets {
        generated.java.srcDir 'build/generated-src'
    }

    compileGeneratedJava {
        dependsOn 'generateCodecs'
        if (JavaVersion.current().ordinal() >= JavaVersion.VERSION_1_9.ordinal()) {
            options.compilerArgs.addAll(['--add-exports', 'java.base/java.lang.reflect=ALL-UNNAMED'])
            options.compilerArgs.addAll(['--add-exports', 'jdk.unsupported/sun.misc=ALL-UNNAMED'])
        }
        options.encoding = 'UTF-8'
        options.deprecation = true
        classpath += project(':sbe-all').sourceSets.main.runtimeClasspath
    }

    compileJava {
        dependsOn 'compileGeneratedJava'
    }

    task generateCodecs(type: JavaExec) {
        main = 'uk.co.real_logic.sbe.SbeTool'
        classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
        systemProperties(
            'sbe.output.dir': 'build/generated-src',
            'sbe.target.language': 'Java',
            'sbe.validation.stop.on.error': 'true',
            'sbe.validation.xsd': validationXsdPath,
            'sbe.java.encoding.buffer.type': 'org.agrona.concurrent.UnsafeBuffer',
            'sbe.java.decoding.buffer.type': 'org.agrona.concurrent.UnsafeBuffer')
        args = ['src/main/resources/car.xml', 'src/main/resources/fix-message-samples.xml']
    }

    shadowJar {
        archiveFileName = 'sbe-benchmarks.jar'
        archiveClassifier = 'benchmarks'
        manifest.attributes('Main-Class': 'org.openjdk.jmh.Main')
    }

    uploadArchives {
        repositories {
            mavenDeployer {
                beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }

                repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
                    authentication(userName: ossrhUsername, password: ossrhPassword)
                }

                snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
                    authentication(userName: ossrhUsername, password: ossrhPassword)
                }

                pom.project(projectPom)
            }
        }
    }

    task sourcesJar(type: Jar) {
        archiveClassifier = 'sources'
        from sourceSets.main.allSource
    }

    task javadocJar(type: Jar, dependsOn: javadoc) {
        archiveClassifier = 'javadoc'
        from javadoc.destinationDir
    }

    artifacts {
        archives sourcesJar
        archives javadocJar
    }

    signing {
        required { isReleaseVersion && gradle.taskGraph.hasTask("uploadArchives") }
        sign configurations.shadow
    }
}

/*
 * Rust codec targets used for testing and demonstration
 */
task generateRustCarExample(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'rust/car_example/src',
        'sbe.xinclude.aware': 'true',
        'sbe.target.language': 'uk.co.real_logic.sbe.generation.rust.Rust',
        'sbe.target.namespace': 'car_example_generated_codec')
    args = ['sbe-samples/src/main/resources/example-schema.xml']
}

task generateCarExampleDataFile(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.examples.ExampleUsingGeneratedStub'
    classpath = project(':sbe-samples').sourceSets.main.runtimeClasspath
    systemProperties('sbe.encoding.filename': 'rust/car_example/car_example_data.sbe')
    args = []
    standardOutput = new ByteArrayOutputStream()
}

task runRustCarExample(type: Exec) {
    workingDir = './rust/car_example'
    executable = 'cargo'
    args = ['run']
    standardOutput = new ByteArrayOutputStream()
    errorOutput = new ByteArrayOutputStream()
    dependsOn 'generateRustCarExample', 'generateCarExampleDataFile'
}

def cargo_exists() {
    try {
        def result = project.exec {
            executable = 'cargo'
            args = [ '-V' ]
            standardOutput = new ByteArrayOutputStream()
        }
        return result.exitValue == 0
    }
    catch (Exception ignore) {
        return false
    }
}

if (cargo_exists() && !project.hasProperty('sbe.skipRust')) {
    test.dependsOn('runRustCarExample')
} else {
    println 'Skipping Rust integration test due to absent cargo command or sbe.skipRust property'
}

task generateRustCodecs {
    description = 'Generate rust test codecs'
    dependsOn 'generateRustCarExample', 'generateCarExampleDataFile'
}

/*
 * Golang codec targets used for testing, benchmarking etc. We have
 * multiple targets as:
 *  *) some of the test files generate warnings from the xsd so we don't
 *     validate those.
 *  *) Some of the test files need an additional output directory setting
 *     as they generate into the same directory and golang won't allow that.
 *  *) Some examples need to fiddle with WorkingDir to deal with XInclude
 */
task generateGolangCodecTestComposite(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'gocode/src',
        'sbe.target.language': 'golang')
    args = ['sbe-tool/src/test/resources/composite-elements-schema-rc4.xml']
}

task generateGolangCodecTestBasic(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'gocode/src/basic',
        'sbe.target.language': 'golang')
    args = ['sbe-tool/src/test/resources/basic-types-schema.xml']
}

task generateGolangCodecTestGroup(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'gocode/src/group',
        'sbe.target.language': 'golang')
    args = ['sbe-tool/src/test/resources/basic-group-schema.xml']
}

task generateGolangCodecTestVarData(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'gocode/src/vardata',
        'sbe.target.language': 'golang')
    args = ['sbe-tool/src/test/resources/basic-variable-length-schema.xml']
}

task generateGolangCodecsWithXIncludes(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'gocode/src',
        'sbe.target.language': 'golang',
        'sbe.xinclude.aware': 'true',
        'sbe.validation.xsd': validationXsdPath)
    args = ['sbe-samples/src/main/resources/example-schema.xml',
            'sbe-samples/src/main/resources/example-extension-schema.xml']
}

task generateGolangCodecsWithXSD(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'gocode/src',
        'sbe.target.language': 'golang',
        'sbe.xinclude.aware': 'true',
        'sbe.validation.xsd': validationXsdPath)
    args = ['sbe-tool/src/test/resources/group-with-data-schema.xml',
            'sbe-tool/src/test/resources/FixBinary.xml',
            'sbe-tool/src/test/resources/issue435.xml',
            'sbe-tool/src/test/resources/issue472.xml',
            'sbe-tool/src/test/resources/issue483.xml',
            'sbe-tool/src/test/resources/issue488.xml',
            'sbe-tool/src/test/resources/issue560.xml',
            'sbe-tool/src/test/resources/issue661.xml',
            'sbe-tool/src/test/resources/since-deprecated-test-schema.xml',
            'sbe-tool/src/test/resources/example-bigendian-test-schema.xml',
            'gocode/resources/example-composite.xml',
            'gocode/resources/example-extension-2-schema.xml',
            'gocode/resources/group-with-data-extension-schema.xml',
            'gocode/resources/simple.xml']
}

task generateGolangCodecs {
    description = 'Generate golang test codecs'
    dependsOn 'generateGolangCodecTestVarData',
        'generateGolangCodecTestGroup',
        'generateGolangCodecTestBasic',
        'generateGolangCodecTestComposite',
        'generateGolangCodecsWithXIncludes',
        'generateGolangCodecsWithXSD'
}

/*
 * CSharp codec targets used for testing, benchmarking etc. We have
 * multiple targets as XInclude forces us to change working dir
 */
task generateCSharpCodecsWithXIncludes(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'csharp/sbe-generated',
        'sbe.target.language': 'uk.co.real_logic.sbe.generation.csharp.CSharp',
        'sbe.xinclude.aware': 'true',
        'sbe.validation.xsd': validationXsdPath)
    args = ['sbe-samples/src/main/resources/example-schema.xml',
            'sbe-samples/src/main/resources/example-extension-schema.xml']
}

task generateCSharpCodecsTests(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'csharp/sbe-generated',
        'sbe.target.language': 'uk.co.real_logic.sbe.generation.csharp.CSharp',
        'sbe.xinclude.aware': 'true',
        'sbe.validation.xsd': validationXsdPath)
    args = ['sbe-tool/src/test/resources/FixBinary.xml',
            'sbe-tool/src/test/resources/issue435.xml',
            'sbe-tool/src/test/resources/issue483.xml',
            'sbe-tool/src/test/resources/issue560.xml',
            'sbe-tool/src/test/resources/since-deprecated-test-schema.xml',
            'sbe-tool/src/test/resources/example-bigendian-test-schema.xml',
            'sbe-benchmarks/src/main/resources/fix-message-samples.xml']
}

task generateCSharpCodecs {
    description = 'Generate csharp codecs'
    dependsOn 'generateCSharpCodecsTests',
        'generateCSharpCodecsWithXIncludes'
}

task generateJavaIrCodecs(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'sbe-tool/src/main/java',
        'sbe.target.language': 'Java',
        'sbe.validation.xsd': validationXsdPath)
    args = ['sbe-tool/src/main/resources/sbe-ir.xml']
}

task generateCppIrCodecs(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'sbe-tool/src/main/cpp',
        'sbe.target.language': 'cpp',
        'sbe.validation.xsd': validationXsdPath)
    args = ['sbe-tool/src/main/resources/sbe-ir.xml']
}

task generateGolangIrCodecs(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'sbe-tool/src/main/golang',
        'sbe.target.language': 'golang',
        'sbe.validation.xsd': validationXsdPath)
    args = ['sbe-tool/src/main/resources/sbe-ir.xml']
}

task generateIrCodecs {
    description = 'Generate Java, C++, and golang IR Codecs'
    dependsOn 'generateJavaIrCodecs', 'generateCppIrCodecs', 'generateGolangIrCodecs'
}

task runJavaBenchmarks(type: Exec) {
    commandLine 'java',
        '-jar', 'sbe-benchmarks/build/libs/sbe-benchmarks.jar',
        '-jvmArgs', '-Dagrona.disable.bounds.checks=true -XX:+UseParallelOldGC',
        '-w', '1s', '-r', '1s','-wi', '3', '-i', '5', '-tu', 'ns', '-f', '5'
}

task uploadToMavenCentral {
    dependsOn 'sbe-tool:uploadArchives',
        'sbe-samples:uploadArchives',
        'sbe-benchmarks:uploadArchives',
        'sbe-all:uploadArchives',
        'sbe-all:uploadShadow'
}

wrapper {
    gradleVersion = '5.6.3'
    distributionType = 'ALL'
}