CLCommandQueue/CLException: Remove 'import static pack.class.*' for all (Easy on ClassLoader)

2 files changed, 258 insertions, 265 deletions

diff --git a/src/com/jogamp/opencl/CLCommandQueue.java b/src/com/jogamp/opencl/CLCommandQueue.java
index dd5c0f66..b68c4cd0 100644
--- a/src/com/jogamp/opencl/CLCommandQueue.java
+++ b/src/com/jogamp/opencl/CLCommandQueue.java
@@ -28,11 +28,13 @@
 
 package com.jogamp.opencl;
 
-import com.jogamp.common.nio.CachedBufferFactory;
-import com.jogamp.opencl.llb.gl.CLGL;
-import com.jogamp.common.nio.PointerBuffer;
-import com.jogamp.opencl.gl.CLGLObject;
-import com.jogamp.opencl.llb.CLCommandQueueBinding;
+import static com.jogamp.opencl.CLException.checkForError;
+import static com.jogamp.opencl.CLException.newException;
+import static com.jogamp.opencl.llb.CL.CL_SUCCESS;
+import static com.jogamp.opencl.llb.CLCommandQueueBinding.CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
+import static com.jogamp.opencl.llb.CLCommandQueueBinding.CL_QUEUE_PROFILING_ENABLE;
+import static com.jogamp.opencl.util.CLUtil.clBoolean;
+
 import java.nio.Buffer;
 import java.nio.ByteBuffer;
 import java.nio.IntBuffer;
@@ -41,9 +43,11 @@ import java.util.Arrays;
 import java.util.EnumSet;
 import java.util.List;
 
