public ComboPooledDataSource() 
{
     
     this( true );
}

 public ComboPooledDataSource(boolean autoregister) 
{
        super( autoregister );
        // System.err.println("...Initializing ComboPooledDataSource.");
        dmds  = new DriverManagerDataSource();
        wcpds = new WrapperConnectionPoolDataSource();
        wcpds.setNestedDataSource( dmds );
        try
        { this.setConnectionPoolDataSource( wcpds ); }
        catch (PropertyVetoException e)
        {
            logger.log(MLevel.WARNING, "Hunh??? This can't happen. We haven't set up any listeners to veto the property change yet!", e);
            throw new RuntimeException("Hunh??? This can't happen. We haven't set up any listeners to veto the property change yet! " + e);
        }
        // set things up in case there are future changes to our ConnectionPoolDataSource
        //
        setUpPropertyEvents();
}

 public ComboPooledDataSource(String configName) 
{
 
        this();
        initializeNamedConfig( configName );
}

 public int getAcquireIncrement() 
{
 return wcpds.getAcquireIncrement();
}

 public int getAcquireRetryAttempts() 
{
 return wcpds.getAcquireRetryAttempts();
}

 public int getAcquireRetryDelay() 
{
 return wcpds.getAcquireRetryDelay();
}

 public String getAutomaticTestTable() 
{
 return wcpds.getAutomaticTestTable();
}

 public int getCheckoutTimeout() 
{
 return wcpds.getCheckoutTimeout();
}

 public String getConnectionCustomizerClassName() 
{
 return wcpds.getConnectionCustomizerClassName();
}

 public String getConnectionTesterClassName() 
{
 return wcpds.getConnectionTesterClassName();
}

 public String getDescription() 
{
 return dmds.getDescription();
}

 public String getDriverClass() 
{
 return dmds.getDriverClass();
}

 public String getFactoryClassLocation() 
{
 return super.getFactoryClassLocation();
}

 public int getIdleConnectionTestPeriod() 
{
 return wcpds.getIdleConnectionTestPeriod();
}

 public int getInitialPoolSize() 
{
 return wcpds.getInitialPoolSize();
}

 public String getJdbcUrl() 
{
  
//      System.err.println("getting jdbcUrl: " + dmds.getJdbcUrl()); 
        return dmds.getJdbcUrl();
}

 public int getMaxAdministrativeTaskTime() 
{
 return wcpds.getMaxAdministrativeTaskTime();
}

 public int getMaxConnectionAge() 
{
 return wcpds.getMaxConnectionAge();
}

 public int getMaxIdleTime() 
{
 return wcpds.getMaxIdleTime();
}

 public int getMaxIdleTimeExcessConnections() 
{
 return wcpds.getMaxIdleTimeExcessConnections();
}

 public int getMaxPoolSize() 
{
 return wcpds.getMaxPoolSize();
}

 public int getMaxStatements() 
{
 return wcpds.getMaxStatements();
}

 public int getMaxStatementsPerConnection() 
{
 return wcpds.getMaxStatementsPerConnection();
}

 public int getMinPoolSize() 
{
 return wcpds.getMinPoolSize();
}

 public String getOverrideDefaultPassword() 
{
 return wcpds.getOverrideDefaultPassword();
}

 public String getOverrideDefaultUser() 
{
 return wcpds.getOverrideDefaultUser();
}

 public String getPassword() 
{
 return dmds.getPassword();
}

 public String getPreferredTestQuery() 
{
 return wcpds.getPreferredTestQuery();
}

 public Properties getProperties() 
{
 
        //System.err.println("getting properties: " + dmds.getProperties()); 
        return dmds.getProperties();
}

 public int getPropertyCycle() 
{
 return wcpds.getPropertyCycle();
}

 public int getUnreturnedConnectionTimeout() 
{
 return wcpds.getUnreturnedConnectionTimeout();
}

 public String getUser() 
{
 return dmds.getUser();
}

 public String getUserOverridesAsString() 
{
 return wcpds.getUserOverridesAsString();
}

 public boolean isAutoCommitOnClose() 
{
 return wcpds.isAutoCommitOnClose();
}

 public boolean isBreakAfterAcquireFailure() 
{
 return wcpds.isBreakAfterAcquireFailure();
}

 public boolean isDebugUnreturnedConnectionStackTraces() 
{
 return wcpds.isDebugUnreturnedConnectionStackTraces();
}

 public boolean isForceIgnoreUnresolvedTransactions() 
{
 return wcpds.isForceIgnoreUnresolvedTransactions();
}

 public boolean isTestConnectionOnCheckin() 
{
 return wcpds.isTestConnectionOnCheckin();
}

 public boolean isTestConnectionOnCheckout() 
{
 return wcpds.isTestConnectionOnCheckout();
}

 public boolean isUsesTraditionalReflectiveProxies() 
{
 return wcpds.isUsesTraditionalReflectiveProxies();
}

 public  void setAcquireIncrement(int acquireIncrement) 
{
 
        wcpds.setAcquireIncrement( acquireIncrement ); 
        this.resetPoolManager( false );
}

 public  void setAcquireRetryAttempts(int acquireRetryAttempts) 
{
 
        wcpds.setAcquireRetryAttempts( acquireRetryAttempts ); 
        this.resetPoolManager( false );
}

 public  void setAcquireRetryDelay(int acquireRetryDelay) 
{
 
        wcpds.setAcquireRetryDelay( acquireRetryDelay ); 
        this.resetPoolManager( false );
}

 public  void setAutoCommitOnClose(boolean autoCommitOnClose) 
{
 
        wcpds.setAutoCommitOnClose( autoCommitOnClose ); 
        this.resetPoolManager( false );
}

 public  void setAutomaticTestTable(String automaticTestTable) 
{
 
        wcpds.setAutomaticTestTable( automaticTestTable ); 
        this.resetPoolManager( false );
}

 public  void setBreakAfterAcquireFailure(boolean breakAfterAcquireFailure) 
{
 
        wcpds.setBreakAfterAcquireFailure( breakAfterAcquireFailure ); 
        this.resetPoolManager( false );
}

 public  void setCheckoutTimeout(int checkoutTimeout) 
{
 
        wcpds.setCheckoutTimeout( checkoutTimeout ); 
        this.resetPoolManager( false );
}

 public  void setConnectionCustomizerClassName(String connectionCustomizerClassName) 
{
 
        wcpds.setConnectionCustomizerClassName( connectionCustomizerClassName ); 
        this.resetPoolManager( false );
}

 public  void setConnectionTesterClassName(String connectionTesterClassName) throws PropertyVetoException 
{
 
        wcpds.setConnectionTesterClassName( connectionTesterClassName ); 
        this.resetPoolManager( false );
}

 public  void setDebugUnreturnedConnectionStackTraces(boolean debugUnreturnedConnectionStackTraces) 
{
        wcpds.setDebugUnreturnedConnectionStackTraces( debugUnreturnedConnectionStackTraces ); 
        this.resetPoolManager( false );
}

 public  void setDescription(String description) 
{
 dmds.setDescription( description );
}

 public  void setDriverClass(String driverClass) throws PropertyVetoException 
{
 
        dmds.setDriverClass( driverClass ); 
//      System.err.println("setting driverClass: " + driverClass);
}

 public  void setFactoryClassLocation(String factoryClassLocation) 
{
        dmds.setFactoryClassLocation( factoryClassLocation );
        wcpds.setFactoryClassLocation( factoryClassLocation );
        super.setFactoryClassLocation( factoryClassLocation );
}

 public  void setForceIgnoreUnresolvedTransactions(boolean forceIgnoreUnresolvedTransactions) 
{
 
        wcpds.setForceIgnoreUnresolvedTransactions( forceIgnoreUnresolvedTransactions ); 
        this.resetPoolManager( false );
}

 public  void setIdleConnectionTestPeriod(int idleConnectionTestPeriod) 
{
 
        wcpds.setIdleConnectionTestPeriod( idleConnectionTestPeriod ); 
        this.resetPoolManager( false );
}

 public  void setInitialPoolSize(int initialPoolSize) 
{
 
        wcpds.setInitialPoolSize( initialPoolSize ); 
        this.resetPoolManager( false );
}

 public  void setJdbcUrl(String jdbcUrl) 
{
 
        dmds.setJdbcUrl( jdbcUrl ); 
        this.resetPoolManager( false );
//      System.err.println("setting jdbcUrl: " + jdbcUrl + " [dmds@" + C3P0ImplUtils.identityToken( dmds ) + "]"); 
//      if (jdbcUrl == null)
//      new Exception("*** NULL SETTER ***").printStackTrace();
}

 public  void setMaxAdministrativeTaskTime(int maxAdministrativeTaskTime) 
{
 
        wcpds.setMaxAdministrativeTaskTime( maxAdministrativeTaskTime ); 
        this.resetPoolManager( false );
}

 public  void setMaxConnectionAge(int maxConnectionAge) 
{
 
        wcpds.setMaxConnectionAge( maxConnectionAge ); 
        this.resetPoolManager( false );
}

 public  void setMaxIdleTime(int maxIdleTime) 
{
 
        wcpds.setMaxIdleTime( maxIdleTime ); 
        this.resetPoolManager( false );
}

 public  void setMaxIdleTimeExcessConnections(int maxIdleTimeExcessConnections) 
{
 
        wcpds.setMaxIdleTimeExcessConnections( maxIdleTimeExcessConnections ); 
        this.resetPoolManager( false );
}

 public  void setMaxPoolSize(int maxPoolSize) 
{
 
        wcpds.setMaxPoolSize( maxPoolSize ); 
        this.resetPoolManager( false );
}

 public  void setMaxStatements(int maxStatements) 
{
 
        wcpds.setMaxStatements( maxStatements ); 
        this.resetPoolManager( false );
}

 public  void setMaxStatementsPerConnection(int maxStatementsPerConnection) 
{
 
        wcpds.setMaxStatementsPerConnection( maxStatementsPerConnection ); 
        this.resetPoolManager( false );
}

 public  void setMinPoolSize(int minPoolSize) 
{
 
        wcpds.setMinPoolSize( minPoolSize ); 
        this.resetPoolManager( false );
}

 public  void setOverrideDefaultPassword(String overrideDefaultPassword) 
{
 
        wcpds.setOverrideDefaultPassword( overrideDefaultPassword ); 
        this.resetPoolManager( false );
}

 public  void setOverrideDefaultUser(String overrideDefaultUser) 
{
 
        wcpds.setOverrideDefaultUser( overrideDefaultUser ); 
        this.resetPoolManager( false );
}

 public  void setPassword(String password) 
{
 
        dmds.setPassword( password ); 
        this.resetPoolManager( false );
}

 public  void setPreferredTestQuery(String preferredTestQuery) 
{
 
        wcpds.setPreferredTestQuery( preferredTestQuery ); 
        this.resetPoolManager( false );
}

 public  void setProperties(Properties properties) 
{
 
        //System.err.println("setting properties: " + properties); 
        dmds.setProperties( properties ); 
        this.resetPoolManager(false);
}

 public  void setPropertyCycle(int propertyCycle) 
{
 
        wcpds.setPropertyCycle( propertyCycle ); 
        this.resetPoolManager( false );
}

 public  void setTestConnectionOnCheckin(boolean testConnectionOnCheckin) 
{
 
        wcpds.setTestConnectionOnCheckin( testConnectionOnCheckin ); 
        this.resetPoolManager( false );
}

 public  void setTestConnectionOnCheckout(boolean testConnectionOnCheckout) 
{
 
        wcpds.setTestConnectionOnCheckout( testConnectionOnCheckout ); 
        this.resetPoolManager( false );
}

 public  void setUnreturnedConnectionTimeout(int unreturnedConnectionTimeout) 
{
        wcpds.setUnreturnedConnectionTimeout( unreturnedConnectionTimeout ); 
        this.resetPoolManager( false );
}

 public  void setUser(String user) 
{
 
        dmds.setUser( user ); 
        this.resetPoolManager( false );
}

 public  void setUserOverridesAsString(String userOverridesAsString) throws PropertyVetoException 
{
 
        wcpds.setUserOverridesAsString( userOverridesAsString ); 
        this.resetPoolManager( false );
}

 public  void setUsesTraditionalReflectiveProxies(boolean usesTraditionalReflectiveProxies) 
{
 
        wcpds.setUsesTraditionalReflectiveProxies( usesTraditionalReflectiveProxies ); 
        this.resetPoolManager( false );
}

 public String toString() 
{
        //System.err.println("ComboPooledDataSource.toString()");
        StringBuffer sb = new StringBuffer(512);
        sb.append( this.getClass().getName() );
        sb.append(" [ ");
        try { BeansUtils.appendPropNamesAndValues(sb, this, TO_STRING_IGNORE_PROPS); }
        catch (Exception e)
        { 
            sb.append( e.toString() ); 
            //e.printStackTrace();
        }
        sb.append(" ]");
//      Map userOverrides = wcpds.getUserOverrides();
//      if (userOverrides != null)
//      sb.append("; userOverrides: " + userOverrides.toString());
        return sb.toString();
}