Merge pull request #1040 from fbraem/develop

Redis Module
2025-02-20 14:24:35 +01:00 · 2015-11-20 17:54:58 -06:00 · 2015-11-20 17:54:58 -06:00 · e06d381e59
commit e06d381e59
parent 6822faded5 ff1bf69ac1
41 changed files with 7297 additions and 4 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -77,6 +77,7 @@ option(ENABLE_CPPPARSER "Enable C++ parser" OFF)
 option(ENABLE_POCODOC "Enable Poco Documentation Generator" OFF)
 option(ENABLE_PAGECOMPILER "Enable PageCompiler" ON)
 option(ENABLE_PAGECOMPILER_FILE2PAGE "Enable File2Page" ON)
+option(ENABLE_REDIS "Enable Redis" ON)

 option(FORCE_OPENSSL "Force usage of OpenSSL even under windows" OFF)

@ -192,6 +193,10 @@ if(ENABLE_ZIP)
 add_subdirectory(Zip)
 list(APPEND Poco_COMPONENTS "Zip")
 endif()
+if(ENABLE_REDIS)
+add_subdirectory(Redis)
+list(APPEND Poco_COMPONENTS "Redis")
+endif()

 find_package(APR)
 find_package(Apache2)
--- a/23
+++ b/23
@ -70,7 +70,7 @@ poco: libexecs $(if $(TESTS),tests) $(if $(SAMPLES),samples)
 all: libexecs tests samples

 INSTALLDIR = $(DESTDIR)$(POCO_PREFIX)
-COMPONENTS = Foundation XML JSON Util Net Crypto NetSSL_OpenSSL Data Data/SQLite Data/ODBC Data/MySQL MongoDB Zip PageCompiler PageCompiler/File2Page CppParser PDF
+COMPONENTS = Foundation XML JSON Util Net Crypto NetSSL_OpenSSL Data Data/SQLite Data/ODBC Data/MySQL MongoDB Redis Zip PageCompiler PageCompiler/File2Page CppParser PDF

 cppunit:
 	$(MAKE) -C $(POCO_BASE)/CppUnit 
@ -97,10 +97,10 @@ endif
 	find $(POCO_BUILD)/lib/$(OSNAME)/$(OSARCH) -name "libPoco*" -type f -exec cp -f  {} $(INSTALLDIR)/lib \;
 	find $(POCO_BUILD)/lib/$(OSNAME)/$(OSARCH) -name "libPoco*" -type l -exec cp -Rf {} $(INSTALLDIR)/lib \;

-libexecs =  Foundation-libexec XML-libexec JSON-libexec Util-libexec Net-libexec Crypto-libexec NetSSL_OpenSSL-libexec Data-libexec Data/SQLite-libexec Data/ODBC-libexec Data/MySQL-libexec MongoDB-libexec Zip-libexec PageCompiler-libexec PageCompiler/File2Page-libexec CppParser-libexec PDF-libexec
-tests    =  Foundation-tests XML-tests JSON-tests Util-tests Net-tests Crypto-tests NetSSL_OpenSSL-tests Data-tests Data/SQLite-tests Data/ODBC-tests Data/MySQL-tests MongoDB-tests Zip-tests CppParser-tests PDF-tests
+libexecs =  Foundation-libexec XML-libexec JSON-libexec Util-libexec Net-libexec Crypto-libexec NetSSL_OpenSSL-libexec Data-libexec Data/SQLite-libexec Data/ODBC-libexec Data/MySQL-libexec MongoDB-libexec Redis-libexec Zip-libexec PageCompiler-libexec PageCompiler/File2Page-libexec CppParser-libexec PDF-libexec
+tests    =  Foundation-tests XML-tests JSON-tests Util-tests Net-tests Crypto-tests NetSSL_OpenSSL-tests Data-tests Data/SQLite-tests Data/ODBC-tests Data/MySQL-tests MongoDB-tests Redis-tests Zip-tests CppParser-tests PDF-tests
 samples  =  Foundation-samples XML-samples JSON-samples Util-samples Net-samples Crypto-samples NetSSL_OpenSSL-samples Data-samples MongoDB-samples Zip-samples PageCompiler-samples PDF-samples
-cleans   =  Foundation-clean XML-clean JSON-clean Util-clean Net-clean Crypto-clean NetSSL_OpenSSL-clean Data-clean Data/SQLite-clean Data/ODBC-clean Data/MySQL-clean MongoDB-clean Zip-clean PageCompiler-clean PageCompiler/File2Page-clean CppParser-clean PDF-clean
+cleans   =  Foundation-clean XML-clean JSON-clean Util-clean Net-clean Crypto-clean NetSSL_OpenSSL-clean Data-clean Data/SQLite-clean Data/ODBC-clean Data/MySQL-clean MongoDB-clean Redis-clean Zip-clean PageCompiler-clean PageCompiler/File2Page-clean CppParser-clean PDF-clean

 .PHONY: $(libexecs)
 .PHONY: $(tests)
@ -268,6 +268,21 @@ MongoDB-clean:
 	$(MAKE) -C $(POCO_BASE)/MongoDB/testsuite clean
 	$(MAKE) -C $(POCO_BASE)/MongoDB/samples clean

+Redis-libexec:  Foundation-libexec Net-libexec
+	$(MAKE) -C $(POCO_BASE)/Redis
+
+Redis-tests: Redis-libexec cppunit
+	$(MAKE) -C $(POCO_BASE)/Redis/testsuite
+
+#No samples yet ... uncomment this when added, and add Redis-samples to samples above
+#Redis-samples: Redis-libexec 
+#	$(MAKE) -C $(POCO_BASE)/Redis/samples
+
+Redis-clean:
+	$(MAKE) -C $(POCO_BASE)/Redis clean
+	$(MAKE) -C $(POCO_BASE)/Redis/testsuite clean
+#	$(MAKE) -C $(POCO_BASE)/Redis/samples clean
+
 Zip-libexec:  Foundation-libexec Net-libexec Util-libexec XML-libexec
 	$(MAKE) -C $(POCO_BASE)/Zip

