← Back to branch summary

~ubuntu-branches/ubuntu/raring/ceph/raring

« back to all changes in this revision

Viewing changes to src/leveldb/include/leveldb/cache.h

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2012-07-19 08:28:18 UTC
  • Revision ID: package-import@ubuntu.com-20120719082818-rdnt9r2hc0ced8n5
Tags: 0.48-1ubuntu2
* Drop use of in-tree dependencies, re-align with Debian:
  - d/patches/{intree_leveldb|add-powerpc-support}.patch: Dropped.
  - d/patches/series: Use patches to support lib{leveldb|s3}-dev usage.
  - d/control: BD on libsnappy-dev, liblevedb-dev, libs3-dev.
  - d/rules: Use system provided leveldb and libs3.
  - d/rules: Enable hardening.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/leveldb/include/leveldb/cache.h
1
 
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
2
 
// Use of this source code is governed by a BSD-style license that can be
3
 
// found in the LICENSE file. See the AUTHORS file for names of contributors.
4
 
//
5
 
// A Cache is an interface that maps keys to values.  It has internal
6
 
// synchronization and may be safely accessed concurrently from
7
 
// multiple threads.  It may automatically evict entries to make room
8
 
// for new entries.  Values have a specified charge against the cache
9
 
// capacity.  For example, a cache where the values are variable
10
 
// length strings, may use the length of the string as the charge for
11
 
// the string.
12
 
//
13
 
// A builtin cache implementation with a least-recently-used eviction
14
 
// policy is provided.  Clients may use their own implementations if
15
 
// they want something more sophisticated (like scan-resistance, a
16
 
// custom eviction policy, variable cache sizing, etc.)
17
 
 
18
 
#ifndef STORAGE_LEVELDB_INCLUDE_CACHE_H_
19
 
#define STORAGE_LEVELDB_INCLUDE_CACHE_H_
20
 
 
21
 
#include <stdint.h>
22
 
#include "leveldb/slice.h"
23
 
 
24
 
namespace leveldb {
25
 
 
26
 
class Cache;
27
 
 
28
 
// Create a new cache with a fixed size capacity.  This implementation
29
 
// of Cache uses a least-recently-used eviction policy.
30
 
extern Cache* NewLRUCache(size_t capacity);
31
 
 
32
 
class Cache {
33
 
 public:
34
 
  Cache() { }
35
 
 
36
 
  // Destroys all existing entries by calling the "deleter"
37
 
  // function that was passed to the constructor.
38
 
  virtual ~Cache();
39
 
 
40
 
  // Opaque handle to an entry stored in the cache.
41
 
  struct Handle { };
42
 
 
43
 
  // Insert a mapping from key->value into the cache and assign it
44
 
  // the specified charge against the total cache capacity.
45
 
  //
46
 
  // Returns a handle that corresponds to the mapping.  The caller
47
 
  // must call this->Release(handle) when the returned mapping is no
48
 
  // longer needed.
49
 
  //
50
 
  // When the inserted entry is no longer needed, the key and
51
 
  // value will be passed to "deleter".
52
 
  virtual Handle* Insert(const Slice& key, void* value, size_t charge,
53
 
                         void (*deleter)(const Slice& key, void* value)) = 0;
54
 
 
55
 
  // If the cache has no mapping for "key", returns NULL.
56
 
  //
57
 
  // Else return a handle that corresponds to the mapping.  The caller
58
 
  // must call this->Release(handle) when the returned mapping is no
59
 
  // longer needed.
60
 
  virtual Handle* Lookup(const Slice& key) = 0;
61
 
 
62
 
  // Release a mapping returned by a previous Lookup().
63
 
  // REQUIRES: handle must not have been released yet.
64
 
  // REQUIRES: handle must have been returned by a method on *this.
65
 
  virtual void Release(Handle* handle) = 0;
66
 
 
67
 
  // Return the value encapsulated in a handle returned by a
68
 
  // successful Lookup().
69
 
  // REQUIRES: handle must not have been released yet.
70
 
  // REQUIRES: handle must have been returned by a method on *this.
71
 
  virtual void* Value(Handle* handle) = 0;
72
 
 
73
 
  // If the cache contains entry for key, erase it.  Note that the
74
 
  // underlying entry will be kept around until all existing handles
75
 
  // to it have been released.
76
 
  virtual void Erase(const Slice& key) = 0;
77
 
 
78
 
  // Return a new numeric id.  May be used by multiple clients who are
79
 
  // sharing the same cache to partition the key space.  Typically the
80
 
  // client will allocate a new id at startup and prepend the id to
81
 
  // its cache keys.
82
 
  virtual uint64_t NewId() = 0;
83
 
 
84
 
 private:
85
 
  void LRU_Remove(Handle* e);
86
 
  void LRU_Append(Handle* e);
87
 
  void Unref(Handle* e);
88
 
 
89
 
  struct Rep;
90
 
  Rep* rep_;
91
 
 
92
 
  // No copying allowed
93
 
  Cache(const Cache&);
94
 
  void operator=(const Cache&);
95
 
};
96
 
 
97
 
}  // namespace leveldb
98
 
 
99
 
#endif  // STORAGE_LEVELDB_UTIL_CACHE_H_