Merge pull request #1970 from Kampbell/poco-1.8.0

Poco 1.8.0

.gitignore

@@ -16,6 +16,21 @@
 *.vsp
 *.psess
 
+# Gradle #
+##########
+.gradle/
+gradle/
+
+# NuGet #
+#########
+*.nupkg
+
+# WiX #
+#######
+*.msi
+*.wixobj
+*.wixpdb
+
 # 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

.travis.yml

@@ -85,19 +85,32 @@ matrix:
     #    - export POCO_BASE=`pwd`
     #    - sudo -E build/script/runtests.sh
 
+    # build documentation and release
+    - env:    TEST_NAME="documentation & release"
+      compiler: gcc
+      script:
+        - $CXX --version
+        - . env.sh && mkdoc all && mkrel all
+        - find releases/poco*-all
+        - find releases/poco*-all-doc
+        
     # QA jobs for code analytics and metrics
     # static code analysis with cppcheck (we can add --enable=all later)
     - env:    TEST_NAME="cppcheck"
       script: cppcheck --force --quiet --inline-suppr -j2 -iData/SQLite/src/sqlite3.c .
+
     # search for TODO within source tree
     - env:    TEST_NAME="TODO"
       script: grep -r TODO *
+ 
     # search for FIXME within source tree
     - env:    TEST_NAME="FIXME"
       script: grep -r FIXME *
+ 
     # search for HACK within source tree
     - env:    TEST_NAME="HACK"
       script: grep -r HACK *
+ 
     # some statistics about the code base
     - env:    TEST_NAME="sloccount"
       script: sloccount .

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/include/Poco/Environment.h

@@ -100,6 +100,24 @@ public:
 		///    - Dx mark development releases,
 		///    - Ax mark alpha releases, and
 		///    - Bx mark beta releases.
+
+	static Poco::Int32 os();
+		/// Return the operating system as defined
+		/// in the include Foundation/Platform.h (POCO_OS)
+
+	static Poco::Int32 cpu();
+		/// Return the underlying cpu that runs this operating system
+		/// as defined in Foundation/Platform (POCO_ARCH)
+
+	static bool osFamilyUnix();
+		/// Return true if the operating system belongs to the Linux family
+
+	static bool osFamilyWindows();
+		/// Return true if the operating system belongs to the Windows family
+
+	static bool osFamilyVms();
+		/// Return true if the operating system belongs to the VMS family
+
 };
 
 

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/src/Environment.cpp

@@ -24,15 +24,13 @@
 #include "Environment_VX.cpp"
 #elif defined(POCO_OS_FAMILY_UNIX)
 #include "Environment_UNIX.cpp"
-#elif defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+#elif defined(POCO_OS_FAMILY_WINDOWS)
 #if defined(_WIN32_WCE)
 #include "Environment_WINCE.cpp"
 #else
-#include "Environment_WIN32U.cpp"
-#endif
-#elif defined(POCO_OS_FAMILY_WINDOWS)
 #include "Environment_WIN32.cpp"
 #endif
+#endif
 
 
 namespace Poco {
@@ -128,5 +126,41 @@ Poco::UInt32 Environment::libraryVersion()
 	return POCO_VERSION;
 }
 
+Poco::Int32 Environment::os()
+{
+	return POCO_OS;
+}
+
+Poco::Int32 Environment::cpu()
+{
+	return POCO_ARCH;
+}
+
+bool Environment::osFamilyUnix()
+{
+#if defined(POCO_OS_FAMILY_UNIX)
+	return true;
+#else
+	return false;
+#endif
+}
+
+bool Environment::osFamilyWindows()
+{
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	return true;
+#else
+	return false;
+#endif
+}
+
+bool Environment::osFamilyVms()
+{
+#if defined(POCO_OS_FAMILY_VMS)
+	return true;
+#else
+	return false;
+#endif
+}
 
 } // namespace Poco

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) {
+			}
+		}
+	}
+}
+
+

