Add Gradle build scripts.

.gitignore

@@ -16,6 +16,11 @@
 *.vsp
 *.psess
 
+# Gradle #
+##########
+.gradle/
+gradle/
+
 # Make #
 ########
 config.build

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "openssl"]
 	path = openssl
 	url = https://github.com/pocoproject/openssl
+[submodule "gradle"]
+	path = gradle
+	url = https://github.com/pocoproject/gradle

CppParser/build.gradle

@@ -0,0 +1,32 @@
+model {
+	components {
+		CppParser(NativeLibrarySpec) {
+			sources {
+				rc {
+					source {
+						srcDir '..'
+						include 'DLLVersion.rc'
+					}
+				}
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	binaries {
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+				 cppCompiler.define "CppParser_EXPORTS"
+			}
+		}
+	}
+}
+task poco { dependsOn "assemble" }

CppParser/testsuite/build.gradle

@@ -0,0 +1,52 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		TestSuite(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '*Driver.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit'
+					lib project: ':CppParser', library: 'CppParser'
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	testSuites {
+		CppParserTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+    binaries {
+		all {
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+		}
+        withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+        }
+	}
+}
+task testsuite { dependsOn "assemble" }
+
+

CppUnit/WinTestRunner/build.gradle

@@ -0,0 +1,33 @@
+project(":CppUnit/WinTestRunner") {
+	model {
+		components {
+			PocoWinTestRunner(NativeExecutableSpec) {
+				sources {
+					cpp {
+						source {
+							srcDir 'src'
+							include '**/*.cpp'
+						}
+						exportedHeaders {
+							srcDir 'include'
+						}
+					}
+				}
+			}
+		}
+		binaries {
+			all {
+			}
+			withType(SharedLibraryBinarySpec) {
+				lib project: ':CppUnit', library: 'PocoCppUnit', linkage: 'shared'
+				if (toolChain in VisualCpp) {
+					 cppCompiler.define "WinTestRunner_EXPORTS"
+				}
+			}
+			withType(StaticLibraryBinarySpec) {
+				lib project: ':CppUnit', library: 'PocoCppUnit', linkage: 'static'
+			}
+		}
+	}
+}
+

CppUnit/build.gradle

@@ -0,0 +1,35 @@
+model {
+	components {
+		CppUnit(NativeLibrarySpec) {
+			sources {
+				rc {
+					source {
+						srcDir '..'
+						include 'DLLVersion.rc'
+					}
+				}
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+				}
+			}
+		}
+	}
+	binaries {
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+				 cppCompiler.define "CppUnit_EXPORTS"
+			}
+		}
+		withType(StaticLibraryBinarySpec) {
+		}
+	}
+}
+task poco { dependsOn "assemble" }
+
+

Crypto/build.gradle

@@ -0,0 +1,45 @@
+model {
+	components {
+		Crypto(NativeLibrarySpec) {
+			sources {
+				rc {
+					source {
+						srcDir '..'
+						include 'DLLVersion.rc'
+					}
+				}
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib library: 'ssl'
+					lib library: 'crypto'
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	binaries {
+		all {
+			if (toolChain in VisualCpp) {
+				linker.args "ws2_32.lib"
+				linker.args "iphlpapi.lib"
+			}
+			if (toolChain in Gcc) {
+				linker.args "-lssl"
+				linker.args "-lcrypto"
+			}
+		}
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+				 cppCompiler.define "Crypto_EXPORTS"
+			}
+		}
+	}
+}
+task poco { dependsOn "assemble" }
+

Crypto/samples/build.gradle

@@ -0,0 +1,27 @@
+model {
+	components {
+		genrsakey(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'genrsakey/src' include '**/*.cpp' }
+				cpp.lib project: ':Crypto', library: 'Crypto'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+		}
+		withType(StaticLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+		withType(NativeExecutableSpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+	}
+}
+task sample { dependsOn "assemble" }
+
+

Crypto/testsuite/build.gradle

@@ -0,0 +1,65 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		TestSuite(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '*Driver.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit'
+					lib project: ':Crypto', library: 'Crypto'
+					lib library: 'ssl'
+					lib library: 'crypto'
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	testSuites {
+		CryptoTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+    binaries {                                               
+        withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+		}
+	}
+}
+task testsuite { dependsOn "assemble" }
+

Data/MySQL/build.gradle

@@ -0,0 +1,104 @@
+model {
+	repositories {
+		libs(PrebuiltLibraries) {
+			mysql {
+				headers.srcDir "$mysql32Home/include"
+				binaries.withType(StaticLibraryBinary) {
+					def libName = "foobar"
+					if (buildType == buildTypes.debug) {
+						libName = 'libmysqld.lib'
+						if (targetPlatform.name == 'win32') {
+							staticLibraryFile = file("$mysql32Home/lib/$libName")
+						} else
+						if (targetPlatform.name == 'win64') {
+							headers.srcDir "$mysql64Home/include"
+							staticLibraryFile = file("$mysql64Home/lib/$libName")
+						}
+					} else
+					if (buildType == buildTypes.release) {
+						libName = 'libmysql.lib'
+						if (targetPlatform.name == 'win32') {
+							headers.srcDir "$mysql32Home/include"
+							staticLibraryFile = file("$mysql32Home/lib/$libName")
+						} else
+						if (targetPlatform.name == 'win64') {
+							headers.srcDir "$mysql64Home/include"
+							staticLibraryFile = file("$mysql64Home/lib/$libName")
+						}
+					} else {
+						throw new GradleException("Unknown buildType" + buildType)
+					}
+				}
+				binaries.withType(SharedLibraryBinary) {
+					def dllName
+					def linkName
+					if (buildType == buildTypes.debug) {
+						dllName = 'libmysqld.dll'
+						linkName = 'libmysqld.lib'
+						if (targetPlatform.name == 'win32') {
+							headers.srcDir "$mysql32Home/include"
+							sharedLibraryFile     = file("$mysql32Home/lib/$dllName")
+							sharedLibraryLinkFile = file("$mysql32Home/lib/$linkName")
+						} else
+						if (targetPlatform.name == 'win64') {
+							headers.srcDir "$mysql64Home/include"
+							sharedLibraryFile     = file("$mysql64Home/lib/$dllName")
+							sharedLibraryLinkFile = file("$mysql64Home/lib/$linkName")
+						}
+					} else
+					if (buildType == buildTypes.release) {
+						dllName = 'libmysql.dll'
+						linkName = 'libmysql.lib'
+						if (targetPlatform.name == 'win32') {
+							headers.srcDir "$mysql32Home/include"
+							sharedLibraryFile     = file("$mysql32Home/lib/$dllName")
+							sharedLibraryLinkFile = file("$mysql32Home/lib/$linkName")
+						} else
+						if (targetPlatform.name == 'win64') {
+							headers.srcDir "$mysql64Home/include"
+							sharedLibraryFile     = file("$mysql64Home/lib/$dllName")
+							sharedLibraryLinkFile = file("$mysql64Home/lib/$linkName")
+						}
+					} else {
+						throw new GradleException("Unknown buildType" + buildType)
+					}
+				}
+			}
+		}
+	}
+	components {
+		DataMySQL(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib library: 'mysql'
+					lib project: ':Data', library: 'Data'
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	binaries {
+		all {
+			cppCompiler.define	"THREADSAFE"
+			cppCompiler.define 	"__LCC__"	
+			cppCompiler.define 	"WINVER=0x0600"
+		}
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+				cppCompiler.define	"MySQL_EXPORTS"
+			}
+		}
+		withType(StaticLibraryBinarySpec) {
+		}
+	}
+}
+task poco { dependsOn "assemble" }
+
+

Data/MySQL/testsuite/build.gradle

@@ -0,0 +1,73 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		TestSuite(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '*Driver.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+					lib project: ':Data:MySQL', library: 'mysql', linkage: 'shared'
+					lib project: ':Data:MySQL', library: 'DataMySQL', linkage: 'shared'
+					lib project: ':Data', library: 'Data', linkage: 'shared'
+					lib project: ':Util', library: 'Util'
+					lib project: ':JSON', library: 'JSON'
+					lib project: ':XML', library: 'XML'
+					lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+				}
+			}
+		}
+	}
+	testSuites {
+		MySQLTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+    binaries {
+		all {
+			cppCompiler.define	"THREADSAFE"
+			cppCompiler.define 	"__LCC__"	
+			cppCompiler.define 	"WINVER=0x0600"
+		}
+        withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+        }
+	}
+}
+task testsuite { dependsOn "assemble" }
+

Data/ODBC/build.gradle

@@ -0,0 +1,46 @@
+model {
+	components {
+		DataODBC(NativeLibrarySpec) {
+			sources {
+				rc {
+					source {
+						srcDir '../..'
+						include 'DLLVersion.rc'
+					}
+				}
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude 'Unicode_WIN32.cpp'
+						exclude 'Unicode_UNIXODBC.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib project: ':Data', library: 'Data'
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	binaries {
+		all {
+			if (toolChain in VisualCpp) {
+				cppCompiler.define	"THREADSAFE=1"
+			}
+		}
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+				cppCompiler.define	"ODBC_EXPORTS"
+				linker.args 'odbc32.lib'
+				linker.args 'odbccp32.lib'
+			}
+		}
+		withType(StaticLibraryBinarySpec) {
+		}
+	}
+}
+task poco { dependsOn "assemble" }
+
+

Data/ODBC/testsuite/build.gradle

@@ -0,0 +1,69 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		TestSuite(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '*Driver.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+					lib project: ':Data:ODBC', library: 'DataODBC', linkage: 'shared'
+					lib project: ':Data', library: 'Data', linkage: 'shared'
+					lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+				}
+			}
+		}
+	}
+	testSuites {
+		ODBCTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+	binaries {
+		all {
+			if (toolChain in VisualCpp) {
+				linker.args 'odbc32.lib'
+				linker.args 'odbccp32.lib'
+			}
+		}
+        withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+        }
+	}
+}
+task testsuite { dependsOn "assemble" }

Data/SQLite/build.gradle

