CapabilityRegistry.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 "Capability.h"
 
#include <map>
#include <set>
#include <string>
#include <utility>
 
#ifdef MOOSE_UNIT_TEST
class CapabilitiesTest;
#endif
 
namespace Moose::internal
{
 
class Capabilities;
 
class CapabilityRegistry
{
public:
  static const std::set<std::string, std::less<>> augmented_capability_names;
 
  ~CapabilityRegistry() = default;
 
  using RegistryType = std::map<std::string, Capability, std::less<>>;
 
  enum CheckState
  {
    CERTAIN_FAIL = 0,
    POSSIBLE_FAIL = 1,
    UNKNOWN = 2,
    POSSIBLE_PASS = 3,
    CERTAIN_PASS = 4,
    IGNORE = 5
  };
 
  struct CheckResult
  {
    CheckState state;
    std::set<std::string> capability_names;
  };
 
  struct CheckOptions
  {
    CheckOptions() : certain(true), ignore_capabilities() {}
 
    bool certain;
    std::set<std::string> ignore_capabilities;
  };
 
  Capability & add(const std::string_view name,
                   const Moose::Capability::Value & value,
                   const std::string_view doc);
 
  const Capability * query(std::string capability) const;
#if defined(MOOSE_UNIT_TEST) || defined(FOR_PYCAPABILITIES)
  inline Capability * query(std::string capability);
#endif
 
  const Capability & get(const std::string & capability) const;
#ifdef MOOSE_UNIT_TEST
  inline Capability & get(const std::string & capability);
#endif
 
  std::size_t size() const { return _registry.size(); }
 
  CheckResult check(
      std::string requirements,
      const CapabilityRegistry::CheckOptions & options = CapabilityRegistry::CheckOptions()) const;
 
protected:
#ifdef MOOSE_UNIT_TEST
  friend class ::CapabilitiesTest;
#endif
 
  RegistryType _registry;
};
 
#if defined(MOOSE_UNIT_TEST) || defined(FOR_PYCAPABILITIES)
Capability *
CapabilityRegistry::query(std::string capability)
{
  return const_cast<Capability *>(std::as_const(*this).query(capability));
}
#endif
 
#ifdef MOOSE_UNIT_TEST
Capability &
CapabilityRegistry::get(const std::string & capability)
{
  return const_cast<Capability &>(std::as_const(*this).get(capability));
}
#endif
} // namespace Moose::internal