PocoDoc/cfg/mkdoc-poco.xml

@@ -13,6 +13,13 @@
 				expat*.h,
 				zconf.h,
 				zlib.h,
+				Alignment.h,
+				QName.h,
+				CppUnitException.h,
+				Constants.h,
+				inffast.h,
+				PDF/include/*.h,
+				CppParser/include/*.h
 			</exclude>
 		</files>
 		<pages>
@@ -28,21 +35,41 @@
 			${PocoBuild}/*/doc/images
 		</resources>
 		<compiler>
-			<exec>clang++</exec>
-			<options>
-				${Includes},
-				-I/usr/local/mysql/include,
-				-I/usr/include/mysql,
-				-D_DEBUG,
-				-E,
-				-C,
-				-DPOCO_NO_GCC_API_ATTRIBUTE,
-				-xc++
-				-std=c++11,
-				-stdlib=libc++
-			</options>
-			<path></path>
-			<usePipe>true</usePipe>
+			<windows>
+				<exec>cl.exe</exec>
+				<options>
+					${Includes},
+					/I${PocoBase}/openssl/include
+					/I${VC}/include,
+					/I${WDK}/shared
+					/I${WDK}/um
+					/I${WDK}/ucrt
+					/nologo,
+					/D_DEBUG,
+					/E,
+					/C,
+					/DPOCO_NO_GCC_API_ATTRIBUTE
+					/DPOCO_NO_WINDOWS_H
+				</options>
+				<path>${VC}/bin</path>
+				<usePipe>true</usePipe>
+			</windows>
+			<unix>
+				<exec>${CXX} ${CXXFLAGS}</exec>
+				<options>
+					${Includes},
+					-I/usr/local/mysql/include,
+					-I/usr/include/mysql,
+					-I/usr/include/postgresql,
+					-D_DEBUG,
+					-E,
+					-C,
+					-DPOCO_NO_GCC_API_ATTRIBUTE
+					-DPOCO_NO_WINDOWS_H
+				</options>
+				<path></path>
+				<usePipe>true</usePipe>
+			</unix>
 		</compiler>
 		<language>EN</language>
 		<charset>utf-8</charset>

PocoDoc/cfg/mkdocumentation.xml

@@ -13,7 +13,9 @@
 				expat*.h,
 				zconf.h,
 				zlib.h,
-				${PocoBuild}/Util/include/Poco/Util/Units.h
+				XMLStreamParser.h,
+				CppUnitException.h,
+				RepeatedTest.h,
 			</exclude>
 		</files>
 		<pages>
