build.gradle

import static org.apache.tools.ant.taskdefs.condition.Os.*

plugins {
  // cpp
  id 'cpp'

  // Publish library to maven
  id 'maven-publish'

  // Add basic gradle conventions like archiving
  id 'base'

  // Google test suite for native build
  id 'google-test-test-suite'

  // GradleRIO
  id 'edu.wpi.first.GradleRIO' version '2022.2.1'

  // Doxygen
  id 'org.ysb33r.doxygen' version '0.7.0'
}

allprojects {
  plugins.withType(edu.wpi.first.toolchain.roborio.RoboRioToolchainPlugin).whenPluginAdded {
    if (project.hasProperty('no-roborio'))
      toolchainsPlugin.getByName('roboRio').optional = true
  }

  plugins.withType(NativeComponentPlugin).whenPluginAdded {
    project.model {
      binaries {
        all {
          if (it instanceof NativeBinarySpec) {
            if (project.hasProperty('no-desktop') && targetPlatform.name == edu.wpi.first.toolchain.NativePlatforms.desktop) {
              it.buildable = false
            }
            if (project.hasProperty('no-roborio') && targetPlatform.name == edu.wpi.first.toolchain.NativePlatforms.roborio) {
              it.buildable = false
            }
          }

          // Toolchain defines (cpp version)
          if (toolChain in [Gcc, Clang]) {
            println "Using Gcc"
            cppCompiler.args "-std=${cpp_version}"
          } else if (toolChain in VisualCpp) {
            cppCompiler.args "/std:${cpp_version}"
          }
          
        }
      }
    }
  }
}

subprojects {
  project.buildDir = rootProject.buildDir

  plugins.withType(CppPlugin).whenPluginAdded {
    project.apply plugin: 'visual-studio'
  }

  ext.binaryPublishers = [:]
  ext.binaryArtifacts = { scope, name ->
    if (binaryPublishers[name] == null)
      binaryPublishers[name] = []
    binaryPublishers[name] << [scope: scope]
  }

  project.model {
    binaries {
      withType(NativeBinarySpec) {

        // Create classified binary zip task i.e -> maven_test-2021.3.1-cpp-linuxathena.zip
        def bin = it
        if (it.buildable && (it instanceof SharedLibraryBinary || it instanceof StaticLibraryBinary)) {
          def sharedlib = bin instanceof SharedLibraryBinary
          def staticlib = bin instanceof StaticLibraryBinary
          def taskSuffix = "${component.name}${targetPlatform.name}${buildType.name}"
          def source = (sharedlib ? bin.sharedLibraryFile : bin.staticLibraryFile)

          def type = (sharedlib ? "" : "static")
          def ziptask = task "zip${taskSuffix}${type}"(type: Zip) {
            def allsrc = [source]
            if (sharedlib && bin.targetPlatform.operatingSystem.isWindows()) {
              allsrc << bin.sharedLibraryLinkFile
            } else if (staticlib && bin.targetPlatform.operatingSystem.isWindows()) {
              allsrc << bin.staticLibraryFile
            }

            destinationDirectory = outputFolder

            ext.platformArc = targetPlatform.name
            platformArc = platformArc.replace("${OS_NAME}", "")

            from(allsrc as Set<File>) {
              into("${OS_NAME}/${platformArc}/" + (sharedlib ? "shared" : "static"))
            }

            from(licenseFile) {
              into("${OS_NAME}/${platformArc}/" + (sharedlib ? "shared" : "static"))
            }

            baseName = component.name
            classifier = targetPlatform.name + (buildType.name == 'debug' ? "${type}debug" : "${type}")

            dependsOn(build)
            dependsOn bin.tasks.withType(AbstractLinkTask)
          }


          // Binary Publisher classifier
          if (binaryPublishers[bin.component.name] != null) {
            binaryPublishers[bin.component.name].each { entry ->
              entry.scope.artifact(ziptask) {
                classifier targetPlatform.name + (buildType.name == 'debug' ? "${type}debug" : "${type}")
              }
            }
          }


        }
      }
    }
  }
}

wrapper {
  gradleVersion = '7.3.3' // new but... with model?
}