MooseEnum.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
 
// MOOSE includes
#include "MooseEnumBase.h"
#include "MooseStringUtils.h"
#include "MooseUtils.h"
 
#include <optional>
#include <cctype>
#include <algorithm>
 
#define CreateMooseEnumClass(EnumName, /* enumerators */...)                                       \
  static inline std::string get##EnumName##Options()                                               \
  {                                                                                                \
    /* 1) stringify the enumerator list                                               */           \
    std::string s = #__VA_ARGS__;                                                                  \
    /* 2) normalize to the format MooseEnum expects: "A B C=3 D ..."                  */           \
    std::vector<std::string> elements;                                                             \
    MooseUtils::tokenize(s, elements, 1, ",");                                                     \
    for (auto & elem : elements)                                                                   \
      elem.erase(std::remove_if(elem.begin(), elem.end(), isspace), elem.end());                   \
    return MooseUtils::join(elements, " ");                                                        \
  }                                                                                                \
  enum class EnumName                                                                              \
  {                                                                                                \
    __VA_ARGS__                                                                                    \
  }
 
// Forward declarations
namespace libMesh
{
class Parameters;
}
 
class MooseEnum : public MooseEnumBase
{
public:
  enum class CompareMode
  {
    COMPARE_NAME,
    COMPARE_ID,
    COMPARE_BOTH
  };
 
  MooseEnum(std::string names, std::string default_name = "", bool allow_out_of_range = false);
 
  MooseEnum(const MooseEnum & other_enum);
 
  MooseEnum & operator=(const MooseEnum & other_enum) = default;
 
  virtual ~MooseEnum() = default;
 
  operator int() const { return _current.id(); }
  operator std::string() const { return _current.rawName(); }
 
  bool operator==(const char * value) const;
  bool operator!=(const char * value) const;
 
  bool operator==(int value) const;
  bool operator!=(int value) const;
 
  bool operator==(unsigned short value) const;
  bool operator!=(unsigned short value) const;
 
  bool operator==(const MooseEnum & value) const;
  bool operator!=(const MooseEnum & value) const;
 
  bool compareCurrent(const MooseEnum & other, CompareMode mode = CompareMode::COMPARE_NAME) const;
 
 
  MooseEnum & operator=(const std::string & name);
  MooseEnum & operator=(int value);
  MooseEnum & operator=(const MooseEnumItem & item);
  void assign(const std::string & name, const std::optional<std::string> & context = {});
  void assign(int value);
  void assign(const MooseEnumItem & item);
 
  virtual bool isValid() const override { return _current.id() > MooseEnumItem::INVALID_ID; }
 
  // InputParameters is allowed to create an empty enum but is responsible for
  // filling it in after the fact
  friend class libMesh::Parameters;
 
  friend std::ostream & operator<<(std::ostream & out, const MooseEnum & obj)
  {
    out << obj._current.rawName();
    return out;
  }
 
  template <typename T>
  T getEnum() const;
 
protected:
  virtual void checkDeprecated() const override;
 
  MooseEnum();
 
private:
  MooseEnumItem _current;
};
 
template <typename T>
T
MooseEnum::getEnum() const
{
#ifdef LIBMESH_HAVE_CXX11_TYPE_TRAITS
  static_assert(std::is_enum<T>::value == true,
                "The type requested from MooseEnum::getEnum must be an enum type!\n\n");
#endif
  return static_cast<T>(_current.id());
}