android/android-emugl/host/libs/libGLES12Translator/gles/mru_cache.h

/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * 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 GRAPHICS_TRANSLATION_GLES_MRU_CACHE_H_
#define GRAPHICS_TRANSLATION_GLES_MRU_CACHE_H_

#include <list>
#include <utility>

// A container of a limited number of objects that are managed in a most
// recently used manner and can be looked up by a Key.
template <typename Key, typename Value>
class MruCache {
 public:
  // Typedef for the function that can be used to clean up objects if/when
  // they get removed from the cache.
  typedef void (*DestroyFn)(Value* v);

  typedef std::list<std::pair<Key, Value> > Cache;

  explicit MruCache(size_t limit) : cache_(), destroy_(NULL), limit_(limit) {}

  MruCache(size_t limit, DestroyFn destroy)
      : cache_(), destroy_(destroy), limit_(limit) {}

  ~MruCache() {
    if (destroy_) {
      while (cache_.size() != 0) {
        destroy_(&cache_.back().second);
        cache_.pop_back();
      }
    }
  }

  Value* GetMostRecentlyUsed() {
    if (cache_.size() > 0) {
      return &cache_.front().second;
    }
    return NULL;
  }

  // Gets a pointer to the object referenced by the Key (or NULL if no such
  // object).  Will internally move the object to the "front" of the cache.
  Value* Get(const Key& key) {
    for (typename Cache::iterator i = cache_.begin(); i != cache_.end(); ++i) {
      if (i->first == key) {
        cache_.splice(cache_.begin(), cache_, i);
        return &i->second;
      }
    }
    return NULL;
  }

  // Push an object into the cache referenced by the Key.
  Value* Push(const Key& key, const Value& value) {
    if (cache_.size() == limit_) {
      if (destroy_) {
        destroy_(&cache_.back().second);
      }
      cache_.pop_back();
    }
    cache_.push_front(std::make_pair(key, value));
    return &cache_.front().second;
  }

 private:
  Cache cache_;
  DestroyFn destroy_;
  size_t limit_;

  MruCache(const MruCache&);
  MruCache& operator=(const MruCache&);
};

#endif  // GRAPHICS_TRANSLATION_GLES_MRU_CACHE_H_