lru_cache.h

Go to the documentation of this file.

/*
 * Copyright 2010 Google 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.
 */


#ifndef PAGESPEED_KERNEL_CACHE_LRU_CACHE_H_
#define PAGESPEED_KERNEL_CACHE_LRU_CACHE_H_

#include <cstddef>
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/cache_interface.h"
#include "pagespeed/kernel/base/shared_string.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/cache/lru_cache_base.h"

namespace net_instaweb {

class LRUCache : public CacheInterface {
 public:
  explicit LRUCache(size_t max_size);
  virtual ~LRUCache();

  virtual void Get(const GoogleString& key, Callback* callback);

  virtual void Put(const GoogleString& key, const SharedString& new_value);
  virtual void Delete(const GoogleString& key);

  void DeleteWithPrefixForTesting(StringPiece prefix);

  size_t size_bytes() const { return base_.size_bytes(); }

  size_t max_bytes_in_cache() const { return base_.max_bytes_in_cache(); }

  size_t num_elements() const { return base_.num_elements(); }

  size_t num_evictions() const { return base_.num_evictions(); }
  size_t num_hits() const { return base_.num_hits(); }
  size_t num_misses() const { return base_.num_misses(); }
  size_t num_inserts() const { return base_.num_inserts(); }
  size_t num_identical_reinserts() const {
    return base_.num_identical_reinserts();
  }
  size_t num_deletes() const { return base_.num_deletes(); }

  void SanityCheck() { base_.SanityCheck(); }

  void Clear() { base_.Clear(); }

  void ClearStats() { base_.ClearStats(); }

  static GoogleString FormatName() { return "LRUCache"; }
  virtual GoogleString Name() const { return FormatName(); }
  virtual bool IsBlocking() const { return true; }
  virtual bool IsHealthy() const { return is_healthy_; }
  virtual void ShutDown() { set_is_healthy(false); }

  void set_is_healthy(bool x) { is_healthy_ = x; }

 private:
  struct SharedStringHelper {
    size_t size(const SharedString& ss) const {
      return ss.size();
    }
    bool Equal(const SharedString& a, const SharedString& b) const {
      return a.Value() == b.Value();
    }
    void EvictNotify(const SharedString& a) {}
    bool ShouldReplace(const SharedString& old_value,
                       const SharedString& new_value) const {
      return true;
    }
  };
  typedef LRUCacheBase<SharedString, SharedStringHelper> Base;

  Base base_;
  bool is_healthy_;
  SharedStringHelper value_helper_;

  
};

}  

#endif