TheWarehouse.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include <map>
#include <string>
#include <vector>
#include <unordered_map>
#include <iostream>
#include <mutex>

#include "MooseObject.h"
#include "MooseHashing.h"
#include "MooseUtils.h"

class MooseObject;
class WarehouseStorage;
class TheWarehouse;

class Attribute
{
public:
  Attribute(TheWarehouse & w, const std::string name);
  virtual ~Attribute() {}

  inline bool operator==(const Attribute & other) const
  {
    return _id == other._id && isEqual(other);
  }
  inline bool operator!=(const Attribute & other) const { return !(*this == other); }

  inline unsigned int id() const { return _id; }

  virtual std::size_t hash() const = 0;

  virtual void initFrom(const MooseObject * obj) = 0;
  virtual bool isMatch(const Attribute & other) const = 0;
  virtual bool isEqual(const Attribute & other) const = 0;
  virtual std::unique_ptr<Attribute> clone() const = 0;

private:
  int _id = -1;
};

#define clonefunc(T)                                                                               \
  virtual std::unique_ptr<Attribute> clone() const override                                        \
  {                                                                                                \
    return std::unique_ptr<Attribute>(new T(*this));                                               \
  }

#define hashfunc(...)                                                                              \
  virtual std::size_t hash() const override                                                        \
  {                                                                                                \
    std::size_t h = 0;                                                                             \
    Moose::hash_combine(h, __VA_ARGS__);                                                           \
    return h;                                                                                      \
  }

class AttribSorted : public Attribute
{
public:
  typedef bool Key;
  void setFrom(const Key & k) { _val = k; }

  AttribSorted(TheWarehouse & w) : Attribute(w, "sorted"), _val(false), _initd(false) {}
  AttribSorted(TheWarehouse & w, bool is_sorted)
    : Attribute(w, "sorted"), _val(is_sorted), _initd(true)
  {
  }
  AttribSorted(const AttribSorted &) = default;
  AttribSorted(AttribSorted &&) = default;
  AttribSorted & operator=(const AttribSorted &) = default;
  AttribSorted & operator=(AttribSorted &&) = default;

  virtual void initFrom(const MooseObject * obj) override;
  virtual bool isMatch(const Attribute & other) const override;
  virtual bool isEqual(const Attribute & other) const override;
  hashfunc(_val);
  clonefunc(AttribSorted);

private:
  bool _val;
  bool _initd;
};

#undef clonefunc
#undef hashfunc

bool operator==(const std::unique_ptr<Attribute> & lhs, const std::unique_ptr<Attribute> & rhs);

namespace std
{
template <>
struct hash<Attribute>
{
public:
  std::size_t operator()(const Attribute & attrib) const
  {
    std::size_t h = attrib.hash();
    Moose::hash_combine(h, attrib.id());
    return h;
  }
};

template <>
struct hash<std::vector<std::unique_ptr<Attribute>>>
{
public:
  std::size_t operator()(const std::vector<std::unique_ptr<Attribute>> & attribs) const
  {
    std::size_t h = 0;
    for (auto & attrib : attribs)
      Moose::hash_combine(h, *attrib);
    return h;
  }
};
}

class TheWarehouse
{
public:
  template <typename T>
  using KeyType = typename T::Key;
  template <typename T>
  using AttribType = T *;

  template <typename... Attribs>
  class QueryCache
  {
  public:
    typedef std::tuple<KeyType<Attribs>...> KeyTuple;
    typedef std::tuple<AttribType<Attribs>...> AttribTuple;

    QueryCache() {}

    QueryCache(TheWarehouse & w) : _w(&w)
    {
      addAttribs<0, Attribs...>();
      _attribs.reserve(5);
    }

    template <typename T>
    QueryCache(const T & q) : _w(&q.warehouse())
    {
      addAttribs<0, Attribs...>();
      _attribs.reserve(5);

      for (auto & attrib : q.attributes())
        _attribs.push_back(attrib->clone());
    }

