MultiMooseEnum.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 "Moose.h"
#include "MooseEnumBase.h"
#include "MooseError.h"
 
// C++ includes
#include <vector>
 
// Forward declarations
class ExecFlagEnum;
namespace libMesh
{
class Parameters;
}
 
typedef std::vector<MooseEnumItem>::const_iterator MooseEnumIterator;
 
class MultiMooseEnum : public MooseEnumBase
{
public:
 
  MultiMooseEnum(std::string valid_names,
                 std::string initialization_values,
                 bool allow_out_of_range = false);
  // We need to explicitly define this version so MultiMooseEnum("one two", "one")
  // doesn't implicitly convert "one" to a bool and use the 2-parameter constructor
  MultiMooseEnum(std::string valid_names,
                 const char * initialization_values,
                 bool allow_out_of_range = false);
 
  MultiMooseEnum(std::string valid_names, bool allow_out_of_range = false);
 
  MultiMooseEnum(const MultiMooseEnum & other_enum);
 
  MultiMooseEnum & operator=(const MultiMooseEnum & other_enum) = default;
 
 
  bool operator==(const MultiMooseEnum & value) const;
  bool operator!=(const MultiMooseEnum & value) const;
 
 
  bool contains(const std::string & value) const { return isValueSet(value); }
  bool contains(int value) const { return isValueSet(value); }
  bool contains(unsigned short value) const { return isValueSet(value); }
  bool contains(const MultiMooseEnum & value) const { return isValueSet(value); }
  bool contains(const MooseEnumItem & value) const { return isValueSet(value); }
 
  // The following are aliases for contains with more descriptive name
 
  bool isValueSet(const std::string & value) const;
  bool isValueSet(int value) const;
  bool isValueSet(unsigned short value) const;
  bool isValueSet(const MultiMooseEnum & value) const;
  bool isValueSet(const MooseEnumItem & value) const;
 
 
  MultiMooseEnum & operator=(const std::string & names);
  MultiMooseEnum & operator=(const std::vector<std::string> & names);
  MultiMooseEnum & operator=(const std::set<std::string> & names);
 
 
  void erase(const std::string & names);
  void erase(const std::vector<std::string> & names);
  void erase(const std::set<std::string> & names);
 
  // The following replaces erase with a more descriptive name
 
  void eraseSetValue(const std::string & names);
  void eraseSetValue(const std::vector<std::string> & names);
  void eraseSetValue(const std::set<std::string> & names);
 
 
  void push_back(const std::string & names);
  void push_back(const std::vector<std::string> & names);
  void push_back(const std::set<std::string> & names);
  void push_back(const MultiMooseEnum & other_enum);
 
  // The following replaces push_back with a more descriptive name
 
  void setAdditionalValue(const std::string & names);
  void setAdditionalValue(const std::vector<std::string> & names);
  void setAdditionalValue(const std::set<std::string> & names);
  void setAdditionalValue(const MultiMooseEnum & other_enum);
 
  const std::string & operator[](unsigned int i) const;
 
  unsigned int get(unsigned int i) const;
 
  template <typename T>
  std::vector<T> getEnum() const;
 
  // The following replaces getEnum with a more descriptive name
  template <typename T>
  std::vector<T> getSetValueIDs() const;
 
 
  MooseEnumIterator begin() const { return _current_values.begin(); }
  MooseEnumIterator end() const { return _current_values.end(); }
 
 
  void clearSetValues();
  void clear();
 
  unsigned int size() const;
 
  virtual bool isValid() const override { return !_current_values.empty(); }
 
  // InputParameters and Output 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 MultiMooseEnum & obj);
 
  // The following functions would add possible values
  // (to _items) that an enumerated variable can take. However "+=" is not a
  // descriptive enough funtion name for this and should not be used in case
  // users get confused that the operator actually changes the set values of the
  // variable (_current_values). We have re-implemented this logic under a method
  // with a more descirptive name to force users to be informed. These are deprecated.
  MooseEnumBase & operator+=(const std::string & name);
  MooseEnumBase & operator+=(const std::initializer_list<std::string> & names);
 
  // The following replaces operator+= with a more descriptive name
  void addValidName(const std::string & name);
  void addValidName(const std::initializer_list<std::string> & names);
  void addValidName(const MultiMooseEnum & names);
 
protected:
  virtual void checkDeprecated() const override;
 
  template <typename InputIterator>
  MultiMooseEnum & assignValues(InputIterator first, InputIterator last, bool append);
 
  template <typename InputIterator>
  void removeSetValues(InputIterator first, InputIterator last);
 
  std::vector<MooseEnumItem> _current_values;
 
  MultiMooseEnum();
 
  MultiMooseEnum(const MooseEnumBase & other_enum);
};
 
template <typename T>
std::vector<T>
MultiMooseEnum::getSetValueIDs() 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
  std::vector<T> enum_vec;
  for (const auto & current_value : _current_values)
    enum_vec.push_back(static_cast<T>(current_value.id()));
  return enum_vec;
}
 
template <typename T>
std::vector<T>
MultiMooseEnum::getEnum() const
{
  mooseDeprecated("MultiMooseEnum::getEnum is deprecated, use MultiMooseEnum::getSetValueIDs");
  return MultiMooseEnum::getSetValueIDs<T>();
}