Cache.h

//=========================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//=========================================================================
#ifndef smtk_geometry_Cache_h
#define smtk_geometry_Cache_h
 
#include "smtk/geometry/GeometryForBackend.h"
#include "smtk/geometry/Resource.h"
 
#include <map>
 
namespace smtk
{
namespace geometry
{
 
template<typename BaseClass>
class Cache : public BaseClass
{
public:
  smtkTypeMacro(Cache);
  smtkSharedFromThisMacro(Geometry);
  smtkSuperclassMacro(BaseClass);
 
  using GenerationNumber = Geometry::GenerationNumber;
  using DataType = typename BaseClass::DataType;
  using BoundingBox = Geometry::BoundingBox;
  using Visitor = Geometry::Visitor;
  static constexpr GenerationNumber Invalid = Geometry::Invalid;
  static constexpr GenerationNumber Initial = Geometry::Initial;
 
  struct CacheEntry
  {
    GenerationNumber m_generation; 
    DataType m_geometry;           
 
    CacheEntry()
      : m_generation(Invalid)
    {
    }
 
    CacheEntry(CacheEntry&&) noexcept = default;
    CacheEntry(const CacheEntry&) = default;
    CacheEntry(GenerationNumber gen, const DataType& data)
      : m_generation(gen)
      , m_geometry(data)
    {
    }
    CacheEntry& operator=(const CacheEntry&) = default;
 
    bool isValid() const { return m_generation != Invalid; }
  };
 
  virtual void queryGeometry(const smtk::resource::PersistentObject::Ptr&, CacheEntry& cache) const
  {
    cache.m_generation = Invalid;
  }
 
  GenerationNumber generationNumber(const smtk::resource::PersistentObject::Ptr& obj) const override
  {
    if (obj)
    {
      auto it = m_cache.find(obj->id());
      bool found = it != m_cache.end();
      if (found && it->second.m_geometry)
      { // Cache is clean.
        return it->second.m_generation;
      }
      else if (found)
      { // Cache was marked dirty.
        this->queryGeometry(obj, it->second);
        if (!it->second.isValid())
        {
          m_cache.erase(it);
        }
        else
        {
          return it->second.m_generation;
        }
      }
      else
      { // No cache entry yet; try to add one.
        CacheEntry entry;
        this->queryGeometry(obj, entry);
        if (entry.isValid())
        {
          m_cache[obj->id()] = entry;
          return entry.m_generation;
        }
      }
    }
    return Invalid;
  }
 
  void bounds(const smtk::resource::PersistentObject::Ptr& obj, BoundingBox& bds) const override
  {
    if (obj)
    {
      auto it = m_cache.find(obj->id());
      bool found = it != m_cache.end();
      if (found && it->second.m_geometry)
      { // Cache is clean:
        this->geometricBounds(it->second.m_geometry, bds);
        return;
      }
      else if (found)
      { // Cache was marked dirty. Update it:
        this->queryGeometry(obj, it->second);
        if (it->second.isValid())
        {
          this->geometricBounds(it->second.m_geometry, bds);
          return;
        }
        else
        {
          m_cache.erase(it);
        }
      }
      else
      {
        CacheEntry entry;
        this->queryGeometry(obj, entry);
        if (entry.isValid())
        {
          m_cache[obj->id()] = entry;
          this->geometricBounds(entry.m_geometry, bds);
          return;
        }
      }
    }
    // Object is invalid or has no geometry; return invalid bounds.
    bds[0] = bds[2] = bds[4] = 0.0;
    bds[1] = bds[3] = bds[5] = -1.0;
  }
 
  DataType& data(const smtk::resource::PersistentObject::Ptr& obj) const override
  {
    if (obj)
    {
      auto it = m_cache.find(obj->id());
      bool found = it != m_cache.end();
      if (found && it->second.m_geometry)
      { // Cache is clean.
        return it->second.m_geometry;
      }
      else if (found)
      { // Cache was marked dirty. Update it:
        this->queryGeometry(obj, it->second);
        if (it->second.isValid())
        {
          return it->second.m_geometry;
        }
        else
        {
          m_cache.erase(it);
        }
      }
      else
      { // No cache existed. See if we can create an entry:
        CacheEntry entry;
        this->queryGeometry(obj, entry);
        if (entry.isValid())
        {
          m_cache[obj->id()] = entry;
          return m_cache[obj->id()].m_geometry;
        }
      }
    }
    static DataType invalid;
    return invalid;
  }
 
  void visit(Visitor visitor) const override
  {
    this->update();
    auto rsrc = this->resource();
    if (rsrc)
    {
      auto it = m_cache.begin();
      for (auto entry = it; entry != m_cache.end(); entry = it)
      {
        ++it;
        auto comp = rsrc->find(entry->first);
        if (comp)
        {
          visitor(comp, entry->second.m_generation);
        }
        else if (entry->first == rsrc->id())
        {
          visitor(rsrc, entry->second.m_generation);
        }
        // else remove cache entry?
      }
    }
  }
 
  void markModified(const smtk::resource::PersistentObject::Ptr& obj) override
  {
    if (obj)
    {
      ++this->BaseClass::m_lastModified;
      auto it = m_cache.find(obj->id());
      if (it != m_cache.end())
      {
        DataType blank; // Assume default constructor creates "null" data.
        it->second.m_geometry = blank;
      }
      else
      {
        CacheEntry invalid;
        m_cache[obj->id()] = invalid;
      }
    }
  }
 
  bool erase(const smtk::common::UUID& uid) override { return m_cache.erase(uid) > 0; }
 
protected:
  mutable std::map<smtk::common::UUID, CacheEntry> m_cache;
};
 
} // namespace geometry
} // namespace smtk
 
#endif // smtk_geometry_Cache_h