more astyle

Author: Paul Harwood

source/pdal/pdalc_dimtype.cpp

@@ -37,122 +37,122 @@ namespace capi
 {
 size_t PDALGetDimTypeListSize(PDALDimTypeListPtr types)
 {
-pdal::capi::DimTypeList *wrapper = reinterpret_cast<pdal::capi::DimTypeList *>(types);
+    pdal::capi::DimTypeList *wrapper = reinterpret_cast<pdal::capi::DimTypeList *>(types);
 
-size_t size = 0;
+    size_t size = 0;
 
-if (wrapper && wrapper->get())
-{
-    try
-    {
-        pdal::DimTypeList *list = wrapper->get();
-        size = list->size();
-    }
-    catch (const std::exception &e)
+    if (wrapper && wrapper->get())
     {
-        printf("%s\n", e.what());
+        try
+        {
+            pdal::DimTypeList *list = wrapper->get();
+            size = list->size();
+        }
+        catch (const std::exception &e)
+        {
+            printf("%s\n", e.what());
+        }
     }
-}
 
-return size;
+    return size;
 }
 
 uint64_t PDALGetDimTypeListByteCount(PDALDimTypeListPtr types)
 {
-uint64_t byteCount = 0;
-size_t pointCount = PDALGetDimTypeListSize(types);
+    uint64_t byteCount = 0;
+    size_t pointCount = PDALGetDimTypeListSize(types);
 
-for (size_t i = 0; i < pointCount; ++i)
-{
-    byteCount += PDALGetDimTypeInterpretationByteCount(PDALGetDimType(types, i));
-}
+    for (size_t i = 0; i < pointCount; ++i)
+    {
+        byteCount += PDALGetDimTypeInterpretationByteCount(PDALGetDimType(types, i));
+    }
 
-return byteCount;
+    return byteCount;
 }
 
 PDALDimType PDALGetInvalidDimType()
 {
-PDALDimType dim =
-{
-    static_cast<uint32_t>(pdal::Dimension::id("")), static_cast<uint32_t>(pdal::Dimension::type("")),
-    1.0, 0.0
-};
+    PDALDimType dim =
+    {
+        static_cast<uint32_t>(pdal::Dimension::id("")), static_cast<uint32_t>(pdal::Dimension::type("")),
+        1.0, 0.0
+    };
 
-return dim;
+    return dim;
 }
 
 size_t PDALGetDimTypeIdName(PDALDimType dim, char *name, size_t size)
 {
-size_t result = 0;
+    size_t result = 0;
 
-if (name && size > 0)
-{
-    std::string s = pdal::Dimension::name(
-                        static_cast<pdal::Dimension::Id>(dim.id));
-    std::strncpy(name, s.c_str(), size);
-    result = std::min(std::strlen(name), size);
-}
+    if (name && size > 0)
+    {
+        std::string s = pdal::Dimension::name(
+                            static_cast<pdal::Dimension::Id>(dim.id));
+        std::strncpy(name, s.c_str(), size);
+        result = std::min(std::strlen(name), size);
+    }
 
-return result;
+    return result;
 }
 
 size_t PDALGetDimTypeInterpretationName(PDALDimType dim, char *name, size_t size)
 {
-size_t result = 0;
+    size_t result = 0;
 
-if (name && size > 0)
-{
-    std::string s = pdal::Dimension::interpretationName(
-                        static_cast<pdal::Dimension::Type>(dim.type));
-    std::strncpy(name, s.c_str(), size);
-    result = std::min(std::strlen(name), size);
-}
+    if (name && size > 0)
+    {
+        std::string s = pdal::Dimension::interpretationName(
+                            static_cast<pdal::Dimension::Type>(dim.type));
+        std::strncpy(name, s.c_str(), size);
+        result = std::min(std::strlen(name), size);
+    }
 
-return result;
+    return result;
 }
 
 size_t PDALGetDimTypeInterpretationByteCount(PDALDimType dim)
 {
-return pdal::Dimension::size(static_cast<pdal::Dimension::Type>(dim.type));
+    return pdal::Dimension::size(static_cast<pdal::Dimension::Type>(dim.type));
 }
 
 PDALDimType PDALGetDimType(PDALDimTypeListPtr types, size_t index)
 {
-pdal::capi::DimTypeList *wrapper = reinterpret_cast<pdal::capi::DimTypeList *>(types);
+    pdal::capi::DimTypeList *wrapper = reinterpret_cast<pdal::capi::DimTypeList *>(types);
 
-PDALDimType dim = PDALGetInvalidDimType();
+    PDALDimType dim = PDALGetInvalidDimType();
 
-if (wrapper && wrapper->get())
-{
-    try
+    if (wrapper && wrapper->get())
     {
-        pdal::DimTypeList *list = wrapper->get();
-
-        if (index < list->size())
+        try
         {
-            pdal::DimType nativeDim = list->at(index);
-            dim.id = static_cast<uint32_t>(nativeDim.m_id);
-            dim.type = static_cast<uint32_t>(nativeDim.m_type);
-            dim.scale = nativeDim.m_xform.m_scale.m_val;
-            dim.offset = nativeDim.m_xform.m_offset.m_val;
+            pdal::DimTypeList *list = wrapper->get();
+
+            if (index < list->size())
+            {
+                pdal::DimType nativeDim = list->at(index);
+                dim.id = static_cast<uint32_t>(nativeDim.m_id);
+                dim.type = static_cast<uint32_t>(nativeDim.m_type);
+                dim.scale = nativeDim.m_xform.m_scale.m_val;
+                dim.offset = nativeDim.m_xform.m_offset.m_val;
+            }
+        }
+        catch (const std::exception &e)
+        {
+            printf("%s\n", e.what());
         }
     }
-    catch (const std::exception &e)
-    {
-        printf("%s\n", e.what());
-    }
-}
 
-return dim;
+    return dim;
 }
 
 void PDALDisposeDimTypeList(PDALDimTypeListPtr types)
 {
-if (types)
-{
-    pdal::capi::DimTypeList *ptr = reinterpret_cast<pdal::capi::DimTypeList *>(types);
-    delete ptr;
-}
+    if (types)
+    {
+        pdal::capi::DimTypeList *ptr = reinterpret_cast<pdal::capi::DimTypeList *>(types);
+        delete ptr;
+    }
 }
 }
 }

source/pdal/pdalc_forward.h

@@ -81,16 +81,16 @@ typedef struct PDALDimType PDALDimType;
 struct PDALDimType
 {
 /// The dimension's identifier
-uint32_t id;
+    uint32_t id;
 
 /// The dimension's interpretation type
-uint32_t type;
+    uint32_t type;
 
 /// The dimension's scaling factor
-double scale;
+    double scale;
 
 /// The dimension's offset value
-double offset;
+    double offset;
 };
 
 /// A pointer to a dimension type list