    QueryCache & operator=(const QueryCache & other)
    {
      if (this == &other)
        return *this;

      _attribs.clear();
      _w = other._w;
      // MUST have own pointers to attribs to avoid data races - don't copy _key_attribs.
      // initialize parametrized attributes and tuple:
      addAttribs<0, Attribs...>();
      _key_tup = other._key_tup;
      // do NOT copy the cache.

      // only copy over non-parametrized attributes
      for (std::size_t i = std::tuple_size<AttribTuple>::value; i < other._attribs.size(); i++)
        _attribs.push_back(other._attribs[i]->clone());
      return *this;
    }

    template <typename T>
    QueryCache & operator=(const T & q)
    {
      _attribs.clear();
      _w = &q.warehouse();

      addAttribs<0, Attribs...>();
      _attribs.reserve(5);

      for (auto & attrib : q.attributes())
        _attribs.push_back(attrib->clone());

      return *this;
    }

    QueryCache(const QueryCache & other) : _w(other._w), _key_tup(other._key_tup)
    {
      // do NOT copy the cache.

      // initialize parametrized attributes and tuple:
      addAttribs<0, Attribs...>(); // MUST have own pointers to attribs to avoid data races.
      for (std::size_t i = std::tuple_size<AttribTuple>::value; i < other._attribs.size(); i++)
        _attribs.push_back(other._attribs[i]->clone());
    }

    template <typename T, typename... Args>
    QueryCache & condition(Args &&... args)
    {
      _attribs.emplace_back(new T(*_w, std::forward<Args>(args)...));
      _cache.clear(); // invalidate cache if base query changes.
      return *this;
    }

    QueryCache clone() const { return Query(*this); }
    std::size_t count() { return _w->count(_attribs); }

    TheWarehouse & warehouse() const { return *_w; }

    std::vector<std::unique_ptr<Attribute>> attributes() const { return clone()._attribs; }

    template <typename T, typename... Args>
    std::vector<T *> & queryInto(std::vector<T *> & results, Args &&... args)
    {
      return queryIntoHelper(results, true, args...);
    }

    template <typename T, typename... Args>
    std::vector<T *> & queryIntoUnsorted(std::vector<T *> & results, Args &&... args)
    {
      return queryIntoHelper(results, false, args...);
    }

    std::size_t numAttribs() const { return _attribs.size(); }

  private:
    template <typename T, typename... Args>
    std::vector<T *> & queryIntoHelper(std::vector<T *> & results, const bool sort, Args &&... args)
    {
      std::lock_guard<std::mutex> lock(_cache_mutex);
      setKeysInner<0, KeyType<Attribs>...>(args...);

      std::size_t query_id;
      const auto entry = _cache.find(std::make_pair(sort, _key_tup));
      if (entry == _cache.end())
      {
        setAttribsInner<0, KeyType<Attribs>...>(args...);
        // add the sort attribute. No need (I think) to clear the cache because the base query is
        // not changing
        _attribs.emplace_back(new AttribSorted(*_w, sort));
        query_id = _w->queryID(_attribs);
        _cache[std::make_pair(sort, _key_tup)] = query_id;
        // remove the sort attribute
        _attribs.pop_back();
      }
      else
        query_id = entry->second;

      return _w->queryInto(query_id, results);
    }

    template <int Index, typename A, typename... As>
    void addAttribs()
    {
      std::get<Index>(_attrib_tup) = new A(*_w);
      _attribs.emplace_back(std::get<Index>(_attrib_tup));
      addAttribs<Index + 1, As...>();
    }
    template <int Index>
    void addAttribs()
    {
    }

    template <int Index, typename K, typename... Args>
    void setKeysInner(K & k, Args &... args)
    {
      std::get<Index>(_key_tup) = k;
      setKeysInner<Index + 1, Args...>(args...);
    }
    template <int Index>
    void setKeysInner()
    {
    }