@@ -29,15 +31,23 @@
 			${PocoBuild}/*/doc/images
 		</resources>
 		<compiler>
-			<exec>g++</exec>
+			<exec>C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\cl.exe</exec>
 			<options>
 				${Includes},
 				-I/usr/local/mysql/include,
 				-I/usr/include/mysql,
+				-I/usr/include/postgresql,
+				/I${PocoBase}/openssl/include
+				/IC:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\include,
+				/IC:\Program Files (x86)\Windows Kits\8.1\Include\shared,
+				/IC:\Program Files (x86)\Windows Kits\8.1\Include\um,
+				/IC:\Program Files (x86)\Windows Kits\10\Include\10.0.15063.0\ucrt,
+				/nologo,
 				-D_DEBUG,
 				-E,
 				-C,
 				-DPOCO_NO_GCC_API_ATTRIBUTE
+				-DPOCO_NO_WINDOWS_H
 			</options>
 			<path></path>
 			<usePipe>true</usePipe>
@@ -94,7 +104,7 @@
 		<loggers>
 			<root>
 				<channel>c1</channel>
-				<level>warning</level>
+				<level>information</level>
 			</root>
 		</loggers>
 		<channels>

PocoDoc/src/PocoDoc.cpp

@@ -60,6 +60,7 @@ using Poco::Util::OptionCallback;
 using Poco::Util::HelpFormatter;
 using Poco::Util::AbstractConfiguration;
 
+static std::string osName = Environment::osName();
 
 class Preprocessor
 {
@@ -219,11 +220,16 @@ protected:
 	{
 		Path pp(file);
 		pp.setExtension("i");
+		std::string comp = "PocoDoc.compiler";
+		if (Environment::osFamilyWindows())
+			comp += ".windows";
+		else
+			comp += ".unix";
+		std::string exec = config().getString(comp + ".exec");
+		std::string opts = config().getString(comp + ".options");
+		std::string path = config().getString(comp + ".path", "");
+		bool usePipe = config().getBool(comp + ".usePipe", false);
 
-		std::string exec = config().getString("PocoDoc.compiler.exec");
-		std::string opts = config().getString("PocoDoc.compiler.options");
-		std::string path = config().getString("PocoDoc.compiler.path", "");
-		bool usePipe = config().getBool("PocoDoc.compiler.usePipe", false);
 		std::string popts;
 		for (std::string::const_iterator it = opts.begin(); it != opts.end(); ++it)
 		{

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=

packaging/Boost License.rtf

@@ -0,0 +1,34 @@
+{\rtf1\ansi\deff0{\fonttbl{\f0\fnil\fcharset0 Courier New;}}
+{\*\generator Msftedit 5.41.21.2510;}\viewkind4\uc1\pard\lang1036\f0\fs22 Boost Software License - Version 1.0 - August 17th, 2003\par
+\par
+Permission is hereby granted, free of charge, to any person or organization\par
+obtaining a copy of the software and accompanying documentation covered by\par
+this license (the "Software") to use, reproduce, display, distribute,\par
+execute, and transmit the Software, and to prepare derivative works of the\par
+Software, and to permit third-parties to whom the Software is furnished to\par
+do so, all subject to the following:\par
+\par
+The copyright notices in the Software and this entire statement, including\par
+the above license grant, this restriction and the following disclaimer,\par
+must be included in all copies of the Software, in whole or in part, and\par
+all derivative works of the Software, unless such copies or derivative\par
+works are solely in the form of machine-executable object code generated by\par
+a source language processor.\par
+\par
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\par
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\par
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT\par
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE\par
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,\par
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\par
+DEALINGS IN THE SOFTWARE.\par
+\par
+---------------------------------------------------------------------------\par
+Note:\par
+Individual files contain the following tag instead of the full license text.\par
+\par
+	SPDX-License-Identifier:	BSL-1.0\par
+\par
+This enables machine processing of license information based on the SPDX\par
+License Identifiers that are here available: http://spdx.org/licenses/\par
+}

packaging/README.md

@@ -0,0 +1,111 @@
+POCO C++ Distribution
+=====================
+
+This repository contains packaged Poco releases for various platforms and
+successive versions of Poco starting from release Poco-1.6.1.
+ 
+CHANGELOG contains all changes for the following releases
+
+- Release 1.7.8p4 (2017-08-11)
+- Release 1.7.8p3 (2017-06-22)
+- Release 1.7.8p2 (2017-04-18)
+- Release 1.7.7 (2016-12-31)
+- Release 1.7.6 (2016-10-18)
+- Release 1.7.5 (2016-08-29)
+- Release 1.7.4 (2016-07-20)
+- Release 1.7.3 (2016-05-02)
+- Release 1.7.2 (2016-03-21)
+- Release 1.7.1 (2016-03-14)
+- Release 1.7.0 (2016-03-07)
+- Release 1.6.1 (2015-08-03)
+- Release 1.6.0 (2014-12-22)
+- Release 1.5.4 (2014-10-14)
+- Release 1.5.3 (2014-06-30)
+- Release 1.5.2 (2013-09-16)
+- Release 1.5.1 (2013-01-11)
+- Release 1.5.0 (2012-10-14)
+- Release 1.4.7p1 (2014-11-25)
+- Release 1.4.7 (2014-10-06)
+- Release 1.4.6p4 (2014-04-18)
+- Release 1.4.6p3 (2014-04-02)
+- Release 1.4.6p2 (2013-09-16)
+- Release 1.4.6p1 (2013-03-06)
+- Release 1.4.6 (2013-01-10)
+- Release 1.4.5 (2012-11-19)
+- Release 1.4.4 (2012-09-03)
+- Release 1.4.3p1 (2012-01-23)
+- Release 1.4.3 (2012-01-16)
+- Release 1.4.2p1 (2011-09-24)
+- Release 1.4.2 (2011-08-28)
+- Release 1.4.1p1 (2011-02-08)
+- Release 1.4.1 (2011-01-29)
+- Release 1.4.0 (2010-12-14)
+- Release 1.3.6p2 (2010-01-15)
+- Release 1.3.6p1 (2009-12-21)
+- Release 1.3.6 (2009-11-24)
+- Release 1.3.5 (2009-05-11)
+- Release 1.3.4 (2009-04-21)
+- Release 1.3.3p1 (2008-10-09)
+- Release 1.3.3 (2008-10-07)
+- Release 1.3.2 (2008-02-04)
+- Release 1.3.1 (2007-08-08)
+- Release 1.3.0 (2007-05-07)
+- Release 1.2.9 (2007-02-26)
+- Release 1.2.8 (2007-01-04)
+- Release 1.2.7 (2006-12-07)
+- Release 1.2.6 (2006-11-19)
+- Release 1.2.5 (2006-10-23)
+- Release 1.2.4 (2006-10-02)
+- Release 1.2.3 (2006-09-14)
+- Release 1.2.2 (2006-09-01)
+- Release 1.2.1 (2006-08-29)
+- Release 1.2.0 (2006-08-29)
+- Release 1.1.2 (2006-07-07)
+- Release 1.1.1 (2006-04-03)
+- Release 1.1.0 (2006-03-23)
+- Release 1.1b2 (2006-03-04)
+- Release 1.1b1 (2006-03-03)
+- Release 1.0.0 (2006-01-19)
+- Release 1.0b2 (2006-01-16)
+- Release 1.0b1 (2006-01-09)
+- Release 1.0a1 (2006-01-03) [internal]
+- Release 0.96.1 (2005-12-28)
+- Release 0.95.4 (2005-11-07)
+- Release 0.95.3 (2005-10-28) [internal]
+- Release 0.95.2 (2005-10-22) [internal]
+- Release 0.94.1 (2005-09-30) [internal]
+- Release 0.93.1 (2005-08-01)
+- Release 0.92.1 (2005-05-09)
+- Release 0.91.4 (2005-04-11)
+- Release 0.91.3 (2005-03-19)
+- Release 0.91.2 (2005-02-27)
+- Release 0.91.1 (2005-02-21)
+
+
+ POCO C++ Libraries
+==================
+
+POrtable COmponents C++ Libraries are:
+--------------------------------------
+- A collection of C++ class libraries, conceptually similar to the Java Class Library, the .NET Framework or Apple’s Cocoa.
+- Focused on solutions to frequently-encountered practical problems.
+- Focused on ‘internet-age’ network-centric applications.
+- Written in efficient, modern, 100% ANSI/ISO Standard C++.
+- Based on and complementing the C++ Standard Library/STL.
+- Highly portable and available on many different platforms.
+- Open Source, licensed under the [Boost Software License](https://spdx.org/licenses/BSL-1.0).
+
+----
+To start using POCO, see the [Guided Tour](http://pocoproject.org/docs-1.5.3/00100-GuidedTour.html) and [Getting Started](http://pocoproject.org/docs-1.5.3/00200-GettingStarted.html) documents.
+
+----
+POCO has an active user and contributing community, please visit our [web site](http://pocoproject.org), [forum](http://pocoproject.org/forum) and [blog](http://pocoproject.org/blog). 
+Answers to POCO-related questions can also be found on [Stack Overflow](http://stackoverflow.com/questions/tagged/poco-libraries).
+
+----
+In regards to Boost, in spite of some functional overlapping,
+POCO is best thought of as a Boost complement (rather than replacement).
+Side-by-side use of Boost and POCO is a very common occurrence.
+
+
+ 

packaging/README.txt

@@ -0,0 +1,24 @@
+ POCO C++ Libraries
+==================
+
+POrtable COmponents C++ Libraries are:
+--------------------------------------
+- A collection of C++ class libraries, conceptually similar to the Java Class Library, the .NET Framework or Apple’s Cocoa.
+- Focused on solutions to frequently-encountered practical problems.
+- Focused on ‘internet-age’ network-centric applications.
+- Written in efficient, modern, 100% ANSI/ISO Standard C++.
+- Based on and complementing the C++ Standard Library/STL.
+- Highly portable and available on many different platforms.
+- Open Source, licensed under the [Boost Software License](https://spdx.org/licenses/BSL-1.0).
+
+----
+To start using POCO, see the [Guided Tour](http://pocoproject.org/docs-1.5.3/00100-GuidedTour.html) and [Getting Started](http://pocoproject.org/docs-1.5.3/00200-GettingStarted.html) documents.
+
+----
+POCO has an active user and contributing community, please visit our [web site](http://pocoproject.org), [forum](http://pocoproject.org/forum) and [blog](http://pocoproject.org/blog). 
+Answers to POCO-related questions can also be found on [Stack Overflow](http://stackoverflow.com/questions/tagged/poco-libraries).
+
+----
+In regards to Boost, in spite of some functional overlapping,
+POCO is best thought of as a Boost complement (rather than replacement).
+Side-by-side use of Boost and POCO is a very common occurrence.

packaging/Windows/NuGet/Pocoproject.Poco.vs140.nuspec

@@ -0,0 +1,44 @@
+<?xml version='1.0' encoding='utf-8'?>
+<package xmlns='http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd'>
+    <metadata>
+        <id>Pocoproject.Poco.vs140</id>
+        <version>$version$</version>
+        <title>Poco $version$</title>
+        <authors> Applied Informatics &amp; Contributors</authors>
+        <owners>Günter Obiltschnig &amp; Aleksandar Fabijanic</owners>
+        <licenseUrl>https://pocoproject.org/license.html</licenseUrl>
+        <projectUrl>https://pocoproject.org/</projectUrl>
+        <iconUrl>https://avatars1.githubusercontent.com/u/201918?v=4&amp;s=200</iconUrl>
+        <requireLicenseAcceptance>false</requireLicenseAcceptance>
+        <description>Modern, powerful open source C++ class libraries for building network- and internet-based applications that run on desktop, server, mobile and embedded systems.</description>
+        <releaseNotes>
+		</releaseNotes>
+        <copyright>Copyright 2017</copyright>
+        <tags>string filesystem thread date log event regex uri uuid cache native nativepackage sockets mime http ftp mail pop3 smtp html sax sax2 dom xml</tags>
+        <dependencies>
+            <dependency id='openssl' version='1.0.2' />
+        </dependencies>
+    </metadata>
+    <files>
+		<file src='packaging\Windows\NuGet\Pocoproject.Poco.vs140.targets'			target='build\native'/>
+        <file src='bin\*' 							target='build\native\bin'  	exclude='bin\PocoCppParser*'/>
+        <file src='lib\*' 							target='build\native\lib'  	exclude='lib\PocoCppParser*'/>
+        <file src='bin64\*' 						target='build\native\bin64'	exclude='bin64\PocoCppParser*'/>
+        <file src='lib64\*' 						target='build\native\lib64'	exclude='lib64\PocoCppParser*'/>
+		<file src='CppUnit\include\**' 				target='build\native\inc' />
+		<file src='Crypto\include\**' 				target='build\native\inc' />
+		<file src='Data\MySQL\include\**' 			target='build\native\inc' />
+		<file src='Data\ODBC\include\**' 			target='build\native\inc' />
+		<file src='Data\SQLite\include\**' 			target='build\native\inc' />
+		<file src='Foundation\include\**' 			target='build\native\inc' />
+		<file src='JSON\include\**' 				target='build\native\inc' />
+		<file src='MongoDB\include\**' 				target='build\native\inc' />
+		<file src='Net\include\**' 					target='build\native\inc' />
+		<file src='NetSSL_OpenSSL\include\**' 		target='build\native\inc' />
+		<file src='NetSSL_Win\include\**' 			target='build\native\inc' />
+		<file src='PDF\include\**' 					target='build\native\inc' />
+		<file src='Util\include\**' 				target='build\native\inc' />
+		<file src='XML\include\**' 					target='build\native\inc' />
+		<file src='Zip\include\**' 					target='build\native\inc' />
+     </files>
+</package>

packaging/Windows/NuGet/Pocoproject.Poco.vs140.symbols.nuspec

@@ -0,0 +1,25 @@
+<?xml version='1.0' encoding='utf-8'?>
+<package xmlns='http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd'>
+    <metadata>
+        <id>Pocoproject.Poco.vs140</id>
+        <version>$version$</version>
+        <title>Poco $version$</title>
+        <authors> Applied Informatics &amp; Contributors</authors>
+        <owners>Günter Obiltschnig &amp; Aleksandar Fabijanic</owners>
+        <licenseUrl>https://pocoproject.org/license.html</licenseUrl>
+        <projectUrl>https://pocoproject.org/</projectUrl>
+        <iconUrl>https://avatars1.githubusercontent.com/u/201918?v=4&amp;s=200</iconUrl>
+        <requireLicenseAcceptance>false</requireLicenseAcceptance>
+        <description>Modern, powerful open source C++ class libraries for building network- and internet-based applications that run on desktop, server, mobile and embedded systems.</description>
+        <releaseNotes>
+		</releaseNotes>
+        <copyright>Copyright 2017</copyright>
+        <tags>string filesystem thread date log event regex uri uuid cache native nativepackage sockets mime http ftp mail pop3 smtp html sax sax2 dom xml</tags>
+   </metadata>
+    <files>
+        <file src='bin\*.pdb' 							target='build\native\bin'  	exclude='..\bin\PocoCppParser*'/>
+        <file src='bin\*.dll' 							target='build\native\bin'  	exclude='..\bin\PocoCppParser*/>
+        <file src='bin64\*.pdb' 						target='build\native\bin64'	exclude='..\bin64\PocoCppParser*'/>
+        <file src='bin64\*.dll' 						target='build\native\bin64'	exclude='..\bin64\PocoCppParser*'/>
+     </files>
+</package>

