base_map_cache.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2020 The Apollo Authors. 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.
 *****************************************************************************/
#pragma once

#include <functional>
#include <utility>
#include "cyber/common/log.h"

#include "modules/common/util/lru_cache.h"

namespace apollo {
namespace localization {
namespace msf {

template <class Key, class Element>
using LRUCache = ::apollo::common::util::LRUCache<Key, Element*>;

template <class Key, class Element, class MapLRUCache = LRUCache<Key, Element>>
class MapNodeCache {
 public:
  using DestroyFunc = std::function<bool(Element*)>;
  static bool CacheL1Destroy(Element* value) {
    value->SetIsReserved(false);
    return true;
  }
  static bool CacheL2Destroy(Element* value) {
    return !(value->GetIsReserved());
  }

 public:
  MapNodeCache(unsigned int capacity, const DestroyFunc& destroy_func)
      : destroy_func_(destroy_func), lru_map_nodes_(capacity) {}
  ~MapNodeCache() {}
  bool Get(const Key& key, Element** value);
  bool GetSilent(const Key& key, Element** value);
  Element* Put(const Key& key, Element* value);
  Element* Remove(const Key& key);
  Element* ClearOne();
  // bool clear();
  bool IsExist(const Key& key);

  bool ChangeCapacity(int capacity) {
    return lru_map_nodes_.ChangeCapacity(capacity);
  }
  unsigned int Size() { return lru_map_nodes_.size(); }
  unsigned Capacity() { return lru_map_nodes_.capacity(); }

 private:
  const DestroyFunc destroy_func_;
  MapLRUCache lru_map_nodes_;
};

template <class Key, class Element, class MapLRUCache>
bool MapNodeCache<Key, Element, MapLRUCache>::Get(const Key& key,
                                                  Element** value) {
  auto value_ptr = lru_map_nodes_.Get(key);
  if (!value_ptr) {
    return false;
  }
  *value = *value_ptr;
  return true;
}

template <class Key, class Element, class MapLRUCache>
bool MapNodeCache<Key, Element, MapLRUCache>::GetSilent(const Key& key,
                                                        Element** value) {
  auto value_ptr = lru_map_nodes_.GetSilently(key);
  if (!value_ptr) {
    return false;
  }
  *value = *value_ptr;
  return true;
}

template <class Key, class Element, class MapLRUCache>
Element* MapNodeCache<Key, Element, MapLRUCache>::Put(const Key& key,
                                                      Element* value) {
  if (value == nullptr) {
    AINFO << "LRUCache Warning: put a NULL";
    return nullptr;
  }

  auto* value_ptr = lru_map_nodes_.Get(key);
  Element* node_remove = nullptr;
  if (value_ptr) {
    node_remove = *value_ptr;
    if (destroy_func_(node_remove)) {
      *value_ptr = value;
    } else {
      node_remove = value;
    }
    return node_remove;
  }

  if (lru_map_nodes_.size() >= lru_map_nodes_.capacity()) {
    auto* node = lru_map_nodes_.Last();
    node_remove = node->val;
    Key key_tmp;
    lru_map_nodes_.PutAndGetObsolete(key, &value, &key_tmp);
    return node_remove;
  }

  lru_map_nodes_.Put(key, std::move(value));
  return node_remove;
}

template <class Key, class Element, class MapLRUCache>
Element* MapNodeCache<Key, Element, MapLRUCache>::Remove(const Key& key) {
  auto* node_remove = lru_map_nodes_.GetSilently(key);
  if (node_remove && lru_map_nodes_.Remove(key)) {
    return *node_remove;
  }

  return nullptr;
}

template <class Key, class Element, class MapLRUCache>
Element* MapNodeCache<Key, Element, MapLRUCache>::ClearOne() {
  auto* node_remove = lru_map_nodes_.Last();
  if (!node_remove) {
    return nullptr;
  }
  while (node_remove != lru_map_nodes_.First()) {
    if (destroy_func_(node_remove->val)) {
      lru_map_nodes_.Remove(node_remove->key);
      return node_remove->val;
    }
    node_remove = node_remove->prev;
  }
  if (node_remove == lru_map_nodes_.First() &&
      destroy_func_(node_remove->val)) {
    lru_map_nodes_.Remove(node_remove->key);
    return node_remove->val;
  }
  return nullptr;
}

template <class Key, class Element, class MapLRUCache>
bool MapNodeCache<Key, Element, MapLRUCache>::IsExist(const Key& key) {
  return lru_map_nodes_.Prioritize(key);
}

}  // namespace msf
}  // namespace localization
}  // namespace apollo