build.gradle

import org.gradle.internal.os.OperatingSystem

import java.nio.file.Files
import java.nio.file.Paths

apply plugin: 'maven-publish'

publishing {
    repositories {
        maven {
            url "${System.getProperty('user.home')}/releases/maven/development"
        }
        maven {
            url "${System.getProperty('user.home')}/releases/maven/release"
        }
    }
}

def getPlatform() {
    def platform
    def os_name = System.getProperty("os.name")
    def os_arch = System.getProperty("os.arch")

    if (os_arch == 'amd64') {
        os_arch = 'x86_64'
    } else if (os_arch == 'aarch64' || os_arch == 'arm64') {
        os_arch = 'arm64'
    }

    if (OperatingSystem.current().isWindows()) {
        platform = "windows-${os_arch}"
    } else if (OperatingSystem.current().isLinux()) {
        platform = "linux-${os_arch}"
    } else if (OperatingSystem.current().isMacOsX()) {
        platform = "osx-${os_arch}"
    } else {
        platform = "${os_name}-${os_arch}"
    }
    return platform
}

def getPlatformPath(platform) {
    if (platform == "linux-athena") {
        return "linux/athena"
    } else if (platform == "linux-arm32") {
        return "linux/arm32"
    } else if (platform == "linux-arm64") {
        return "linux/arm64"
    } else if (platform == "linux-x86_64") {
        return "linux/x86-64"
    } else if (platform == "osx-universal") {
        return "osx/universal"
    } else if (platform == "windows-x86_64") {
        return "windows/x86-64"
    } else if (platform == "windows-arm64") {
        return "windows/arm64"
    } else {
        return ""
    }
}

if (!project.hasProperty('platform')) {
    println "No 'platform' property specified; using the build system's platform"
    ext.platform = getPlatform()
}
ext.platformPath = getPlatformPath(project.platform)
def outputClassifierStatic = ext.platformPath.replaceFirst('/', '') + 'static'

def pubVersion = "4.3-2"

def outputsFolder = file("$project.buildDir/outputs")

def baseArtifactId = 'gtsam'
def artifactGroupId = 'edu.wpi.first.thirdparty.frc2025.gtsam'
def zipBaseName = '_GROUP_edu_wpi_first_thirdparty_frc2025_gtsam_ID_gtsam-cpp_CLS'

def versionFile = file("$outputsFolder/version.txt")
def licenseFile = file("LICENSE.md")

println platformPath

task copyAllOutputs(type: Copy) {
    destinationDir = outputsFolder
}

ext.addTaskToCopyAllOutputs = { task ->
    copyAllOutputs.dependsOn task
    copyAllOutputs.inputs.file task.archiveFile
    copyAllOutputs.from task.archiveFile
}

task outputVersions() {
    description = 'Prints the versions of this to a file for use by the downstream packaging project'
    group = 'Build'
    outputs.files(versionFile)

    doFirst {
        buildDir.mkdir()
        outputsFolder.mkdir()
    }

    doLast {
        versionFile.write pubVersion
    }
}

["Debug", "RelWithDebInfo"].each { buildType ->
    def buildDir = "build$buildType"
    def installDir = "install$buildType"

    task "cmakeConfigure$buildType"(type: Exec) {
        def baseArgs = ["-B", buildDir, "-G", "Ninja", "-DCMAKE_BUILD_TYPE=$buildType", "-DCMAKE_INSTALL_PREFIX=$installDir"]

        if (project.hasProperty('sccache')) {
            baseArgs = baseArgs + "-DCMAKE_C_COMPILER_LAUNCHER=sccache" + "-DCMAKE_CXX_COMPILER_LAUNCHER=sccache"
        }
        outputs.dir buildDir
        executable "cmake"
        args baseArgs
    }

    task "cmakeBuild$buildType"(type: Exec) {
        dependsOn "cmakeConfigure$buildType"
        def processors = Runtime.runtime.availableProcessors()
        def baseArgs = ["--build", buildDir, "--parallel", "$processors", "--target", "install"]
        outputs.dirs buildDir, installDir
        executable "cmake"
        args baseArgs
    }

    task "cppLibsZipStatic$buildType"(type: Zip) {
        dependsOn "cmakeBuild$buildType"
        destinationDirectory = outputsFolder
        archiveClassifier = outputClassifierStatic + (buildType == "Debug" ? "debug" : "")
        archiveBaseName = zipBaseName
        duplicatesStrategy = 'exclude'

        def license = Paths.get(projectDir.canonicalPath).resolve(buildDir).resolve("_deps").resolve("gtsam-src")
        from(license.toFile()) {
            into '/'
            include 'LICENSE*'
        }
        def resolvedDir = Paths.get(projectDir.canonicalPath).resolve(installDir).resolve("lib")
        from(resolvedDir.toFile()) {
            into project.platformPath + '/static'
            include '**/*.a'
            include '**/*.lib'
            include '**/*.pdb'
        }
        includeEmptyDirs = false
    }
}
// Choice of using Debug is arbitrary, just wanted a build task to depend on
task cppHeadersZip(type: Zip) {
    dependsOn "cmakeBuildDebug"
    dependsOn outputVersions
    destinationDirectory = outputsFolder
    archiveBaseName = zipBaseName
    archiveClassifier = "headers"

    def license = Paths.get(projectDir.canonicalPath).resolve("buildDebug").resolve("_deps").resolve("gtsam-src")
    from(license.toFile()) {
        into '/'
        include 'LICENSE*'
    }
    def resolvedDir = Paths.get(projectDir.canonicalPath).resolve("installDebug").resolve("include")
    from(resolvedDir.toFile()) {
        into '/'
        include '**/*.hpp', '**/*.h'
    }

    includeEmptyDirs = false
}

task cppSourcesZip(type: Zip) {
    dependsOn "cmakeBuildDebug"
    dependsOn outputVersions
    destinationDirectory = outputsFolder
    archiveBaseName = zipBaseName
    archiveClassifier = "sources"

    def license = Paths.get(projectDir.canonicalPath).resolve("buildDebug").resolve("_deps").resolve("gtsam-src")
    from(license.toFile()) {
        into '/'
        include 'LICENSE*'
    }
    def resolvedDir = Paths.get(projectDir.canonicalPath).resolve("installDebug").resolve("include")
    from(resolvedDir.toFile()) {
        into '/'
        include '**/*.hpp', '**/*.h'
    }

    includeEmptyDirs = false
}

if (!project.hasProperty('skipRelease')) {
    addTaskToCopyAllOutputs(cppLibsZipStaticRelWithDebInfo)
}

if (!project.hasProperty('skipDebug')) {
    addTaskToCopyAllOutputs(cppLibsZipStaticDebug)
}

model {
    publishing {
        publications {
            cpp(MavenPublication) {
                artifact cppHeadersZip
                artifact cppLibsZipStaticRelWithDebInfo
                artifact cppLibsZipStaticDebug
                artifact cppSourcesZip
                artifactId = "${baseArtifactId}-cpp"
                groupId artifactGroupId
                version pubVersion
            }
        }
    }
}