packaging/Windows/NuGet/Pocoproject.Poco.vs140.targets

@@ -0,0 +1,13 @@
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(MSBuildThisFileDirectory)inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+	<Link  Condition="'$(Platform)'=='Win32'">
+		<AdditionalLibraryDirectories>$(MSBuildThisFileDirectory)lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+	</Link>
+	<Link  Condition="'$(Platform)'=='x64'">
+		<AdditionalLibraryDirectories>$(MSBuildThisFileDirectory)lib64;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+	</Link>
+  </ItemDefinitionGroup>
+</Project>

packaging/Windows/NuGet/api.key

@@ -0,0 +1 @@
+e5709aaf-9638-45e8-a8b9-0de8a7cec41e

release/script/mkdoc

@@ -1,4 +1,4 @@
-#! /bin/sh
+#! /bin/bash
 #
 # mkdoc
 #
@@ -12,6 +12,11 @@
 # usage: mkdoc [-l <perforce-label>] [<specfile>]
 #
 
+if [ "$POCO_BASE" = "" ] ; then
+  echo "Error: POCO_BASE not set."
+  exit 1
+fi
+
 osname=`uname -s | tr ' ' '_'`
 osarch=`uname -m | tr ' ' '_'`
 
@@ -19,14 +24,14 @@ if [ ${osname:0:6} = "CYGWIN" ] ; then
 	osname="CYGWIN"
 fi
 
