Configuration.h

Go to the documentation of this file.

#ifndef ISPN_HOTROD_CONFIGURATION_H
#define ISPN_HOTROD_CONFIGURATION_H



#include <string>
#include <vector>
#include "infinispan/hotrod/portable.h"
#include "infinispan/hotrod/ImportExport.h"
#include "ConnectionPoolConfiguration.h"
#include "ServerConfiguration.h"
#include "SslConfiguration.h"
#include "infinispan/hotrod/FailOverRequestBalancingStrategy.h"

namespace infinispan {
namespace hotrod {

// TODO: should we really return references?
class Configuration
{
  public:
    HR_EXTERN static const char* PROTOCOL_VERSION_10;
    HR_EXTERN static const char* PROTOCOL_VERSION_11;
    HR_EXTERN static const char* PROTOCOL_VERSION_12;
    HR_EXTERN static const char* PROTOCOL_VERSION_13;
    HR_EXTERN static const char* PROTOCOL_VERSION_20;
    HR_EXTERN static const char* PROTOCOL_VERSION_21;
    HR_EXTERN static const char* PROTOCOL_VERSION_22;
    HR_EXTERN static const char* PROTOCOL_VERSION_23;
    HR_EXTERN static const char* PROTOCOL_VERSION_24;


    Configuration(const std::string &_protocolVersion,
            const ConnectionPoolConfiguration& _connectionPoolConfiguration,
            int _connectionTimeout,
            bool _forceReturnValue,
            int _keySizeEstimate,
            std::vector<ServerConfiguration> _serversConfiguration,
            int _socketTimeout,
            const SslConfiguration _sslConfiguration,
            bool _tcpNoDelay,
            int _valueSizeEstimate,
            int _maxRetries,
            FailOverRequestBalancingStrategy::ProducerFn bsp=0):
                protocolVersion(_protocolVersion), protocolVersionPtr(),
                connectionPoolConfiguration(_connectionPoolConfiguration),
                connectionTimeout(_connectionTimeout), forceReturnValue(_forceReturnValue),
                keySizeEstimate(_keySizeEstimate), servers(_serversConfiguration),
                socketTimeout(_socketTimeout), sslConfiguration(_sslConfiguration),tcpNoDelay(_tcpNoDelay),
                valueSizeEstimate(_valueSizeEstimate), maxRetries(_maxRetries), balancingStrategyProducer(bsp) {}

    HR_EXTERN const std::string &getProtocolVersion() const {
        if (protocolVersionPtr.get() == NULL) {
            const_cast<Configuration *>(this)->protocolVersionPtr
                    .set(new std::string(protocolVersion.c_string()), &deleteString);
        }
        return *(protocolVersionPtr.get());
    }

    HR_EXTERN const char *getProtocolVersionCString() const;

    HR_EXTERN const ConnectionPoolConfiguration& getConnectionPoolConfiguration() const;

    HR_EXTERN const int& getConnectionTimeout() const;

    HR_EXTERN const bool& isForceReturnValue() const;

    HR_EXTERN const int& getKeySizeEstimate() const;

    std::vector<ServerConfiguration> getServersConfiguration() const {
        return servers.std_vector();
    }

    HR_EXTERN const int& getSocketTimeout() const;

    HR_EXTERN const SslConfiguration& getSslConfiguration() const;

    HR_EXTERN const bool& isTcpNoDelay() const;

    HR_EXTERN const int& getValueSizeEstimate() const;

    HR_EXTERN const int& getMaxRetries() const;

    HR_EXTERN FailOverRequestBalancingStrategy::ProducerFn getBalancingStrategy() const;

private:
    portable::string protocolVersion;
    portable::local_ptr<std::string> protocolVersionPtr;
    ConnectionPoolConfiguration connectionPoolConfiguration;
    int connectionTimeout;
    bool forceReturnValue;
    int keySizeEstimate;
    portable::vector<ServerConfiguration> servers;
    int socketTimeout;
    SslConfiguration sslConfiguration;
    bool tcpNoDelay;
    int valueSizeEstimate;
    int maxRetries;
    FailOverRequestBalancingStrategy::ProducerFn balancingStrategyProducer;

    static void deleteString(std::string *str) { delete str; }
};

}} // namespace

#endif /* ISPN_HOTROD_CONFIGURATION_H */