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);