-if [ "$POCO_BASE" = "" ] ; then
-  echo "Error: POCO_BASE not set."
-  exit 1
+if [ $osname = "Darwin" ] ; then
+	archpath=`dirname stage/tools/PocoDoc/bin/Darwin/*/PocoDoc`
+	osarch=`basename $archpath`
 fi
 
 spec=""
 docConfig=$POCO_BASE/PocoDoc/cfg/mkdoc-poco.xml
-while [ "$1" != "" ] ; 
+while [ "$1" != "" ] ;
 do
 	if [ "$1" = "-C" ] ; then
 		shift
@@ -88,18 +93,13 @@ cd $tools
 make -s -j8 
 
 if [ $osname = "CYGWIN" ] ; then
-    find $tools -type f -name "*.$libversion.dll" > $TMP/dlls
+    find $tools -type f -name "cyg*$libversion.dll" > $TMP/dlls
     rebase -O -T $TMP/dlls
     rm $TMP/dlls
 fi
 
 cd $POCO_BASE
 
-if [ $osname = "Darwin" ] ; then
-	archpath=`dirname stage/tools/PocoDoc/bin/Darwin/*/PocoDoc`
-	osarch=`basename $archpath`
-fi
-
 if [ $osname = "CYGWIN" ] ; then
 #   Poco dlls must be on PATH for Cygwin
     export PATH=$tools/lib/$osname/$osarch:$PATH