-import static com.jogamp.opencl.CLException.*;
-import static com.jogamp.opencl.llb.CL.*;
-import static com.jogamp.opencl.util.CLUtil.*;
+import com.jogamp.common.nio.CachedBufferFactory;
+import com.jogamp.common.nio.PointerBuffer;
+import com.jogamp.opencl.gl.CLGLObject;
+import com.jogamp.opencl.llb.CLCommandQueueBinding;
+import com.jogamp.opencl.llb.gl.CLGL;
 
 /**
  * The command queue is used to queue a set of operations for a specific {@link CLDevice}.
diff --git a/src/com/jogamp/opencl/CLException.java b/src/com/jogamp/opencl/CLException.java
index f776730b..84d3536c 100644
--- a/src/com/jogamp/opencl/CLException.java
+++ b/src/com/jogamp/opencl/CLException.java
@@ -28,7 +28,8 @@
 
 package com.jogamp.opencl;
 
-import static com.jogamp.opencl.llb.gl.CLGL.*;
+import com.jogamp.opencl.llb.gl.CLGL;
+import com.jogamp.opencl.llb.CL;
 
 /**
  * Main Exception type for runtime OpenCL errors and failed function calls (e.g. returning not CL_SUCCESS).
@@ -62,7 +63,7 @@ public class CLException extends RuntimeException {
      * Throws a CLException when <code>status != CL_SUCCESS</code>.
      */
     public static void checkForError(int status, String message) {
-        if(status != CL_SUCCESS) {
+        if(status != CL.CL_SUCCESS) {
             CLException ex = newException(status, message);
             ex.fillInStackTrace();
             throw ex;
@@ -96,676 +97,664 @@ public class CLException extends RuntimeException {
      */
     public static String resolveErrorCode(int error) {
         switch(error) {
-            case CL_DEVICE_NOT_FOUND:                       return "CL_DEVICE_NOT_FOUND";
-            case CL_DEVICE_NOT_AVAILABLE:                   return "CL_DEVICE_NOT_AVAILABLE";
-            case CL_COMPILER_NOT_AVAILABLE:                 return "CL_COMPILER_NOT_AVAILABLE";
-            case CL_MEM_OBJECT_ALLOCATION_FAILURE:          return "CL_MEM_OBJECT_ALLOCATION_FAILURE";
-            case CL_OUT_OF_RESOURCES:                       return "CL_OUT_OF_RESOURCES";
-            case CL_OUT_OF_HOST_MEMORY:                     return "CL_OUT_OF_HOST_MEMORY";
-            case CL_PROFILING_INFO_NOT_AVAILABLE:           return "CL_PROFILING_INFO_NOT_AVAILABLE";
-            case CL_MEM_COPY_OVERLAP:                       return "CL_MEM_COPY_OVERLAP";
-            case CL_IMAGE_FORMAT_MISMATCH:                  return "CL_IMAGE_FORMAT_MISMATCH";
-            case CL_IMAGE_FORMAT_NOT_SUPPORTED:             return "CL_IMAGE_FORMAT_NOT_SUPPORTED";
-            case CL_BUILD_PROGRAM_FAILURE:                  return "CL_BUILD_PROGRAM_FAILURE";
-            case CL_MAP_FAILURE:                            return "CL_MAP_FAILURE";
-            case CL_INVALID_VALUE:                          return "CL_INVALID_VALUE";
-            case CL_INVALID_DEVICE_TYPE:                    return "CL_INVALID_DEVICE_TYPE";
-            case CL_INVALID_PLATFORM:                       return "CL_INVALID_PLATFORM";
-            case CL_INVALID_DEVICE:                         return "CL_INVALID_DEVICE";
-            case CL_INVALID_CONTEXT:                        return "CL_INVALID_CONTEXT";
-            case CL_INVALID_QUEUE_PROPERTIES:               return "CL_INVALID_QUEUE_PROPERTIES";
-            case CL_INVALID_COMMAND_QUEUE:                  return "CL_INVALID_COMMAND_QUEUE";
-            case CL_INVALID_HOST_PTR:                       return "CL_INVALID_HOST_PTR";
-            case CL_INVALID_MEM_OBJECT:                     return "CL_INVALID_MEM_OBJECT";
-            case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:        return "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR";
-            case CL_INVALID_IMAGE_SIZE:                     return "CL_INVALID_IMAGE_SIZE";
-            case CL_INVALID_SAMPLER:                        return "CL_INVALID_SAMPLER";
-            case CL_INVALID_BINARY:                         return "CL_INVALID_BINARY";
-            case CL_INVALID_BUILD_OPTIONS:                  return "CL_INVALID_BUILD_OPTIONS";
-            case CL_INVALID_PROGRAM:                        return "CL_INVALID_PROGRAM";
-            case CL_INVALID_PROGRAM_EXECUTABLE:             return "CL_INVALID_PROGRAM_EXECUTABLE";
-            case CL_INVALID_KERNEL_NAME:                    return "CL_INVALID_KERNEL_NAME";
-            case CL_INVALID_KERNEL_DEFINITION:              return "CL_INVALID_KERNEL_DEFINITION";
-            case CL_INVALID_KERNEL:                         return "CL_INVALID_KERNEL";
-            case CL_INVALID_ARG_INDEX:                      return "CL_INVALID_ARG_INDEX";
-            case CL_INVALID_ARG_VALUE:                      return "CL_INVALID_ARG_VALUE";
-            case CL_INVALID_ARG_SIZE:                       return "CL_INVALID_ARG_SIZE";
-            case CL_INVALID_KERNEL_ARGS:                    return "CL_INVALID_KERNEL_ARGS";
-            case CL_INVALID_WORK_DIMENSION:                 return "CL_INVALID_WORK_DIMENSION";
-            case CL_INVALID_WORK_GROUP_SIZE:                return "CL_INVALID_WORK_GROUP_SIZE";
-            case CL_INVALID_WORK_ITEM_SIZE:                 return "CL_INVALID_WORK_ITEM_SIZE";
-            case CL_INVALID_GLOBAL_OFFSET:                  return "CL_INVALID_GLOBAL_OFFSET";
-            case CL_INVALID_EVENT_WAIT_LIST:                return "CL_INVALID_EVENT_WAIT_LIST";
-            case CL_INVALID_EVENT:                          return "CL_INVALID_EVENT";
-            case CL_INVALID_OPERATION:                      return "CL_INVALID_OPERATION";
-            case CL_INVALID_GL_OBJECT:                      return "CL_INVALID_GL_OBJECT";
-            case CL_INVALID_BUFFER_SIZE:                    return "CL_INVALID_BUFFER_SIZE";
-            case CL_INVALID_MIP_LEVEL:                      return "CL_INVALID_MIP_LEVEL";
-            case CL_INVALID_GLOBAL_WORK_SIZE:               return "CL_INVALID_GLOBAL_WORK_SIZE";
-            case CL_INVALID_PROPERTY:                       return "CL_INVALID_PROPERTY";
-            case CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR:    return "CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR";
-            case CL_PLATFORM_NOT_FOUND_KHR:                 return "CL_PLATFORM_NOT_FOUND_KHR";
-            case CL_MISALIGNED_SUB_BUFFER_OFFSET:             return "CL_MISALIGNED_SUB_BUFFER_OFFSET";
-            case CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST:  return "CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST";
+            case CL.CL_DEVICE_NOT_FOUND:                       return "CL_DEVICE_NOT_FOUND";
+            case CL.CL_DEVICE_NOT_AVAILABLE:                   return "CL_DEVICE_NOT_AVAILABLE";
+            case CL.CL_COMPILER_NOT_AVAILABLE:                 return "CL_COMPILER_NOT_AVAILABLE";
+            case CL.CL_MEM_OBJECT_ALLOCATION_FAILURE:          return "CL_MEM_OBJECT_ALLOCATION_FAILURE";
+            case CL.CL_OUT_OF_RESOURCES:                       return "CL_OUT_OF_RESOURCES";
+            case CL.CL_OUT_OF_HOST_MEMORY:                     return "CL_OUT_OF_HOST_MEMORY";
+            case CL.CL_PROFILING_INFO_NOT_AVAILABLE:           return "CL_PROFILING_INFO_NOT_AVAILABLE";
+            case CL.CL_MEM_COPY_OVERLAP:                       return "CL_MEM_COPY_OVERLAP";
+            case CL.CL_IMAGE_FORMAT_MISMATCH:                  return "CL_IMAGE_FORMAT_MISMATCH";
+            case CL.CL_IMAGE_FORMAT_NOT_SUPPORTED:             return "CL_IMAGE_FORMAT_NOT_SUPPORTED";
+            case CL.CL_BUILD_PROGRAM_FAILURE:                  return "CL_BUILD_PROGRAM_FAILURE";
+            case CL.CL_MAP_FAILURE:                            return "CL_MAP_FAILURE";
+            case CL.CL_INVALID_VALUE:                          return "CL_INVALID_VALUE";
+            case CL.CL_INVALID_DEVICE_TYPE:                    return "CL_INVALID_DEVICE_TYPE";
+            case CL.CL_INVALID_PLATFORM:                       return "CL_INVALID_PLATFORM";
+            case CL.CL_INVALID_DEVICE:                         return "CL_INVALID_DEVICE";
+            case CL.CL_INVALID_CONTEXT:                        return "CL_INVALID_CONTEXT";
+            case CL.CL_INVALID_QUEUE_PROPERTIES:               return "CL_INVALID_QUEUE_PROPERTIES";
+            case CL.CL_INVALID_COMMAND_QUEUE:                  return "CL_INVALID_COMMAND_QUEUE";
+            case CL.CL_INVALID_HOST_PTR:                       return "CL_INVALID_HOST_PTR";
+            case CL.CL_INVALID_MEM_OBJECT:                     return "CL_INVALID_MEM_OBJECT";
+            case CL.CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:        return "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR";
+            case CL.CL_INVALID_IMAGE_SIZE:                     return "CL_INVALID_IMAGE_SIZE";
+            case CL.CL_INVALID_SAMPLER:                        return "CL_INVALID_SAMPLER";
+            case CL.CL_INVALID_BINARY:                         return "CL_INVALID_BINARY";
+            case CL.CL_INVALID_BUILD_OPTIONS:                  return "CL_INVALID_BUILD_OPTIONS";
+            case CL.CL_INVALID_PROGRAM:                        return "CL_INVALID_PROGRAM";
+            case CL.CL_INVALID_PROGRAM_EXECUTABLE:             return "CL_INVALID_PROGRAM_EXECUTABLE";
+            case CL.CL_INVALID_KERNEL_NAME:                    return "CL_INVALID_KERNEL_NAME";
+            case CL.CL_INVALID_KERNEL_DEFINITION:              return "CL_INVALID_KERNEL_DEFINITION";
+            case CL.CL_INVALID_KERNEL:                         return "CL_INVALID_KERNEL";
+            case CL.CL_INVALID_ARG_INDEX:                      return "CL_INVALID_ARG_INDEX";
+            case CL.CL_INVALID_ARG_VALUE:                      return "CL_INVALID_ARG_VALUE";
+            case CL.CL_INVALID_ARG_SIZE:                       return "CL_INVALID_ARG_SIZE";
+            case CL.CL_INVALID_KERNEL_ARGS:                    return "CL_INVALID_KERNEL_ARGS";
+            case CL.CL_INVALID_WORK_DIMENSION:                 return "CL_INVALID_WORK_DIMENSION";
+            case CL.CL_INVALID_WORK_GROUP_SIZE:                return "CL_INVALID_WORK_GROUP_SIZE";
+            case CL.CL_INVALID_WORK_ITEM_SIZE:                 return "CL_INVALID_WORK_ITEM_SIZE";
+            case CL.CL_INVALID_GLOBAL_OFFSET:                  return "CL_INVALID_GLOBAL_OFFSET";
+            case CL.CL_INVALID_EVENT_WAIT_LIST:                return "CL_INVALID_EVENT_WAIT_LIST";
+            case CL.CL_INVALID_EVENT:                          return "CL_INVALID_EVENT";
+            case CL.CL_INVALID_OPERATION:                      return "CL_INVALID_OPERATION";
+            case CL.CL_INVALID_BUFFER_SIZE:                    return "CL_INVALID_BUFFER_SIZE";
+            case CL.CL_INVALID_MIP_LEVEL:                      return "CL_INVALID_MIP_LEVEL";
+            case CL.CL_INVALID_GLOBAL_WORK_SIZE:               return "CL_INVALID_GLOBAL_WORK_SIZE";
+            case CL.CL_INVALID_PROPERTY:                       return "CL_INVALID_PROPERTY";
+            case CL.CL_PLATFORM_NOT_FOUND_KHR:                 return "CL_PLATFORM_NOT_FOUND_KHR";
+            case CL.CL_MISALIGNED_SUB_BUFFER_OFFSET:             return "CL_MISALIGNED_SUB_BUFFER_OFFSET";
+            case CL.CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST:  return "CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST";
+            case CLGL.CL_INVALID_GL_OBJECT:                    return "CL_INVALID_GL_OBJECT";
+            case CLGL.CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR:  return "CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR";
             default: return null;
         }
     }
 
     private static CLException createSpecificException(int error, String message) {
         switch(error) {
-            case CL_DEVICE_NOT_FOUND:                       return new CLDeviceNotFoundException(message);
-            case CL_DEVICE_NOT_AVAILABLE:                   return new CLDeviceNotAvailableException(message);
-            case CL_COMPILER_NOT_AVAILABLE:                 return new CLCompilerNotAvailableException(message);
-            case CL_MEM_OBJECT_ALLOCATION_FAILURE:          return new CLMemObjectAllocationFailureException(message);
-            case CL_OUT_OF_RESOURCES:                       return new CLOutOfResourcesException(message);
-            case CL_OUT_OF_HOST_MEMORY:                     return new CLOutOfHostMemoryException(message);
-            case CL_PROFILING_INFO_NOT_AVAILABLE:           return new CLProfilingInfoNotAvailableException(message);
-            case CL_MEM_COPY_OVERLAP:                       return new CLMemCopyOverlapException(message);
-            case CL_IMAGE_FORMAT_MISMATCH:                  return new CLImageFormatMismatchException(message);
-            case CL_IMAGE_FORMAT_NOT_SUPPORTED:             return new CLImageFormatNotSupportedException(message);
-            case CL_BUILD_PROGRAM_FAILURE:                  return new CLBuildProgramFailureException(message);
-            case CL_MAP_FAILURE:                            return new CLMapFailureException(message);
-            case CL_INVALID_VALUE:                          return new CLInvalidValueException(message);
-            case CL_INVALID_DEVICE_TYPE:                    return new CLInvalidDeviceTypeException(message);
-            case CL_INVALID_PLATFORM:                       return new CLInvalidPlatformException(message);
-            case CL_INVALID_DEVICE:                         return new CLInvalidDeviceException(message);
-            case CL_INVALID_CONTEXT:                        return new CLInvalidContextException(message);
-            case CL_INVALID_QUEUE_PROPERTIES:               return new CLInvalidQueuePropertiesException(message);
-            case CL_INVALID_COMMAND_QUEUE:                  return new CLInvalidCommandQueueException(message);
-            case CL_INVALID_HOST_PTR:                       return new CLInvalidHostPtrException(message);
-            case CL_INVALID_MEM_OBJECT:                     return new CLInvalidMemObjectException(message);
-            case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:        return new CLInvalidImageFormatDescriptorException(message);
-            case CL_INVALID_IMAGE_SIZE:                     return new CLInvalidImageSizeException(message);
-            case CL_INVALID_SAMPLER:                        return new CLInvalidSamplerException(message);
-            case CL_INVALID_BINARY:                         return new CLInvalidBinaryException(message);
-            case CL_INVALID_BUILD_OPTIONS:                  return new CLInvalidBuildOptionsException(message);
-            case CL_INVALID_PROGRAM:                        return new CLInvalidProgramException(message);
-            case CL_INVALID_PROGRAM_EXECUTABLE:             return new CLInvalidProgramExecutableException(message);
-            case CL_INVALID_KERNEL_NAME:                    return new CLInvalidKernelNameException(message);
-            case CL_INVALID_KERNEL_DEFINITION:              return new CLInvalidKernelDefinitionException(message);
-            case CL_INVALID_KERNEL:                         return new CLInvalidKernelException(message);
-            case CL_INVALID_ARG_INDEX:                      return new CLInvalidArgIndexException(message);
-            case CL_INVALID_ARG_VALUE:                      return new CLInvalidArgValueException(message);
-            case CL_INVALID_ARG_SIZE:                       return new CLInvalidArgSizeException(message);
-            case CL_INVALID_KERNEL_ARGS:                    return new CLInvalidKernelArgsException(message);
-            case CL_INVALID_WORK_DIMENSION:                 return new CLInvalidWorkDimensionException(message);
-            case CL_INVALID_WORK_GROUP_SIZE:                return new CLInvalidWorkGroupSizeException(message);
-            case CL_INVALID_WORK_ITEM_SIZE:                 return new CLInvalidWorkItemSizeException(message);
-            case CL_INVALID_GLOBAL_OFFSET:                  return new CLInvalidGlobalOffsetException(message);
-            case CL_INVALID_EVENT_WAIT_LIST:                return new CLInvalidEventWaitListException(message);
-            case CL_INVALID_EVENT:                          return new CLInvalidEventException(message);
-            case CL_INVALID_OPERATION:                      return new CLInvalidOperationException(message);
-            case CL_INVALID_GL_OBJECT:                      return new CLInvalidGLObjectException(message);
-            case CL_INVALID_BUFFER_SIZE:                    return new CLInvalidBufferSizeException(message);
-            case CL_INVALID_MIP_LEVEL:                      return new CLInvalidMipLevelException(message);
-            case CL_INVALID_GLOBAL_WORK_SIZE:               return new CLInvalidGlobalWorkSizeException(message);
-            case CL_INVALID_PROPERTY:                       return new CLInvalidPropertyException(message);
-            case CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR:    return new CLInvalidGLSharegroupReferenceKhrException(message);
-            case CL_PLATFORM_NOT_FOUND_KHR:                 return new CLPlatformNotFoundKhrException(message);
-            case CL_MISALIGNED_SUB_BUFFER_OFFSET:             return new CLMisalignedSubBufferOffsetException(message);
-            case CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST:  return new CLExecStatusErrorForEventsInWaitListException(message);
+            case CL.CL_DEVICE_NOT_FOUND:                       return new CLDeviceNotFoundException(message);
+            case CL.CL_DEVICE_NOT_AVAILABLE:                   return new CLDeviceNotAvailableException(message);
+            case CL.CL_COMPILER_NOT_AVAILABLE:                 return new CLCompilerNotAvailableException(message);
+            case CL.CL_MEM_OBJECT_ALLOCATION_FAILURE:          return new CLMemObjectAllocationFailureException(message);
+            case CL.CL_OUT_OF_RESOURCES:                       return new CLOutOfResourcesException(message);
+            case CL.CL_OUT_OF_HOST_MEMORY:                     return new CLOutOfHostMemoryException(message);
+            case CL.CL_PROFILING_INFO_NOT_AVAILABLE:           return new CLProfilingInfoNotAvailableException(message);
+            case CL.CL_MEM_COPY_OVERLAP:                       return new CLMemCopyOverlapException(message);
+            case CL.CL_IMAGE_FORMAT_MISMATCH:                  return new CLImageFormatMismatchException(message);
+            case CL.CL_IMAGE_FORMAT_NOT_SUPPORTED:             return new CLImageFormatNotSupportedException(message);
+            case CL.CL_BUILD_PROGRAM_FAILURE:                  return new CLBuildProgramFailureException(message);
+            case CL.CL_MAP_FAILURE:                            return new CLMapFailureException(message);
+            case CL.CL_INVALID_VALUE:                          return new CLInvalidValueException(message);
+            case CL.CL_INVALID_DEVICE_TYPE:                    return new CLInvalidDeviceTypeException(message);
+            case CL.CL_INVALID_PLATFORM:                       return new CLInvalidPlatformException(message);
+            case CL.CL_INVALID_DEVICE:                         return new CLInvalidDeviceException(message);
+            case CL.CL_INVALID_CONTEXT:                        return new CLInvalidContextException(message);
+            case CL.CL_INVALID_QUEUE_PROPERTIES:               return new CLInvalidQueuePropertiesException(message);
+            case CL.CL_INVALID_COMMAND_QUEUE:                  return new CLInvalidCommandQueueException(message);
+            case CL.CL_INVALID_HOST_PTR:                       return new CLInvalidHostPtrException(message);
+            case CL.CL_INVALID_MEM_OBJECT:                     return new CLInvalidMemObjectException(message);
+            case CL.CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:        return new CLInvalidImageFormatDescriptorException(message);
+            case CL.CL_INVALID_IMAGE_SIZE:                     return new CLInvalidImageSizeException(message);
+            case CL.CL_INVALID_SAMPLER:                        return new CLInvalidSamplerException(message);
+            case CL.CL_INVALID_BINARY:                         return new CLInvalidBinaryException(message);
+            case CL.CL_INVALID_BUILD_OPTIONS:                  return new CLInvalidBuildOptionsException(message);
+            case CL.CL_INVALID_PROGRAM:                        return new CLInvalidProgramException(message);
+            case CL.CL_INVALID_PROGRAM_EXECUTABLE:             return new CLInvalidProgramExecutableException(message);
+            case CL.CL_INVALID_KERNEL_NAME:                    return new CLInvalidKernelNameException(message);
+            case CL.CL_INVALID_KERNEL_DEFINITION:              return new CLInvalidKernelDefinitionException(message);
+            case CL.CL_INVALID_KERNEL:                         return new CLInvalidKernelException(message);
+            case CL.CL_INVALID_ARG_INDEX:                      return new CLInvalidArgIndexException(message);
+            case CL.CL_INVALID_ARG_VALUE:                      return new CLInvalidArgValueException(message);
+            case CL.CL_INVALID_ARG_SIZE:                       return new CLInvalidArgSizeException(message);
+            case CL.CL_INVALID_KERNEL_ARGS:                    return new CLInvalidKernelArgsException(message);
+            case CL.CL_INVALID_WORK_DIMENSION:                 return new CLInvalidWorkDimensionException(message);
+            case CL.CL_INVALID_WORK_GROUP_SIZE:                return new CLInvalidWorkGroupSizeException(message);
+            case CL.CL_INVALID_WORK_ITEM_SIZE:                 return new CLInvalidWorkItemSizeException(message);
+            case CL.CL_INVALID_GLOBAL_OFFSET:                  return new CLInvalidGlobalOffsetException(message);
+            case CL.CL_INVALID_EVENT_WAIT_LIST:                return new CLInvalidEventWaitListException(message);
+            case CL.CL_INVALID_EVENT:                          return new CLInvalidEventException(message);
+            case CL.CL_INVALID_OPERATION:                      return new CLInvalidOperationException(message);
+            case CL.CL_INVALID_BUFFER_SIZE:                    return new CLInvalidBufferSizeException(message);
+            case CL.CL_INVALID_MIP_LEVEL:                      return new CLInvalidMipLevelException(message);
+            case CL.CL_INVALID_GLOBAL_WORK_SIZE:               return new CLInvalidGlobalWorkSizeException(message);
+            case CL.CL_INVALID_PROPERTY:                       return new CLInvalidPropertyException(message);
+            case CL.CL_PLATFORM_NOT_FOUND_KHR:                 return new CLPlatformNotFoundKhrException(message);
+            case CL.CL_MISALIGNED_SUB_BUFFER_OFFSET:             return new CLMisalignedSubBufferOffsetException(message);
+            case CL.CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST:  return new CLExecStatusErrorForEventsInWaitListException(message);
+            case CLGL.CL_INVALID_GL_OBJECT:                    return new CLInvalidGLObjectException(message);
+            case CLGL.CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR:  return new CLInvalidGLSharegroupReferenceKhrException(message);
             default: return null;
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_DEVICE_NOT_FOUND errors.
-     * @author Michael Bien
      */
     public final static class CLDeviceNotFoundException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_DEVICE_NOT_FOUND;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_DEVICE_NOT_FOUND;
         public CLDeviceNotFoundException(String message) {
-            super(CL_DEVICE_NOT_FOUND, "CL_DEVICE_NOT_FOUND", message);
+            super(CL.CL_DEVICE_NOT_FOUND, "CL_DEVICE_NOT_FOUND", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_DEVICE_NOT_AVAILABLE errors.
-     * @author Michael Bien
      */
     public final static class CLDeviceNotAvailableException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_DEVICE_NOT_AVAILABLE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_DEVICE_NOT_AVAILABLE;
         public CLDeviceNotAvailableException(String message) {
-            super(CL_DEVICE_NOT_AVAILABLE, "CL_DEVICE_NOT_AVAILABLE", message);
+            super(CL.CL_DEVICE_NOT_AVAILABLE, "CL_DEVICE_NOT_AVAILABLE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_COMPILER_NOT_AVAILABLE errors.
-     * @author Michael Bien
      */
     public final static class CLCompilerNotAvailableException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_COMPILER_NOT_AVAILABLE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_COMPILER_NOT_AVAILABLE;
         public CLCompilerNotAvailableException(String message) {
-            super(CL_COMPILER_NOT_AVAILABLE, "CL_COMPILER_NOT_AVAILABLE", message);
+            super(CL.CL_COMPILER_NOT_AVAILABLE, "CL_COMPILER_NOT_AVAILABLE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_MEM_OBJECT_ALLOCATION_FAILURE errors.
-     * @author Michael Bien
      */
     public final static class CLMemObjectAllocationFailureException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_MEM_OBJECT_ALLOCATION_FAILURE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_MEM_OBJECT_ALLOCATION_FAILURE;
         public CLMemObjectAllocationFailureException(String message) {
-            super(CL_MEM_OBJECT_ALLOCATION_FAILURE, "CL_MEM_OBJECT_ALLOCATION_FAILURE", message);
+            super(CL.CL_MEM_OBJECT_ALLOCATION_FAILURE, "CL_MEM_OBJECT_ALLOCATION_FAILURE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_OUT_OF_RESOURCES errors.
-     * @author Michael Bien
      */
     public final static class CLOutOfResourcesException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_OUT_OF_RESOURCES;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_OUT_OF_RESOURCES;
         public CLOutOfResourcesException(String message) {
-            super(CL_OUT_OF_RESOURCES, "CL_OUT_OF_RESOURCES", message);
+            super(CL.CL_OUT_OF_RESOURCES, "CL_OUT_OF_RESOURCES", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_OUT_OF_HOST_MEMORY errors.
-     * @author Michael Bien
      */
     public final static class CLOutOfHostMemoryException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_OUT_OF_HOST_MEMORY;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_OUT_OF_HOST_MEMORY;
         public CLOutOfHostMemoryException(String message) {
-            super(CL_OUT_OF_HOST_MEMORY, "CL_OUT_OF_HOST_MEMORY", message);
+            super(CL.CL_OUT_OF_HOST_MEMORY, "CL_OUT_OF_HOST_MEMORY", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_PROFILING_INFO_NOT_AVAILABLE errors.
-     * @author Michael Bien
      */
     public final static class CLProfilingInfoNotAvailableException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_PROFILING_INFO_NOT_AVAILABLE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_PROFILING_INFO_NOT_AVAILABLE;
         public CLProfilingInfoNotAvailableException(String message) {
-            super(CL_PROFILING_INFO_NOT_AVAILABLE, "CL_PROFILING_INFO_NOT_AVAILABLE", message);
+            super(CL.CL_PROFILING_INFO_NOT_AVAILABLE, "CL_PROFILING_INFO_NOT_AVAILABLE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_MEM_COPY_OVERLAP errors.
-     * @author Michael Bien
      */
     public final static class CLMemCopyOverlapException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_MEM_COPY_OVERLAP;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_MEM_COPY_OVERLAP;
         public CLMemCopyOverlapException(String message) {
-            super(CL_MEM_COPY_OVERLAP, "CL_MEM_COPY_OVERLAP", message);
+            super(CL.CL_MEM_COPY_OVERLAP, "CL_MEM_COPY_OVERLAP", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_IMAGE_FORMAT_MISMATCH errors.
-     * @author Michael Bien
      */
     public final static class CLImageFormatMismatchException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_IMAGE_FORMAT_MISMATCH;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_IMAGE_FORMAT_MISMATCH;
         public CLImageFormatMismatchException(String message) {
-            super(CL_IMAGE_FORMAT_MISMATCH, "CL_IMAGE_FORMAT_MISMATCH", message);
+            super(CL.CL_IMAGE_FORMAT_MISMATCH, "CL_IMAGE_FORMAT_MISMATCH", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_IMAGE_FORMAT_NOT_SUPPORTED errors.
-     * @author Michael Bien
      */
     public final static class CLImageFormatNotSupportedException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_IMAGE_FORMAT_NOT_SUPPORTED;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_IMAGE_FORMAT_NOT_SUPPORTED;
         public CLImageFormatNotSupportedException(String message) {
-            super(CL_IMAGE_FORMAT_NOT_SUPPORTED, "CL_IMAGE_FORMAT_NOT_SUPPORTED", message);
+            super(CL.CL_IMAGE_FORMAT_NOT_SUPPORTED, "CL_IMAGE_FORMAT_NOT_SUPPORTED", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_BUILD_PROGRAM_FAILURE errors.
-     * @author Michael Bien
      */
     public final static class CLBuildProgramFailureException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_BUILD_PROGRAM_FAILURE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_BUILD_PROGRAM_FAILURE;
         public CLBuildProgramFailureException(String message) {
-            super(CL_BUILD_PROGRAM_FAILURE, "CL_BUILD_PROGRAM_FAILURE", message);
+            super(CL.CL_BUILD_PROGRAM_FAILURE, "CL_BUILD_PROGRAM_FAILURE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_MAP_FAILURE errors.
-     * @author Michael Bien
      */
     public final static class CLMapFailureException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_MAP_FAILURE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_MAP_FAILURE;
         public CLMapFailureException(String message) {
-            super(CL_MAP_FAILURE, "CL_MAP_FAILURE", message);
+            super(CL.CL_MAP_FAILURE, "CL_MAP_FAILURE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_VALUE errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidValueException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_VALUE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_VALUE;
         public CLInvalidValueException(String message) {
-            super(CL_INVALID_VALUE, "CL_INVALID_VALUE", message);
+            super(CL.CL_INVALID_VALUE, "CL_INVALID_VALUE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_DEVICE_TYPE errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidDeviceTypeException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_DEVICE_TYPE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_DEVICE_TYPE;
         public CLInvalidDeviceTypeException(String message) {
-            super(CL_INVALID_DEVICE_TYPE, "CL_INVALID_DEVICE_TYPE", message);
+            super(CL.CL_INVALID_DEVICE_TYPE, "CL_INVALID_DEVICE_TYPE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_PLATFORM errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidPlatformException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_PLATFORM;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_PLATFORM;
         public CLInvalidPlatformException(String message) {
-            super(CL_INVALID_PLATFORM, "CL_INVALID_PLATFORM", message);
+            super(CL.CL_INVALID_PLATFORM, "CL_INVALID_PLATFORM", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_DEVICE errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidDeviceException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_DEVICE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_DEVICE;
         public CLInvalidDeviceException(String message) {
-            super(CL_INVALID_DEVICE, "CL_INVALID_DEVICE", message);
+            super(CL.CL_INVALID_DEVICE, "CL_INVALID_DEVICE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_CONTEXT errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidContextException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_CONTEXT;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_CONTEXT;
         public CLInvalidContextException(String message) {
-            super(CL_INVALID_CONTEXT, "CL_INVALID_CONTEXT", message);
+            super(CL.CL_INVALID_CONTEXT, "CL_INVALID_CONTEXT", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_QUEUE_PROPERTIES errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidQueuePropertiesException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_QUEUE_PROPERTIES;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_QUEUE_PROPERTIES;
         public CLInvalidQueuePropertiesException(String message) {
-            super(CL_INVALID_QUEUE_PROPERTIES, "CL_INVALID_QUEUE_PROPERTIES", message);
+            super(CL.CL_INVALID_QUEUE_PROPERTIES, "CL_INVALID_QUEUE_PROPERTIES", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_COMMAND_QUEUE errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidCommandQueueException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_COMMAND_QUEUE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_COMMAND_QUEUE;
         public CLInvalidCommandQueueException(String message) {
-            super(CL_INVALID_COMMAND_QUEUE, "CL_INVALID_COMMAND_QUEUE", message);
+            super(CL.CL_INVALID_COMMAND_QUEUE, "CL_INVALID_COMMAND_QUEUE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_HOST_PTR errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidHostPtrException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_HOST_PTR;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_HOST_PTR;
         public CLInvalidHostPtrException(String message) {
-            super(CL_INVALID_HOST_PTR, "CL_INVALID_HOST_PTR", message);
+            super(CL.CL_INVALID_HOST_PTR, "CL_INVALID_HOST_PTR", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_MEM_OBJECT errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidMemObjectException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_MEM_OBJECT;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_MEM_OBJECT;
         public CLInvalidMemObjectException(String message) {
-            super(CL_INVALID_MEM_OBJECT, "CL_INVALID_MEM_OBJECT", message);
+            super(CL.CL_INVALID_MEM_OBJECT, "CL_INVALID_MEM_OBJECT", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_IMAGE_FORMAT_DESCRIPTOR errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidImageFormatDescriptorException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_IMAGE_FORMAT_DESCRIPTOR;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_IMAGE_FORMAT_DESCRIPTOR;
         public CLInvalidImageFormatDescriptorException(String message) {
-            super(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR", message);
+            super(CL.CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_IMAGE_SIZE errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidImageSizeException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_IMAGE_SIZE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_IMAGE_SIZE;
         public CLInvalidImageSizeException(String message) {
-            super(CL_INVALID_IMAGE_SIZE, "CL_INVALID_IMAGE_SIZE", message);
+            super(CL.CL_INVALID_IMAGE_SIZE, "CL_INVALID_IMAGE_SIZE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_SAMPLER errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidSamplerException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_SAMPLER;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_SAMPLER;
         public CLInvalidSamplerException(String message) {
-            super(CL_INVALID_SAMPLER, "CL_INVALID_SAMPLER", message);
+            super(CL.CL_INVALID_SAMPLER, "CL_INVALID_SAMPLER", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_BINARY errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidBinaryException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_BINARY;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_BINARY;
         public CLInvalidBinaryException(String message) {
-            super(CL_INVALID_BINARY, "CL_INVALID_BINARY", message);
+            super(CL.CL_INVALID_BINARY, "CL_INVALID_BINARY", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_BUILD_OPTIONS errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidBuildOptionsException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_BUILD_OPTIONS;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_BUILD_OPTIONS;
         public CLInvalidBuildOptionsException(String message) {
-            super(CL_INVALID_BUILD_OPTIONS, "CL_INVALID_BUILD_OPTIONS", message);
+            super(CL.CL_INVALID_BUILD_OPTIONS, "CL_INVALID_BUILD_OPTIONS", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_PROGRAM errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidProgramException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_PROGRAM;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_PROGRAM;
         public CLInvalidProgramException(String message) {
-            super(CL_INVALID_PROGRAM, "CL_INVALID_PROGRAM", message);
+            super(CL.CL_INVALID_PROGRAM, "CL_INVALID_PROGRAM", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_PROGRAM_EXECUTABLE errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidProgramExecutableException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_PROGRAM_EXECUTABLE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_PROGRAM_EXECUTABLE;
         public CLInvalidProgramExecutableException(String message) {
-            super(CL_INVALID_PROGRAM_EXECUTABLE, "CL_INVALID_PROGRAM_EXECUTABLE", message);
+            super(CL.CL_INVALID_PROGRAM_EXECUTABLE, "CL_INVALID_PROGRAM_EXECUTABLE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_KERNEL_NAME errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidKernelNameException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_KERNEL_NAME;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_KERNEL_NAME;
         public CLInvalidKernelNameException(String message) {
-            super(CL_INVALID_KERNEL_NAME, "CL_INVALID_KERNEL_NAME", message);
+            super(CL.CL_INVALID_KERNEL_NAME, "CL_INVALID_KERNEL_NAME", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_KERNEL_DEFINITION errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidKernelDefinitionException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_KERNEL_DEFINITION;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_KERNEL_DEFINITION;
         public CLInvalidKernelDefinitionException(String message) {
-            super(CL_INVALID_KERNEL_DEFINITION, "CL_INVALID_KERNEL_DEFINITION", message);
+            super(CL.CL_INVALID_KERNEL_DEFINITION, "CL_INVALID_KERNEL_DEFINITION", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_KERNEL errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidKernelException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_KERNEL;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_KERNEL;
         public CLInvalidKernelException(String message) {
-            super(CL_INVALID_KERNEL, "CL_INVALID_KERNEL", message);
+            super(CL.CL_INVALID_KERNEL, "CL_INVALID_KERNEL", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_ARG_INDEX errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidArgIndexException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_ARG_INDEX;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_ARG_INDEX;
         public CLInvalidArgIndexException(String message) {
-            super(CL_INVALID_ARG_INDEX, "CL_INVALID_ARG_INDEX", message);
+            super(CL.CL_INVALID_ARG_INDEX, "CL_INVALID_ARG_INDEX", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_ARG_VALUE errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidArgValueException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_ARG_VALUE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_ARG_VALUE;
         public CLInvalidArgValueException(String message) {
-            super(CL_INVALID_ARG_VALUE, "CL_INVALID_ARG_VALUE", message);
+            super(CL.CL_INVALID_ARG_VALUE, "CL_INVALID_ARG_VALUE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_ARG_SIZE errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidArgSizeException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_ARG_SIZE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_ARG_SIZE;
         public CLInvalidArgSizeException(String message) {
-            super(CL_INVALID_ARG_SIZE, "CL_INVALID_ARG_SIZE", message);
+            super(CL.CL_INVALID_ARG_SIZE, "CL_INVALID_ARG_SIZE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_KERNEL_ARGS errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidKernelArgsException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_KERNEL_ARGS;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_KERNEL_ARGS;
         public CLInvalidKernelArgsException(String message) {
-            super(CL_INVALID_KERNEL_ARGS, "CL_INVALID_KERNEL_ARGS", message);
+            super(CL.CL_INVALID_KERNEL_ARGS, "CL_INVALID_KERNEL_ARGS", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_WORK_DIMENSION errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidWorkDimensionException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_WORK_DIMENSION;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_WORK_DIMENSION;
         public CLInvalidWorkDimensionException(String message) {
-            super(CL_INVALID_WORK_DIMENSION, "CL_INVALID_WORK_DIMENSION", message);
+            super(CL.CL_INVALID_WORK_DIMENSION, "CL_INVALID_WORK_DIMENSION", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_WORK_GROUP_SIZE errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidWorkGroupSizeException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_WORK_GROUP_SIZE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_WORK_GROUP_SIZE;
         public CLInvalidWorkGroupSizeException(String message) {
-            super(CL_INVALID_WORK_GROUP_SIZE, "CL_INVALID_WORK_GROUP_SIZE", message);
+            super(CL.CL_INVALID_WORK_GROUP_SIZE, "CL_INVALID_WORK_GROUP_SIZE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_WORK_ITEM_SIZE errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidWorkItemSizeException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_WORK_ITEM_SIZE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_WORK_ITEM_SIZE;
         public CLInvalidWorkItemSizeException(String message) {
-            super(CL_INVALID_WORK_ITEM_SIZE, "CL_INVALID_WORK_ITEM_SIZE", message);
+            super(CL.CL_INVALID_WORK_ITEM_SIZE, "CL_INVALID_WORK_ITEM_SIZE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_GLOBAL_OFFSET errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidGlobalOffsetException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_GLOBAL_OFFSET;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_GLOBAL_OFFSET;
         public CLInvalidGlobalOffsetException(String message) {
-            super(CL_INVALID_GLOBAL_OFFSET, "CL_INVALID_GLOBAL_OFFSET", message);
+            super(CL.CL_INVALID_GLOBAL_OFFSET, "CL_INVALID_GLOBAL_OFFSET", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_EVENT_WAIT_LIST errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidEventWaitListException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_EVENT_WAIT_LIST;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_EVENT_WAIT_LIST;
         public CLInvalidEventWaitListException(String message) {
-            super(CL_INVALID_EVENT_WAIT_LIST, "CL_INVALID_EVENT_WAIT_LIST", message);
+            super(CL.CL_INVALID_EVENT_WAIT_LIST, "CL_INVALID_EVENT_WAIT_LIST", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_EVENT errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidEventException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_EVENT;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_EVENT;
         public CLInvalidEventException(String message) {
-            super(CL_INVALID_EVENT, "CL_INVALID_EVENT", message);
+            super(CL.CL_INVALID_EVENT, "CL_INVALID_EVENT", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_OPERATION errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidOperationException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_OPERATION;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_OPERATION;
         public CLInvalidOperationException(String message) {
-            super(CL_INVALID_OPERATION, "CL_INVALID_OPERATION", message);
+            super(CL.CL_INVALID_OPERATION, "CL_INVALID_OPERATION", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_GL_OBJECT errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidGLObjectException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_GL_OBJECT;
+        private static final long serialVersionUID = CLException.serialVersionUID+CLGL.CL_INVALID_GL_OBJECT;
         public CLInvalidGLObjectException(String message) {
-            super(CL_INVALID_GL_OBJECT, "CL_INVALID_GL_OBJECT", message);
+            super(CLGL.CL_INVALID_GL_OBJECT, "CL_INVALID_GL_OBJECT", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_BUFFER_SIZE errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidBufferSizeException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_BUFFER_SIZE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_BUFFER_SIZE;
         public CLInvalidBufferSizeException(String message) {
-            super(CL_INVALID_BUFFER_SIZE, "CL_INVALID_BUFFER_SIZE", message);
+            super(CL.CL_INVALID_BUFFER_SIZE, "CL_INVALID_BUFFER_SIZE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_MIP_LEVEL errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidMipLevelException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_MIP_LEVEL;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_MIP_LEVEL;
         public CLInvalidMipLevelException(String message) {
-            super(CL_INVALID_MIP_LEVEL, "CL_INVALID_MIP_LEVEL", message);
+            super(CL.CL_INVALID_MIP_LEVEL, "CL_INVALID_MIP_LEVEL", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_GLOBAL_WORK_SIZE errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidGlobalWorkSizeException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_GLOBAL_WORK_SIZE;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_GLOBAL_WORK_SIZE;
         public CLInvalidGlobalWorkSizeException(String message) {
-            super(CL_INVALID_GLOBAL_WORK_SIZE, "CL_INVALID_GLOBAL_WORK_SIZE", message);
+            super(CL.CL_INVALID_GLOBAL_WORK_SIZE, "CL_INVALID_GLOBAL_WORK_SIZE", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_PROPERTY errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidPropertyException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_PROPERTY;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_INVALID_PROPERTY;
         public CLInvalidPropertyException(String message) {
-            super(CL_INVALID_PROPERTY, "CL_INVALID_PROPERTY", message);
+            super(CL.CL_INVALID_PROPERTY, "CL_INVALID_PROPERTY", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLInvalidGLSharegroupReferenceKhrException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR;
+        private static final long serialVersionUID = CLException.serialVersionUID+CLGL.CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR;
         public CLInvalidGLSharegroupReferenceKhrException(String message) {
-            super(CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR, "CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR", message);
+            super(CLGL.CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR, "CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_PLATFORM_NOT_FOUND_KHR errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLPlatformNotFoundKhrException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_PLATFORM_NOT_FOUND_KHR;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_PLATFORM_NOT_FOUND_KHR;
         public CLPlatformNotFoundKhrException(String message) {
-            super(CL_PLATFORM_NOT_FOUND_KHR, "CL_PLATFORM_NOT_FOUND_KHR", message);
+            super(CL.CL_PLATFORM_NOT_FOUND_KHR, "CL_PLATFORM_NOT_FOUND_KHR", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_MISALIGNED_SUB_BUFFER_OFFSET errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLMisalignedSubBufferOffsetException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_MISALIGNED_SUB_BUFFER_OFFSET;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_MISALIGNED_SUB_BUFFER_OFFSET;
         public CLMisalignedSubBufferOffsetException(String message) {
-            super(CL_MISALIGNED_SUB_BUFFER_OFFSET, "CL_MISALIGNED_SUB_BUFFER_OFFSET", message);
+            super(CL.CL_MISALIGNED_SUB_BUFFER_OFFSET, "CL_MISALIGNED_SUB_BUFFER_OFFSET", message);
         }
     }
 
     /**
      * {@link CLException} thrown on CL.CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST errors.
-     * @author Michael Bien
+     * 
      */
     public final static class CLExecStatusErrorForEventsInWaitListException extends CLException {
-        private static final long serialVersionUID = CLException.serialVersionUID+CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST;
+        private static final long serialVersionUID = CLException.serialVersionUID+CL.CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST;
         public CLExecStatusErrorForEventsInWaitListException(String message) {
-            super(CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST, "CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST", message);
+            super(CL.CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST, "CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST", message);
         }
     }