docs: private void initialize(Chunk chunk)
      {
          final String mName = "initialize";
  
          if(logger.isLoggable(Level.FINER)) 
              logger.entering(className, mName);
  
          try
          {
              if (chunk.getRetryLimit() != null){
                  _retryLimit = Integer.parseInt(chunk.getRetryLimit());
                  if (_retryLimit < 0) {
                      throw new IllegalArgumentException("The retry-limit attribute on a chunk cannot be a negative value");
                  }
  
              }
          }
          catch (NumberFormatException nfe)
          {
              throw new RuntimeException("NumberFormatException reading " + RETRY_COUNT, nfe);
          }
  
          // Read the include/exclude exceptions.
          _retryIncludeExceptions = new HashSet<String>();
          _retryExcludeExceptions = new HashSet<String>();
          _retryNoRBIncludeExceptions = new HashSet<String>();
          _retryNoRBExcludeExceptions = new HashSet<String>();
  
          if (chunk.getRetryableExceptionClasses() != null) {
              if (chunk.getRetryableExceptionClasses().getIncludeList() != null) {
                  List<ExceptionClassFilter.Include> includes = chunk.getRetryableExceptionClasses().getIncludeList();
                  for (ExceptionClassFilter.Include include : includes) {
                      _retryIncludeExceptions.add(include.getClazz().trim());
                      logger.finer("RETRYHANDLE: include: " + include.getClazz().trim());
                  }
  
                  if (_retryIncludeExceptions.size() == 0) {
                      logger.finer("RETRYHANDLE: include element not present");
  
                  }
              }
              if (chunk.getRetryableExceptionClasses().getExcludeList() != null) {
                  List<ExceptionClassFilter.Exclude> excludes = chunk.getRetryableExceptionClasses().getExcludeList();
                  for (ExceptionClassFilter.Exclude exclude : excludes) {
                      _retryExcludeExceptions.add(exclude.getClazz().trim());
                      logger.finer("SKIPHANDLE: exclude: " + exclude.getClazz().trim());
                  }
  
                  if (_retryExcludeExceptions.size() == 0) {
                      logger.finer("SKIPHANDLE: exclude element not present");
  
                  }
              }
          }
  
          if (chunk.getNoRollbackExceptionClasses() != null) {
              if (chunk.getNoRollbackExceptionClasses().getIncludeList() != null) {
                  List<ExceptionClassFilter.Include> includes = chunk.getNoRollbackExceptionClasses().getIncludeList();
                  for (ExceptionClassFilter.Include include : includes) {
                      _retryNoRBIncludeExceptions.add(include.getClazz().trim());
                      logger.finer("RETRYHANDLE: include: " + include.getClazz().trim());
                  }
  
                  if (_retryNoRBIncludeExceptions.size() == 0) {
                      logger.finer("RETRYHANDLE: include element not present");
  
                  }
              }
              if (chunk.getNoRollbackExceptionClasses().getExcludeList() != null) {
                  List<ExceptionClassFilter.Exclude> excludes = chunk.getNoRollbackExceptionClasses().getExcludeList();
                  for (ExceptionClassFilter.Exclude exclude : excludes) {
                      _retryNoRBExcludeExceptions.add(exclude.getClazz().trim());
                      logger.finer("SKIPHANDLE: exclude: " + exclude.getClazz().trim());
                  }
  
                  if (_retryNoRBExcludeExceptions.size() == 0) {
                      logger.finer("SKIPHANDLE: exclude element not present");
  
                  }
              }
          }
          
          // Create the ExceptionMatcher Object
          excMatcher = new ExceptionMatcher(_retryIncludeExceptions, _retryExcludeExceptions);
          noRBexcMatcher = new ExceptionMatcher(_retryNoRBIncludeExceptions, _retryNoRBExcludeExceptions);
  
  
          if (logger.isLoggable(Level.FINE)) {
              logger.logp(Level.FINE, className, mName, "added include exception " + _retryIncludeExceptions 
                      + "; added exclude exception " + _retryExcludeExceptions);
              logger.logp(Level.FINE, className, mName, "added include no rollback exception " + _retryNoRBIncludeExceptions
                      + "; added exclude no rollback exception " + _retryNoRBExcludeExceptions);
          }
              
          if(logger.isLoggable(Level.FINER)) {
            logger.exiting(className, mName, this.toString());
          }
        }