FilePersistentCache.h

Go to the documentation of this file.

/*
 * Copyright 2017-present Facebook, Inc.
 *
 * 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 <folly/FileUtil.h>
#include <folly/Memory.h>
#include <folly/ScopeGuard.h>
#include <folly/json.h>
#include <wangle/client/persistence/LRUPersistentCache.h>

namespace wangle {

template<typename K, typename V, typename M = std::mutex>
class FilePersistentCache : public PersistentCache<K, V>,
                            private boost::noncopyable {
 public:
  FilePersistentCache(
      const std::string& file,
      std::size_t cacheCapacity,
      std::chrono::seconds syncInterval =
          std::chrono::duration_cast<std::chrono::seconds>(
              client::persistence::DEFAULT_CACHE_SYNC_INTERVAL),
      int nSyncRetries = client::persistence::DEFAULT_CACHE_SYNC_RETRIES);

  FilePersistentCache(
      std::shared_ptr<folly::Executor> executor,
      const std::string& file,
      std::size_t cacheCapacity,
      std::chrono::seconds syncInterval,
      int nSyncRetries);

  ~FilePersistentCache() override {}

  folly::Optional<V> get(const K& key) override {
    return cache_->get(key);
  }

  void put(const K& key, const V& val) override {
    cache_->put(key, val);
  }

  bool remove(const K& key) override {
    return cache_->remove(key);
  }

  void clear(bool clearPersistence = false) override {
    cache_->clear(clearPersistence);
  }

  size_t size() override {
    return cache_->size();
  }

  void setSyncOnDestroy(bool syncOnDestroy) {
    cache_->setSyncOnDestroy(syncOnDestroy);
  }

 private:
  typename LRUPersistentCache<K, V, M>::Ptr cache_;
};

} // namespace wangle

#include <wangle/client/persistence/FilePersistentCache-inl.h>