From 4782ae61f156ea0acebacbd4a69d4106dbc0a7fa Mon Sep 17 00:00:00 2001
From: Toshaan Bharvani <toshaan@powerel.org>
Date: Sat, 8 Oct 2022 21:52:13 +0200
Subject: [PATCH] add missing sources

Signed-off-by: Toshaan Bharvani <toshaan@powerel.org>
---
 SOURCES/OpenCL-CLHPP-2.0.12.zip       |   Bin 0 -> 106113 bytes
 SOURCES/OpenCL-Headers-d65bcc5.tar.gz |   Bin 0 -> 55627 bytes
 SOURCES/cl.hpp                        | 12934 ++++++++++++++++++++++++
 3 files changed, 12934 insertions(+)
 create mode 100644 SOURCES/OpenCL-CLHPP-2.0.12.zip
 create mode 100644 SOURCES/OpenCL-Headers-d65bcc5.tar.gz
 create mode 100644 SOURCES/cl.hpp

diff --git a/SOURCES/OpenCL-CLHPP-2.0.12.zip b/SOURCES/OpenCL-CLHPP-2.0.12.zip
new file mode 100644
index 0000000000000000000000000000000000000000..087e6015f99d80c56a2746e52875fc74b6634715
GIT binary patch
literal 106113
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%0A&$X9Dyal}|%5w%cJ*p56Bf~NHfMtiN&eJMbu
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
L@NkxOl9c~H)EXQ?

literal 0
HcmV?d00001

diff --git a/SOURCES/OpenCL-Headers-d65bcc5.tar.gz b/SOURCES/OpenCL-Headers-d65bcc5.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..dd3b71d7cd4a91b54407113f7fe6ae87ec4ae69c
GIT binary patch
literal 55627
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

literal 0
HcmV?d00001

