cppcache/src/EntriesMap.hpp

/*
 * 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.
 */

#pragma once

#ifndef GEODE_ENTRIESMAP_H_
#define GEODE_ENTRIESMAP_H_

// This needs to be ace free so that the region can include it.

#include <memory>

#include <geode/CacheableKey.hpp>
#include <geode/RegionEntry.hpp>
#include <geode/internal/geode_globals.hpp>

#include "MapEntry.hpp"
#include "MapSegment.hpp"

namespace apache {
namespace geode {
namespace client {

#define SYNCHRONIZE_SEGMENT_FOR_KEY(keyPtr) \
  SegmentMutexGuard _segment_guard(((EntriesMap*)m_entries)->segmentFor(keyPtr))

/**
 * @brief Concurrent entries map. Not designed for subclassing...
 */
class APACHE_GEODE_EXPORT EntriesMap {
 public:
  explicit EntriesMap(std::unique_ptr<EntryFactory> entryFactory)
      : m_entryFactory(std::move(entryFactory)) {}
  virtual ~EntriesMap() {}

  /**
   * Initialize segments with proper EntryFactory.
   */
  virtual void open(uint32_t initialCapacity = 5000) = 0;

  /** @brief Close the map. */
  virtual void close() = 0;

  /**
   * @brief put a value in the map, replacing if key already exists.
   */
  virtual GfErrType put(const std::shared_ptr<CacheableKey>& key,
                        const std::shared_ptr<Cacheable>& newValue,
                        std::shared_ptr<MapEntryImpl>& me,
                        std::shared_ptr<Cacheable>& oldValue, int updateCount,
                        int destroyTracker,
                        std::shared_ptr<VersionTag> versionTag,
                        bool& isUpdate = EntriesMap::boolVal,
                        DataInput* delta = nullptr) = 0;
  virtual GfErrType invalidate(const std::shared_ptr<CacheableKey>& key,
                               std::shared_ptr<MapEntryImpl>& me,
                               std::shared_ptr<Cacheable>& oldValue,
                               std::shared_ptr<VersionTag> versionTag) = 0;
  virtual GfErrType create(const std::shared_ptr<CacheableKey>& key,
                           const std::shared_ptr<Cacheable>& newValue,
                           std::shared_ptr<MapEntryImpl>& me,
                           std::shared_ptr<Cacheable>& oldValue,
                           int updateCount, int destroyTracker,
                           std::shared_ptr<VersionTag> versionTag) = 0;

  /**
   * @brief get a value out of the map; returns false if absent
   */
  virtual bool get(const std::shared_ptr<CacheableKey>& key,
                   std::shared_ptr<Cacheable>& value,
                   std::shared_ptr<MapEntryImpl>& me) = 0;

  /**
   * @brief get MapEntry for key; returns nullptr if absent
   */
  virtual void getEntry(const std::shared_ptr<CacheableKey>& key,
                        std::shared_ptr<MapEntryImpl>& result,
                        std::shared_ptr<Cacheable>& value) const = 0;
  /** @brief remove all entries in the map. */
  virtual void clear() = 0;

  /**
   * @brief remove the entry for key from the map;
   *   returns false and nullptr MapEntry if absent
   */
  virtual GfErrType remove(const std::shared_ptr<CacheableKey>& key,
                           std::shared_ptr<Cacheable>& result,
                           std::shared_ptr<MapEntryImpl>& me, int updateCount,
                           std::shared_ptr<VersionTag> versionTag,
                           bool afterRemote) = 0;

  /**
   * @brief return true if there exists an entry for the key.
   */
  virtual bool containsKey(const std::shared_ptr<CacheableKey>& key) const = 0;

  /**
   * @brief return the all the keys in a vector.
   */
  virtual void getKeys(
      std::vector<std::shared_ptr<CacheableKey>>& result) const = 0;

  /**
   * @brief return all the entries in a vector.
   */
  virtual void getEntries(
      std::vector<std::shared_ptr<RegionEntry>>& result) const = 0;

  /**
   * @brief return all values in a vector.
   */
  virtual void getValues(
      std::vector<std::shared_ptr<Cacheable>>& result) const = 0;

  /** @brief return the number of entries in the map. */
  virtual uint32_t size() const = 0;

  /**
   * Add a watch for updates for the given entry. If the entry is present in
   * the cache then the current update counter for the entry is returned,
   * else a new entry is created with destroyed token and zero is returned.
   * A failure value of -1 is returned if <addIfAbsent> is false and an
   * existing entry is not found or <failIfPresent> parameter is true
   * and an existing entry is found.
   * The parameter <incUpdateCount> should be set to true if this is a write
   * operation and update counter sould be incremented for the entry.
   */
  virtual int addTrackerForEntry(const std::shared_ptr<CacheableKey>& key,
                                 std::shared_ptr<Cacheable>& oldValue,
                                 bool addIfAbsent, bool failIfPresent,
                                 bool incUpdateCount) = 0;

  virtual void removeTrackerForEntry(
      const std::shared_ptr<CacheableKey>& key) = 0;

  /**
   * Add trackers for all the entries and returns the map of keys to
   * tracking number. The "addDestroyTracking" flag also adds tracking
   * for any destroys (e.g. through notification) to the map so that
   * subsequent creates do not overwrite the destroys.
   */
  virtual int addTrackerForAllEntries(MapOfUpdateCounters& updateCounterMap,
                                      bool addDestroyTracking) = 0;

  /**
   * Decrement destroy tracking flag for this map by one.
   */
  virtual void removeDestroyTracking() = 0;

  /**
   * @brief The MapSegment can be used to protect against concurrency...
   * SYNCHRONIZE_SEGMENT_FOR_KEY( keyPtr ) creates a guard that locks
   * and release the segment.
   */
  virtual MapSegment* segmentFor(
      const std::shared_ptr<CacheableKey>& key) const = 0;

  virtual std::shared_ptr<Cacheable> getFromDisk(
      const std::shared_ptr<CacheableKey>& key,
      std::shared_ptr<MapEntryImpl>& me) const;

  virtual void reapTombstones(std::map<uint16_t, int64_t>& gcVersions) = 0;

  virtual void reapTombstones(
      std::shared_ptr<CacheableHashSet> removedKeys) = 0;

  /**
   * for internal testing, returns if an entry is a tombstone
   */
  virtual GfErrType isTombstone(std::shared_ptr<CacheableKey>& key,
                                std::shared_ptr<MapEntryImpl>& me,
                                bool& result) = 0;

  static bool boolVal;

 protected:
  const std::unique_ptr<EntryFactory> m_entryFactory;

  /** @brief return the instance of EntryFactory for the segments to use. */
  inline const EntryFactory* getEntryFactory() const {
    return m_entryFactory.get();
  }

};  // class EntriesMap

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

#endif  // GEODE_ENTRIESMAP_H_