run make style

src/axom/sina/core/AdiakWriter.hpp

@@ -3,7 +3,6 @@
 //
 // SPDX-License-Identifier: (BSD-3-Clause)
 
-
 #ifndef SINA_ADIAK_HPP
 #define SINA_ADIAK_HPP
 
@@ -20,15 +19,15 @@
 #include "axom/config.hpp"
 #ifdef AXOM_USE_ADIAK
 
-#include <string>
-#include <type_traits>
+  #include <string>
+  #include <type_traits>
 
-#include "axom/sina/core/ConduitUtil.hpp"
-#include "axom/sina/core/Record.hpp"
-#include "axom/sina/core/Run.hpp"
+  #include "axom/sina/core/ConduitUtil.hpp"
+  #include "axom/sina/core/Record.hpp"
+  #include "axom/sina/core/Run.hpp"
 
 extern "C" {
-#include "adiak_tool.h"
+  #include "adiak_tool.h"
 }
 
 namespace axom
@@ -53,12 +52,16 @@ namespace sina
  *            anything like a CurveSet. As a result, to do that, you must hold on to
  *            the Record object passed here as the opaque value and manipulate it directly.
  **/
-void adiakSinaCallback(const char *name, adiak_category_t category, const char *subcategory, adiak_value_t *value, adiak_datatype_t *t, void *opaque_value);
-
-}  // end sina namespace
-}  // end axom namespace
+void adiakSinaCallback(const char *name,
+                       adiak_category_t category,
+                       const char *subcategory,
+                       adiak_value_t *value,
+                       adiak_datatype_t *t,
+                       void *opaque_value);
 
-#endif // AXOM_USE_ADIAK
+}  // namespace sina
+}  // namespace axom
 
-#endif // SINA_ADIAK_HPP
+#endif  // AXOM_USE_ADIAK
 
+#endif  // SINA_ADIAK_HPP

src/axom/sina/core/ConduitUtil.cpp

@@ -3,7 +3,6 @@
 //
 // SPDX-License-Identifier: (BSD-3-Clause)
 
-
 /*!
  ******************************************************************************
  *
@@ -42,120 +41,145 @@ namespace
  * @throws std::invalid_argument if the field is not a string
  */
 std::string getExpectedString(conduit::Node const &field,
-        std::string const &fieldName,
-        std::string const &parentType) {
-    if (!field.dtype().is_string()) {
-        std::ostringstream message;
-        message << "The field '" << fieldName
-                << "' for objects of type '" << parentType
-                << "' must be a string, was '"
-                << field.dtype().name() << "'";
-        throw std::invalid_argument(message.str());
-    }
-    return field.as_string();
-}
+                              std::string const &fieldName,
+                              std::string const &parentType)
+{
+  if(!field.dtype().is_string())
+  {
+    std::ostringstream message;
+    message << "The field '" << fieldName << "' for objects of type '"
+            << parentType << "' must be a string, was '" << field.dtype().name()
+            << "'";
+    throw std::invalid_argument(message.str());
+  }
+  return field.as_string();
 }
+}  // namespace
 
 conduit::Node const &getRequiredField(std::string const &fieldName,
-        conduit::Node const &parent, std::string const &parentType) {
-    if (!parent.has_child(fieldName)) {
-        std::ostringstream message;
-        message << "The field '" << fieldName
-                << "' is required for objects of type '" << parentType << "'";
-        throw std::invalid_argument(message.str());
-    }
-    return parent.child(fieldName);
+                                      conduit::Node const &parent,
+                                      std::string const &parentType)
+{
+  if(!parent.has_child(fieldName))
+  {
+    std::ostringstream message;
+    message << "The field '" << fieldName
+            << "' is required for objects of type '" << parentType << "'";
+    throw std::invalid_argument(message.str());
+  }
+  return parent.child(fieldName);
 }
 
 std::string getRequiredString(std::string const &fieldName,
-        conduit::Node const &parent, std::string const &parentType) {
-    conduit::Node const &field = getRequiredField(fieldName, parent, parentType);
-    return getExpectedString(field, fieldName, parentType);
+                              conduit::Node const &parent,
+                              std::string const &parentType)
+{
+  conduit::Node const &field = getRequiredField(fieldName, parent, parentType);
+  return getExpectedString(field, fieldName, parentType);
 }
 
 std::string getOptionalString(std::string const &fieldName,
-        conduit::Node const &parent, std::string const &parentType) {
-    if (!parent.has_child(fieldName) || parent.child(fieldName).dtype().is_empty()) {
-        return "";
-    }
-    return getExpectedString(parent.child(fieldName), fieldName, parentType);
+                              conduit::Node const &parent,
+                              std::string const &parentType)
+{
+  if(!parent.has_child(fieldName) || parent.child(fieldName).dtype().is_empty())
+  {
+    return "";
+  }
+  return getExpectedString(parent.child(fieldName), fieldName, parentType);
 }
 
 double getRequiredDouble(std::string const &fieldName,
-        conduit::Node const &parent, std::string const &parentType) {
-    auto &ref = getRequiredField(fieldName, parent, parentType);
-    if (!ref.dtype().is_number()) {
-        std::ostringstream message;
-        message << "The field '" << fieldName
-                << "' for objects of type '" << parentType
-                << "' must be a double";
-        throw std::invalid_argument(message.str());
-    }
-    return ref.as_double();
+                         conduit::Node const &parent,
+                         std::string const &parentType)
+{
+  auto &ref = getRequiredField(fieldName, parent, parentType);
+  if(!ref.dtype().is_number())
+  {
+    std::ostringstream message;
+    message << "The field '" << fieldName << "' for objects of type '"
+            << parentType << "' must be a double";
+    throw std::invalid_argument(message.str());
+  }
+  return ref.as_double();
 }
 
