NearCacheConfig.h

/*
 * Copyright (c) 2008-2017, Hazelcast, Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef HAZELCAST_CLIENT_CONFIG_NEARCACHECONFIG_H_
#define HAZELCAST_CLIENT_CONFIG_NEARCACHECONFIG_H_

#include <string>
#include <sstream>
#include <stdint.h>

#include <boost/shared_ptr.hpp>

#include "hazelcast/client/config/InMemoryFormat.h"
#include "hazelcast/client/config/EvictionConfig.h"
#include "hazelcast/client/config/NearCacheConfigBase.h"
#include "hazelcast/client/serialization/pimpl/Data.h"
#include "hazelcast/client/TypedData.h"

#if  defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(push)
#pragma warning(disable: 4251) //for dll export 
#endif

namespace hazelcast {
    namespace client {
        namespace config {
            template <typename K, typename V>
            class NearCacheConfig : public NearCacheConfigBase {
            public:
                static const int32_t DEFAULT_TTL_SECONDS;

                static const int32_t DEFAULT_MAX_IDLE_SECONDS;

                static const InMemoryFormat DEFAULT_MEMORY_FORMAT;

                enum LocalUpdatePolicy {
                            INVALIDATE,

                            CACHE
                };

                NearCacheConfig() : name("default"), timeToLiveSeconds(DEFAULT_TTL_SECONDS),
                                    maxIdleSeconds(DEFAULT_MAX_IDLE_SECONDS),
                                    inMemoryFormat(DEFAULT_MEMORY_FORMAT),
                                    localUpdatePolicy(INVALIDATE), invalidateOnChange(true), cacheLocalEntries(false),
                                    evictionConfig(new EvictionConfig<K, V>()) {
                }

                NearCacheConfig(const char *cacheName) : name(cacheName), timeToLiveSeconds(DEFAULT_TTL_SECONDS),
                                                         maxIdleSeconds(DEFAULT_MAX_IDLE_SECONDS),
                                                         inMemoryFormat(DEFAULT_MEMORY_FORMAT),
                                                         localUpdatePolicy(INVALIDATE), invalidateOnChange(true),
                                                         cacheLocalEntries(false),
                                                         evictionConfig(new EvictionConfig<K, V>()) {
                }

                NearCacheConfig(const char *cacheName, InMemoryFormat memoryFormat) : name(cacheName), timeToLiveSeconds(DEFAULT_TTL_SECONDS),
                                                         maxIdleSeconds(DEFAULT_MAX_IDLE_SECONDS),
                                                         inMemoryFormat(memoryFormat),
                                                         localUpdatePolicy(INVALIDATE), invalidateOnChange(true),
                                                         cacheLocalEntries(false),
                                                         evictionConfig(new EvictionConfig<K, V>()) {
                }

                NearCacheConfig(int32_t timeToLiveSeconds, int32_t maxIdleSeconds, bool invalidateOnChange,
                                InMemoryFormat inMemoryFormat, boost::shared_ptr<EvictionConfig<K, V> > evictConfig)
                        : evictionConfig(new EvictionConfig<K, V>()) {
                    this->timeToLiveSeconds = timeToLiveSeconds;
                    this->maxIdleSeconds = maxIdleSeconds;
                    this->invalidateOnChange = invalidateOnChange;
                    this->inMemoryFormat = inMemoryFormat;
                    localUpdatePolicy= INVALIDATE;
                    // EvictionConfig is not allowed to be NULL
                    if (evictConfig.get() != NULL) {
                        this->evictionConfig = evictConfig;
                    }
                    this->cacheLocalEntries = false;
                }

                NearCacheConfig(const NearCacheConfig<K, V> &config) {
                    name = config.getName();
                    inMemoryFormat = config.getInMemoryFormat();
                    invalidateOnChange = config.isInvalidateOnChange();
                    maxIdleSeconds = config.getMaxIdleSeconds();
                    timeToLiveSeconds = config.getTimeToLiveSeconds();
                    cacheLocalEntries = config.isCacheLocalEntries();
                    localUpdatePolicy = config.localUpdatePolicy;
                    // EvictionConfig is not allowed to be NULL
                    if (config.evictionConfig.get() != NULL) {
                        this->evictionConfig = config.evictionConfig;
                    }
                }

                virtual ~NearCacheConfig() {
                }

                const std::string &getName() const {
                    return name;
                }

                NearCacheConfig &setName(const std::string &name) {
                    this->name = name;
                    return *this;
                }

                int32_t getTimeToLiveSeconds() const {
                    return timeToLiveSeconds;
                }

                NearCacheConfig &setTimeToLiveSeconds(int32_t timeToLiveSeconds) {
                    this->timeToLiveSeconds = util::Preconditions::checkNotNegative(timeToLiveSeconds,
                                                                                    "TTL seconds cannot be negative!");
                    return *this;
                }

                int32_t getMaxIdleSeconds() const {
                    return maxIdleSeconds;
                }

                NearCacheConfig &setMaxIdleSeconds(int32_t maxIdleSeconds) {
                    this->maxIdleSeconds = util::Preconditions::checkNotNegative(maxIdleSeconds,
                                                                                 "Max-Idle seconds cannot be negative!");
                    return *this;
                }

                bool isInvalidateOnChange() const {
                    return invalidateOnChange;
                }

                NearCacheConfig &setInvalidateOnChange(bool invalidateOnChange) {
                    this->invalidateOnChange = invalidateOnChange;
                    return *this;
                }

                const InMemoryFormat &getInMemoryFormat() const {
                    return inMemoryFormat;
                }

                virtual NearCacheConfig &setInMemoryFormat(const InMemoryFormat &inMemoryFormat) {
                    this->inMemoryFormat = inMemoryFormat;
                    return *this;
                }

                bool isCacheLocalEntries() const {
                    return cacheLocalEntries;
                }

                NearCacheConfig &setCacheLocalEntries(bool cacheLocalEntries) {
                    this->cacheLocalEntries = cacheLocalEntries;
                    return *this;
                }

                const LocalUpdatePolicy &getLocalUpdatePolicy() const {
                    return localUpdatePolicy;
                }

                NearCacheConfig &setLocalUpdatePolicy(const LocalUpdatePolicy &localUpdatePolicy) {
                    this->localUpdatePolicy = localUpdatePolicy;
                    return *this;
                }

                const boost::shared_ptr<EvictionConfig<K, V> > &getEvictionConfig() const {
                    return evictionConfig;
                }

                NearCacheConfig &setEvictionConfig(const boost::shared_ptr<EvictionConfig<K, V> > &evictionConfig) {
                    this->evictionConfig = util::Preconditions::checkNotNull<EvictionConfig<K, V> >(evictionConfig,
                                                                                                    "EvictionConfig cannot be NULL!");
                    return *this;
                }

                std::ostream &operator<<(std::ostream &out) {
                    out << "NearCacheConfig{"
                        << "timeToLiveSeconds=" << timeToLiveSeconds
                        << ", maxIdleSeconds=" << maxIdleSeconds
                        << ", invalidateOnChange=" << invalidateOnChange
                        << ", inMemoryFormat=" << inMemoryFormat
                        << ", cacheLocalEntries=" << cacheLocalEntries
                        << ", localUpdatePolicy=" << localUpdatePolicy
                        << *evictionConfig;
                    out << '}';

                    return out;
                }
            private:
                std::string name;

                int32_t timeToLiveSeconds;
                int32_t maxIdleSeconds;

                InMemoryFormat inMemoryFormat;

                LocalUpdatePolicy localUpdatePolicy;

                bool invalidateOnChange;
                bool cacheLocalEntries;

                boost::shared_ptr<EvictionConfig<K, V> > evictionConfig;

                int32_t calculateMaxSize(int32_t maxSize) {
                    return (maxSize == 0) ? INT32_MAX : util::Preconditions::checkNotNegative(maxSize,
                                                                                              "Max-size cannot be negative!");
                }
            };

            template<typename K, typename V>
            const int32_t NearCacheConfig<K, V>::DEFAULT_TTL_SECONDS = 0;

            template<typename K, typename V>
            const int32_t NearCacheConfig<K, V>::DEFAULT_MAX_IDLE_SECONDS = 0;

            template<typename K, typename V>
            const InMemoryFormat NearCacheConfig<K, V>::DEFAULT_MEMORY_FORMAT = BINARY;

        }

        namespace mixedtype {
            namespace config {
                class HAZELCAST_API MixedNearCacheConfig : public client::config::NearCacheConfig<TypedData, TypedData> {
                public:
                    MixedNearCacheConfig(const char *cacheName)
                            : client::config::NearCacheConfig<TypedData, TypedData>(cacheName) {
                    }

                    virtual MixedNearCacheConfig &setInMemoryFormat(const client::config::InMemoryFormat &inMemoryFormat) {
                        if (client::config::OBJECT == inMemoryFormat) {
                            throw exception::IllegalArgumentException(
                                    "MixedNearCacheConfig does not allow setting the in memory format different from BINARY.");
                        }

                        client::config::NearCacheConfig<TypedData, TypedData>::setInMemoryFormat(inMemoryFormat);
                        return *this;
                    }
                };
            }
        }
    }
}

#if  defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(pop)
#endif

#endif /* HAZELCAST_CLIENT_CONFIG_NEARCACHECONFIG_H_ */