cppcache/src/RegionAttributesFactory.cpp

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

#include <cstdlib>
#include <string>

#include <geode/Cache.hpp>
#include <geode/ExpirationAttributes.hpp>
#include <geode/Pool.hpp>
#include <geode/PoolManager.hpp>

#include "DistributedSystem.hpp"
#include "Utils.hpp"

namespace apache {
namespace geode {
namespace client {

class Region;

RegionAttributesFactory::RegionAttributesFactory() : m_regionAttributes() {}

RegionAttributesFactory::RegionAttributesFactory(
    const RegionAttributes regionAttributes)
    : m_regionAttributes(regionAttributes) {}

RegionAttributesFactory::~RegionAttributesFactory() {}

RegionAttributesFactory& RegionAttributesFactory::setCacheLoader(
    const std::shared_ptr<CacheLoader>& cacheLoader) {
  m_regionAttributes.m_cacheLoader = cacheLoader;
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setCacheWriter(
    const std::shared_ptr<CacheWriter>& cacheWriter) {
  m_regionAttributes.m_cacheWriter = cacheWriter;
  return *this;
}
RegionAttributesFactory& RegionAttributesFactory::setCacheListener(
    const std::shared_ptr<CacheListener>& aListener) {
  m_regionAttributes.m_cacheListener = aListener;
  return *this;
}
RegionAttributesFactory& RegionAttributesFactory::setPartitionResolver(
    const std::shared_ptr<PartitionResolver>& aResolver) {
  m_regionAttributes.m_partitionResolver = aResolver;
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setCacheLoader(
    const std::string& lib, const std::string& func) {
  m_regionAttributes.setCacheLoader(lib, func);
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setCacheWriter(
    const std::string& lib, const std::string& func) {
  m_regionAttributes.setCacheWriter(lib, func);
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setCacheListener(
    const std::string& lib, const std::string& func) {
  m_regionAttributes.setCacheListener(lib, func);
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setPartitionResolver(
    const std::string& lib, const std::string& func) {
  m_regionAttributes.setPartitionResolver(lib, func);
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setEntryIdleTimeout(
    ExpirationAction action, std::chrono::seconds idleTimeout) {
  m_regionAttributes.m_entryIdleTimeout = idleTimeout;
  m_regionAttributes.m_entryIdleTimeoutExpirationAction = action;
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setEntryTimeToLive(
    ExpirationAction action, std::chrono::seconds timeToLive) {
  m_regionAttributes.m_entryTimeToLive = timeToLive;
  m_regionAttributes.m_entryTimeToLiveExpirationAction = action;
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setRegionIdleTimeout(
    ExpirationAction action, std::chrono::seconds idleTimeout) {
  m_regionAttributes.m_regionIdleTimeout = idleTimeout;
  m_regionAttributes.m_regionIdleTimeoutExpirationAction = action;
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setRegionTimeToLive(
    ExpirationAction action, std::chrono::seconds timeToLive) {
  m_regionAttributes.m_regionTimeToLive = timeToLive;
  m_regionAttributes.m_regionTimeToLiveExpirationAction = action;
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setInitialCapacity(
    int32_t initialCapacity) {
  m_regionAttributes.m_initialCapacity = initialCapacity;
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setLoadFactor(
    float loadFactor) {
  m_regionAttributes.m_loadFactor = loadFactor;
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setConcurrencyLevel(
    uint8_t concurrencyLevel) {
  m_regionAttributes.m_concurrencyLevel = concurrencyLevel;
  return *this;
}

RegionAttributes RegionAttributesFactory::create() {
  validateAttributes(m_regionAttributes);
  RegionAttributes regionAttributes(m_regionAttributes);
  return regionAttributes;  // RegionAttributes(m_regionAttributes);
}

void RegionAttributesFactory::validateAttributes(RegionAttributes& attrs) {
  if (!attrs.m_caching) {
    if (attrs.m_entryTimeToLive != std::chrono::seconds::zero()) {
      throw IllegalStateException(
          "Entry TimeToLive use is incompatible with disabled caching");
    }

    if (attrs.m_entryIdleTimeout != std::chrono::seconds::zero()) {
      throw IllegalStateException(
          "Entry IdleTimeout use is incompatible with disabled caching");
    }

    if (attrs.m_lruEntriesLimit != 0) {
      throw IllegalStateException(
          "Non-zero LRU entries limit is incompatible with disabled caching");
    }
    if (attrs.m_diskPolicy != DiskPolicyType::NONE) {
      if (attrs.m_lruEntriesLimit == 0) {
        throw IllegalStateException(
            "When DiskPolicy is OVERFLOWS, LRU entries limit must be non-zero "
            "with disabled caching");
      }
    }
  }

  if (attrs.m_diskPolicy != DiskPolicyType::NONE) {
    if (attrs.m_persistenceManager == nullptr &&
        (attrs.m_persistenceLibrary.empty() ||
         attrs.m_persistenceFactory.empty())) {
      throw IllegalStateException(
          "Persistence Manager must be set if DiskPolicy is OVERFLOWS");
    }
  }
  if (attrs.m_diskPolicy != DiskPolicyType::NONE) {
    if (attrs.m_lruEntriesLimit == 0) {
      throw IllegalStateException(
          "LRU entries limit cannot be zero if DiskPolicy is OVERFLOWS");
    }
  }
}

RegionAttributesFactory& RegionAttributesFactory::setLruEntriesLimit(
    const uint32_t entriesLimit) {
  m_regionAttributes.m_lruEntriesLimit = entriesLimit;
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setDiskPolicy(
    const DiskPolicyType diskPolicy) {
  if (diskPolicy == DiskPolicyType::PERSIST) {
    throw IllegalStateException("Persistence feature is not supported");
  }
  m_regionAttributes.m_diskPolicy = diskPolicy;
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setCachingEnabled(
    bool cachingEnabled) {
  m_regionAttributes.m_caching = cachingEnabled;
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setPersistenceManager(
    const std::shared_ptr<PersistenceManager>& persistenceManager,
    const std::shared_ptr<Properties>& props) {
  m_regionAttributes.m_persistenceManager = persistenceManager;
  m_regionAttributes.m_persistenceProperties = props;
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setPersistenceManager(
    const std::string& lib, const std::string& func,
    const std::shared_ptr<Properties>& config) {
  m_regionAttributes.setPersistenceManager(lib, func, config);
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setPoolName(
    const std::string& name) {
  m_regionAttributes.setPoolName(name);
  return *this;
}

RegionAttributesFactory& RegionAttributesFactory::setCloningEnabled(
    bool isClonable) {
  m_regionAttributes.setCloningEnabled(isClonable);
  return *this;
}
RegionAttributesFactory& RegionAttributesFactory::setConcurrencyChecksEnabled(
    bool enable) {
  m_regionAttributes.setConcurrencyChecksEnabled(enable);
  return *this;
}

}  // namespace client
}  // namespace geode
}  // namespace apache