@@ -0,0 +1,69 @@
+model {
+	components {
+		DataSQLite(NativeLibrarySpec) {
+			sources {
+				rc {
+					source {
+						srcDir '../..'
+						include 'DLLVersion.rc'
+					}
+				}
+				c {
+					source {
+						srcDir 'src'
+						include '**/*.c'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib project: ':Data', library: 'Data'
+					lib project: ':Foundation', library: 'Foundation'
+				}
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib project: ':Data', library: 'Data'
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	binaries {
+		all {
+			if (toolChain in VisualCpp) {
+				cCompiler.define	"SQLITE_THREADSAFE=1"
+				cCompiler.define	"SQLITE_ENABLE_FTS3"
+				cCompiler.define	"SQLITE_ENABLE_FTS3_PARENTHESIS"
+				cCompiler.define	"SQLITE_OMIT_UTF16"
+				cCompiler.define	"SQLITE_OMIT_PROGRESS_CALLBACK"
+				cCompiler.define	"SQLITE_OMIT_COMPLETE"
+				cCompiler.define	"SQLITE_OMIT_TCL_VARIABLE"
+				cCompiler.define	"SQLITE_OMIT_DEPRECATED"
+				
+				cppCompiler.define	"SQLITE_THREADSAFE=1"
+				cppCompiler.define	"SQLITE_ENABLE_FTS3"
+				cppCompiler.define	"SQLITE_ENABLE_FTS3_PARENTHESIS"
+				cppCompiler.define	"SQLITE_OMIT_UTF16"
+				cppCompiler.define	"SQLITE_OMIT_PROGRESS_CALLBACK"
+				cppCompiler.define	"SQLITE_OMIT_COMPLETE"
+				cppCompiler.define	"SQLITE_OMIT_TCL_VARIABLE"
+				cppCompiler.define	"SQLITE_OMIT_DEPRECATED"
+			}
+		}
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+				cppCompiler.define	"SQLite_EXPORTS"
+			}
+		}
+		withType(StaticLibraryBinarySpec) {
+		}
+	}
+}
+task poco { dependsOn "assemble" }
+
+

Data/SQLite/testsuite/build.gradle

@@ -0,0 +1,64 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		TestSuite(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '*Driver.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+					lib project: ':Data:SQLite', library: 'DataSQLite', linkage: 'shared'
+					lib project: ':Data', library: 'Data', linkage: 'shared'
+					lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+				}
+			}
+		}
+	}
+	testSuites {
+		SQLiteTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+    binaries {
+        withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+        }
+	}
+}
+task testsuite { dependsOn "assemble" }
+

Data/build.gradle

@@ -0,0 +1,35 @@
+model {
+	components {
+		Data(NativeLibrarySpec) {
+			sources {
+				rc {
+					source {
+						srcDir '..'
+						include 'DLLVersion.rc'
+					}
+				}
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+				lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+				 cppCompiler.define "Data_EXPORTS"
+			}
+		}
+	}
+}
+task poco { dependsOn "assemble" }
+

Data/samples/build.gradle

@@ -0,0 +1,69 @@
+model {
+	components {
+		Binding(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'Binding/src' include '**/*.cpp' }
+				cpp.lib project: ':Data', library: 'Data'				
+				cpp.lib project: ':Data:SQLite', library: 'DataSQLite'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		RecordSet(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'RecordSet/src' include '**/*.cpp' }
+				cpp.lib project: ':Data', library: 'Data'				
+				cpp.lib project: ':Data:SQLite', library: 'DataSQLite'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		RowFormatter(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'RowFormatter/src' include '**/*.cpp' }
+				cpp.lib project: ':Data', library: 'Data'				
+				cpp.lib project: ':Data:SQLite', library: 'DataSQLite'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		Tuple(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'Tuple/src' include '**/*.cpp' }
+				cpp.lib project: ':Data', library: 'Data'				
+				cpp.lib project: ':Data:SQLite', library: 'DataSQLite'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		TypeHandler(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'TypeHandler/src' include '**/*.cpp' }
+				cpp.lib project: ':Data', library: 'Data'				
+				cpp.lib project: ':Data:SQLite', library: 'DataSQLite'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		WebNotifier(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'WebNotifier/src' include '**/*.cpp' }
+				cpp.lib project: ':Data', library: 'Data'				
+				cpp.lib project: ':Data:SQLite', library: 'DataSQLite'				
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+		}
+		withType(StaticLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+		withType(NativeExecutableSpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+	}
+}
+task samples { dependsOn "assemble" }
+
+

Data/testsuite/build.gradle

@@ -0,0 +1,65 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		TestSuite(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '*Driver.cpp'
+						exclude 'StatementImpl.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+					lib project: ':Data', library: 'Data', linkage: 'shared'
+					lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+				}
+			}
+		}
+	}
+	testSuites {
+		DataTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+    binaries {                                               
+        withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+        }
+	}
+}
+task testsuite { dependsOn "assemble" }
+
+

Foundation/build.gradle