release/script/mkdocumentation

@@ -41,7 +41,7 @@ specfile=""
 tag=""
 config=""
 
-while [ "$1" != "" ] ; 
+while [ "$1" != "" ] ;
 do
 	if [ "$1" = "-f" ] ; then
 		shift
@@ -117,6 +117,13 @@ for inc in `find $build -name include -print` ; do
 	includes="$includes,-I$inc"
 done
 
+: ${CC:=gcc}
+: ${CXX:=g++}
+: ${CXXFLAGS:=-std=c++11}
+
+echo "CC=$CC" >>$build/PocoDoc.ini
+echo "CXX=$CXX" >>$build/PocoDoc.ini
+echo "CXXFLAGS=$CXXFLAGS" >>$build/PocoDoc.ini
 echo "PocoBuild=$build" >>$build/PocoDoc.ini
 echo "PocoBase=$POCO_BASE" >>$build/PocoDoc.ini
 echo "PocoDoc.output=$docPath" >>$build/PocoDoc.ini

release/script/mkrel

@@ -34,7 +34,7 @@ esac
 label=""
 spec=""
 lineEndConv=""
-while [ "$1" != "" ] ; 
+while [ "$1" != "" ] ;
 do
 	if [ "$1" = "-l" ] ; then
 		shift

release/script/mkrelease

@@ -25,7 +25,7 @@ output=""
 lineEndConv=""
 licensingDep=""
 
-while [ "$1" != "" ] ; 
+while [ "$1" != "" ] ;
 do
 	if [ "$1" = "-i" ] ; then
 		shift
@@ -107,11 +107,9 @@ cp ${POCO_BASE}/CMakeLists.txt ${target}
 mkdir -p ${target}/build/config
 mkdir -p ${target}/build/rules
 mkdir -p ${target}/build/script
-mkdir -p ${target}/build/vxconfig
 
 cp ${POCO_BASE}/build/config/* ${target}/build/config
 cp ${POCO_BASE}/build/rules/* ${target}/build/rules
-cp ${POCO_BASE}/build/vxconfig/* ${target}/build/vxconfig
 cp ${POCO_BASE}/build/script/* ${target}/build/script
 cp ${POCO_BASE}/buildwin.cmd ${target}
 cp ${POCO_BASE}/configure ${target}

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'
+