ConnectionPoolConfigurationBuilder.h

Go to the documentation of this file.

#ifndef CONNECTIONPOOLCONFIGURATIONBUILDER_H_
#define CONNECTIONPOOLCONFIGURATIONBUILDER_H_
 
#include "infinispan/hotrod/ImportExport.h"
#include "ConfigurationChildBuilder.h"
 
namespace infinispan {
namespace hotrod {
 
class ConnectionPoolConfigurationBuilder
  : public ConfigurationChildBuilder
{
  public:
    ConnectionPoolConfigurationBuilder(ConfigurationBuilder &builder):
        ConfigurationChildBuilder(builder),
        m_exhaustedAction(WAIT),
        m_lifo(true),
        m_maxActive(8),
        m_maxTotal(-1),
        m_maxWait(-1),
        m_maxIdle(8),
        m_minIdle(0),
        m_numTestsPerEvictionRun(3),
        m_timeBetweenEvictionRuns(120000),
        m_minEvictableIdleTime(1000l * 60l * 30l),
        m_testOnBorrow(false),
        m_testOnReturn(false),
        m_testWhileIdle(true) {}
    virtual void validate() {}
    virtual ~ConnectionPoolConfigurationBuilder() {}
 
    ConnectionPoolConfigurationBuilder& exhaustedAction(ExhaustedAction exhaustedAction_) {
        m_exhaustedAction = exhaustedAction_;
        return *this;
    }
 
    ConnectionPoolConfigurationBuilder& lifo(bool lifo_) {
        m_lifo = lifo_;
        return *this;
    }
 
    ConnectionPoolConfigurationBuilder& maxActive(int maxActive_) {
        m_maxActive = maxActive_;
        return *this;
    }
 
    ConnectionPoolConfigurationBuilder& maxTotal(int maxTotal_) {
        m_maxTotal = maxTotal_;
        return *this;
    }
 
    ConnectionPoolConfigurationBuilder& maxWait(long maxWait_) {
        m_maxWait = maxWait_;
        return *this;
    }
 
    ConnectionPoolConfigurationBuilder& maxIdle(int maxIdle_) {
        m_maxIdle = maxIdle_;
        return *this;
    }
 
    ConnectionPoolConfigurationBuilder& minIdle(int minIdle_) {
        m_minIdle = minIdle_;
        return *this;
    }
 
    ConnectionPoolConfigurationBuilder& numTestsPerEvictionRun(int numTestsPerEvictionRun_) {
        m_numTestsPerEvictionRun = numTestsPerEvictionRun_;
        return *this;
    }
 
    ConnectionPoolConfigurationBuilder& timeBetweenEvictionRuns(int timeBetweenEvictionRuns_) {
        m_timeBetweenEvictionRuns = timeBetweenEvictionRuns_;
        return *this;
    }
 
    ConnectionPoolConfigurationBuilder& minEvictableIdleTime(int minEvictableIdleTime_) {
        m_minEvictableIdleTime = minEvictableIdleTime_;
        return *this;
    }
 
    ConnectionPoolConfigurationBuilder& testOnBorrow(bool testOnBorrow_) {
        m_testOnBorrow = testOnBorrow_;
        return *this;
    }
 
    ConnectionPoolConfigurationBuilder& testOnReturn(bool testOnReturn_) {
        m_testOnReturn = testOnReturn_;
        return *this;
    }
 
    ConnectionPoolConfigurationBuilder& testWhileIdle(bool testWhileIdle_) {
        m_testWhileIdle = testWhileIdle_;
        return *this;
    }
 
    virtual ConnectionPoolConfiguration create() {
        return ConnectionPoolConfiguration(
            m_exhaustedAction,
            m_lifo,
            m_maxActive,
            m_maxTotal,
            m_maxWait,
            m_maxIdle,
            m_minIdle,
            m_numTestsPerEvictionRun,
            m_timeBetweenEvictionRuns,
            m_minEvictableIdleTime,
            m_testOnBorrow,
            m_testOnReturn,
            m_testWhileIdle);
    }
    virtual ConnectionPoolConfigurationBuilder& read(ConnectionPoolConfiguration& configuration) {
        // FIXME: implement
        (void) configuration;
        return *this;
    }
 
  private:
    ExhaustedAction m_exhaustedAction;
    bool m_lifo;
    int m_maxActive;
    int m_maxTotal;
    long m_maxWait;
    int m_maxIdle;
    int m_minIdle;
    int m_numTestsPerEvictionRun;
    int m_timeBetweenEvictionRuns;
    int m_minEvictableIdleTime;
    bool m_testOnBorrow;
    bool m_testOnReturn;
    bool m_testWhileIdle;
};
 
}} //namespace
#endif /* CONNECTIONPOOLCONFIGURATIONBUILDER_H_ */