Apply clang-format to source tree

[alexxy/gromacs.git] / python_packaging / src / gmxapi / export_tprfile.cpp

diff --git a/python_packaging/src/gmxapi/export_tprfile.cpp b/python_packaging/src/gmxapi/export_tprfile.cpp
index b5d86404be83ab9e18db6ba6138ac8755b0a0979..58e48728fee6436cee5e94d738baa5e0deb6af59 100644 (file)
--- a/python_packaging/src/gmxapi/export_tprfile.cpp
+++ b/python_packaging/src/gmxapi/export_tprfile.cpp
@@ -61,22 +61,21 @@ namespace gmxpy
 {
 
 
-void detail::export_tprfile(pybind11::module &module)
+void detail::export_tprfile(pybind11::module& module)
 {
     namespace py = pybind11;
     using gmxapicompat::GmxMdParams;
-    using gmxapicompat::TprReadHandle;
     using gmxapicompat::readTprFile;
+    using gmxapicompat::TprReadHandle;
 
     py::class_<GmxMdParams> mdparams(module, "SimulationParameters");
     // We don't want Python users to create invalid params objects, so don't
     // export a constructor until we can default initialize a valid one.
     //    mdparams.def(py::init());
     mdparams.def("extract",
-                 [](const GmxMdParams &self)
-                 {
+                 [](const GmxMdParams& self) {
                      py::dict dictionary;
-                     for (const auto &key: gmxapicompat::keys(self))
+                     for (const auto& key : gmxapicompat::keys(self))
                      {
                          try
                          {
@@ -89,7 +88,7 @@ void detail::export_tprfile(pybind11::module &module)
 
                              // We can use templates and/or tag dispatch in a more complete
                              // future implementation.
-                             const auto &paramType = gmxapicompat::mdParamToType(key);
+                             const auto& paramType = gmxapicompat::mdParamToType(key);
                              if (paramType == GmxapiType::FLOAT64)
                              {
                                  dictionary[key.c_str()] = extractParam(self, key, double());
@@ -99,7 +98,7 @@ void detail::export_tprfile(pybind11::module &module)
                                  dictionary[key.c_str()] = extractParam(self, key, int64_t());
                              }
                          }
-                         catch (const gmxapicompat::ValueError &e)
+                         catch (const gmxapicompat::ValueError& e)
                          {
                              throw gmxapi::ProtocolError(std::string("Unknown parameter: ") + key);
                          }
@@ -110,77 +109,60 @@ void detail::export_tprfile(pybind11::module &module)
 
     // Overload a setter for each known type and None
     mdparams.def("set",
-                 [](GmxMdParams* self, const std::string &key, int64_t value)
-                 {
+                 [](GmxMdParams* self, const std::string& key, int64_t value) {
                      gmxapicompat::setParam(self, key, value);
                  },
-                 py::arg("key").none(false),
-                 py::arg("value").none(false),
+                 py::arg("key").none(false), py::arg("value").none(false),
                  "Use a dictionary to update simulation parameters.");
     mdparams.def("set",
-                 [](GmxMdParams* self, const std::string &key, double value)
-                 {
+                 [](GmxMdParams* self, const std::string& key, double value) {
                      gmxapicompat::setParam(self, key, value);
                  },
-                 py::arg("key").none(false),
-                 py::arg("value").none(false),
+                 py::arg("key").none(false), py::arg("value").none(false),
                  "Use a dictionary to update simulation parameters.");
     mdparams.def("set",
-                 [](GmxMdParams* self, const std::string &key, py::none)
-                 {
+                 [](GmxMdParams* self, const std::string& key, py::none) {
                      // unsetParam(self, key);
                  },
-                 py::arg("key").none(false),
-                 py::arg("value"),
+                 py::arg("key").none(false), py::arg("value"),
                  "Use a dictionary to update simulation parameters.");
 
 
     py::class_<TprReadHandle> tprfile(module, "TprFile");
-    tprfile.def("params",
-                [](const TprReadHandle &self)
-                {
-                    auto params = gmxapicompat::getMdParams(self);
-                    return params;
-                });
-
-    module.def("read_tprfile",
-               &readTprFile,
-               py::arg("filename"),
+    tprfile.def("params", [](const TprReadHandle& self) {
+        auto params = gmxapicompat::getMdParams(self);
+        return params;
+    });
+
+    module.def("read_tprfile", &readTprFile, py::arg("filename"),
                "Get a handle to a TPR file resource for a given file name.");
 
     module.def("write_tprfile",
-               [](std::string filename, const GmxMdParams &parameterObject)
-               {
+               [](std::string filename, const GmxMdParams& parameterObject) {
                    auto tprReadHandle = gmxapicompat::getSourceFileHandle(parameterObject);
-                   auto params = gmxapicompat::getMdParams(tprReadHandle);
-                   auto structure = gmxapicompat::getStructureSource(tprReadHandle);
-                   auto state = gmxapicompat::getSimulationState(tprReadHandle);
-                   auto topology = gmxapicompat::getTopologySource(tprReadHandle);
+                   auto params        = gmxapicompat::getMdParams(tprReadHandle);
+                   auto structure     = gmxapicompat::getStructureSource(tprReadHandle);
+                   auto state         = gmxapicompat::getSimulationState(tprReadHandle);
+                   auto topology      = gmxapicompat::getTopologySource(tprReadHandle);
                    gmxapicompat::writeTprFile(filename, *params, *structure, *state, *topology);
                },
-               py::arg("filename").none(false),
-               py::arg("parameters"),
+               py::arg("filename").none(false), py::arg("parameters"),
                "Write a new TPR file with the provided data.");
 
     module.def("copy_tprfile",
-               [](const gmxapicompat::TprReadHandle &input, std::string outFile)
-               {
+               [](const gmxapicompat::TprReadHandle& input, std::string outFile) {
                    return gmxapicompat::copy_tprfile(input, outFile);
                },
-               py::arg("source"),
-               py::arg("destination"),
-               "Copy a TPR file from `source` to `destination`."
-               );
-
-    module.def("rewrite_tprfile",
-               [](std::string input, std::string output, double end_time)
-               {
-                   return gmxapicompat::rewrite_tprfile(input, output, end_time);
-               },
-               py::arg("source"),
-               py::arg("destination"),
-               py::arg("end_time"),
-               "Copy a TPR file from `source` to `destination`, replacing `nsteps` with `end_time`.");
+               py::arg("source"), py::arg("destination"),
+               "Copy a TPR file from `source` to `destination`.");
+
+    module.def(
+            "rewrite_tprfile",
+            [](std::string input, std::string output, double end_time) {
+                return gmxapicompat::rewrite_tprfile(input, output, end_time);
+            },
+            py::arg("source"), py::arg("destination"), py::arg("end_time"),
+            "Copy a TPR file from `source` to `destination`, replacing `nsteps` with `end_time`.");
 }
 
 } // end namespace gmxpy