@@ -0,0 +1,115 @@
+model {
+	components {
+		Foundation(NativeLibrarySpec) { m ->
+			sources {
+//
+//				mc {
+//					source {
+//						srcDir 'src'
+//						include '**/*.mc'
+//					}
+//				}
+				rc {
+					source {
+						srcDir '..'
+						include 'DLLVersion.rc'
+					}
+				}
+				c {
+					source {
+						srcDir 'src'
+						include '**/*.c'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+				}
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude 'ByteOrder.cpp'
+						exclude 'String.cpp'
+						exclude 'SignalHandler.cpp'
+						exclude 'Environment_*.cpp'
+						exclude 'FPEnvironment_*.cpp'
+						exclude 'Timezone_*.cpp'
+						exclude 'DirectoryIterator_*.cpp'
+						exclude 'File_*.cpp'
+						exclude 'FileStream_*.cpp'
+						exclude 'Path_*.cpp'
+						exclude 'LogFile_*.cpp'
+						exclude 'NamedEvent_*.cpp'
+						exclude 'NamedMutex_*.cpp'
+						exclude 'PipeImpl_*.cpp'
+						exclude 'Process_*.cpp'
+						exclude 'SharedMemory_*.cpp'
+						exclude 'SharedLibrary_*.cpp'
+						exclude 'Event_*.cpp'
+						exclude 'Mutex_*.cpp'
+						exclude 'RWLock_*.cpp'
+						exclude 'Semaphore_*.cpp'
+						exclude 'Thread_*.cpp'
+
+						exclude 'EventLogChannel.cpp'
+						exclude 'UnWindows.cpp'
+						exclude 'WindowsConsoleChannel.cpp'
+						exclude 'OpcomChannel.cpp'
+						exclude 'AndroidLogChannel.cpp'
+						exclude 'SyslogChannel.cpp'
+
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+				}
+			}
+			binaries.all {
+				sources {
+					if (targetPlatform.operatingSystem.windows) {
+						platformWindows(CppSourceSet) {
+							lib m.sources.cpp
+							source {
+								srcDir 'src'
+								include 'EventLogChannel.cpp'
+								include 'UnWindows.cpp'
+								include 'WindowsConsoleChannel.cpp'
+							}
+						}
+					} else
+                     if (targetPlatform.operatingSystem.macOsX || targetPlatform.operatingSystem.linux) {
+						platformNix(CppSourceSet) {
+							lib m.sources.cpp
+							source {
+								srcDir 'src'
+								include 'SignalHandler.cpp'
+								include 'SyslogChannel.cpp'
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	binaries {
+		all {
+			if (toolChain in VisualCpp) {
+				linker.args "ws2_32.lib"
+				linker.args "iphlpapi.lib"
+			}
+		}
+		withType(NativeExecutableSpec) {
+		}
+		withType(StaticLibraryBinarySpec) {
+		}
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+//					addCompilerDefine "Foundation_EXPORTS" ""
+				cCompiler.define "Foundation_EXPORTS"
+				cppCompiler.define "Foundation_EXPORTS"
+			}
+		}
+	}
+}
+task poco { dependsOn "assemble" }
+

Foundation/samples/build.gradle

@@ -0,0 +1,146 @@
+model {
+	components {
+		ActiveMethod(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'ActiveMethod/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		Activity(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'ActiveMethod/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		base64decode(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'base64decode/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		base64encode(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'base64encode/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		Benchmark(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'Benchmark/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		BinaryReaderWriter(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'BinaryReaderWriter/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		DateTime(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'DateTime/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		deflate(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'deflate/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		dir(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'dir/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		grep(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'grep/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		hmacmd5(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'hmacmd5/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		inflate(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'inflate/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		LineEndingConverter(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'LineEndingConverter/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		Logger(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'Logger/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		LogRotation(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'LogRotation/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		md5(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'md5/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		NotificationQueue(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'NotificationQueue/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		StringTokenizer(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'StringTokenizer/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		Timer(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'Timer/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		URI(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'URI/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		uuidgen(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'uuidgen/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+		}
+		withType(StaticLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+		withType(NativeExecutableSpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+	}
+}
+task samples { dependsOn "assemble" }
+
+

Foundation/testsuite/build.gradle

@@ -0,0 +1,92 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		TestLib(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include 'TestLibrary.cpp'
+						include 'TestPlugin.cpp'
+					}
+					lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+					lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+				}
+			}
+		}
+		TestApp(NativeExecutableSpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include 'TestApp.cpp'
+					}
+					lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+					lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+					lib library: 'TestLib', linkage: 'shared'
+				}
+			}
+		}
+		TestSuite(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '*Driver.cpp'
+						exclude '*_WINCE.cpp'
+						exclude 'TestApp*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+					lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+				}
+			}
+		}
+	}
+	testSuites {
+		FoundationTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+    binaries {                                               
+        withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+ 			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+       }
+	}
+
+}
+task testsuite { dependsOn "assemble" }
+
+

JSON/build.gradle

@@ -0,0 +1,48 @@
+model {
+	components {
+		JSON(NativeLibrarySpec) {
+			sources {
+				rc {
+					source {
+						srcDir '..'
+						include 'DLLVersion.rc'
+					}
+				}
+				c {
+					source {
+						srcDir 'src'
+						include '**/*.c'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib project: ':Foundation', library: 'Foundation'
+				}
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	binaries {
+		all {
+			if (toolChain in VisualCpp) {
+				cCompiler.args "/TP"
+			}
+		}
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+				 cppCompiler.define "JSON_EXPORTS"
+			}
+		}
+	}
+}
+task poco { dependsOn "assemble" }
+

JSON/samples/build.gradle

@@ -0,0 +1,27 @@
+model {
+	components {
+		Benchmark(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'Benchmark/src' include '**/*.cpp' }
+				cpp.lib project: ':JSON', library: 'JSON'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+		}
+		withType(StaticLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+		withType(NativeExecutableSpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+	}
+}
+task samples { dependsOn "assemble" }
+
+

JSON/testsuite/build.gradle

@@ -0,0 +1,63 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		TestSuite(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '*Driver.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+					lib project: ':JSON', library: 'JSON', linkage: 'shared'
+					lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+				}
+			}
+		}
+	}
+	testSuites {
+		JSONTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+    binaries {                                               
+        withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+        }
+	}
+}
+task testsuite { dependsOn "assemble" }
+

MongoDB/build.gradle

@@ -0,0 +1,37 @@
+model {
+	components {
+		MongoDB(NativeLibrarySpec) {
+			sources {
+				rc {
+					source {
+						srcDir '..'
+						include 'DLLVersion.rc'
+					}
+				}
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib project: ':Net', library: 'Net'
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+				 cppCompiler.define "MongoDB_EXPORTS"
+			}
+		}
+	}
+}
+task poco { dependsOn "assemble" }
+
+

MongoDB/samples/build.gradle

@@ -0,0 +1,28 @@
+model {
+	components {
+		SQLToMongo(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'SQLToMongo/src' include '**/*.cpp' }
+				cpp.lib project: ':MongoDB', library: 'MongoDB'				
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+		}
+		withType(StaticLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+		withType(NativeExecutableSpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+	}
+}
+task samples { dependsOn "assemble" }
+
+

MongoDB/testsuite/build.gradle

@@ -0,0 +1,63 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		TestSuite(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '*Driver.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+					lib project: ':MongoDB', library: 'MongoDB', linkage: 'shared'
+					lib project: ':Net', library: 'Net', linkage: 'shared'
+					lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+				}
+			}
+		}
+	}
+	testSuites {
+		MongoDBTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+    binaries {                                               
+        withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+        }
+	}
+}
+task testsuite { dependsOn "assemble" }

Net/build.gradle

@@ -0,0 +1,40 @@
+model {
+	components {
+		Net(NativeLibrarySpec) {
+			sources {
+				rc {
+					source {
+						srcDir '..'
+						include 'DLLVersion.rc'
+					}
+				}
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	binaries {
+		all {
+			if (targetPlatform.operatingSystem.windows) {
+				linker.args "ws2_32.lib"
+				linker.args "iphlpapi.lib"
+			}
+		}
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+				 cppCompiler.define "Net_EXPORTS"
+			}
+		}
+	}
+}
+task poco { dependsOn "assemble" }
+
+

Net/samples/build.gradle

@@ -0,0 +1,118 @@
+model {
+	components {
+		dict(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'dict/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		download(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'download/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		EchoServer(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'EchoServer/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		HTTPFormServer(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'HTTPFormServer/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		httpget(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'httpget/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		HTTPLoadTest(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'HTTPLoadTest/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		HTTPTimeServer(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'HTTPTimeServer/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		ifconfig(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'ifconfig/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		Mail(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'Mail/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		Ping(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'Ping/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		SMTPLogger(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'SMTPLogger/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		TimeServer(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'TimeServer/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		WebSocketServer(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'WebSocketServer/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+		}
+		withType(StaticLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+		withType(NativeExecutableSpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+	}
+}
+task samples { dependsOn "assemble" }
+
+

Net/testsuite/build.gradle

@@ -0,0 +1,69 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		TestSuite(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '*Driver.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+					lib project: ':Net', library: 'Net', linkage: 'shared'
+					lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+				}
+			}
+		}
+	}
+	testSuites {
+		NetTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+	binaries {
+		all {
+			if (targetPlatform.operatingSystem.windows) {
+				linker.args "ws2_32.lib"
+				linker.args "iphlpapi.lib"
+			}
+		}
+        withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+        }
+	}
+}
+task testsuite { dependsOn "assemble" }
+

NetSSL_OpenSSL/build.gradle

@@ -0,0 +1,41 @@
+model {
+	components {
+		NetSSL(NativeLibrarySpec) {
+			sources {
+				rc {
+					source {
+						srcDir '..'
+						include 'DLLVersion.rc'
+					}
+				}
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib library: 'ssl'
+					lib library: 'crypto'
+					lib project: ':Crypto', library: 'Crypto'
+					lib project: ':Net', library: 'Net'
+					lib project: ':Util', library: 'Util'
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	binaries {
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+				 cppCompiler.define "NetSSL_EXPORTS"
+			}
+		}
+		withType(StaticLibraryBinarySpec) {
+		}
+	}
+}
+task poco { dependsOn "assemble" }
+
+

NetSSL_OpenSSL/samples/build.gradle

@@ -0,0 +1,68 @@
+model {
+	components {
+		download(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'download/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':NetSSL_OpenSSL', library: 'NetSSL'				
+				cpp.lib project: ':Crypto', library: 'Crypto'				
+				cpp.lib library: 'crypto'
+				cpp.lib library: 'ssl'
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		HTTPSTimeServer(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'EchoServer/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':NetSSL_OpenSSL', library: 'NetSSL'				
+				cpp.lib project: ':Crypto', library: 'Crypto'				
+				cpp.lib library: 'crypto'
+				cpp.lib library: 'ssl'
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		Mail(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'HTTPFormServer/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':NetSSL_OpenSSL', library: 'NetSSL'				
+				cpp.lib project: ':Crypto', library: 'Crypto'				
+				cpp.lib library: 'crypto'
+				cpp.lib library: 'ssl'
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		TwitterClient(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'httpget/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':NetSSL_OpenSSL', library: 'NetSSL'				
+				cpp.lib project: ':Crypto', library: 'Crypto'				
+				cpp.lib library: 'crypto'
+				cpp.lib library: 'ssl'
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+		}
+		withType(StaticLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+		withType(NativeExecutableSpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+	}
+}
+task samples { dependsOn "assemble" }
+
+

NetSSL_OpenSSL/testsuite/build.gradle

@@ -0,0 +1,74 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		TestSuite(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '*Driver.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit'
+					lib library: 'crypto'
+					lib library: 'ssl'
+					lib project: ':Crypto', library: 'Crypto'
+					lib project: ':Net', library: 'Net'
+					lib project: ':NetSSL_OpenSSL', library: 'NetSSL'
+					lib project: ':Util', library: 'Util'
+					lib project: ':JSON', library: 'JSON'
+					lib project: ':XML', library: 'XML'
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+			binaries.all {
+				if (targetPlatform.operatingSystem.windows) {
+					lib library: 'WS2_32', linkage: 'static'
+				}
+			}
+		}
+	}
+	testSuites {
+		NetSSLTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+    binaries {                                               
+        withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+        }
+	}
+}
+task testsuite { dependsOn "assemble" }

NetSSL_Win/build.gradle

@@ -0,0 +1,46 @@
+model {
+	components {
+		NetSSLWin(NativeLibrarySpec) {
+			binaries.all {
+				if (targetPlatform.operatingSystem.windows) {
+					sources {
+						rc(WindowsResourceSet) {
+							source {
+								srcDir '..'
+								include 'DLLVersion.rc'
+							}
+						}
+						cpp(CppSourceSet) {
+							source {
+								srcDir 'src'
+								include '**/*.cpp'
+							}
+							exportedHeaders {
+								srcDir 'include'
+							}
+							lib project: ':Crypto', library: 'Crypto'
+							lib project: ':Net', library: 'Net'
+							lib project: ':Util', library: 'Util'
+							lib project: ':Foundation', library: 'Foundation'
+						}
+					}
+				}
+			}
+		}
+	}
+	binaries {
+		all {
+			if (toolChain in VisualCpp) {
+				linker.args "Crypt32.lib"
+				linker.args 'ws2_32.lib'
+				linker.args 'iphlpapi.lib'
+			}
+		}
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+				 cppCompiler.define "NetSSL_Win_EXPORTS"
+			}
+		}
+	}
+}
+task poco { dependsOn "assemble" }

NetSSL_Win/samples/build.gradle

@@ -0,0 +1,56 @@
+model {
+	components {
+		download(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'dict/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':NetSSL_OpenSSL', library: 'NetSSL'				
+				cpp.lib project: ':Crypto', library: 'Crypto'				
+				cpp.lib library: 'crypto'
+				cpp.lib library: 'ssl'
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		HTTPSTimeServer(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'download/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':NetSSL_OpenSSL', library: 'NetSSL'				
+				cpp.lib project: ':Crypto', library: 'Crypto'				
+				cpp.lib library: 'crypto'
+				cpp.lib library: 'ssl'
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		Mail(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'EchoServer/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':NetSSL_OpenSSL', library: 'NetSSL'				
+				cpp.lib project: ':Crypto', library: 'Crypto'				
+				cpp.lib library: 'crypto'
+				cpp.lib library: 'ssl'
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+		}
+		withType(StaticLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+		withType(NativeExecutableSpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+	}
+}
+task samples { dependsOn "assemble" }
+
+

NetSSL_Win/testsuite/build.gradle

@@ -0,0 +1,70 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		TestSuite(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '*Driver.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit'
+					lib library: 'crypto'
+					lib library: 'ssl'
+					lib project: ':Crypto', library: 'Crypto'
+					lib project: ':Net', library: 'Net'
+					lib project: ':NetSSL_OpenSSL', library: 'NetSSL'
+					lib project: ':Util', library: 'Util'
+					lib project: ':JSON', library: 'JSON'
+					lib project: ':XML', library: 'XML'
+					lib project: ':Foundation', library: 'Foundation'
+					lib library: 'WS2_32', linkage: 'static'
+				}
+			}
+		}
+	}
+	testSuites {
+		NetSSLTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+    binaries {                                               
+		withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+        }
+	}
+}
+task testsuite { dependsOn "assemble" }

PDF/build.gradle

@@ -0,0 +1,39 @@
+project(":PDF") {
+	model {
+		components {
+			PDF(NativeLibrarySpec) {
+				sources {
+					c {
+						source {
+							srcDir 'src'
+							include '**/*.c'
+						}
+						exportedHeaders {
+							srcDirs 'include', 'include/Poco/PDF'
+						}
+					}
+					cpp {
+						source {
+							srcDir 'src'
+							include '**/*.cpp'
+						}
+						exportedHeaders {
+							srcDirs 'include', 'include/Poco/PDF'
+						}
+						lib project: ':Util', library: 'Util'
+						lib project: ':Foundation', library: 'Foundation'
+					}
+				}
+			}
+		}
+		binaries {
+			withType(SharedLibraryBinarySpec) {
+				if (toolChain in VisualCpp) {
+					 cppCompiler.define "PDF_EXPORTS"
+				}
+			}
+		}
+	}
+}
+task poco { dependsOn "assemble" }
+

PDF/samples/build.gradle

@@ -0,0 +1,34 @@
+model {
+	components {
+		Image(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'Image/src' include '**/*.cpp' }
+				cpp.lib project: ':PDF', library: 'PDF'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		Text(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'Image/src' include '**/*.cpp' }
+				cpp.lib project: ':PDF', library: 'PDF'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+		}
+		withType(StaticLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+		withType(NativeExecutableSpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+	}
+}
+task samples { dependsOn "assemble" }
+
+

PDF/testsuite/build.gradle

@@ -0,0 +1,61 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		TestSuite(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '*Driver.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit'
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	testSuites {
+		PDFTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+    binaries {                                               
+		withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+        }
+	}
+}
+task testsuite { dependsOn "assemble" }

PageCompiler/File2Page/build.gradle

@@ -0,0 +1,29 @@
+project(":PageCompiler:File2Page") {
+	model {
+		components {
+			File2page(NativeExecutableSpec) {
+				baseName 'f2pc'
+				sources {
+					cpp {
+						source {
+							srcDir 'src'
+							include '**/*.cpp'
+						}
+						exportedHeaders {
+							srcDir 'include'
+						}
+						lib project: ':Net', library: 'Net'
+						lib project: ':Util', library: 'Util'
+						lib project: ':Foundation', library: 'Foundation'
+					}
+				}
+				binaries.withType(NativeExecutableSpec) {
+					lib project: ':Net', library: 'Net', linkage: 'shared'
+					lib project: ':Util', library: 'Util', linkage: 'shared'
+					lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+				}
+			}
+		}
+	}
+}
+

PageCompiler/build.gradle

@@ -0,0 +1,41 @@
+model {
+	components {
+		cpspc(NativeExecutableSpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib project: ':Net', library: 'Net', linkage: 'shared'
+					lib project: ':Util', library: 'Util', linkage: 'shared'
+					lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+				}
+			}
+		}
+	}
+	binaries {
+		withType(NativeExecutableBinarySpec) {
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+		}
+	}
+}
+task poco { dependsOn "assemble" }
+
+

PageCompiler/samples/build.gradle

@@ -0,0 +1,28 @@
+model {
+	components {
+		HTTPTimeServer(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'HTTPTimeServer/src' include '**/*.cpp' }
+				cpp.lib project: ':Net', library: 'Net'				
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+		}
+		withType(StaticLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+		withType(NativeExecutableSpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+	}
+}
+task samples { dependsOn "assemble" }
+
+

PocoDoc/build.gradle

@@ -0,0 +1,44 @@
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		PocoDoc(NativeExecutableSpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib project: ':CppParser', library: 'CppParser'
+					lib project: ':Util', library: 'Util'
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	binaries {
+		withType(NativeExecutableSpec) {
+			if (toolChain in VisualCpp) {
+			}
+			if (toolChain in Gcc) {
+			}
+		}
+	}
+}
+
+

SevenZip/samples/build.gradle

@@ -0,0 +1,26 @@
+model {
+	components {
+		un7zip(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'dict/src' include '**/*.cpp' }
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+		}
+		withType(StaticLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+		withType(NativeExecutableSpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+	}
+}
+task samples { dependsOn "assemble" }
+
+

Util/build.gradle

@@ -0,0 +1,60 @@
+model {
+	components {
+		Util(NativeLibrarySpec) { m ->
+			sources {
+				rc {
+					source {
+						srcDir '..'
+						include 'DLLVersion.rc'
+					}
+				}
+				c {
+					source {
+						srcDir 'src'
+						include '**/*.c'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+				}
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '**/Win*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib project: ':Foundation', library: 'Foundation'
+					lib project: ':XML', library: 'XML'
+					lib project: ':JSON', library: 'JSON'
+				}
+			}
+			binaries.all {
+				if (targetPlatform.operatingSystem.windows) {
+					sources {
+						platformWindows(CppSourceSet) {
+							lib m.sources.cpp
+							source {
+								srcDir 'src'
+								include '**/Win*.cpp'
+							}
+							lib project: ':Foundation', library: 'Foundation'
+							lib project: ':XML', library: 'XML'
+							lib project: ':JSON', library: 'JSON'
+						}
+					}
+				}
+			}
+		}
+	}
+	binaries {
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+				 cppCompiler.define "Util_EXPORTS"
+			}
+		}
+	}
+}
+task poco { dependsOn "assemble" }

Util/samples/build.gradle

@@ -0,0 +1,48 @@
+model {
+	components {
+		pkill(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'pkill/src' include '**/*.cpp' }
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		SampleApp(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'SampleApp/src' include '**/*.cpp' }
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		SampleServer(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'SampleServer/src' include '**/*.cpp' }
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		Units(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'Units/src' include '**/*.cpp' }
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+		}
+		withType(StaticLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+		withType(NativeExecutableSpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+	}
+}
+task samples { dependsOn "assemble" }
+
+

Util/testsuite/build.gradle

@@ -0,0 +1,86 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		TestSuite(NativeLibrarySpec) { m ->
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude 'Win*.cpp'
+						exclude 'Driver.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+					lib project: ':JSON', library: 'JSON', linkage: 'shared'
+					lib project: ':XML', library: 'XML', linkage: 'shared'
+					lib project: ':Util', library: 'Util', linkage: 'shared'
+					lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+				}
+			}
+			binaries.all {
+				if (targetPlatform.operatingSystem.windows) {
+					sources {
+						platformWindows(CppSourceSet) {
+							lib m.sources.cpp
+							source {
+								srcDir 'src'
+								include 'Win*.cpp'
+								exclude '*Driver.cpp'
+							}
+							exportedHeaders {
+								srcDir 'src'
+							}
+							lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+							lib project: ':Util', library: 'Util', linkage: 'shared'
+							lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+						}
+					}
+				}
+			}
+		}
+	}
+	testSuites {
+		UtilTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+    binaries {                                               
+        withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+        }
+	}
+}
+task testsuite { dependsOn "assemble" }
+

XML/build.gradle

@@ -0,0 +1,57 @@
+model {
+	components {
+		XML(NativeLibrarySpec) {
+			sources {
+				rc {
+					source {
+						srcDir '..'
+						include 'DLLVersion.rc'
+					}
+				}
+				c {
+					source {
+						srcDir 'src'
+						include '**/*.c'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib project: ':Foundation', library: 'Foundation'
+				}
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	binaries {
+		all {
+			cCompiler.define "XML_STATIC"
+			cCompiler.define "XML_NS"
+			cCompiler.define "XML_DTD"
+			cCompiler.define "HAVE_EXPAT_CONFIG_H"
+
+			cppCompiler.define "XML_STATIC"
+			cppCompiler.define "XML_NS"
+			cppCompiler.define "XML_DTD"
+			cppCompiler.define "HAVE_EXPAT_CONFIG_H"
+		}
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+				 cCompiler.define "XML_EXPORTS"
+				 cppCompiler.define "XML_EXPORTS"
+			}
+		}
+		withType(StaticLibraryBinarySpec) {
+		}
+	}
+}
+task poco { dependsOn "assemble" }
+

XML/samples/build.gradle

@@ -0,0 +1,49 @@
+model {
+	components {
+		data(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'data/src' include '**/*.cpp' }
+				cpp.lib project: ':XML', library: 'XML', linkage: 'shared'				
+				cpp.lib project: ':Foundation', library: 'Foundation', linkage: 'shared'				
+			}
+		}
+		DOMParser(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'DOMParser/src' include '**/*.cpp' }
+				cpp.lib project: ':XML', library: 'XML', linkage: 'shared'				
+				cpp.lib project: ':Foundation', library: 'Foundation', linkage: 'shared'				
+			}
+		}
+		DOMWriter(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'DOMWriter/src' include '**/*.cpp' }
+				cpp.lib project: ':XML', library: 'XML', linkage: 'shared'				
+				cpp.lib project: ':Foundation', library: 'Foundation', linkage: 'shared'				
+			}
+		}
+		PrettyPrint(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'PrettyPrint/src' include '**/*.cpp' }
+				cpp.lib project: ':XML', library: 'XML', linkage: 'shared'				
+				cpp.lib project: ':Foundation', library: 'Foundation', linkage: 'shared'				
+			}
+		}
+//		RoundTrip(NativeExecutableSpec) {
+//			sources {
+//				cpp.source { srcDir 'RoundTrip/src' include '**/*.cpp' }
+//				cpp.lib project: ':XML', library: 'XML', linkage: 'shared'				
+//				cpp.lib project: ':Foundation', library: 'Foundation', linkage: 'shared'				
+//			}
+//		}
+		SAXParser(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'SAXParser/src' include '**/*.cpp' }
+				cpp.lib project: ':XML', library: 'XML', linkage: 'shared'				
+				cpp.lib project: ':Foundation', library: 'Foundation', linkage: 'shared'				
+			}
+		}
+	}
+}
+task samples { dependsOn "assemble" }
+
+

XML/testsuite/build.gradle

@@ -0,0 +1,62 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		TestSuite(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '*Driver.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+					lib project: ':XML', library: 'XML', linkage: 'shared'
+					lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+				}
+			}
+		}
+	}
+	testSuites {
+		XMLTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+    binaries {                                               
+        withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+        }
+	}
+}
+task testsuite { dependsOn "assemble" }

