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

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