ReporterName.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 <iostream>
#include "MooseTypes.h"
 
class ReporterName
{
public:
  ReporterName(const std::string & object_name, const std::string & value_name);
  ReporterName(const std::string & object_and_value_name);
  ReporterName(const char * combined_name);
  ReporterName() {} // empty constructor for InputParameters
 
  static bool isValidName(const std::string & object_and_value_name);
 
  const std::string & getObjectName() const;
 
  const std::string & getValueName() const;
 
  const std::string getCombinedName() const;
 
  static const std::string REPORTER_RESTARTABLE_DATA_PREFIX;
 
  std::string getRestartableName() const;
 
  operator std::string() const;
 
  bool operator==(const ReporterName & rhs) const;
  bool operator==(const std::string & combined_name) const;
 
  bool operator<(const ReporterName & rhs) const;
 
  std::string specialTypeToName() const;
 
  bool isPostprocessor() const { return _special_type == SpecialType::POSTPROCESSOR; }
  bool isVectorPostprocessor() const { return _special_type == SpecialType::VECTORPOSTPROCESSOR; }
 
  void setIsPostprocessor() { _special_type = SpecialType::POSTPROCESSOR; }
  void setIsVectorPostprocessor() { _special_type = SpecialType::VECTORPOSTPROCESSOR; }
 
  bool empty() const { return _object_name.empty() || _value_name.empty(); }
 
private:
  enum class SpecialType
  {
    ANY = 0,
    POSTPROCESSOR = 1,
    VECTORPOSTPROCESSOR = 2
  };
 
  ReporterName::SpecialType _special_type = ReporterName::SpecialType::ANY;
 
  std::string _object_name;
  std::string _value_name;
};
 
class PostprocessorReporterName : public ReporterName
{
public:
  PostprocessorReporterName(const PostprocessorName & name);
};
 
class VectorPostprocessorReporterName : public ReporterName
{
public:
  VectorPostprocessorReporterName(const VectorPostprocessorName & name,
                                  const std::string & vector_name);
};
 
// This with the operator== allow this to be used as a key in a std::unordered_map
namespace std
{
template <>
struct hash<ReporterName>
{
  size_t operator()(const ReporterName & other) const { return hash<string>{}(other); }
};
}
 
// Support << output
std::ostream & operator<<(std::ostream & os, const ReporterName & state);