Zip/build.gradle

@@ -0,0 +1,38 @@
+model {
+	components {
+		Zip(NativeLibrarySpec) {
+			sources {
+				rc {
+					source {
+						srcDir '..'
+						include 'DLLVersion.rc'
+					}
+				}
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+					}
+					exportedHeaders {
+						srcDir 'include'
+					}
+					lib project: ':Foundation', library: 'Foundation'
+				}
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			if (toolChain in VisualCpp) {
+				 cppCompiler.define "Zip_EXPORTS"
+			}
+		}
+		withType(StaticLibraryBinarySpec) {
+		}
+	}
+}
+task poco { dependsOn "assemble" }
+
+

Zip/samples/build.gradle

@@ -0,0 +1,36 @@
+model {
+	components {
+		zip(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'zip/src' include '**/*.cpp' }
+				cpp.lib project: ':Zip', library: 'Zip'				
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+		unzip(NativeExecutableSpec) {
+			sources {
+				cpp.source { srcDir 'unzip/src' include '**/*.cpp' }
+				cpp.lib project: ':Zip', library: 'Zip'				
+				cpp.lib project: ':Util', library: 'Util'				
+				cpp.lib project: ':Foundation', library: 'Foundation'				
+			}
+		}
+	}
+	binaries {
+		all {
+		}
+		withType(SharedLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+		}
+		withType(StaticLibraryBinarySpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+		withType(NativeExecutableSpec) {
+			lib project: ':Foundation', library: 'Foundation', linkage: 'static'
+		}
+	}
+}
+task samples { dependsOn "assemble" }
+
+

Zip/testsuite/build.gradle

@@ -0,0 +1,62 @@
+import org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec
+
+model {
+	components {
+		withType(NativeComponentSpec) {
+			binaries.withType(NativeBinarySpec) {
+				if (buildType == buildTypes.debug) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+					}
+				} else
+				if (buildType == buildTypes.release) {
+					if (it instanceof NativeExecutableBinarySpec) {
+						executable.file = toLocalBin(executable.file, targetPlatform)
+					} 
+				}
+			}
+		}
+		TestSuite(NativeLibrarySpec) {
+			sources {
+				cpp {
+					source {
+						srcDir 'src'
+						include '**/*.cpp'
+						exclude '*Driver.cpp'
+					}
+					exportedHeaders {
+						srcDir 'src'
+					}
+					lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+					lib project: ':Zip', library: 'Zip', linkage: 'shared'
+					lib project: ':Foundation', library: 'Foundation', linkage: 'shared'
+				}
+			}
+		}
+	}
+	testSuites {
+		ZipTestSuite(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteSpec) {
+			testing $.components.TestSuite 
+		}
+	}
+    binaries {                                               
+        withType(org.gradle.nativeplatform.test.cppunit.CppUnitTestSuiteBinarySpec) {
+ 			lib project: ':CppUnit', library: 'CppUnit', linkage: 'shared'
+			if (toolChain in VisualCpp) {
+				if (buildType == buildTypes.debug) {
+					cCompiler.args "/MDd"
+					cppCompiler.args "/MDd"
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.args "/MD"
+					cppCompiler.args "/MD"
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			}
+			if (toolChain in Gcc) {
+			}
+        }
+	}
+}
+task testsuite { dependsOn "assemble" }

