Cache.h

Go to the documentation of this file.

#ifndef INCLUDE_MOLASSEMBLER_TEMPLE_CACHE_H
#define INCLUDE_MOLASSEMBLER_TEMPLE_CACHE_H

#include <boost/any.hpp>
#include <boost/optional.hpp>

#include <map>
#include <string>
#include <functional>
#include <cassert>
#include <vector>

namespace Scine {
namespace Molassembler {
namespace Temple {

template<typename KeyType, typename ValueType>
class MinimalCache {
public:
  using key_type = KeyType;
  using value_type = ValueType;

  void add(const KeyType key, const ValueType value) {
    cache_.emplace(
      std::move(key),
      std::move(value)
    );
  }

  void invalidate() {
    cache_.clear();
  }

  void invalidate(const KeyType& key) {
    if(cache_.count(key) == 1) {
      cache_.erase(key);
    }
  }

  boost::optional<const ValueType&> getOption(const KeyType& key) const {
    if(cache_.count(key) == 1) {
      return boost::optional<const ValueType&>(
        cache_.at(key)
      );
    }

    return {};
  }

  bool has(const KeyType& key) const {
    return cache_.count(key) > 0;
  }

  const ValueType& get(const KeyType& key) const {
    if(cache_.count(key) == 0) {
      throw "Fetching member in Cache whose key does not exist!";
    }

    return cache_.at(key);
  }

private:
/* Private members */
  std::map<KeyType, ValueType> cache_;
};

template<typename KeyType>
class Cache {
public:
  Cache() = default;
  Cache(
    const std::initializer_list<
      std::pair<
        KeyType,
        std::function<
          boost::any()
        >
      >
    >& initList
  ) {
    // add all generators
    for(const auto& pair: initList) {
      generationMap_[pair.first] = pair.second;
    }
  }


  template<typename T>
  void add(const KeyType& key, const T& value) {
    cache_.emplace(
      key,
      value
    );
  }

  template<typename T>
  T getGeneratable(const KeyType& key) {
    // if this is false, user has violated contract
    assert(generationMap_.count(key) == 1);

    if(cache_.count(key) == 1) {
      return boost::any_cast<T>(
        cache_.at(key)
      );
    }

    cache_.emplace(
      key,
      generationMap_.at(key)() // calling it!
    );

    return boost::any_cast<T>(
      cache_.at(key)
    );
  }

  /* C++17
   * get rid of the raw pointer using map's extract and insert
   */
  template<typename T>
  void changeGeneratable(
    const KeyType& key,
    std::function<
      void(T*)
    > modifyingUnaryFunction
  ) {
    assert(generationMap_.count(key) == 1);

    // if the generatable does not exist yet, generate it
    if(cache_.count(key) == 0) {
      cache_.emplace(
        key,
        generationMap_.at(key)()
      );
    }

    // modify it
    modifyingUnaryFunction(
      boost::any_cast<T>(
        &(
          cache_.find(key) -> second
        )
      )
    );

  }

  void invalidate() {
    cache_.clear();
  }

  void invalidate(const KeyType& key) {
    if(cache_.count(key) == 1) {
      cache_.erase(key);
    }
  }

  template<typename T>
  boost::optional<T> getOption(const KeyType& key) const {
    if(cache_.count(key) == 1) {
      return boost::optional<T>(
        boost::any_cast<T>(
          cache_.at(key)
        )
      );
    }

    return {};
  }

  bool has(const KeyType& key) const {
    return (cache_.count(key) > 0);
  }

private:
/* Private members */
  std::map<
    KeyType,
    boost::any
  > cache_;

  std::map<
    KeyType,
    std::function<
      boost::any()
    >
  > generationMap_;
};

} // namespace Temple
} // namespace Molassembler
} // namespace Scine

#endif