    template <int Index, typename K, typename... Args>
    void setAttribsInner(K k, Args &... args)
    {
      std::get<Index>(_attrib_tup)->setFrom(k);
      setAttribsInner<Index + 1, Args...>(args...);
    }
    template <int Index>
    void setAttribsInner()
    {
    }

    TheWarehouse * _w = nullptr;
    std::vector<std::unique_ptr<Attribute>> _attribs;

    KeyTuple _key_tup;
    AttribTuple _attrib_tup;
    std::map<std::pair<bool, KeyTuple>, std::size_t> _cache;
    std::mutex _cache_mutex;
  };

  using Query = QueryCache<>;

  TheWarehouse();
  ~TheWarehouse();

  template <typename T, typename... Args>
  unsigned int registerAttribute(const std::string & name, Args... dummy_args)
  {
    auto it = _attrib_ids.find(name);
    if (it != _attrib_ids.end())
      return it->second;

    _attrib_ids[name] = _attrib_list.size();
    _attrib_list.push_back(std::unique_ptr<Attribute>(new T(*this, dummy_args...)));
    return _attrib_list.size() - 1;
  }

  inline unsigned int attribID(const std::string & name)
  {
    auto it = _attrib_ids.find(name);
    if (it != _attrib_ids.end())
      return it->second;
    mooseError("no ID exists for unregistered attribute '", name, "'");
  }

  void add(std::shared_ptr<MooseObject> obj);

  void update(MooseObject * obj);
  void update(MooseObject * obj, const Attribute & extra);
  Query query() { return Query(*this); }
  std::size_t count(const std::vector<std::unique_ptr<Attribute>> & conds);
  template <typename T>
  std::vector<T *> & queryInto(const std::vector<std::unique_ptr<Attribute>> & conds,
                               std::vector<T *> & results)
  {
    return queryInto(queryID(conds), results);
  }

  std::size_t queryID(const std::vector<std::unique_ptr<Attribute>> & conds);

  template <typename T>
  std::vector<T *> & queryInto(int query_id, std::vector<T *> & results, bool show_all = false)
  {
    std::lock_guard<std::mutex> lock(_obj_cache_mutex);
    auto & objs = query(query_id);
    results.clear();
    results.reserve(objs.size());
    for (auto & obj : objs)
    {
      mooseAssert(obj, "Null object");
      auto cast_obj = dynamic_cast<T *>(obj);
      if (obj)
        mooseAssert(cast_obj,
                    "Queried object " + obj->typeAndName() + " has incompatible c++ type with " +
                        MooseUtils::prettyCppType<T>());
      mooseAssert(std::find(results.begin(), results.end(), cast_obj) == results.end(),
                  "Duplicate object");
      if (show_all || obj->enabled())
        results.push_back(cast_obj);
    }
    return results;
  }

private:
  int prepare(std::vector<std::unique_ptr<Attribute>> conds);

  const std::vector<MooseObject *> & query(int query_id);

  void readAttribs(const MooseObject * obj, std::vector<std::unique_ptr<Attribute>> & attribs);

  std::unique_ptr<WarehouseStorage> _store;
  std::vector<std::shared_ptr<MooseObject>> _objects;
  std::unordered_map<MooseObject *, std::size_t> _obj_ids;

  // Results from queries are cached here. The outer vector index is the query id as stored by the
  // _query_cache data structure.  A list objects that match each query id are stored.
  std::vector<std::vector<MooseObject *>> _obj_cache;
  // This stores a query id for every query keyed by the query conditions/attributes.
  // User-initiated queries check this map to see if a queries results have already been cached.
  // The query id is an index into the _obj_cache data structure.
  std::unordered_map<std::vector<std::unique_ptr<Attribute>>, int> _query_cache;

  std::unordered_map<std::string, unsigned int> _attrib_ids;
  std::vector<std::unique_ptr<Attribute>> _attrib_list;

  std::mutex _obj_mutex;
  std::mutex _query_cache_mutex;
  std::mutex _obj_cache_mutex;
};