array_ad_cache.h

Go to the documentation of this file.

#ifndef ARRAY_AD_CACHE_H
#define ARRAY_AD_CACHE_H

#include <map>
#include "array_ad.h"

namespace FullPhysics {
  
  /****************************************************************/
  template<class K, class T, int D> class ArrayAdCache
  {
    public:
      virtual ~ArrayAdCache() {}
      virtual ArrayAd<T, D> operator[](const K& key) const = 0;
      virtual bool is_valid(const K& key) const = 0;
      virtual void insert(const K& key, const ArrayAd<T, D>& value) = 0;
      virtual void erase(const K& key) = 0;
      virtual void clear() = 0;
  };

  /****************************************************************/
  template<class K, class T, int D> class ArrayAdMapCache : public ArrayAdCache<K, T, D>
  {
    public:
      ArrayAdMapCache() { }
      virtual ~ArrayAdMapCache() {}
      inline virtual ArrayAd<T, D> operator[](const K& key) const
      { 
        typename std::map<K, ArrayAd<T, D> >::const_iterator value_it;
        value_it = cache_map.find(key);
        if (value_it == cache_map.end())
          throw Exception("Could not find value_it in cache");
        return value_it->second;
      }

      inline virtual bool is_valid(const K& key) const
      { 
        return cache_map.find(key) != cache_map.end();
      }

      inline virtual void insert(const K& key, const ArrayAd<T, D>& value)
      { 
        ArrayAd<T, D> cached_copy;
        cached_copy = value;
        cache_map.insert(std::pair<K, ArrayAd<T, D> >(key, cached_copy));
      }

      inline virtual void erase(const K& key)
      {
        cache_map.erase(key);
      }

      inline virtual void clear()
      {
        cache_map.clear();
      }
    private:
      std::map<K, ArrayAd<T, D> > cache_map;
  };

  /****************************************************************/
  template<class K, class T, int D> class ArrayAdVectorCache : public ArrayAdCache<K, T, D>
  {
    public:

      ArrayAdVectorCache(int prealloc_size = 0) : cache_index(0) 
      {
        cached_data_.resize(prealloc_size);
      }

      inline typename std::vector<std::pair<K, ArrayAd<T, D> > >::const_iterator find(const K& key) const
      {
        typename std::vector<std::pair<K, ArrayAd<T, D> > >::const_iterator curr_it;
        curr_it = cached_data_.begin();
        for ( ; curr_it != cached_data_.end() && curr_it != cached_data_.begin()+cache_index; curr_it++) if ( curr_it->first == key ) break;
        if(curr_it == cached_data_.begin()+cache_index)
          return cached_data_.end();
        else
          return curr_it;
      }

      inline typename std::vector<std::pair<K, ArrayAd<T, D> > >::iterator find(const K& key)
      {
        typename std::vector<std::pair<K, ArrayAd<T, D> > >::iterator curr_it;
        curr_it = cached_data_.begin();
        for ( ; curr_it != cached_data_.end() && curr_it != cached_data_.begin()+cache_index; curr_it++) if ( curr_it->first == key ) break;
        if(curr_it == cached_data_.begin()+cache_index)
          return cached_data_.end();
        else
          return curr_it;
      }

      inline virtual ArrayAd<T, D> operator[](const K& key) const
      {
        typename std::vector<std::pair<K, ArrayAd<T, D> > >::const_iterator value_it;
        value_it = find(key);
        if (value_it == cached_data_.end())
          throw Exception("Could not find key in vector cache to retrieve");
        return value_it->second;
      }

      inline virtual bool is_valid(const K& key) const
      { 
        return find(key) != cached_data_.end();
      }

      inline virtual void insert(const K& key, const ArrayAd<T, D>& value)
      { 
        ArrayAd<T, D> cached_copy;
        cached_copy = value;
        if ((int) cached_data_.size() > cache_index)
          cached_data_[cache_index] = std::pair<K, ArrayAd<T, D> >(key, cached_copy);
        else
          cached_data_.push_back(std::pair<K, ArrayAd<T, D> >(key, cached_copy));
        cache_index++;
      }

      inline virtual void erase(const K& key)
      {
        typename std::vector<std::pair<K, ArrayAd<T, D> > >::iterator value_it;
        value_it = find(key);
        if (value_it == cached_data_.end())
          throw Exception("Could not find key in vector cache to erase");
        cached_data_.erase(value_it);
        cache_index--;
      }

      inline virtual void clear()
      {
        cache_index = 0;
      }

      inline virtual void clear(bool clear_memory)
      {
        if (clear_memory)
          cached_data_.clear();
        clear();
      }

      virtual std::vector<std::pair<K, ArrayAd<T, D> > > cached_data() const
      {
         return std::vector<std::pair<K, ArrayAd<T, D> > >(cached_data_.begin(), cached_data_.begin()+cache_index);
      }
    private:
      int cache_index;
      std::vector<std::pair<K, ArrayAd<T, D> > > cached_data_;
  };

}

#endif