build.gradle

@@ -0,0 +1,950 @@
+buildscript {
+}
+
+/*
+dependencies {
+	testCompile group: 'org.jvnet.hudson.plugins', name: 'cppunit', version: '1.10'
+}
+*/
+/*
+dependencies {
+	classpath group: 'org.pocoproject', name: 'cppunit-test-suite', version:'1.0.0'
+	classpath group: 'org.pocoproject', name: 'windows-message-compiler', version:'1.0.0'
+}
+*/
+
+apply plugin: 'base' 
+
+def os = org.gradle.internal.os.OperatingSystem.current()
+def String version = file("VERSION").text.replaceAll("[\n\r]", "")
+
+File appendDebugSuffix(File binaryFile) {
+	String name = binaryFile.getName()
+	File parent = binaryFile.getParentFile()
+	int extensionSeparatorIndex = name.lastIndexOf('.')
+	if (extensionSeparatorIndex == -1) {
+		return new File(parent, name + "d")
+	}
+	return new File(parent, name.substring(0, extensionSeparatorIndex) + "d" + name.substring(extensionSeparatorIndex))
+}
+ 
+File appendStaticSuffix(File binaryFile) {
+    def os = org.gradle.internal.os.OperatingSystem.current()
+	if (!os.windows) {
+		return binaryFile
+    }
+    String name = binaryFile.getName()
+    File parent = binaryFile.getParentFile()
+    int extensionSeparatorIndex = name.lastIndexOf('.')
+    if (extensionSeparatorIndex == -1) {
+    	return new File(parent, name + "MT")
+    }
+    return new File(parent, name.substring(0, extensionSeparatorIndex) + "MT" + name.substring(extensionSeparatorIndex))
+}
+File appendSemiStaticSuffix(File binaryFile) {
+	String name = binaryFile.getName()
+	File parent = binaryFile.getParentFile()
+	int extensionSeparatorIndex = name.lastIndexOf('.')
+	if (extensionSeparatorIndex == -1) {
+		return new File(parent, name + "MD")
+	}
+	return new File(parent, name.substring(0, extensionSeparatorIndex) + "MD" + name.substring(extensionSeparatorIndex))
+}
+File prefixByPoco(File binaryFile) {
+	String name = binaryFile.getName()
+	String prefix = ''
+	if (name.startsWith('lib')) {
+		prefix = 'lib'
+		name = name.substring(3)
+	}
+	File parent = binaryFile.getParentFile()
+	return new File(parent, prefix + "Poco" + name);
+}
+File suffixByArch(File binaryFile, Platform platform) {
+	if (!platform.operatingSystem.windows) {
+		return binaryFile
+	}
+	String name = binaryFile.getName()
+	String suffix = ''
+	if (platform.architecture.name == 'x86') {
+		suffix = ''
+	} else
+	if (platform.architecture.name == 'x86-64') {
+		suffix = '64'
+	} else {
+		throw new GradleException("Unknown architecture: " + platform.architecture.name)
+	}
+	int extensionSeparatorIndex = name.lastIndexOf('.')
+	if (extensionSeparatorIndex == -1) {
+		return new File(parent, name + suffix)
+	}
+	File parent = binaryFile.getParentFile()
+	return new File(parent, name.substring(0, extensionSeparatorIndex) + suffix + name.substring(extensionSeparatorIndex));
+}
+File toLocalBin(File binaryFile, Platform platform) {
+	String name = binaryFile.getName()
+	String target
+	if (platform.architecture.name == 'x86') {
+		target = 'bin'
+	} else
+	if (platform.architecture.name == 'x86-64') {
+		target = 'bin64'
+	} else {
+		throw new GradleException("Unknown architecture: " + platform.architecture.name)
+	}
+	File parent = new File(target)
+	return new File(parent, name);
+}
+File toBin(File sharedFile, Platform platform) {
+	File parent = sharedFile.parentFile
+	if (parent.canonicalPath.contains("testsuite"))
+		return sharedFile;
+	if (parent.canonicalPath.contains("sample"))
+		return sharedFile;
+		
+	if (platform.operatingSystem.linux) {
+		return toLib(sharedFile, platform)
+	}
+
+	String name = sharedFile.getName()
+	String target
+	if (platform.architecture.name == 'x86') {
+		target = 'bin'
+	} else
+	if (platform.architecture.name == 'x86-64') {
+		target = 'bin64'
+	} else {
+		throw new GradleException("Unknown architecture: " + platform.architecture.name)
+	}
+	File newParent = new File(rootDir, target)
+	return new File(newParent, name);
+}
+File toLib(File linkFile, Platform platform) {
+	File parent = linkFile.parentFile
+	if (parent.canonicalPath.contains("testsuite"))
+		return linkFile;
+	if (parent.canonicalPath.contains("sample"))
+		return linkFile;
+		
+	// On macOS, it creates a dylib file which is the shared and import library
+	if (platform.operatingSystem.macOsX) {
+		return toBin(linkFile, platform)
+	}
+
+	String name = linkFile.getName()
+	String target
+	if (platform.architecture.name == 'x86') {
+		target = 'lib'
+	} else
+	if (platform.architecture.name == 'x86-64') {
+		target = 'lib64'
+	} else {
+		throw new GradleException("Unknown architecture: " + platform.architecture.name)
+	}
+	File newParent = new File(rootDir, target )
+	return new File(newParent, name);
+}
+File toStatic(File staticFile, Platform platform) {
+	String name = staticFile.getName()
+	String target
+	if (platform.architecture.name == 'x86') {
+		target = 'lib'
+	} else
+	if (platform.architecture.name == 'x86-64') {
+		target = 'lib64'
+	} else {
+		throw new GradleException("Unknown architecture: " + platform.architecture.name)
+	}
+	File parent = new File(rootDir, target)
+	return new File(parent, name);
+}
+File toPDB(File binaryFile) {
+	String name = binaryFile.getName()
+	File parent = binaryFile.getParentFile()
+	int extensionSeparatorIndex = name.lastIndexOf('.')
+	return new File(parent, name.substring(0, extensionSeparatorIndex) + ".pdb")
+}
+
+
+allprojects {
+	buildDir = new File("root")	            // DO NOT REMOVE OR CHANGE to 'build'
+	file('bin').mkdirs()
+	file('bin64').mkdirs()
+	file('lib').mkdirs()
+	file('lib64').mkdirs()
+/*
+	clean.doFirst {
+		file(projectDir, 'bin').delete()
+		file(projectDir, 'bin64').delete() 
+		file(projectDir, 'lib').delete() 
+		file(projectDir, 'lib64').delete() 
+	}
+*/
+}
+subprojects {
+	apply plugin:	'c'
+	apply plugin:	'cpp'
+	apply plugin:	'cppunit-test-suite'
+ 	apply plugin:	'windows-resources'
+	apply plugin:	'windows-messages'
+	
+	buildDir = new File("gradle")	
+	
+
+	model {
+		buildTypes {
+			release
+			debug
+		}
+
+/*
+		toolChains {
+			visualCpp(VisualCpp) {
+				// Specify the installDir if Visual Studio cannot be located
+				// installDir "C:/Apps/Microsoft Visual Studio 10.0"
+			}
+			gcc(Gcc) {
+				// Uncomment to use a GCC install that is not in the PATH
+				// path "/usr/bin/gcc"
+			}
+			clang(Clang)
+		}
+*/
+		platforms {
+			win32 {
+				operatingSystem "windows"
+				architecture 'x86'
+			}
+			win64 {
+				operatingSystem "windows"
+				architecture 'x64'
+			}
+			linux32 {
+				operatingSystem "linux"
+				architecture 'x86'
+			}
+			linux64 {
+				operatingSystem "linux"
+				architecture 'x64'
+			}
+			macos {
+				operatingSystem "macosx"
+				architecture 'x64'
+			}
+		}
+
+		flavors {
+			bundled
+//			unbundled
+		}
+		repositories {
+			libs(PrebuiltLibraries) {
+				WS2_32 {
+					headers.srcDir 'C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/um'
+					binaries.withType(StaticLibraryBinary) {
+						if (targetPlatform.operatingSystem.windows) {
+							staticLibraryFile = file('C:/Program Files (x86)/Windows Kits/10/Lib/10.0.15063.0/um/x86/WS2_32.lib')
+						}
+					}
+				}
+				def opensslHome = new File(rootDir, "openssl/VS_120")
+				def opensslBrewHome = new File('/usr/local/opt/openssl')
+				def opensslLinuxHome = new File('/usr/lib/x86_64-linux-gnu')
+				crypto {
+					headers.srcDir "$opensslHome/include"
+
+					binaries.withType(StaticLibraryBinary) {
+						def libName = "foobar"
+						if (buildType == buildTypes.debug) {
+							if (targetPlatform.name == 'win32') {
+								libName = 'libcrypto.lib'
+								staticLibraryFile = file("$opensslHome/win32/lib/debug/$libName")
+							} else if (targetPlatform.name == 'win64') {
+								libName = 'libcrypto.lib'
+								staticLibraryFile = file("$opensslHome/win64/lib/debug/$libName")
+							} else if (targetPlatform.operatingSystem.macOsX) {
+								libName = 'libcrypto.a'
+								staticLibraryFile = file("$opensslBrewHome/lib/$libName")
+							} else if (targetPlatform.operatingSystem.linux) {
+								libName = 'libcrypto.a'
+								staticLibraryFile = file("$opensslLinuxHome/$libName")
+							}
+						} else
+						if (buildType == buildTypes.release) {
+							if (targetPlatform.name == 'win32') {
+								libName = 'libcrypto.lib'
+								staticLibraryFile = file("$opensslHome/win32/lib/release/$libName")
+							} else if (targetPlatform.name == 'win64') {
+								libName = 'libcrypto.lib'
+								staticLibraryFile = file("$opensslHome/win64/lib/release/$libName")
+							} else if (targetPlatform.operatingSystem.macOsX) {
+								libName = 'libcrypto.a'
+								staticLibraryFile = file("$opensslBrewHome/lib/$libName")
+							} else if (targetPlatform.operatingSystem.linux) {
+								libName = 'libcrypto.a'
+								staticLibraryFile = file("$opensslLinuxHome/$libName")
+							}
+						} else {
+							throw new GradleException("Unknown buildType" + buildType)
+						}
+					}
+					binaries.withType(SharedLibraryBinary) {
+						def dllName
+						def linkName
+						if (buildType == buildTypes.debug) {
+							if (targetPlatform.name == 'win32') {
+								dllName = 'libcrypto.dll'
+								linkName = 'libcrypto.lib'
+								sharedLibraryFile	 = file("$opensslHome/win32/bin/debug/$dllName")
+								sharedLibraryLinkFile = file("$opensslHome/win32/bin/debug/$linkName")
+							} else if (targetPlatform.name == 'win64') {
+								dllName = 'libcrypto.dll'
+								linkName = 'libcrypto.lib'
+								sharedLibraryFile	 = file("$opensslHome/win64/bin/debug/$dllName")
+								sharedLibraryLinkFile = file("$opensslHome/win64/bin/debug/$linkName")
+							} else if (targetPlatform.operatingSystem.macOsX) {
+								dllName = 'libcrypto.dylib'
+								linkName = 'libcrypto.dylib'
+								sharedLibraryFile	 = file("$opensslBrewHome/lib/$dllName")
+								sharedLibraryLinkFile = file("$opensslBrewHome/lib/$linkName")
+							} else if (targetPlatform.operatingSystem.linux) {
+								dllName = 'libcrypto.so'
+								linkName = 'libcrypto.so'
+								sharedLibraryFile	 = file("$opensslLinuxHome/$dllName")
+								sharedLibraryLinkFile = file("$opensslLinuxHome/$linkName")
+							}
+						} else
+						if (buildType == buildTypes.release) {
+							if (targetPlatform.name == 'win32') {
+								dllName = 'libcrypto.dll'
+								linkName = 'libcrypto.lib'
+								sharedLibraryFile	 = file("$opensslHome/win32/bin/release/$dllName")
+								sharedLibraryLinkFile = file("$opensslHome/win32/bin/release/$linkName")
+							} else if (targetPlatform.name == 'win64') {
+								dllName = 'libcrypto.dll'
+								linkName = 'libcrypto.lib'
+								sharedLibraryFile	 = file("$opensslHome/win64/bin/release/$dllName")
+								sharedLibraryLinkFile = file("$opensslHome/win64/bin/release/$linkName")
+							} else if (targetPlatform.operatingSystem.macOsX) {
+								dllName = 'libcrypto.dylib'
+								linkName = 'libcrypto.dylib'
+								sharedLibraryFile	 = file("$opensslBrewHome/lib/$dllName")
+								sharedLibraryLinkFile = file("$opensslBrewHome/lib/$linkName")
+							} else if (targetPlatform.operatingSystem.linux) {
+								dllName = 'libcrypto.so'
+								linkName = 'libcrypto.so'
+								sharedLibraryFile	 = file("$opensslLinuxHome/$dllName")
+								sharedLibraryLinkFile = file("$opensslLinuxHome/$linkName")
+							}
+						} else {
+							throw new GradleException("Unknown buildType" + buildType)
+						}
+					}
+				}
+				ssl {
+					headers.srcDir "$opensslHome/include"
+
+					binaries.withType(StaticLibraryBinary) {
+						def libName
+						if (buildType == buildTypes.debug) {
+							if (targetPlatform.name == 'win32') {
+								libName = 'libssl.lib'
+								staticLibraryFile = file("$opensslHome/win32/lib/debug/$libName")
+							} else if (targetPlatform.name == 'win64') {
+								libName = 'libssl.lib'
+								staticLibraryFile = file("$opensslHome/win64/lib/debug/$libName")
+							} else if (targetPlatform.operatingSystem.macOsX) {
+								libName = 'libssl.a'
+								staticLibraryFile = file("$opensslBrewHome/lib/$libName")
+							} else if (targetPlatform.operatingSystem.linux) {
+								libName = 'libssl.a'
+								staticLibraryFile = file("$opensslLinuxHome/$libName")
+							}
+						} else
+						if (buildType == buildTypes.release) {
+							if (targetPlatform.name == 'win32') {
+								libName = 'libssl.lib'
+								staticLibraryFile = file("$opensslHome/win32/lib/release/$libName")
+							} else if (targetPlatform.name == 'win64') {
+								libName = 'libssl.lib'
+								staticLibraryFile = file("$opensslHome/win64/lib/release/$libName")
+							} else if (targetPlatform.operatingSystem.macOsX) {
+								libName = 'libssl.a'
+								staticLibraryFile = file("$opensslBrewHome/lib/$libName")
+							} else if (targetPlatform.operatingSystem.linux) {
+								libName = 'libssl.a'
+								staticLibraryFile = file("$opensslLinuxHome/$libName")
+							}
+						} else {
+							throw new GradleException("Unknown buildType" + buildType)
+						}
+					}
+					binaries.withType(SharedLibraryBinary) {
+						def dllName
+						def linkName
+						if (buildType == buildTypes.debug) {
+							if (targetPlatform.name == 'win32') {
+								dllName = 'libssl.dll'
+								linkName = 'libssl.lib'
+								sharedLibraryFile	 = file("$opensslHome/win32/bin/debug/$dllName")
+								sharedLibraryLinkFile = file("$opensslHome/win32/bin/debug/$linkName")
+							} else if (targetPlatform.name == 'win64') {
+								dllName = 'libssl.dll'
+								linkName = 'libssl.lib'
+								sharedLibraryFile	 = file("$opensslHome/win64/bin/debug/$dllName")
+								sharedLibraryLinkFile = file("$opensslHome/win64/bin/debug/$linkName")
+							} else if (targetPlatform.operatingSystem.macOsX) {
+								dllName = 'libssl.dylib'
+								linkName = 'libssl.dylib'
+								sharedLibraryFile	 = file("$opensslBrewHome/lib/$dllName")
+								sharedLibraryLinkFile = file("$opensslBrewHome/lib/$linkName")
+							} else if (targetPlatform.operatingSystem.linux) {
+								dllName = 'libssl.so'
+								linkName = 'libssl.so'
+								sharedLibraryFile	 = file("$opensslLinuxHome/$dllName")
+								sharedLibraryLinkFile = file("$opensslLinuxHome/$linkName")
+							}
+						} else if (buildType == buildTypes.release) {
+							if (targetPlatform.name == 'win32') {
+								dllName = 'libssl.dll'
+								linkName = 'libssl.lib'
+								sharedLibraryFile	 = file("$opensslHome/win32/bin/release/$dllName")
+								sharedLibraryLinkFile = file("$opensslHome/win32/bin/release/$linkName")
+							} else if (targetPlatform.name == 'win64') {
+								dllName = 'libssl.dll'
+								linkName = 'libssl.lib'
+								sharedLibraryFile	 = file("$opensslHome/win64/bin/release/$dllName")
+								sharedLibraryLinkFile = file("$opensslHome/win64/bin/release/$linkName")
+							} else if (targetPlatform.operatingSystem.macOsX) {
+								dllName = 'libssl.dylib'
+								linkName = 'libssl.dylib'
+								sharedLibraryFile	 = file("$opensslBrewHome/lib/$dllName")
+								sharedLibraryLinkFile = file("$opensslBrewHome/lib/$linkName")
+							} else if (targetPlatform.operatingSystem.linux) {
+								dllName = 'libssl.so'
+								linkName = 'libssl.so'
+								sharedLibraryFile	 = file("$opensslLinuxHome/$dllName")
+								sharedLibraryLinkFile = file("$opensslLinuxHome/$linkName")
+							}
+						} else {
+							throw new GradleException("Unknown buildType" + buildType)
+						}
+					}
+				}
+			}
+		}
+		components {
+			withType(NativeComponentSpec) {
+				targetPlatform "win32"
+				targetPlatform "win64"
+				targetPlatform "linux32"
+				targetPlatform "linux64"
+				targetPlatform "macos"
+
+				binaries.withType(NativeTestSuiteBinarySpec) {
+					if (buildType == buildTypes.debug) {
+						if (it instanceof NativeExecutableBinarySpec) {
+							executable.file = toLocalBin(appendDebugSuffix(executable.file), targetPlatform)
+						}
+					} else
+					if (buildType == buildTypes.release) {
+						if (it instanceof NativeExecutableBinarySpec) {
+							executable.file = toLocalBin(executable.file, targetPlatform)
+						} 
+					}
+				}
+				binaries.withType(NativeBinarySpec) {
+
+					if (toolChain in Clang) {
+						cppCompiler.args "-std=c++11"
+					}
+					if (buildType == buildTypes.debug) {
+						if (it instanceof SharedLibraryBinarySpec) {
+							sharedLibraryFile	 = toBin(prefixByPoco(appendDebugSuffix(suffixByArch(sharedLibraryFile, targetPlatform))), targetPlatform)
+							sharedLibraryLinkFile = toLib(prefixByPoco(appendDebugSuffix(sharedLibraryLinkFile)), targetPlatform)
+
+							if (targetPlatform.operatingSystem.windows) {
+								// WINDOWS ONLY
+								linker.args "/implib:${sharedLibraryLinkFile}"  // For MSVC only
+								// use the following for MinGW
+								// linker.args "-Wl,--out-implib,${sharedLibraryLinkFile}"
+								// This next part is simply to ensure the directory is created as the compiler (tested on MSVC only) won't create it
+								def binary = it  // Simply to expose the binary in the `doFirst`
+								tasks.withType(LinkSharedLibrary) {
+									doFirst {
+										binary.sharedLibraryLinkFile.parentFile.mkdirs()
+									}
+								}
+							}
+						} else
+						if (it instanceof StaticLibraryBinarySpec) {
+							staticLibraryFile = toStatic(prefixByPoco(appendDebugSuffix(appendStaticSuffix(staticLibraryFile))), targetPlatform)
+							def binary = it
+							tasks.withType(CreateStaticLibrary) {
+								doFirst {
+									binary.staticLibraryFile.parentFile.mkdirs()
+								}
+							}
+						} else
+						if (it instanceof SemiStaticLibraryBinarySpec) {
+							semiStaticLibraryFile = toStatic(prefixByPoco(appendDebugSuffix(appendSemiStaticSuffix(semiStaticLibraryFile))), targetPlatform)
+						} else
+						if (it instanceof NativeExecutableBinarySpec) {
+							executable.file = toBin(appendDebugSuffix(executable.file), targetPlatform)
+						} else {
+							throw new GradleException("Unknown native library binary")
+						}
+					} else
+					if (buildType == buildTypes.release) {
+						if (it instanceof SharedLibraryBinarySpec) {
+							sharedLibraryFile = toBin(prefixByPoco(suffixByArch(sharedLibraryFile, targetPlatform)), targetPlatform)
+							sharedLibraryLinkFile = toLib(prefixByPoco(sharedLibraryLinkFile), targetPlatform)
+
+							if (targetPlatform.operatingSystem.windows) {
+								// WINDOWS ONLY
+								linker.args "/implib:${sharedLibraryLinkFile}"  // For MSVC only
+								// use the following for MinGW
+								// linker.args "-Wl,--out-implib,${sharedLibraryLinkFile}"
+								// This next part is simply to ensure the directory is created as the compiler (tested on MSVC only) won't create it
+								def binary = it  // Simply to expose the binary in the `doFirst`
+								tasks.withType(LinkSharedLibrary) {
+									doFirst {
+										binary.sharedLibraryLinkFile.parentFile.mkdirs()
+									}
+								}
+							}
+						} else
+						if (it instanceof StaticLibraryBinarySpec) {
+							staticLibraryFile = toStatic(prefixByPoco(appendStaticSuffix(staticLibraryFile)), targetPlatform)
+							def binary = it
+							tasks.withType(CreateStaticLibrary) {
+								doFirst {
+									binary.staticLibraryFile.parentFile.mkdirs()
+								}
+							}
+						} else
+						if (it instanceof SemiStaticLibraryBinarySpec) {
+							semiStaticLibraryFile = toStatic(prefixByPoco(appendSemiStaticSuffix(semiStaticLibraryFile)), targetPlatform)
+							def binary = it
+							tasks.withType(CreateSemiStaticLibrary) {
+								doFirst {
+									binary.semiStaticLibraryFile.parentFile.mkdirs()
+								}
+							}
+						} else
+						if (it instanceof NativeExecutableBinarySpec) {
+							executable.file = toBin(executable.file, targetPlatform)
+						} else {
+							throw new GradleException("Unknown native library binary")
+						} 
+					} else {
+						throw new GradleException("Unknown buildType" + buildType)
+					}
+				}
+			}
+		}
+
+
+		binaries {
+			all {
+				if (flavor != flavors.bundled) {
+					cCompiler.define 'POCO_UNBUNDLED'
+					cppCompiler.define 'POCO_UNBUNDLED'
+				}
+				if (buildType == buildTypes.debug) {
+					cCompiler.define '_DEBUG'
+					cppCompiler.define '_DEBUG'
+				} else 
+				if (buildType == buildTypes.release) {
+					cCompiler.define 'NDEBUG'
+					cppCompiler.define 'NDEBUG'
+				} else {
+					throw new GradleException("Unknown buildType" + buildType)
+				}
+			
+				if (toolChain in Gcc) {
+					cppCompiler.define "_XOPEN_SOURCE=600"
+					cppCompiler.define "_REENTRANT"
+					cppCompiler.define "_THREAD_SAFE"
+					cppCompiler.define "_FILE_OFFSET_BITS=64"
+					cppCompiler.define "_LARGEFILE64_SOURCE"
+					cppCompiler.define "POCO_HAVE_FD_EPOLL"
+					cppCompiler.define "POCO_HAVE_ADDRINFO"
+					cppCompiler.define "POCO_HAVE_LIBRESOLV"
+					cppCompiler.args "-std=c++11"
+					cppCompiler.args "-fPIC"
+
+					linker.args "-lrt"
+					linker.args "-ldl"
+					linker.args "-lpthread"
+				}
+				if (toolChain in VisualCpp) {
+					if (targetPlatform == platforms.win64) {
+						linker.args '/MACHINE:X64'
+					} else {
+						linker.args '/MACHINE:X86'
+					}
+					if (buildType == buildTypes.debug) {
+						cCompiler.args '/Zi'
+						cppCompiler.args '/Zi'
+						linker.args '/DEBUG'
+					}
+					cCompiler.args '/RTC1'
+					cCompiler.args '/FS'
+					cCompiler.args '/Zc:wchar_t'
+					cCompiler.args '/Zc:inline'
+					cCompiler.args '/Zc:forScope'
+					cCompiler.args '/GR'
+					cCompiler.args '/GF'
+					cCompiler.args '/EHsc'
+					cCompiler.args '/bigobj'
+					cCompiler.define 'WIN32'
+					cCompiler.define '_WIN32'
+					cCompiler.define '_WINDOWS'
+					cCompiler.define '_MBCS'
+
+					cppCompiler.args '/RTC1'
+					cppCompiler.args '/FS'
+					cppCompiler.args '/Zc:wchar_t'
+					cppCompiler.args '/Zc:inline'
+					cppCompiler.args '/Zc:forScope'
+					cppCompiler.args '/GR'
+					cppCompiler.args '/GF'
+					cppCompiler.args '/EHsc'
+					cppCompiler.args '/bigobj'
+					cppCompiler.define 'WIN32'
+					cppCompiler.define '_WIN32'
+					cppCompiler.define '_WINDOWS'
+					cppCompiler.define '_MBCS'
+					
+					linker.args 'kernel32.lib'
+					linker.args 'user32.lib'
+					linker.args 'gdi32.lib'
+					linker.args 'winspool.lib'
+					linker.args 'comdlg32.lib'
+					linker.args 'advapi32.lib'
+					linker.args 'shell32.lib'
+					linker.args 'ole32.lib'
+					linker.args 'oleaut32.lib'
+					linker.args 'uuid.lib'
+					
+					linker.args '/NXCOMPAT' 
+					linker.args '/OPT:REF' 
+					linker.args '/INCREMENTAL:NO' 
+//					linker.args '/MANIFEST' 
+//					linker.args '/MANIFESTUAC:"level='asInvoker' uiAccess='false'"' 
+					linker.args '/OPT:ICF' 
+					linker.args '/NOLOGO' 
+					linker.args '/SUBSYSTEM:CONSOLE'
+				}
+			}
+			withType(SharedLibraryBinarySpec) {
+				if (toolChain in VisualCpp) {
+					cCompiler.define   '_USRDLL'
+					cCompiler.define   '_WINDLL'
+					cppCompiler.define '_USRDLL'
+					cppCompiler.define '_WINDLL'
+					if (buildType == buildTypes.debug) {
+						cCompiler.args "/MDd"
+						cppCompiler.args "/MDd"
+					} else 
+					if (buildType == buildTypes.release) {
+						cCompiler.args "/MD"
+						cppCompiler.args "/MD"
+					} else {
+						throw new GradleException("Unknown buildType" + buildType)
+					}
+				}
+				if (toolChain in Gcc) {
+					linker.args "-Wl,-rpath,$rootDir/lib64"   //FIXME
+				}
+			}
+			withType(StaticLibraryBinarySpec) {
+				if (toolChain in VisualCpp) {
+					cCompiler.define   '_LIB'
+					cCompiler.define   'POCO_STATIC'
+					cppCompiler.define '_LIB'
+					cppCompiler.define 'POCO_STATIC'
+					if (buildType == buildTypes.debug) {
+						cCompiler.args "/MTd"
+						cCompiler.args "/Fd" + toStatic(toPDB(staticLibraryFile), targetPlatform)
+						cppCompiler.args "/MTd"
+						cppCompiler.args "/Fd" + toStatic(toPDB(staticLibraryFile), targetPlatform)
+					} else 
+					if (buildType == buildTypes.release) {
+						cCompiler.args "/MT"
+						cppCompiler.args "/MT"
+					} else {
+						throw new GradleException("Unknown buildType" + buildType)
+					}
+				}
+				if (toolChain in Gcc) {
+				}
+			}
+			withType(SemiStaticLibraryBinarySpec) {
+				if (toolChain in VisualCpp) {
+					cCompiler.define   '_LIB'
+					cCompiler.define   'POCO_STATIC'
+					cppCompiler.define '_LIB'
+					cppCompiler.define 'POCO_STATIC'
+					if (buildType == buildTypes.debug) {
+						cCompiler.args "/MDd"
+						cCompiler.args "/Fd" + toStatic(toPDB(semiStaticLibraryFile), targetPlatform)
+						cppCompiler.args "/MDd"
+						cppCompiler.args "/Fd" + toStatic(toPDB(semiStaticLibraryFile), targetPlatform)
+					} else 
+					if (buildType == buildTypes.release) {
+						cCompiler.args "/MD"
+						cppCompiler.args "/MD"
+					} else {
+						throw new GradleException("Unknown buildType" + buildType)
+					}
+				}
+				if (toolChain in Gcc) {
+				}
+			}
+			withType(NativeExecutableBinarySpec) {
+				if (toolChain in VisualCpp) {
+					if (buildType == buildTypes.debug) {
+						cCompiler.args "/MDd"
+						cppCompiler.args "/MDd"
+					} else 
+					if (buildType == buildTypes.release) {
+						cCompiler.args "/MD"
+						cppCompiler.args "/MD"
+					} else {
+						throw new GradleException("Unknown buildType" + buildType)
+					}
+				}
+				if (toolChain in Gcc) {
+				}
+			}
+		}
+	}
+	tasks.withType(RunTestExecutable) {
+		args test
+	}
+	task showCompilerOutput {
+	   doLast {
+	      FileTree tree = fileTree('gradle').include('**/output.txt')
+	      // Iterate over the contents of a tree
+	      tree.each {File file ->
+	          println 'Content of file ' + file + ':\n'
+	          println file.text
+	      }
+	   }
+	}
+/*
+  	tasks.withType(CppCompile) {
+		finalizedBy showCompilerOutput
+	}
+*/
+}
+task pocos() {
+		def Set<Task> tts = project.getTasksByName('poco', true)
+		setDependsOn(tts)
+}
+task PocoDocIni {
+    def file = new File("$rootDir/PocoDoc/PocoDoc.ini")
+    file.createNewFile()
+    file.text = """
+PocoBuild=$rootDir
+PocoBase=$rootDir
+PocoDoc.output=releases/poco-${version}-all-doc
+PocoDoc.version=${version}-all
+"""
+	if (os.windows) {
+		file.text += """
+Includes=-I${postgres32Home}/include,-I${mysql32Home}/include,-ICppParser/include,-ICppUnit/include,-ICrypto/include,-IData/include,-IData/MySQL/include,-IData/ODBC/include,-IData/PostgreSQL/include,-IData/SQLite/include, -IData/SQLite/src,-IFoundation/include,-IJSON/include,-IMongoDB/include,-INet/include,-INetSSL_OpenSSL/include,-INetSSL_Win/include,-IRedis/include,-IUtil/include,-IXML/include,-IZip/include,-ISevenZip/include,-IPDF/include
+VC=${VCHome}
+WDK=${WDKHome}
+"""
+	} else {
+	}
+}
+task pocoDoc(type: Exec) {
+	dependsOn ':PocoDoc::assemble'
+	dependsOn PocoDocIni
+	if (os.windows) {
+		environment "Path", "$rootDir\\bin;$Path"
+		executable "PocoDoc/bin/PocoDoc.exe"
+		args "/config=$rootDir/PocoDoc/cfg/mkdoc-poco.xml"
+		args "/config=$rootDir/PocoDoc/PocoDoc.ini"
+	} 
+	if (os.linux) {
+		environment "LD_LIBRARY_PATH", "$rootDir/lib64:$LD_LIBRARY_PATH"
+		executable "PocoDoc/bin64/PocoDoc"
+		args "-config=$rootDir/PocoDoc/cfg/mkdoc-poco.xml"
+		args "-config=$rootDir/PocoDoc/PocoDoc.ini"
+	}
+	if (os.macOsX) {
+		//FIXME environment "LD_LIBRARY_PATH", "$rootDir/bin:$LD_LIBRARY_PATH"
+		args "-config=$rootDir/PocoDoc/cfg/mkdoc-poco.xml"
+		args "-config=$rootDir/PocoDoc/PocoDoc.ini"
+	}
+//	inputs.files(tasks.getByPath(':production').outputs.files)
+//	inputs.files(executable)
+	inputs.files(fileTree("doc").filter { it.isFile() })
+	inputs.files(new File("$rootDir/PocoDoc/cfg/mkdoc-poco.xml"))
+	outputs.files(new File("releases/$version-all-doc/index.html"))
+}
+task zipDoc(type: Zip) {
+	from "releases/poco-${version}-all-doc/"
+	include '*'
+	include '*/*'
+	archiveName "poco-${version}-all-doc.zip"
+	destinationDir(file('releases'))
+	inputs.files(new File("releases/$version-all-doc/index.html"))
+	outputs.files(new File("releases/poco-${version}-all-doc.zip"))
+//	dependsOn pocoDoc
+}
+
+def candle(VSYEAR, VERSION, target, os) {
+	return tasks.create("Candle-${VSYEAR}-${VERSION}-${target}", Exec) {
+		dependsOn ':pocos'
+		dependsOn ':pocoDoc'
+		executable "${WiXHome}/bin/Candle.exe"
+		workingDir "packaging/Windows/WiX"
+		args "-arch", "${target}"
+		args "-dVSYEAR=${VSYEAR}"
+		args "-dVERSION=${VERSION}"
+		args "-dPOCO=${rootDir}"
+		args "-dPlatform=${target}"
+		args "-ext", "${WiXHome}/bin/WixUIExtension.dll"
+		args "-out", "${VSYEAR}/${VSYEAR}-Poco-$VERSION-${target}.wixobj"
+		args "Poco-${VERSION}.wxs"
+		inputs.files(new File(workingDir, "Poco-${VERSION}.wxs"))
+//			inputs.files(tasks.getByPath(':poco').outputs.files)
+		outputs.files(new File(workingDir,"${VSYEAR}/${VSYEAR}-Poco-$VERSION-${target}.wixobj"))
+		onlyIf(new Spec<Exec>() {
+			boolean isSatisfiedBy(Exec task) {
+				   return os.windows;
+			}
+		});
+	}
+}
+def light(VSYEAR, VERSION, target, os) {
+	return tasks.create("Light-${VSYEAR}-${VERSION}-${target}", Exec) {
+		dependsOn candle(VSYEAR, VERSION, target, os)
+		executable "${WiXHome}/bin/Light.exe"
+		workingDir "packaging/Windows/WiX"
+		args "-cultures:null"
+		args "-ext", "${WiXHome}/bin/WixUIExtension.dll"
+		args "-out"
+		args "${VSYEAR}/${VSYEAR}-Poco-$VERSION-${target}.msi"
+		args "${VSYEAR}/${VSYEAR}-Poco-$VERSION-${target}.wixobj"
+		inputs.files(new File(workingDir, "${VSYEAR}/${VSYEAR}-Poco-$VERSION-${target}.wixobj"))
+		outputs.files(new File(workingDir, "${VSYEAR}/${VSYEAR}-Poco-$VERSION-${target}.msi"))
+		onlyIf(new Spec<Exec>() {
+			boolean isSatisfiedBy(Exec task) {
+				   return os.windows;
+			}
+		});
+	}
+}
+task wix() {
+	dependsOn 		light('VS2015', version, 'x86', os)
+	dependsOn 		light('VS2015', version, 'x64', os)
+	onlyIf(new Spec<Task>() {
+		boolean isSatisfiedBy(Task task) {
+			   return os.windows;
+		}
+	});
+}
+task nuget(type: Exec) {
+	dependsOn ':pocos'
+	executable "${NuGetHome}/NuGet.exe"
+	workingDir "packaging/Windows/NuGet"
+	args "pack"
+	args "-BasePath", "$rootDir"
+	args "-Version", version
+	args "-Symbols"
+	args "-NonInteractive"
+	args "Pocoproject.Poco.vs140.nuspec"
+	inputs.files(new File(workingDir, "Pocoproject.Poco.vs140.nuspec"))
+//	inputs.files(tasks.getByPath(':poco').outputs.files)
+	outputs.files(new File(workingDir,"Pocoproject.Poco.vs140.${version}.nupkg"))
+	onlyIf(new Spec<Exec>() {
+		boolean isSatisfiedBy(Exec task) {
+			   return os.windows;
+		}
+	});
+}
+
+task packaging() {
+	if (os.windows) {
+		dependsOn nuget
+		dependsOn wix
+	}
+}
+task all() {
+//doLast {
+//        def files =  fileTree("src").filter { it.isFile() }.files.name;
+//        println files;
+//        println "------------------------------------"
+//        println project.tasks.matching { Task task -> task.name.contains("assemble") }
+//        println "------------------------------------"
+//		def Set<Project> projects = project.subprojects
+//		println projects
+//        println "------------------------------------"
+//		def Set<Task> tts = project.getTasksByName('poco', true)
+//		println tts
+//		setDependsOn(tts)
+//		println project.subprojects.tasks.matching { Task task -> task.name.contains("poco") }
+//        println "------------------------------------"
+//        def c = subprojects.tasks.findAll { it.findByName(":poco") }
+//		println c
+
+//        CppCompile task = tasks.getByPath(':compileHelloSharedLibraryHelloCpp');
+//        println task;
+/*
+        FileCollection incs = task.includes;
+        incs.each { dir -> fileTree(dir).files.each { file -> inputs.files(file) }};
+        inputs.files.each { file -> println file.path }
+*/
+//}
+}
+	def get() {
+		def foo = subprojects.tasks.findAll { it.name.contains('poco') }
+		return foo
+	}
+task includes() {
+	doLast {
+		TaskContainer tc;
+//		Task t = tasks.getByPath(':poco');
+//		TaskDependency td = t.taskDependencies;
+//		td.values.each { task -> println task }
+		def ts = subprojects.tasks //.matching { task -> task.name.contains("poco") }
+//		println ts.each { it.matching { task -> task.name.contains("poco") } }
+		def foo = binaries.findAll { it.buildable }
+		println foo
+/*
+		def compileTasks = tasks.withType(CppCompile).matching { Task task -> 
+				String path = task.path;
+				String name = task.name;
+				name.contains("Shared") && name.contains("Release") && name.contains("Win32") && !path.contains("test") && !path.contains("sample")
+		}
+		println compileTasks
+*/
+	}
+}
+/*
+    tasks { t ->
+        $.components.main.binaries.each { binary ->
+            def stripTask = binary.tasks.taskName("strip")
+            t.create(stripTask) {
+                dependsOn binary.tasks.link
+                doFirst {
+                    if (binary.toolChain in Gcc) {
+                        ["strip", binary.tasks.link.outputFile].execute().waitForOrKill(1000)
+                    }
+                }
+            }
+            binary.tasks.build.dependsOn stripTask
+        }
+    }
+*/
+
+
+
+

