field_factory.inl: clang-format.

src/field_factory.inl

@@ -9,71 +9,109 @@
 
 #include "field.h"
 
-inline Field_t FieldFactory::init(const CdoVar& var) {
-  if(var.memType == MemType::Float) {
-    return Field<float>{var.gridID, var.gridsize, var.missval, var.gridsize * var.nwpv};
-  } else if (var.memType == MemType::Double) {
-    return Field<double>{var.gridID, var.gridsize, var.missval, var.gridsize * var.nwpv};
-  } else {
-    throw std::runtime_error("Not supported type");
-  }
+inline Field_t FieldFactory::init(const CdoVar& var)
+{
+  if (var.memType == MemType::Float)
+    {
+      return Field<float>{var.gridID, var.gridsize, var.missval, var.gridsize * var.nwpv};
+    }
+  else if (var.memType == MemType::Double)
+    {
+      return Field<double>{var.gridID, var.gridsize, var.missval, var.gridsize * var.nwpv};
+    }
+  else
+    {
+      throw std::runtime_error("Not supported type");
+    }
 }
 
-inline Field_t FieldFactory::init(const MemType memType) {
-  if(memType == MemType::Float) {
-    return Field<float>{};
-  } else if (memType == MemType::Double) {
-    return Field<double>{};
-  } else {
-    throw std::runtime_error("Not supported type");
-  }
+inline Field_t FieldFactory::init(const MemType memType)
+{
+  if (memType == MemType::Float)
+    {
+      return Field<float>{};
+    }
+  else if (memType == MemType::Double)
+    {
+      return Field<double>{};
+    }
+  else
+    {
+      throw std::runtime_error("Not supported type");
+    }
 }
 
-inline Field_t FieldFactory::init(const CdoVar& var, const MemType memType) {
-  if(memType == MemType::Float) {
-    return Field<float>{var.gridID, var.gridsize, var.missval, var.gridsize * var.nwpv};
-  } else if (memType == MemType::Double) {
-    return Field<double>{var.gridID, var.gridsize, var.missval, var.gridsize * var.nwpv};
-  } else {
-    throw std::runtime_error("Not supported type");
-  }
+inline Field_t FieldFactory::init(const CdoVar& var, const MemType memType)
+{
+  if (memType == MemType::Float)
+    {
+      return Field<float>{var.gridID, var.gridsize, var.missval, var.gridsize * var.nwpv};
+    }
+  else if (memType == MemType::Double)
+    {
+      return Field<double>{var.gridID, var.gridsize, var.missval, var.gridsize * var.nwpv};
+    }
+  else
+    {
+      throw std::runtime_error("Not supported type");
+    }
 }
 
-inline Field3D_t FieldFactory::init3D(const CdoVar& var) {
-  if(var.memType == MemType::Float) {
-    return Field3D<float>{var.gridID, var.gridsize, var.missval, var.gridsize * var.nwpv, static_cast<size_t>(var.nlevels)};
-  } else if (var.memType == MemType::Double) {
-    return Field3D<double>{var.gridID, var.gridsize, var.missval, var.gridsize * var.nwpv, static_cast<size_t>(var.nlevels)};
-  } else {
-    throw std::runtime_error("Not supported type");
-  }
+inline Field3D_t FieldFactory::init3D(const CdoVar& var)
+{
+  if (var.memType == MemType::Float)
+    {
+      return Field3D<float>{var.gridID, var.gridsize, var.missval, var.gridsize * var.nwpv, static_cast<size_t>(var.nlevels)};
+    }
+  else if (var.memType == MemType::Double)
+    {
+      return Field3D<double>{var.gridID, var.gridsize, var.missval, var.gridsize * var.nwpv, static_cast<size_t>(var.nlevels)};
+    }
+  else
+    {
+      throw std::runtime_error("Not supported type");
+    }
 }
 
-inline Field3D_t FieldFactory::init3D(const MemType memType) {
-  if(memType == MemType::Float) {
-    return Field3D<float>{};
-  } else if (memType == MemType::Double) {
-    return Field3D<double>{};
-  } else {
-    throw std::runtime_error("Not supported type");
-  }
+inline Field3D_t FieldFactory::init3D(const MemType memType)
+{
+  if (memType == MemType::Float)
+    {
+      return Field3D<float>{};
+    }
+  else if (memType == MemType::Double)
+    {
+      return Field3D<double>{};
+    }
+  else
+    {
+      throw std::runtime_error("Not supported type");
+    }
 }
 
-inline Field_t FieldFactory::reInit(Field_t& field, const CdoVar& var) {
-  if((var.memType == MemType::Float && std::holds_alternative<FieldDouble>(field)) ||
-      (var.memType == MemType::Double && std::holds_alternative<FieldFloat>(field))) {
+inline Field_t FieldFactory::reInit(Field_t& field, const CdoVar& var)
+{
+  if ((var.memType == MemType::Float && std::holds_alternative<FieldDouble>(field)) ||
+      (var.memType == MemType::Double && std::holds_alternative<FieldFloat>(field)))
+    {
       // The type has changed
       return FieldFactory::init(var);
-  } else if (var.memType == MemType::Double &&  std::holds_alternative<FieldDouble>(field)) {
-    std::get<FieldDouble>(field).resize(var.gridsize * var.nwpv);
-    return std::move(field);
-  } else  if (var.memType == MemType::Float &&  std::holds_alternative<FieldFloat>(field)) {
-    std::get<FieldFloat>(field).resize(var.gridsize * var.nwpv);
-    return std::move(field);
-  } else {
-    throw std::runtime_error("Not supported type");
-  }
+    }
+  else if (var.memType == MemType::Double &&  std::holds_alternative<FieldDouble>(field))
+    {
+      std::get<FieldDouble>(field).resize(var.gridsize * var.nwpv);
+      return std::move(field);
+    }
+  else  if (var.memType == MemType::Float &&  std::holds_alternative<FieldFloat>(field))
+    {
+      std::get<FieldFloat>(field).resize(var.gridsize * var.nwpv);
+      return std::move(field);
+    }
+  else
+    {
+      throw std::runtime_error("Not supported type");
+    }
 }
 
 
-#endif // FIELD_FACOTRY_INL
\ No newline at end of file
+#endif // FIELD_FACOTRY_INL