-void addStringsToNode(conduit::Node &parent, std::string const &child_name,
-      std::vector<std::string> const &string_values){
+void addStringsToNode(conduit::Node &parent,
+                      std::string const &child_name,
+                      std::vector<std::string> const &string_values)
+{
   // If the child already exists, add_child returns it
   conduit::Node &child_node = parent.add_child(child_name);
   for(auto &value : string_values)
   {
-      auto &list_entry = child_node.append();
-      list_entry.set(value);
+    auto &list_entry = child_node.append();
+    list_entry.set(value);
   }
 
   // If there were no children, this will be a null node rather than a list.
   // We prefer empty lists to null values in our serialized JSON, so force
   // this to be a list
-  if (child_node.number_of_children() == 0) {
-      child_node.set_dtype(conduit::DataType::list());
+  if(child_node.number_of_children() == 0)
+  {
+    child_node.set_dtype(conduit::DataType::list());
   }
 }
 
 std::vector<double> toDoubleVector(conduit::Node const &node,
-        std::string const &name) {
-    if (node.dtype().is_list() && node.dtype().number_of_elements() == 0) {
-        return std::vector<double>{};
-    }
-    conduit::Node asDoubles;
-    try {
-        node.to_double_array(asDoubles);
-    } catch (conduit::Error const &err) {
-        std::ostringstream errStream;
-        errStream << "Error trying to convert node \"" << name
-                  << "\" into a list of doubles" << err.what();
-        throw std::invalid_argument(errStream.str());
-    }
-    double const *start = asDoubles.as_double_ptr();
-    auto count = static_cast<std::vector<double>::size_type>(
-            asDoubles.dtype().number_of_elements());
-    return std::vector<double>{start, start + count};
+                                   std::string const &name)
+{
+  if(node.dtype().is_list() && node.dtype().number_of_elements() == 0)
+  {
+    return std::vector<double> {};
+  }
+  conduit::Node asDoubles;
+  try
+  {
+    node.to_double_array(asDoubles);
+  }
+  catch(conduit::Error const &err)
+  {
+    std::ostringstream errStream;
+    errStream << "Error trying to convert node \"" << name
+              << "\" into a list of doubles" << err.what();
+    throw std::invalid_argument(errStream.str());
+  }
+  double const *start = asDoubles.as_double_ptr();
+  auto count = static_cast<std::vector<double>::size_type>(
+    asDoubles.dtype().number_of_elements());
+  return std::vector<double> {start, start + count};
 }
 
 std::vector<std::string> toStringVector(conduit::Node const &node,
-        std::string const &name) {
-    std::vector<std::string> converted;
-    if (!node.dtype().is_list()) {
-        std::ostringstream errStream;
-        errStream << "Error trying to convert node \"" << name
-                  << "\" into a list of strings. It is not a list. "
-                  << node.to_json_default();
-        throw std::invalid_argument(errStream.str());
+                                        std::string const &name)
+{
+  std::vector<std::string> converted;
+  if(!node.dtype().is_list())
+  {
+    std::ostringstream errStream;
+    errStream << "Error trying to convert node \"" << name
+              << "\" into a list of strings. It is not a list. "
+              << node.to_json_default();
+    throw std::invalid_argument(errStream.str());
+  }
+  for(auto iter = node.children(); iter.has_next();)
+  {
+    auto &child = iter.next();
+    if(child.dtype().is_string())
+    {
+      converted.emplace_back(child.as_string());
     }
-    for (auto iter = node.children(); iter.has_next(); ) {
-        auto &child = iter.next();
-        if (child.dtype().is_string()) {
-            converted.emplace_back(child.as_string());
-        } else {
-            std::ostringstream errStream;
-            errStream << "Error trying to convert node \"" << name
-                      << "\" into a list of strings. A value is not a string. "
-                      << node.to_json_default();
-            throw std::invalid_argument(errStream.str());
-        }
+    else
+    {
+      std::ostringstream errStream;
+      errStream << "Error trying to convert node \"" << name
+                << "\" into a list of strings. A value is not a string. "
+                << node.to_json_default();
+      throw std::invalid_argument(errStream.str());
     }
-    return converted;
+  }
+  return converted;
 }
 
-}  // end sina namespace
-}  // end axom namespace
+}  // namespace sina
+}  // namespace axom