gradle.properties

@@ -0,0 +1,33 @@
+# https://cdn.mysql.com//Downloads/MySQL-5.7/mysql-5.7.19-win32.zip
+mysql32Home=C:/mysql-5.6.37-win32
+
+
+# https://cdn.mysql.com//Downloads/MySQL-5.7/mysql-5.7.19-winx64.zip
+mysql64Home=C:/mysql-5.6.37-winx64
+
+
+# https://get.enterprisedb.com/postgresql/postgresql-9.6.3-2-windows-binaries.zip
+postgres32Home=C:/postgresql-9.6.3-2-win32/pgsql
+
+
+# https://get.enterprisedb.com/postgresql/postgresql-9.6.3-2-windows-x64-binaries.zip
+postgres64Home=C:/postgresql-9.6.3-2-win64/pgsql
+
+
+# Windows Development Kit
+WDKHome=C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0
+
+# VisualStudio 2015
+VCHome=C:/Program Files (x86)/Microsoft Visual Studio 14.0/VC
+
+
+# https://github.com/wixtoolset/wix3/releases/download/wix311rtm/wix311.exe
+WiXHome=C:/Progra~2/WIXTOO~1.11
+
+
+# https://dist.nuget.org/win-x86-commandline/v4.3.0/nuget.exe
+NuGetHome=C:/Program Files (x86)/NuGet
+
+
+test=-print
+LD_LIBRARY_PATH=

