docs: public void startElement(String uri, String name, String qName, Attributes atts)
      {
          boolean isDebug = logger.isDebugEnabled();
          try
          {
              switch (getLiteralId(qName))
              {
                  case JDBC_CONNECTION_DESCRIPTOR:
                      {
                          if (isDebug) logger.debug("   > " + tags.getTagById(JDBC_CONNECTION_DESCRIPTOR));
                          JdbcConnectionDescriptor newJcd = new JdbcConnectionDescriptor();
                          currentAttributeContainer = newJcd;
  
                          conDesList.add(newJcd);
                          m_CurrentJCD = newJcd;
  
                          // set the jcdAlias attribute
                          String jcdAlias = atts.getValue(tags.getTagById(JCD_ALIAS));
                          if (isDebug) logger.debug("     " + tags.getTagById(JCD_ALIAS) + ": " + jcdAlias);
                          m_CurrentJCD.setJcdAlias(jcdAlias);
  
                          // set the jcdAlias attribute
                          String defaultConnection = atts.getValue(tags.getTagById(DEFAULT_CONNECTION));
                          if (isDebug) logger.debug("     " + tags.getTagById(DEFAULT_CONNECTION) + ": " + defaultConnection);
                          m_CurrentJCD.setDefaultConnection(Boolean.valueOf(defaultConnection).booleanValue());
                          if (m_CurrentJCD.isDefaultConnection())
                          {
                              if (defaultConnectionFound)
                              {
                                  throw new MetadataException("Found two jdbc-connection-descriptor elements with default-connection=\"true\"");
                              }
                              else
                              {
                                  defaultConnectionFound = true;
                              }
                          }
  
                          // set platform attribute
                          String platform = atts.getValue(tags.getTagById(DBMS_NAME));
                          if (isDebug) logger.debug("     " + tags.getTagById(DBMS_NAME) + ": " + platform);
                          m_CurrentJCD.setDbms(platform);
  
                          // set jdbc-level attribute
                          String level = atts.getValue(tags.getTagById(JDBC_LEVEL));
                          if (isDebug) logger.debug("     " + tags.getTagById(JDBC_LEVEL) + ": " + level);
                          m_CurrentJCD.setJdbcLevel(level);
  
                          // set driver attribute
                          String driver = atts.getValue(tags.getTagById(DRIVER_NAME));
                          if (isDebug) logger.debug("     " + tags.getTagById(DRIVER_NAME) + ": " + driver);
                          m_CurrentJCD.setDriver(driver);
  
                          // set protocol attribute
                          String protocol = atts.getValue(tags.getTagById(URL_PROTOCOL));
                          if (isDebug) logger.debug("     " + tags.getTagById(URL_PROTOCOL) + ": " + protocol);
                          m_CurrentJCD.setProtocol(protocol);
  
                          // set subprotocol attribute
                          String subprotocol = atts.getValue(tags.getTagById(URL_SUBPROTOCOL));
                          if (isDebug) logger.debug("     " + tags.getTagById(URL_SUBPROTOCOL) + ": " + subprotocol);
                          m_CurrentJCD.setSubProtocol(subprotocol);
  
                          // set the dbalias attribute
                          String dbalias = atts.getValue(tags.getTagById(URL_DBALIAS));
                          if (isDebug) logger.debug("     " + tags.getTagById(URL_DBALIAS) + ": " + dbalias);
                          m_CurrentJCD.setDbAlias(dbalias);
  
                          // set the datasource attribute
                          String datasource = atts.getValue(tags.getTagById(DATASOURCE_NAME));
                          // check for empty String
                          if(datasource != null && datasource.trim().equals("")) datasource = null;
                          if (isDebug) logger.debug("     " + tags.getTagById(DATASOURCE_NAME) + ": " + datasource);
                          m_CurrentJCD.setDatasourceName(datasource);
  
                          // set the user attribute
                          String user = atts.getValue(tags.getTagById(USER_NAME));
                          if (isDebug) logger.debug("     " + tags.getTagById(USER_NAME) + ": " + user);
                          m_CurrentJCD.setUserName(user);
  
                          // set the password attribute
                          String password = atts.getValue(tags.getTagById(USER_PASSWD));
                          if (isDebug) logger.debug("     " + tags.getTagById(USER_PASSWD) + ": " + password);
                          m_CurrentJCD.setPassWord(password);
  
                          // set eager-release attribute
                          String eagerRelease = atts.getValue(tags.getTagById(EAGER_RELEASE));
                          if (isDebug) logger.debug("     " + tags.getTagById(EAGER_RELEASE) + ": " + eagerRelease);
                          m_CurrentJCD.setEagerRelease(Boolean.valueOf(eagerRelease).booleanValue());
  
                          // set batch-mode attribute
                          String batchMode = atts.getValue(tags.getTagById(BATCH_MODE));
                          if (isDebug) logger.debug("     " + tags.getTagById(BATCH_MODE) + ": " + batchMode);
                          m_CurrentJCD.setBatchMode(Boolean.valueOf(batchMode).booleanValue());
  
                          // set useAutoCommit attribute
                          String useAutoCommit = atts.getValue(tags.getTagById(USE_AUTOCOMMIT));
                          if (isDebug) logger.debug("     " + tags.getTagById(USE_AUTOCOMMIT) + ": " + useAutoCommit);
                          m_CurrentJCD.setUseAutoCommit(Integer.valueOf(useAutoCommit).intValue());
  
                          // set ignoreAutoCommitExceptions attribute
                          String ignoreAutoCommitExceptions = atts.getValue(tags.getTagById(IGNORE_AUTOCOMMIT_EXCEPTION));
                          if (isDebug) logger.debug("     " + tags.getTagById(IGNORE_AUTOCOMMIT_EXCEPTION) + ": " + ignoreAutoCommitExceptions);
                          m_CurrentJCD.setIgnoreAutoCommitExceptions(Boolean.valueOf(ignoreAutoCommitExceptions).booleanValue());
  
                          break;
                      }
                  case CONNECTION_POOL:
                      {
                          if (m_CurrentJCD != null)
                          {
                              if (isDebug) logger.debug("    > " + tags.getTagById(CONNECTION_POOL));
                              final ConnectionPoolDescriptor m_CurrentCPD = m_CurrentJCD.getConnectionPoolDescriptor();
                              this.currentAttributeContainer = m_CurrentCPD;
  
                              String maxActive = atts.getValue(tags.getTagById(CON_MAX_ACTIVE));
                              if (isDebug) logger.debug("     " + tags.getTagById(CON_MAX_ACTIVE) + ": " + maxActive);
                              if (checkString(maxActive)) m_CurrentCPD.setMaxActive(Integer.parseInt(maxActive));
  
                              String maxIdle = atts.getValue(tags.getTagById(CON_MAX_IDLE));
                              if (isDebug) logger.debug("     " + tags.getTagById(CON_MAX_IDLE) + ": " + maxIdle);
                              if (checkString(maxIdle)) m_CurrentCPD.setMaxIdle(Integer.parseInt(maxIdle));
  
                              String maxWait = atts.getValue(tags.getTagById(CON_MAX_WAIT));
                              if (isDebug) logger.debug("     " + tags.getTagById(CON_MAX_WAIT) + ": " + maxWait);
                              if (checkString(maxWait)) m_CurrentCPD.setMaxWait(Integer.parseInt(maxWait));
  
                              String minEvictableIdleTimeMillis = atts.getValue(tags.getTagById(CON_MIN_EVICTABLE_IDLE_TIME_MILLIS));
                              if (isDebug) logger.debug("     " + tags.getTagById(CON_MIN_EVICTABLE_IDLE_TIME_MILLIS) + ": " + minEvictableIdleTimeMillis);
                              if (checkString(minEvictableIdleTimeMillis)) m_CurrentCPD.setMinEvictableIdleTimeMillis(Long.parseLong(minEvictableIdleTimeMillis));
  
                              String numTestsPerEvictionRun = atts.getValue(tags.getTagById(CON_NUM_TESTS_PER_EVICTION_RUN));
                              if (isDebug) logger.debug("     " + tags.getTagById(CON_NUM_TESTS_PER_EVICTION_RUN) + ": " + numTestsPerEvictionRun);
                              if (checkString(numTestsPerEvictionRun)) m_CurrentCPD.setNumTestsPerEvictionRun(Integer.parseInt(numTestsPerEvictionRun));
  
                              String testOnBorrow = atts.getValue(tags.getTagById(CON_TEST_ON_BORROW));
                              if (isDebug) logger.debug("     " + tags.getTagById(CON_TEST_ON_BORROW) + ": " + testOnBorrow);
                              if (checkString(testOnBorrow)) m_CurrentCPD.setTestOnBorrow(Boolean.valueOf(testOnBorrow).booleanValue());
  
                              String testOnReturn = atts.getValue(tags.getTagById(CON_TEST_ON_RETURN));
                              if (isDebug) logger.debug("     " + tags.getTagById(CON_TEST_ON_RETURN) + ": " + testOnReturn);
                              if (checkString(testOnReturn)) m_CurrentCPD.setTestOnReturn(Boolean.valueOf(testOnReturn).booleanValue());
  
                              String testWhileIdle = atts.getValue(tags.getTagById(CON_TEST_WHILE_IDLE));
                              if (isDebug) logger.debug("     " + tags.getTagById(CON_TEST_WHILE_IDLE) + ": " + testWhileIdle);
                              if (checkString(testWhileIdle)) m_CurrentCPD.setTestWhileIdle(Boolean.valueOf(testWhileIdle).booleanValue());
  
                              String timeBetweenEvictionRunsMillis = atts.getValue(tags.getTagById(CON_TIME_BETWEEN_EVICTION_RUNS_MILLIS));
                              if (isDebug) logger.debug("     " + tags.getTagById(CON_TIME_BETWEEN_EVICTION_RUNS_MILLIS) + ": " + timeBetweenEvictionRunsMillis);
                              if (checkString(timeBetweenEvictionRunsMillis)) m_CurrentCPD.setTimeBetweenEvictionRunsMillis(Long.parseLong(timeBetweenEvictionRunsMillis));
  
                              String whenExhaustedAction = atts.getValue(tags.getTagById(CON_WHEN_EXHAUSTED_ACTION));
                              if (isDebug) logger.debug("     " + tags.getTagById(CON_WHEN_EXHAUSTED_ACTION) + ": " + whenExhaustedAction);
                              if (checkString(whenExhaustedAction)) m_CurrentCPD.setWhenExhaustedAction(Byte.parseByte(whenExhaustedAction));
  
                              String connectionFactoryStr = atts.getValue(tags.getTagById(CONNECTION_FACTORY));
                              if (isDebug) logger.debug("     " + tags.getTagById(CONNECTION_FACTORY) + ": " + connectionFactoryStr);
                              if (checkString(connectionFactoryStr)) m_CurrentCPD.setConnectionFactory(ClassHelper.getClass(connectionFactoryStr));
  
                              String validationQuery = atts.getValue(tags.getTagById(VALIDATION_QUERY));
                              if (isDebug) logger.debug("     " + tags.getTagById(VALIDATION_QUERY) + ": " + validationQuery);
                              if (checkString(validationQuery)) m_CurrentCPD.setValidationQuery(validationQuery);
  
                              // abandoned connection properties
                              String logAbandoned = atts.getValue(tags.getTagById(CON_LOG_ABANDONED));
                              if (isDebug) logger.debug("     " + tags.getTagById(CON_LOG_ABANDONED) + ": " + logAbandoned);
                              if (checkString(logAbandoned)) m_CurrentCPD.setLogAbandoned(Boolean.valueOf(logAbandoned).booleanValue());
  
                              String removeAbandoned = atts.getValue(tags.getTagById(CON_REMOVE_ABANDONED));
                              if (isDebug) logger.debug("     " + tags.getTagById(CON_REMOVE_ABANDONED) + ": " + removeAbandoned);
                              if (checkString(removeAbandoned)) m_CurrentCPD.setRemoveAbandoned(Boolean.valueOf(removeAbandoned).booleanValue());
  
                              String removeAbandonedTimeout = atts.getValue(tags.getTagById(CON_REMOVE_ABANDONED_TIMEOUT));
                              if (isDebug) logger.debug("     " + tags.getTagById(CON_REMOVE_ABANDONED_TIMEOUT) + ": " + removeAbandonedTimeout);
                              if (checkString(removeAbandonedTimeout)) m_CurrentCPD.setRemoveAbandonedTimeout(Integer.parseInt(removeAbandonedTimeout));
                          }
                          break;
                      }
  
                  case OBJECT_CACHE:
                      {
                          String className = atts.getValue(tags.getTagById(CLASS_NAME));
                          if(checkString(className) && m_CurrentJCD != null)
                          {
                              ObjectCacheDescriptor ocd = m_CurrentJCD.getObjectCacheDescriptor();
                              this.currentAttributeContainer = ocd;
                              ocd.setObjectCache(ClassHelper.getClass(className));
                              if (isDebug) logger.debug("    > " + tags.getTagById(OBJECT_CACHE));
                              if (isDebug) logger.debug("     " + tags.getTagById(CLASS_NAME) + ": " + className);
                          }
                          break;
                      }
                  case SEQUENCE_MANAGER:
                      {
                          String className = atts.getValue(tags.getTagById(SEQUENCE_MANAGER_CLASS));
                          if(checkString(className))
                          {
                              this.currentSequenceDescriptor = new SequenceDescriptor(this.m_CurrentJCD);
                              this.currentAttributeContainer = currentSequenceDescriptor;
                              this.m_CurrentJCD.setSequenceDescriptor(this.currentSequenceDescriptor);
                              if (isDebug) logger.debug("    > " + tags.getTagById(SEQUENCE_MANAGER));
                              if (isDebug) logger.debug("     " + tags.getTagById(SEQUENCE_MANAGER_CLASS) + ": " + className);
                              if (checkString(className)) currentSequenceDescriptor.setSequenceManagerClass(ClassHelper.getClass(className));
                          }
                          break;
                      }
                  case ATTRIBUTE:
                      {
                          //handle custom attributes
                          String attributeName = atts.getValue(tags.getTagById(ATTRIBUTE_NAME));
                          String attributeValue = atts.getValue(tags.getTagById(ATTRIBUTE_VALUE));
  
                          // If we have a container to store this attribute in, then do so.
                          if (this.currentAttributeContainer != null)
                          {
  
                              if (checkString(attributeName))
                              {
                                  if (isDebug) logger.debug("      > " + tags.getTagById(ATTRIBUTE));
                                  if (isDebug) logger.debug("       " + tags.getTagById(ATTRIBUTE_NAME) + ": " + attributeName
                                          + "  "+tags.getTagById(ATTRIBUTE_VALUE) + ": " + attributeValue);
                                  this.currentAttributeContainer.addAttribute(attributeName, attributeValue);
  //                                logger.info("attribute ["+attributeName+"="+attributeValue+"] add to "+currentAttributeContainer.getClass());
                              }
                              else
                              {
                                  logger.info("Found 'null' or 'empty' attribute object for element "+currentAttributeContainer.getClass() +
                                          " attribute-name=" + attributeName + ", attribute-value=" + attributeValue+
                                          " See jdbc-connection-descriptor with jcdAlias '"+m_CurrentJCD.getJcdAlias()+"'");
                              }
                          }
  //                        else
  //                        {
  //                            logger.info("Found attribute (name="+attributeName+", value="+attributeValue+
  //                                    ") but I could not assign them to a descriptor");
  //                        }
  
                          break;
                      }
                  default :
                      {
                          // noop
                      }
              }
          }
          catch (Exception ex)
          {
              logger.error(ex);
              throw new PersistenceBrokerException(ex);
          }
      }