--- a/Redis/CMakeLists.txt
+++ b/Redis/CMakeLists.txt
@ -0,0 +1,37 @@
+set(LIBNAME "Redis")
+set(POCO_LIBNAME "Poco${LIBNAME}")
+
+# Sources
+file(GLOB SRCS_G "src/*.cpp")
+POCO_SOURCES_AUTO( SRCS ${SRCS_G})
+
+# Headers
+file(GLOB_RECURSE HDRS_G "include/*.h" )
+POCO_HEADERS_AUTO( SRCS ${HDRS_G})
+
+add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
+    PROPERTIES
+    VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL Redis_EXPORTS
+    )
+
+target_link_libraries( "${LIBNAME}" Net Foundation)
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
+target_compile_definitions("${LIBNAME}" PUBLIC ${LIB_MODE_DEFINITIONS})
+
+POCO_INSTALL("${LIBNAME}")
+POCO_GENERATE_PACKAGE("${LIBNAME}")
+
+if (ENABLE_TESTS)
+#    add_subdirectory(samples)
+    add_subdirectory(testsuite)
+endif ()
+
--- a/Redis/Makefile
+++ b/Redis/Makefile
@ -0,0 +1,19 @@
+#
+# Makefile
+#
+# $Id$
+#
+# Makefile for Poco Redis
+#
+
+include $(POCO_BASE)/build/rules/global
+
+INCLUDE += -I $(POCO_BASE)/Redis/include/Poco/Redis
+
+objects = AsyncReader Array Client Command Error Exception RedisStream RedisEventArgs Type
+
+target         = PocoRedis
+target_version = $(LIBVERSION)
+target_libs    = PocoFoundation PocoNet
+
+include $(POCO_BASE)/build/rules/lib
--- a/Redis/Redis.progen
+++ b/Redis/Redis.progen
@ -0,0 +1,16 @@
+vc.project.guid = ${vc.project.guidFromName}
+vc.project.name = Redis
+vc.project.target = Poco${vc.project.name}
+vc.project.type = library
+vc.project.pocobase = ..
+vc.project.outdir = ${vc.project.pocobase}
+vc.project.platforms = Win32, x64
+vc.project.configurations = debug_shared, release_shared, debug_static_mt, release_static_mt, debug_static_md, release_static_md
+vc.project.prototype = ${vc.project.name}_vs90.vcproj
+vc.project.compiler.include = ..\\Foundation\\include;..\\Net\\include
+vc.project.compiler.defines = 
+vc.project.compiler.defines.shared = ${vc.project.name}_EXPORTS
+vc.project.compiler.defines.debug_shared = ${vc.project.compiler.defines.shared}
+vc.project.compiler.defines.release_shared = ${vc.project.compiler.defines.shared}
+vc.solution.create = true
+vc.solution.include = testsuite\\TestSuite
--- a/Redis/Redis_x64_vs90.sln
+++ b/Redis/Redis_x64_vs90.sln
@ -0,0 +1,60 @@
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual Studio 2008
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Redis", "Redis_x64_vs90.vcproj", "{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TestSuite", "testsuite\TestSuite_x64_vs90.vcproj", "{96CF3103-E49E-3F5E-A11D-6DBCDA043053}"
+	ProjectSection(ProjectDependencies) = postProject
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199} = {4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		debug_shared|x64 = debug_shared|x64
+		release_shared|x64 = release_shared|x64
+		debug_static_mt|x64 = debug_static_mt|x64
+		release_static_mt|x64 = release_static_mt|x64
+		debug_static_md|x64 = debug_static_md|x64
+		release_static_md|x64 = release_static_md|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.debug_shared|x64.ActiveCfg = debug_shared|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.debug_shared|x64.Build.0 = debug_shared|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.debug_shared|x64.Deploy.0 = debug_shared|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.release_shared|x64.ActiveCfg = release_shared|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.release_shared|x64.Build.0 = release_shared|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.release_shared|x64.Deploy.0 = release_shared|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.debug_static_mt|x64.ActiveCfg = debug_static_mt|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.debug_static_mt|x64.Build.0 = debug_static_mt|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.debug_static_mt|x64.Deploy.0 = debug_static_mt|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.release_static_mt|x64.ActiveCfg = release_static_mt|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.release_static_mt|x64.Build.0 = release_static_mt|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.release_static_mt|x64.Deploy.0 = release_static_mt|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.debug_static_md|x64.ActiveCfg = debug_static_md|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.debug_static_md|x64.Build.0 = debug_static_md|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.debug_static_md|x64.Deploy.0 = debug_static_md|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.release_static_md|x64.ActiveCfg = release_static_md|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.release_static_md|x64.Build.0 = release_static_md|x64
+		{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}.release_static_md|x64.Deploy.0 = release_static_md|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.debug_shared|x64.ActiveCfg = debug_shared|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.debug_shared|x64.Build.0 = debug_shared|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.debug_shared|x64.Deploy.0 = debug_shared|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.release_shared|x64.ActiveCfg = release_shared|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.release_shared|x64.Build.0 = release_shared|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.release_shared|x64.Deploy.0 = release_shared|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.debug_static_mt|x64.ActiveCfg = debug_static_mt|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.debug_static_mt|x64.Build.0 = debug_static_mt|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.debug_static_mt|x64.Deploy.0 = debug_static_mt|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.release_static_mt|x64.ActiveCfg = release_static_mt|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.release_static_mt|x64.Build.0 = release_static_mt|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.release_static_mt|x64.Deploy.0 = release_static_mt|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.debug_static_md|x64.ActiveCfg = debug_static_md|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.debug_static_md|x64.Build.0 = debug_static_md|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.debug_static_md|x64.Deploy.0 = debug_static_md|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.release_static_md|x64.ActiveCfg = release_static_md|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.release_static_md|x64.Build.0 = release_static_md|x64
+		{96CF3103-E49E-3F5E-A11D-6DBCDA043053}.release_static_md|x64.Deploy.0 = release_static_md|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
--- a/Redis/Redis_x64_vs90.vcproj
+++ b/Redis/Redis_x64_vs90.vcproj
@ -0,0 +1,588 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9,00"
+	Name="Redis"
+	ProjectGUID="{4FF2F34B-7F37-3ACD-AFBC-F21D6D426199}"
+	RootNamespace="Redis"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="0"
+	>
+	<Platforms>
+		<Platform
+			Name="x64"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="debug_shared|x64"
+			OutputDirectory="obj64\$(ConfigurationName)"
+			IntermediateDirectory="obj64\$(ConfigurationName)"
+			ConfigurationType="2"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions=""
+				Optimization="0"
+				AdditionalIncludeDirectories=".\include;..\Foundation\include;..\Net\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;Redis_EXPORTS"
+				StringPooling="true"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				BufferSecurityCheck="true"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="3"
+				CompileAs="0"
+				DisableSpecificWarnings=""
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions=""
+				AdditionalDependencies=""
+				OutputFile="..\bin64\PocoRedis64d.dll"
+				LinkIncremental="2"
+				SuppressStartupBanner="true"
+				AdditionalLibraryDirectories="..\lib64"
+				GenerateDebugInformation="true"
+				ProgramDatabaseFile="..\bin64\PocoRedis64d.pdb"
+				SubSystem="1"
+				ImportLibrary="..\lib64\PocoRedisd.lib"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="release_shared|x64"
+			OutputDirectory="obj64\$(ConfigurationName)"
+			IntermediateDirectory="obj64\$(ConfigurationName)"
+			ConfigurationType="2"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions=""
+				Optimization="4"
+				InlineFunctionExpansion="1"
+				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="1"
+				OmitFramePointers="true"
+				AdditionalIncludeDirectories=".\include;..\Foundation\include;..\Net\include"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;Redis_EXPORTS"
+				StringPooling="true"
+				RuntimeLibrary="2"
+				BufferSecurityCheck="false"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="0"
+				CompileAs="0"
+				DisableSpecificWarnings=""
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions=""
+				AdditionalDependencies=""
+				OutputFile="..\bin64\PocoRedis64.dll"
+				LinkIncremental="1"
+				SuppressStartupBanner="true"
+				AdditionalLibraryDirectories="..\lib64"
+				GenerateDebugInformation="false"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				OptimizeForWindows98="0"
+				ImportLibrary="..\lib64\PocoRedis.lib"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="debug_static_mt|x64"
+			OutputDirectory="obj64\$(ConfigurationName)"
+			IntermediateDirectory="obj64\$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions=""
+				Optimization="0"
+				AdditionalIncludeDirectories=".\include;..\Foundation\include;..\Net\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;POCO_STATIC;"
+				StringPooling="true"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				BufferSecurityCheck="true"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="..\lib64\PocoRedismtd.pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="3"
+				CompileAs="0"
+				DisableSpecificWarnings=""
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="..\lib64\PocoRedismtd.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="release_static_mt|x64"
+			OutputDirectory="obj64\$(ConfigurationName)"
+			IntermediateDirectory="obj64\$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions=""
+				Optimization="4"
+				InlineFunctionExpansion="1"
+				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="1"
+				OmitFramePointers="true"
+				AdditionalIncludeDirectories=".\include;..\Foundation\include;..\Net\include"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;POCO_STATIC;"
+				StringPooling="true"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="false"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="0"
+				CompileAs="0"
+				DisableSpecificWarnings=""
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="..\lib64\PocoRedismt.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="debug_static_md|x64"
+			OutputDirectory="obj64\$(ConfigurationName)"
+			IntermediateDirectory="obj64\$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions=""
+				Optimization="0"
+				AdditionalIncludeDirectories=".\include;..\Foundation\include;..\Net\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;POCO_STATIC;"
+				StringPooling="true"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				BufferSecurityCheck="true"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				UsePrecompiledHeader="0"
+				ProgramDataBaseFileName="..\lib64\PocoRedismdd.pdb"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="3"
+				CompileAs="0"
+				DisableSpecificWarnings=""
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="..\lib64\PocoRedismdd.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="release_static_md|x64"
+			OutputDirectory="obj64\$(ConfigurationName)"
+			IntermediateDirectory="obj64\$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions=""
+				Optimization="4"
+				InlineFunctionExpansion="1"
+				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="1"
+				OmitFramePointers="true"
+				AdditionalIncludeDirectories=".\include;..\Foundation\include;..\Net\include"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;POCO_STATIC;"
+				StringPooling="true"
+				RuntimeLibrary="2"
+				BufferSecurityCheck="false"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="0"
+				CompileAs="0"
+				DisableSpecificWarnings=""
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="..\lib64\PocoRedismd.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			>
+			<File
+				RelativePath=".\src\Array.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\src\AsyncReader.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\src\Client.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\src\Command.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\src\Error.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\src\Exception.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\src\RedisEventArgs.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\src\RedisStream.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\src\Type.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			>
+			<File
+				RelativePath=".\include\Poco\Redis\Array.h"
+				>
+			</File>
+			<File
+				RelativePath=".\include\Poco\Redis\AsyncReader.h"
+				>
+			</File>
+			<File
+				RelativePath=".\include\Poco\Redis\Client.h"
+				>
+			</File>
+			<File
+				RelativePath=".\include\Poco\Redis\Command.h"
+				>
+			</File>
+			<File
+				RelativePath=".\include\Poco\Redis\Error.h"
+				>
+			</File>
+			<File
+				RelativePath=".\include\Poco\Redis\Exception.h"
+				>
+			</File>
+			<File
+				RelativePath=".\include\Poco\Redis\PoolableConnectionFactory.h"
+				>
+			</File>
+			<File
+				RelativePath=".\include\Poco\Redis\Redis.h"
+				>
+			</File>
+			<File
+				RelativePath=".\include\Poco\Redis\RedisEventArgs.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\include\Poco\Redis\RedisStream.h"
+				>
+			</File>
+			<File
+				RelativePath=".\include\Poco\Redis\Type.h"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
--- a/Redis/cmake/PocoRedisConfig.cmake
+++ b/Redis/cmake/PocoRedisConfig.cmake
@ -0,0 +1,4 @@
+include(CMakeFindDependencyMacro)
+find_dependency(PocoFoundation)
+find_dependency(PocoNet)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoRedisTargets.cmake")
--- a/Redis/dependencies
+++ b/Redis/dependencies
@ -0,0 +1,2 @@
+Foundation
+Net
--- a/Redis/include/Poco/Redis/Array.h
+++ b/Redis/include/Poco/Redis/Array.h
@ -0,0 +1,296 @@
+//
+// Array.h
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  Array
+//
+// Definition of the Array class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#ifndef Redis_Array_INCLUDED
+#define Redis_Array_INCLUDED
+
+#include <vector>
+#include <sstream>
+
+#include "Poco/Redis/Redis.h"
+#include "Poco/Redis/Type.h"
+#include "Poco/Redis/Exception.h"
+
+namespace Poco {
+namespace Redis {
+
+class Redis_API Array
+	/// Represents a Redis Array. An Array can contain Integers, Strings,
+	/// Bulk Strings, Errors and other arrays. It can also contain a Null
+	/// value.
+{
+public:
+
+	typedef std::vector<RedisType::Ptr>::const_iterator const_iterator;
+
+	Array();
+		/// Default constructor. As long as there are no elements added,
+		/// the array will contain a Null value.
+
+	Array(const Array& copy);
+		/// Copy constructor.
+
+	virtual ~Array();
+		/// Destructor.
+
+	template<typename T>
+	Array& operator<<(const T& arg)
+		/// Adds the argument to the array.
+		/// Note: a std::string will be added as a BulkString because this
+		/// is commonly used for representing strings in Redis. If you
+		/// really need a simple string, use addSimpleString.
+	{
+		return add(arg);
+	}
+
+	Array& operator<<(const char* s);
+		/// Special implementation for const char*
+		/// Note: the specialization creates a BulkString. If you need
+		/// a simple string, call addSimpleString.
+
+	Array& operator<<(const std::vector<std::string>& strings);
+		/// Special implementation for a vector with strings
+		/// All strings will be added as a BulkString.
+
+	Array& add();
+		/// Adds an Null BulkString
+
+	template<typename T>
+	Array& add(const T& arg)
+		/// Adds an element to the array.
+		/// Note: the specialization for std::string will add a BulkString!
+		/// If you really need a simple string, call addSimpleString.
+	{
+		addRedisType(new Type<T>(arg));
+		return *this;
+	}
+
+	Array& add(const char* s);
+		/// Special implementation for const char*
+		/// Note: the specialization creates a BulkString. If you need
+		/// a simple string, call addSimpleString.
+
+	Array& add(const std::vector<std::string>& strings);
+		/// Special implementation for a vector with strings
+		/// All strings will be added as a BulkString.
+
+	Array& addRedisType(RedisType::Ptr value);
+		/// Adds a Redis element.
+
+	Array& addSimpleString(const std::string& value);
+		/// Adds a simple string (can't contain newline characters!)
+
+	const_iterator begin() const;
+		/// Returns an iterator to the start of the array. Note:
+		/// this can throw a NullValueException when this is a Null array.
+
+	void clear();
+		/// Removes all elements from the array.
+
+	const_iterator end() const;
+		/// Returns an iterator to the end of the array. Note:
+		/// this can throw a NullValueException when this is a Null array.
+
+	template<typename T>
+	T get(size_t pos) const
+		/// Returns the element on the given position and tries to convert
+		/// to the template type. A BadCastException will be thrown when the
+		/// the conversion fails. An InvalidArgumentException will be thrown
+		/// when the index is out of range. When the array is a Null array
+		/// a NullValueException is thrown.
+	{
+		if ( _elements.isNull() ) throw NullValueException();
+
+		if ( pos >= _elements.value().size() ) throw InvalidArgumentException();
+
+		RedisType::Ptr element = _elements.value().at(pos);
+		if ( RedisTypeTraits<T>::TypeId == element->type() )
+		{
+			Type<T>* concrete = dynamic_cast<Type<T>* >(element.get());
+			if ( concrete != NULL ) return concrete->value();
+		}
+		throw BadCastException();
+	}
+
+	int getType(size_t pos) const;
+		/// Returns the type of the element. This can throw a NullValueException
+		/// when this array is a Null array. An InvalidArgumentException will
+		/// be thrown when the index is out of range.
+
+	bool isNull() const;
+		/// Returns true when this is a Null array.
+
+	void makeNull();
+		/// Turns the array into a Null array. When the array already has some
+		/// elements, the array will be cleared.
+
+	std::string toString() const;
+		/// Returns the String representation as specified in the
+		/// Redis Protocol specification.
+
+	size_t size() const;
+		/// Returns the size of the array. Note:
+		/// this can throw a NullValueException when this is a Null array.
+
+private:
+
+	Nullable<std::vector<RedisType::Ptr> > _elements;
+
+	void checkNull();
+		/// Checks for null array and sets a new vector if true.
+};
+
+inline Array& Array::operator<<(const char* s)
+{
+	BulkString value(s);
+	return add(value);
+}
+
+inline Array& Array::operator<<(const std::vector<std::string>& strings)
+{
+	return add(strings);
+}
+
+inline Array& Array::add()
+{
+	BulkString value;
+	return add(value);
+}
+
+template<>
+inline Array& Array::add(const std::string& arg)
+{
+	BulkString value(arg);
+	return add(value);
+}
+
+inline Array& Array::add(const char* s)
+{
+	BulkString value(s);
+	return add(value);
+}
+
+inline Array& Array::add(const std::vector<std::string>& strings)
+{
+	for(std::vector<std::string>::const_iterator it = strings.begin(); it != strings.end(); ++it)
+	{
+		add(*it);
+	}
+	return *this;
+}
+
+inline Array& Array::addSimpleString(const std::string& value)
+{
+	return addRedisType(new Type<std::string>(value));
+}
+
+inline Array::const_iterator Array::begin() const
+{
+	return _elements.value().begin();
+}
+
+inline void Array::checkNull()
+{
+	std::vector<RedisType::Ptr> v;
+	if ( _elements.isNull() ) _elements.assign(v);
+}
+
+inline void Array::clear()
+{
+	if ( !_elements.isNull() )
+	{
+		_elements.value().clear();
+	}
+}
+
+inline Array::const_iterator Array::end() const
+{
+	return _elements.value().end();
+}
+
+inline bool Array::isNull() const
+{
+	return _elements.isNull();
+}
+
+inline void Array::makeNull()
+{
+	if ( !_elements.isNull() ) _elements.value().clear();
+
+	_elements.clear();
+}
+
+inline size_t Array::size() const
+{
+	return _elements.value().size();
+}
+
+
+template<>
+struct RedisTypeTraits<Array>
+{
+	enum { TypeId = RedisType::REDIS_ARRAY };
+
+	static const char marker = '*';
+
+	static std::string toString(const Array& value)
+	{
+		std::stringstream result;
+		result <<  marker;
+		if ( value.isNull() )
+		{
+			result << "-1" << LineEnding::NEWLINE_CRLF;
+		}
+		else
+		{
+			result << value.size() << LineEnding::NEWLINE_CRLF;
+			for(std::vector<RedisType::Ptr>::const_iterator it = value.begin();
+				it != value.end(); ++it)
+			{
+				result << (*it)->toString();
+			}
+		}
+		return result.str();
+	}
+
+	static void read(RedisInputStream& input, Array& value)
+	{
+		value.clear();
+
+		Int64 length = NumberParser::parse64(input.getline());
+
+		if ( length != -1 )
+		{
+			for(int i = 0; i < length; ++i)
+			{
+				char marker = input.get();
+				RedisType::Ptr element = RedisType::createRedisType(marker);
+
+				if ( element.isNull() )
+					throw RedisException("Wrong answer received from Redis server");
+
+				element->read(input);
+				value.addRedisType(element);
+			}
+		}
+	}
+};
+
+
+}}
+
+#endif // Redis_Array_INCLUDED
--- a/Redis/include/Poco/Redis/AsyncReader.h
+++ b/Redis/include/Poco/Redis/AsyncReader.h
@ -0,0 +1,95 @@
+//
+// AsyncReader.h
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  AsyncReader
+//
+// Definition of the AsyncReader class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Redis_AsyncReader_INCLUDED
+#define Redis_AsyncReader_INCLUDED
+
+
+#include "Poco/Redis/Redis.h"
+#include "Poco/Redis/Client.h"
+#include "Poco/Redis/RedisEventArgs.h"
+#include "Poco/Activity.h"
+
+namespace Poco {
+namespace Redis {
+
+
+class Redis_API AsyncReader
+	/// Wrapper around a Redis client to read messages asynchronously. Use this
+	/// for publish/subscribe. The redisResponse event is used to notify that
+	/// a message is received. When a reader is started for a Redis server,
+	/// you should use execute<void>, because this class is responsible for
+	/// reading all replies.
+{
+public:
+
+	BasicEvent<RedisEventArgs> redisResponse;
+		/// Event that is called when a message is received
+	BasicEvent<RedisEventArgs> redisException;
+		/// Event that is called when an error occurred.
+
+	AsyncReader(Client& client);
+		/// Constructor.
+
+	virtual ~AsyncReader();
+		/// Destructor
+
+	bool isStopped();
+		/// Returns true if the activity is not running, false when it is.
+
+	void start();
+		/// Starts the activity to read replies from the Redis server.
+
+	void stop();
+		/// Stops the read activity.
+
+protected:
+
+	void runActivity();
+
+private:
+
+	AsyncReader(const AsyncReader&);
+	AsyncReader& operator = (const AsyncReader&);
+
+
+	Activity<AsyncReader> _activity;
+
+	Client& _client;
+};
+
+
+inline bool AsyncReader::isStopped()
+{
+	return _activity.isStopped();
+}
+
+inline void AsyncReader::start()
+{
+	_activity.start();
+}
+
+inline void AsyncReader::stop()
+{
+	_activity.stop();
+}
+
+
+} } // namespace Poco::Redis
+
+#endif //Redis_AsyncReader_INCLUDED
--- a/Redis/include/Poco/Redis/Client.h
+++ b/Redis/include/Poco/Redis/Client.h
@ -0,0 +1,232 @@
+//
+// Client.h
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  Client
+//
+// Definition of the Client class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Redis_Client_INCLUDED
+#define Redis_Client_INCLUDED
+
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Timespan.h"
+
+#include "Poco/Redis/Redis.h"
+#include "Poco/Redis/Array.h"
+#include "Poco/Redis/Error.h"
+#include "Poco/Redis/RedisStream.h"
+
+namespace Poco {
+namespace Redis {
+
+
+class Redis_API Client
+	/// Represents a connection to a Redis server.
+	///
+	/// A command is always made from an Array and a reply can be a signed 64
+	/// bit integer, a simple string, a bulk string, an array or an error. The
+	/// first element of the command array is the Redis command. A simple string
+	/// is a string that cannot contain a CR or LF character. A bulk string is
+	/// implemented as a typedef for Poco::Nullable<std::string>. This is
+	/// because a bulk string can represent a Null value.
+	///
+	///   BulkString bs = client.execute<BulkString>(...);
+	///   if ( bs.isNull() )
+	///   {
+	///      // We have a Null value
+	///   }
+	///   else
+	///   {
+	///      // We have a string value
+	///   }
+	///
+	/// To create Redis commands, the factory methods of the Command class can
+	/// be used or the Array class can be used directly.
+	///
+	///    Command llen = Command::llen("list");
+	///
+	/// is the same as
+	///
+	///    Array command;
+	///    command.add("LLEN").add("list");
+	///
+	/// or
+	///
+	///    Array command;
+	///    command << "LLEN" << "list";
+	///
+	///	or even
+	///
+	///    Command command("LLEN");
+	///    command << "list";
+{
+public:
+
+	typedef SharedPtr<Client> Ptr;
+
+	Client();
+		/// Default constructor. Use this when you want to
+		/// connect later on.
+
+	Client(const std::string& hostAndPort);
+		/// Constructor which connects to the given Redis host/port.
+		/// The host and port must be separated with a colon.
+
+	Client(const std::string& host, int port);
+		/// Constructor which connects to the given Redis host/port.
+
+	Client(const Net::SocketAddress& addrs);
+		/// Constructor which connects to the given Redis host/port.
+
+	virtual ~Client();
+		/// Destructor.
+
+	Net::SocketAddress address() const;
+		/// Returns the address of the Redis connection.
+
+	void connect(const std::string& hostAndPort);
+		/// Connects to the given Redis server. The host and port must be
+		/// separated with a colon.
+
+	void connect(const std::string& host, int port);
+		/// Connects to the given Redis server.
+
+	void connect(const Net::SocketAddress& addrs);
+		/// Connects to the given Redis server.
+
+	void connect(const std::string& hostAndPort, const Timespan& timeout);
+		/// Connects to the given Redis server. The host and port must be
+		/// separated with a colon.
+
+	void connect(const std::string& host, int port, const Timespan& timeout);
+		/// Connects to the given Redis server.
+
+	void connect(const Net::SocketAddress& addrs, const Timespan& timeout);
+		/// Connects to the given Redis server.
+
+	void disconnect();
+		/// Disconnects from the Redis server.
+
+	template<typename T>
+	T execute(const Array& command)
+		/// Sends the Redis Command to the server. It gets the reply
+		/// and tries to convert it to the given template type.
+		///
+		/// A specialization exists for type void, which doesn't read
+		/// the reply. If the server sends a reply, it is your
+		/// responsibility to read it ... (Use this for pipelining)
+		///
+		/// A BadCastException will be thrown when the reply couldn't be
+		/// converted. Supported types are Int64, std::string, BulkString,
+		/// Array and void. When the reply is an Error, it will throw
+		/// a RedisException.
+	{
+		T result;
+		writeCommand(command, true);
+		readReply(result);
+		return result;
+	}
+
+	void flush();
+		/// Flush the output buffer to Redis. Use this when commands
+		/// are stored in the buffer to send them all at once to Redis.
+
+	RedisType::Ptr sendCommand(const Array& command);
+		/// Sends a Redis command to the server and returns the reply.
+		/// Use this when the type of the reply isn't known.
+
+	RedisType::Ptr readReply();
+		/// Read a reply from the Redis server.
+
+	template<typename T>
+	void readReply(T& result)
+		/// Read a reply from the Redis server and tries to convert that reply
+		/// to the template type. When the reply is a Redis error, it will
+		/// throw a RedisException. A BadCastException will be thrown, when
+		/// the reply is not of the given type.
+	{
+		RedisType::Ptr redisResult = readReply();
+		if (redisResult->type() == RedisTypeTraits<Error>::TypeId)
+		{
+			Type<Error>* error = dynamic_cast<Type<Error>*>(redisResult.get());
+			throw RedisException(error->value().getMessage());
+		}
+
+		if (redisResult->type() == RedisTypeTraits<T>::TypeId)
+		{
+			Type<T>* type = dynamic_cast<Type<T>*>(redisResult.get());
+			if (type != NULL) result = type->value();
+		}
+		else throw BadCastException();
+	}
+
+	Array sendCommands(const std::vector<Array>& commands);
+		/// Sends all commands (pipelining) to the Redis server before
+		/// getting all replies.
+
+	void setReceiveTimeout(const Timespan& timeout);
+		/// Sets a receive timeout.
+
+private:
+
+	Client(const Client&);
+	Client& operator = (const Client&);
+
+	Net::SocketAddress _address;
+	Net::StreamSocket _socket;
+
+	void connect();
+		/// Connects to the Redis server
+
+	void connect(const Timespan& timeout);
+		/// Connects to the Redis server and sets a timeout.
+
+	void writeCommand(const Array& command, bool flush);
+		/// Sends a request to the Redis server. Use readReply to get the
+		/// answer. Can also be used for pipelining commands. Make sure you
+		/// call readReply as many times as you called writeCommand, even when
+		/// an error occurred on a command.
+
+	RedisInputStream* _input;
+	RedisOutputStream* _output;
+};
+
+
+inline Net::SocketAddress Client::address() const
+{
+	return _address;
+}
+
+template<> inline
+void Client::execute<void>(const Array& command)
+{
+	writeCommand(command, false);
+}
+
+inline void Client::flush()
+{
+	poco_assert(_output);
+	_output->flush();
+}
+
+inline void Client::setReceiveTimeout(const Timespan& timeout)
+{
+	_socket.setReceiveTimeout(timeout);
+}
+
+
+} } // namespace Poco::Redis
+
+
+#endif //Redis_Client_INCLUDED
--- a/Redis/include/Poco/Redis/Command.h
+++ b/Redis/include/Poco/Redis/Command.h
@ -0,0 +1,256 @@
+//
+// Command.h
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  Command
+//
+// Definition of the Command class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#ifndef Redis_Command_INCLUDED
+#define Redis_Command_INCLUDED
+
+#include "Poco/Redis/Redis.h"
+#include "Poco/Redis/Array.h"
+
+#include <vector>
+#include <map>
+
+namespace Poco {
+namespace Redis {
+
+class Redis_API Command : public Array
+	/// Helper class for creating commands. This class contains
+	/// factory methods for commonly used Redis commands.
+	/// There are two ways of building commands:
+	/// 1. Use this class and the factory methods
+	/// 2. Use the Array or Command class and build the command using the add
+	///    method or << operator.
+	/// For example:
+	///
+	///    Command cmd = Command::set("mykey", "Hello");
+	///
+	/// is the same as:
+	///
+	///    Array cmd;
+	///    cmd << "SET" << "mykey" << "Hello";
+	///
+{
+public:
+
+	typedef std::vector<std::string> StringVec;
+
+	Command(const std::string& command);
+		/// Constructor
+
+	Command(const Command& copy);
+		/// Copy constructor
+
+	virtual ~Command();
+		/// Destructor
+
+	static Command append(const std::string& key, const std::string& value);
+		/// Returns an APPEND command
+
+	static Command blpop(const StringVec& lists, Int64 timeout = 0);
+		/// Returns a BLPOP command
+
+	static Command brpop(const StringVec& lists, Int64 timeout = 0);
+		/// Returns a BRPOP command
+
+	static Command brpoplpush(const std::string& sourceList, const std::string& destinationList, Int64 timeout = 0);
+		/// Returns a BRPOPLPUSH command
+
+	static Command decr(const std::string& key, Int64 by = 0);
+		/// Returns an DECR or DECRBY command. Calls DECR when by is omitted or zero.
+
+	static Command del(const std::string& key);
+		/// Returns an DEL command
+
+	static Command del(const StringVec& keys);
+		/// Returns an DEL command
+
+	static Command get(const std::string& key);
+		/// Returns an GET command
+
+	static Command hdel(const std::string& hash, const std::string& field);
+		/// Returns an HDEL command
+
+	static Command hdel(const std::string& hash, const StringVec& fields);
+		/// Returns an HDEL command
+
+	static Command hexists(const std::string& hash, const std::string& field);
+		/// Returns an HEXISTS command
+
+	static Command hget(const std::string& hash, const std::string& field);
+		/// Returns an HGET command
+
+	static Command hgetall(const std::string& hash);
+		/// Returns an HGETALL command
+
+	static Command hincrby(const std::string& hash, const std::string& field, Int64 by = 1);
+		/// Returns an HINCRBY command
+
+	static Command hkeys(const std::string& hash);
+		/// Returns an HKEYS command
+
+	static Command hlen(const std::string& hash);
+		/// Returns an HLEN command
+
+	static Command hmget(const std::string& hash, const StringVec& fields);
+		/// Returns an HMGET command
+
+	static Command hmset(const std::string& hash, std::map<std::string, std::string>& fields);
+		/// Returns a HMSET command
+
+	static Command hset(const std::string& hash, const std::string& field, const std::string& value, bool create = true);
+		/// Returns an HSET or HSETNX (when create is false) command
+
+	static Command hset(const std::string& hash, const std::string& field, Int64 value, bool create = true);
+		/// Returns an HSET or HSETNX (when create is false) command
+
+	static Command hstrlen(const std::string& hash, const std::string& field);
+		/// Returns an HSTRLEN command (Available for Redis 3.2)
+
+	static Command hvals(const std::string& hash);
+		/// Returns an HVALS command
+
+	static Command incr(const std::string& key, Int64 by = 0);
+		/// Returns an INCR or INCRBY command. Calls INCR when by is omitted or zero.
+
+	static Command lindex(const std::string& list, Int64 index = 0);
+		/// Returns a LINDEX command
+
+	static Command linsert(const std::string& list, bool before, const std::string& reference, const std::string& value);
+		/// Returns a LINSERT command
+
+	static Command llen(const std::string& list);
+		/// Returns a LLEN command
+
+	static Command lpop(const std::string& list);
+		/// Returns a LPOP command
+
+	static Command lpush(const std::string& list, const std::string& value, bool create = true);
+		/// Returns a LPUSH or LPUSHX (when create is false) command
+
+	static Command lpush(const std::string& list, const StringVec& value, bool create = true);
+		/// Returns a LPUSH or LPUSHX (when create is false) command
+
+	static Command lrange(const std::string& list, Int64 start = 0, Int64 stop = -1);
+		/// Returns a LRANGE command. When start and stop is omitted an LRANGE
+		/// command will returned that returns all items of the list.
+
+	static Command lrem(const std::string& list, Int64 count, const std::string& value);
+		/// Returns a LREM command
+
+	static Command lset(const std::string& list, Int64 index, const std::string& value);
+		/// Returns a LSET command
+
+	static Command ltrim(const std::string& list, Int64 start = 0, Int64 stop = -1);
+		/// Returns a LTRIM command
+
+	static Command mget(const StringVec& keys);
+		/// Returns a MGET command
+
+	static Command mset(const std::map<std::string, std::string>& keyvalues, bool create = true);
+		/// Returns a MSET or MSETNX (when create is false) command
+
+	static Command sadd(const std::string& set, const std::string& value);
+		/// Returns a SADD command
+
+	static Command sadd(const std::string& set, const StringVec& values);
+		/// Returns a SADD command
+
+	static Command scard(const std::string& set);
+		/// Returns a SCARD command
+
+	static Command sdiff(const std::string& set1, const std::string& set2);
+		/// Returns a SDIFF command
+
+	static Command sdiff(const std::string& set, const StringVec& sets);
+		/// Returns a SDIFF command
+
+	static Command sdiffstore(const std::string& set, const std::string& set1, const std::string& set2);
+		/// Returns a SDIFFSTORE command
+
+	static Command sdiffstore(const std::string& set, const StringVec& sets);
+		/// Returns a SDIFFSTORE command
+
+	static Command set(const std::string& key, const std::string& value, bool overwrite = true, const Poco::Timespan& expireTime = 0, bool create = true);
+		/// Returns a SET command to set the key with a value
+
+	static Command set(const std::string& key, Int64 value, bool overwrite = true, const Poco::Timespan& expireTime = 0, bool create = true);
+		/// Returns a SET command to set the key with a value
+
+	static Command sinter(const std::string& set1, const std::string& set2);
+		/// Returns a SINTER command
+
+	static Command sinter(const std::string& set, const StringVec& sets);
+		/// Returns a SINTER command
+
+	static Command sinterstore(const std::string& set, const std::string& set1, const std::string& set2);
+		/// Returns a SINTERSTORE command
+
+	static Command sinterstore(const std::string& set, const StringVec& sets);
+		/// Returns a SINTERSTORE command
+
+	static Command sismember(const std::string& set, const std::string& member);
+		/// Returns a SISMEMBER command
+
+	static Command smembers(const std::string& set);
+		/// Returns a SMEMBERS command
+
+	static Command smove(const std::string& source, const std::string& destination, const std::string& member);
+		/// Returns a SMOVE command
+
+	static Command spop(const std::string& set, Int64 count = 0);
+		/// Returns a SPOP command
+
+	static Command srandmember(const std::string& set, Int64 count = 0);
+		/// Returns a SRANDMEMBER command
+
+	static Command srem(const std::string& set, const std::string& member);
+		/// Returns a SREM command
+
+	static Command srem(const std::string& set, const StringVec& members);
+		/// Returns a SREM command
+
+	static Command sunion(const std::string& set1, const std::string& set2);
+		/// Returns a SUNION command
+
+	static Command sunion(const std::string& set, const StringVec& sets);
+		/// Returns a SUNION command
+
+	static Command sunionstore(const std::string& set, const std::string& set1, const std::string& set2);
+		/// Returns a SUNIONSTORE command
+
+	static Command sunionstore(const std::string& set, const StringVec& sets);
+		/// Returns a SUNIONSTORE command
+
+	static Command rename(const std::string& key, const std::string& newName, bool overwrite = true);
+		/// Returns a RENAME or RENAMENX when overwrite is false
+
+	static Command rpop(const std::string& list);
+		/// Returns a RPOP command
+
+	static Command rpoplpush(const std::string& sourceList, const std::string& destinationList);
+		/// Returns a RPOPLPUSH command
+
+	static Command rpush(const std::string& list, const std::string& value, bool create = true);
+		/// Returns a RPUSH or RPUSHX (when create is false) command
+
+	static Command rpush(const std::string& list, const StringVec& value, bool create = true);
+		/// Returns a RPUSH or RPUSHX (when create is false) command
+};
+
+}} // namespace Poco::Redis
+
+#endif // Redis_Command_INCLUDED
--- a/Redis/include/Poco/Redis/Error.h
+++ b/Redis/include/Poco/Redis/Error.h
@ -0,0 +1,81 @@
+//
+// Error.h
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  Error
+//
+// Definition of the Error class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#ifndef Redis_Error_INCLUDED
+#define Redis_Error_INCLUDED
+
+#include "Poco/Redis/Type.h"
+
+namespace Poco {
+namespace Redis {
+
+class Redis_API Error
+	/// Represent a Redis error
+{
+public:
+
+	Error();
+		/// Constructor
+
+	Error(const std::string& message);
+		/// Constructor
+
+	virtual ~Error();
+		/// Destructor
+
+	std::string  getMessage() const;
+		/// Returns the error message
+
+	void setMessage(const std::string& message);
+		/// Sets the error message
+
+private:
+
+	std::string _message;
+};
+
+inline std::string Error::getMessage() const
+{
+	return _message;
+}
+
+inline void Error::setMessage(const std::string& message)
+{
+	_message = message;
+}
+
+template<>
+struct RedisTypeTraits<Error>
+{
+	enum { TypeId = RedisType::REDIS_ERROR };
+
+	static const char marker = '-';
+
+	static std::string toString(const Error& value)
+	{
+		return marker + value.getMessage()  + LineEnding::NEWLINE_CRLF;
+	}
+
+	static void read(RedisInputStream& input, Error& value)
+	{
+		value.setMessage(input.getline());
+	}
+};
+
+}} // Namespace Poco::Redis
+
+#endif // Redis_Error_INCLUDED
--- a/Redis/include/Poco/Redis/Exception.h
+++ b/Redis/include/Poco/Redis/Exception.h
@ -0,0 +1,32 @@
+//
+// Exception.h
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  Exception
+//
+// Definition of the Exception class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#ifndef Redis_Exception_INCLUDED
+#define Redis_Exception_INCLUDED
+
+#include "Poco/Redis/Redis.h"
+#include <typeinfo>
+#include "Poco/Exception.h"
+
+namespace Poco {
+namespace Redis {
+
+POCO_DECLARE_EXCEPTION(Redis_API, RedisException, Exception)
+
+}}
+
+#endif // Redis_Exception_INCLUDED
--- a/Redis/include/Poco/Redis/PoolableConnectionFactory.h
+++ b/Redis/include/Poco/Redis/PoolableConnectionFactory.h
@ -0,0 +1,111 @@
+//
+// PoolableConnectionFactory.h
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  PoolableConnectionFactory
+//
+// Definition of the PoolableConnectionFactory class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Redis_PoolableConnectionFactory_INCLUDED
+#define Redis_PoolableConnectionFactory_INCLUDED
+
+
+#include "Poco/Redis/Client.h"
+#include "Poco/ObjectPool.h"
+
+
+namespace Poco {
+
+
+template<>
+class PoolableObjectFactory<Redis::Client, Redis::Client::Ptr>
+	/// PoolableObjectFactory specialisation for Client. New connections
+	/// are created with the given address.
+{
+public:
+	PoolableObjectFactory(Net::SocketAddress& address)
+		: _address(address)
+	{
+	}
+
+	PoolableObjectFactory(const std::string& address)
+		: _address(address)
+	{
+	}
+
+	Redis::Client::Ptr createObject()
+	{
+		return new Redis::Client(_address);
+	}
+
+	bool validateObject(Redis::Client::Ptr pObject)
+	{
+		return true;
+	}
+
+	void activateObject(Redis::Client::Ptr pObject)
+	{
+	}
+
+	void deactivateObject(Redis::Client::Ptr pObject)
+	{
+	}
+
+	void destroyObject(Redis::Client::Ptr pObject)
+	{
+	}
+
+private:
+	Net::SocketAddress _address;
+};
+
+
+namespace Redis {
+
+
+class Redis_API PooledConnection
+	/// Helper class for borrowing and returning a connection automatically from a pool.
+{
+public:
+	PooledConnection(ObjectPool<Client, Client::Ptr>& pool, long timeoutMilliseconds = 0) : _pool(pool)
+	{
+		_client = _pool.borrowObject(timeoutMilliseconds);
+	}
+
+	virtual ~PooledConnection()
+	{
+		try
+		{
+			_pool.returnObject(_client);
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+
+	operator Client::Ptr ()
+	{
+		return _client;
+	}
+
+private:
+	ObjectPool<Client, Client::Ptr>& _pool;
+	Client::Ptr _client;
+};
+
+
+} // namespace Redis
+} // namespace Poco
+
+#endif // Redis_PoolableConnectionFactory_INCLUDED
--- a/Redis/include/Poco/Redis/Redis.h
+++ b/Redis/include/Poco/Redis/Redis.h
@ -0,0 +1,66 @@
+//
+// Redis.h
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  Redis
+//
+// Basic definitions for the Poco Redis library.
+// This file must be the first file included by every other Redis
+// header file.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef RedisRedis_INCLUDED
+#define RedisRedis_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+//
+// The following block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the Redis_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// Redis_API functions as being imported from a DLL, wheras this DLL sees symbols
+// defined with this macro as being exported.
+//
+
+
+#if defined(_WIN32) && defined(POCO_DLL)
+	#if defined(Redis_EXPORTS)
+		#define Redis_API __declspec(dllexport)
+	#else
+		#define Redis_API __declspec(dllimport)
+	#endif
+#endif
+
+
+#if !defined(Redis_API)
+	#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
+		#define Redis_API __attribute__ ((visibility ("default")))
+	#else
+		#define Redis_API
+	#endif
+#endif
+
+
+//
+// Automatically link Redis library.
+//
+#if defined(_MSC_VER)
+	#if !defined(POCO_NO_AUTOMATIC_LIBS) && !defined(Redis_EXPORTS)
+		#pragma comment(lib, "PocoRedis" POCO_LIB_SUFFIX)
+	#endif
+#endif
+
+
+#endif // RedisRedis_INCLUDED
--- a/Redis/include/Poco/Redis/RedisEventArgs.h
+++ b/Redis/include/Poco/Redis/RedisEventArgs.h
@ -0,0 +1,85 @@
+//
+// RedisEventArgs.h
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  RedisEventArgs
+//
+// Definition of the RedisEventArgs class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#ifndef Redis_RedisEventArgs_INCLUDED
+#define Redis_RedisEventArgs_INCLUDED
+
+#include "Poco/Redis/Type.h"
+
+namespace Poco {
+namespace Redis {
+
+class Redis_API RedisEventArgs
+{
+public:
+	RedisEventArgs(RedisType::Ptr message);
+		/// Constructor
+
+	RedisEventArgs(Exception* e);
+		/// Constructor
+
+	~RedisEventArgs();
+		/// Destructor
+
+	RedisType::Ptr message() const;
+		/// Returns the message retrieved from the Redis server.
+		/// This can be a NULL pointer when this event is about an exception.
+
+	const Exception* exception() const;
+		/// Returns the exception if any, otherwise it returns null pointer
+
+	void stop();
+		/// When called, the AsyncReader will stop.
+		/// Note: The AsyncReader will always stop when this is an exception
+		/// event. Use this for example for pub/sub when there are no
+		/// subcribers anymore ...
+
+	bool isStopped() const;
+		/// Returns true when the AsyncReader will stop
+
+private:
+	RedisType::Ptr _message;
+
+	Exception* _exception;
+
+	bool _stop;
+};
+
+inline RedisType::Ptr RedisEventArgs::message() const
+{
+	return _message;
+}
+
+inline const Exception* RedisEventArgs::exception() const
+{
+	return _exception;
+}
+
+inline bool RedisEventArgs::isStopped() const
+{
+	return _stop;
+}
+
+inline void RedisEventArgs::stop()
+{
+	_stop = true;
+}
+
+
+}} // namespace Poco::Redis
+
+#endif // Redis_RedisEventArgs_INCLUDED
--- a/Redis/include/Poco/Redis/RedisStream.h
+++ b/Redis/include/Poco/Redis/RedisStream.h
@ -0,0 +1,112 @@
+//
+// RedisStream.h
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  RedisStream
+//
+// Definition of the RedisStream class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#ifndef Redis_RedisStream_INCLUDED
+#define Redis_RedisStream_INCLUDED
+
+#include "Poco/BufferedStreamBuf.h"
+#include "Poco/Net/StreamSocket.h"
+
+#include <istream>
+#include <ostream>
+
+namespace Poco {
+namespace Redis {
+
+class RedisStreamBuf : public BufferedStreamBuf
+	/// BufferedStreamBuf for Redis
+{
+public:
+	RedisStreamBuf(Net::StreamSocket& redis);
+		/// Constructor
+
+	~RedisStreamBuf();
+		/// Destructor
+
+	std::string readLine();
+		/// Reads a line from Redis (until \r\n is encountered).
+
+protected:
+	int readFromDevice(char* buffer, std::streamsize length);
+
+	int writeToDevice(const char* buffer, std::streamsize length);
+
+private:
+
+	enum
+	{
+		STREAM_BUFFER_SIZE = 1024
+	};
+
+	Net::StreamSocket& _redis;
+};
+
+class RedisIOS: public virtual std::ios
+{
+public:
+	RedisIOS(Net::StreamSocket& redis);
+		/// Creates the RedisIOS with the given socket.
+
+	~RedisIOS();
+		/// Destroys the RedisIOS.
+		///
+		/// Flushes the buffer, but does not close the socket.
+
+	RedisStreamBuf* rdbuf();
+		/// Returns a pointer to the internal RedisStreamBuf.
+
+	void close();
+		/// Flushes the stream.
+
+protected:
+	RedisStreamBuf _buf;
+};
+
+
+class RedisOutputStream: public RedisIOS, public std::ostream
+	/// An output stream for writing to a Redis server.
+{
+public:
+	RedisOutputStream(Net::StreamSocket& redis);
+		/// Creates the RedisOutputStream with the given socket.
+
+	~RedisOutputStream();
+		/// Destroys the RedisOutputStream.
+		///
+		/// Flushes the buffer.
+};
+
+
+class RedisInputStream: public RedisIOS, public std::istream
+	/// An input stream for reading from a Redis server.
+{
+public:
+	RedisInputStream(Net::StreamSocket& redis);
+		/// Creates the RedisInputStream with the given socket.
+
+	~RedisInputStream();
+		/// Destroys the RedisInputStream.
+
+	std::string getline();
+		/// Redis uses /r/n as delimiter. This getline version removes
+		/// the /r from the result.
+};
+
+
+}} // Poco::Redis
+
+#endif // Redis_RedisStream_INCLUDED
--- a/Redis/include/Poco/Redis/Type.h
+++ b/Redis/include/Poco/Redis/Type.h
@ -0,0 +1,276 @@
+//
+// Type.h
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  Type
+//
+// Definition of the Type class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#ifndef Redis_Type_INCLUDED
+#define Redis_Type_INCLUDED
+
+#include "Poco/LineEndingConverter.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/NumberParser.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Nullable.h"
+
+#include "Poco/Redis/Redis.h"
+#include "Poco/Redis/RedisStream.h"
+
+namespace Poco {
+namespace Redis {
+
+
+class Redis_API RedisType
+	/// Base class for all Redis types. This class makes it possible to store
+	/// element with different types in Array.
+{
+public:
+
+	enum Types {
+		REDIS_INTEGER, // Redis Integer
+		REDIS_SIMPLE_STRING, // Redis Simple String
+		REDIS_BULK_STRING, // Redis Bulkstring
+		REDIS_ARRAY, // Redis Array
+		REDIS_ERROR // Redis Error
+	};
+
+	typedef SharedPtr<RedisType> Ptr;
+
+	RedisType();
+		/// Constructor
+
+	virtual ~RedisType();
+		/// Destructor
+
+	bool isArray() const;
+		/// Returns true when the value is a Redis array.
+
+	bool isBulkString() const;
+		/// Returns true when the value is a Redis bulkstring.
+
+	bool isError() const;
+		/// Returns true when the value is a Redis error.
+
+	bool isInteger() const;
+		/// Returns true when the value is a Redis integer (64 bit integer)
+
+	bool isSimpleString() const;
+		/// Returns true when the value is a simple string.
+
+	virtual int type() const = 0;
+		/// Returns the type of the value.
+
+	virtual void read(RedisInputStream& input) = 0;
+		/// Reads the value from the stream.
+
+	virtual std::string toString() const = 0;
+		/// Converts the value to a RESP (REdis Serialization Protocol) string.
+
+	static RedisType::Ptr createRedisType(char marker);
+		/// Create a Redis type based on the marker :
+		/// + : a simple string (std::string)
+		/// - : an error (Error)
+		/// $ : a bulk string (BulkString)
+		/// * : an array (Array)
+		/// : : a signed 64 bit integer (Int64)
+
+private:
+
+};
+
+inline bool RedisType::isArray() const
+{
+	return type() == REDIS_ARRAY;
+}
+
+inline bool RedisType::isBulkString() const
+{
+	return type() == REDIS_BULK_STRING;
+}
+
+inline bool RedisType::isError() const
+{
+	return type() == REDIS_ERROR;
+}
+
+inline bool RedisType::isInteger() const
+{
+	return type() == REDIS_INTEGER;
+}
+
+inline bool RedisType::isSimpleString() const
+{
+	return type() == REDIS_SIMPLE_STRING;
+}
+
+template<typename T>
+struct RedisTypeTraits
+{
+};
+
+
+template<>
+struct RedisTypeTraits<Int64>
+{
+	enum { TypeId = RedisType::REDIS_INTEGER };
+
+	static const char marker = ':';
+
+	static std::string toString(const Int64& value)
+	{
+		return marker + NumberFormatter::format(value) + "\r\n";
+	}
+
+	static void read(RedisInputStream& input, Int64& value)
+	{
+		std::string number = input.getline();
+		value = NumberParser::parse64(number);
+	}
+
+};
+
+
+template<>
+struct RedisTypeTraits<std::string>
+{
+	enum { TypeId = RedisType::REDIS_SIMPLE_STRING };
+
+	static const char marker = '+';
+
+	static std::string toString(const std::string& value)
+	{
+		return marker + value + LineEnding::NEWLINE_CRLF;
+	}
+
+	static void read(RedisInputStream& input, std::string& value)
+	{
+		value = input.getline();
+	}
+};
+
+
+typedef Nullable<std::string> BulkString;
+	/// A bulk string is a string that can contain a NULL value.
+	/// So, BulkString is a typedef for Nullable<std::string>.
+
+
+template<>
+struct RedisTypeTraits<BulkString>
+{
+	enum { TypeId = RedisType::REDIS_BULK_STRING };
+
+	static const char marker = '$';
+
+	static std::string toString(const BulkString& value)
+	{
+		if ( value.isNull() )
+		{
+			return marker + std::string("-1") + LineEnding::NEWLINE_CRLF;
+		}
+		else
+		{
+			std::string s = value.value();
+			return marker
+				+ NumberFormatter::format(s.length())
+				+ LineEnding::NEWLINE_CRLF
+				+ s
+				+ LineEnding::NEWLINE_CRLF;
+		}
+	}
+
+	static void read(RedisInputStream& input, BulkString& value)
+	{
+		value.clear();
+
+		std::string line = input.getline();
+		int length = NumberParser::parse(line);
+
+		if ( length >= 0 )
+		{
+			std::string s;
+			s.resize(length, ' ');
+			input.read(&*s.begin(), length);
+			value.assign(s);
+
+			input.getline(); // Read and ignore /r/n
+		}
+	}
+};
+
+
+template<typename T>
+class Type : public RedisType
+	/// Template class for all Redis types. This class will use
+	/// RedisTypeTraits structure for calling the type specific code.
+{
+public:
+
+	Type()
+		/// Constructor
+	{
+	}
+
+	Type(const T& t) : _value(t)
+		/// Constructor
+	{
+	}
+
+	Type(const Type& copy) : _value(copy._value)
+		/// Copy Constructor
+	{
+	}
+
+	virtual ~Type()
+		/// Destructor
+	{
+	}
+
+	int type() const
+		/// Returns the type of the value
+	{
+		return RedisTypeTraits<T>::TypeId;
+	}
+
+	void read(RedisInputStream& socket)
+		/// Reads the value from the stream (RESP).
+	{
+		RedisTypeTraits<T>::read(socket, _value);
+	}
+
+	std::string toString() const
+		/// Converts the value to a string based on the RESP protocol.
+	{
+		return RedisTypeTraits<T>::toString(_value);
+	}
+
+	T& value()
+		/// Returns the value
+	{
+		return _value;
+	}
+
+	const T& value() const
+		/// Returns a const value
+	{
+		return _value;
+	}
+
+private:
+
+	T _value;
+};
+
+}} // Namespace Poco/Redis
+
+#endif // Redis_Type_INCLUDED
--- a/Redis/src/Array.cpp
+++ b/Redis/src/Array.cpp
@ -0,0 +1,65 @@
+//
+// Array.h
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  Array
+//
+// Implementation of the Array class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#include "Poco/Redis/Array.h"
+
+namespace Poco {
+namespace Redis {
+
+
+Array::Array()
+{
+}
+
+
+Array::Array(const Array& copy) : _elements(copy._elements)
+{
+}
+
+
+Array::~Array()
+{
+}
+
+
+Array& Array::addRedisType(RedisType::Ptr value)
+{
+	checkNull();
+
+	_elements.value().push_back(value);
+
+	return *this;
+}
+
+
+int Array::getType(size_t pos) const
+{
+	if ( _elements.isNull() ) throw NullValueException();
+
+	if ( pos >= _elements.value().size() ) throw InvalidArgumentException();
+
+	RedisType::Ptr element = _elements.value().at(pos);
+	return element->type();
+}
+
+
+std::string Array::toString() const
+{
+	return RedisTypeTraits<Array>::toString(*this);
+}
+
+} }
--- a/Redis/src/AsyncReader.cpp
+++ b/Redis/src/AsyncReader.cpp
@ -0,0 +1,60 @@
+//
+// AsyncReader.cpp
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  AsyncReader
+//
+// Implementation of the AsyncReader class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#include "Poco/Redis/AsyncReader.h"
+
+namespace Poco {
+namespace Redis {
+
+
+AsyncReader::AsyncReader(Client& client) : _client(client),
+	_activity(this, &AsyncReader::runActivity)
+{
+}
+
+
+AsyncReader::~AsyncReader()
+{
+	stop();
+}
+
+
+void AsyncReader::runActivity()
+{
+	while(!_activity.isStopped())
+	{
+		try
+		{
+			RedisType::Ptr reply = _client.readReply();
+
+			RedisEventArgs args(reply);
+			redisResponse.notify(this, args);
+
+			if ( args.isStopped() ) stop();
+		}
+		catch(Exception& e)
+		{
+			RedisEventArgs args(&e);
+			redisException.notify(this, args);
+			stop();
+		}
+		if (!_activity.isStopped()) Thread::trySleep(100);
+	}
+}
+
+
+} } // Poco::Redis
--- a/Redis/src/Client.cpp
+++ b/Redis/src/Client.cpp
@ -0,0 +1,176 @@
+//
+// Client.cpp
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  Client
+//
+// Implementation of the Client class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#include "Poco/Redis/Client.h"
+#include "Poco/Redis/Exception.h"
+
+namespace Poco {
+namespace Redis {
+
+
+Client::Client() : _address(), _socket(), _input(0), _output(0)
+{
+}
+
+
+Client::Client(const std::string& hostAndPort) : _address(hostAndPort), _socket(), _input(0), _output(0)
+{
+	connect();
+}
+
+
+Client::Client(const std::string& host, int port) : _address(host, port), _socket(), _input(0), _output(0)
+{
+	connect();
+}
+
+
+Client::Client(const Net::SocketAddress& addrs) : _address(addrs), _socket(), _input(0), _output(0)
+{
+	connect();
+}
+
+
+Client::~Client()
+{
+	delete _input;
+	delete _output;
+}
+
+
+void Client::connect()
+{
+	poco_assert(! _input);
+	poco_assert(! _output);
+
+	_socket.connect(_address);
+	_input = new RedisInputStream(_socket);
+	_output = new RedisOutputStream(_socket);
+}
+
+void Client::connect(const std::string& hostAndPort)
+{
+	_address = Net::SocketAddress(hostAndPort);
+	connect();
+}
+
+
+void Client::connect(const std::string& host, int port)
+{
+	_address = Net::SocketAddress(host, port);
+	connect();
+}
+
+
+void Client::connect(const Net::SocketAddress& addrs)
+{
+	_address = addrs;
+	connect();
+}
+
+void Client::connect(const Timespan& timeout)
+{
+	poco_assert(! _input);
+	poco_assert(! _output);
+
+	_socket.connect(_address, timeout);
+	_input = new RedisInputStream(_socket);
+	_output = new RedisOutputStream(_socket);
+}
+
+void Client::connect(const std::string& hostAndPort, const Timespan& timeout)
+{
+	_address = Net::SocketAddress(hostAndPort);
+	connect(timeout);
+}
+
+
+void Client::connect(const std::string& host, int port, const Timespan& timeout)
+{
+	_address = Net::SocketAddress(host, port);
+	connect(timeout);
+}
+
+
+void Client::connect(const Net::SocketAddress& addrs, const Timespan& timeout)
+{
+	_address = addrs;
+	connect(timeout);
+}
+
+void Client::disconnect()
+{
+	delete _input;
+	_input = 0;
+
+	delete _output;
+	_output = 0;
+
+	_socket.close();
+}
+
+void Client::writeCommand(const Array& command, bool flush)
+{
+	poco_assert(_output);
+
+	std::string commandStr = command.toString();
+
+	_output->write(commandStr.c_str(), commandStr.length());
+	if ( flush ) _output->flush();
+}
+
+RedisType::Ptr Client::readReply()
+{
+	poco_assert(_input);
+
+	int c = _input->get();
+	RedisType::Ptr result = RedisType::createRedisType(c);
+	if ( result.isNull() )
+	{
+		throw RedisException("Invalid Redis type returned");
+	}
+
+	result->read(*_input);
+
+	return result;
+}
+
+RedisType::Ptr Client::sendCommand(const Array& command)
+{
+	writeCommand(command, true);
+	return readReply();
+}
+
+Array Client::sendCommands(const std::vector<Array>& commands)
+{
+	Array results;
+
+	for(std::vector<Array>::const_iterator it = commands.begin(); it != commands.end(); ++it)
+	{
+		writeCommand(*it, false);
+	}
+	_output->flush();
+
+	for(int i = 0; i < commands.size(); ++i)
+	{
+		results.addRedisType(readReply());
+	}
+
+	return results;
+}
+
+} } // Poco::Redis
--- a/Redis/src/Command.cpp
+++ b/Redis/src/Command.cpp
@ -0,0 +1,620 @@
+//
+// Command.cpp
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  Command
+//
+// Implementation of the Command class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#include "Poco/Redis/Command.h"
+#include "Poco/NumberFormatter.h"
+
+namespace Poco {
+namespace Redis {
+
+Command::Command(const std::string& command) : Array()
+{
+	add(command);
+}
+
+Command::Command(const Command& copy) : Array(copy)
+{
+}
+
+Command::~Command()
+{
+}
+
+Command Command::append(const std::string& key, const std::string& value)
+{
+	Command cmd("APPEND");
+
+	cmd << key << value;
+
+	return cmd;
+}
+
+Command Command::blpop(const StringVec& lists, Int64 timeout)
+{
+	Command cmd("BLPOP");
+
+	cmd << lists << NumberFormatter::format(timeout);
+
+	return cmd;
+}
+
+Command Command::brpop(const StringVec& lists, Int64 timeout)
+{
+	Command cmd("BRPOP");
+
+	cmd << lists << NumberFormatter::format(timeout);
+
+	return cmd;
+}
+
+Command Command::brpoplpush(const std::string& sourceList, const std::string& destinationList, Int64 timeout)
+{
+	Command cmd("BRPOPLPUSH");
+
+	cmd << sourceList << destinationList << NumberFormatter::format(timeout);
+
+	return cmd;
+}
+
+Command Command::decr(const std::string& key, Int64 by)
+{
+	Command cmd(by == 0 ? "DECR" : "DECRBY");
+
+	cmd << key;
+	if ( by > 0 ) cmd << NumberFormatter::format(by);
+
+	return cmd;
+}
+
+Command Command::del(const std::string& key)
+{
+	Command cmd("DEL");
+
+	cmd << key;
+
+	return cmd;
+}
+
+Command Command::del(const StringVec& keys)
+{
+	Command cmd("DEL");
+
+	cmd << keys;
+
+	return cmd;
+}
+
+Command Command::get(const std::string& key)
+{
+	Command cmd("GET");
+
+	cmd << key;
+
+	return cmd;
+}
+
+Command Command::hdel(const std::string& hash, const std::string& field)
+{
+	Command cmd("HDEL");
+
+	cmd << hash << field;
+
+	return cmd;
+}
+
+Command Command::hdel(const std::string& hash, const StringVec& fields)
+{
+	Command cmd("HDEL");
+
+	cmd << hash << fields;
+
+	return cmd;
+}
+
+Command Command::hexists(const std::string& hash, const std::string& field)
+{
+	Command cmd("HEXISTS");
+
+	cmd << hash << field;
+
+	return cmd;
+}
+
+Command Command::hget(const std::string& hash, const std::string& field)
+{
+	Command cmd("HGET");
+
+	cmd << hash << field;
+
+	return cmd;
+}
+
+Command Command::hgetall(const std::string& hash)
+{
+	Command cmd("HGETALL");
+
+	cmd << hash;
+
+	return cmd;
+}
+
+Command Command::hincrby(const std::string& hash, const std::string& field, Int64 by)
+{
+	Command cmd("HINCRBY");
+
+	cmd << hash << field << NumberFormatter::format(by);
+
+	return cmd;
+}
+
+Command Command::hkeys(const std::string& hash)
+{
+	Command cmd("HKEYS");
+
+	cmd << hash;
+
+	return cmd;
+}
+
+Command Command::hlen(const std::string& hash)
+{
+	Command cmd("HLEN");
+
+	cmd << hash;
+
+	return cmd;
+}
+
+Command Command::hmget(const std::string& hash, const StringVec& fields)
+{
+	Command cmd("HMGET");
+
+	cmd << hash << fields;
+
+	return cmd;
+}
+
+Command Command::hmset(const std::string& hash, std::map<std::string, std::string>& fields)
+{
+	Command cmd("HMSET");
+
+	cmd << hash;
+	for(std::map<std::string, std::string>::const_iterator it = fields.begin(); it != fields.end(); ++it)
+	{
+		cmd << it->first << it->second;
+	}
+
+	return cmd;
+}
+
+Command Command::hset(const std::string& hash, const std::string& field, const std::string& value, bool create)
+{
+	Command cmd(create ? "HSET" : "HSETNX");
+
+	cmd << hash << field << value;
+
+	return cmd;
+}
+
+Command Command::hset(const std::string& hash, const std::string& field, Int64 value, bool create)
+{
+	return hset(hash, field, NumberFormatter::format(value), create);
+}
+
+Command Command::hstrlen(const std::string& hash, const std::string& field)
+{
+	Command cmd("HSTRLEN");
+
+	cmd << hash << field;
+
+	return cmd;
+}
+
+Command Command::hvals(const std::string& hash)
+{
+	Command cmd("HVALS");
+
+	cmd << hash;
+
+	return cmd;
+}
+
+Command Command::incr(const std::string& key, Int64 by)
+{
+	Command cmd(by == 0 ? "INCR" : "INCRBY");
+
+	cmd << key;
+	if ( by > 0 ) cmd << NumberFormatter::format(by);
+
+	return cmd;
+}
+
+Command Command::lindex(const std::string& list, Int64 index)
+{
+	Command cmd("LINDEX");
+
+	cmd << list << NumberFormatter::format(index);
+
+	return cmd;
+}
+
+Command Command::linsert(const std::string& list, bool before, const std::string& reference, const std::string& value)
+{
+	Command cmd("LINSERT");
+
+	cmd << list << (before ? "BEFORE" : "AFTER") << reference << value;
+	return cmd;
+}
+
+Command Command::llen(const std::string& list)
+{
+	Command cmd("LLEN");
+
+	cmd << list;
+
+	return cmd;
+}
+
+Command Command::lpop(const std::string& list)
+{
+	Command cmd("LPOP");
+
+	cmd << list;
+
+	return cmd;
+}
+
+Command Command::lpush(const std::string& list, const std::string& value, bool create)
+{
+	Command cmd(create ? "LPUSH" : "LPUSHX");
+
+	cmd << list << value;
+
+	return cmd;
+}
+
+Command Command::lpush(const std::string& list, const StringVec& values, bool create)
+{
+	Command cmd(create ? "LPUSH" : "LPUSHX");
+
+	cmd << list << values;
+
+	return cmd;
+}
+
+Command Command::lrange(const std::string& list, Int64 start, Int64 stop)
+{
+	Command cmd("LRANGE");
+
+	cmd << list << NumberFormatter::format(start) << NumberFormatter::format(stop);
+
+	return cmd;
+}
+
+Command Command::lrem(const std::string& list, Int64 count, const std::string& value)
+{
+	Command cmd("LREM");
+
+	cmd << list << NumberFormatter::format(count) << value;
+
+	return cmd;
+}
+
+Command Command::lset(const std::string& list, Int64 index, const std::string& value)
+{
+	Command cmd("LSET");
+
+	cmd << list << NumberFormatter::format(index) << value;
+
+	return cmd;
+}
+
+Command Command::ltrim(const std::string& list, Int64 start, Int64 stop)
+{
+	Command cmd("LTRIM");
+
+	cmd << list << NumberFormatter::format(start) << NumberFormatter::format(stop);
+
+	return cmd;
+}
+
+Command Command::mget(const StringVec& keys)
+{
+	Command cmd("MGET");
+
+	cmd << keys;
+
+	return cmd;
+}
+
+Command Command::mset(const std::map<std::string, std::string>& keyvalues, bool create)
+{
+	Command cmd(create ? "MSET" : "MSETNX");
+
+	for(std::map<std::string, std::string>::const_iterator it = keyvalues.begin(); it != keyvalues.end(); ++it)
+	{
+		cmd << it->first << it->second;
+	}
+
+	return cmd;
+}
+
+Command Command::sadd(const std::string& set, const std::string& value)
+{
+	Command cmd("SADD");
+
+	cmd << set << value;
+
+	return cmd;
+}
+
+Command Command::sadd(const std::string& set, const StringVec& values)
+{
+	Command cmd("SADD");
+
+	cmd << set << values;
+
+	return cmd;
+}
+
+Command Command::scard(const std::string& set)
+{
+	Command cmd("SCARD");
+
+	cmd << set;
+
+	return cmd;
+}
+
+Command Command::sdiff(const std::string& set1, const std::string& set2)
+{
+	Command cmd("SDIFF");
+
+	cmd << set1 << set2;
+
+	return cmd;
+}
+
+Command Command::sdiff(const std::string& set, const StringVec& sets)
+{
+	Command cmd("SDIFF");
+
+	cmd << set << sets;
+
+	return cmd;
+}
+
+Command Command::sdiffstore(const std::string& set, const std::string& set1, const std::string& set2)
+{
+	Command cmd("SDIFFSTORE");
+
+	cmd << set << set1 << set2;
+
+	return cmd;
+}
+
+Command Command::sdiffstore(const std::string& set, const StringVec& sets)
+{
+	Command cmd("SDIFFSTORE");
+
+	cmd << set << sets;
+
+	return cmd;
+}
+
+Command Command::set(const std::string& key, const std::string& value, bool overwrite, const Poco::Timespan& expireTime, bool create)
+{
+	Command cmd("SET");
+
+	cmd << key << value;
+	if (! overwrite) cmd << "NX";
+	if (! create) cmd << "XX";
+	if (expireTime.totalMicroseconds() > 0) cmd << "PX" << expireTime.totalMilliseconds();
+
+	return cmd;
+}
+
+Command Command::set(const std::string& key, Int64 value, bool overwrite, const Poco::Timespan& expireTime, bool create)
+{
+	return set(key, NumberFormatter::format(value), overwrite, expireTime, create);
+}
+
+Command Command::sinter(const std::string& set1, const std::string& set2)
+{
+	Command cmd("SINTER");
+
+	cmd << set1 << set2;
+
+	return cmd;
+}
+
+Command Command::sinter(const std::string& set, const StringVec& sets)
+{
+	Command cmd("SINTER");
+
+	cmd << set << sets;
+
+	return cmd;
+}
+
+Command Command::sinterstore(const std::string& set, const std::string& set1, const std::string& set2)
+{
+	Command cmd("SINTERSTORE");
+
+	cmd << set << set1 << set2;
+
+	return cmd;
+}
+
+Command Command::sinterstore(const std::string& set, const StringVec& sets)
+{
+	Command cmd("SINTERSTORE");
+
+	cmd << set << sets;
+
+	return cmd;
+}
+
+Command Command::sismember(const std::string& set, const std::string& member)
+{
+	Command cmd("SISMEMBER");
+
+	cmd << set << member;
+
+	return cmd;
+}
+
+Command Command::smembers(const std::string& set)
+{
+	Command cmd("SMEMBERS");
+
+	cmd << set;
+
+	return cmd;
+}
+
+Command Command::smove(const std::string& source, const std::string& destination, const std::string& member)
+{
+	Command cmd("SMOVE");
+
+	cmd << source  << destination << member;
+
+	return cmd;
+}
+
+Command Command::spop(const std::string& set, Int64 count)
+{
+	Command cmd("SPOP");
+
+	cmd << set;
+	if( count != 0 ) cmd << NumberFormatter::format(count);
+
+	return cmd;
+}
+
+Command Command::srandmember(const std::string& set, Int64 count)
+{
+	Command cmd("SRANDMEMBER");
+
+	cmd << set;
+	if( count != 0 ) cmd << NumberFormatter::format(count);
+
+	return cmd;
+}
+
+Command Command::srem(const std::string& set1, const std::string& member)
+{
+	Command cmd("SREM");
+
+	cmd << set1 << member;
+
+	return cmd;
+}
+
+Command Command::srem(const std::string& set, const StringVec& members)
+{
+	Command cmd("SREM");
+
+	cmd << set << members;
+
+	return cmd;
+}
+
+Command Command::sunion(const std::string& set1, const std::string& set2)
+{
+	Command cmd("SUNION");
+
+	cmd << set1 << set2;
+
+	return cmd;
+}
+
+Command Command::sunion(const std::string& set, const StringVec& sets)
+{
+	Command cmd("SUNION");
+
+	cmd << set << sets;
+
+	return cmd;
+}
+
+Command Command::sunionstore(const std::string& set, const std::string& set1, const std::string& set2)
+{
+	Command cmd("SUNIONSTORE");
+
+	cmd << set << set1 << set2;
+
+	return cmd;
+}
+
+Command Command::sunionstore(const std::string& set, const StringVec& sets)
+{
+	Command cmd("SUNIONSTORE");
+
+	cmd << set << sets;
+
+	return cmd;
+}
+
+Command Command::rename(const std::string& key, const std::string& newName, bool overwrite)
+{
+	Command cmd(overwrite ? "RENAME" : "RENAMENX");
+
+	cmd << key << newName;
+
+	return cmd;
+}
+
+
+Command Command::rpop(const std::string& list)
+{
+	Command cmd("RPOP");
+
+	cmd << list;
+
+	return cmd;
+}
+
+Command Command::rpoplpush(const std::string& sourceList, const std::string& destinationList)
+{
+	Command cmd("RPOPLPUSH");
+
+	cmd << sourceList << destinationList;
+
+	return cmd;
+}
+
+Command Command::rpush(const std::string& list, const std::string& value, bool create)
+{
+	Command cmd(create ? "RPUSH" : "RPUSHX");
+
+	cmd << list << value;
+
+	return cmd;
+}
+
+Command Command::rpush(const std::string& list, const StringVec& values, bool create)
+{
+	Command cmd(create ? "RPUSH" : "RPUSHX");
+
+	cmd << list << values;
+
+	return cmd;
+}
+
+
+}} // Poco::Redis
--- a/Redis/src/Error.cpp
+++ b/Redis/src/Error.cpp
@ -0,0 +1,35 @@
+//
+// Error.cpp
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  Error
+//
+// Implementation of the Error class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#include "Poco/Redis/Error.h"
+
+namespace Poco {
+namespace Redis {
+
+Error::Error()
+{
+}
+
+Error::Error(const std::string& message) : _message(message)
+{
+}
+
+Error::~Error()
+{
+}
+
+} }
--- a/Redis/src/Exception.cpp
+++ b/Redis/src/Exception.cpp
@ -0,0 +1,25 @@
+//
+// Exception.h
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  Exception
+//
+// Implementation of the Exception class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#include "Poco/Redis/Exception.h"
+
+namespace Poco {
+namespace Redis {
+
+POCO_IMPLEMENT_EXCEPTION(RedisException, Exception, "Redis Exception")
+
+}}
--- a/Redis/src/RedisEventArgs.cpp
+++ b/Redis/src/RedisEventArgs.cpp
@ -0,0 +1,43 @@
+//
+// RedisEventArgs.cpp
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  RedisEventArgs
+//
+// Implementation of the RedisEventArgs class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#include "Poco/Redis/RedisEventArgs.h"
+
+namespace Poco {
+namespace Redis {
+
+RedisEventArgs::RedisEventArgs(RedisType::Ptr message) :
+	_message(message),
+	_exception(0),
+	_stop(false)
+{
+}
+
+RedisEventArgs::RedisEventArgs(Exception* exception) :
+	_message(),
+	_exception(exception ? exception->clone() : 0),
+	_stop(false)
+{
+}
+
+RedisEventArgs::~RedisEventArgs()
+{
+	delete _exception;
+}
+
+
+}} // namespace Poco::Redis
--- a/Redis/src/RedisStream.cpp
+++ b/Redis/src/RedisStream.cpp
@ -0,0 +1,108 @@
+//
+// RedisStream.cpp
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  RedisStream
+//
+// Implementation of the RedisStream class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+#include <iostream>
+#include "Poco/Redis/RedisStream.h"
+
+namespace Poco {
+namespace Redis {
+
+
+RedisStreamBuf::RedisStreamBuf(Net::StreamSocket& redis):
+	BufferedStreamBuf(STREAM_BUFFER_SIZE, std::ios::in | std::ios::out),
+	_redis(redis)
+{
+}
+
+
+RedisStreamBuf::~RedisStreamBuf()
+{
+}
+
+
+int RedisStreamBuf::readFromDevice(char* buffer, std::streamsize len)
+{
+	return _redis.receiveBytes(buffer, len);
+}
+
+
+int RedisStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	return _redis.sendBytes(buffer, length);
+}
+
+RedisIOS::RedisIOS(Net::StreamSocket& redis):
+	_buf(redis)
+{
+	poco_ios_init(&_buf);
+}
+
+
+RedisIOS::~RedisIOS()
+{
+	try
+	{
+		_buf.sync();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+RedisStreamBuf* RedisIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+void RedisIOS::close()
+{
+	_buf.sync();
+}
+
+RedisOutputStream::RedisOutputStream(Net::StreamSocket& redis):
+	RedisIOS(redis),
+	std::ostream(&_buf)
+{
+}
+
+
+RedisOutputStream::~RedisOutputStream()
+{
+}
+
+RedisInputStream::RedisInputStream(Net::StreamSocket& redis):
+	RedisIOS(redis),
+	std::istream(&_buf)
+{
+}
+
+
+RedisInputStream::~RedisInputStream()
+{
+}
+
+std::string RedisInputStream::getline()
+{
+	std::string line;
+	std::getline(*this, line);
+	if ( line.size() > 0 ) line.erase(line.end() - 1);
+	return line;
+}
+
+
+}}
--- a/Redis/src/Type.cpp
+++ b/Redis/src/Type.cpp
@ -0,0 +1,61 @@
+//
+// Type.h
+//
+// $Id$
+//
+// Library: Redis
+// Package: Redis
+// Module:  Type
+//
+// Implementation of the Type class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#include "Poco/Redis/Type.h"
+#include "Poco/Redis/Error.h"
+#include "Poco/Redis/Array.h"
+
+namespace Poco {
+namespace Redis {
+
+
+RedisType::RedisType()
+{
+}
+
+RedisType::~RedisType()
+{
+}
+
+
+RedisType::Ptr RedisType::createRedisType(char marker)
+{
+	RedisType::Ptr result;
+
+	switch(marker)
+	{
+		case RedisTypeTraits<Int64>::marker :
+			result = new Type<Int64>();
+			break;
+		case RedisTypeTraits<std::string>::marker :
+			result = new Type<std::string>();
+			break;
+		case RedisTypeTraits<BulkString>::marker :
+			result = new Type<BulkString>();
+			break;
+		case RedisTypeTraits<Array>::marker :
+			result = new Type<Array>();
+			break;
+		case RedisTypeTraits<Error>::marker :
+			result = new Type<Error>();
+			break;
+	}
+	return result;
+}
+
+
+}}
--- a/Redis/testsuite/CMakeLists.txt
+++ b/Redis/testsuite/CMakeLists.txt
@ -0,0 +1,23 @@
+set(TESTUNIT "${LIBNAME}-testrunner")
+
+# Sources
+file(GLOB SRCS_G "src/*.cpp")
+POCO_SOURCES_AUTO( TEST_SRCS ${SRCS_G})
+
+# Headers
+file(GLOB_RECURSE HDRS_G "src/*.h" )
+POCO_HEADERS_AUTO( TEST_SRCS ${HDRS_G})
+
+POCO_SOURCES_AUTO_PLAT( TEST_SRCS OFF
+    src/WinDriver.cpp
+)
+
+POCO_SOURCES_AUTO_PLAT( TEST_SRCS WINCE
+    src/WinCEDriver.cpp
+)
+
+set(TESTUNIT "${LIBNAME}-testrunner")
+
+add_executable( ${TESTUNIT} ${TEST_SRCS} )
+add_test(NAME ${LIBNAME} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMAND ${TESTUNIT} -all)
+target_link_libraries( ${TESTUNIT}  PocoRedis PocoFoundation CppUnit )
--- a/Redis/testsuite/Makefile
+++ b/Redis/testsuite/Makefile
@ -0,0 +1,17 @@
+#
+# Makefile
+#
+# $Id$
+#
+# Makefile for Poco Redis testsuite
+#
+
+include $(POCO_BASE)/build/rules/global
+
+objects = Driver RedisTest RedisTestSuite
+
+target         = testrunner
+target_version = 1
+target_libs    = PocoRedis PocoFoundation PocoNet CppUnit
+
+include $(POCO_BASE)/build/rules/exec
--- a/Redis/testsuite/TestSuite.progen
+++ b/Redis/testsuite/TestSuite.progen
@ -0,0 +1,9 @@
+vc.project.guid = ${vc.project.guidFromName}
+vc.project.name = TestSuite
+vc.project.target = TestSuite
+vc.project.type = testsuite
+vc.project.pocobase = ..\\..
+vc.project.platforms = Win32, x64
+vc.project.configurations = debug_shared, release_shared, debug_static_mt, release_static_mt, debug_static_md, release_static_md
+vc.project.prototype = TestSuite_vs90.vcproj
+vc.project.compiler.include = ..\\..\\Foundation\\include;..\\..\\Net\\include
--- a/Redis/testsuite/TestSuite_x64_vs90.vcproj
+++ b/Redis/testsuite/TestSuite_x64_vs90.vcproj
@ -0,0 +1,464 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	Name="TestSuite"
+	Version="9.00"
+	ProjectType="Visual C++"
+	ProjectGUID="{96CF3103-E49E-3F5E-A11D-6DBCDA043053}"
+	RootNamespace="TestSuite"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="x64"/>
+	</Platforms>
+	<ToolFiles/>
+	<Configurations>
+		<Configuration
+			Name="debug_shared|x64"
+			OutputDirectory="obj64\$(ConfigurationName)"
+			IntermediateDirectory="obj64\$(ConfigurationName)"
+			ConfigurationType="1"
+			UseOfMFC="2"
+			CharacterSet="2">
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\include;..\..\CppUnit\include;..\..\CppUnit\WinTestRunner\include;..\..\Foundation\include;..\..\Net\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;WINVER=0x0501;"
+				StringPooling="true"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				BufferSecurityCheck="true"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="3"
+				CompileAs="0"
+				DisableSpecificWarnings=""
+				AdditionalOptions=""/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="CppUnitd.lib WinTestRunnerd.lib "
+				OutputFile="bin64\TestSuited.exe"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories="..\..\lib64"
+				SuppressStartupBanner="true"
+				GenerateDebugInformation="true"
+				ProgramDatabaseFile="bin64\TestSuited.pdb"
+				SubSystem="2"
+				TargetMachine="17"
+				AdditionalOptions=""/>
+			<Tool
+				Name="VCALinkTool"/>
+			<Tool
+				Name="VCManifestTool"/>
+			<Tool
+				Name="VCXDCMakeTool"/>
+			<Tool
+				Name="VCBscMakeTool"/>
+			<Tool
+				Name="VCFxCopTool"/>
+			<Tool
+				Name="VCAppVerifierTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+		</Configuration>
+		<Configuration
+			Name="release_shared|x64"
+			OutputDirectory="obj64\$(ConfigurationName)"
+			IntermediateDirectory="obj64\$(ConfigurationName)"
+			ConfigurationType="1"
+			UseOfMFC="2"
+			CharacterSet="2">
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="4"
+				InlineFunctionExpansion="1"
+				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="1"
+				OmitFramePointers="true"
+				AdditionalIncludeDirectories="..\include;..\..\CppUnit\include;..\..\CppUnit\WinTestRunner\include;..\..\Foundation\include;..\..\Net\include"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;WINVER=0x0501;"
+				StringPooling="true"
+				RuntimeLibrary="2"
+				BufferSecurityCheck="false"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="0"
+				CompileAs="0"
+				DisableSpecificWarnings=""
+				AdditionalOptions=""/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="CppUnit.lib WinTestRunner.lib "
+				OutputFile="bin64\TestSuite.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="..\..\lib64"
+				GenerateDebugInformation="false"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="17"
+				AdditionalOptions=""/>
+			<Tool
+				Name="VCALinkTool"/>
+			<Tool
+				Name="VCManifestTool"/>
+			<Tool
+				Name="VCXDCMakeTool"/>
+			<Tool
+				Name="VCBscMakeTool"/>
+			<Tool
+				Name="VCFxCopTool"/>
+			<Tool
+				Name="VCAppVerifierTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+		</Configuration>
+		<Configuration
+			Name="debug_static_mt|x64"
+			OutputDirectory="obj64\$(ConfigurationName)"
+			IntermediateDirectory="obj64\$(ConfigurationName)"
+			ConfigurationType="1"
+			UseOfMFC="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="4"
+				AdditionalIncludeDirectories="..\include;..\..\CppUnit\include;..\..\CppUnit\WinTestRunner\include;..\..\Foundation\include;..\..\Net\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;WINVER=0x0501;POCO_STATIC;"
+				StringPooling="true"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				BufferSecurityCheck="true"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="3"
+				CompileAs="0"
+				DisableSpecificWarnings=""
+				AdditionalOptions=""/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="CppUnitmtd.lib WinTestRunnermtd.lib iphlpapi.lib winmm.lib nafxcwd.lib libcmtd.lib WinTestRunner.res "
+				OutputFile="bin64\static_mt\TestSuited.exe"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories="..\..\lib64"
+				IgnoreDefaultLibraryNames="nafxcwd.lib;libcmtd.lib"
+				SuppressStartupBanner="true"
+				GenerateDebugInformation="true"
+				ProgramDatabaseFile="bin64\static_mt\TestSuited.pdb"
+				SubSystem="2"
+				TargetMachine="17"
+				AdditionalOptions=""/>
+			<Tool
+				Name="VCALinkTool"/>
+			<Tool
+				Name="VCManifestTool"/>
+			<Tool
+				Name="VCXDCMakeTool"/>
+			<Tool
+				Name="VCBscMakeTool"/>
+			<Tool
+				Name="VCFxCopTool"/>
+			<Tool
+				Name="VCAppVerifierTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+		</Configuration>
+		<Configuration
+			Name="release_static_mt|x64"
+			OutputDirectory="obj64\$(ConfigurationName)"
+			IntermediateDirectory="obj64\$(ConfigurationName)"
+			ConfigurationType="1"
+			UseOfMFC="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="4"
+				InlineFunctionExpansion="1"
+				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="1"
+				OmitFramePointers="true"
+				AdditionalIncludeDirectories="..\include;..\..\CppUnit\include;..\..\CppUnit\WinTestRunner\include;..\..\Foundation\include;..\..\Net\include"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;WINVER=0x0501;POCO_STATIC;"
+				StringPooling="true"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="false"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="0"
+				CompileAs="0"
+				DisableSpecificWarnings=""
+				AdditionalOptions=""/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="CppUnitmt.lib WinTestRunnermt.lib iphlpapi.lib winmm.lib nafxcw.lib libcmt.lib WinTestRunner.res "
+				OutputFile="bin64\static_mt\TestSuite.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="..\..\lib64"
+				IgnoreDefaultLibraryNames="nafxcw.lib;libcmt.lib"
+				GenerateDebugInformation="false"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="17"
+				AdditionalOptions=""/>
+			<Tool
+				Name="VCALinkTool"/>
+			<Tool
+				Name="VCManifestTool"/>
+			<Tool
+				Name="VCXDCMakeTool"/>
+			<Tool
+				Name="VCBscMakeTool"/>
+			<Tool
+				Name="VCFxCopTool"/>
+			<Tool
+				Name="VCAppVerifierTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+		</Configuration>
+		<Configuration
+			Name="debug_static_md|x64"
+			OutputDirectory="obj64\$(ConfigurationName)"
+			IntermediateDirectory="obj64\$(ConfigurationName)"
+			ConfigurationType="1"
+			UseOfMFC="2"
+			CharacterSet="2">
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="4"
+				AdditionalIncludeDirectories="..\include;..\..\CppUnit\include;..\..\CppUnit\WinTestRunner\include;..\..\Foundation\include;..\..\Net\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;WINVER=0x0501;POCO_STATIC;"
+				StringPooling="true"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				BufferSecurityCheck="true"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="3"
+				CompileAs="0"
+				DisableSpecificWarnings=""
+				AdditionalOptions=""/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="CppUnitmdd.lib WinTestRunnermdd.lib iphlpapi.lib winmm.lib WinTestRunner.res "
+				OutputFile="bin64\static_md\TestSuited.exe"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories="..\..\lib64"
+				SuppressStartupBanner="true"
+				GenerateDebugInformation="true"
+				ProgramDatabaseFile="bin64\static_md\TestSuited.pdb"
+				SubSystem="2"
+				TargetMachine="17"
+				AdditionalOptions=""/>
+			<Tool
+				Name="VCALinkTool"/>
+			<Tool
+				Name="VCManifestTool"/>
+			<Tool
+				Name="VCXDCMakeTool"/>
+			<Tool
+				Name="VCBscMakeTool"/>
+			<Tool
+				Name="VCFxCopTool"/>
+			<Tool
+				Name="VCAppVerifierTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+		</Configuration>
+		<Configuration
+			Name="release_static_md|x64"
+			OutputDirectory="obj64\$(ConfigurationName)"
+			IntermediateDirectory="obj64\$(ConfigurationName)"
+			ConfigurationType="1"
+			UseOfMFC="2"
+			CharacterSet="2">
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="4"
+				InlineFunctionExpansion="1"
+				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="1"
+				OmitFramePointers="true"
+				AdditionalIncludeDirectories="..\include;..\..\CppUnit\include;..\..\CppUnit\WinTestRunner\include;..\..\Foundation\include;..\..\Net\include"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;WINVER=0x0501;POCO_STATIC;"
+				StringPooling="true"
+				RuntimeLibrary="2"
+				BufferSecurityCheck="false"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="0"
+				CompileAs="0"
+				DisableSpecificWarnings=""
+				AdditionalOptions=""/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="CppUnitmd.lib WinTestRunnermd.lib iphlpapi.lib winmm.lib WinTestRunner.res "
+				OutputFile="bin64\static_md\TestSuite.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="..\..\lib64"
+				GenerateDebugInformation="false"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="17"
+				AdditionalOptions=""/>
+			<Tool
+				Name="VCALinkTool"/>
+			<Tool
+				Name="VCManifestTool"/>
+			<Tool
+				Name="VCXDCMakeTool"/>
+			<Tool
+				Name="VCBscMakeTool"/>
+			<Tool
+				Name="VCFxCopTool"/>
+			<Tool
+				Name="VCAppVerifierTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+		</Configuration>
+	</Configurations>
+	<References/>
+	<Files>
+		<Filter
+			Name="Source Files">
+			<File
+				RelativePath=".\src\RedisTest.cpp"/>
+			<File
+				RelativePath=".\src\RedisTestSuite.cpp"/>
+			<File
+				RelativePath=".\src\WinDriver.cpp"/>
+		</Filter>
+		<Filter
+			Name="Header Files">
+			<File
+				RelativePath=".\src\RedisTest.h"/>
+			<File
+				RelativePath=".\src\RedisTestSuite.h"/>
+		</Filter>
+	</Files>
+	<Globals/>
+</VisualStudioProject>
--- a/Redis/testsuite/src/Driver.cpp
+++ b/Redis/testsuite/src/Driver.cpp
@ -0,0 +1,19 @@
+//
+// Driver.cpp
+//
+// $Id$
+//
+// Console-based test driver for Poco MongoDB.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "CppUnit/TestRunner.h"
+#include "RedisTestSuite.h"
+
+
+CppUnitMain(RedisTestSuite)
--- a/Redis/testsuite/src/RedisTest.cpp
+++ b/Redis/testsuite/src/RedisTest.cpp
--- a/Redis/testsuite/src/RedisTest.h
+++ b/Redis/testsuite/src/RedisTest.h
@ -0,0 +1,106 @@
+//
+// RedisTest.h
+//
+// $Id$
+//
+// Definition of the RedisTest class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef RedisTest_INCLUDED
+#define RedisTest_INCLUDED
+
+
+#include "Poco/Redis/Redis.h"
+#include "Poco/Redis/Client.h"
+
+#include "CppUnit/TestCase.h"
+
+
+class RedisTest: public CppUnit::TestCase
+{
+public:
+	RedisTest(const std::string& name);
+
+
+	virtual ~RedisTest();
+
+	void testAPPEND();
+	void testBLPOP();
+	void testBRPOP();
+	void testDECR();
+	void testECHO();
+	void testError();
+	void testEVAL();
+	void testHDEL();
+	void testHEXISTS();
+	void testHGETALL();
+	void testHINCRBY();
+	void testHKEYS();
+	void testHMGET();
+	void testHMSET();
+	void testHSET();
+	void testHSTRLEN();
+	void testHVALS();
+	void testINCR();
+	void testINCRBY();
+	void testLINDEX();
+	void testLINSERT();
+	void testLPOP();
+	void testLREM();
+	void testLSET();
+	void testLTRIM();
+	void testMULTI();
+	void testMSET();
+	void testMSETWithMap();
+	void testPING();
+	void testPipeliningWithSendCommands();
+	void testPipeliningWithWriteCommand();
+	void testPubSub();
+	void testSADD();
+	void testSCARD();
+	void testSDIFF();
+	void testSDIFFSTORE();
+	void testSET();
+	void testSINTER();
+	void testSINTERSTORE();
+	void testSISMEMBER();
+	void testSMEMBERS();
+	void testSMOVE();
+	void testSPOP();
+	void testSRANDMEMBER();
+	void testSREM();
+	void testSUNION();
+	void testSUNIONSTORE();
+	void testSTRLEN();
+	void testRENAME();
+	void testRENAMENX();
+	void testRPOP();
+	void testRPOPLPUSH();
+	void testRPUSH();
+
+	void testPool();
+
+	void setUp();
+	void tearDown();
+
+	static CppUnit::Test* suite();
+
+private:
+
+	void delKey(const std::string& key);
+
+	std::string _host;
+	unsigned    _port;
+	static bool _connected;
+	static Poco::Redis::Client _redis;
+
+};
+
+
+#endif // RedisTest_INCLUDED
--- a/Redis/testsuite/src/RedisTestSuite.cpp
+++ b/Redis/testsuite/src/RedisTestSuite.cpp
@ -0,0 +1,24 @@
+//
+// RedisTestSuite.cpp
+//
+// $Id$
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "RedisTestSuite.h"
+#include "RedisTest.h"
+
+
+CppUnit::Test* RedisTestSuite::suite()
+{
+	CppUnit::TestSuite* pSuite = new CppUnit::TestSuite("RedisTestSuite");
+
+	pSuite->addTest(RedisTest::suite());
+
+	return pSuite;
+}
--- a/Redis/testsuite/src/RedisTestSuite.h
+++ b/Redis/testsuite/src/RedisTestSuite.h
@ -0,0 +1,29 @@
+//
+// RedisTestSuite.h
+//
+// $Id$
+//
+// Definition of the RedisTestSuite class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef RedisTestSuite_INCLUDED
+#define RedisTestSuite_INCLUDED
+
+
+#include "CppUnit/TestSuite.h"
+
+
+class RedisTestSuite
+{
+public:
+	static CppUnit::Test* suite();
+};
+
+
+#endif // RedisTestSuite_INCLUDED
--- a/Redis/testsuite/src/WinCEDriver.cpp
+++ b/Redis/testsuite/src/WinCEDriver.cpp
@ -0,0 +1,32 @@
+//
+// WinCEDriver.cpp
+//
+// $Id$
+//
+// Console-based test driver for Windows CE.
+//
+// Copyright (c) 2004-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "CppUnit/TestRunner.h"
+#include "RedisTestSuite.h"
+#include <cstdlib>
+
+
+int _tmain(int argc, wchar_t* argv[])
+{
+	std::vector<std::string> args;
+	for (int i = 0; i < argc; ++i)
+	{
+		char buffer[1024];
+		std::wcstombs(buffer, argv[i], sizeof(buffer));
+		args.push_back(std::string(buffer));
+	}
+	CppUnit::TestRunner runner;	
+	runner.addTest("RedisTestSuite", RedisTestSuite::suite());
+	return runner.run(args) ? 0 : 1;
+}
--- a/Redis/testsuite/src/WinDriver.cpp
+++ b/Redis/testsuite/src/WinDriver.cpp
@ -0,0 +1,30 @@
+//
+// WinDriver.cpp
+//
+// $Id$
+//
+// Windows test driver for Poco MongoDB.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "WinTestRunner/WinTestRunner.h"
+#include "RedisTestSuite.h"
+
+
+class TestDriver: public CppUnit::WinTestRunnerApp
+{
+	void TestMain()
+	{
+		CppUnit::WinTestRunner runner;
+		runner.addTest(RedisTestSuite::suite());
+		runner.run();
+	}
+};
+
+
+TestDriver theDriver;
--- a/1
+++ b/1
@ -18,5 +18,6 @@ PageCompiler/File2Page
 PDF
 CppParser
 MongoDB
+Redis
 PocoDoc
 ProGen