src/axom/sina/core/ConduitUtil.hpp

@@ -3,7 +3,6 @@
 //
 // SPDX-License-Identifier: (BSD-3-Clause)
 
-
 #ifndef SINA_JSONUTIL_HPP
 #define SINA_JSONUTIL_HPP
 
@@ -38,7 +37,8 @@ namespace sina
  * \throws std::invalid_argument if the field does not exist
  */
 conduit::Node const &getRequiredField(std::string const &fieldName,
-        conduit::Node const &parent, std::string const &parentType);
+                                      conduit::Node const &parent,
+                                      std::string const &parentType);
 
 /**
  * \brief Get the value of a required field from a conduit Node. The field value
@@ -52,7 +52,8 @@ conduit::Node const &getRequiredField(std::string const &fieldName,
  * \throws std::invalid_argument if the field does not exist or is not a string
  */
 std::string getRequiredString(std::string const &fieldName,
-        conduit::Node const &parent, std::string const &parentType);
+                              conduit::Node const &parent,
+                              std::string const &parentType);
 
 /**
  * \brief Get the value of a required field from a conduit Node. The field value
@@ -66,7 +67,8 @@ std::string getRequiredString(std::string const &fieldName,
  * \throws std::invalid_argument if the field does not exist or is not a double
  */
 double getRequiredDouble(std::string const &fieldName,
-        conduit::Node const &parent, std::string const &parentType);
+                         conduit::Node const &parent,
+                         std::string const &parentType);
 
 /**
  * \brief Get the value of an optional field from a conduit Node. The field value
@@ -81,7 +83,8 @@ double getRequiredDouble(std::string const &fieldName,
  * \throws std::invalid_argument if the field exists but is not a string
  */
 std::string getOptionalString(std::string const &fieldName,
-        conduit::Node const &parent, std::string const &parentType);
+                              conduit::Node const &parent,
+                              std::string const &parentType);
 
 /**
  * \brief Convert the given node to a vector of doubles.
@@ -92,7 +95,7 @@ std::string getOptionalString(std::string const &fieldName,
  * \throws std::invalid_argument if the node is not a list of doubles
  */
 std::vector<double> toDoubleVector(conduit::Node const &node,
-        std::string const &name);
+                                   std::string const &name);
 
 /**
  * \brief Convert the given node to a vector of strings.
@@ -103,7 +106,7 @@ std::vector<double> toDoubleVector(conduit::Node const &node,
  * \throws std::invalid_argument if the node is not a list of strings
  */
 std::vector<std::string> toStringVector(conduit::Node const &node,
-        std::string const &name);
+                                        std::string const &name);
 
 /**
  * \brief Add a vector of strings to a Node. This operation's not natively
@@ -113,10 +116,11 @@ std::vector<std::string> toStringVector(conduit::Node const &node,
  * \param child_name the name of the child (aka the name of the field)
  * \param string_values the data values for the field
  */
-void addStringsToNode(conduit::Node &parent, const std::string &child_name,
-      std::vector<std::string> const &string_values);
+void addStringsToNode(conduit::Node &parent,
+                      const std::string &child_name,
+                      std::vector<std::string> const &string_values);
 
 }  // end namespace sina
 }  // end namespace axom
 
-#endif //SINA_JSONUTIL_HPP
+#endif  //SINA_JSONUTIL_HPP