Conversion.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 "MooseTypes.h"
 
// libMesh
#include "libmesh/enum_order.h"
#include "libmesh/enum_quadrature_type.h"
#include "libmesh/enum_fe_family.h"
#include "libmesh/enum_elem_type.h"
 
#include <variant>
 
// Forward declarations
class MultiMooseEnum;
namespace libMesh
{
class Point;
class FEType;
}
 
namespace Moose
{
// Scalar conversions
template <typename T>
T stringToEnum(const std::string & s);
 
template <>
libMesh::QuadratureType stringToEnum<libMesh::QuadratureType>(const std::string & s);
 
template <>
libMesh::Order stringToEnum<libMesh::Order>(const std::string & s);
 
template <>
CoordinateSystemType stringToEnum<CoordinateSystemType>(const std::string & s);
 
template <>
SolveType stringToEnum<SolveType>(const std::string & s);
 
template <>
LineSearchType stringToEnum<LineSearchType>(const std::string & s);
 
template <>
TimeIntegratorType stringToEnum<TimeIntegratorType>(const std::string & s);
 
template <>
RelationshipManagerType stringToEnum<RelationshipManagerType>(const std::string & s);
 
// Vector conversions
template <typename T>
std::vector<T> vectorStringsToEnum(const MultiMooseEnum & v);
 
template <typename T>
std::string
stringify(const T & t)
{
  std::ostringstream os;
  os << t;
  return os.str();
}
 
// overload for boolean type instead of simply printing 0 or 1
inline std::string
stringify(bool v)
{
  return v ? "true" : "false";
}
 
// overloads for integer types where std::to_string gives the same result and is faster
inline std::string
stringify(int v)
{
  return std::to_string(v);
}
inline std::string
stringify(long v)
{
  return std::to_string(v);
}
inline std::string
stringify(long long v)
{
  return std::to_string(v);
}
inline std::string
stringify(unsigned int v)
{
  return std::to_string(v);
}
inline std::string
stringify(unsigned long v)
{
  return std::to_string(v);
}
inline std::string
stringify(unsigned long long v)
{
  return std::to_string(v);
}
 
namespace internal
{
template <typename T, typename V>
inline std::string
stringify_variant(const V & value)
{
  return std::holds_alternative<T>(value) ? stringify(std::get<T>(value)) : "";
}
}
 
template <typename... T>
inline std::string
stringify(std::variant<T...> v)
{
  return (internal::stringify_variant<T>(v) + ...);
}
 
std::string stringify(const SolveType & t);
 
std::string stringify(const EigenSolveType & t);
 
std::string stringify(const VarFieldType & t);
 
std::string stringify(const std::string & s);
 
std::string stringify(libMesh::FEFamily f);
 
std::string stringify(const libMesh::FEType & t);
 
std::string stringify(SolutionIterationType t);
 
std::string stringify(ElementType t);
 
std::string stringify(libMesh::ElemType t);
 
template <typename T, typename U>
std::string
stringify(const std::pair<T, U> & p, const std::string & delim = ":")
{
  return stringify(p.first) + delim + stringify(p.second);
}
 
template <typename... Args>
std::string
stringify(const std::tuple<Args...> & t, const std::string & delim = ":")
{
  if constexpr (sizeof...(Args) == 0)
  {
    return "";
  }
 
  return std::apply(
      [&delim](const auto &... args)
      {
        std::size_t n{0};
        std::string result;
        ((result += (n++ == 0 ? "" : delim) + stringify(args)), ...);
        return result;
      },
      t);
}
 
template <template <typename...> class T, typename... U>
std::string
stringify(const T<U...> & c,
          const std::string & delim = ", ",
          const std::string & elem_encl = "",
          bool enclose_list_in_curly_braces = false)
{
  std::string str;
  if (enclose_list_in_curly_braces)
    str += "{";
  const auto begin = c.begin();
  const auto end = c.end();
  for (auto i = begin; i != end; ++i)
    str += (i != begin ? delim : "") + elem_encl + stringify(*i) + elem_encl;
  if (enclose_list_in_curly_braces)
    str += "}";
  return str;
}
 
std::string stringifyExact(Real);
}
 
template <typename T1, typename T2>
std::vector<T2>
vectorCast(std::vector<T2> in)
{
  std::vector<T2> out(in.begin(), in.end());
  return out;
}
 
Point toPoint(const std::vector<Real> & pos);