settings.gradle

@@ -0,0 +1,71 @@
+def os = org.gradle.internal.os.OperatingSystem.current()
+rootProject.name = 'Poco'
+
+include ':CppUnit'
+include ':Foundation'
+include ':XML'
+include ':JSON'
+include ':Util'
+include ':Net'
+include ':Crypto'
+include ':NetSSL_OpenSSL'
+if (os.windows) {
+	include ':NetSSL_Win'
+}
+include ':Data'
+if (os.windows) {
+	include ':Data:ODBC'
+	include ':Data:SQLite'
+	include ':Data:MySQL'
+	include ':Data:PostgreSQL'
+}
+include ':Zip'
+include ':PageCompiler'
+include ':PageCompiler:File2Page'
+include ':PDF'
+include ':CppParser'
+include ':MongoDB'
+include ':Redis'
+include ':PocoDoc'
+include ':ProGen'
+
+include ':Foundation:testsuite'
+include ':XML:testsuite'
+include ':JSON:testsuite'
+include ':Util:testsuite'
+include ':Net:testsuite'
+include ':Crypto:testsuite'
+include ':NetSSL_OpenSSL:testsuite'
+if (os.windows) {
+	include ':NetSSL_Win:testsuite'
+}
+include ':Data:testsuite'
+if (os.windows) {
+	include ':Data:ODBC:testsuite'
+	include ':Data:SQLite:testsuite'
+	include ':Data:MySQL:testsuite'
+	include ':Data:PostgreSQL:testsuite'
+}
+//include ':MongoDB:testsuite'
+include ':Redis:testsuite'
+include ':CppParser:testsuite'
+include ':Zip:testsuite'
+
+include ':Foundation:samples'
+if (os.windows) {
+	include ':Data:samples'
+}
+include ':NetSSL_OpenSSL:samples'
+if (os.windows) {
+	include ':NetSSL_Win:samples'
+}
+include ':JSON:samples'
+include ':MongoDB:samples'
+include ':Net:samples'
+include ':PageCompiler:samples'
+include ':PDF:samples'
+include ':Util:samples'
+include ':XML:samples'
+include ':SevenZip:samples'
+include ':Zip:samples'
+