[Cleanup] Refactor enums

src/Makefile.am

@@ -3,6 +3,7 @@ bin_PROGRAMS = sand-wedge-2D sand-wedge-3D
 common_sources = \
 	assemblers.cc \
 	boundary_writer.cc \
+	enumparser.cc \
 	friction_writer.cc \
 	solverfactory.cc \
 	state.cc \

src/enum_friction_model.cc

-#include <dune/common/exceptions.hh>
-
-#include "enums.hh"
-
-template <> struct StringToEnum<Config::FrictionModel> {
-  static Config::FrictionModel convert(std::string const &s) {
-    if (s == "Truncated")
-      return Config::Truncated;
-
-    if (s == "Regularised")
-      return Config::Regularised;
-
-    DUNE_THROW(Dune::Exception, "failed to parse enum");
-  }
-};

src/enum_scheme.cc

-#include <dune/common/exceptions.hh>
-
-#include "enums.hh"
-
-template <> struct StringToEnum<Config::scheme> {
-  static Config::scheme convert(std::string const &s) {
-    if (s == "newmark")
-      return Config::Newmark;
-
-    if (s == "backwardEuler")
-      return Config::BackwardEuler;
-
-    DUNE_THROW(Dune::Exception, "failed to parse enum");
-  }
-};

src/enum_state_model.cc

-#include <dune/common/exceptions.hh>
-
-#include "enums.hh"
-
-template <> struct StringToEnum<Config::stateModel> {
-  static Config::stateModel convert(std::string const &s) {
-    if (s == "AgeingLaw")
-      return Config::AgeingLaw;
-
-    if (s == "SlipLaw")
-      return Config::SlipLaw;
-
-    DUNE_THROW(Dune::Exception, "failed to parse enum");
-  }
-};

src/enum_verbosity.cc

-#include <dune/solvers/common/numproc.hh> // Solver::VerbosityMode
-#include <dune/common/exceptions.hh>
-
-template <> struct StringToEnum<Solver::VerbosityMode> {
-  static Solver::VerbosityMode convert(std::string const &s) {
-    if (s == "full")
-      return Solver::FULL;
-
-    if (s == "reduced")
-      return Solver::REDUCED;
-
-    if (s == "quiet")
-      return Solver::QUIET;
-
-    DUNE_THROW(Dune::Exception, "failed to parse enum");
-  }
-};

src/enumparser.cc

+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+// Copyright Carsten Graeser 2012
+
+#include <dune/common/exceptions.hh>
+
+#include "enumparser.hh"
+
+template <class Enum>
+typename Dune::enable_if<
+    !Dune::IsBaseOf<Dune::NotImplemented, StringToEnum<Enum>>::value,
+    std::istream &>::type
+operator>>(std::istream &lhs, Enum &e) {
+  std::string s;
+  lhs >> s;
+
+  try {
+    e = StringToEnum<Enum>::convert(s);
+  }
+  catch (typename Dune::Exception) {
+    lhs.setstate(std::ios_base::failbit);
+  }
+  return lhs;
+}
+
+Config::FrictionModel StringToEnum<Config::FrictionModel>::convert(
+    std::string const &s) {
+  if (s == "Truncated")
+    return Config::Truncated;
+
+  if (s == "Regularised")
+    return Config::Regularised;
+
+  DUNE_THROW(Dune::Exception, "failed to parse enum");
+}
+
+Config::scheme StringToEnum<Config::scheme>::convert(std::string const &s) {
+  if (s == "newmark")
+    return Config::Newmark;
+
+  if (s == "backwardEuler")
+    return Config::BackwardEuler;
+
+  DUNE_THROW(Dune::Exception, "failed to parse enum");
+}
+
+Config::stateModel StringToEnum<Config::stateModel>::convert(
+    std::string const &s) {
+  if (s == "AgeingLaw")
+    return Config::AgeingLaw;
+
+  if (s == "SlipLaw")
+    return Config::SlipLaw;
+
+  DUNE_THROW(Dune::Exception, "failed to parse enum");
+}
+
+Solver::VerbosityMode StringToEnum<Solver::VerbosityMode>::convert(
+    std::string const &s) {
+  if (s == "full")
+    return Solver::FULL;
+
+  if (s == "reduced")
+    return Solver::REDUCED;
+
+  if (s == "quiet")
+    return Solver::QUIET;
+
+  DUNE_THROW(Dune::Exception, "failed to parse enum");
+}
+
+template std::istream &operator>>(std::istream &lhs, Config::FrictionModel &);
+template std::istream &operator>>(std::istream &lhs, Config::stateModel &);
+template std::istream &operator>>(std::istream &lhs, Config::scheme &);
+template std::istream &operator>>(std::istream &lhs, Solver::VerbosityMode &);

src/enum_parser.cc → src/enumparser.hh

+#ifndef SRC_ENUMPARSER_HH
+#define SRC_ENUMPARSER_HH
+
 // Copyright Carsten Graeser 2012
 
-#include <dune/common/exceptions.hh>
 #include <dune/common/typetraits.hh>
 
+#include <dune/solvers/solvers/solver.hh>
+
+#include "enums.hh"
+
 template <class Enum> struct StringToEnum : public Dune::NotImplemented {};
 
+template <> struct StringToEnum<Config::FrictionModel> {
+  static Config::FrictionModel convert(std::string const &s);
+};
+
+template <> struct StringToEnum<Config::stateModel> {
+  static Config::stateModel convert(std::string const &s);
+};
+
+template <> struct StringToEnum<Config::scheme> {
+  static Config::scheme convert(std::string const &s);
+};
+
+template <> struct StringToEnum<Solver::VerbosityMode> {
+  static Solver::VerbosityMode convert(std::string const &s);
+};
+
 template <class Enum>
 typename Dune::enable_if<
     !Dune::IsBaseOf<Dune::NotImplemented, StringToEnum<Enum>>::value,
     std::istream &>::type
-operator>>(std::istream &lhs, Enum &e) {
-  std::string s;
-  lhs >> s;
-
-  try {
-    e = StringToEnum<Enum>::convert(s);
-  }
-  catch (typename Dune::Exception) {
-    lhs.setstate(std::ios_base::failbit);
-  }
-  return lhs;
-}
+operator>>(std::istream &lhs, Enum &e);
+#endif

src/sand-wedge.cc

@@ -68,11 +68,7 @@
 
 #include "assemblers.hh"
 #include "tobool.hh"
-#include "enum_parser.cc"
-#include "enum_friction_model.cc"
-#include "enum_scheme.cc"
-#include "enum_state_model.cc"
-#include "enum_verbosity.cc"
+#include "enumparser.hh"
 #include "enums.hh"
 #include "friction_writer.hh"
 #include "sand-wedge-data/mybody.hh"