DependencyResolverInterface.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
 
// STL includes
#include <string>
#include <set>
#include <iostream>
#include <algorithm>
 
// MOOSE includes
#include "DependencyResolver.h"
#include "MooseUtils.h"
 
class DependencyResolverInterface
{
public:
  DependencyResolverInterface() {}
 
#ifdef MOOSE_KOKKOS_ENABLED
  DependencyResolverInterface(const DependencyResolverInterface &,
                              const Moose::Kokkos::FunctorCopy &)
  {
  }
#endif
 
  virtual const std::set<std::string> & getRequestedItems() = 0;
 
  virtual const std::set<std::string> & getSuppliedItems() = 0;
 
  template <typename T>
  static void sort(typename std::vector<T> & vector);
 
  template <typename T>
  static void sortDFS(typename std::vector<T> & vector);
 
  template <typename T, typename T2, typename NameFunc>
  static void cyclicDependencyError(CyclicDependencyException<T2> & e,
                                    const std::string & header,
                                    NameFunc && name_func);
 
  template <typename T, typename T2>
  static void cyclicDependencyError(CyclicDependencyException<T2> & e, const std::string & header);
};
 
template <typename T>
void
DependencyResolverInterface::sort(typename std::vector<T> & vector)
{
  sortDFS(vector);
}
 
template <typename T>
void
DependencyResolverInterface::sortDFS(typename std::vector<T> & vector)
{
  if (vector.size() <= 1)
    return;
 
  DependencyResolver<T> graph;
 
  // Map of suppliers: what is supplied -> by what object
  std::multimap<std::string, T> suppliers_map;
  for (auto & v : vector)
  {
    // Whether or not this object supplies something, we will always
    // add it as a node because we want to make sure that it gets returned
    graph.addNode(v);
 
    for (const auto & supplied_item : v->getSuppliedItems())
      suppliers_map.emplace(supplied_item, v);
  }
 
  // build the dependency graph
  for (auto & v : vector)
    for (const auto & requested_item : v->getRequestedItems())
    {
      const auto & [begin_it, end_it] = suppliers_map.equal_range(requested_item);
      for (const auto & [supplier_name, supplier_object] : as_range(begin_it, end_it))
      {
        libmesh_ignore(supplier_name);
 
        // We allow an object to have a circular dependency within itself; e.g. we choose to
        // trust a developer knows what they are doing within a single object
        if (supplier_object != v)
          graph.addEdge(supplier_object, v);
      }
    }
 
  const auto & sorted = graph.dfs();
 
  // The set here gets unique objects, as it's valid to pass in duplicates
  mooseAssert(sorted.size() == std::set<T>(vector.begin(), vector.end()).size(), "Size mismatch");
 
  vector = sorted;
}
 
template <typename T, typename T2, typename NameFunc>
void
DependencyResolverInterface::cyclicDependencyError(CyclicDependencyException<T2> & e,
                                                   const std::string & header,
                                                   NameFunc && name_func)
{
  std::ostringstream oss;
 
  oss << header << ":\n";
  const auto cycle = e.getCyclicDependencies();
  std::vector<std::string> names(cycle.size());
  for (const auto i : index_range(cycle))
    names[i] = name_func(cycle[i]);
  oss << MooseUtils::join(names, " <- ");
  mooseError(oss.str());
}
 
template <typename T, typename T2>
void
DependencyResolverInterface::cyclicDependencyError(CyclicDependencyException<T2> & e,
                                                   const std::string & header)
{
  cyclicDependencyError<T>(e, header, [](const auto & obj) { return static_cast<T>(obj)->name(); });
}