diff --git a/SOURCES/cl.hpp b/SOURCES/cl.hpp
new file mode 100644
index 0000000..396b867
--- /dev/null
+++ b/SOURCES/cl.hpp
@@ -0,0 +1,12934 @@
+/*******************************************************************************
+ * Copyright (c) 2008-2015 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ ******************************************************************************/
+
+/*! \file
+ *
+ *   \brief C++ bindings for OpenCL 1.0 (rev 48), OpenCL 1.1 (rev 33) and 
+ *       OpenCL 1.2 (rev 15)    
+ *   \author Benedict R. Gaster, Laurent Morichetti and Lee Howes
+ *   
+ *   Additions and fixes from:
+ *       Brian Cole, March 3rd 2010 and April 2012 
+ *       Matt Gruenke, April 2012.
+ *       Bruce Merry, February 2013.
+ *       Tom Deakin and Simon McIntosh-Smith, July 2013
+ *   
+ *   \version 1.2.8
+ *   \date October 2015
+ *
+ *   Optional extension support
+ *
+ *         cl
+ *         cl_ext_device_fission
+ *				#define USE_CL_DEVICE_FISSION
+ */
+
+/*! \mainpage
+ * \section intro Introduction
+ * For many large applications C++ is the language of choice and so it seems
+ * reasonable to define C++ bindings for OpenCL.
+ *
+ *
+ * The interface is contained with a single C++ header file \em cl.hpp and all
+ * definitions are contained within the namespace \em cl. There is no additional
+ * requirement to include \em cl.h and to use either the C++ or original C
+ * bindings it is enough to simply include \em cl.hpp.
+ *
+ * The bindings themselves are lightweight and correspond closely to the
+ * underlying C API. Using the C++ bindings introduces no additional execution
+ * overhead.
+ *
+ * For detail documentation on the bindings see:
+ *
+ * The OpenCL C++ Wrapper API 1.2 (revision 09)
+ *  http://www.khronos.org/registry/cl/specs/opencl-cplusplus-1.2.pdf
+ *
+ * \section example Example
+ *
+ * The following example shows a general use case for the C++
+ * bindings, including support for the optional exception feature and
+ * also the supplied vector and string classes, see following sections for
+ * decriptions of these features.
+ *
+ * \code
+ * #define __CL_ENABLE_EXCEPTIONS
+ * 
+ * #if defined(__APPLE__) || defined(__MACOSX)
+ * #include <OpenCL/cl.hpp>
+ * #else
+ * #include <CL/cl.hpp>
+ * #endif
+ * #include <cstdio>
+ * #include <cstdlib>
+ * #include <iostream>
+ * 
+ *  const char * helloStr  = "__kernel void "
+ *                           "hello(void) "
+ *                           "{ "
+ *                           "  "
+ *                           "} ";
+ * 
+ *  int
+ *  main(void)
+ *  {
+ *     cl_int err = CL_SUCCESS;
+ *     try {
+ *
+ *       std::vector<cl::Platform> platforms;
+ *       cl::Platform::get(&platforms);
+ *       if (platforms.size() == 0) {
+ *           std::cout << "Platform size 0\n";
+ *           return -1;
+ *       }
+ *
+ *       cl_context_properties properties[] = 
+ *          { CL_CONTEXT_PLATFORM, (cl_context_properties)(platforms[0])(), 0};
+ *       cl::Context context(CL_DEVICE_TYPE_CPU, properties); 
+ * 
+ *       std::vector<cl::Device> devices = context.getInfo<CL_CONTEXT_DEVICES>();
+ * 
+ *       cl::Program::Sources source(1,
+ *           std::make_pair(helloStr,strlen(helloStr)));
+ *       cl::Program program_ = cl::Program(context, source);
+ *       program_.build(devices);
+ * 
+ *       cl::Kernel kernel(program_, "hello", &err);
+ * 
+ *       cl::Event event;
+ *       cl::CommandQueue queue(context, devices[0], 0, &err);
+ *       queue.enqueueNDRangeKernel(
+ *           kernel, 
+ *           cl::NullRange, 
+ *           cl::NDRange(4,4),
+ *           cl::NullRange,
+ *           NULL,
+ *           &event); 
+ * 
+ *       event.wait();
+ *     }
+ *     catch (cl::Error err) {
+ *        std::cerr 
+ *           << "ERROR: "
+ *           << err.what()
+ *           << "("
+ *           << err.err()
+ *           << ")"
+ *           << std::endl;
+ *     }
+ * 
+ *    return EXIT_SUCCESS;
+ *  }
+ * 
+ * \endcode
+ *
+ */
+#ifndef CL_HPP_
+#define CL_HPP_
+
+#ifdef _WIN32
+
+#include <malloc.h>
+
+#if defined(USE_DX_INTEROP)
+#include <CL/cl_d3d10.h>
+#include <CL/cl_dx9_media_sharing.h>
+#endif
+#endif // _WIN32
+
+#if defined(_MSC_VER)
+#include <intrin.h>
+#endif // _MSC_VER
+
+// 
+#if defined(USE_CL_DEVICE_FISSION)
+#include <CL/cl_ext.h>
+#endif
+
+#if defined(__APPLE__) || defined(__MACOSX)
+#include <OpenCL/opencl.h>
+#else
+#include <CL/opencl.h>
+#endif // !__APPLE__
+
+#if (_MSC_VER >= 1700) || (__cplusplus >= 201103L)
+#define CL_HPP_RVALUE_REFERENCES_SUPPORTED
+#define CL_HPP_CPP11_ATOMICS_SUPPORTED
+#include <atomic>
+#endif
+
+#if (__cplusplus >= 201103L)
+#define CL_HPP_NOEXCEPT noexcept
+#else
+#define CL_HPP_NOEXCEPT
+#endif
+
+
+// To avoid accidentally taking ownership of core OpenCL types
+// such as cl_kernel constructors are made explicit
+// under OpenCL 1.2
+#if defined(CL_VERSION_1_2) && !defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
+#define __CL_EXPLICIT_CONSTRUCTORS explicit
+#else // #if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
+#define __CL_EXPLICIT_CONSTRUCTORS 
+#endif // #if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
+
+// Define deprecated prefixes and suffixes to ensure compilation
+// in case they are not pre-defined
+#if !defined(CL_EXT_PREFIX__VERSION_1_1_DEPRECATED)
+#define CL_EXT_PREFIX__VERSION_1_1_DEPRECATED  
+#endif // #if !defined(CL_EXT_PREFIX__VERSION_1_1_DEPRECATED)
+#if !defined(CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED)
+#define CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+#endif // #if !defined(CL_EXT_PREFIX__VERSION_1_1_DEPRECATED)
+
+#if !defined(CL_CALLBACK)
+#define CL_CALLBACK
+#endif //CL_CALLBACK
+
+#include <utility>
+#include <limits>
+#include <iterator>
+
+#if defined(__CL_ENABLE_EXCEPTIONS)
+#include <exception>
+#endif // #if defined(__CL_ENABLE_EXCEPTIONS)
+
+#if !defined(__NO_STD_VECTOR)
+#include <vector>
+#endif
+
+#if !defined(__NO_STD_STRING)
+#include <string>
+#endif 
+
+#if defined(__ANDROID__) || defined(linux) || defined(__APPLE__) || defined(__MACOSX)
+#include <alloca.h>
+#endif // linux
+
+#include <cstring>
+
+
+/*! \namespace cl
+ *
+ * \brief The OpenCL C++ bindings are defined within this namespace.
+ *
+ */
+namespace cl {
+
+class Memory;
+
+/**
+ * Deprecated APIs for 1.2
+ */
+#if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS) || (defined(CL_VERSION_1_1) && !defined(CL_VERSION_1_2)) 
+#define __INIT_CL_EXT_FCN_PTR(name) \
+    if(!pfn_##name) { \
+        pfn_##name = (PFN_##name) \
+            clGetExtensionFunctionAddress(#name); \
+        if(!pfn_##name) { \
+        } \
+    }
+#endif // #if defined(CL_VERSION_1_1)
+
+#if defined(CL_VERSION_1_2)
+#define __INIT_CL_EXT_FCN_PTR_PLATFORM(platform, name) \
+    if(!pfn_##name) { \
+        pfn_##name = (PFN_##name) \
+            clGetExtensionFunctionAddressForPlatform(platform, #name); \
+        if(!pfn_##name) { \
+        } \
+    }
+#endif // #if defined(CL_VERSION_1_1)
+
+class Program;
+class Device;
+class Context;
+class CommandQueue;
+class Memory;
+class Buffer;
+
+#if defined(__CL_ENABLE_EXCEPTIONS)
+/*! \brief Exception class 
+ * 
+ *  This may be thrown by API functions when __CL_ENABLE_EXCEPTIONS is defined.
+ */
+class Error : public std::exception
+{
+private:
+    cl_int err_;
+    const char * errStr_;
+public:
+    /*! \brief Create a new CL error exception for a given error code
+     *  and corresponding message.
+     * 
+     *  \param err error code value.
+     *
+     *  \param errStr a descriptive string that must remain in scope until
+     *                handling of the exception has concluded.  If set, it
+     *                will be returned by what().
+     */
+    Error(cl_int err, const char * errStr = NULL) : err_(err), errStr_(errStr)
+    {}
+
+    ~Error() throw() {}
+
+    /*! \brief Get error string associated with exception
+     *
+     * \return A memory pointer to the error message string.
+     */
+    virtual const char * what() const throw ()
+    {
+        if (errStr_ == NULL) {
+            return "empty";
+        }
+        else {
+            return errStr_;
+        }
+    }
+
+    /*! \brief Get error code associated with exception
+     *
+     *  \return The error code.
+     */
+    cl_int err(void) const { return err_; }
+};
+
+#define __ERR_STR(x) #x
+#else
+#define __ERR_STR(x) NULL
+#endif // __CL_ENABLE_EXCEPTIONS
+
+
+namespace detail
+{
+#if defined(__CL_ENABLE_EXCEPTIONS)
+static inline cl_int errHandler (
+    cl_int err,
+    const char * errStr = NULL)
+{
+    if (err != CL_SUCCESS) {
+        throw Error(err, errStr);
+    }
+    return err;
+}
+#else
+static inline cl_int errHandler (cl_int err, const char * errStr = NULL)
+{
+    (void) errStr; // suppress unused variable warning
+    return err;
+}
+#endif // __CL_ENABLE_EXCEPTIONS
+}
+
+
+
+//! \cond DOXYGEN_DETAIL
+#if !defined(__CL_USER_OVERRIDE_ERROR_STRINGS)
+#define __GET_DEVICE_INFO_ERR               __ERR_STR(clGetDeviceInfo)
+#define __GET_PLATFORM_INFO_ERR             __ERR_STR(clGetPlatformInfo)
+#define __GET_DEVICE_IDS_ERR                __ERR_STR(clGetDeviceIDs)
+#define __GET_PLATFORM_IDS_ERR              __ERR_STR(clGetPlatformIDs)
+#define __GET_CONTEXT_INFO_ERR              __ERR_STR(clGetContextInfo)
+#define __GET_EVENT_INFO_ERR                __ERR_STR(clGetEventInfo)
+#define __GET_EVENT_PROFILE_INFO_ERR        __ERR_STR(clGetEventProfileInfo)
+#define __GET_MEM_OBJECT_INFO_ERR           __ERR_STR(clGetMemObjectInfo)
+#define __GET_IMAGE_INFO_ERR                __ERR_STR(clGetImageInfo)
+#define __GET_SAMPLER_INFO_ERR              __ERR_STR(clGetSamplerInfo)
+#define __GET_KERNEL_INFO_ERR               __ERR_STR(clGetKernelInfo)
+#if defined(CL_VERSION_1_2)
+#define __GET_KERNEL_ARG_INFO_ERR               __ERR_STR(clGetKernelArgInfo)
+#endif // #if defined(CL_VERSION_1_2)
+#define __GET_KERNEL_WORK_GROUP_INFO_ERR    __ERR_STR(clGetKernelWorkGroupInfo)
+#define __GET_PROGRAM_INFO_ERR              __ERR_STR(clGetProgramInfo)
+#define __GET_PROGRAM_BUILD_INFO_ERR        __ERR_STR(clGetProgramBuildInfo)
+#define __GET_COMMAND_QUEUE_INFO_ERR        __ERR_STR(clGetCommandQueueInfo)
+
+#define __CREATE_CONTEXT_ERR                __ERR_STR(clCreateContext)
+#define __CREATE_CONTEXT_FROM_TYPE_ERR      __ERR_STR(clCreateContextFromType)
+#define __GET_SUPPORTED_IMAGE_FORMATS_ERR   __ERR_STR(clGetSupportedImageFormats)
+
+#define __CREATE_BUFFER_ERR                 __ERR_STR(clCreateBuffer)
+#define __COPY_ERR                          __ERR_STR(cl::copy)
+#define __CREATE_SUBBUFFER_ERR              __ERR_STR(clCreateSubBuffer)
+#define __CREATE_GL_BUFFER_ERR              __ERR_STR(clCreateFromGLBuffer)
+#define __CREATE_GL_RENDER_BUFFER_ERR       __ERR_STR(clCreateFromGLBuffer)
+#define __GET_GL_OBJECT_INFO_ERR            __ERR_STR(clGetGLObjectInfo)
+#if defined(CL_VERSION_1_2)
+#define __CREATE_IMAGE_ERR                  __ERR_STR(clCreateImage)
+#define __CREATE_GL_TEXTURE_ERR             __ERR_STR(clCreateFromGLTexture)
+#define __IMAGE_DIMENSION_ERR               __ERR_STR(Incorrect image dimensions)
+#endif // #if defined(CL_VERSION_1_2)
+#define __CREATE_SAMPLER_ERR                __ERR_STR(clCreateSampler)
+#define __SET_MEM_OBJECT_DESTRUCTOR_CALLBACK_ERR __ERR_STR(clSetMemObjectDestructorCallback)
+
+#define __CREATE_USER_EVENT_ERR             __ERR_STR(clCreateUserEvent)
+#define __SET_USER_EVENT_STATUS_ERR         __ERR_STR(clSetUserEventStatus)
+#define __SET_EVENT_CALLBACK_ERR            __ERR_STR(clSetEventCallback)
+#define __WAIT_FOR_EVENTS_ERR               __ERR_STR(clWaitForEvents)
+
+#define __CREATE_KERNEL_ERR                 __ERR_STR(clCreateKernel)
+#define __SET_KERNEL_ARGS_ERR               __ERR_STR(clSetKernelArg)
+#define __CREATE_PROGRAM_WITH_SOURCE_ERR    __ERR_STR(clCreateProgramWithSource)
+#define __CREATE_PROGRAM_WITH_BINARY_ERR    __ERR_STR(clCreateProgramWithBinary)
+#if defined(CL_VERSION_1_2)
+#define __CREATE_PROGRAM_WITH_BUILT_IN_KERNELS_ERR    __ERR_STR(clCreateProgramWithBuiltInKernels)
+#endif // #if defined(CL_VERSION_1_2)
+#define __BUILD_PROGRAM_ERR                 __ERR_STR(clBuildProgram)
+#if defined(CL_VERSION_1_2)
+#define __COMPILE_PROGRAM_ERR                  __ERR_STR(clCompileProgram)
+#define __LINK_PROGRAM_ERR                  __ERR_STR(clLinkProgram)
+#endif // #if defined(CL_VERSION_1_2)
+#define __CREATE_KERNELS_IN_PROGRAM_ERR     __ERR_STR(clCreateKernelsInProgram)
+
+#define __CREATE_COMMAND_QUEUE_ERR          __ERR_STR(clCreateCommandQueue)
+#define __SET_COMMAND_QUEUE_PROPERTY_ERR    __ERR_STR(clSetCommandQueueProperty)
+#define __ENQUEUE_READ_BUFFER_ERR           __ERR_STR(clEnqueueReadBuffer)
+#define __ENQUEUE_READ_BUFFER_RECT_ERR      __ERR_STR(clEnqueueReadBufferRect)
+#define __ENQUEUE_WRITE_BUFFER_ERR          __ERR_STR(clEnqueueWriteBuffer)
+#define __ENQUEUE_WRITE_BUFFER_RECT_ERR     __ERR_STR(clEnqueueWriteBufferRect)
+#define __ENQEUE_COPY_BUFFER_ERR            __ERR_STR(clEnqueueCopyBuffer)
+#define __ENQEUE_COPY_BUFFER_RECT_ERR       __ERR_STR(clEnqueueCopyBufferRect)
+#define __ENQUEUE_FILL_BUFFER_ERR           __ERR_STR(clEnqueueFillBuffer)
+#define __ENQUEUE_READ_IMAGE_ERR            __ERR_STR(clEnqueueReadImage)
+#define __ENQUEUE_WRITE_IMAGE_ERR           __ERR_STR(clEnqueueWriteImage)
+#define __ENQUEUE_COPY_IMAGE_ERR            __ERR_STR(clEnqueueCopyImage)
+#define __ENQUEUE_FILL_IMAGE_ERR           __ERR_STR(clEnqueueFillImage)
+#define __ENQUEUE_COPY_IMAGE_TO_BUFFER_ERR  __ERR_STR(clEnqueueCopyImageToBuffer)
+#define __ENQUEUE_COPY_BUFFER_TO_IMAGE_ERR  __ERR_STR(clEnqueueCopyBufferToImage)
+#define __ENQUEUE_MAP_BUFFER_ERR            __ERR_STR(clEnqueueMapBuffer)
+#define __ENQUEUE_MAP_IMAGE_ERR             __ERR_STR(clEnqueueMapImage)
+#define __ENQUEUE_UNMAP_MEM_OBJECT_ERR      __ERR_STR(clEnqueueUnMapMemObject)
+#define __ENQUEUE_NDRANGE_KERNEL_ERR        __ERR_STR(clEnqueueNDRangeKernel)
+#define __ENQUEUE_TASK_ERR                  __ERR_STR(clEnqueueTask)
+#define __ENQUEUE_NATIVE_KERNEL             __ERR_STR(clEnqueueNativeKernel)
+#if defined(CL_VERSION_1_2)
+#define __ENQUEUE_MIGRATE_MEM_OBJECTS_ERR   __ERR_STR(clEnqueueMigrateMemObjects)
+#endif // #if defined(CL_VERSION_1_2)
+
+#define __ENQUEUE_ACQUIRE_GL_ERR            __ERR_STR(clEnqueueAcquireGLObjects)
+#define __ENQUEUE_RELEASE_GL_ERR            __ERR_STR(clEnqueueReleaseGLObjects)
+
+
+#define __RETAIN_ERR                        __ERR_STR(Retain Object)
+#define __RELEASE_ERR                       __ERR_STR(Release Object)
+#define __FLUSH_ERR                         __ERR_STR(clFlush)
+#define __FINISH_ERR                        __ERR_STR(clFinish)
+#define __VECTOR_CAPACITY_ERR               __ERR_STR(Vector capacity error)
+
+/**
+ * CL 1.2 version that uses device fission.
+ */
+#if defined(CL_VERSION_1_2)
+#define __CREATE_SUB_DEVICES                __ERR_STR(clCreateSubDevices)
+#else
+#define __CREATE_SUB_DEVICES                __ERR_STR(clCreateSubDevicesEXT)
+#endif // #if defined(CL_VERSION_1_2)
+
+/**
+ * Deprecated APIs for 1.2
+ */
+#if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS) || (defined(CL_VERSION_1_1) && !defined(CL_VERSION_1_2)) 
+#define __ENQUEUE_MARKER_ERR                __ERR_STR(clEnqueueMarker)
+#define __ENQUEUE_WAIT_FOR_EVENTS_ERR       __ERR_STR(clEnqueueWaitForEvents)
+#define __ENQUEUE_BARRIER_ERR               __ERR_STR(clEnqueueBarrier)
+#define __UNLOAD_COMPILER_ERR               __ERR_STR(clUnloadCompiler)
+#define __CREATE_GL_TEXTURE_2D_ERR          __ERR_STR(clCreateFromGLTexture2D)
+#define __CREATE_GL_TEXTURE_3D_ERR          __ERR_STR(clCreateFromGLTexture3D)
+#define __CREATE_IMAGE2D_ERR                __ERR_STR(clCreateImage2D)
+#define __CREATE_IMAGE3D_ERR                __ERR_STR(clCreateImage3D)
+#endif // #if defined(CL_VERSION_1_1)
+
+#endif // __CL_USER_OVERRIDE_ERROR_STRINGS
+//! \endcond
+
+/**
+ * CL 1.2 marker and barrier commands
+ */
+#if defined(CL_VERSION_1_2)
+#define __ENQUEUE_MARKER_WAIT_LIST_ERR                __ERR_STR(clEnqueueMarkerWithWaitList)
+#define __ENQUEUE_BARRIER_WAIT_LIST_ERR               __ERR_STR(clEnqueueBarrierWithWaitList)
+#endif // #if defined(CL_VERSION_1_2)
+
+#if !defined(__USE_DEV_STRING) && !defined(__NO_STD_STRING)
+typedef std::string STRING_CLASS;
+#elif !defined(__USE_DEV_STRING) 
+
+/*! \class string
+ * \brief Simple string class, that provides a limited subset of std::string
+ * functionality but avoids many of the issues that come with that class.
+ 
+ *  \note Deprecated. Please use std::string as default or
+ *  re-define the string class to match the std::string
+ *  interface by defining STRING_CLASS
+ */
+class CL_EXT_PREFIX__VERSION_1_1_DEPRECATED string CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+private:
+    ::size_t size_;
+    char * str_;
+public:
+    //! \brief Constructs an empty string, allocating no memory.
+    string(void) : size_(0), str_(NULL)
+    {
+    }
+
+    /*! \brief Constructs a string populated from an arbitrary value of
+     *  specified size.
+     * 
+     *  An extra '\0' is added, in case none was contained in str.
+     *
+     *  \param str the initial value of the string instance.  Note that '\0'     
+     *             characters receive no special treatment.  If NULL,
+     *             the string is left empty, with a size of 0.
+     *
+     *  \param size the number of characters to copy from str.
+     */
+    string(const char * str, ::size_t size) :
+        size_(size),
+        str_(NULL)
+    {
+        if( size > 0 ) {
+            str_ = new char[size_+1];
+            if (str_ != NULL) {
+                memcpy(str_, str, size_  * sizeof(char));
+                str_[size_] = '\0';
+            }
+            else {
+                size_ = 0;
+            }
+        }
+    }
+
+    /*! \brief Constructs a string populated from a null-terminated value.
+     *
+     *  \param str the null-terminated initial value of the string instance.
+     *             If NULL, the string is left empty, with a size of 0.
+     */
+    string(const char * str) :
+        size_(0),
+        str_(NULL)
+    {
+        if( str ) {
+            size_= ::strlen(str);
+        }
+        if( size_ > 0 ) {
+            str_ = new char[size_ + 1];
+            if (str_ != NULL) {
+                memcpy(str_, str, (size_ + 1) * sizeof(char));
+            }
+        }
+    }
+
+    void resize( ::size_t n )
+    {
+        if( size_ == n ) {
+            return;
+        }
+        if (n == 0) {
+            if( str_ ) {
+                delete [] str_;
+            }
+            str_ = NULL;
+            size_ = 0;
+        } 
+        else {
+            char *newString = new char[n + 1];
+            ::size_t copySize = n;
+            if( size_ < n ) {
+                copySize = size_;
+            }
+            size_ = n;
+            
+            if(str_) {
+                memcpy(newString, str_, (copySize + 1) * sizeof(char));
+            }
+            if( copySize < size_ ) {
+                memset(newString + copySize, 0, size_ - copySize);
+            }
+            newString[size_] = '\0';
+
+            delete [] str_;
+            str_ = newString;
+        }
+    }
+
+    const char& operator[] ( ::size_t pos ) const
+    {
+        return str_[pos];
+    }
+
+    char& operator[] ( ::size_t pos )
+    {
+        return str_[pos];
+    }
+
+    /*! \brief Copies the value of another string to this one.
+     *
+     *  \param rhs the string to copy.
+     *
+     *  \returns a reference to the modified instance.
+     */
+    string& operator=(const string& rhs)
+    {
+        if (this == &rhs) {
+            return *this;
+        }
+
+        if( str_ != NULL ) {
+            delete [] str_;
+            str_ = NULL;
+            size_ = 0;
+        }
+
+        if (rhs.size_ == 0 || rhs.str_ == NULL) {
+            str_ = NULL;
+            size_ = 0;
+        } 
+        else {
+            str_ = new char[rhs.size_ + 1];
+            size_ = rhs.size_;
+            
+            if (str_ != NULL) {
+                memcpy(str_, rhs.str_, (size_ + 1) * sizeof(char));
+            }
+            else {
+                size_ = 0;
+            }
+        }
+
+        return *this;
+    }
+
+    /*! \brief Constructs a string by copying the value of another instance.
+     *
+     *  \param rhs the string to copy.
+     */
+    string(const string& rhs) :
+        size_(0),
+        str_(NULL)
+    {
+        *this = rhs;
+    }
+
+    //! \brief Destructor - frees memory used to hold the current value.
+    ~string()
+    {
+        delete[] str_;
+        str_ = NULL;
+    }
+    
+    //! \brief Queries the length of the string, excluding any added '\0's.
+    ::size_t size(void) const   { return size_; }
+
+    //! \brief Queries the length of the string, excluding any added '\0's.
+    ::size_t length(void) const { return size(); }
+
+    /*! \brief Returns a pointer to the private copy held by this instance,
+     *  or "" if empty/unset.
+     */
+    const char * c_str(void) const { return (str_) ? str_ : "";}
+};
+typedef cl::string STRING_CLASS;
+#endif // #elif !defined(__USE_DEV_STRING) 
+
+#if !defined(__USE_DEV_VECTOR) && !defined(__NO_STD_VECTOR)
+#define VECTOR_CLASS std::vector
+#elif !defined(__USE_DEV_VECTOR) 
+#define VECTOR_CLASS cl::vector 
+
+#if !defined(__MAX_DEFAULT_VECTOR_SIZE)
+#define __MAX_DEFAULT_VECTOR_SIZE 10
+#endif
+
+/*! \class vector
+ * \brief Fixed sized vector implementation that mirroring 
+ *
+ *  \note Deprecated. Please use std::vector as default or
+ *  re-define the vector class to match the std::vector
+ *  interface by defining VECTOR_CLASS
+
+ *  \note Not recommended for use with custom objects as
+ *  current implementation will construct N elements
+ *
+ * std::vector functionality.
+ *  \brief Fixed sized vector compatible with std::vector.
+ *
+ *  \note
+ *  This differs from std::vector<> not just in memory allocation,
+ *  but also in terms of when members are constructed, destroyed,
+ *  and assigned instead of being copy constructed.
+ *
+ *  \param T type of element contained in the vector.
+ *
+ *  \param N maximum size of the vector.
+ */
+template <typename T, unsigned int N = __MAX_DEFAULT_VECTOR_SIZE>
+class CL_EXT_PREFIX__VERSION_1_1_DEPRECATED vector
+{
+private:
+    T data_[N];
+    unsigned int size_;
+
+public:
+    //! \brief Constructs an empty vector with no memory allocated.
+    vector() :  
+        size_(static_cast<unsigned int>(0))
+    {}
+
+    //! \brief Deallocates the vector's memory and destroys all of its elements.
+    ~vector() 
+    {
+        clear();
+    }
+
+    //! \brief Returns the number of elements currently contained.
+    unsigned int size(void) const
+    {
+        return size_;
+    }
+    
+    /*! \brief Empties the vector of all elements.
+     *  \note
+     *  This does not deallocate memory but will invoke destructors
+     *  on contained elements.
+     */
+    void clear()
+    {
+        while(!empty()) {
+            pop_back();
+        }
+    }
+
+    /*! \brief Appends an element after the last valid element.
+     * Calling this on a vector that has reached capacity will throw an 
+     * exception if exceptions are enabled.
+     */
+    void push_back (const T& x)
+    { 
+        if (size() < N) {
+            new (&data_[size_]) T(x);
+            size_++;
+        } else {
+            detail::errHandler(CL_MEM_OBJECT_ALLOCATION_FAILURE, __VECTOR_CAPACITY_ERR);
+        }
+    }
+
+    /*! \brief Removes the last valid element from the vector.
+     * Calling this on an empty vector will throw an exception
+     * if exceptions are enabled.
+     */
+    void pop_back(void)
+    {
+        if (size_ != 0) {
+            --size_;
+            data_[size_].~T();
+        } else {
+            detail::errHandler(CL_MEM_OBJECT_ALLOCATION_FAILURE, __VECTOR_CAPACITY_ERR);
+        }
+    }
+
+    /*! \brief Constructs with a value copied from another.
+     *
+     *  \param vec the vector to copy.
+     */
+    vector(const vector<T, N>& vec) : 
+        size_(vec.size_)
+    {
+        if (size_ != 0) {
+            assign(vec.begin(), vec.end());
+        }
+    } 
+
+    /*! \brief Constructs with a specified number of initial elements.
+     *
+     *  \param size number of initial elements.
+     *
+     *  \param val value of initial elements.
+     */
+    vector(unsigned int size, const T& val = T()) :
+        size_(0)
+    {
+        for (unsigned int i = 0; i < size; i++) {
+            push_back(val);
+        }
+    }
+
+    /*! \brief Overwrites the current content with that copied from another
+     *         instance.
+     *
+     *  \param rhs vector to copy.
+     *
+     *  \returns a reference to this.
+     */
+    vector<T, N>& operator=(const vector<T, N>& rhs)
+    {
+        if (this == &rhs) {
+            return *this;
+        }
+
+        if (rhs.size_ != 0) {	
+            assign(rhs.begin(), rhs.end());
+        } else {
+            clear();
+        }
+
+        return *this;
+    }
+
+    /*! \brief Tests equality against another instance.
+     *
+     *  \param vec the vector against which to compare.
+     */
+    bool operator==(vector<T,N> &vec)
+    {
+        if (size() != vec.size()) {
+            return false;
+        }
+
+        for( unsigned int i = 0; i < size(); ++i ) {
+            if( operator[](i) != vec[i] ) {
+                return false;
+            }
+        }
+        return true;
+    }
+  
+    //! \brief Conversion operator to T*.
+    operator T* ()             { return data_; }
+
+    //! \brief Conversion operator to const T*.
+    operator const T* () const { return data_; }
+   
+    //! \brief Tests whether this instance has any elements.
+    bool empty (void) const
+    {
+        return size_==0;
+    }
+  
+    //! \brief Returns the maximum number of elements this instance can hold.
+    unsigned int max_size (void) const
+    {
+        return N;
+    }
+
+    //! \brief Returns the maximum number of elements this instance can hold.
+    unsigned int capacity () const
+    {
+        return N;
+    }
+
+    //! \brief Resizes the vector to the given size
+    void resize(unsigned int newSize, T fill = T())
+    {
+        if (newSize > N)
+        {
+            detail::errHandler(CL_MEM_OBJECT_ALLOCATION_FAILURE, __VECTOR_CAPACITY_ERR);
+        }
+        else
+        {
+            while (size_ < newSize)
+            {
+                new (&data_[size_]) T(fill);
+                size_++;
+            }
+            while (size_ > newSize)
+            {
+                --size_;
+                data_[size_].~T();
+            }
+        }
+    }
+
+    /*! \brief Returns a reference to a given element.
+     *
+     *  \param index which element to access.     *
+     *  \note
+     *  The caller is responsible for ensuring index is >= 0 and < size().
+     */
+    T& operator[](int index)
+    {
+        return data_[index];
+    }
+  
+    /*! \brief Returns a const reference to a given element.
+     *
+     *  \param index which element to access.
+     *
+     *  \note
+     *  The caller is responsible for ensuring index is >= 0 and < size().
+     */
+    const T& operator[](int index) const
+    {
+        return data_[index];
+    }
+  
+    /*! \brief Assigns elements of the vector based on a source iterator range.
+     *
+     *  \param start Beginning iterator of source range
+     *  \param end Enditerator of source range
+     *
+     *  \note
+     *  Will throw an exception if exceptions are enabled and size exceeded.
+     */
+    template<class I>
+    void assign(I start, I end)
+    {
+        clear();   
+        while(start != end) {
+            push_back(*start);
+            start++;
+        }
+    }
+
+    /*! \class iterator
+     * \brief Const iterator class for vectors
+     */
+    class iterator
+    {
+    private:
+        const vector<T,N> *vec_;
+        int index_;
+
+        /**
+         * Internal iterator constructor to capture reference
+         * to the vector it iterates over rather than taking 
+         * the vector by copy.
+         */
+        iterator (const vector<T,N> &vec, int index) :
+            vec_(&vec)
+        {            
+            if( !vec.empty() ) {
+                index_ = index;
+            } else {
+                index_ = -1;
+            }
+        }
+
+    public:
+        iterator(void) : 
+            index_(-1),
+            vec_(NULL)
+        {
+        }
+
+        iterator(const iterator& rhs) :
+            vec_(rhs.vec_),
+            index_(rhs.index_)
+        {
+        }
+
+        ~iterator(void) {}
+
+        static iterator begin(const cl::vector<T,N> &vec)
+        {
+            iterator i(vec, 0);
+
+            return i;
+        }
+
+        static iterator end(const cl::vector<T,N> &vec)
+        {
+            iterator i(vec, vec.size());
+
+            return i;
+        }
+    
+        bool operator==(iterator i)
+        {
+            return ((vec_ == i.vec_) && 
+                    (index_ == i.index_));
+        }
+
+        bool operator!=(iterator i)
+        {
+            return (!(*this==i));
+        }
+
+        iterator& operator++()
+        {
+            ++index_;
+            return *this;
+        }
+
+        iterator operator++(int)
+        {
+            iterator retVal(*this);
+            ++index_;
+            return retVal;
+        }
+
+        iterator& operator--()
+        {
+            --index_;
+            return *this;
+        }
+
+        iterator operator--(int)
+        {
+            iterator retVal(*this);
+            --index_;
+            return retVal;
+        }
+
+        const T& operator *() const
+        {
+            return (*vec_)[index_];
+        }
+    };
+
+    iterator begin(void)
+    {
+        return iterator::begin(*this);
+    }
+
+    iterator begin(void) const
+    {
+        return iterator::begin(*this);
+    }
+
+    iterator end(void)
+    {
+        return iterator::end(*this);
+    }
+
+    iterator end(void) const
+    {
+        return iterator::end(*this);
+    }
+
+    T& front(void)
+    {
+        return data_[0];
+    }
+
+    T& back(void)
+    {
+        return data_[size_];
+    }
+
+    const T& front(void) const
+    {
+        return data_[0];
+    }
+
+    const T& back(void) const
+    {
+        return data_[size_-1];
+    }
+} CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED;
+#endif // #if !defined(__USE_DEV_VECTOR) && !defined(__NO_STD_VECTOR)
+
+
+
+
+
+namespace detail {
+#define __DEFAULT_NOT_INITIALIZED 1 
+#define __DEFAULT_BEING_INITIALIZED 2
+#define __DEFAULT_INITIALIZED 4
+
+    /*
+     * Compare and exchange primitives are needed for handling of defaults
+    */
+
+#ifdef CL_HPP_CPP11_ATOMICS_SUPPORTED
+    inline int compare_exchange(std::atomic<int> * dest, int exchange, int comparand)
+#else // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+    inline int compare_exchange(volatile int * dest, int exchange, int comparand)
+#endif // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+    {
+#ifdef CL_HPP_CPP11_ATOMICS_SUPPORTED
+        std::atomic_compare_exchange_strong(dest, &comparand, exchange);
+        return comparand;
+#elif _MSC_VER
+        return (int)(_InterlockedCompareExchange(
+            (volatile long*)dest,
+            (long)exchange,
+            (long)comparand));
+#else // !_MSC_VER && !CL_HPP_CPP11_ATOMICS_SUPPORTED
+        return (__sync_val_compare_and_swap(
+            dest,
+            comparand,
+            exchange));
+#endif // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+    }
+
+    inline void fence() {
+#ifdef CL_HPP_CPP11_ATOMICS_SUPPORTED
+        std::atomic_thread_fence(std::memory_order_seq_cst);
+#elif _MSC_VER // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+        _ReadWriteBarrier();
+#else // !_MSC_VER && !CL_HPP_CPP11_ATOMICS_SUPPORTED
+        __sync_synchronize();
+#endif // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+    }
+} // namespace detail
+
+    
+/*! \brief class used to interface between C++ and
+ *  OpenCL C calls that require arrays of size_t values, whose
+ *  size is known statically.
+ */
+template <int N>
+class size_t
+{ 
+private:
+    ::size_t data_[N];
+
+public:
+    //! \brief Initialize size_t to all 0s
+    size_t()
+    {
+        for( int i = 0; i < N; ++i ) {
+            data_[i] = 0;
+        }
+    }
+
+    ::size_t& operator[](int index)
+    {
+        return data_[index];
+    }
+
+    const ::size_t& operator[](int index) const
+    {
+        return data_[index];
+    }
+
+    //! \brief Conversion operator to T*.
+    operator ::size_t* ()             { return data_; }
+
+    //! \brief Conversion operator to const T*.
+    operator const ::size_t* () const { return data_; }
+};
+
+namespace detail {
+
+// Generic getInfoHelper. The final parameter is used to guide overload
+// resolution: the actual parameter passed is an int, which makes this
+// a worse conversion sequence than a specialization that declares the
+// parameter as an int.
+template<typename Functor, typename T>
+inline cl_int getInfoHelper(Functor f, cl_uint name, T* param, long)
+{
+    return f(name, sizeof(T), param, NULL);
+}
+
+// Specialized getInfoHelper for VECTOR_CLASS params
+template <typename Func, typename T>
+inline cl_int getInfoHelper(Func f, cl_uint name, VECTOR_CLASS<T>* param, long)
+{
+    ::size_t required;
+    cl_int err = f(name, 0, NULL, &required);
+    if (err != CL_SUCCESS) {
+        return err;
+    }
+
+    T* value = (T*) alloca(required);
+    err = f(name, required, value, NULL);
+    if (err != CL_SUCCESS) {
+        return err;
+    }
+
+    param->assign(&value[0], &value[required/sizeof(T)]);
+    return CL_SUCCESS;
+}
+
+/* Specialization for reference-counted types. This depends on the
+ * existence of Wrapper<T>::cl_type, and none of the other types having the
+ * cl_type member. Note that simplify specifying the parameter as Wrapper<T>
+ * does not work, because when using a derived type (e.g. Context) the generic
+ * template will provide a better match.
+ */
+template <typename Func, typename T>
+inline cl_int getInfoHelper(Func f, cl_uint name, VECTOR_CLASS<T>* param, int, typename T::cl_type = 0)
+{
+    ::size_t required;
+    cl_int err = f(name, 0, NULL, &required);
+    if (err != CL_SUCCESS) {
+        return err;
+    }
+
+    typename T::cl_type * value = (typename T::cl_type *) alloca(required);
+    err = f(name, required, value, NULL);
+    if (err != CL_SUCCESS) {
+        return err;
+    }
+
+    ::size_t elements = required / sizeof(typename T::cl_type);
+    param->assign(&value[0], &value[elements]);
+    for (::size_t i = 0; i < elements; i++)
+    {
+        if (value[i] != NULL)
+        {
+            err = (*param)[i].retain();
+            if (err != CL_SUCCESS) {
+                return err;
+            }
+        }
+    }
+    return CL_SUCCESS;
+}
+
+// Specialized for getInfo<CL_PROGRAM_BINARIES>
+template <typename Func>
+inline cl_int getInfoHelper(Func f, cl_uint name, VECTOR_CLASS<char *>* param, int)
+{
+    cl_int err = f(name, param->size() * sizeof(char *), &(*param)[0], NULL);
+
+    if (err != CL_SUCCESS) {
+        return err;
+    }
+
+    return CL_SUCCESS;
+}
+
+// Specialized GetInfoHelper for STRING_CLASS params
+template <typename Func>
+inline cl_int getInfoHelper(Func f, cl_uint name, STRING_CLASS* param, long)
+{
+#if defined(__NO_STD_VECTOR) || defined(__NO_STD_STRING)
+    ::size_t required;
+    cl_int err = f(name, 0, NULL, &required);
+    if (err != CL_SUCCESS) {
+        return err;
+    }
+
+    char* value = (char*)alloca(required);
+    err = f(name, required, value, NULL);
+    if (err != CL_SUCCESS) {
+        return err;
+    }
+
+    *param = value;
+    return CL_SUCCESS;
+#else 
+    ::size_t required;
+    cl_int err = f(name, 0, NULL, &required);
+    if (err != CL_SUCCESS) {
+        return err;
+    }
+
+    // std::string has a constant data member
+    // a char vector does not
+    VECTOR_CLASS<char> value(required);
+    err = f(name, required, value.data(), NULL);
+    if (err != CL_SUCCESS) {
+        return err;
+    }
+    if (param) {
+        param->assign(value.begin(), value.end());
+    }
+#endif
+    return CL_SUCCESS;
+}
+
+// Specialized GetInfoHelper for cl::size_t params
+template <typename Func, ::size_t N>
+inline cl_int getInfoHelper(Func f, cl_uint name, size_t<N>* param, long)
+{
+    ::size_t required;
+    cl_int err = f(name, 0, NULL, &required);
+    if (err != CL_SUCCESS) {
+        return err;
+    }
+
+    ::size_t* value = (::size_t*) alloca(required);
+    err = f(name, required, value, NULL);
+    if (err != CL_SUCCESS) {
+        return err;
+    }
+
+    for(int i = 0; i < N; ++i) {
+        (*param)[i] = value[i];
+    }
+
+    return CL_SUCCESS;
+}
+
+template<typename T> struct ReferenceHandler;
+
+/* Specialization for reference-counted types. This depends on the
+ * existence of Wrapper<T>::cl_type, and none of the other types having the
+ * cl_type member. Note that simplify specifying the parameter as Wrapper<T>
+ * does not work, because when using a derived type (e.g. Context) the generic
+ * template will provide a better match.
+ */
+template<typename Func, typename T>
+inline cl_int getInfoHelper(Func f, cl_uint name, T* param, int, typename T::cl_type = 0)
+{
+    typename T::cl_type value;
+    cl_int err = f(name, sizeof(value), &value, NULL);
+    if (err != CL_SUCCESS) {
+        return err;
+    }
+    *param = value;
+    if (value != NULL)
+    {
+        err = param->retain();
+        if (err != CL_SUCCESS) {
+            return err;
+        }
+    }
+    return CL_SUCCESS;
+}
+
+#define __PARAM_NAME_INFO_1_0(F) \
+    F(cl_platform_info, CL_PLATFORM_PROFILE, STRING_CLASS) \
+    F(cl_platform_info, CL_PLATFORM_VERSION, STRING_CLASS) \
+    F(cl_platform_info, CL_PLATFORM_NAME, STRING_CLASS) \
+    F(cl_platform_info, CL_PLATFORM_VENDOR, STRING_CLASS) \
+    F(cl_platform_info, CL_PLATFORM_EXTENSIONS, STRING_CLASS) \
+    \
+    F(cl_device_info, CL_DEVICE_TYPE, cl_device_type) \
+    F(cl_device_info, CL_DEVICE_VENDOR_ID, cl_uint) \
+    F(cl_device_info, CL_DEVICE_MAX_COMPUTE_UNITS, cl_uint) \
+    F(cl_device_info, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, cl_uint) \
+    F(cl_device_info, CL_DEVICE_MAX_WORK_GROUP_SIZE, ::size_t) \
+    F(cl_device_info, CL_DEVICE_MAX_WORK_ITEM_SIZES, VECTOR_CLASS< ::size_t>) \
+    F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, cl_uint) \
+    F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, cl_uint) \
+    F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, cl_uint) \
+    F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, cl_uint) \
+    F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, cl_uint) \
+    F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, cl_uint) \
+    F(cl_device_info, CL_DEVICE_MAX_CLOCK_FREQUENCY, cl_uint) \
+    F(cl_device_info, CL_DEVICE_ADDRESS_BITS, cl_uint) \
+    F(cl_device_info, CL_DEVICE_MAX_READ_IMAGE_ARGS, cl_uint) \
+    F(cl_device_info, CL_DEVICE_MAX_WRITE_IMAGE_ARGS, cl_uint) \
+    F(cl_device_info, CL_DEVICE_MAX_MEM_ALLOC_SIZE, cl_ulong) \
+    F(cl_device_info, CL_DEVICE_IMAGE2D_MAX_WIDTH, ::size_t) \
+    F(cl_device_info, CL_DEVICE_IMAGE2D_MAX_HEIGHT, ::size_t) \
+    F(cl_device_info, CL_DEVICE_IMAGE3D_MAX_WIDTH, ::size_t) \
+    F(cl_device_info, CL_DEVICE_IMAGE3D_MAX_HEIGHT, ::size_t) \
+    F(cl_device_info, CL_DEVICE_IMAGE3D_MAX_DEPTH, ::size_t) \
+    F(cl_device_info, CL_DEVICE_IMAGE_SUPPORT, cl_bool) \
+    F(cl_device_info, CL_DEVICE_MAX_PARAMETER_SIZE, ::size_t) \
+    F(cl_device_info, CL_DEVICE_MAX_SAMPLERS, cl_uint) \
+    F(cl_device_info, CL_DEVICE_MEM_BASE_ADDR_ALIGN, cl_uint) \
+    F(cl_device_info, CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, cl_uint) \
+    F(cl_device_info, CL_DEVICE_SINGLE_FP_CONFIG, cl_device_fp_config) \
+    F(cl_device_info, CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, cl_device_mem_cache_type) \
+    F(cl_device_info, CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, cl_uint)\
+    F(cl_device_info, CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, cl_ulong) \
+    F(cl_device_info, CL_DEVICE_GLOBAL_MEM_SIZE, cl_ulong) \
+    F(cl_device_info, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, cl_ulong) \
+    F(cl_device_info, CL_DEVICE_MAX_CONSTANT_ARGS, cl_uint) \
+    F(cl_device_info, CL_DEVICE_LOCAL_MEM_TYPE, cl_device_local_mem_type) \
+    F(cl_device_info, CL_DEVICE_LOCAL_MEM_SIZE, cl_ulong) \
+    F(cl_device_info, CL_DEVICE_ERROR_CORRECTION_SUPPORT, cl_bool) \
+    F(cl_device_info, CL_DEVICE_PROFILING_TIMER_RESOLUTION, ::size_t) \
+    F(cl_device_info, CL_DEVICE_ENDIAN_LITTLE, cl_bool) \
+    F(cl_device_info, CL_DEVICE_AVAILABLE, cl_bool) \
+    F(cl_device_info, CL_DEVICE_COMPILER_AVAILABLE, cl_bool) \
+    F(cl_device_info, CL_DEVICE_EXECUTION_CAPABILITIES, cl_device_exec_capabilities) \
+    F(cl_device_info, CL_DEVICE_QUEUE_PROPERTIES, cl_command_queue_properties) \
+    F(cl_device_info, CL_DEVICE_PLATFORM, cl_platform_id) \
+    F(cl_device_info, CL_DEVICE_NAME, STRING_CLASS) \
+    F(cl_device_info, CL_DEVICE_VENDOR, STRING_CLASS) \
+    F(cl_device_info, CL_DRIVER_VERSION, STRING_CLASS) \
+    F(cl_device_info, CL_DEVICE_PROFILE, STRING_CLASS) \
+    F(cl_device_info, CL_DEVICE_VERSION, STRING_CLASS) \
+    F(cl_device_info, CL_DEVICE_EXTENSIONS, STRING_CLASS) \
+    \
+    F(cl_context_info, CL_CONTEXT_REFERENCE_COUNT, cl_uint) \
+    F(cl_context_info, CL_CONTEXT_DEVICES, VECTOR_CLASS<Device>) \
+    F(cl_context_info, CL_CONTEXT_PROPERTIES, VECTOR_CLASS<cl_context_properties>) \
+    \
+    F(cl_event_info, CL_EVENT_COMMAND_QUEUE, cl::CommandQueue) \
+    F(cl_event_info, CL_EVENT_COMMAND_TYPE, cl_command_type) \
+    F(cl_event_info, CL_EVENT_REFERENCE_COUNT, cl_uint) \
+    F(cl_event_info, CL_EVENT_COMMAND_EXECUTION_STATUS, cl_int) \
+    \
+    F(cl_profiling_info, CL_PROFILING_COMMAND_QUEUED, cl_ulong) \
+    F(cl_profiling_info, CL_PROFILING_COMMAND_SUBMIT, cl_ulong) \
+    F(cl_profiling_info, CL_PROFILING_COMMAND_START, cl_ulong) \
+    F(cl_profiling_info, CL_PROFILING_COMMAND_END, cl_ulong) \
+    \
+    F(cl_mem_info, CL_MEM_TYPE, cl_mem_object_type) \
+    F(cl_mem_info, CL_MEM_FLAGS, cl_mem_flags) \
+    F(cl_mem_info, CL_MEM_SIZE, ::size_t) \
+    F(cl_mem_info, CL_MEM_HOST_PTR, void*) \
+    F(cl_mem_info, CL_MEM_MAP_COUNT, cl_uint) \
+    F(cl_mem_info, CL_MEM_REFERENCE_COUNT, cl_uint) \
+    F(cl_mem_info, CL_MEM_CONTEXT, cl::Context) \
+    \
+    F(cl_image_info, CL_IMAGE_FORMAT, cl_image_format) \
+    F(cl_image_info, CL_IMAGE_ELEMENT_SIZE, ::size_t) \
+    F(cl_image_info, CL_IMAGE_ROW_PITCH, ::size_t) \
+    F(cl_image_info, CL_IMAGE_SLICE_PITCH, ::size_t) \
+    F(cl_image_info, CL_IMAGE_WIDTH, ::size_t) \
+    F(cl_image_info, CL_IMAGE_HEIGHT, ::size_t) \
+    F(cl_image_info, CL_IMAGE_DEPTH, ::size_t) \
+    \
+    F(cl_sampler_info, CL_SAMPLER_REFERENCE_COUNT, cl_uint) \
+    F(cl_sampler_info, CL_SAMPLER_CONTEXT, cl::Context) \
+    F(cl_sampler_info, CL_SAMPLER_NORMALIZED_COORDS, cl_bool) \
+    F(cl_sampler_info, CL_SAMPLER_ADDRESSING_MODE, cl_addressing_mode) \
+    F(cl_sampler_info, CL_SAMPLER_FILTER_MODE, cl_filter_mode) \
+    \
+    F(cl_program_info, CL_PROGRAM_REFERENCE_COUNT, cl_uint) \
+    F(cl_program_info, CL_PROGRAM_CONTEXT, cl::Context) \
+    F(cl_program_info, CL_PROGRAM_NUM_DEVICES, cl_uint) \
+    F(cl_program_info, CL_PROGRAM_DEVICES, VECTOR_CLASS<Device>) \
+    F(cl_program_info, CL_PROGRAM_SOURCE, STRING_CLASS) \
+    F(cl_program_info, CL_PROGRAM_BINARY_SIZES, VECTOR_CLASS< ::size_t>) \
+    F(cl_program_info, CL_PROGRAM_BINARIES, VECTOR_CLASS<char *>) \
+    \
+    F(cl_program_build_info, CL_PROGRAM_BUILD_STATUS, cl_build_status) \
+    F(cl_program_build_info, CL_PROGRAM_BUILD_OPTIONS, STRING_CLASS) \
+    F(cl_program_build_info, CL_PROGRAM_BUILD_LOG, STRING_CLASS) \
+    \
+    F(cl_kernel_info, CL_KERNEL_FUNCTION_NAME, STRING_CLASS) \
+    F(cl_kernel_info, CL_KERNEL_NUM_ARGS, cl_uint) \
+    F(cl_kernel_info, CL_KERNEL_REFERENCE_COUNT, cl_uint) \
+    F(cl_kernel_info, CL_KERNEL_CONTEXT, cl::Context) \
+    F(cl_kernel_info, CL_KERNEL_PROGRAM, cl::Program) \
+    \
+    F(cl_kernel_work_group_info, CL_KERNEL_WORK_GROUP_SIZE, ::size_t) \
+    F(cl_kernel_work_group_info, CL_KERNEL_COMPILE_WORK_GROUP_SIZE, cl::size_t<3>) \
+    F(cl_kernel_work_group_info, CL_KERNEL_LOCAL_MEM_SIZE, cl_ulong) \
+    \
+    F(cl_command_queue_info, CL_QUEUE_CONTEXT, cl::Context) \
+    F(cl_command_queue_info, CL_QUEUE_DEVICE, cl::Device) \
+    F(cl_command_queue_info, CL_QUEUE_REFERENCE_COUNT, cl_uint) \
+    F(cl_command_queue_info, CL_QUEUE_PROPERTIES, cl_command_queue_properties)
+
+#if defined(CL_VERSION_1_1)
+#define __PARAM_NAME_INFO_1_1(F) \
+    F(cl_context_info, CL_CONTEXT_NUM_DEVICES, cl_uint)\
+    F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF, cl_uint) \
+    F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, cl_uint) \
+    F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, cl_uint) \
+    F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, cl_uint) \
+    F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, cl_uint) \
+    F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, cl_uint) \
+    F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, cl_uint) \
+    F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, cl_uint) \
+    F(cl_device_info, CL_DEVICE_DOUBLE_FP_CONFIG, cl_device_fp_config) \
+    F(cl_device_info, CL_DEVICE_HALF_FP_CONFIG, cl_device_fp_config) \
+    F(cl_device_info, CL_DEVICE_HOST_UNIFIED_MEMORY, cl_bool) \
+    F(cl_device_info, CL_DEVICE_OPENCL_C_VERSION, STRING_CLASS) \
+    \
+    F(cl_mem_info, CL_MEM_ASSOCIATED_MEMOBJECT, cl::Memory) \
+    F(cl_mem_info, CL_MEM_OFFSET, ::size_t) \
+    \
+    F(cl_kernel_work_group_info, CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, ::size_t) \
+    F(cl_kernel_work_group_info, CL_KERNEL_PRIVATE_MEM_SIZE, cl_ulong) \
+    \
+    F(cl_event_info, CL_EVENT_CONTEXT, cl::Context)
+#endif // CL_VERSION_1_1
+
+    
+#if defined(CL_VERSION_1_2)
+#define __PARAM_NAME_INFO_1_2(F) \
+    F(cl_image_info, CL_IMAGE_BUFFER, cl::Buffer) \
+    \
+    F(cl_program_info, CL_PROGRAM_NUM_KERNELS, ::size_t) \
+    F(cl_program_info, CL_PROGRAM_KERNEL_NAMES, STRING_CLASS) \
+    \
+    F(cl_program_build_info, CL_PROGRAM_BINARY_TYPE, cl_program_binary_type) \
+    \
+    F(cl_kernel_info, CL_KERNEL_ATTRIBUTES, STRING_CLASS) \
+    \
+    F(cl_kernel_arg_info, CL_KERNEL_ARG_ADDRESS_QUALIFIER, cl_kernel_arg_address_qualifier) \
+    F(cl_kernel_arg_info, CL_KERNEL_ARG_ACCESS_QUALIFIER, cl_kernel_arg_access_qualifier) \
+    F(cl_kernel_arg_info, CL_KERNEL_ARG_TYPE_NAME, STRING_CLASS) \
+    F(cl_kernel_arg_info, CL_KERNEL_ARG_NAME, STRING_CLASS) \
+    F(cl_kernel_arg_info, CL_KERNEL_ARG_TYPE_QUALIFIER, cl_kernel_arg_type_qualifier) \
+    \
+    F(cl_device_info, CL_DEVICE_PARENT_DEVICE, cl_device_id) \
+    F(cl_device_info, CL_DEVICE_PARTITION_PROPERTIES, VECTOR_CLASS<cl_device_partition_property>) \
+    F(cl_device_info, CL_DEVICE_PARTITION_TYPE, VECTOR_CLASS<cl_device_partition_property>)  \
+    F(cl_device_info, CL_DEVICE_REFERENCE_COUNT, cl_uint) \
+    F(cl_device_info, CL_DEVICE_PREFERRED_INTEROP_USER_SYNC, ::size_t) \
+    F(cl_device_info, CL_DEVICE_PARTITION_AFFINITY_DOMAIN, cl_device_affinity_domain) \
+    F(cl_device_info, CL_DEVICE_BUILT_IN_KERNELS, STRING_CLASS)
+#endif // #if defined(CL_VERSION_1_2)
+
+#if defined(USE_CL_DEVICE_FISSION)
+#define __PARAM_NAME_DEVICE_FISSION(F) \
+    F(cl_device_info, CL_DEVICE_PARENT_DEVICE_EXT, cl_device_id) \
+    F(cl_device_info, CL_DEVICE_PARTITION_TYPES_EXT, VECTOR_CLASS<cl_device_partition_property_ext>) \
+    F(cl_device_info, CL_DEVICE_AFFINITY_DOMAINS_EXT, VECTOR_CLASS<cl_device_partition_property_ext>) \
+    F(cl_device_info, CL_DEVICE_REFERENCE_COUNT_EXT , cl_uint) \
+    F(cl_device_info, CL_DEVICE_PARTITION_STYLE_EXT, VECTOR_CLASS<cl_device_partition_property_ext>)
+#endif // USE_CL_DEVICE_FISSION
+
+template <typename enum_type, cl_int Name>
+struct param_traits {};
+
+#define __CL_DECLARE_PARAM_TRAITS(token, param_name, T) \
+struct token;                                        \
+template<>                                           \
+struct param_traits<detail:: token,param_name>       \
+{                                                    \
+    enum { value = param_name };                     \
+    typedef T param_type;                            \
+};
+
+__PARAM_NAME_INFO_1_0(__CL_DECLARE_PARAM_TRAITS)
+#if defined(CL_VERSION_1_1)
+__PARAM_NAME_INFO_1_1(__CL_DECLARE_PARAM_TRAITS)
+#endif // CL_VERSION_1_1
+#if defined(CL_VERSION_1_2)
+__PARAM_NAME_INFO_1_2(__CL_DECLARE_PARAM_TRAITS)
+#endif // CL_VERSION_1_1
+
+#if defined(USE_CL_DEVICE_FISSION)
+__PARAM_NAME_DEVICE_FISSION(__CL_DECLARE_PARAM_TRAITS);
+#endif // USE_CL_DEVICE_FISSION
+
+#ifdef CL_PLATFORM_ICD_SUFFIX_KHR
+__CL_DECLARE_PARAM_TRAITS(cl_platform_info, CL_PLATFORM_ICD_SUFFIX_KHR, STRING_CLASS)
+#endif
+
+#ifdef CL_DEVICE_PROFILING_TIMER_OFFSET_AMD
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_PROFILING_TIMER_OFFSET_AMD, cl_ulong)
+#endif
+
+#ifdef CL_DEVICE_GLOBAL_FREE_MEMORY_AMD
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_GLOBAL_FREE_MEMORY_AMD, VECTOR_CLASS< ::size_t>)
+#endif
+#ifdef CL_DEVICE_SIMD_PER_COMPUTE_UNIT_AMD
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_SIMD_PER_COMPUTE_UNIT_AMD, cl_uint)
+#endif
+#ifdef CL_DEVICE_SIMD_WIDTH_AMD
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_SIMD_WIDTH_AMD, cl_uint)
+#endif
+#ifdef CL_DEVICE_SIMD_INSTRUCTION_WIDTH_AMD
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_SIMD_INSTRUCTION_WIDTH_AMD, cl_uint)
+#endif
+#ifdef CL_DEVICE_WAVEFRONT_WIDTH_AMD
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_WAVEFRONT_WIDTH_AMD, cl_uint)
+#endif
+#ifdef CL_DEVICE_GLOBAL_MEM_CHANNELS_AMD
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_GLOBAL_MEM_CHANNELS_AMD, cl_uint)
+#endif
+#ifdef CL_DEVICE_GLOBAL_MEM_CHANNEL_BANKS_AMD
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_GLOBAL_MEM_CHANNEL_BANKS_AMD, cl_uint)
+#endif
+#ifdef CL_DEVICE_GLOBAL_MEM_CHANNEL_BANK_WIDTH_AMD
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_GLOBAL_MEM_CHANNEL_BANK_WIDTH_AMD, cl_uint)
+#endif
+#ifdef CL_DEVICE_LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD, cl_uint)
+#endif
+#ifdef CL_DEVICE_LOCAL_MEM_BANKS_AMD
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_LOCAL_MEM_BANKS_AMD, cl_uint)
+#endif
+
+#ifdef CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, cl_uint)
+#endif
+#ifdef CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, cl_uint)
+#endif
+#ifdef CL_DEVICE_REGISTERS_PER_BLOCK_NV
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_REGISTERS_PER_BLOCK_NV, cl_uint)
+#endif
+#ifdef CL_DEVICE_WARP_SIZE_NV
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_WARP_SIZE_NV, cl_uint)
+#endif
+#ifdef CL_DEVICE_GPU_OVERLAP_NV
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_GPU_OVERLAP_NV, cl_bool)
+#endif
+#ifdef CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, cl_bool)
+#endif
+#ifdef CL_DEVICE_INTEGRATED_MEMORY_NV
+__CL_DECLARE_PARAM_TRAITS(cl_device_info, CL_DEVICE_INTEGRATED_MEMORY_NV, cl_bool)
+#endif
+
+// Convenience functions
+
+template <typename Func, typename T>
+inline cl_int
+getInfo(Func f, cl_uint name, T* param)
+{
+    return getInfoHelper(f, name, param, 0);
+}
+
+template <typename Func, typename Arg0>
+struct GetInfoFunctor0
+{
+    Func f_; const Arg0& arg0_;
+    cl_int operator ()(
+        cl_uint param, ::size_t size, void* value, ::size_t* size_ret)
+    { return f_(arg0_, param, size, value, size_ret); }
+};
+
+template <typename Func, typename Arg0, typename Arg1>
+struct GetInfoFunctor1
+{
+    Func f_; const Arg0& arg0_; const Arg1& arg1_;
+    cl_int operator ()(
+        cl_uint param, ::size_t size, void* value, ::size_t* size_ret)
+    { return f_(arg0_, arg1_, param, size, value, size_ret); }
+};
+
+template <typename Func, typename Arg0, typename T>
+inline cl_int
+getInfo(Func f, const Arg0& arg0, cl_uint name, T* param)
+{
+    GetInfoFunctor0<Func, Arg0> f0 = { f, arg0 };
+    return getInfoHelper(f0, name, param, 0);
+}
+
+template <typename Func, typename Arg0, typename Arg1, typename T>
+inline cl_int
+getInfo(Func f, const Arg0& arg0, const Arg1& arg1, cl_uint name, T* param)
+{
+    GetInfoFunctor1<Func, Arg0, Arg1> f0 = { f, arg0, arg1 };
+    return getInfoHelper(f0, name, param, 0);
+}
+
+template<typename T>
+struct ReferenceHandler
+{ };
+
+#if defined(CL_VERSION_1_2)
+/**
+ * OpenCL 1.2 devices do have retain/release.
+ */
+template <>
+struct ReferenceHandler<cl_device_id>
+{
+    /**
+     * Retain the device.
+     * \param device A valid device created using createSubDevices
+     * \return 
+     *   CL_SUCCESS if the function executed successfully.
+     *   CL_INVALID_DEVICE if device was not a valid subdevice
+     *   CL_OUT_OF_RESOURCES
+     *   CL_OUT_OF_HOST_MEMORY
+     */
+    static cl_int retain(cl_device_id device)
+    { return ::clRetainDevice(device); }
+    /**
+     * Retain the device.
+     * \param device A valid device created using createSubDevices
+     * \return 
+     *   CL_SUCCESS if the function executed successfully.
+     *   CL_INVALID_DEVICE if device was not a valid subdevice
+     *   CL_OUT_OF_RESOURCES
+     *   CL_OUT_OF_HOST_MEMORY
+     */
+    static cl_int release(cl_device_id device)
+    { return ::clReleaseDevice(device); }
+};
+#else // #if defined(CL_VERSION_1_2)
+/**
+ * OpenCL 1.1 devices do not have retain/release.
+ */
+template <>
+struct ReferenceHandler<cl_device_id>
+{
+    // cl_device_id does not have retain().
+    static cl_int retain(cl_device_id)
+    { return CL_SUCCESS; }
+    // cl_device_id does not have release().
+    static cl_int release(cl_device_id)
+    { return CL_SUCCESS; }
+};
+#endif // #if defined(CL_VERSION_1_2)
+
+template <>
+struct ReferenceHandler<cl_platform_id>
+{
+    // cl_platform_id does not have retain().
+    static cl_int retain(cl_platform_id)
+    { return CL_SUCCESS; }
+    // cl_platform_id does not have release().
+    static cl_int release(cl_platform_id)
+    { return CL_SUCCESS; }
+};
+
+template <>
+struct ReferenceHandler<cl_context>
+{
+    static cl_int retain(cl_context context)
+    { return ::clRetainContext(context); }
+    static cl_int release(cl_context context)
+    { return ::clReleaseContext(context); }
+};
+
+template <>
+struct ReferenceHandler<cl_command_queue>
+{
+    static cl_int retain(cl_command_queue queue)
+    { return ::clRetainCommandQueue(queue); }
+    static cl_int release(cl_command_queue queue)
+    { return ::clReleaseCommandQueue(queue); }
+};
+
+template <>
+struct ReferenceHandler<cl_mem>
+{
+    static cl_int retain(cl_mem memory)
+    { return ::clRetainMemObject(memory); }
+    static cl_int release(cl_mem memory)
+    { return ::clReleaseMemObject(memory); }
+};
+
+template <>
+struct ReferenceHandler<cl_sampler>
+{
+    static cl_int retain(cl_sampler sampler)
+    { return ::clRetainSampler(sampler); }
+    static cl_int release(cl_sampler sampler)
+    { return ::clReleaseSampler(sampler); }
+};
+
+template <>
+struct ReferenceHandler<cl_program>
+{
+    static cl_int retain(cl_program program)
+    { return ::clRetainProgram(program); }
+    static cl_int release(cl_program program)
+    { return ::clReleaseProgram(program); }
+};
+
+template <>
+struct ReferenceHandler<cl_kernel>
+{
+    static cl_int retain(cl_kernel kernel)
+    { return ::clRetainKernel(kernel); }
+    static cl_int release(cl_kernel kernel)
+    { return ::clReleaseKernel(kernel); }
+};
+
+template <>
+struct ReferenceHandler<cl_event>
+{
+    static cl_int retain(cl_event event)
+    { return ::clRetainEvent(event); }
+    static cl_int release(cl_event event)
+    { return ::clReleaseEvent(event); }
+};
+
+
+// Extracts version number with major in the upper 16 bits, minor in the lower 16
+static cl_uint getVersion(const char *versionInfo)
+{
+    int highVersion = 0;
+    int lowVersion = 0;
+    int index = 7;
+    while(versionInfo[index] != '.' ) {
+        highVersion *= 10;
+        highVersion += versionInfo[index]-'0';
+        ++index;
+    }
+    ++index;
+    while(versionInfo[index] != ' ' &&  versionInfo[index] != '\0') {
+        lowVersion *= 10;
+        lowVersion += versionInfo[index]-'0';
+        ++index;
+    }
+    return (highVersion << 16) | lowVersion;
+}
+
+static cl_uint getPlatformVersion(cl_platform_id platform)
+{
+    ::size_t size = 0;
+    clGetPlatformInfo(platform, CL_PLATFORM_VERSION, 0, NULL, &size);
+    char *versionInfo = (char *) alloca(size);
+    clGetPlatformInfo(platform, CL_PLATFORM_VERSION, size, &versionInfo[0], &size);
+    return getVersion(versionInfo);
+}
+
+static cl_uint getDevicePlatformVersion(cl_device_id device)
+{
+    cl_platform_id platform;
+    clGetDeviceInfo(device, CL_DEVICE_PLATFORM, sizeof(platform), &platform, NULL);
+    return getPlatformVersion(platform);
+}
+
+#if defined(CL_VERSION_1_2) && defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
+static cl_uint getContextPlatformVersion(cl_context context)
+{
+    // The platform cannot be queried directly, so we first have to grab a
+    // device and obtain its context
+    ::size_t size = 0;
+    clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &size);
+    if (size == 0)
+        return 0;
+    cl_device_id *devices = (cl_device_id *) alloca(size);
+    clGetContextInfo(context, CL_CONTEXT_DEVICES, size, devices, NULL);
+    return getDevicePlatformVersion(devices[0]);
+}
+#endif // #if defined(CL_VERSION_1_2) && defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
+
+template <typename T>
+class Wrapper
+{
+public:
+    typedef T cl_type;
+
+protected:
+    cl_type object_;
+
+public:
+    Wrapper() : object_(NULL) { }
+
+    Wrapper(const cl_type &obj) : object_(obj) { }
+
+    ~Wrapper()
+    {
+        if (object_ != NULL) { release(); }
+    }
+
+    Wrapper(const Wrapper<cl_type>& rhs)
+    {
+        object_ = rhs.object_;
+        if (object_ != NULL) { detail::errHandler(retain(), __RETAIN_ERR); }
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    Wrapper(Wrapper<cl_type>&& rhs) CL_HPP_NOEXCEPT
+    {
+        object_ = rhs.object_;
+        rhs.object_ = NULL;
+    }
+#endif
+
+    Wrapper<cl_type>& operator = (const Wrapper<cl_type>& rhs)
+    {
+        if (this != &rhs) {
+            if (object_ != NULL) { detail::errHandler(release(), __RELEASE_ERR); }
+            object_ = rhs.object_;
+            if (object_ != NULL) { detail::errHandler(retain(), __RETAIN_ERR); }
+        }
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    Wrapper<cl_type>& operator = (Wrapper<cl_type>&& rhs)
+    {
+        if (this != &rhs) {
+            if (object_ != NULL) { detail::errHandler(release(), __RELEASE_ERR); }
+            object_ = rhs.object_;
+            rhs.object_ = NULL;
+        }
+        return *this;
+    }
+#endif
+
+    Wrapper<cl_type>& operator = (const cl_type &rhs)
+    {
+        if (object_ != NULL) { detail::errHandler(release(), __RELEASE_ERR); }
+        object_ = rhs;
+        return *this;
+    }
+
+    cl_type operator ()() const { return object_; }
+
+    cl_type& operator ()() { return object_; }
+
+protected:
+    template<typename Func, typename U>
+    friend inline cl_int getInfoHelper(Func, cl_uint, U*, int, typename U::cl_type);
+
+    cl_int retain() const
+    {
+        return ReferenceHandler<cl_type>::retain(object_);
+    }
+
+    cl_int release() const
+    {
+        return ReferenceHandler<cl_type>::release(object_);
+    }
+};
+
+template <>
+class Wrapper<cl_device_id>
+{
+public:
+    typedef cl_device_id cl_type;
+
+protected:
+    cl_type object_;
+    bool referenceCountable_;
+
+    static bool isReferenceCountable(cl_device_id device)
+    {
+        bool retVal = false;
+        if (device != NULL) {
+            int version = getDevicePlatformVersion(device);
+            if(version > ((1 << 16) + 1)) {
+                retVal = true;
+            }
+        }
+        return retVal;
+    }
+
+public:
+    Wrapper() : object_(NULL), referenceCountable_(false) 
+    { 
+    }
+    
+    Wrapper(const cl_type &obj) : object_(obj), referenceCountable_(false) 
+    {
+        referenceCountable_ = isReferenceCountable(obj); 
+    }
+
+    ~Wrapper()
+    {
+        if (object_ != NULL) { release(); }
+    }
+    
+    Wrapper(const Wrapper<cl_type>& rhs)
+    {
+        object_ = rhs.object_;
+        referenceCountable_ = isReferenceCountable(object_); 
+        if (object_ != NULL) { detail::errHandler(retain(), __RETAIN_ERR); }
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    Wrapper(Wrapper<cl_type>&& rhs) CL_HPP_NOEXCEPT
+    {
+        object_ = rhs.object_;
+        referenceCountable_ = rhs.referenceCountable_;
+        rhs.object_ = NULL;
+        rhs.referenceCountable_ = false;
+    }
+#endif
+
+    Wrapper<cl_type>& operator = (const Wrapper<cl_type>& rhs)
+    {
+        if (this != &rhs) {
+            if (object_ != NULL) { detail::errHandler(release(), __RELEASE_ERR); }
+            object_ = rhs.object_;
+            referenceCountable_ = rhs.referenceCountable_;
+            if (object_ != NULL) { detail::errHandler(retain(), __RETAIN_ERR); }
+        }
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    Wrapper<cl_type>& operator = (Wrapper<cl_type>&& rhs)
+    {
+        if (this != &rhs) {
+            if (object_ != NULL) { detail::errHandler(release(), __RELEASE_ERR); }
+            object_ = rhs.object_;
+            referenceCountable_ = rhs.referenceCountable_;
+            rhs.object_ = NULL;
+            rhs.referenceCountable_ = false;
+        }
+        return *this;
+    }
+#endif
+
+    Wrapper<cl_type>& operator = (const cl_type &rhs)
+    {
+        if (object_ != NULL) { detail::errHandler(release(), __RELEASE_ERR); }
+        object_ = rhs;
+        referenceCountable_ = isReferenceCountable(object_); 
+        return *this;
+    }
+
+    cl_type operator ()() const { return object_; }
+
+    cl_type& operator ()() { return object_; }
+
+protected:
+    template<typename Func, typename U>
+    friend inline cl_int getInfoHelper(Func, cl_uint, U*, int, typename U::cl_type);
+
+    template<typename Func, typename U>
+    friend inline cl_int getInfoHelper(Func, cl_uint, VECTOR_CLASS<U>*, int, typename U::cl_type);
+
+    cl_int retain() const
+    {
+        if( referenceCountable_ ) {
+            return ReferenceHandler<cl_type>::retain(object_);
+        }
+        else {
+            return CL_SUCCESS;
+        }
+    }
+
+    cl_int release() const
+    {
+        if( referenceCountable_ ) {
+            return ReferenceHandler<cl_type>::release(object_);
+        }
+        else {
+            return CL_SUCCESS;
+        }
+    }
+};
+
+} // namespace detail
+//! \endcond
+
+/*! \stuct ImageFormat
+ *  \brief Adds constructors and member functions for cl_image_format.
+ *
+ *  \see cl_image_format
+ */
+struct ImageFormat : public cl_image_format
+{
+    //! \brief Default constructor - performs no initialization.
+    ImageFormat(){}
+
+    //! \brief Initializing constructor.
+    ImageFormat(cl_channel_order order, cl_channel_type type)
+    {
+        image_channel_order = order;
+        image_channel_data_type = type;
+    }
+
+    //! \brief Assignment operator.
+    ImageFormat& operator = (const ImageFormat& rhs)
+    {
+        if (this != &rhs) {
+            this->image_channel_data_type = rhs.image_channel_data_type;
+            this->image_channel_order     = rhs.image_channel_order;
+        }
+        return *this;
+    }
+};
+
+/*! \brief Class interface for cl_device_id.
+ *
+ *  \note Copies of these objects are inexpensive, since they don't 'own'
+ *        any underlying resources or data structures.
+ *
+ *  \see cl_device_id
+ */
+class Device : public detail::Wrapper<cl_device_id>
+{
+public:
+    //! \brief Default constructor - initializes to NULL.
+    Device() : detail::Wrapper<cl_type>() { }
+
+    /*! \brief Constructor from cl_device_id.
+     * 
+     *  This simply copies the device ID value, which is an inexpensive operation.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS Device(const cl_device_id &device) : detail::Wrapper<cl_type>(device) { }
+
+    /*! \brief Returns the first device on the default context.
+     *
+     *  \see Context::getDefault()
+     */
+    static Device getDefault(cl_int * err = NULL);
+
+    /*! \brief Assignment operator from cl_device_id.
+     * 
+     *  This simply copies the device ID value, which is an inexpensive operation.
+     */
+    Device& operator = (const cl_device_id& rhs)
+    {
+        detail::Wrapper<cl_type>::operator=(rhs);
+        return *this;
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Device(const Device& dev) : detail::Wrapper<cl_type>(dev) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Device& operator = (const Device &dev)
+    {
+        detail::Wrapper<cl_type>::operator=(dev);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Device(Device&& dev) CL_HPP_NOEXCEPT : detail::Wrapper<cl_type>(std::move(dev)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Device& operator = (Device &&dev)
+    {
+        detail::Wrapper<cl_type>::operator=(std::move(dev));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+
+    //! \brief Wrapper for clGetDeviceInfo().
+    template <typename T>
+    cl_int getInfo(cl_device_info name, T* param) const
+    {
+        return detail::errHandler(
+            detail::getInfo(&::clGetDeviceInfo, object_, name, param),
+            __GET_DEVICE_INFO_ERR);
+    }
+
+    //! \brief Wrapper for clGetDeviceInfo() that returns by value.
+    template <cl_int name> typename
+    detail::param_traits<detail::cl_device_info, name>::param_type
+    getInfo(cl_int* err = NULL) const
+    {
+        typename detail::param_traits<
+            detail::cl_device_info, name>::param_type param;
+        cl_int result = getInfo(name, &param);
+        if (err != NULL) {
+            *err = result;
+        }
+        return param;
+    }
+
+    /**
+     * CL 1.2 version
+     */
+#if defined(CL_VERSION_1_2)
+    //! \brief Wrapper for clCreateSubDevicesEXT().
+    cl_int createSubDevices(
+        const cl_device_partition_property * properties,
+        VECTOR_CLASS<Device>* devices)
+    {
+        cl_uint n = 0;
+        cl_int err = clCreateSubDevices(object_, properties, 0, NULL, &n);
+        if (err != CL_SUCCESS) {
+            return detail::errHandler(err, __CREATE_SUB_DEVICES);
+        }
+
+        cl_device_id* ids = (cl_device_id*) alloca(n * sizeof(cl_device_id));
+        err = clCreateSubDevices(object_, properties, n, ids, NULL);
+        if (err != CL_SUCCESS) {
+            return detail::errHandler(err, __CREATE_SUB_DEVICES);
+        }
+
+        devices->assign(&ids[0], &ids[n]);
+        return CL_SUCCESS;
+    }
+#endif // #if defined(CL_VERSION_1_2)
+
+/**
+ * CL 1.1 version that uses device fission.
+ */
+#if defined(CL_VERSION_1_1)
+#if defined(USE_CL_DEVICE_FISSION)
+    cl_int createSubDevices(
+        const cl_device_partition_property_ext * properties,
+        VECTOR_CLASS<Device>* devices)
+    {
+        typedef CL_API_ENTRY cl_int 
+            ( CL_API_CALL * PFN_clCreateSubDevicesEXT)(
+                cl_device_id /*in_device*/,
+                const cl_device_partition_property_ext * /* properties */,
+                cl_uint /*num_entries*/,
+                cl_device_id * /*out_devices*/,
+                cl_uint * /*num_devices*/ ) CL_EXT_SUFFIX__VERSION_1_1;
+
+        static PFN_clCreateSubDevicesEXT pfn_clCreateSubDevicesEXT = NULL;
+        __INIT_CL_EXT_FCN_PTR(clCreateSubDevicesEXT);
+
+        cl_uint n = 0;
+        cl_int err = pfn_clCreateSubDevicesEXT(object_, properties, 0, NULL, &n);
+        if (err != CL_SUCCESS) {
+            return detail::errHandler(err, __CREATE_SUB_DEVICES);
+        }
+
+        cl_device_id* ids = (cl_device_id*) alloca(n * sizeof(cl_device_id));
+        err = pfn_clCreateSubDevicesEXT(object_, properties, n, ids, NULL);
+        if (err != CL_SUCCESS) {
+            return detail::errHandler(err, __CREATE_SUB_DEVICES);
+        }
+
+        devices->assign(&ids[0], &ids[n]);
+        return CL_SUCCESS;
+    }
+#endif // #if defined(USE_CL_DEVICE_FISSION)
+#endif // #if defined(CL_VERSION_1_1)
+};
+
+/*! \brief Class interface for cl_platform_id.
+ *
+ *  \note Copies of these objects are inexpensive, since they don't 'own'
+ *        any underlying resources or data structures.
+ *
+ *  \see cl_platform_id
+ */
+class Platform : public detail::Wrapper<cl_platform_id>
+{
+public:
+    //! \brief Default constructor - initializes to NULL.
+    Platform() : detail::Wrapper<cl_type>()  { }
+
+    /*! \brief Constructor from cl_platform_id.
+     * 
+     *  This simply copies the platform ID value, which is an inexpensive operation.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS Platform(const cl_platform_id &platform) : detail::Wrapper<cl_type>(platform) { }
+
+    /*! \brief Assignment operator from cl_platform_id.
+     * 
+     *  This simply copies the platform ID value, which is an inexpensive operation.
+     */
+    Platform& operator = (const cl_platform_id& rhs)
+    {
+        detail::Wrapper<cl_type>::operator=(rhs);
+        return *this;
+    }
+
+    //! \brief Wrapper for clGetPlatformInfo().
+    cl_int getInfo(cl_platform_info name, STRING_CLASS* param) const
+    {
+        return detail::errHandler(
+            detail::getInfo(&::clGetPlatformInfo, object_, name, param),
+            __GET_PLATFORM_INFO_ERR);
+    }
+
+    //! \brief Wrapper for clGetPlatformInfo() that returns by value.
+    template <cl_int name> typename
+    detail::param_traits<detail::cl_platform_info, name>::param_type
+    getInfo(cl_int* err = NULL) const
+    {
+        typename detail::param_traits<
+            detail::cl_platform_info, name>::param_type param;
+        cl_int result = getInfo(name, &param);
+        if (err != NULL) {
+            *err = result;
+        }
+        return param;
+    }
+
+    /*! \brief Gets a list of devices for this platform.
+     * 
+     *  Wraps clGetDeviceIDs().
+     */
+    cl_int getDevices(
+        cl_device_type type,
+        VECTOR_CLASS<Device>* devices) const
+    {
+        cl_uint n = 0;
+        if( devices == NULL ) {
+            return detail::errHandler(CL_INVALID_ARG_VALUE, __GET_DEVICE_IDS_ERR);
+        }
+        cl_int err = ::clGetDeviceIDs(object_, type, 0, NULL, &n);
+        if (err != CL_SUCCESS) {
+            return detail::errHandler(err, __GET_DEVICE_IDS_ERR);
+        }
+
+        cl_device_id* ids = (cl_device_id*) alloca(n * sizeof(cl_device_id));
+        err = ::clGetDeviceIDs(object_, type, n, ids, NULL);
+        if (err != CL_SUCCESS) {
+            return detail::errHandler(err, __GET_DEVICE_IDS_ERR);
+        }
+
+        devices->assign(&ids[0], &ids[n]);
+        return CL_SUCCESS;
+    }
+
+#if defined(USE_DX_INTEROP)
+   /*! \brief Get the list of available D3D10 devices.
+     *
+     *  \param d3d_device_source.
+     *
+     *  \param d3d_object.
+     *
+     *  \param d3d_device_set.
+     *
+     *  \param devices returns a vector of OpenCL D3D10 devices found. The cl::Device
+     *  values returned in devices can be used to identify a specific OpenCL
+     *  device. If \a devices argument is NULL, this argument is ignored.
+     *
+     *  \return One of the following values:
+     *    - CL_SUCCESS if the function is executed successfully.
+     *
+     *  The application can query specific capabilities of the OpenCL device(s)
+     *  returned by cl::getDevices. This can be used by the application to
+     *  determine which device(s) to use.
+     *
+     * \note In the case that exceptions are enabled and a return value
+     * other than CL_SUCCESS is generated, then cl::Error exception is
+     * generated.
+     */
+    cl_int getDevices(
+        cl_d3d10_device_source_khr d3d_device_source,
+        void *                     d3d_object,
+        cl_d3d10_device_set_khr    d3d_device_set,
+        VECTOR_CLASS<Device>* devices) const
+    {
+        typedef CL_API_ENTRY cl_int (CL_API_CALL *PFN_clGetDeviceIDsFromD3D10KHR)(
+            cl_platform_id platform, 
+            cl_d3d10_device_source_khr d3d_device_source, 
+            void * d3d_object,
+            cl_d3d10_device_set_khr d3d_device_set,
+            cl_uint num_entries,
+            cl_device_id * devices,
+            cl_uint* num_devices);
+
+        if( devices == NULL ) {
+            return detail::errHandler(CL_INVALID_ARG_VALUE, __GET_DEVICE_IDS_ERR);
+        }
+
+        static PFN_clGetDeviceIDsFromD3D10KHR pfn_clGetDeviceIDsFromD3D10KHR = NULL;
+        __INIT_CL_EXT_FCN_PTR_PLATFORM(object_, clGetDeviceIDsFromD3D10KHR);
+
+        cl_uint n = 0;
+        cl_int err = pfn_clGetDeviceIDsFromD3D10KHR(
+            object_, 
+            d3d_device_source, 
+            d3d_object,
+            d3d_device_set, 
+            0, 
+            NULL, 
+            &n);
+        if (err != CL_SUCCESS) {
+            return detail::errHandler(err, __GET_DEVICE_IDS_ERR);
+        }
+
+        cl_device_id* ids = (cl_device_id*) alloca(n * sizeof(cl_device_id));
+        err = pfn_clGetDeviceIDsFromD3D10KHR(
+            object_, 
+            d3d_device_source, 
+            d3d_object,
+            d3d_device_set,
+            n, 
+            ids, 
+            NULL);
+        if (err != CL_SUCCESS) {
+            return detail::errHandler(err, __GET_DEVICE_IDS_ERR);
+        }
+
+        devices->assign(&ids[0], &ids[n]);
+        return CL_SUCCESS;
+    }
+#endif
+
+    /*! \brief Gets a list of available platforms.
+     * 
+     *  Wraps clGetPlatformIDs().
+     */
+    static cl_int get(
+        VECTOR_CLASS<Platform>* platforms)
+    {
+        cl_uint n = 0;
+
+        if( platforms == NULL ) {
+            return detail::errHandler(CL_INVALID_ARG_VALUE, __GET_PLATFORM_IDS_ERR);
+        }
+
+        cl_int err = ::clGetPlatformIDs(0, NULL, &n);
+        if (err != CL_SUCCESS) {
+            return detail::errHandler(err, __GET_PLATFORM_IDS_ERR);
+        }
+
+        cl_platform_id* ids = (cl_platform_id*) alloca(
+            n * sizeof(cl_platform_id));
+        err = ::clGetPlatformIDs(n, ids, NULL);
+        if (err != CL_SUCCESS) {
+            return detail::errHandler(err, __GET_PLATFORM_IDS_ERR);
+        }
+
+        platforms->assign(&ids[0], &ids[n]);
+        return CL_SUCCESS;
+    }
+
+    /*! \brief Gets the first available platform.
+     * 
+     *  Wraps clGetPlatformIDs(), returning the first result.
+     */
+    static cl_int get(
+        Platform * platform)
+    {
+        cl_uint n = 0;
+
+        if( platform == NULL ) {
+            return detail::errHandler(CL_INVALID_ARG_VALUE, __GET_PLATFORM_IDS_ERR);
+        }
+
+        cl_int err = ::clGetPlatformIDs(0, NULL, &n);
+        if (err != CL_SUCCESS) {
+            return detail::errHandler(err, __GET_PLATFORM_IDS_ERR);
+        }
+
+        cl_platform_id* ids = (cl_platform_id*) alloca(
+            n * sizeof(cl_platform_id));
+        err = ::clGetPlatformIDs(n, ids, NULL);
+        if (err != CL_SUCCESS) {
+            return detail::errHandler(err, __GET_PLATFORM_IDS_ERR);
+        }
+
+        *platform = ids[0];
+        return CL_SUCCESS;
+    }
+
+    /*! \brief Gets the first available platform, returning it by value.
+     * 
+     *  Wraps clGetPlatformIDs(), returning the first result.
+     */
+    static Platform get(
+        cl_int * errResult = NULL)
+    {
+        Platform platform;
+        cl_uint n = 0;
+        cl_int err = ::clGetPlatformIDs(0, NULL, &n);
+        if (err != CL_SUCCESS) {
+            detail::errHandler(err, __GET_PLATFORM_IDS_ERR);
+            if (errResult != NULL) {
+                *errResult = err;
+            }
+            return Platform();
+        }
+
+        cl_platform_id* ids = (cl_platform_id*) alloca(
+            n * sizeof(cl_platform_id));
+        err = ::clGetPlatformIDs(n, ids, NULL);
+
+        if (err != CL_SUCCESS) {
+            detail::errHandler(err, __GET_PLATFORM_IDS_ERR);
+            if (errResult != NULL) {
+                *errResult = err;
+            }
+            return Platform();
+        }
+
+        
+        return Platform(ids[0]);
+    }
+
+    static Platform getDefault( 
+        cl_int *errResult = NULL )
+    {
+        return get(errResult);
+    }
+
+    
+#if defined(CL_VERSION_1_2)
+    //! \brief Wrapper for clUnloadCompiler().
+    cl_int
+    unloadCompiler()
+    {
+        return ::clUnloadPlatformCompiler(object_);
+    }
+#endif // #if defined(CL_VERSION_1_2)
+}; // class Platform
+
+/**
+ * Deprecated APIs for 1.2
+ */
+#if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS) || (defined(CL_VERSION_1_1) && !defined(CL_VERSION_1_2))
+/**
+ * Unload the OpenCL compiler.
+ * \note Deprecated for OpenCL 1.2. Use Platform::unloadCompiler instead.
+ */
+inline CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_int
+UnloadCompiler() CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED;
+inline cl_int
+UnloadCompiler()
+{
+    return ::clUnloadCompiler();
+}
+#endif // #if defined(CL_VERSION_1_1)
+
+/*! \brief Class interface for cl_context.
+ *
+ *  \note Copies of these objects are shallow, meaning that the copy will refer
+ *        to the same underlying cl_context as the original.  For details, see
+ *        clRetainContext() and clReleaseContext().
+ *
+ *  \see cl_context
+ */
+class Context 
+    : public detail::Wrapper<cl_context>
+{
+private:
+
+#ifdef CL_HPP_CPP11_ATOMICS_SUPPORTED
+    static std::atomic<int> default_initialized_;
+#else // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+    static volatile int default_initialized_;
+#endif // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+    static Context default_;
+    static volatile cl_int default_error_;
+public:
+    /*! \brief Constructs a context including a list of specified devices.
+     *
+     *  Wraps clCreateContext().
+     */
+    Context(
+        const VECTOR_CLASS<Device>& devices,
+        cl_context_properties* properties = NULL,
+        void (CL_CALLBACK * notifyFptr)(
+            const char *,
+            const void *,
+            ::size_t,
+            void *) = NULL,
+        void* data = NULL,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+
+        ::size_t numDevices = devices.size();
+        cl_device_id* deviceIDs = (cl_device_id*) alloca(numDevices * sizeof(cl_device_id));
+        for( ::size_t deviceIndex = 0; deviceIndex < numDevices; ++deviceIndex ) {
+            deviceIDs[deviceIndex] = (devices[deviceIndex])();
+        }
+
+        object_ = ::clCreateContext(
+            properties, (cl_uint) numDevices,
+            deviceIDs,
+            notifyFptr, data, &error);
+
+        detail::errHandler(error, __CREATE_CONTEXT_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    Context(
+        const Device& device,
+        cl_context_properties* properties = NULL,
+        void (CL_CALLBACK * notifyFptr)(
+            const char *,
+            const void *,
+            ::size_t,
+            void *) = NULL,
+        void* data = NULL,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+
+        cl_device_id deviceID = device();
+
+        object_ = ::clCreateContext(
+            properties, 1,
+            &deviceID,
+            notifyFptr, data, &error);
+
+        detail::errHandler(error, __CREATE_CONTEXT_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    /*! \brief Constructs a context including all or a subset of devices of a specified type.
+     *
+     *  Wraps clCreateContextFromType().
+     */
+    Context(
+        cl_device_type type,
+        cl_context_properties* properties = NULL,
+        void (CL_CALLBACK * notifyFptr)(
+            const char *,
+            const void *,
+            ::size_t,
+            void *) = NULL,
+        void* data = NULL,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+
+#if !defined(__APPLE__) && !defined(__MACOS)
+        cl_context_properties prop[4] = {CL_CONTEXT_PLATFORM, 0, 0, 0 };
+
+        if (properties == NULL) {
+            // Get a valid platform ID as we cannot send in a blank one
+            VECTOR_CLASS<Platform> platforms;
+            error = Platform::get(&platforms);
+            if (error != CL_SUCCESS) {
+                detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
+                if (err != NULL) {
+                    *err = error;
+                }
+                return;
+            }
+
+            // Check the platforms we found for a device of our specified type
+            cl_context_properties platform_id = 0;
+            for (unsigned int i = 0; i < platforms.size(); i++) {
+
+                VECTOR_CLASS<Device> devices;
+
+#if defined(__CL_ENABLE_EXCEPTIONS)
+                try {
+#endif
+
+                    error = platforms[i].getDevices(type, &devices);
+
+#if defined(__CL_ENABLE_EXCEPTIONS)
+                } catch (Error) {}
+    // Catch if exceptions are enabled as we don't want to exit if first platform has no devices of type
+    // We do error checking next anyway, and can throw there if needed
+#endif
+
+                // Only squash CL_SUCCESS and CL_DEVICE_NOT_FOUND
+                if (error != CL_SUCCESS && error != CL_DEVICE_NOT_FOUND) {
+                    detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
+                    if (err != NULL) {
+                        *err = error;
+                    }
+                }
+
+                if (devices.size() > 0) {
+                    platform_id = (cl_context_properties)platforms[i]();
+                    break;
+                }
+            }
+
+            if (platform_id == 0) {
+                detail::errHandler(CL_DEVICE_NOT_FOUND, __CREATE_CONTEXT_FROM_TYPE_ERR);
+                if (err != NULL) {
+                    *err = CL_DEVICE_NOT_FOUND;
+                }
+                return;
+            }
+
+            prop[1] = platform_id;
+            properties = &prop[0];
+        }
+#endif
+        object_ = ::clCreateContextFromType(
+            properties, type, notifyFptr, data, &error);
+
+        detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Context(const Context& ctx) : detail::Wrapper<cl_type>(ctx) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Context& operator = (const Context &ctx)
+    {
+        detail::Wrapper<cl_type>::operator=(ctx);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Context(Context&& ctx) CL_HPP_NOEXCEPT : detail::Wrapper<cl_type>(std::move(ctx)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Context& operator = (Context &&ctx)
+    {
+        detail::Wrapper<cl_type>::operator=(std::move(ctx));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+
+    /*! \brief Returns a singleton context including all devices of CL_DEVICE_TYPE_DEFAULT.
+     *
+     *  \note All calls to this function return the same cl_context as the first.
+     */
+    static Context getDefault(cl_int * err = NULL) 
+    {
+        int state = detail::compare_exchange(
+            &default_initialized_, 
+            __DEFAULT_BEING_INITIALIZED, __DEFAULT_NOT_INITIALIZED);
+        
+        if (state & __DEFAULT_INITIALIZED) {
+            if (err != NULL) {
+                *err = default_error_;
+            }
+            return default_;
+        }
+
+        if (state & __DEFAULT_BEING_INITIALIZED) {
+              // Assume writes will propagate eventually...
+              while(default_initialized_ != __DEFAULT_INITIALIZED) {
+                  detail::fence();
+              }
+
+            if (err != NULL) {
+                *err = default_error_;
+            }
+            return default_;
+        }
+
+        cl_int error;
+        default_ = Context(
+            CL_DEVICE_TYPE_DEFAULT,
+            NULL,
+            NULL,
+            NULL,
+            &error);
+
+        detail::fence();
+
+        default_error_ = error;
+        // Assume writes will propagate eventually...
+        default_initialized_ = __DEFAULT_INITIALIZED;
+
+        detail::fence();
+
+        if (err != NULL) {
+            *err = default_error_;
+        }
+        return default_;
+
+    }
+
+    //! \brief Default constructor - initializes to NULL.
+    Context() : detail::Wrapper<cl_type>() { }
+
+    /*! \brief Constructor from cl_context - takes ownership.
+     * 
+     *  This effectively transfers ownership of a refcount on the cl_context
+     *  into the new Context object.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS Context(const cl_context& context) : detail::Wrapper<cl_type>(context) { }
+
+    /*! \brief Assignment operator from cl_context - takes ownership.
+     * 
+     *  This effectively transfers ownership of a refcount on the rhs and calls
+     *  clReleaseContext() on the value previously held by this instance.
+     */
+    Context& operator = (const cl_context& rhs)
+    {
+        detail::Wrapper<cl_type>::operator=(rhs);
+        return *this;
+    }
+
+    //! \brief Wrapper for clGetContextInfo().
+    template <typename T>
+    cl_int getInfo(cl_context_info name, T* param) const
+    {
+        return detail::errHandler(
+            detail::getInfo(&::clGetContextInfo, object_, name, param),
+            __GET_CONTEXT_INFO_ERR);
+    }
+
+    //! \brief Wrapper for clGetContextInfo() that returns by value.
+    template <cl_int name> typename
+    detail::param_traits<detail::cl_context_info, name>::param_type
+    getInfo(cl_int* err = NULL) const
+    {
+        typename detail::param_traits<
+            detail::cl_context_info, name>::param_type param;
+        cl_int result = getInfo(name, &param);
+        if (err != NULL) {
+            *err = result;
+        }
+        return param;
+    }
+
+    /*! \brief Gets a list of supported image formats.
+     *  
+     *  Wraps clGetSupportedImageFormats().
+     */
+    cl_int getSupportedImageFormats(
+        cl_mem_flags flags,
+        cl_mem_object_type type,
+        VECTOR_CLASS<ImageFormat>* formats) const
+    {
+        cl_uint numEntries;
+
+        if (!formats) {
+            return CL_SUCCESS;
+        }
+
+        cl_int err = ::clGetSupportedImageFormats(
+            object_,
+            flags,
+            type,
+            0,
+            NULL,
+            &numEntries);
+        if (err != CL_SUCCESS) {
+            return detail::errHandler(err, __GET_SUPPORTED_IMAGE_FORMATS_ERR);
+        }
+
+        if (numEntries > 0) {
+            ImageFormat* value = (ImageFormat*)
+                alloca(numEntries * sizeof(ImageFormat));
+            err = ::clGetSupportedImageFormats(
+                object_,
+                flags,
+                type,
+                numEntries,
+                (cl_image_format*)value,
+                NULL);
+            if (err != CL_SUCCESS) {
+                return detail::errHandler(err, __GET_SUPPORTED_IMAGE_FORMATS_ERR);
+            }
+
+            formats->assign(&value[0], &value[numEntries]);
+        }
+        else {
+            formats->clear();
+        }
+        return CL_SUCCESS;
+    }
+};
+
+inline Device Device::getDefault(cl_int * err)
+{
+    cl_int error;
+    Device device;
+
+    Context context = Context::getDefault(&error);
+    detail::errHandler(error, __CREATE_CONTEXT_ERR);
+
+    if (error != CL_SUCCESS) {
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+    else {
+        device = context.getInfo<CL_CONTEXT_DEVICES>()[0];
+        if (err != NULL) {
+            *err = CL_SUCCESS;
+        }
+    }
+
+    return device;
+}
+
+
+#ifdef _WIN32
+#ifdef CL_HPP_CPP11_ATOMICS_SUPPORTED
+__declspec(selectany) std::atomic<int> Context::default_initialized_;
+#else // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+__declspec(selectany) volatile int Context::default_initialized_ = __DEFAULT_NOT_INITIALIZED;
+#endif // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+__declspec(selectany) Context Context::default_;
+__declspec(selectany) volatile cl_int Context::default_error_ = CL_SUCCESS;
+#else // !_WIN32
+#ifdef CL_HPP_CPP11_ATOMICS_SUPPORTED
+__attribute__((weak)) std::atomic<int> Context::default_initialized_;
+#else // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+__attribute__((weak)) volatile int Context::default_initialized_ = __DEFAULT_NOT_INITIALIZED;
+#endif // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+__attribute__((weak)) Context Context::default_;
+__attribute__((weak)) volatile cl_int Context::default_error_ = CL_SUCCESS;
+#endif // !_WIN32
+
+/*! \brief Class interface for cl_event.
+ *
+ *  \note Copies of these objects are shallow, meaning that the copy will refer
+ *        to the same underlying cl_event as the original.  For details, see
+ *        clRetainEvent() and clReleaseEvent().
+ *
+ *  \see cl_event
+ */
+class Event : public detail::Wrapper<cl_event>
+{
+public:
+    //! \brief Default constructor - initializes to NULL.
+    Event() : detail::Wrapper<cl_type>() { }
+
+    /*! \brief Constructor from cl_event - takes ownership.
+     * 
+     *  This effectively transfers ownership of a refcount on the cl_event
+     *  into the new Event object.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS Event(const cl_event& event) : detail::Wrapper<cl_type>(event) { }
+
+    /*! \brief Assignment operator from cl_event - takes ownership.
+     *
+     *  This effectively transfers ownership of a refcount on the rhs and calls
+     *  clReleaseEvent() on the value previously held by this instance.
+     */
+    Event& operator = (const cl_event& rhs)
+    {
+        detail::Wrapper<cl_type>::operator=(rhs);
+        return *this;
+    }
+
+    //! \brief Wrapper for clGetEventInfo().
+    template <typename T>
+    cl_int getInfo(cl_event_info name, T* param) const
+    {
+        return detail::errHandler(
+            detail::getInfo(&::clGetEventInfo, object_, name, param),
+            __GET_EVENT_INFO_ERR);
+    }
+
+    //! \brief Wrapper for clGetEventInfo() that returns by value.
+    template <cl_int name> typename
+    detail::param_traits<detail::cl_event_info, name>::param_type
+    getInfo(cl_int* err = NULL) const
+    {
+        typename detail::param_traits<
+            detail::cl_event_info, name>::param_type param;
+        cl_int result = getInfo(name, &param);
+        if (err != NULL) {
+            *err = result;
+        }
+        return param;
+    }
+
+    //! \brief Wrapper for clGetEventProfilingInfo().
+    template <typename T>
+    cl_int getProfilingInfo(cl_profiling_info name, T* param) const
+    {
+        return detail::errHandler(detail::getInfo(
+            &::clGetEventProfilingInfo, object_, name, param),
+            __GET_EVENT_PROFILE_INFO_ERR);
+    }
+
+    //! \brief Wrapper for clGetEventProfilingInfo() that returns by value.
+    template <cl_int name> typename
+    detail::param_traits<detail::cl_profiling_info, name>::param_type
+    getProfilingInfo(cl_int* err = NULL) const
+    {
+        typename detail::param_traits<
+            detail::cl_profiling_info, name>::param_type param;
+        cl_int result = getProfilingInfo(name, &param);
+        if (err != NULL) {
+            *err = result;
+        }
+        return param;
+    }
+
+    /*! \brief Blocks the calling thread until this event completes.
+     * 
+     *  Wraps clWaitForEvents().
+     */
+    cl_int wait() const
+    {
+        return detail::errHandler(
+            ::clWaitForEvents(1, &object_),
+            __WAIT_FOR_EVENTS_ERR);
+    }
+
+#if defined(CL_VERSION_1_1)
+    /*! \brief Registers a user callback function for a specific command execution status.
+     *
+     *  Wraps clSetEventCallback().
+     */
+    cl_int setCallback(
+        cl_int type,
+        void (CL_CALLBACK * pfn_notify)(cl_event, cl_int, void *),		
+        void * user_data = NULL)
+    {
+        return detail::errHandler(
+            ::clSetEventCallback(
+                object_,
+                type,
+                pfn_notify,
+                user_data), 
+            __SET_EVENT_CALLBACK_ERR);
+    }
+#endif
+
+    /*! \brief Blocks the calling thread until every event specified is complete.
+     * 
+     *  Wraps clWaitForEvents().
+     */
+    static cl_int
+    waitForEvents(const VECTOR_CLASS<Event>& events)
+    {
+        return detail::errHandler(
+            ::clWaitForEvents(
+                (cl_uint) events.size(), (events.size() > 0) ? (cl_event*)&events.front() : NULL),
+            __WAIT_FOR_EVENTS_ERR);
+    }
+};
+
+#if defined(CL_VERSION_1_1)
+/*! \brief Class interface for user events (a subset of cl_event's).
+ * 
+ *  See Event for details about copy semantics, etc.
+ */
+class UserEvent : public Event
+{
+public:
+    /*! \brief Constructs a user event on a given context.
+     *
+     *  Wraps clCreateUserEvent().
+     */
+    UserEvent(
+        const Context& context,
+        cl_int * err = NULL)
+    {
+        cl_int error;
+        object_ = ::clCreateUserEvent(
+            context(),
+            &error);
+
+        detail::errHandler(error, __CREATE_USER_EVENT_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    //! \brief Default constructor - initializes to NULL.
+    UserEvent() : Event() { }
+
+    /*! \brief Sets the execution status of a user event object.
+     *
+     *  Wraps clSetUserEventStatus().
+     */
+    cl_int setStatus(cl_int status)
+    {
+        return detail::errHandler(
+            ::clSetUserEventStatus(object_,status), 
+            __SET_USER_EVENT_STATUS_ERR);
+    }
+};
+#endif
+
+/*! \brief Blocks the calling thread until every event specified is complete.
+ * 
+ *  Wraps clWaitForEvents().
+ */
+inline static cl_int
+WaitForEvents(const VECTOR_CLASS<Event>& events)
+{
+    return detail::errHandler(
+        ::clWaitForEvents(
+            (cl_uint) events.size(), (events.size() > 0) ? (cl_event*)&events.front() : NULL),
+        __WAIT_FOR_EVENTS_ERR);
+}
+
+/*! \brief Class interface for cl_mem.
+ *
+ *  \note Copies of these objects are shallow, meaning that the copy will refer
+ *        to the same underlying cl_mem as the original.  For details, see
+ *        clRetainMemObject() and clReleaseMemObject().
+ *
+ *  \see cl_mem
+ */
+class Memory : public detail::Wrapper<cl_mem>
+{
+public:
+    //! \brief Default constructor - initializes to NULL.
+    Memory() : detail::Wrapper<cl_type>() { }
+
+    /*! \brief Constructor from cl_mem - takes ownership.
+     * 
+     *  This effectively transfers ownership of a refcount on the cl_mem
+     *  into the new Memory object.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS Memory(const cl_mem& memory) : detail::Wrapper<cl_type>(memory) { }
+
+    /*! \brief Assignment operator from cl_mem - takes ownership.
+     *
+     *  This effectively transfers ownership of a refcount on the rhs and calls
+     *  clReleaseMemObject() on the value previously held by this instance.
+     */
+    Memory& operator = (const cl_mem& rhs)
+    {
+        detail::Wrapper<cl_type>::operator=(rhs);
+        return *this;
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Memory(const Memory& mem) : detail::Wrapper<cl_type>(mem) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Memory& operator = (const Memory &mem)
+    {
+        detail::Wrapper<cl_type>::operator=(mem);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Memory(Memory&& mem) CL_HPP_NOEXCEPT : detail::Wrapper<cl_type>(std::move(mem)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Memory& operator = (Memory &&mem)
+    {
+        detail::Wrapper<cl_type>::operator=(std::move(mem));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+
+    //! \brief Wrapper for clGetMemObjectInfo().
+    template <typename T>
+    cl_int getInfo(cl_mem_info name, T* param) const
+    {
+        return detail::errHandler(
+            detail::getInfo(&::clGetMemObjectInfo, object_, name, param),
+            __GET_MEM_OBJECT_INFO_ERR);
+    }
+
+    //! \brief Wrapper for clGetMemObjectInfo() that returns by value.
+    template <cl_int name> typename
+    detail::param_traits<detail::cl_mem_info, name>::param_type
+    getInfo(cl_int* err = NULL) const
+    {
+        typename detail::param_traits<
+            detail::cl_mem_info, name>::param_type param;
+        cl_int result = getInfo(name, &param);
+        if (err != NULL) {
+            *err = result;
+        }
+        return param;
+    }
+
+#if defined(CL_VERSION_1_1)
+    /*! \brief Registers a callback function to be called when the memory object
+     *         is no longer needed.
+     *
+     *  Wraps clSetMemObjectDestructorCallback().
+     *
+     *  Repeated calls to this function, for a given cl_mem value, will append
+     *  to the list of functions called (in reverse order) when memory object's
+     *  resources are freed and the memory object is deleted.
+     *
+     *  \note
+     *  The registered callbacks are associated with the underlying cl_mem
+     *  value - not the Memory class instance.
+     */
+    cl_int setDestructorCallback(
+        void (CL_CALLBACK * pfn_notify)(cl_mem, void *),		
+        void * user_data = NULL)
+    {
+        return detail::errHandler(
+            ::clSetMemObjectDestructorCallback(
+                object_,
+                pfn_notify,
+                user_data), 
+            __SET_MEM_OBJECT_DESTRUCTOR_CALLBACK_ERR);
+    }
+#endif
+
+};
+
+// Pre-declare copy functions
+class Buffer;
+template< typename IteratorType >
+cl_int copy( IteratorType startIterator, IteratorType endIterator, cl::Buffer &buffer );
+template< typename IteratorType >
+cl_int copy( const cl::Buffer &buffer, IteratorType startIterator, IteratorType endIterator );
+template< typename IteratorType >
+cl_int copy( const CommandQueue &queue, IteratorType startIterator, IteratorType endIterator, cl::Buffer &buffer );
+template< typename IteratorType >
+cl_int copy( const CommandQueue &queue, const cl::Buffer &buffer, IteratorType startIterator, IteratorType endIterator );
+
+
+/*! \brief Class interface for Buffer Memory Objects.
+ * 
+ *  See Memory for details about copy semantics, etc.
+ *
+ *  \see Memory
+ */
+class Buffer : public Memory
+{
+public:
+
+    /*! \brief Constructs a Buffer in a specified context.
+     *
+     *  Wraps clCreateBuffer().
+     *
+     *  \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was
+     *                  specified.  Note alignment & exclusivity requirements.
+     */
+    Buffer(
+        const Context& context,
+        cl_mem_flags flags,
+        ::size_t size,
+        void* host_ptr = NULL,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+        object_ = ::clCreateBuffer(context(), flags, size, host_ptr, &error);
+
+        detail::errHandler(error, __CREATE_BUFFER_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    /*! \brief Constructs a Buffer in the default context.
+     *
+     *  Wraps clCreateBuffer().
+     *
+     *  \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was
+     *                  specified.  Note alignment & exclusivity requirements.
+     *
+     *  \see Context::getDefault()
+     */
+    Buffer(
+         cl_mem_flags flags,
+        ::size_t size,
+        void* host_ptr = NULL,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+
+        Context context = Context::getDefault(err);
+
+        object_ = ::clCreateBuffer(context(), flags, size, host_ptr, &error);
+
+        detail::errHandler(error, __CREATE_BUFFER_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    /*!
+     * \brief Construct a Buffer from a host container via iterators.
+     * IteratorType must be random access.
+     * If useHostPtr is specified iterators must represent contiguous data.
+     */
+    template< typename IteratorType >
+    Buffer(
+        IteratorType startIterator,
+        IteratorType endIterator,
+        bool readOnly,
+        bool useHostPtr = false,
+        cl_int* err = NULL)
+    {
+        typedef typename std::iterator_traits<IteratorType>::value_type DataType;
+        cl_int error;
+
+        cl_mem_flags flags = 0;
+        if( readOnly ) {
+            flags |= CL_MEM_READ_ONLY;
+        }
+        else {
+            flags |= CL_MEM_READ_WRITE;
+        }
+        if( useHostPtr ) {
+            flags |= CL_MEM_USE_HOST_PTR;
+        }
+        
+        ::size_t size = sizeof(DataType)*(endIterator - startIterator);
+
+        Context context = Context::getDefault(err);
+
+        if( useHostPtr ) {
+            object_ = ::clCreateBuffer(context(), flags, size, static_cast<DataType*>(&*startIterator), &error);
+        } else {
+            object_ = ::clCreateBuffer(context(), flags, size, 0, &error);
+        }
+
+        detail::errHandler(error, __CREATE_BUFFER_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+
+        if( !useHostPtr ) {
+            error = cl::copy(startIterator, endIterator, *this);
+            detail::errHandler(error, __CREATE_BUFFER_ERR);
+            if (err != NULL) {
+                *err = error;
+            }
+        }
+    }
+
+    /*!
+     * \brief Construct a Buffer from a host container via iterators using a specified context.
+     * IteratorType must be random access.
+     * If useHostPtr is specified iterators must represent contiguous data.
+     */
+    template< typename IteratorType >
+    Buffer(const Context &context, IteratorType startIterator, IteratorType endIterator,
+        bool readOnly, bool useHostPtr = false, cl_int* err = NULL);
+
+    /*!
+    * \brief Construct a Buffer from a host container via iterators using a specified queue.
+    * If useHostPtr is specified iterators must represent contiguous data.
+    */
+    template< typename IteratorType >
+    Buffer(const CommandQueue &queue, IteratorType startIterator, IteratorType endIterator,
+        bool readOnly, bool useHostPtr = false, cl_int* err = NULL);
+
+    //! \brief Default constructor - initializes to NULL.
+    Buffer() : Memory() { }
+
+    /*! \brief Constructor from cl_mem - takes ownership.
+     *
+     *  See Memory for further details.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS Buffer(const cl_mem& buffer) : Memory(buffer) { }
+
+    /*! \brief Assignment from cl_mem - performs shallow copy.
+     *
+     *  See Memory for further details.
+     */
+    Buffer& operator = (const cl_mem& rhs)
+    {
+        Memory::operator=(rhs);
+        return *this;
+    }
+    
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Buffer(const Buffer& buf) : Memory(buf) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Buffer& operator = (const Buffer &buf)
+    {
+        Memory::operator=(buf);
+        return *this;
+    }
+    
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Buffer(Buffer&& buf) CL_HPP_NOEXCEPT : Memory(std::move(buf)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Buffer& operator = (Buffer &&buf)
+    {
+        Memory::operator=(std::move(buf));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+
+#if defined(CL_VERSION_1_1)
+    /*! \brief Creates a new buffer object from this.
+     *
+     *  Wraps clCreateSubBuffer().
+     */
+    Buffer createSubBuffer(
+        cl_mem_flags flags,
+        cl_buffer_create_type buffer_create_type,
+        const void * buffer_create_info,
+        cl_int * err = NULL)
+    {
+        Buffer result;
+        cl_int error;
+        result.object_ = ::clCreateSubBuffer(
+            object_, 
+            flags, 
+            buffer_create_type, 
+            buffer_create_info, 
+            &error);
+
+        detail::errHandler(error, __CREATE_SUBBUFFER_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+
+        return result;
+    }		
+#endif
+};
+
+#if defined (USE_DX_INTEROP)
+/*! \brief Class interface for creating OpenCL buffers from ID3D10Buffer's.
+ *
+ *  This is provided to facilitate interoperability with Direct3D.
+ * 
+ *  See Memory for details about copy semantics, etc.
+ *
+ *  \see Memory
+ */
+class BufferD3D10 : public Buffer
+{
+public:
+    typedef CL_API_ENTRY cl_mem (CL_API_CALL *PFN_clCreateFromD3D10BufferKHR)(
+    cl_context context, cl_mem_flags flags, ID3D10Buffer*  buffer,
+    cl_int* errcode_ret);
+
+    /*! \brief Constructs a BufferD3D10, in a specified context, from a
+     *         given ID3D10Buffer.
+     *
+     *  Wraps clCreateFromD3D10BufferKHR().
+     */
+    BufferD3D10(
+        const Context& context,
+        cl_mem_flags flags,
+        ID3D10Buffer* bufobj,
+        cl_int * err = NULL)
+    {
+        static PFN_clCreateFromD3D10BufferKHR pfn_clCreateFromD3D10BufferKHR = NULL;
+
+#if defined(CL_VERSION_1_2)
+        vector<cl_context_properties> props = context.getInfo<CL_CONTEXT_PROPERTIES>();
+        cl_platform platform = -1;
+        for( int i = 0; i < props.size(); ++i ) {
+            if( props[i] == CL_CONTEXT_PLATFORM ) {
+                platform = props[i+1];
+            }
+        }
+        __INIT_CL_EXT_FCN_PTR_PLATFORM(platform, clCreateFromD3D10BufferKHR);
+#endif
+#if defined(CL_VERSION_1_1)
+        __INIT_CL_EXT_FCN_PTR(clCreateFromD3D10BufferKHR);
+#endif
+
+        cl_int error;
+        object_ = pfn_clCreateFromD3D10BufferKHR(
+            context(),
+            flags,
+            bufobj,
+            &error);
+
+        detail::errHandler(error, __CREATE_GL_BUFFER_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    //! \brief Default constructor - initializes to NULL.
+    BufferD3D10() : Buffer() { }
+
+    /*! \brief Constructor from cl_mem - takes ownership.
+     *
+     *  See Memory for further details.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS BufferD3D10(const cl_mem& buffer) : Buffer(buffer) { }
+
+    /*! \brief Assignment from cl_mem - performs shallow copy.
+     *
+     *  See Memory for further details.
+     */
+    BufferD3D10& operator = (const cl_mem& rhs)
+    {
+        Buffer::operator=(rhs);
+        return *this;
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+    * Required for MSVC.
+    */
+    BufferD3D10(const BufferD3D10& buf) : Buffer(buf) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+    * Required for MSVC.
+    */
+    BufferD3D10& operator = (const BufferD3D10 &buf)
+    {
+        Buffer::operator=(buf);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+    * Required for MSVC.
+    */
+    BufferD3D10(BufferD3D10&& buf) CL_HPP_NOEXCEPT : Buffer(std::move(buf)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+    * Required for MSVC.
+    */
+    BufferD3D10& operator = (BufferD3D10 &&buf)
+    {
+        Buffer::operator=(std::move(buf));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+};
+#endif
+
+/*! \brief Class interface for GL Buffer Memory Objects.
+ *
+ *  This is provided to facilitate interoperability with OpenGL.
+ * 
+ *  See Memory for details about copy semantics, etc.
+ * 
+ *  \see Memory
+ */
+class BufferGL : public Buffer
+{
+public:
+    /*! \brief Constructs a BufferGL in a specified context, from a given
+     *         GL buffer.
+     *
+     *  Wraps clCreateFromGLBuffer().
+     */
+    BufferGL(
+        const Context& context,
+        cl_mem_flags flags,
+        cl_GLuint bufobj,
+        cl_int * err = NULL)
+    {
+        cl_int error;
+        object_ = ::clCreateFromGLBuffer(
+            context(),
+            flags,
+            bufobj,
+            &error);
+
+        detail::errHandler(error, __CREATE_GL_BUFFER_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    //! \brief Default constructor - initializes to NULL.
+    BufferGL() : Buffer() { }
+
+    /*! \brief Constructor from cl_mem - takes ownership.
+     *
+     *  See Memory for further details.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS BufferGL(const cl_mem& buffer) : Buffer(buffer) { }
+
+    /*! \brief Assignment from cl_mem - performs shallow copy.
+     *
+     *  See Memory for further details.
+     */
+    BufferGL& operator = (const cl_mem& rhs)
+    {
+        Buffer::operator=(rhs);
+        return *this;
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+    * Required for MSVC.
+    */
+    BufferGL(const BufferGL& buf) : Buffer(buf) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+    * Required for MSVC.
+    */
+    BufferGL& operator = (const BufferGL &buf)
+    {
+        Buffer::operator=(buf);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+    * Required for MSVC.
+    */
+    BufferGL(BufferGL&& buf) CL_HPP_NOEXCEPT : Buffer(std::move(buf)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+    * Required for MSVC.
+    */
+    BufferGL& operator = (BufferGL &&buf)
+    {
+        Buffer::operator=(std::move(buf));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+
+    //! \brief Wrapper for clGetGLObjectInfo().
+    cl_int getObjectInfo(
+        cl_gl_object_type *type,
+        cl_GLuint * gl_object_name)
+    {
+        return detail::errHandler(
+            ::clGetGLObjectInfo(object_,type,gl_object_name),
+            __GET_GL_OBJECT_INFO_ERR);
+    }
+};
+
+/*! \brief C++ base class for Image Memory objects.
+ *
+ *  See Memory for details about copy semantics, etc.
+ * 
+ *  \see Memory
+ */
+class Image : public Memory
+{
+protected:
+    //! \brief Default constructor - initializes to NULL.
+    Image() : Memory() { }
+
+    /*! \brief Constructor from cl_mem - takes ownership.
+     *
+     *  See Memory for further details.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS Image(const cl_mem& image) : Memory(image) { }
+
+    /*! \brief Assignment from cl_mem - performs shallow copy.
+     *
+     *  See Memory for further details.
+     */
+    Image& operator = (const cl_mem& rhs)
+    {
+        Memory::operator=(rhs);
+        return *this;
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image(const Image& img) : Memory(img) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image& operator = (const Image &img)
+    {
+        Memory::operator=(img);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image(Image&& img) CL_HPP_NOEXCEPT : Memory(std::move(img)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image& operator = (Image &&img)
+    {
+        Memory::operator=(std::move(img));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+
+public:
+    //! \brief Wrapper for clGetImageInfo().
+    template <typename T>
+    cl_int getImageInfo(cl_image_info name, T* param) const
+    {
+        return detail::errHandler(
+            detail::getInfo(&::clGetImageInfo, object_, name, param),
+            __GET_IMAGE_INFO_ERR);
+    }
+    
+    //! \brief Wrapper for clGetImageInfo() that returns by value.
+    template <cl_int name> typename
+    detail::param_traits<detail::cl_image_info, name>::param_type
+    getImageInfo(cl_int* err = NULL) const
+    {
+        typename detail::param_traits<
+            detail::cl_image_info, name>::param_type param;
+        cl_int result = getImageInfo(name, &param);
+        if (err != NULL) {
+            *err = result;
+        }
+        return param;
+    }
+};
+
+#if defined(CL_VERSION_1_2)
+/*! \brief Class interface for 1D Image Memory objects.
+ *
+ *  See Memory for details about copy semantics, etc.
+ * 
+ *  \see Memory
+ */
+class Image1D : public Image
+{
+public:
+    /*! \brief Constructs a 1D Image in a specified context.
+     *
+     *  Wraps clCreateImage().
+     */
+    Image1D(
+        const Context& context,
+        cl_mem_flags flags,
+        ImageFormat format,
+        ::size_t width,
+        void* host_ptr = NULL,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+        cl_image_desc desc =
+        {
+            CL_MEM_OBJECT_IMAGE1D,
+            width,
+            0, 0, 0, 0, 0, 0, 0, 0
+        };
+        object_ = ::clCreateImage(
+            context(), 
+            flags, 
+            &format, 
+            &desc, 
+            host_ptr, 
+            &error);
+
+        detail::errHandler(error, __CREATE_IMAGE_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    //! \brief Default constructor - initializes to NULL.
+    Image1D() { }
+
+    /*! \brief Constructor from cl_mem - takes ownership.
+     *
+     *  See Memory for further details.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS Image1D(const cl_mem& image1D) : Image(image1D) { }
+
+    /*! \brief Assignment from cl_mem - performs shallow copy.
+     *
+     *  See Memory for further details.
+     */
+    Image1D& operator = (const cl_mem& rhs)
+    {
+        Image::operator=(rhs);
+        return *this;
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image1D(const Image1D& img) : Image(img) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image1D& operator = (const Image1D &img)
+    {
+        Image::operator=(img);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image1D(Image1D&& img) CL_HPP_NOEXCEPT : Image(std::move(img)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image1D& operator = (Image1D &&img)
+    {
+        Image::operator=(std::move(img));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+};
+
+/*! \class Image1DBuffer
+ * \brief Image interface for 1D buffer images.
+ */
+class Image1DBuffer : public Image
+{
+public:
+    Image1DBuffer(
+        const Context& context,
+        cl_mem_flags flags,
+        ImageFormat format,
+        ::size_t width,
+        const Buffer &buffer,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+        cl_image_desc desc =
+        {
+            CL_MEM_OBJECT_IMAGE1D_BUFFER,
+            width,
+            0, 0, 0, 0, 0, 0, 0,
+            buffer()
+        };
+        object_ = ::clCreateImage(
+            context(), 
+            flags, 
+            &format, 
+            &desc, 
+            NULL, 
+            &error);
+
+        detail::errHandler(error, __CREATE_IMAGE_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    Image1DBuffer() { }
+
+    __CL_EXPLICIT_CONSTRUCTORS Image1DBuffer(const cl_mem& image1D) : Image(image1D) { }
+
+    Image1DBuffer& operator = (const cl_mem& rhs)
+    {
+        Image::operator=(rhs);
+        return *this;
+    }
+    
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image1DBuffer(const Image1DBuffer& img) : Image(img) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image1DBuffer& operator = (const Image1DBuffer &img)
+    {
+        Image::operator=(img);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image1DBuffer(Image1DBuffer&& img) CL_HPP_NOEXCEPT : Image(std::move(img)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image1DBuffer& operator = (Image1DBuffer &&img)
+    {
+        Image::operator=(std::move(img));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+};
+
+/*! \class Image1DArray
+ * \brief Image interface for arrays of 1D images.
+ */
+class Image1DArray : public Image
+{
+public:
+    Image1DArray(
+        const Context& context,
+        cl_mem_flags flags,
+        ImageFormat format,
+        ::size_t arraySize,
+        ::size_t width,
+        ::size_t rowPitch,
+        void* host_ptr = NULL,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+        cl_image_desc desc =
+        {
+            CL_MEM_OBJECT_IMAGE1D_ARRAY,
+            width,
+            0, 0,  // height, depth (unused)
+            arraySize,
+            rowPitch,
+            0, 0, 0, 0
+        };
+        object_ = ::clCreateImage(
+            context(), 
+            flags, 
+            &format, 
+            &desc, 
+            host_ptr, 
+            &error);
+
+        detail::errHandler(error, __CREATE_IMAGE_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    Image1DArray() { }
+
+    __CL_EXPLICIT_CONSTRUCTORS Image1DArray(const cl_mem& imageArray) : Image(imageArray) { }
+
+    Image1DArray& operator = (const cl_mem& rhs)
+    {
+        Image::operator=(rhs);
+        return *this;
+    }
+    
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image1DArray(const Image1DArray& img) : Image(img) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image1DArray& operator = (const Image1DArray &img)
+    {
+        Image::operator=(img);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image1DArray(Image1DArray&& img) CL_HPP_NOEXCEPT : Image(std::move(img)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image1DArray& operator = (Image1DArray &&img)
+    {
+        Image::operator=(std::move(img));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+};
+#endif // #if defined(CL_VERSION_1_2)
+
+
+/*! \brief Class interface for 2D Image Memory objects.
+ *
+ *  See Memory for details about copy semantics, etc.
+ * 
+ *  \see Memory
+ */
+class Image2D : public Image
+{
+public:
+    /*! \brief Constructs a 1D Image in a specified context.
+     *
+     *  Wraps clCreateImage().
+     */
+    Image2D(
+        const Context& context,
+        cl_mem_flags flags,
+        ImageFormat format,
+        ::size_t width,
+        ::size_t height,
+        ::size_t row_pitch = 0,
+        void* host_ptr = NULL,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+        bool useCreateImage;
+
+#if defined(CL_VERSION_1_2) && defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
+        // Run-time decision based on the actual platform
+        {
+            cl_uint version = detail::getContextPlatformVersion(context());
+            useCreateImage = (version >= 0x10002); // OpenCL 1.2 or above
+        }
+#elif defined(CL_VERSION_1_2)
+        useCreateImage = true;
+#else
+        useCreateImage = false;
+#endif
+
+#if defined(CL_VERSION_1_2)
+        if (useCreateImage)
+        {
+            cl_image_desc desc =
+            {
+                CL_MEM_OBJECT_IMAGE2D,
+                width,
+                height,
+                0, 0, // depth, array size (unused)
+                row_pitch,
+                0, 0, 0, 0
+            };
+            object_ = ::clCreateImage(
+                context(),
+                flags,
+                &format,
+                &desc,
+                host_ptr,
+                &error);
+
+            detail::errHandler(error, __CREATE_IMAGE_ERR);
+            if (err != NULL) {
+                *err = error;
+            }
+        }
+#endif // #if defined(CL_VERSION_1_2)
+#if !defined(CL_VERSION_1_2) || defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
+        if (!useCreateImage)
+        {
+            object_ = ::clCreateImage2D(
+                context(), flags,&format, width, height, row_pitch, host_ptr, &error);
+
+            detail::errHandler(error, __CREATE_IMAGE2D_ERR);
+            if (err != NULL) {
+                *err = error;
+            }
+        }
+#endif // #if !defined(CL_VERSION_1_2) || defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
+    }
+
+    //! \brief Default constructor - initializes to NULL.
+    Image2D() { }
+
+    /*! \brief Constructor from cl_mem - takes ownership.
+     *
+     *  See Memory for further details.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS Image2D(const cl_mem& image2D) : Image(image2D) { }
+
+    /*! \brief Assignment from cl_mem - performs shallow copy.
+     *
+     *  See Memory for further details.
+     */
+    Image2D& operator = (const cl_mem& rhs)
+    {
+        Image::operator=(rhs);
+        return *this;
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image2D(const Image2D& img) : Image(img) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image2D& operator = (const Image2D &img)
+    {
+        Image::operator=(img);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image2D(Image2D&& img) CL_HPP_NOEXCEPT : Image(std::move(img)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image2D& operator = (Image2D &&img)
+    {
+        Image::operator=(std::move(img));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+};
+
+
+#if !defined(CL_VERSION_1_2)
+/*! \brief Class interface for GL 2D Image Memory objects.
+ *
+ *  This is provided to facilitate interoperability with OpenGL.
+ * 
+ *  See Memory for details about copy semantics, etc.
+ * 
+ *  \see Memory
+ *  \note Deprecated for OpenCL 1.2. Please use ImageGL instead.
+ */
+class CL_EXT_PREFIX__VERSION_1_1_DEPRECATED Image2DGL CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED : public Image2D
+{
+public:
+    /*! \brief Constructs an Image2DGL in a specified context, from a given
+     *         GL Texture.
+     *
+     *  Wraps clCreateFromGLTexture2D().
+     */
+    Image2DGL(
+        const Context& context,
+        cl_mem_flags flags,
+        cl_GLenum target,
+        cl_GLint  miplevel,
+        cl_GLuint texobj,
+        cl_int * err = NULL)
+    {
+        cl_int error;
+        object_ = ::clCreateFromGLTexture2D(
+            context(),
+            flags,
+            target,
+            miplevel,
+            texobj,
+            &error);
+
+        detail::errHandler(error, __CREATE_GL_TEXTURE_2D_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+
+    }
+    
+    //! \brief Default constructor - initializes to NULL.
+    Image2DGL() : Image2D() { }
+
+    /*! \brief Constructor from cl_mem - takes ownership.
+     *
+     *  See Memory for further details.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS Image2DGL(const cl_mem& image) : Image2D(image) { }
+
+    /*! \brief Assignment from cl_mem - performs shallow copy.
+     *
+     *  See Memory for further details.
+     */
+    Image2DGL& operator = (const cl_mem& rhs)
+    {
+        Image2D::operator=(rhs);
+        return *this;
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image2DGL(const Image2DGL& img) : Image2D(img) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image2DGL& operator = (const Image2DGL &img)
+    {
+        Image2D::operator=(img);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image2DGL(Image2DGL&& img) CL_HPP_NOEXCEPT : Image2D(std::move(img)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image2DGL& operator = (Image2DGL &&img)
+    {
+        Image2D::operator=(std::move(img));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+};
+#endif // #if !defined(CL_VERSION_1_2)
+
+#if defined(CL_VERSION_1_2)
+/*! \class Image2DArray
+ * \brief Image interface for arrays of 2D images.
+ */
+class Image2DArray : public Image
+{
+public:
+    Image2DArray(
+        const Context& context,
+        cl_mem_flags flags,
+        ImageFormat format,
+        ::size_t arraySize,
+        ::size_t width,
+        ::size_t height,
+        ::size_t rowPitch,
+        ::size_t slicePitch,
+        void* host_ptr = NULL,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+        cl_image_desc desc =
+        {
+            CL_MEM_OBJECT_IMAGE2D_ARRAY,
+            width,
+            height,
+            0,       // depth (unused)
+            arraySize,
+            rowPitch,
+            slicePitch,
+            0, 0, 0
+        };
+        object_ = ::clCreateImage(
+            context(), 
+            flags, 
+            &format, 
+            &desc, 
+            host_ptr, 
+            &error);
+
+        detail::errHandler(error, __CREATE_IMAGE_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    Image2DArray() { }
+
+    __CL_EXPLICIT_CONSTRUCTORS Image2DArray(const cl_mem& imageArray) : Image(imageArray) { }
+
+    Image2DArray& operator = (const cl_mem& rhs)
+    {
+        Image::operator=(rhs);
+        return *this;
+    }
+    
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image2DArray(const Image2DArray& img) : Image(img) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image2DArray& operator = (const Image2DArray &img)
+    {
+        Image::operator=(img);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image2DArray(Image2DArray&& img) CL_HPP_NOEXCEPT : Image(std::move(img)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image2DArray& operator = (Image2DArray &&img)
+    {
+        Image::operator=(std::move(img));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+};
+#endif // #if defined(CL_VERSION_1_2)
+
+/*! \brief Class interface for 3D Image Memory objects.
+ *
+ *  See Memory for details about copy semantics, etc.
+ * 
+ *  \see Memory
+ */
+class Image3D : public Image
+{
+public:
+    /*! \brief Constructs a 3D Image in a specified context.
+     *
+     *  Wraps clCreateImage().
+     */
+    Image3D(
+        const Context& context,
+        cl_mem_flags flags,
+        ImageFormat format,
+        ::size_t width,
+        ::size_t height,
+        ::size_t depth,
+        ::size_t row_pitch = 0,
+        ::size_t slice_pitch = 0,
+        void* host_ptr = NULL,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+        bool useCreateImage;
+
+#if defined(CL_VERSION_1_2) && defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
+        // Run-time decision based on the actual platform
+        {
+            cl_uint version = detail::getContextPlatformVersion(context());
+            useCreateImage = (version >= 0x10002); // OpenCL 1.2 or above
+        }
+#elif defined(CL_VERSION_1_2)
+        useCreateImage = true;
+#else
+        useCreateImage = false;
+#endif
+
+#if defined(CL_VERSION_1_2)
+        if (useCreateImage)
+        {
+            cl_image_desc desc =
+            {
+                CL_MEM_OBJECT_IMAGE3D,
+                width,
+                height,
+                depth,
+                0,      // array size (unused)
+                row_pitch,
+                slice_pitch,
+                0, 0, 0
+            };
+            object_ = ::clCreateImage(
+                context(), 
+                flags, 
+                &format, 
+                &desc, 
+                host_ptr, 
+                &error);
+
+            detail::errHandler(error, __CREATE_IMAGE_ERR);
+            if (err != NULL) {
+                *err = error;
+            }
+        }
+#endif  // #if defined(CL_VERSION_1_2)
+#if !defined(CL_VERSION_1_2) || defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
+        if (!useCreateImage)
+        {
+            object_ = ::clCreateImage3D(
+                context(), flags, &format, width, height, depth, row_pitch,
+                slice_pitch, host_ptr, &error);
+
+            detail::errHandler(error, __CREATE_IMAGE3D_ERR);
+            if (err != NULL) {
+                *err = error;
+            }
+        }
+#endif // #if !defined(CL_VERSION_1_2) || defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
+    }
+
+    //! \brief Default constructor - initializes to NULL.
+    Image3D() : Image() { }
+
+    /*! \brief Constructor from cl_mem - takes ownership.
+     *
+     *  See Memory for further details.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS Image3D(const cl_mem& image3D) : Image(image3D) { }
+
+    /*! \brief Assignment from cl_mem - performs shallow copy.
+     *
+     *  See Memory for further details.
+     */
+    Image3D& operator = (const cl_mem& rhs)
+    {
+        Image::operator=(rhs);
+        return *this;
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image3D(const Image3D& img) : Image(img) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image3D& operator = (const Image3D &img)
+    {
+        Image::operator=(img);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image3D(Image3D&& img) CL_HPP_NOEXCEPT : Image(std::move(img)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image3D& operator = (Image3D &&img)
+    {
+        Image::operator=(std::move(img));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+};
+
+#if !defined(CL_VERSION_1_2)
+/*! \brief Class interface for GL 3D Image Memory objects.
+ *
+ *  This is provided to facilitate interoperability with OpenGL.
+ * 
+ *  See Memory for details about copy semantics, etc.
+ * 
+ *  \see Memory
+ */
+class Image3DGL : public Image3D
+{
+public:
+    /*! \brief Constructs an Image3DGL in a specified context, from a given
+     *         GL Texture.
+     *
+     *  Wraps clCreateFromGLTexture3D().
+     */
+    Image3DGL(
+        const Context& context,
+        cl_mem_flags flags,
+        cl_GLenum target,
+        cl_GLint  miplevel,
+        cl_GLuint texobj,
+        cl_int * err = NULL)
+    {
+        cl_int error;
+        object_ = ::clCreateFromGLTexture3D(
+            context(),
+            flags,
+            target,
+            miplevel,
+            texobj,
+            &error);
+
+        detail::errHandler(error, __CREATE_GL_TEXTURE_3D_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    //! \brief Default constructor - initializes to NULL.
+    Image3DGL() : Image3D() { }
+
+    /*! \brief Constructor from cl_mem - takes ownership.
+     *
+     *  See Memory for further details.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS Image3DGL(const cl_mem& image) : Image3D(image) { }
+
+    /*! \brief Assignment from cl_mem - performs shallow copy.
+     *
+     *  See Memory for further details.
+     */
+    Image3DGL& operator = (const cl_mem& rhs)
+    {
+        Image3D::operator=(rhs);
+        return *this;
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image3DGL(const Image3DGL& img) : Image3D(img) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image3DGL& operator = (const Image3DGL &img)
+    {
+        Image3D::operator=(img);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image3DGL(Image3DGL&& img) CL_HPP_NOEXCEPT : Image3D(std::move(img)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Image3DGL& operator = (Image3DGL &&img)
+    {
+        Image3D::operator=(std::move(img));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+};
+#endif // #if !defined(CL_VERSION_1_2)
+
+#if defined(CL_VERSION_1_2)
+/*! \class ImageGL
+ * \brief general image interface for GL interop.
+ * We abstract the 2D and 3D GL images into a single instance here
+ * that wraps all GL sourced images on the grounds that setup information
+ * was performed by OpenCL anyway.
+ */
+class ImageGL : public Image
+{
+public:
+    ImageGL(
+        const Context& context,
+        cl_mem_flags flags,
+        cl_GLenum target,
+        cl_GLint  miplevel,
+        cl_GLuint texobj,
+        cl_int * err = NULL)
+    {
+        cl_int error;
+        object_ = ::clCreateFromGLTexture(
+            context(), 
+            flags, 
+            target,
+            miplevel,
+            texobj,
+            &error);
+
+        detail::errHandler(error, __CREATE_GL_TEXTURE_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    ImageGL() : Image() { }
+
+    __CL_EXPLICIT_CONSTRUCTORS ImageGL(const cl_mem& image) : Image(image) { }
+
+    ImageGL& operator = (const cl_mem& rhs)
+    {
+        Image::operator=(rhs);
+        return *this;
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    ImageGL(const ImageGL& img) : Image(img) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    ImageGL& operator = (const ImageGL &img)
+    {
+        Image::operator=(img);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    ImageGL(ImageGL&& img) CL_HPP_NOEXCEPT : Image(std::move(img)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    ImageGL& operator = (ImageGL &&img)
+    {
+        Image::operator=(std::move(img));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+};
+#endif // #if defined(CL_VERSION_1_2)
+
+/*! \brief Class interface for GL Render Buffer Memory Objects.
+*
+*  This is provided to facilitate interoperability with OpenGL.
+*
+*  See Memory for details about copy semantics, etc.
+*
+*  \see Memory
+*/
+class BufferRenderGL : 
+#if defined(CL_VERSION_1_2)
+    public ImageGL
+#else // #if defined(CL_VERSION_1_2)
+    public Image2DGL
+#endif //#if defined(CL_VERSION_1_2)
+{
+public:
+    /*! \brief Constructs a BufferRenderGL in a specified context, from a given
+    *         GL Renderbuffer.
+    *
+    *  Wraps clCreateFromGLRenderbuffer().
+    */
+    BufferRenderGL(
+        const Context& context,
+        cl_mem_flags flags,
+        cl_GLuint bufobj,
+        cl_int * err = NULL)
+    {
+        cl_int error;
+        object_ = ::clCreateFromGLRenderbuffer(
+            context(),
+            flags,
+            bufobj,
+            &error);
+
+        detail::errHandler(error, __CREATE_GL_RENDER_BUFFER_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    //! \brief Default constructor - initializes to NULL.
+#if defined(CL_VERSION_1_2)
+    BufferRenderGL() : ImageGL() {};
+#else // #if defined(CL_VERSION_1_2)
+    BufferRenderGL() : Image2DGL() {};
+#endif //#if defined(CL_VERSION_1_2)
+
+    /*! \brief Constructor from cl_mem - takes ownership.
+    *
+    *  See Memory for further details.
+    */
+#if defined(CL_VERSION_1_2)
+    __CL_EXPLICIT_CONSTRUCTORS BufferRenderGL(const cl_mem& buffer) : ImageGL(buffer) { }
+#else // #if defined(CL_VERSION_1_2)
+    __CL_EXPLICIT_CONSTRUCTORS BufferRenderGL(const cl_mem& buffer) : Image2DGL(buffer) { }
+#endif //#if defined(CL_VERSION_1_2)
+
+
+    /*! \brief Assignment from cl_mem - performs shallow copy.
+    *
+    *  See Memory for further details.
+    */
+    BufferRenderGL& operator = (const cl_mem& rhs)
+    {
+#if defined(CL_VERSION_1_2)
+        ImageGL::operator=(rhs);
+#else // #if defined(CL_VERSION_1_2)
+        Image2DGL::operator=(rhs);
+#endif //#if defined(CL_VERSION_1_2)
+        
+        return *this;
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+    * Required for MSVC.
+    */
+#if defined(CL_VERSION_1_2)
+    BufferRenderGL(const BufferRenderGL& buf) : ImageGL(buf) {}
+#else // #if defined(CL_VERSION_1_2)
+    BufferRenderGL(const BufferRenderGL& buf) : Image2DGL(buf) {}
+#endif //#if defined(CL_VERSION_1_2)
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+    * Required for MSVC.
+    */
+    BufferRenderGL& operator = (const BufferRenderGL &rhs)
+    {
+#if defined(CL_VERSION_1_2)
+        ImageGL::operator=(rhs);
+#else // #if defined(CL_VERSION_1_2)
+        Image2DGL::operator=(rhs);
+#endif //#if defined(CL_VERSION_1_2)
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+    * Required for MSVC.
+    */
+#if defined(CL_VERSION_1_2)
+    BufferRenderGL(BufferRenderGL&& buf) CL_HPP_NOEXCEPT : ImageGL(std::move(buf)) {}
+#else // #if defined(CL_VERSION_1_2)
+    BufferRenderGL(BufferRenderGL&& buf) CL_HPP_NOEXCEPT : Image2DGL(std::move(buf)) {}
+#endif //#if defined(CL_VERSION_1_2)
+    
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+    * Required for MSVC.
+    */
+    BufferRenderGL& operator = (BufferRenderGL &&buf)
+    {
+#if defined(CL_VERSION_1_2)
+        ImageGL::operator=(std::move(buf));
+#else // #if defined(CL_VERSION_1_2)
+        Image2DGL::operator=(std::move(buf));
+#endif //#if defined(CL_VERSION_1_2)
+        
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+
+    //! \brief Wrapper for clGetGLObjectInfo().
+    cl_int getObjectInfo(
+        cl_gl_object_type *type,
+        cl_GLuint * gl_object_name)
+    {
+        return detail::errHandler(
+            ::clGetGLObjectInfo(object_, type, gl_object_name),
+            __GET_GL_OBJECT_INFO_ERR);
+    }
+};
+
+/*! \brief Class interface for cl_sampler.
+ *
+ *  \note Copies of these objects are shallow, meaning that the copy will refer
+ *        to the same underlying cl_sampler as the original.  For details, see
+ *        clRetainSampler() and clReleaseSampler().
+ *
+ *  \see cl_sampler 
+ */
+class Sampler : public detail::Wrapper<cl_sampler>
+{
+public:
+    //! \brief Default constructor - initializes to NULL.
+    Sampler() { }
+
+    /*! \brief Constructs a Sampler in a specified context.
+     *
+     *  Wraps clCreateSampler().
+     */
+    Sampler(
+        const Context& context,
+        cl_bool normalized_coords,
+        cl_addressing_mode addressing_mode,
+        cl_filter_mode filter_mode,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+        object_ = ::clCreateSampler(
+            context(), 
+            normalized_coords,
+            addressing_mode,
+            filter_mode,
+            &error);
+
+        detail::errHandler(error, __CREATE_SAMPLER_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    /*! \brief Constructor from cl_sampler - takes ownership.
+     * 
+     *  This effectively transfers ownership of a refcount on the cl_sampler
+     *  into the new Sampler object.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS Sampler(const cl_sampler& sampler) : detail::Wrapper<cl_type>(sampler) { }
+
+    /*! \brief Assignment operator from cl_sampler - takes ownership.
+     *
+     *  This effectively transfers ownership of a refcount on the rhs and calls
+     *  clReleaseSampler() on the value previously held by this instance.
+     */
+    Sampler& operator = (const cl_sampler& rhs)
+    {
+        detail::Wrapper<cl_type>::operator=(rhs);
+        return *this;
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Sampler(const Sampler& sam) : detail::Wrapper<cl_type>(sam) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Sampler& operator = (const Sampler &sam)
+    {
+        detail::Wrapper<cl_type>::operator=(sam);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Sampler(Sampler&& sam) CL_HPP_NOEXCEPT : detail::Wrapper<cl_type>(std::move(sam)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Sampler& operator = (Sampler &&sam)
+    {
+        detail::Wrapper<cl_type>::operator=(std::move(sam));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+
+    //! \brief Wrapper for clGetSamplerInfo().
+    template <typename T>
+    cl_int getInfo(cl_sampler_info name, T* param) const
+    {
+        return detail::errHandler(
+            detail::getInfo(&::clGetSamplerInfo, object_, name, param),
+            __GET_SAMPLER_INFO_ERR);
+    }
+
+    //! \brief Wrapper for clGetSamplerInfo() that returns by value.
+    template <cl_int name> typename
+    detail::param_traits<detail::cl_sampler_info, name>::param_type
+    getInfo(cl_int* err = NULL) const
+    {
+        typename detail::param_traits<
+            detail::cl_sampler_info, name>::param_type param;
+        cl_int result = getInfo(name, &param);
+        if (err != NULL) {
+            *err = result;
+        }
+        return param;
+    }
+};
+
+class Program;
+class CommandQueue;
+class Kernel;
+
+//! \brief Class interface for specifying NDRange values.
+class NDRange
+{
+private:
+    size_t<3> sizes_;
+    cl_uint dimensions_;
+
+public:
+    //! \brief Default constructor - resulting range has zero dimensions.
+    NDRange()
+        : dimensions_(0)
+    { }
+
+    //! \brief Constructs one-dimensional range.
+    NDRange(::size_t size0)
+        : dimensions_(1)
+    {
+        sizes_[0] = size0;
+    }
+
+    //! \brief Constructs two-dimensional range.
+    NDRange(::size_t size0, ::size_t size1)
+        : dimensions_(2)
+    {
+        sizes_[0] = size0;
+        sizes_[1] = size1;
+    }
+
+    //! \brief Constructs three-dimensional range.
+    NDRange(::size_t size0, ::size_t size1, ::size_t size2)
+        : dimensions_(3)
+    {
+        sizes_[0] = size0;
+        sizes_[1] = size1;
+        sizes_[2] = size2;
+    }
+
+    /*! \brief Conversion operator to const ::size_t *.
+     *  
+     *  \returns a pointer to the size of the first dimension.
+     */
+    operator const ::size_t*() const { 
+        return (const ::size_t*) sizes_; 
+    }
+
+    //! \brief Queries the number of dimensions in the range.
+    ::size_t dimensions() const { return dimensions_; }
+};
+
+//! \brief A zero-dimensional range.
+static const NDRange NullRange;
+
+//! \brief Local address wrapper for use with Kernel::setArg
+struct LocalSpaceArg
+{
+    ::size_t size_;
+};
+
+namespace detail {
+
+template <typename T>
+struct KernelArgumentHandler
+{
+    static ::size_t size(const T&) { return sizeof(T); }
+    static const T* ptr(const T& value) { return &value; }
+};
+
+template <>
+struct KernelArgumentHandler<LocalSpaceArg>
+{
+    static ::size_t size(const LocalSpaceArg& value) { return value.size_; }
+    static const void* ptr(const LocalSpaceArg&) { return NULL; }
+};
+
+} 
+//! \endcond
+
+/*! __local
+ * \brief Helper function for generating LocalSpaceArg objects.
+ * Deprecated. Replaced with Local.
+ */
+inline CL_EXT_PREFIX__VERSION_1_1_DEPRECATED LocalSpaceArg
+__local(::size_t size) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED;
+inline LocalSpaceArg
+__local(::size_t size)
+{
+    LocalSpaceArg ret = { size };
+    return ret;
+}
+
+/*! Local
+ * \brief Helper function for generating LocalSpaceArg objects.
+ */
+inline LocalSpaceArg
+Local(::size_t size)
+{
+    LocalSpaceArg ret = { size };
+    return ret;
+}
+
+//class KernelFunctor;
+
+/*! \brief Class interface for cl_kernel.
+ *
+ *  \note Copies of these objects are shallow, meaning that the copy will refer
+ *        to the same underlying cl_kernel as the original.  For details, see
+ *        clRetainKernel() and clReleaseKernel().
+ *
+ *  \see cl_kernel
+ */
+class Kernel : public detail::Wrapper<cl_kernel>
+{
+public:
+    inline Kernel(const Program& program, const char* name, cl_int* err = NULL);
+
+    //! \brief Default constructor - initializes to NULL.
+    Kernel() { }
+
+    /*! \brief Constructor from cl_kernel - takes ownership.
+     * 
+     *  This effectively transfers ownership of a refcount on the cl_kernel
+     *  into the new Kernel object.
+     */
+    __CL_EXPLICIT_CONSTRUCTORS Kernel(const cl_kernel& kernel) : detail::Wrapper<cl_type>(kernel) { }
+
+    /*! \brief Assignment operator from cl_kernel - takes ownership.
+     *
+     *  This effectively transfers ownership of a refcount on the rhs and calls
+     *  clReleaseKernel() on the value previously held by this instance.
+     */
+    Kernel& operator = (const cl_kernel& rhs)
+    {
+        detail::Wrapper<cl_type>::operator=(rhs);
+        return *this;
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Kernel(const Kernel& kernel) : detail::Wrapper<cl_type>(kernel) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Kernel& operator = (const Kernel &kernel)
+    {
+        detail::Wrapper<cl_type>::operator=(kernel);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Kernel(Kernel&& kernel) CL_HPP_NOEXCEPT : detail::Wrapper<cl_type>(std::move(kernel)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Kernel& operator = (Kernel &&kernel)
+    {
+        detail::Wrapper<cl_type>::operator=(std::move(kernel));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+
+    template <typename T>
+    cl_int getInfo(cl_kernel_info name, T* param) const
+    {
+        return detail::errHandler(
+            detail::getInfo(&::clGetKernelInfo, object_, name, param),
+            __GET_KERNEL_INFO_ERR);
+    }
+
+    template <cl_int name> typename
+    detail::param_traits<detail::cl_kernel_info, name>::param_type
+    getInfo(cl_int* err = NULL) const
+    {
+        typename detail::param_traits<
+            detail::cl_kernel_info, name>::param_type param;
+        cl_int result = getInfo(name, &param);
+        if (err != NULL) {
+            *err = result;
+        }
+        return param;
+    }
+
+#if defined(CL_VERSION_1_2)
+    template <typename T>
+    cl_int getArgInfo(cl_uint argIndex, cl_kernel_arg_info name, T* param) const
+    {
+        return detail::errHandler(
+            detail::getInfo(&::clGetKernelArgInfo, object_, argIndex, name, param),
+            __GET_KERNEL_ARG_INFO_ERR);
+    }
+
+    template <cl_int name> typename
+    detail::param_traits<detail::cl_kernel_arg_info, name>::param_type
+    getArgInfo(cl_uint argIndex, cl_int* err = NULL) const
+    {
+        typename detail::param_traits<
+            detail::cl_kernel_arg_info, name>::param_type param;
+        cl_int result = getArgInfo(argIndex, name, &param);
+        if (err != NULL) {
+            *err = result;
+        }
+        return param;
+    }
+#endif // #if defined(CL_VERSION_1_2)
+
+    template <typename T>
+    cl_int getWorkGroupInfo(
+        const Device& device, cl_kernel_work_group_info name, T* param) const
+    {
+        return detail::errHandler(
+            detail::getInfo(
+                &::clGetKernelWorkGroupInfo, object_, device(), name, param),
+                __GET_KERNEL_WORK_GROUP_INFO_ERR);
+    }
+
+    template <cl_int name> typename
+    detail::param_traits<detail::cl_kernel_work_group_info, name>::param_type
+        getWorkGroupInfo(const Device& device, cl_int* err = NULL) const
+    {
+        typename detail::param_traits<
+        detail::cl_kernel_work_group_info, name>::param_type param;
+        cl_int result = getWorkGroupInfo(device, name, &param);
+        if (err != NULL) {
+            *err = result;
+        }
+        return param;
+    }
+
+    template <typename T>
+    cl_int setArg(cl_uint index, const T &value)
+    {
+        return detail::errHandler(
+            ::clSetKernelArg(
+                object_,
+                index,
+                detail::KernelArgumentHandler<T>::size(value),
+                detail::KernelArgumentHandler<T>::ptr(value)),
+            __SET_KERNEL_ARGS_ERR);
+    }
+
+    cl_int setArg(cl_uint index, ::size_t size, const void* argPtr)
+    {
+        return detail::errHandler(
+            ::clSetKernelArg(object_, index, size, argPtr),
+            __SET_KERNEL_ARGS_ERR);
+    }
+};
+
+/*! \class Program
+ * \brief Program interface that implements cl_program.
+ */
+class Program : public detail::Wrapper<cl_program>
+{
+public:
+    typedef VECTOR_CLASS<std::pair<const void*, ::size_t> > Binaries;
+    typedef VECTOR_CLASS<std::pair<const char*, ::size_t> > Sources;
+
+    Program(
+        const STRING_CLASS& source,
+        bool build = false,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+
+        const char * strings = source.c_str();
+        const ::size_t length  = source.size();
+
+        Context context = Context::getDefault(err);
+
+        object_ = ::clCreateProgramWithSource(
+            context(), (cl_uint)1, &strings, &length, &error);
+
+        detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR);
+
+        if (error == CL_SUCCESS && build) {
+
+            error = ::clBuildProgram(
+                object_,
+                0,
+                NULL,
+                "",
+                NULL,
+                NULL);
+
+            detail::errHandler(error, __BUILD_PROGRAM_ERR);
+        }
+
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    Program(
+        const Context& context,
+        const STRING_CLASS& source,
+        bool build = false,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+
+        const char * strings = source.c_str();
+        const ::size_t length  = source.size();
+
+        object_ = ::clCreateProgramWithSource(
+            context(), (cl_uint)1, &strings, &length, &error);
+
+        detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR);
+
+        if (error == CL_SUCCESS && build) {
+
+            error = ::clBuildProgram(
+                object_,
+                0,
+                NULL,
+                "",
+                NULL,
+                NULL);
+
+            detail::errHandler(error, __BUILD_PROGRAM_ERR);
+        }
+
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    Program(
+        const Context& context,
+        const Sources& sources,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+
+        const ::size_t n = (::size_t)sources.size();
+        ::size_t* lengths = (::size_t*) alloca(n * sizeof(::size_t));
+        const char** strings = (const char**) alloca(n * sizeof(const char*));
+
+        for (::size_t i = 0; i < n; ++i) {
+            strings[i] = sources[(int)i].first;
+            lengths[i] = sources[(int)i].second;
+        }
+
+        object_ = ::clCreateProgramWithSource(
+            context(), (cl_uint)n, strings, lengths, &error);
+
+        detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    /**
+     * Construct a program object from a list of devices and a per-device list of binaries.
+     * \param context A valid OpenCL context in which to construct the program.
+     * \param devices A vector of OpenCL device objects for which the program will be created.
+     * \param binaries A vector of pairs of a pointer to a binary object and its length.
+     * \param binaryStatus An optional vector that on completion will be resized to
+     *   match the size of binaries and filled with values to specify if each binary
+     *   was successfully loaded.
+     *   Set to CL_SUCCESS if the binary was successfully loaded.
+     *   Set to CL_INVALID_VALUE if the length is 0 or the binary pointer is NULL.
+     *   Set to CL_INVALID_BINARY if the binary provided is not valid for the matching device.
+     * \param err if non-NULL will be set to CL_SUCCESS on successful operation or one of the following errors:
+     *   CL_INVALID_CONTEXT if context is not a valid context.
+     *   CL_INVALID_VALUE if the length of devices is zero; or if the length of binaries does not match the length of devices; 
+     *     or if any entry in binaries is NULL or has length 0.
+     *   CL_INVALID_DEVICE if OpenCL devices listed in devices are not in the list of devices associated with context.
+     *   CL_INVALID_BINARY if an invalid program binary was encountered for any device. binaryStatus will return specific status for each device.
+     *   CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the OpenCL implementation on the host.
+     */
+    Program(
+        const Context& context,
+        const VECTOR_CLASS<Device>& devices,
+        const Binaries& binaries,
+        VECTOR_CLASS<cl_int>* binaryStatus = NULL,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+        
+        const ::size_t numDevices = devices.size();
+        
+        // Catch size mismatch early and return
+        if(binaries.size() != numDevices) {
+            error = CL_INVALID_VALUE;
+            detail::errHandler(error, __CREATE_PROGRAM_WITH_BINARY_ERR);
+            if (err != NULL) {
+                *err = error;
+            }
+            return;
+        }
+
+        ::size_t* lengths = (::size_t*) alloca(numDevices * sizeof(::size_t));
+        const unsigned char** images = (const unsigned char**) alloca(numDevices * sizeof(const unsigned char**));
+
+        for (::size_t i = 0; i < numDevices; ++i) {
+            images[i] = (const unsigned char*)binaries[i].first;
+            lengths[i] = binaries[(int)i].second;
+        }
+
+        cl_device_id* deviceIDs = (cl_device_id*) alloca(numDevices * sizeof(cl_device_id));
+        for( ::size_t deviceIndex = 0; deviceIndex < numDevices; ++deviceIndex ) {
+            deviceIDs[deviceIndex] = (devices[deviceIndex])();
+        }
+
+        if(binaryStatus) {
+            binaryStatus->resize(numDevices);
+        }
+        
+        object_ = ::clCreateProgramWithBinary(
+            context(), (cl_uint) devices.size(),
+            deviceIDs,
+            lengths, images, (binaryStatus != NULL && numDevices > 0)
+               ? &binaryStatus->front()
+               : NULL, &error);
+
+        detail::errHandler(error, __CREATE_PROGRAM_WITH_BINARY_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    
+#if defined(CL_VERSION_1_2)
+    /**
+     * Create program using builtin kernels.
+     * \param kernelNames Semi-colon separated list of builtin kernel names
+     */
+    Program(
+        const Context& context,
+        const VECTOR_CLASS<Device>& devices,
+        const STRING_CLASS& kernelNames,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+
+
+        ::size_t numDevices = devices.size();
+        cl_device_id* deviceIDs = (cl_device_id*) alloca(numDevices * sizeof(cl_device_id));
+        for( ::size_t deviceIndex = 0; deviceIndex < numDevices; ++deviceIndex ) {
+            deviceIDs[deviceIndex] = (devices[deviceIndex])();
+        }
+        
+        object_ = ::clCreateProgramWithBuiltInKernels(
+            context(), 
+            (cl_uint) devices.size(),
+            deviceIDs,
+            kernelNames.c_str(), 
+            &error);
+
+        detail::errHandler(error, __CREATE_PROGRAM_WITH_BUILT_IN_KERNELS_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+#endif // #if defined(CL_VERSION_1_2)
+
+    Program() { }
+
+    __CL_EXPLICIT_CONSTRUCTORS Program(const cl_program& program) : detail::Wrapper<cl_type>(program) { }
+
+    Program& operator = (const cl_program& rhs)
+    {
+        detail::Wrapper<cl_type>::operator=(rhs);
+        return *this;
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Program(const Program& program) : detail::Wrapper<cl_type>(program) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    Program& operator = (const Program &program)
+    {
+        detail::Wrapper<cl_type>::operator=(program);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Program(Program&& program) CL_HPP_NOEXCEPT : detail::Wrapper<cl_type>(std::move(program)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    Program& operator = (Program &&program)
+    {
+        detail::Wrapper<cl_type>::operator=(std::move(program));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+
+    cl_int build(
+        const VECTOR_CLASS<Device>& devices,
+        const char* options = NULL,
+        void (CL_CALLBACK * notifyFptr)(cl_program, void *) = NULL,
+        void* data = NULL) const
+    {
+        ::size_t numDevices = devices.size();
+        cl_device_id* deviceIDs = (cl_device_id*) alloca(numDevices * sizeof(cl_device_id));
+        for( ::size_t deviceIndex = 0; deviceIndex < numDevices; ++deviceIndex ) {
+            deviceIDs[deviceIndex] = (devices[deviceIndex])();
+        }
+
+        return detail::errHandler(
+            ::clBuildProgram(
+                object_,
+                (cl_uint)
+                devices.size(),
+                deviceIDs,
+                options,
+                notifyFptr,
+                data),
+                __BUILD_PROGRAM_ERR);
+    }
+
+    cl_int build(
+        const char* options = NULL,
+        void (CL_CALLBACK * notifyFptr)(cl_program, void *) = NULL,
+        void* data = NULL) const
+    {
+        return detail::errHandler(
+            ::clBuildProgram(
+                object_,
+                0,
+                NULL,
+                options,
+                notifyFptr,
+                data),
+                __BUILD_PROGRAM_ERR);
+    }
+
+#if defined(CL_VERSION_1_2)
+    cl_int compile(
+        const char* options = NULL,
+        void (CL_CALLBACK * notifyFptr)(cl_program, void *) = NULL,
+        void* data = NULL) const
+    {
+        return detail::errHandler(
+            ::clCompileProgram(
+                object_,
+                0,
+                NULL,
+                options,
+                0,
+                NULL,
+                NULL,
+                notifyFptr,
+                data),
+                __COMPILE_PROGRAM_ERR);
+    }
+#endif
+
+    template <typename T>
+    cl_int getInfo(cl_program_info name, T* param) const
+    {
+        return detail::errHandler(
+            detail::getInfo(&::clGetProgramInfo, object_, name, param),
+            __GET_PROGRAM_INFO_ERR);
+    }
+
+    template <cl_int name> typename
+    detail::param_traits<detail::cl_program_info, name>::param_type
+    getInfo(cl_int* err = NULL) const
+    {
+        typename detail::param_traits<
+            detail::cl_program_info, name>::param_type param;
+        cl_int result = getInfo(name, &param);
+        if (err != NULL) {
+            *err = result;
+        }
+        return param;
+    }
+
+    template <typename T>
+    cl_int getBuildInfo(
+        const Device& device, cl_program_build_info name, T* param) const
+    {
+        return detail::errHandler(
+            detail::getInfo(
+                &::clGetProgramBuildInfo, object_, device(), name, param),
+                __GET_PROGRAM_BUILD_INFO_ERR);
+    }
+
+    template <cl_int name> typename
+    detail::param_traits<detail::cl_program_build_info, name>::param_type
+    getBuildInfo(const Device& device, cl_int* err = NULL) const
+    {
+        typename detail::param_traits<
+            detail::cl_program_build_info, name>::param_type param;
+        cl_int result = getBuildInfo(device, name, &param);
+        if (err != NULL) {
+            *err = result;
+        }
+        return param;
+    }
+
+    cl_int createKernels(VECTOR_CLASS<Kernel>* kernels)
+    {
+        cl_uint numKernels;
+        cl_int err = ::clCreateKernelsInProgram(object_, 0, NULL, &numKernels);
+        if (err != CL_SUCCESS) {
+            return detail::errHandler(err, __CREATE_KERNELS_IN_PROGRAM_ERR);
+        }
+
+        Kernel* value = (Kernel*) alloca(numKernels * sizeof(Kernel));
+        err = ::clCreateKernelsInProgram(
+            object_, numKernels, (cl_kernel*) value, NULL);
+        if (err != CL_SUCCESS) {
+            return detail::errHandler(err, __CREATE_KERNELS_IN_PROGRAM_ERR);
+        }
+
+        kernels->assign(&value[0], &value[numKernels]);
+        return CL_SUCCESS;
+    }
+};
+
+#if defined(CL_VERSION_1_2)
+inline Program linkProgram(
+    Program input1,
+    Program input2,
+    const char* options = NULL,
+    void (CL_CALLBACK * notifyFptr)(cl_program, void *) = NULL,
+    void* data = NULL,
+    cl_int* err = NULL) 
+{
+    cl_int error_local = CL_SUCCESS;
+
+    cl_program programs[2] = { input1(), input2() };
+
+    Context ctx = input1.getInfo<CL_PROGRAM_CONTEXT>(&error_local);
+    if(error_local!=CL_SUCCESS) {
+        detail::errHandler(error_local, __LINK_PROGRAM_ERR);
+    }
+
+    cl_program prog = ::clLinkProgram(
+        ctx(),
+        0,
+        NULL,
+        options,
+        2,
+        programs,
+        notifyFptr,
+        data,
+        &error_local);
+
+    detail::errHandler(error_local,__COMPILE_PROGRAM_ERR);
+    if (err != NULL) {
+        *err = error_local;
+    }
+
+    return Program(prog);
+}
+
+inline Program linkProgram(
+    VECTOR_CLASS<Program> inputPrograms,
+    const char* options = NULL,
+    void (CL_CALLBACK * notifyFptr)(cl_program, void *) = NULL,
+    void* data = NULL,
+    cl_int* err = NULL) 
+{
+    cl_int error_local = CL_SUCCESS;
+
+    cl_program * programs = (cl_program*) alloca(inputPrograms.size() * sizeof(cl_program));
+
+    if (programs != NULL) {
+        for (unsigned int i = 0; i < inputPrograms.size(); i++) {
+          programs[i] = inputPrograms[i]();
+        }
+    } 
+
+    Context ctx;
+    if(inputPrograms.size() > 0) {
+        ctx = inputPrograms[0].getInfo<CL_PROGRAM_CONTEXT>(&error_local);
+        if(error_local!=CL_SUCCESS) {
+            detail::errHandler(error_local, __LINK_PROGRAM_ERR);
+        }
+    }
+    cl_program prog = ::clLinkProgram(
+        ctx(),
+        0,
+        NULL,
+        options,
+        (cl_uint)inputPrograms.size(),
+        programs,
+        notifyFptr,
+        data,
+        &error_local);
+
+    detail::errHandler(error_local,__COMPILE_PROGRAM_ERR);
+    if (err != NULL) {
+        *err = error_local;
+    }
+
+    return Program(prog);
+}
+#endif
+
+template<>
+inline VECTOR_CLASS<char *> cl::Program::getInfo<CL_PROGRAM_BINARIES>(cl_int* err) const
+{
+    VECTOR_CLASS< ::size_t> sizes = getInfo<CL_PROGRAM_BINARY_SIZES>();
+    VECTOR_CLASS<char *> binaries;
+    for (VECTOR_CLASS< ::size_t>::iterator s = sizes.begin(); s != sizes.end(); ++s) 
+    {
+        char *ptr = NULL;
+        if (*s != 0) 
+            ptr = new char[*s];
+        binaries.push_back(ptr);
+    }
+    
+    cl_int result = getInfo(CL_PROGRAM_BINARIES, &binaries);
+    if (err != NULL) {
+        *err = result;
+    }
+    return binaries;
+}
+
+inline Kernel::Kernel(const Program& program, const char* name, cl_int* err)
+{
+    cl_int error;
+
+    object_ = ::clCreateKernel(program(), name, &error);
+    detail::errHandler(error, __CREATE_KERNEL_ERR);
+
+    if (err != NULL) {
+        *err = error;
+    }
+
+}
+
+/*! \class CommandQueue
+ * \brief CommandQueue interface for cl_command_queue.
+ */
+class CommandQueue : public detail::Wrapper<cl_command_queue>
+{
+private:
+#ifdef CL_HPP_CPP11_ATOMICS_SUPPORTED
+    static std::atomic<int> default_initialized_;
+#else // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+    static volatile int default_initialized_;
+#endif // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+    static CommandQueue default_;
+    static volatile cl_int default_error_;
+public:
+   CommandQueue(
+        cl_command_queue_properties properties,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+
+        Context context = Context::getDefault(&error);
+        detail::errHandler(error, __CREATE_CONTEXT_ERR);
+
+        if (error != CL_SUCCESS) {
+            if (err != NULL) {
+                *err = error;
+            }
+        }
+        else {
+            Device device = context.getInfo<CL_CONTEXT_DEVICES>()[0];
+
+            object_ = ::clCreateCommandQueue(
+                context(), device(), properties, &error);
+
+            detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
+            if (err != NULL) {
+                *err = error;
+            }
+        }
+    }
+    /*!
+    * \brief Constructs a CommandQueue for an implementation defined device in the given context
+    */
+    explicit CommandQueue(
+        const Context& context,
+        cl_command_queue_properties properties = 0,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+        VECTOR_CLASS<cl::Device> devices;
+        error = context.getInfo(CL_CONTEXT_DEVICES, &devices);
+
+        detail::errHandler(error, __CREATE_CONTEXT_ERR);
+
+        if (error != CL_SUCCESS)
+        {
+            if (err != NULL) {
+                *err = error;
+            }
+            return;
+        }
+
+        object_ = ::clCreateCommandQueue(context(), devices[0](), properties, &error);
+
+        detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
+
+        if (err != NULL) {
+            *err = error;
+        }
+
+    }
+
+    CommandQueue(
+        const Context& context,
+        const Device& device,
+        cl_command_queue_properties properties = 0,
+        cl_int* err = NULL)
+    {
+        cl_int error;
+        object_ = ::clCreateCommandQueue(
+            context(), device(), properties, &error);
+
+        detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+
+    /*! \brief Copy constructor to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    CommandQueue(const CommandQueue& queue) : detail::Wrapper<cl_type>(queue) {}
+
+    /*! \brief Copy assignment to forward copy to the superclass correctly.
+     * Required for MSVC.
+     */
+    CommandQueue& operator = (const CommandQueue &queue)
+    {
+        detail::Wrapper<cl_type>::operator=(queue);
+        return *this;
+    }
+
+#if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+    /*! \brief Move constructor to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    CommandQueue(CommandQueue&& queue) CL_HPP_NOEXCEPT : detail::Wrapper<cl_type>(std::move(queue)) {}
+
+    /*! \brief Move assignment to forward move to the superclass correctly.
+     * Required for MSVC.
+     */
+    CommandQueue& operator = (CommandQueue &&queue)
+    {
+        detail::Wrapper<cl_type>::operator=(std::move(queue));
+        return *this;
+    }
+#endif // #if defined(CL_HPP_RVALUE_REFERENCES_SUPPORTED)
+
+    static CommandQueue getDefault(cl_int * err = NULL) 
+    {
+        int state = detail::compare_exchange(
+            &default_initialized_, 
+            __DEFAULT_BEING_INITIALIZED, __DEFAULT_NOT_INITIALIZED);
+        
+        if (state & __DEFAULT_INITIALIZED) {
+            if (err != NULL) {
+                *err = default_error_;
+            }
+            return default_;
+        }
+
+        if (state & __DEFAULT_BEING_INITIALIZED) {
+              // Assume writes will propagate eventually...
+              while(default_initialized_ != __DEFAULT_INITIALIZED) {
+                  detail::fence();
+              }
+
+            if (err != NULL) {
+                *err = default_error_;
+            }
+            return default_;
+        }
+
+        cl_int error;
+
+        Context context = Context::getDefault(&error);
+        detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
+
+        if (error != CL_SUCCESS) {
+            if (err != NULL) {
+                *err = error;
+            }
+        }
+        else {
+            Device device = context.getInfo<CL_CONTEXT_DEVICES>()[0];
+
+            default_ = CommandQueue(context, device, 0, &error);
+
+            detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
+            if (err != NULL) {
+                *err = error;
+            }
+        }
+
+        detail::fence();
+
+        default_error_ = error;
+        // Assume writes will propagate eventually...
+        default_initialized_ = __DEFAULT_INITIALIZED;
+
+        detail::fence();
+
+        if (err != NULL) {
+            *err = default_error_;
+        }
+        return default_;
+
+    }
+
+    CommandQueue() { }
+
+    __CL_EXPLICIT_CONSTRUCTORS CommandQueue(const cl_command_queue& commandQueue) : detail::Wrapper<cl_type>(commandQueue) { }
+
+    CommandQueue& operator = (const cl_command_queue& rhs)
+    {
+        detail::Wrapper<cl_type>::operator=(rhs);
+        return *this;
+    }
+
+    template <typename T>
+    cl_int getInfo(cl_command_queue_info name, T* param) const
+    {
+        return detail::errHandler(
+            detail::getInfo(
+                &::clGetCommandQueueInfo, object_, name, param),
+                __GET_COMMAND_QUEUE_INFO_ERR);
+    }
+
+    template <cl_int name> typename
+    detail::param_traits<detail::cl_command_queue_info, name>::param_type
+    getInfo(cl_int* err = NULL) const
+    {
+        typename detail::param_traits<
+            detail::cl_command_queue_info, name>::param_type param;
+        cl_int result = getInfo(name, &param);
+        if (err != NULL) {
+            *err = result;
+        }
+        return param;
+    }
+
+    cl_int enqueueReadBuffer(
+        const Buffer& buffer,
+        cl_bool blocking,
+        ::size_t offset,
+        ::size_t size,
+        void* ptr,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueReadBuffer(
+                object_, buffer(), blocking, offset, size,
+                ptr,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQUEUE_READ_BUFFER_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+    cl_int enqueueWriteBuffer(
+        const Buffer& buffer,
+        cl_bool blocking,
+        ::size_t offset,
+        ::size_t size,
+        const void* ptr,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueWriteBuffer(
+                object_, buffer(), blocking, offset, size,
+                ptr,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+                __ENQUEUE_WRITE_BUFFER_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+    cl_int enqueueCopyBuffer(
+        const Buffer& src,
+        const Buffer& dst,
+        ::size_t src_offset,
+        ::size_t dst_offset,
+        ::size_t size,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueCopyBuffer(
+                object_, src(), dst(), src_offset, dst_offset, size,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQEUE_COPY_BUFFER_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+    cl_int enqueueReadBufferRect(
+        const Buffer& buffer,
+        cl_bool blocking,
+        const size_t<3>& buffer_offset,
+        const size_t<3>& host_offset,
+        const size_t<3>& region,
+        ::size_t buffer_row_pitch,
+        ::size_t buffer_slice_pitch,
+        ::size_t host_row_pitch,
+        ::size_t host_slice_pitch,
+        void *ptr,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueReadBufferRect(
+                object_, 
+                buffer(), 
+                blocking, 
+                (const ::size_t *)buffer_offset,
+                (const ::size_t *)host_offset,
+                (const ::size_t *)region,
+                buffer_row_pitch,
+                buffer_slice_pitch,
+                host_row_pitch,
+                host_slice_pitch,
+                ptr,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+                __ENQUEUE_READ_BUFFER_RECT_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+    cl_int enqueueWriteBufferRect(
+        const Buffer& buffer,
+        cl_bool blocking,
+        const size_t<3>& buffer_offset,
+        const size_t<3>& host_offset,
+        const size_t<3>& region,
+        ::size_t buffer_row_pitch,
+        ::size_t buffer_slice_pitch,
+        ::size_t host_row_pitch,
+        ::size_t host_slice_pitch,
+        void *ptr,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueWriteBufferRect(
+                object_, 
+                buffer(), 
+                blocking, 
+                (const ::size_t *)buffer_offset,
+                (const ::size_t *)host_offset,
+                (const ::size_t *)region,
+                buffer_row_pitch,
+                buffer_slice_pitch,
+                host_row_pitch,
+                host_slice_pitch,
+                ptr,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+                __ENQUEUE_WRITE_BUFFER_RECT_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+    cl_int enqueueCopyBufferRect(
+        const Buffer& src,
+        const Buffer& dst,
+        const size_t<3>& src_origin,
+        const size_t<3>& dst_origin,
+        const size_t<3>& region,
+        ::size_t src_row_pitch,
+        ::size_t src_slice_pitch,
+        ::size_t dst_row_pitch,
+        ::size_t dst_slice_pitch,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueCopyBufferRect(
+                object_, 
+                src(), 
+                dst(), 
+                (const ::size_t *)src_origin, 
+                (const ::size_t *)dst_origin, 
+                (const ::size_t *)region,
+                src_row_pitch,
+                src_slice_pitch,
+                dst_row_pitch,
+                dst_slice_pitch,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQEUE_COPY_BUFFER_RECT_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+#if defined(CL_VERSION_1_2)
+    /**
+     * Enqueue a command to fill a buffer object with a pattern
+     * of a given size. The pattern is specified a as vector.
+     * \tparam PatternType The datatype of the pattern field. 
+     *     The pattern type must be an accepted OpenCL data type.
+     */
+    template<typename PatternType>
+    cl_int enqueueFillBuffer(
+        const Buffer& buffer,
+        PatternType pattern,
+        ::size_t offset,
+        ::size_t size,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueFillBuffer(
+                object_, 
+                buffer(),
+                static_cast<void*>(&pattern),
+                sizeof(PatternType), 
+                offset, 
+                size,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+                __ENQUEUE_FILL_BUFFER_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+#endif // #if defined(CL_VERSION_1_2)
+
+    cl_int enqueueReadImage(
+        const Image& image,
+        cl_bool blocking,
+        const size_t<3>& origin,
+        const size_t<3>& region,
+        ::size_t row_pitch,
+        ::size_t slice_pitch,
+        void* ptr,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueReadImage(
+                object_, image(), blocking, (const ::size_t *) origin,
+                (const ::size_t *) region, row_pitch, slice_pitch, ptr,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQUEUE_READ_IMAGE_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+    cl_int enqueueWriteImage(
+        const Image& image,
+        cl_bool blocking,
+        const size_t<3>& origin,
+        const size_t<3>& region,
+        ::size_t row_pitch,
+        ::size_t slice_pitch,
+        void* ptr,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueWriteImage(
+                object_, image(), blocking, (const ::size_t *) origin,
+                (const ::size_t *) region, row_pitch, slice_pitch, ptr,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQUEUE_WRITE_IMAGE_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+    cl_int enqueueCopyImage(
+        const Image& src,
+        const Image& dst,
+        const size_t<3>& src_origin,
+        const size_t<3>& dst_origin,
+        const size_t<3>& region,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueCopyImage(
+                object_, src(), dst(), (const ::size_t *) src_origin,
+                (const ::size_t *)dst_origin, (const ::size_t *) region,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQUEUE_COPY_IMAGE_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+#if defined(CL_VERSION_1_2)
+    /**
+     * Enqueue a command to fill an image object with a specified color.
+     * \param fillColor is the color to use to fill the image.
+     *     This is a four component RGBA floating-point color value if
+     *     the image channel data type is not an unnormalized signed or
+     *     unsigned data type.
+     */
+    cl_int enqueueFillImage(
+        const Image& image,
+        cl_float4 fillColor,
+        const size_t<3>& origin,
+        const size_t<3>& region,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueFillImage(
+                object_, 
+                image(),
+                static_cast<void*>(&fillColor), 
+                (const ::size_t *) origin, 
+                (const ::size_t *) region,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+                __ENQUEUE_FILL_IMAGE_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+    /**
+     * Enqueue a command to fill an image object with a specified color.
+     * \param fillColor is the color to use to fill the image.
+     *     This is a four component RGBA signed integer color value if
+     *     the image channel data type is an unnormalized signed integer
+     *     type.
+     */
+    cl_int enqueueFillImage(
+        const Image& image,
+        cl_int4 fillColor,
+        const size_t<3>& origin,
+        const size_t<3>& region,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueFillImage(
+                object_, 
+                image(),
+                static_cast<void*>(&fillColor), 
+                (const ::size_t *) origin, 
+                (const ::size_t *) region,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+                __ENQUEUE_FILL_IMAGE_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+    /**
+     * Enqueue a command to fill an image object with a specified color.
+     * \param fillColor is the color to use to fill the image.
+     *     This is a four component RGBA unsigned integer color value if
+     *     the image channel data type is an unnormalized unsigned integer
+     *     type.
+     */
+    cl_int enqueueFillImage(
+        const Image& image,
+        cl_uint4 fillColor,
+        const size_t<3>& origin,
+        const size_t<3>& region,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueFillImage(
+                object_, 
+                image(),
+                static_cast<void*>(&fillColor), 
+                (const ::size_t *) origin, 
+                (const ::size_t *) region,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+                __ENQUEUE_FILL_IMAGE_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+#endif // #if defined(CL_VERSION_1_2)
+
+    cl_int enqueueCopyImageToBuffer(
+        const Image& src,
+        const Buffer& dst,
+        const size_t<3>& src_origin,
+        const size_t<3>& region,
+        ::size_t dst_offset,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueCopyImageToBuffer(
+                object_, src(), dst(), (const ::size_t *) src_origin,
+                (const ::size_t *) region, dst_offset,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQUEUE_COPY_IMAGE_TO_BUFFER_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+    cl_int enqueueCopyBufferToImage(
+        const Buffer& src,
+        const Image& dst,
+        ::size_t src_offset,
+        const size_t<3>& dst_origin,
+        const size_t<3>& region,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueCopyBufferToImage(
+                object_, src(), dst(), src_offset,
+                (const ::size_t *) dst_origin, (const ::size_t *) region,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQUEUE_COPY_BUFFER_TO_IMAGE_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+    void* enqueueMapBuffer(
+        const Buffer& buffer,
+        cl_bool blocking,
+        cl_map_flags flags,
+        ::size_t offset,
+        ::size_t size,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL,
+        cl_int* err = NULL) const
+    {
+        cl_event tmp;
+        cl_int error;
+        void * result = ::clEnqueueMapBuffer(
+            object_, buffer(), blocking, flags, offset, size,
+            (events != NULL) ? (cl_uint) events->size() : 0,
+            (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+            (event != NULL) ? &tmp : NULL,
+            &error);
+
+        detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+        if (event != NULL && error == CL_SUCCESS)
+            *event = tmp;
+
+        return result;
+    }
+
+    void* enqueueMapImage(
+        const Image& buffer,
+        cl_bool blocking,
+        cl_map_flags flags,
+        const size_t<3>& origin,
+        const size_t<3>& region,
+        ::size_t * row_pitch,
+        ::size_t * slice_pitch,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL,
+        cl_int* err = NULL) const
+    {
+        cl_event tmp;
+        cl_int error;
+        void * result = ::clEnqueueMapImage(
+            object_, buffer(), blocking, flags,
+            (const ::size_t *) origin, (const ::size_t *) region,
+            row_pitch, slice_pitch,
+            (events != NULL) ? (cl_uint) events->size() : 0,
+            (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+            (event != NULL) ? &tmp : NULL,
+            &error);
+
+        detail::errHandler(error, __ENQUEUE_MAP_IMAGE_ERR);
+        if (err != NULL) {
+              *err = error;
+        }
+        if (event != NULL && error == CL_SUCCESS)
+            *event = tmp;
+        return result;
+    }
+
+    cl_int enqueueUnmapMemObject(
+        const Memory& memory,
+        void* mapped_ptr,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueUnmapMemObject(
+                object_, memory(), mapped_ptr,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQUEUE_UNMAP_MEM_OBJECT_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+#if defined(CL_VERSION_1_2)
+    /**
+     * Enqueues a marker command which waits for either a list of events to complete, 
+     * or all previously enqueued commands to complete.
+     *
+     * Enqueues a marker command which waits for either a list of events to complete, 
+     * or if the list is empty it waits for all commands previously enqueued in command_queue 
+     * to complete before it completes. This command returns an event which can be waited on, 
+     * i.e. this event can be waited on to insure that all events either in the event_wait_list 
+     * or all previously enqueued commands, queued before this command to command_queue, 
+     * have completed.
+     */
+    cl_int enqueueMarkerWithWaitList(
+        const VECTOR_CLASS<Event> *events = 0,
+        Event *event = 0)
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueMarkerWithWaitList(
+                object_,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQUEUE_MARKER_WAIT_LIST_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+    /**
+     * A synchronization point that enqueues a barrier operation.
+     *
+     * Enqueues a barrier command which waits for either a list of events to complete, 
+     * or if the list is empty it waits for all commands previously enqueued in command_queue 
+     * to complete before it completes. This command blocks command execution, that is, any 
+     * following commands enqueued after it do not execute until it completes. This command 
+     * returns an event which can be waited on, i.e. this event can be waited on to insure that 
+     * all events either in the event_wait_list or all previously enqueued commands, queued 
+     * before this command to command_queue, have completed.
+     */
+    cl_int enqueueBarrierWithWaitList(
+        const VECTOR_CLASS<Event> *events = 0,
+        Event *event = 0)
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueBarrierWithWaitList(
+                object_,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQUEUE_BARRIER_WAIT_LIST_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+    
+    /**
+     * Enqueues a command to indicate with which device a set of memory objects
+     * should be associated.
+     */
+    cl_int enqueueMigrateMemObjects(
+        const VECTOR_CLASS<Memory> &memObjects,
+        cl_mem_migration_flags flags,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL
+        )
+    {
+        cl_event tmp;
+        
+        cl_mem* localMemObjects = static_cast<cl_mem*>(alloca(memObjects.size() * sizeof(cl_mem)));
+        for( int i = 0; i < (int)memObjects.size(); ++i ) {
+            localMemObjects[i] = memObjects[i]();
+        }
+
+
+        cl_int err = detail::errHandler(
+            ::clEnqueueMigrateMemObjects(
+                object_, 
+                (cl_uint)memObjects.size(), 
+                static_cast<const cl_mem*>(localMemObjects),
+                flags,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQUEUE_UNMAP_MEM_OBJECT_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+#endif // #if defined(CL_VERSION_1_2)
+
+    cl_int enqueueNDRangeKernel(
+        const Kernel& kernel,
+        const NDRange& offset,
+        const NDRange& global,
+        const NDRange& local = NullRange,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueNDRangeKernel(
+                object_, kernel(), (cl_uint) global.dimensions(),
+                offset.dimensions() != 0 ? (const ::size_t*) offset : NULL,
+                (const ::size_t*) global,
+                local.dimensions() != 0 ? (const ::size_t*) local : NULL,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQUEUE_NDRANGE_KERNEL_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+    cl_int enqueueTask(
+        const Kernel& kernel,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueTask(
+                object_, kernel(),
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQUEUE_TASK_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+    cl_int enqueueNativeKernel(
+        void (CL_CALLBACK *userFptr)(void *),
+        std::pair<void*, ::size_t> args,
+        const VECTOR_CLASS<Memory>* mem_objects = NULL,
+        const VECTOR_CLASS<const void*>* mem_locs = NULL,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL) const
+    {
+        cl_mem * mems = (mem_objects != NULL && mem_objects->size() > 0) 
+            ? (cl_mem*) alloca(mem_objects->size() * sizeof(cl_mem))
+            : NULL;
+
+        if (mems != NULL) {
+            for (unsigned int i = 0; i < mem_objects->size(); i++) {
+                mems[i] = ((*mem_objects)[i])();
+            }
+        }
+
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueNativeKernel(
+                object_, userFptr, args.first, args.second,
+                (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0,
+                mems,
+                (mem_locs != NULL && mem_locs->size() > 0) ? (const void **) &mem_locs->front() : NULL,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQUEUE_NATIVE_KERNEL);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+/**
+ * Deprecated APIs for 1.2
+ */
+#if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS) || (defined(CL_VERSION_1_1) && !defined(CL_VERSION_1_2)) 
+    CL_EXT_PREFIX__VERSION_1_1_DEPRECATED 
+    cl_int enqueueMarker(Event* event = NULL) const CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+    {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            ::clEnqueueMarker(
+                object_, 
+                (event != NULL) ? &tmp : NULL),
+            __ENQUEUE_MARKER_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+
+    CL_EXT_PREFIX__VERSION_1_1_DEPRECATED
+    cl_int enqueueWaitForEvents(const VECTOR_CLASS<Event>& events) const CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+    {
+        return detail::errHandler(
+            ::clEnqueueWaitForEvents(
+                object_,
+                (cl_uint) events.size(),
+                events.size() > 0 ? (const cl_event*) &events.front() : NULL),
+            __ENQUEUE_WAIT_FOR_EVENTS_ERR);
+    }
+#endif // #if defined(CL_VERSION_1_1)
+
+    cl_int enqueueAcquireGLObjects(
+         const VECTOR_CLASS<Memory>* mem_objects = NULL,
+         const VECTOR_CLASS<Event>* events = NULL,
+         Event* event = NULL) const
+     {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+             ::clEnqueueAcquireGLObjects(
+                 object_,
+                 (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0,
+                 (mem_objects != NULL && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): NULL,
+                 (events != NULL) ? (cl_uint) events->size() : 0,
+                 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                 (event != NULL) ? &tmp : NULL),
+             __ENQUEUE_ACQUIRE_GL_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+     }
+
+    cl_int enqueueReleaseGLObjects(
+         const VECTOR_CLASS<Memory>* mem_objects = NULL,
+         const VECTOR_CLASS<Event>* events = NULL,
+         Event* event = NULL) const
+     {
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+             ::clEnqueueReleaseGLObjects(
+                 object_,
+                 (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0,
+                 (mem_objects != NULL && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): NULL,
+                 (events != NULL) ? (cl_uint) events->size() : 0,
+                 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                 (event != NULL) ? &tmp : NULL),
+             __ENQUEUE_RELEASE_GL_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+     }
+
+#if defined (USE_DX_INTEROP)
+typedef CL_API_ENTRY cl_int (CL_API_CALL *PFN_clEnqueueAcquireD3D10ObjectsKHR)(
+    cl_command_queue command_queue, cl_uint num_objects,
+    const cl_mem* mem_objects, cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list, cl_event* event);
+typedef CL_API_ENTRY cl_int (CL_API_CALL *PFN_clEnqueueReleaseD3D10ObjectsKHR)(
+    cl_command_queue command_queue, cl_uint num_objects,
+    const cl_mem* mem_objects,  cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list, cl_event* event);
+
+    cl_int enqueueAcquireD3D10Objects(
+         const VECTOR_CLASS<Memory>* mem_objects = NULL,
+         const VECTOR_CLASS<Event>* events = NULL,
+         Event* event = NULL) const
+    {
+        static PFN_clEnqueueAcquireD3D10ObjectsKHR pfn_clEnqueueAcquireD3D10ObjectsKHR = NULL;
+#if defined(CL_VERSION_1_2)
+        cl_context context = getInfo<CL_QUEUE_CONTEXT>();
+        cl::Device device(getInfo<CL_QUEUE_DEVICE>());
+        cl_platform_id platform = device.getInfo<CL_DEVICE_PLATFORM>();
+        __INIT_CL_EXT_FCN_PTR_PLATFORM(platform, clEnqueueAcquireD3D10ObjectsKHR);
+#endif
+#if defined(CL_VERSION_1_1)
+        __INIT_CL_EXT_FCN_PTR(clEnqueueAcquireD3D10ObjectsKHR);
+#endif
+        
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+             pfn_clEnqueueAcquireD3D10ObjectsKHR(
+                 object_,
+                 (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0,
+                 (mem_objects != NULL && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): NULL,
+                 (events != NULL) ? (cl_uint) events->size() : 0,
+                 (events != NULL) ? (cl_event*) &events->front() : NULL,
+                 (event != NULL) ? &tmp : NULL),
+             __ENQUEUE_ACQUIRE_GL_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+     }
+
+    cl_int enqueueReleaseD3D10Objects(
+         const VECTOR_CLASS<Memory>* mem_objects = NULL,
+         const VECTOR_CLASS<Event>* events = NULL,
+         Event* event = NULL) const
+    {
+        static PFN_clEnqueueReleaseD3D10ObjectsKHR pfn_clEnqueueReleaseD3D10ObjectsKHR = NULL;
+#if defined(CL_VERSION_1_2)
+        cl_context context = getInfo<CL_QUEUE_CONTEXT>();
+        cl::Device device(getInfo<CL_QUEUE_DEVICE>());
+        cl_platform_id platform = device.getInfo<CL_DEVICE_PLATFORM>();
+        __INIT_CL_EXT_FCN_PTR_PLATFORM(platform, clEnqueueReleaseD3D10ObjectsKHR);
+#endif // #if defined(CL_VERSION_1_2)
+#if defined(CL_VERSION_1_1)
+        __INIT_CL_EXT_FCN_PTR(clEnqueueReleaseD3D10ObjectsKHR);
+#endif // #if defined(CL_VERSION_1_1)
+
+        cl_event tmp;
+        cl_int err = detail::errHandler(
+            pfn_clEnqueueReleaseD3D10ObjectsKHR(
+                object_,
+                (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0,
+                (mem_objects != NULL && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): NULL,
+                (events != NULL) ? (cl_uint) events->size() : 0,
+                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+                (event != NULL) ? &tmp : NULL),
+            __ENQUEUE_RELEASE_GL_ERR);
+
+        if (event != NULL && err == CL_SUCCESS)
+            *event = tmp;
+
+        return err;
+    }
+#endif
+
+/**
+ * Deprecated APIs for 1.2
+ */
+#if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS) || (defined(CL_VERSION_1_1) && !defined(CL_VERSION_1_2)) 
+    CL_EXT_PREFIX__VERSION_1_1_DEPRECATED
+    cl_int enqueueBarrier() const CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+    {
+        return detail::errHandler(
+            ::clEnqueueBarrier(object_),
+            __ENQUEUE_BARRIER_ERR);
+    }
+#endif // #if defined(CL_VERSION_1_1)
+
+    cl_int flush() const
+    {
+        return detail::errHandler(::clFlush(object_), __FLUSH_ERR);
+    }
+
+    cl_int finish() const
+    {
+        return detail::errHandler(::clFinish(object_), __FINISH_ERR);
+    }
+};
+
+#ifdef _WIN32
+#ifdef CL_HPP_CPP11_ATOMICS_SUPPORTED
+__declspec(selectany) std::atomic<int> CommandQueue::default_initialized_;
+#else // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+__declspec(selectany) volatile int CommandQueue::default_initialized_ = __DEFAULT_NOT_INITIALIZED;
+#endif // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+__declspec(selectany) CommandQueue CommandQueue::default_;
+__declspec(selectany) volatile cl_int CommandQueue::default_error_ = CL_SUCCESS;
+#else // !_WIN32
+#ifdef CL_HPP_CPP11_ATOMICS_SUPPORTED
+__attribute__((weak)) std::atomic<int> CommandQueue::default_initialized_;
+#else // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+__attribute__((weak)) volatile int CommandQueue::default_initialized_ = __DEFAULT_NOT_INITIALIZED;
+#endif // !CL_HPP_CPP11_ATOMICS_SUPPORTED
+__attribute__((weak)) CommandQueue CommandQueue::default_;
+__attribute__((weak)) volatile cl_int CommandQueue::default_error_ = CL_SUCCESS;
+#endif // !_WIN32
+
+template< typename IteratorType >
+Buffer::Buffer(
+    const Context &context,
+    IteratorType startIterator,
+    IteratorType endIterator,
+    bool readOnly,
+    bool useHostPtr,
+    cl_int* err)
+{
+    typedef typename std::iterator_traits<IteratorType>::value_type DataType;
+    cl_int error;
+
+    cl_mem_flags flags = 0;
+    if( readOnly ) {
+        flags |= CL_MEM_READ_ONLY;
+    }
+    else {
+        flags |= CL_MEM_READ_WRITE;
+    }
+    if( useHostPtr ) {
+        flags |= CL_MEM_USE_HOST_PTR;
+    }
+    
+    ::size_t size = sizeof(DataType)*(endIterator - startIterator);
+
+    if( useHostPtr ) {
+        object_ = ::clCreateBuffer(context(), flags, size, static_cast<DataType*>(&*startIterator), &error);
+    } else {
+        object_ = ::clCreateBuffer(context(), flags, size, 0, &error);
+    }
+
+    detail::errHandler(error, __CREATE_BUFFER_ERR);
+    if (err != NULL) {
+        *err = error;
+    }
+
+    if( !useHostPtr ) {
+        CommandQueue queue(context, 0, &error);
+        detail::errHandler(error, __CREATE_BUFFER_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+
+        error = cl::copy(queue, startIterator, endIterator, *this);
+        detail::errHandler(error, __CREATE_BUFFER_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+}
+
+template< typename IteratorType >
+Buffer::Buffer(
+    const CommandQueue &queue,
+    IteratorType startIterator,
+    IteratorType endIterator,
+    bool readOnly,
+    bool useHostPtr,
+    cl_int* err)
+{
+    typedef typename std::iterator_traits<IteratorType>::value_type DataType;
+    cl_int error;
+
+    cl_mem_flags flags = 0;
+    if (readOnly) {
+        flags |= CL_MEM_READ_ONLY;
+    }
+    else {
+        flags |= CL_MEM_READ_WRITE;
+    }
+    if (useHostPtr) {
+        flags |= CL_MEM_USE_HOST_PTR;
+    }
+
+    ::size_t size = sizeof(DataType)*(endIterator - startIterator);
+
+    Context context = queue.getInfo<CL_QUEUE_CONTEXT>();
+
+    if (useHostPtr) {
+        object_ = ::clCreateBuffer(context(), flags, size, static_cast<DataType*>(&*startIterator), &error);
+    }
+    else {
+        object_ = ::clCreateBuffer(context(), flags, size, 0, &error);
+    }
+
+    detail::errHandler(error, __CREATE_BUFFER_ERR);
+    if (err != NULL) {
+        *err = error;
+    }
+
+    if (!useHostPtr) {
+        error = cl::copy(queue, startIterator, endIterator, *this);
+        detail::errHandler(error, __CREATE_BUFFER_ERR);
+        if (err != NULL) {
+            *err = error;
+        }
+    }
+}
+
+inline cl_int enqueueReadBuffer(
+    const Buffer& buffer,
+    cl_bool blocking,
+    ::size_t offset,
+    ::size_t size,
+    void* ptr,
+    const VECTOR_CLASS<Event>* events = NULL,
+    Event* event = NULL)
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+
+    if (error != CL_SUCCESS) {
+        return error;
+    }
+
+    return queue.enqueueReadBuffer(buffer, blocking, offset, size, ptr, events, event);
+}
+
+inline cl_int enqueueWriteBuffer(
+        const Buffer& buffer,
+        cl_bool blocking,
+        ::size_t offset,
+        ::size_t size,
+        const void* ptr,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL)
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+
+    if (error != CL_SUCCESS) {
+        return error;
+    }
+
+    return queue.enqueueWriteBuffer(buffer, blocking, offset, size, ptr, events, event);
+}
+
+inline void* enqueueMapBuffer(
+        const Buffer& buffer,
+        cl_bool blocking,
+        cl_map_flags flags,
+        ::size_t offset,
+        ::size_t size,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL,
+        cl_int* err = NULL)
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+    detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
+    if (err != NULL) {
+        *err = error;
+    }
+
+    void * result = ::clEnqueueMapBuffer(
+            queue(), buffer(), blocking, flags, offset, size,
+            (events != NULL) ? (cl_uint) events->size() : 0,
+            (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+            (cl_event*) event,
+            &error);
+
+    detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
+    if (err != NULL) {
+        *err = error;
+    }
+    return result;
+}
+
+inline cl_int enqueueUnmapMemObject(
+    const Memory& memory,
+    void* mapped_ptr,
+    const VECTOR_CLASS<Event>* events = NULL,
+    Event* event = NULL)
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+    detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
+    if (error != CL_SUCCESS) {
+        return error;
+    }
+
+    cl_event tmp;
+    cl_int err = detail::errHandler(
+        ::clEnqueueUnmapMemObject(
+            queue(), memory(), mapped_ptr,
+            (events != NULL) ? (cl_uint) events->size() : 0,
+            (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
+            (event != NULL) ? &tmp : NULL),
+        __ENQUEUE_UNMAP_MEM_OBJECT_ERR);
+
+    if (event != NULL && err == CL_SUCCESS)
+        *event = tmp;
+
+    return err;
+}
+
+inline cl_int enqueueCopyBuffer(
+        const Buffer& src,
+        const Buffer& dst,
+        ::size_t src_offset,
+        ::size_t dst_offset,
+        ::size_t size,
+        const VECTOR_CLASS<Event>* events = NULL,
+        Event* event = NULL)
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+
+    if (error != CL_SUCCESS) {
+        return error;
+    }
+
+    return queue.enqueueCopyBuffer(src, dst, src_offset, dst_offset, size, events, event);
+}
+
+/**
+ * Blocking copy operation between iterators and a buffer.
+ * Host to Device.
+ * Uses default command queue.
+ */
+template< typename IteratorType >
+inline cl_int copy( IteratorType startIterator, IteratorType endIterator, cl::Buffer &buffer )
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+    if (error != CL_SUCCESS)
+        return error;
+
+    return cl::copy(queue, startIterator, endIterator, buffer);
+}
+
+/**
+ * Blocking copy operation between iterators and a buffer.
+ * Device to Host.
+ * Uses default command queue.
+ */
+template< typename IteratorType >
+inline cl_int copy( const cl::Buffer &buffer, IteratorType startIterator, IteratorType endIterator )
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+    if (error != CL_SUCCESS)
+        return error;
+
+    return cl::copy(queue, buffer, startIterator, endIterator);
+}
+
+/**
+ * Blocking copy operation between iterators and a buffer.
+ * Host to Device.
+ * Uses specified queue.
+ */
+template< typename IteratorType >
+inline cl_int copy( const CommandQueue &queue, IteratorType startIterator, IteratorType endIterator, cl::Buffer &buffer )
+{
+    typedef typename std::iterator_traits<IteratorType>::value_type DataType;
+    cl_int error;
+    
+    ::size_t length = endIterator-startIterator;
+    ::size_t byteLength = length*sizeof(DataType);
+
+    DataType *pointer = 
+        static_cast<DataType*>(queue.enqueueMapBuffer(buffer, CL_TRUE, CL_MAP_WRITE, 0, byteLength, 0, 0, &error));
+    // if exceptions enabled, enqueueMapBuffer will throw
+    if( error != CL_SUCCESS ) {
+        return error;
+    }
+#if defined(_MSC_VER)
+    std::copy(
+        startIterator, 
+        endIterator, 
+        stdext::checked_array_iterator<DataType*>(
+            pointer, length));
+#else
+    std::copy(startIterator, endIterator, pointer);
+#endif
+    Event endEvent;
+    error = queue.enqueueUnmapMemObject(buffer, pointer, 0, &endEvent);
+    // if exceptions enabled, enqueueUnmapMemObject will throw
+    if( error != CL_SUCCESS ) { 
+        return error;
+    }
+    endEvent.wait();
+    return CL_SUCCESS;
+}
+
+/**
+ * Blocking copy operation between iterators and a buffer.
+ * Device to Host.
+ * Uses specified queue.
+ */
+template< typename IteratorType >
+inline cl_int copy( const CommandQueue &queue, const cl::Buffer &buffer, IteratorType startIterator, IteratorType endIterator )
+{
+    typedef typename std::iterator_traits<IteratorType>::value_type DataType;
+    cl_int error;
+        
+    ::size_t length = endIterator-startIterator;
+    ::size_t byteLength = length*sizeof(DataType);
+
+    DataType *pointer = 
+        static_cast<DataType*>(queue.enqueueMapBuffer(buffer, CL_TRUE, CL_MAP_READ, 0, byteLength, 0, 0, &error));
+    // if exceptions enabled, enqueueMapBuffer will throw
+    if( error != CL_SUCCESS ) {
+        return error;
+    }
+    std::copy(pointer, pointer + length, startIterator);
+    Event endEvent;
+    error = queue.enqueueUnmapMemObject(buffer, pointer, 0, &endEvent);
+    // if exceptions enabled, enqueueUnmapMemObject will throw
+    if( error != CL_SUCCESS ) { 
+        return error;
+    }
+    endEvent.wait();
+    return CL_SUCCESS;
+}
+
+#if defined(CL_VERSION_1_1)
+inline cl_int enqueueReadBufferRect(
+    const Buffer& buffer,
+    cl_bool blocking,
+    const size_t<3>& buffer_offset,
+    const size_t<3>& host_offset,
+    const size_t<3>& region,
+    ::size_t buffer_row_pitch,
+    ::size_t buffer_slice_pitch,
+    ::size_t host_row_pitch,
+    ::size_t host_slice_pitch,
+    void *ptr,
+    const VECTOR_CLASS<Event>* events = NULL,
+    Event* event = NULL)
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+
+    if (error != CL_SUCCESS) {
+        return error;
+    }
+
+    return queue.enqueueReadBufferRect(
+        buffer, 
+        blocking, 
+        buffer_offset, 
+        host_offset,
+        region,
+        buffer_row_pitch,
+        buffer_slice_pitch,
+        host_row_pitch,
+        host_slice_pitch,
+        ptr, 
+        events, 
+        event);
+}
+
+inline cl_int enqueueWriteBufferRect(
+    const Buffer& buffer,
+    cl_bool blocking,
+    const size_t<3>& buffer_offset,
+    const size_t<3>& host_offset,
+    const size_t<3>& region,
+    ::size_t buffer_row_pitch,
+    ::size_t buffer_slice_pitch,
+    ::size_t host_row_pitch,
+    ::size_t host_slice_pitch,
+    void *ptr,
+    const VECTOR_CLASS<Event>* events = NULL,
+    Event* event = NULL)
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+
+    if (error != CL_SUCCESS) {
+        return error;
+    }
+
+    return queue.enqueueWriteBufferRect(
+        buffer, 
+        blocking, 
+        buffer_offset, 
+        host_offset,
+        region,
+        buffer_row_pitch,
+        buffer_slice_pitch,
+        host_row_pitch,
+        host_slice_pitch,
+        ptr, 
+        events, 
+        event);
+}
+
+inline cl_int enqueueCopyBufferRect(
+    const Buffer& src,
+    const Buffer& dst,
+    const size_t<3>& src_origin,
+    const size_t<3>& dst_origin,
+    const size_t<3>& region,
+    ::size_t src_row_pitch,
+    ::size_t src_slice_pitch,
+    ::size_t dst_row_pitch,
+    ::size_t dst_slice_pitch,
+    const VECTOR_CLASS<Event>* events = NULL,
+    Event* event = NULL)
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+
+    if (error != CL_SUCCESS) {
+        return error;
+    }
+
+    return queue.enqueueCopyBufferRect(
+        src,
+        dst,
+        src_origin,
+        dst_origin,
+        region,
+        src_row_pitch,
+        src_slice_pitch,
+        dst_row_pitch,
+        dst_slice_pitch,
+        events, 
+        event);
+}
+#endif
+
+inline cl_int enqueueReadImage(
+    const Image& image,
+    cl_bool blocking,
+    const size_t<3>& origin,
+    const size_t<3>& region,
+    ::size_t row_pitch,
+    ::size_t slice_pitch,
+    void* ptr,
+    const VECTOR_CLASS<Event>* events = NULL,
+    Event* event = NULL) 
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+
+    if (error != CL_SUCCESS) {
+        return error;
+    }
+
+    return queue.enqueueReadImage(
+        image,
+        blocking,
+        origin,
+        region,
+        row_pitch,
+        slice_pitch,
+        ptr,
+        events, 
+        event);
+}
+
+inline cl_int enqueueWriteImage(
+    const Image& image,
+    cl_bool blocking,
+    const size_t<3>& origin,
+    const size_t<3>& region,
+    ::size_t row_pitch,
+    ::size_t slice_pitch,
+    void* ptr,
+    const VECTOR_CLASS<Event>* events = NULL,
+    Event* event = NULL)
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+
+    if (error != CL_SUCCESS) {
+        return error;
+    }
+
+    return queue.enqueueWriteImage(
+        image,
+        blocking,
+        origin,
+        region,
+        row_pitch,
+        slice_pitch,
+        ptr,
+        events, 
+        event);
+}
+
+inline cl_int enqueueCopyImage(
+    const Image& src,
+    const Image& dst,
+    const size_t<3>& src_origin,
+    const size_t<3>& dst_origin,
+    const size_t<3>& region,
+    const VECTOR_CLASS<Event>* events = NULL,
+    Event* event = NULL)
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+
+    if (error != CL_SUCCESS) {
+        return error;
+    }
+
+    return queue.enqueueCopyImage(
+        src,
+        dst,
+        src_origin,
+        dst_origin,
+        region,
+        events,
+        event);
+}
+
+inline cl_int enqueueCopyImageToBuffer(
+    const Image& src,
+    const Buffer& dst,
+    const size_t<3>& src_origin,
+    const size_t<3>& region,
+    ::size_t dst_offset,
+    const VECTOR_CLASS<Event>* events = NULL,
+    Event* event = NULL)
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+
+    if (error != CL_SUCCESS) {
+        return error;
+    }
+
+    return queue.enqueueCopyImageToBuffer(
+        src,
+        dst,
+        src_origin,
+        region,
+        dst_offset,
+        events,
+        event);
+}
+
+inline cl_int enqueueCopyBufferToImage(
+    const Buffer& src,
+    const Image& dst,
+    ::size_t src_offset,
+    const size_t<3>& dst_origin,
+    const size_t<3>& region,
+    const VECTOR_CLASS<Event>* events = NULL,
+    Event* event = NULL)
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+
+    if (error != CL_SUCCESS) {
+        return error;
+    }
+
+    return queue.enqueueCopyBufferToImage(
+        src,
+        dst,
+        src_offset,
+        dst_origin,
+        region,
+        events,
+        event);
+}
+
+
+inline cl_int flush(void)
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+
+    if (error != CL_SUCCESS) {
+        return error;
+    }
+
+    return queue.flush();
+}
+
+inline cl_int finish(void)
+{
+    cl_int error;
+    CommandQueue queue = CommandQueue::getDefault(&error);
+
+    if (error != CL_SUCCESS) {
+        return error;
+    } 
+
+
+    return queue.finish();
+}
+
+// Kernel Functor support
+// New interface as of September 2011
+// Requires the C++11 std::tr1::function (note do not support TR1)
+// Visual Studio 2010 and GCC 4.2
+
+struct EnqueueArgs
+{
+    CommandQueue queue_;
+    const NDRange offset_;
+    const NDRange global_;
+    const NDRange local_;
+    VECTOR_CLASS<Event> events_;
+
+    EnqueueArgs(NDRange global) : 
+      queue_(CommandQueue::getDefault()),
+      offset_(NullRange), 
+      global_(global),
+      local_(NullRange)
+    {
+
+    }
+
+    EnqueueArgs(NDRange global, NDRange local) : 
+      queue_(CommandQueue::getDefault()),
+      offset_(NullRange), 
+      global_(global),
+      local_(local)
+    {
+
+    }
+
+    EnqueueArgs(NDRange offset, NDRange global, NDRange local) : 
+      queue_(CommandQueue::getDefault()),
+      offset_(offset), 
+      global_(global),
+      local_(local)
+    {
+
+    }
+
+    EnqueueArgs(Event e, NDRange global) : 
+      queue_(CommandQueue::getDefault()),
+      offset_(NullRange), 
+      global_(global),
+      local_(NullRange)
+    {
+        events_.push_back(e);
+    }
+
+    EnqueueArgs(Event e, NDRange global, NDRange local) : 
+      queue_(CommandQueue::getDefault()),
+      offset_(NullRange), 
+      global_(global),
+      local_(local)
+    {
+        events_.push_back(e);
+    }
+
+    EnqueueArgs(Event e, NDRange offset, NDRange global, NDRange local) : 
+      queue_(CommandQueue::getDefault()),
+      offset_(offset), 
+      global_(global),
+      local_(local)
+    {
+        events_.push_back(e);
+    }
+
+    EnqueueArgs(const VECTOR_CLASS<Event> &events, NDRange global) : 
+      queue_(CommandQueue::getDefault()),
+      offset_(NullRange), 
+      global_(global),
+      local_(NullRange),
+      events_(events)
+    {
+
+    }
+
+    EnqueueArgs(const VECTOR_CLASS<Event> &events, NDRange global, NDRange local) : 
+      queue_(CommandQueue::getDefault()),
+      offset_(NullRange), 
+      global_(global),
+      local_(local),
+      events_(events)
+    {
+
+    }
+
+    EnqueueArgs(const VECTOR_CLASS<Event> &events, NDRange offset, NDRange global, NDRange local) : 
+      queue_(CommandQueue::getDefault()),
+      offset_(offset), 
+      global_(global),
+      local_(local),
+      events_(events)
+    {
+
+    }
+
+    EnqueueArgs(CommandQueue &queue, NDRange global) : 
+      queue_(queue),
+      offset_(NullRange), 
+      global_(global),
+      local_(NullRange)
+    {
+
+    }
+
+    EnqueueArgs(CommandQueue &queue, NDRange global, NDRange local) : 
+      queue_(queue),
+      offset_(NullRange), 
+      global_(global),
+      local_(local)
+    {
+
+    }
+
+    EnqueueArgs(CommandQueue &queue, NDRange offset, NDRange global, NDRange local) : 
+      queue_(queue),
+      offset_(offset), 
+      global_(global),
+      local_(local)
+    {
+
+    }
+
+    EnqueueArgs(CommandQueue &queue, Event e, NDRange global) : 
+      queue_(queue),
+      offset_(NullRange), 
+      global_(global),
+      local_(NullRange)
+    {
+        events_.push_back(e);
+    }
+
+    EnqueueArgs(CommandQueue &queue, Event e, NDRange global, NDRange local) : 
+      queue_(queue),
+      offset_(NullRange), 
+      global_(global),
+      local_(local)
+    {
+        events_.push_back(e);
+    }
+
+    EnqueueArgs(CommandQueue &queue, Event e, NDRange offset, NDRange global, NDRange local) : 
+      queue_(queue),
+      offset_(offset), 
+      global_(global),
+      local_(local)
+    {
+        events_.push_back(e);
+    }
+
+    EnqueueArgs(CommandQueue &queue, const VECTOR_CLASS<Event> &events, NDRange global) : 
+      queue_(queue),
+      offset_(NullRange), 
+      global_(global),
+      local_(NullRange),
+      events_(events)
+    {
+
+    }
+
+    EnqueueArgs(CommandQueue &queue, const VECTOR_CLASS<Event> &events, NDRange global, NDRange local) : 
+      queue_(queue),
+      offset_(NullRange), 
+      global_(global),
+      local_(local),
+      events_(events)
+    {
+
+    }
+
+    EnqueueArgs(CommandQueue &queue, const VECTOR_CLASS<Event> &events, NDRange offset, NDRange global, NDRange local) : 
+      queue_(queue),
+      offset_(offset), 
+      global_(global),
+      local_(local),
+      events_(events)
+    {
+
+    }
+};
+
+namespace detail {
+
+class NullType {};
+
+template<int index, typename T0>
+struct SetArg
+{
+    static void set (Kernel kernel, T0 arg)
+    {
+        kernel.setArg(index, arg);
+    }
+};  
+
+template<int index>
+struct SetArg<index, NullType>
+{
+    static void set (Kernel, NullType)
+    { 
+    }
+};
+
+template <
+   typename T0,   typename T1,   typename T2,   typename T3,
+   typename T4,   typename T5,   typename T6,   typename T7,
+   typename T8,   typename T9,   typename T10,   typename T11,
+   typename T12,   typename T13,   typename T14,   typename T15,
+   typename T16,   typename T17,   typename T18,   typename T19,
+   typename T20,   typename T21,   typename T22,   typename T23,
+   typename T24,   typename T25,   typename T26,   typename T27,
+   typename T28,   typename T29,   typename T30,   typename T31
+>
+class KernelFunctorGlobal
+{
+private:
+    Kernel kernel_;
+
+public:
+   KernelFunctorGlobal(
+        Kernel kernel) :
+            kernel_(kernel)
+    {}
+
+   KernelFunctorGlobal(
+        const Program& program,
+        const STRING_CLASS name,
+        cl_int * err = NULL) :
+            kernel_(program, name.c_str(), err)
+    {}
+
+    Event operator() (
+        const EnqueueArgs& args,
+        T0 t0,
+        T1 t1 = NullType(),
+        T2 t2 = NullType(),
+        T3 t3 = NullType(),
+        T4 t4 = NullType(),
+        T5 t5 = NullType(),
+        T6 t6 = NullType(),
+        T7 t7 = NullType(),
+        T8 t8 = NullType(),
+        T9 t9 = NullType(),
+        T10 t10 = NullType(),
+        T11 t11 = NullType(),
+        T12 t12 = NullType(),
+        T13 t13 = NullType(),
+        T14 t14 = NullType(),
+        T15 t15 = NullType(),
+        T16 t16 = NullType(),
+        T17 t17 = NullType(),
+        T18 t18 = NullType(),
+        T19 t19 = NullType(),
+        T20 t20 = NullType(),
+        T21 t21 = NullType(),
+        T22 t22 = NullType(),
+        T23 t23 = NullType(),
+        T24 t24 = NullType(),
+        T25 t25 = NullType(),
+        T26 t26 = NullType(),
+        T27 t27 = NullType(),
+        T28 t28 = NullType(),
+        T29 t29 = NullType(),
+        T30 t30 = NullType(),
+        T31 t31 = NullType()
+        )
+    {
+        Event event;
+        SetArg<0, T0>::set(kernel_, t0);
+        SetArg<1, T1>::set(kernel_, t1);
+        SetArg<2, T2>::set(kernel_, t2);
+        SetArg<3, T3>::set(kernel_, t3);
+        SetArg<4, T4>::set(kernel_, t4);
+        SetArg<5, T5>::set(kernel_, t5);
+        SetArg<6, T6>::set(kernel_, t6);
+        SetArg<7, T7>::set(kernel_, t7);
+        SetArg<8, T8>::set(kernel_, t8);
+        SetArg<9, T9>::set(kernel_, t9);
+        SetArg<10, T10>::set(kernel_, t10);
+        SetArg<11, T11>::set(kernel_, t11);
+        SetArg<12, T12>::set(kernel_, t12);
+        SetArg<13, T13>::set(kernel_, t13);
+        SetArg<14, T14>::set(kernel_, t14);
+        SetArg<15, T15>::set(kernel_, t15);
+        SetArg<16, T16>::set(kernel_, t16);
+        SetArg<17, T17>::set(kernel_, t17);
+        SetArg<18, T18>::set(kernel_, t18);
+        SetArg<19, T19>::set(kernel_, t19);
+        SetArg<20, T20>::set(kernel_, t20);
+        SetArg<21, T21>::set(kernel_, t21);
+        SetArg<22, T22>::set(kernel_, t22);
+        SetArg<23, T23>::set(kernel_, t23);
+        SetArg<24, T24>::set(kernel_, t24);
+        SetArg<25, T25>::set(kernel_, t25);
+        SetArg<26, T26>::set(kernel_, t26);
+        SetArg<27, T27>::set(kernel_, t27);
+        SetArg<28, T28>::set(kernel_, t28);
+        SetArg<29, T29>::set(kernel_, t29);
+        SetArg<30, T30>::set(kernel_, t30);
+        SetArg<31, T31>::set(kernel_, t31);
+        
+        args.queue_.enqueueNDRangeKernel(
+            kernel_,
+            args.offset_,
+            args.global_,
+            args.local_,
+            &args.events_,
+            &event);
+        
+        return event;
+    }
+
+};
+
+//------------------------------------------------------------------------------------------------------
+
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16,
+	typename T17,
+	typename T18,
+	typename T19,
+	typename T20,
+	typename T21,
+	typename T22,
+	typename T23,
+	typename T24,
+	typename T25,
+	typename T26,
+	typename T27,
+	typename T28,
+	typename T29,
+	typename T30,
+	typename T31>
+struct functionImplementation_
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24,
+		T25,
+		T26,
+		T27,
+		T28,
+		T29,
+		T30,
+		T31> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 32))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24,
+		T25,
+		T26,
+		T27,
+		T28,
+		T29,
+		T30,
+		T31);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16,
+		T17 arg17,
+		T18 arg18,
+		T19 arg19,
+		T20 arg20,
+		T21 arg21,
+		T22 arg22,
+		T23 arg23,
+		T24 arg24,
+		T25 arg25,
+		T26 arg26,
+		T27 arg27,
+		T28 arg28,
+		T29 arg29,
+		T30 arg30,
+		T31 arg31)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16,
+			arg17,
+			arg18,
+			arg19,
+			arg20,
+			arg21,
+			arg22,
+			arg23,
+			arg24,
+			arg25,
+			arg26,
+			arg27,
+			arg28,
+			arg29,
+			arg30,
+			arg31);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16,
+	typename T17,
+	typename T18,
+	typename T19,
+	typename T20,
+	typename T21,
+	typename T22,
+	typename T23,
+	typename T24,
+	typename T25,
+	typename T26,
+	typename T27,
+	typename T28,
+	typename T29,
+	typename T30>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24,
+		T25,
+		T26,
+		T27,
+		T28,
+		T29,
+		T30,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 31))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24,
+		T25,
+		T26,
+		T27,
+		T28,
+		T29,
+		T30);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16,
+		T17 arg17,
+		T18 arg18,
+		T19 arg19,
+		T20 arg20,
+		T21 arg21,
+		T22 arg22,
+		T23 arg23,
+		T24 arg24,
+		T25 arg25,
+		T26 arg26,
+		T27 arg27,
+		T28 arg28,
+		T29 arg29,
+		T30 arg30)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16,
+			arg17,
+			arg18,
+			arg19,
+			arg20,
+			arg21,
+			arg22,
+			arg23,
+			arg24,
+			arg25,
+			arg26,
+			arg27,
+			arg28,
+			arg29,
+			arg30);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16,
+	typename T17,
+	typename T18,
+	typename T19,
+	typename T20,
+	typename T21,
+	typename T22,
+	typename T23,
+	typename T24,
+	typename T25,
+	typename T26,
+	typename T27,
+	typename T28,
+	typename T29>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24,
+		T25,
+		T26,
+		T27,
+		T28,
+		T29,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 30))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24,
+		T25,
+		T26,
+		T27,
+		T28,
+		T29);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16,
+		T17 arg17,
+		T18 arg18,
+		T19 arg19,
+		T20 arg20,
+		T21 arg21,
+		T22 arg22,
+		T23 arg23,
+		T24 arg24,
+		T25 arg25,
+		T26 arg26,
+		T27 arg27,
+		T28 arg28,
+		T29 arg29)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16,
+			arg17,
+			arg18,
+			arg19,
+			arg20,
+			arg21,
+			arg22,
+			arg23,
+			arg24,
+			arg25,
+			arg26,
+			arg27,
+			arg28,
+			arg29);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16,
+	typename T17,
+	typename T18,
+	typename T19,
+	typename T20,
+	typename T21,
+	typename T22,
+	typename T23,
+	typename T24,
+	typename T25,
+	typename T26,
+	typename T27,
+	typename T28>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24,
+		T25,
+		T26,
+		T27,
+		T28,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 29))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24,
+		T25,
+		T26,
+		T27,
+		T28);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16,
+		T17 arg17,
+		T18 arg18,
+		T19 arg19,
+		T20 arg20,
+		T21 arg21,
+		T22 arg22,
+		T23 arg23,
+		T24 arg24,
+		T25 arg25,
+		T26 arg26,
+		T27 arg27,
+		T28 arg28)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16,
+			arg17,
+			arg18,
+			arg19,
+			arg20,
+			arg21,
+			arg22,
+			arg23,
+			arg24,
+			arg25,
+			arg26,
+			arg27,
+			arg28);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16,
+	typename T17,
+	typename T18,
+	typename T19,
+	typename T20,
+	typename T21,
+	typename T22,
+	typename T23,
+	typename T24,
+	typename T25,
+	typename T26,
+	typename T27>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24,
+		T25,
+		T26,
+		T27,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 28))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24,
+		T25,
+		T26,
+		T27);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16,
+		T17 arg17,
+		T18 arg18,
+		T19 arg19,
+		T20 arg20,
+		T21 arg21,
+		T22 arg22,
+		T23 arg23,
+		T24 arg24,
+		T25 arg25,
+		T26 arg26,
+		T27 arg27)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16,
+			arg17,
+			arg18,
+			arg19,
+			arg20,
+			arg21,
+			arg22,
+			arg23,
+			arg24,
+			arg25,
+			arg26,
+			arg27);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16,
+	typename T17,
+	typename T18,
+	typename T19,
+	typename T20,
+	typename T21,
+	typename T22,
+	typename T23,
+	typename T24,
+	typename T25,
+	typename T26>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24,
+		T25,
+		T26,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 27))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24,
+		T25,
+		T26);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16,
+		T17 arg17,
+		T18 arg18,
+		T19 arg19,
+		T20 arg20,
+		T21 arg21,
+		T22 arg22,
+		T23 arg23,
+		T24 arg24,
+		T25 arg25,
+		T26 arg26)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16,
+			arg17,
+			arg18,
+			arg19,
+			arg20,
+			arg21,
+			arg22,
+			arg23,
+			arg24,
+			arg25,
+			arg26);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16,
+	typename T17,
+	typename T18,
+	typename T19,
+	typename T20,
+	typename T21,
+	typename T22,
+	typename T23,
+	typename T24,
+	typename T25>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24,
+		T25,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 26))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24,
+		T25);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16,
+		T17 arg17,
+		T18 arg18,
+		T19 arg19,
+		T20 arg20,
+		T21 arg21,
+		T22 arg22,
+		T23 arg23,
+		T24 arg24,
+		T25 arg25)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16,
+			arg17,
+			arg18,
+			arg19,
+			arg20,
+			arg21,
+			arg22,
+			arg23,
+			arg24,
+			arg25);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16,
+	typename T17,
+	typename T18,
+	typename T19,
+	typename T20,
+	typename T21,
+	typename T22,
+	typename T23,
+	typename T24>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 25))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		T24);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16,
+		T17 arg17,
+		T18 arg18,
+		T19 arg19,
+		T20 arg20,
+		T21 arg21,
+		T22 arg22,
+		T23 arg23,
+		T24 arg24)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16,
+			arg17,
+			arg18,
+			arg19,
+			arg20,
+			arg21,
+			arg22,
+			arg23,
+			arg24);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16,
+	typename T17,
+	typename T18,
+	typename T19,
+	typename T20,
+	typename T21,
+	typename T22,
+	typename T23>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 24))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		T23);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16,
+		T17 arg17,
+		T18 arg18,
+		T19 arg19,
+		T20 arg20,
+		T21 arg21,
+		T22 arg22,
+		T23 arg23)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16,
+			arg17,
+			arg18,
+			arg19,
+			arg20,
+			arg21,
+			arg22,
+			arg23);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16,
+	typename T17,
+	typename T18,
+	typename T19,
+	typename T20,
+	typename T21,
+	typename T22>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 23))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		T22);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16,
+		T17 arg17,
+		T18 arg18,
+		T19 arg19,
+		T20 arg20,
+		T21 arg21,
+		T22 arg22)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16,
+			arg17,
+			arg18,
+			arg19,
+			arg20,
+			arg21,
+			arg22);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16,
+	typename T17,
+	typename T18,
+	typename T19,
+	typename T20,
+	typename T21>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 22))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		T21);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16,
+		T17 arg17,
+		T18 arg18,
+		T19 arg19,
+		T20 arg20,
+		T21 arg21)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16,
+			arg17,
+			arg18,
+			arg19,
+			arg20,
+			arg21);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16,
+	typename T17,
+	typename T18,
+	typename T19,
+	typename T20>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 21))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		T20);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16,
+		T17 arg17,
+		T18 arg18,
+		T19 arg19,
+		T20 arg20)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16,
+			arg17,
+			arg18,
+			arg19,
+			arg20);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16,
+	typename T17,
+	typename T18,
+	typename T19>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 20))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		T19);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16,
+		T17 arg17,
+		T18 arg18,
+		T19 arg19)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16,
+			arg17,
+			arg18,
+			arg19);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16,
+	typename T17,
+	typename T18>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 19))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		T18);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16,
+		T17 arg17,
+		T18 arg18)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16,
+			arg17,
+			arg18);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16,
+	typename T17>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 18))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		T17);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16,
+		T17 arg17)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16,
+			arg17);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15,
+	typename T16>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 17))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		T16);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15,
+		T16 arg16)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15,
+			arg16);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14,
+	typename T15>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 16))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		T15);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14,
+		T15 arg15)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14,
+			arg15);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13,
+	typename T14>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 15))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		T14);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13,
+		T14 arg14)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13,
+			arg14);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12,
+	typename T13>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 14))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		T13);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12,
+		T13 arg13)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12,
+			arg13);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11,
+	typename T12>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 13))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		T12);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11,
+		T12 arg12)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11,
+			arg12);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10,
+	typename T11>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 12))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		T11);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10,
+		T11 arg11)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10,
+			arg11);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9,
+	typename T10>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 11))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		T10);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9,
+		T10 arg10)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9,
+			arg10);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8,
+	typename T9>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 10))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		T9);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8,
+		T9 arg9)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8,
+			arg9);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7,
+	typename T8>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 9))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		T8);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7,
+		T8 arg8)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7,
+			arg8);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6,
+	typename T7>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 8))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		T7);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6,
+		T7 arg7)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6,
+			arg7);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5,
+	typename T6>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 7))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		T6);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5,
+		T6 arg6)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5,
+			arg6);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4,
+	typename T5>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 6))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		T5);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4,
+		T5 arg5)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4,
+			arg5);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3,
+	typename T4>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		T4,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 5))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3,
+		T4);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3,
+		T4 arg4)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2,
+	typename T3>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	T3,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		T3,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 4))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2,
+		T3);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2,
+		T3 arg3)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2,
+			arg3);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1,
+	typename T2>
+struct functionImplementation_
+<	T0,
+	T1,
+	T2,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		T2,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 3))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1,
+		T2);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1,
+		T2 arg2)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1,
+			arg2);
+	}
+
+
+};
+
+template<
+	typename T0,
+	typename T1>
+struct functionImplementation_
+<	T0,
+	T1,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		T1,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 2))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0,
+		T1);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0,
+		T1 arg1)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0,
+			arg1);
+	}
+
+
+};
+
+template<
+	typename T0>
+struct functionImplementation_
+<	T0,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType,
+	NullType>
+{
+	typedef detail::KernelFunctorGlobal<
+		T0,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType,
+		NullType> FunctorType;
+
+    FunctorType functor_;
+
+    functionImplementation_(const FunctorType &functor) :
+        functor_(functor)
+    {
+    
+        #if (defined(_WIN32) && defined(_VARIADIC_MAX) && (_VARIADIC_MAX < 1))
+        // Fail variadic expansion for dev11
+        static_assert(0, "Visual Studio has a hard limit of argument count for a std::function expansion. Please define _VARIADIC_MAX to be 10. If you need more arguments than that VC12 and below cannot support it.");
+        #endif
+            
+    }
+
+	//! \brief Return type of the functor
+	typedef Event result_type;
+
+	//! \brief Function signature of kernel functor with no event dependency.
+	typedef Event type_(
+		const EnqueueArgs&,
+		T0);
+
+	Event operator()(
+		const EnqueueArgs& enqueueArgs,
+		T0 arg0)
+	{
+		return functor_(
+			enqueueArgs,
+			arg0);
+	}
+
+
+};
+
+
+
+
+
+} // namespace detail
+
+//----------------------------------------------------------------------------------------------
+
+template <
+   typename T0,   typename T1 = detail::NullType,   typename T2 = detail::NullType,
+   typename T3 = detail::NullType,   typename T4 = detail::NullType,
+   typename T5 = detail::NullType,   typename T6 = detail::NullType,
+   typename T7 = detail::NullType,   typename T8 = detail::NullType,
+   typename T9 = detail::NullType,   typename T10 = detail::NullType,
+   typename T11 = detail::NullType,   typename T12 = detail::NullType,
+   typename T13 = detail::NullType,   typename T14 = detail::NullType,
+   typename T15 = detail::NullType,   typename T16 = detail::NullType,
+   typename T17 = detail::NullType,   typename T18 = detail::NullType,
+   typename T19 = detail::NullType,   typename T20 = detail::NullType,
+   typename T21 = detail::NullType,   typename T22 = detail::NullType,
+   typename T23 = detail::NullType,   typename T24 = detail::NullType,
+   typename T25 = detail::NullType,   typename T26 = detail::NullType,
+   typename T27 = detail::NullType,   typename T28 = detail::NullType,
+   typename T29 = detail::NullType,   typename T30 = detail::NullType,
+   typename T31 = detail::NullType
+>
+struct make_kernel :
+    public detail::functionImplementation_<
+               T0,   T1,   T2,   T3,
+               T4,   T5,   T6,   T7,
+               T8,   T9,   T10,   T11,
+               T12,   T13,   T14,   T15,
+               T16,   T17,   T18,   T19,
+               T20,   T21,   T22,   T23,
+               T24,   T25,   T26,   T27,
+               T28,   T29,   T30,   T31
+    >
+{
+public:
+    typedef detail::KernelFunctorGlobal<             
+               T0,   T1,   T2,   T3,
+               T4,   T5,   T6,   T7,
+               T8,   T9,   T10,   T11,
+               T12,   T13,   T14,   T15,
+               T16,   T17,   T18,   T19,
+               T20,   T21,   T22,   T23,
+               T24,   T25,   T26,   T27,
+               T28,   T29,   T30,   T31
+    > FunctorType;
+
+    make_kernel(
+        const Program& program,
+        const STRING_CLASS name,
+        cl_int * err = NULL) :
+           detail::functionImplementation_<
+                    T0,   T1,   T2,   T3,
+                       T4,   T5,   T6,   T7,
+                       T8,   T9,   T10,   T11,
+                       T12,   T13,   T14,   T15,
+                       T16,   T17,   T18,   T19,
+                       T20,   T21,   T22,   T23,
+                       T24,   T25,   T26,   T27,
+                       T28,   T29,   T30,   T31
+           >(
+            FunctorType(program, name, err)) 
+    {}
+
+    make_kernel(
+        const Kernel kernel) :
+           detail::functionImplementation_<
+                    T0,   T1,   T2,   T3,
+                       T4,   T5,   T6,   T7,
+                       T8,   T9,   T10,   T11,
+                       T12,   T13,   T14,   T15,
+                       T16,   T17,   T18,   T19,
+                       T20,   T21,   T22,   T23,
+                       T24,   T25,   T26,   T27,
+                       T28,   T29,   T30,   T31
+           >(
+            FunctorType(kernel)) 
+    {}    
+};
+
+
+//----------------------------------------------------------------------------------------------------------------------
+
+#undef __ERR_STR
+#if !defined(__CL_USER_OVERRIDE_ERROR_STRINGS)
+#undef __GET_DEVICE_INFO_ERR
+#undef __GET_PLATFORM_INFO_ERR
+#undef __GET_DEVICE_IDS_ERR
+#undef __GET_CONTEXT_INFO_ERR
+#undef __GET_EVENT_INFO_ERR
+#undef __GET_EVENT_PROFILE_INFO_ERR
+#undef __GET_MEM_OBJECT_INFO_ERR
+#undef __GET_IMAGE_INFO_ERR
+#undef __GET_SAMPLER_INFO_ERR
+#undef __GET_KERNEL_INFO_ERR
+#undef __GET_KERNEL_ARG_INFO_ERR
+#undef __GET_KERNEL_WORK_GROUP_INFO_ERR
+#undef __GET_PROGRAM_INFO_ERR
+#undef __GET_PROGRAM_BUILD_INFO_ERR
+#undef __GET_COMMAND_QUEUE_INFO_ERR
+
+#undef __CREATE_CONTEXT_ERR
+#undef __CREATE_CONTEXT_FROM_TYPE_ERR
+#undef __GET_SUPPORTED_IMAGE_FORMATS_ERR
+
+#undef __CREATE_BUFFER_ERR
+#undef __CREATE_SUBBUFFER_ERR
+#undef __CREATE_IMAGE2D_ERR
+#undef __CREATE_IMAGE3D_ERR
+#undef __CREATE_SAMPLER_ERR
+#undef __SET_MEM_OBJECT_DESTRUCTOR_CALLBACK_ERR
+
+#undef __CREATE_USER_EVENT_ERR
+#undef __SET_USER_EVENT_STATUS_ERR
+#undef __SET_EVENT_CALLBACK_ERR
+#undef __SET_PRINTF_CALLBACK_ERR
+
+#undef __WAIT_FOR_EVENTS_ERR
+
+#undef __CREATE_KERNEL_ERR
+#undef __SET_KERNEL_ARGS_ERR
+#undef __CREATE_PROGRAM_WITH_SOURCE_ERR
+#undef __CREATE_PROGRAM_WITH_BINARY_ERR
+#undef __CREATE_PROGRAM_WITH_BUILT_IN_KERNELS_ERR
+#undef __BUILD_PROGRAM_ERR
+#undef __CREATE_KERNELS_IN_PROGRAM_ERR
+
+#undef __CREATE_COMMAND_QUEUE_ERR
+#undef __SET_COMMAND_QUEUE_PROPERTY_ERR
+#undef __ENQUEUE_READ_BUFFER_ERR
+#undef __ENQUEUE_WRITE_BUFFER_ERR
+#undef __ENQUEUE_READ_BUFFER_RECT_ERR
+#undef __ENQUEUE_WRITE_BUFFER_RECT_ERR
+#undef __ENQEUE_COPY_BUFFER_ERR
+#undef __ENQEUE_COPY_BUFFER_RECT_ERR
+#undef __ENQUEUE_READ_IMAGE_ERR
+#undef __ENQUEUE_WRITE_IMAGE_ERR
+#undef __ENQUEUE_COPY_IMAGE_ERR
+#undef __ENQUEUE_COPY_IMAGE_TO_BUFFER_ERR
+#undef __ENQUEUE_COPY_BUFFER_TO_IMAGE_ERR
+#undef __ENQUEUE_MAP_BUFFER_ERR
+#undef __ENQUEUE_MAP_IMAGE_ERR
+#undef __ENQUEUE_UNMAP_MEM_OBJECT_ERR
+#undef __ENQUEUE_NDRANGE_KERNEL_ERR
+#undef __ENQUEUE_TASK_ERR
+#undef __ENQUEUE_NATIVE_KERNEL
+
+#undef __CL_EXPLICIT_CONSTRUCTORS
+
+#undef __UNLOAD_COMPILER_ERR
+#endif //__CL_USER_OVERRIDE_ERROR_STRINGS
+
+#undef __CL_FUNCTION_TYPE
+
+// Extensions
+/**
+ * Deprecated APIs for 1.2
+ */
+#if defined(CL_VERSION_1_1)
+#undef __INIT_CL_EXT_FCN_PTR
+#endif // #if defined(CL_VERSION_1_1)
+#undef __CREATE_SUB_DEVICES
+
+#if defined(USE_CL_DEVICE_FISSION)
+#undef __PARAM_NAME_DEVICE_FISSION
+#endif // USE_CL_DEVICE_FISSION
+
+#undef __DEFAULT_NOT_INITIALIZED 
+#undef __DEFAULT_BEING_INITIALIZED 
+#undef __DEFAULT_INITIALIZED
+
+#undef CL_HPP_RVALUE_REFERENCES_SUPPORTED
+#undef CL_HPP_NOEXCEPT
+
+} // namespace cl
+
+#endif // CL_HPP_