Merge pull request #2551 from rouault/clang_format

Reformat code with clang-format-10 from ubuntu 20.04

5 files changed, 245 insertions, 215 deletions

diff --git a/src/iso19111/operation/conversion.cpp b/src/iso19111/operation/conversion.cpp
index 1808dbe7..e9d688b7 100644
--- a/src/iso19111/operation/conversion.cpp
+++ b/src/iso19111/operation/conversion.cpp
@@ -2238,15 +2238,16 @@ ConversionNNPtr Conversion::createPoleRotationGRIBConvention(
 ConversionNNPtr
 Conversion::createChangeVerticalUnit(const util::PropertyMap &properties,
                                      const common::Scale &factor) {
-    return create(properties, createMethodMapNameEPSGCode(
-                                  EPSG_CODE_METHOD_CHANGE_VERTICAL_UNIT),
-                  VectorOfParameters{
-                      createOpParamNameEPSGCode(
-                          EPSG_CODE_PARAMETER_UNIT_CONVERSION_SCALAR),
-                  },
-                  VectorOfValues{
-                      factor,
-                  });
+    return create(
+        properties,
+        createMethodMapNameEPSGCode(EPSG_CODE_METHOD_CHANGE_VERTICAL_UNIT),
+        VectorOfParameters{
+            createOpParamNameEPSGCode(
+                EPSG_CODE_PARAMETER_UNIT_CONVERSION_SCALAR),
+        },
+        VectorOfValues{
+            factor,
+        });
 }
 
 // ---------------------------------------------------------------------------
@@ -2264,9 +2265,10 @@ Conversion::createChangeVerticalUnit(const util::PropertyMap &properties,
  */
 ConversionNNPtr
 Conversion::createHeightDepthReversal(const util::PropertyMap &properties) {
-    return create(properties, createMethodMapNameEPSGCode(
-                                  EPSG_CODE_METHOD_HEIGHT_DEPTH_REVERSAL),
-                  {}, {});
+    return create(
+        properties,
+        createMethodMapNameEPSGCode(EPSG_CODE_METHOD_HEIGHT_DEPTH_REVERSAL), {},
+        {});
 }
 
 // ---------------------------------------------------------------------------
@@ -2310,9 +2312,10 @@ ConversionNNPtr Conversion::createAxisOrderReversal(bool is3D) {
  */
 ConversionNNPtr
 Conversion::createGeographicGeocentric(const util::PropertyMap &properties) {
-    return create(properties, createMethodMapNameEPSGCode(
-                                  EPSG_CODE_METHOD_GEOGRAPHIC_GEOCENTRIC),
-                  {}, {});
+    return create(
+        properties,
+        createMethodMapNameEPSGCode(EPSG_CODE_METHOD_GEOGRAPHIC_GEOCENTRIC), {},
+        {});
 }
 
 // ---------------------------------------------------------------------------
@@ -2458,9 +2461,10 @@ static double lcc_1sp_to_2sp_f(double sinphi, double K, double ec, double n) {
     const double x = sinphi;
     const double ecx = ec * x;
     return (1 - x * x) / (1 - ecx * ecx) -
-           K * K * std::pow((1.0 - x) / (1.0 + x) *
-                                std::pow((1.0 + ecx) / (1.0 - ecx), ec),
-                            n);
+           K * K *
+               std::pow((1.0 - x) / (1.0 + x) *
+                            std::pow((1.0 + ecx) / (1.0 - ecx), ec),
+                        n);
 }
 
 // ---------------------------------------------------------------------------
@@ -2748,8 +2752,9 @@ ConversionPtr Conversion::convertToOtherMethod(int targetEPSGCode) const {
             common::Angle(phi0Deg, common::UnitOfMeasure::DEGREE),
             common::Angle(parameterValueMeasure(
                 EPSG_CODE_PARAMETER_LONGITUDE_FALSE_ORIGIN)),
-            common::Scale(k0), common::Length(parameterValueMeasure(
-                                   EPSG_CODE_PARAMETER_EASTING_FALSE_ORIGIN)),
+            common::Scale(k0),
+            common::Length(parameterValueMeasure(
+                EPSG_CODE_PARAMETER_EASTING_FALSE_ORIGIN)),
             common::Length(
                 parameterValueNumericAsSI(
                     EPSG_CODE_PARAMETER_NORTHING_FALSE_ORIGIN) +
diff --git a/src/iso19111/operation/coordinateoperationfactory.cpp b/src/iso19111/operation/coordinateoperationfactory.cpp
index e4b989c8..44d9b570 100644
--- a/src/iso19111/operation/coordinateoperationfactory.cpp
+++ b/src/iso19111/operation/coordinateoperationfactory.cpp
@@ -30,8 +30,8 @@
 #define FROM_PROJ_CPP
 #endif
 
-#include "proj/coordinateoperation.hpp"
 #include "proj/common.hpp"
+#include "proj/coordinateoperation.hpp"
 #include "proj/crs.hpp"
 #include "proj/io.hpp"
 #include "proj/metadata.hpp"
@@ -1892,8 +1892,8 @@ struct MyPROJStringExportableGeodToGeod final
     ~MyPROJStringExportableGeodToGeod() override;
 
     void
-        // cppcheck-suppress functionStatic
-        _exportToPROJString(io::PROJStringFormatter *formatter) const override {
+    // cppcheck-suppress functionStatic
+    _exportToPROJString(io::PROJStringFormatter *formatter) const override {
 
         formatter->startInversion();
         geodSrc->_exportToPROJString(formatter);
@@ -1922,8 +1922,8 @@ struct MyPROJStringExportableHorizVertical final
     ~MyPROJStringExportableHorizVertical() override;
 
     void
-        // cppcheck-suppress functionStatic
-        _exportToPROJString(io::PROJStringFormatter *formatter) const override {
+    // cppcheck-suppress functionStatic
+    _exportToPROJString(io::PROJStringFormatter *formatter) const override {
 
         formatter->pushOmitZUnitConversion();
 
@@ -1970,8 +1970,8 @@ struct MyPROJStringExportableHorizVerticalHorizPROJBased final
     ~MyPROJStringExportableHorizVerticalHorizPROJBased() override;
 
     void
-        // cppcheck-suppress functionStatic
-        _exportToPROJString(io::PROJStringFormatter *formatter) const override {
+    // cppcheck-suppress functionStatic
+    _exportToPROJString(io::PROJStringFormatter *formatter) const override {
 
         formatter->pushOmitZUnitConversion();
 
@@ -2321,10 +2321,9 @@ CoordinateOperationFactory::Private::createOperationsGeogToGeog(
     }
 
     // Do they differ by vertical units ?
-    if (vconvSrc != vconvDst &&
-        geogSrc->ellipsoid()->_isEquivalentTo(
-            geogDst->ellipsoid().get(),
-            util::IComparable::Criterion::EQUIVALENT)) {
+    if (vconvSrc != vconvDst && geogSrc->ellipsoid()->_isEquivalentTo(
+                                    geogDst->ellipsoid().get(),
+                                    util::IComparable::Criterion::EQUIVALENT)) {
         if (offset_pm.value() == 0 && !axisReversal2D && !axisReversal3D) {
             // If only by vertical units, use a Change of Vertical
             // Unit
@@ -3267,7 +3266,6 @@ CoordinateOperationFactory::Private::createOperationsGeogToVertFromGeoid(
 
     const auto useTransf = [&sourceCRS, &targetCRS, &context,
                             vertDst](const CoordinateOperationNNPtr &op) {
-
         // If the source geographic CRS has a non-metre vertical unit, we need
         // to create an intermediate and operation to do the vertical unit
         // conversion from that vertical unit to the one of the geographic CRS
@@ -3324,85 +3322,86 @@ CoordinateOperationFactory::Private::createOperationsGeogToVertFromGeoid(
         return ret;
     };
 
-    const auto getProjGeoidTransformation = [&sourceCRS, &targetCRS, &vertDst,
-                                             &context](
-        const CoordinateOperationNNPtr &model,
-        const std::string &projFilename) {
-
-        const auto getNameVertCRSMetre = [](const std::string &name) {
-            if (name.empty())
-                return std::string("unnamed");
-            auto ret(name);
-            bool haveOriginalUnit = false;
-            if (name.back() == ')') {
-                const auto pos = ret.rfind(" (");
+    const auto getProjGeoidTransformation =
+        [&sourceCRS, &targetCRS, &vertDst,
+         &context](const CoordinateOperationNNPtr &model,
+                   const std::string &projFilename) {
+            const auto getNameVertCRSMetre = [](const std::string &name) {
+                if (name.empty())
+                    return std::string("unnamed");
+                auto ret(name);
+                bool haveOriginalUnit = false;
+                if (name.back() == ')') {
+                    const auto pos = ret.rfind(" (");
+                    if (pos != std::string::npos) {
+                        haveOriginalUnit = true;
+                        ret = ret.substr(0, pos);
+                    }
+                }
+                const auto pos = ret.rfind(" depth");
                 if (pos != std::string::npos) {
-                    haveOriginalUnit = true;
-                    ret = ret.substr(0, pos);
+                    ret = ret.substr(0, pos) + " height";
                 }
-            }
-            const auto pos = ret.rfind(" depth");
-            if (pos != std::string::npos) {
-                ret = ret.substr(0, pos) + " height";
-            }
-            if (!haveOriginalUnit) {
-                ret += " (metre)";
-            }
-            return ret;
-        };
+                if (!haveOriginalUnit) {
+                    ret += " (metre)";
+                }
+                return ret;
+            };
 
-        const auto &axis = vertDst->coordinateSystem()->axisList()[0];
-        const auto &authFactory = context.context->getAuthorityFactory();
-        const auto dbContext =
-            authFactory ? authFactory->databaseContext().as_nullable()
-                        : nullptr;
+            const auto &axis = vertDst->coordinateSystem()->axisList()[0];
+            const auto &authFactory = context.context->getAuthorityFactory();
+            const auto dbContext =
+                authFactory ? authFactory->databaseContext().as_nullable()
+                            : nullptr;
 
-        const auto geogSrcCRS =
-            dynamic_cast<crs::GeographicCRS *>(model->interpolationCRS().get())
-                ? NN_NO_CHECK(model->interpolationCRS())
-                : sourceCRS->demoteTo2D(std::string(), dbContext)
-                      ->promoteTo3D(std::string(), dbContext);
-        const auto vertCRSMetre =
-            axis->unit() == common::UnitOfMeasure::METRE &&
-                    axis->direction() == cs::AxisDirection::UP
-                ? targetCRS
-                : util::nn_static_pointer_cast<crs::CRS>(
-                      crs::VerticalCRS::create(
-                          util::PropertyMap().set(
-                              common::IdentifiedObject::NAME_KEY,
-                              getNameVertCRSMetre(targetCRS->nameStr())),
-                          vertDst->datum(), vertDst->datumEnsemble(),
-                          cs::VerticalCS::createGravityRelatedHeight(
-                              common::UnitOfMeasure::METRE)));
-        const auto properties = util::PropertyMap().set(
-            common::IdentifiedObject::NAME_KEY,
-            buildOpName("Transformation", vertCRSMetre, geogSrcCRS));
-
-        // Try to find a representative value for the accuracy of this grid
-        // from the registered transformations.
-        std::vector<metadata::PositionalAccuracyNNPtr> accuracies;
-        const auto &modelAccuracies = model->coordinateOperationAccuracies();
-        if (modelAccuracies.empty()) {
-            if (authFactory) {
-                const auto transformationsForGrid =
-                    io::DatabaseContext::getTransformationsForGridName(
-                        authFactory->databaseContext(), projFilename);
-                double accuracy = -1;
-                for (const auto &transf : transformationsForGrid) {
-                    accuracy = std::max(accuracy, getAccuracy(transf));
-                }
-                if (accuracy >= 0) {
-                    accuracies.emplace_back(
-                        metadata::PositionalAccuracy::create(
-                            toString(accuracy)));
+            const auto geogSrcCRS =
+                dynamic_cast<crs::GeographicCRS *>(
+                    model->interpolationCRS().get())
+                    ? NN_NO_CHECK(model->interpolationCRS())
+                    : sourceCRS->demoteTo2D(std::string(), dbContext)
+                          ->promoteTo3D(std::string(), dbContext);
+            const auto vertCRSMetre =
+                axis->unit() == common::UnitOfMeasure::METRE &&
+                        axis->direction() == cs::AxisDirection::UP
+                    ? targetCRS
+                    : util::nn_static_pointer_cast<crs::CRS>(
+                          crs::VerticalCRS::create(
+                              util::PropertyMap().set(
+                                  common::IdentifiedObject::NAME_KEY,
+                                  getNameVertCRSMetre(targetCRS->nameStr())),
+                              vertDst->datum(), vertDst->datumEnsemble(),
+                              cs::VerticalCS::createGravityRelatedHeight(
+                                  common::UnitOfMeasure::METRE)));
+            const auto properties = util::PropertyMap().set(
+                common::IdentifiedObject::NAME_KEY,
+                buildOpName("Transformation", vertCRSMetre, geogSrcCRS));
+
+            // Try to find a representative value for the accuracy of this grid
+            // from the registered transformations.
+            std::vector<metadata::PositionalAccuracyNNPtr> accuracies;
+            const auto &modelAccuracies =
+                model->coordinateOperationAccuracies();
+            if (modelAccuracies.empty()) {
+                if (authFactory) {
+                    const auto transformationsForGrid =
+                        io::DatabaseContext::getTransformationsForGridName(
+                            authFactory->databaseContext(), projFilename);
+                    double accuracy = -1;
+                    for (const auto &transf : transformationsForGrid) {
+                        accuracy = std::max(accuracy, getAccuracy(transf));
+                    }
+                    if (accuracy >= 0) {
+                        accuracies.emplace_back(
+                            metadata::PositionalAccuracy::create(
+                                toString(accuracy)));
+                    }
                 }
             }
-        }
 
-        return Transformation::createGravityRelatedHeightToGeographic3D(
-            properties, vertCRSMetre, geogSrcCRS, nullptr, projFilename,
-            !modelAccuracies.empty() ? modelAccuracies : accuracies);
-    };
+            return Transformation::createGravityRelatedHeightToGeographic3D(
+                properties, vertCRSMetre, geogSrcCRS, nullptr, projFilename,
+                !modelAccuracies.empty() ? modelAccuracies : accuracies);
+        };
 
     std::vector<CoordinateOperationNNPtr> res;
     const auto &authFactory = context.context->getAuthorityFactory();
@@ -3593,35 +3592,38 @@ void CoordinateOperationFactory::Private::
     // NAD83 only exists in 2D version in EPSG, so if it has been
     // promoted to 3D, when researching a vertical to geog
     // transformation, try to down cast to 2D.
-    const auto geog3DToVertTryThroughGeog2D = [&res, &context](
-        const crs::GeographicCRS *geogSrcIn, const crs::VerticalCRS *vertDstIn,
-        const crs::CRSNNPtr &targetCRSIn) {
-        if (res.empty() && geogSrcIn && vertDstIn &&
-            geogSrcIn->coordinateSystem()->axisList().size() == 3) {
-            const auto &authFactory = context.context->getAuthorityFactory();
-            const auto dbContext =
-                authFactory ? authFactory->databaseContext().as_nullable()
-                            : nullptr;
-            const auto candidatesSrcGeod(findCandidateGeodCRSForDatum(
-                authFactory, geogSrcIn,
-                geogSrcIn->datumNonNull(dbContext).get()));
-            for (const auto &candidate : candidatesSrcGeod) {
-                auto geogCandidate =
-                    util::nn_dynamic_pointer_cast<crs::GeographicCRS>(
-                        candidate);
-                if (geogCandidate &&
-                    geogCandidate->coordinateSystem()->axisList().size() == 2) {
-                    bool ignored;
-                    res =
-                        findOpsInRegistryDirect(NN_NO_CHECK(geogCandidate),
-                                                targetCRSIn, context, ignored);
-                    break;
+    const auto geog3DToVertTryThroughGeog2D =
+        [&res, &context](const crs::GeographicCRS *geogSrcIn,
+                         const crs::VerticalCRS *vertDstIn,
+                         const crs::CRSNNPtr &targetCRSIn) {
+            if (res.empty() && geogSrcIn && vertDstIn &&
+                geogSrcIn->coordinateSystem()->axisList().size() == 3) {
+                const auto &authFactory =
+                    context.context->getAuthorityFactory();
+                const auto dbContext =
+                    authFactory ? authFactory->databaseContext().as_nullable()
+                                : nullptr;
+                const auto candidatesSrcGeod(findCandidateGeodCRSForDatum(
+                    authFactory, geogSrcIn,
+                    geogSrcIn->datumNonNull(dbContext).get()));
+                for (const auto &candidate : candidatesSrcGeod) {
+                    auto geogCandidate =
+                        util::nn_dynamic_pointer_cast<crs::GeographicCRS>(
+                            candidate);
+                    if (geogCandidate &&
+                        geogCandidate->coordinateSystem()->axisList().size() ==
+                            2) {
+                        bool ignored;
+                        res = findOpsInRegistryDirect(
+                            NN_NO_CHECK(geogCandidate), targetCRSIn, context,
+                            ignored);
+                        break;
+                    }
                 }
+                return true;
             }
-            return true;
-        }
-        return false;
-    };
+            return false;
+        };
 
     if (geog3DToVertTryThroughGeog2D(geogSrc, vertDst, targetCRS)) {
         // do nothing
@@ -5169,26 +5171,27 @@ crs::CRSNNPtr CRS::getResolvedCRS(const crs::CRSNNPtr &crs,
     // Even if they aren't equivalent, we update extentOut with the one of the
     // identified CRS if our input one is absent/not reliable.
 
-    const auto tryToIdentifyByName = [&crs, &name, &authFactory, approxExtent,
-                                      &extentOut](
-        io::AuthorityFactory::ObjectType objectType) {
-        if (name != "unknown" && name != "unnamed") {
-            auto matches = authFactory->createObjectsFromName(
-                name, {objectType}, false, 2);
-            if (matches.size() == 1) {
-                const auto match =
-                    util::nn_static_pointer_cast<crs::CRS>(matches.front());
-                if (approxExtent || !extentOut) {
-                    extentOut = operation::getExtent(match);
-                }
-                if (match->isEquivalentTo(
-                        crs.get(), util::IComparable::Criterion::EQUIVALENT)) {
-                    return match;
+    const auto tryToIdentifyByName =
+        [&crs, &name, &authFactory, approxExtent,
+         &extentOut](io::AuthorityFactory::ObjectType objectType) {
+            if (name != "unknown" && name != "unnamed") {
+                auto matches = authFactory->createObjectsFromName(
+                    name, {objectType}, false, 2);
+                if (matches.size() == 1) {
+                    const auto match =
+                        util::nn_static_pointer_cast<crs::CRS>(matches.front());
+                    if (approxExtent || !extentOut) {
+                        extentOut = operation::getExtent(match);
+                    }
+                    if (match->isEquivalentTo(
+                            crs.get(),
+                            util::IComparable::Criterion::EQUIVALENT)) {
+                        return match;
+                    }
                 }
             }
-        }
-        return crs;
-    };
+            return crs;
+        };
 
     auto geogCRS = dynamic_cast<crs::GeographicCRS *>(crs.get());
     if (geogCRS && authFactory) {
diff --git a/src/iso19111/operation/parammappings.cpp b/src/iso19111/operation/parammappings.cpp
index de5f4c7e..03200468 100644
--- a/src/iso19111/operation/parammappings.cpp
+++ b/src/iso19111/operation/parammappings.cpp
@@ -760,8 +760,11 @@ static const MethodMapping projectionMethodMappings[] = {
 
     {
         EPSG_NAME_METHOD_OBLIQUE_STEREOGRAPHIC,
-        EPSG_CODE_METHOD_OBLIQUE_STEREOGRAPHIC, "Oblique_Stereographic",
-        "sterea", nullptr, paramsObliqueStereo,
+        EPSG_CODE_METHOD_OBLIQUE_STEREOGRAPHIC,
+        "Oblique_Stereographic",
+        "sterea",
+        nullptr,
+        paramsObliqueStereo,
     },
 
     {EPSG_NAME_METHOD_ORTHOGRAPHIC, EPSG_CODE_METHOD_ORTHOGRAPHIC,
@@ -884,13 +887,16 @@ const struct MethodNameCode methodNameCodes[] = {
     // Projection methods
     METHOD_NAME_CODE(TRANSVERSE_MERCATOR),
     METHOD_NAME_CODE(TRANSVERSE_MERCATOR_SOUTH_ORIENTATED),
-    METHOD_NAME_CODE(LAMBERT_CONIC_CONFORMAL_1SP), METHOD_NAME_CODE(NZMG),
-    METHOD_NAME_CODE(TUNISIA_MAPPING_GRID), METHOD_NAME_CODE(ALBERS_EQUAL_AREA),
+    METHOD_NAME_CODE(LAMBERT_CONIC_CONFORMAL_1SP),
+    METHOD_NAME_CODE(NZMG),
+    METHOD_NAME_CODE(TUNISIA_MAPPING_GRID),
+    METHOD_NAME_CODE(ALBERS_EQUAL_AREA),
     METHOD_NAME_CODE(LAMBERT_CONIC_CONFORMAL_2SP),
     METHOD_NAME_CODE(LAMBERT_CONIC_CONFORMAL_2SP_BELGIUM),
     METHOD_NAME_CODE(LAMBERT_CONIC_CONFORMAL_2SP_MICHIGAN),
     METHOD_NAME_CODE(MODIFIED_AZIMUTHAL_EQUIDISTANT),
-    METHOD_NAME_CODE(GUAM_PROJECTION), METHOD_NAME_CODE(BONNE),
+    METHOD_NAME_CODE(GUAM_PROJECTION),
+    METHOD_NAME_CODE(BONNE),
     METHOD_NAME_CODE(LAMBERT_CYLINDRICAL_EQUAL_AREA_SPHERICAL),
     METHOD_NAME_CODE(LAMBERT_CYLINDRICAL_EQUAL_AREA),
     METHOD_NAME_CODE(CASSINI_SOLDNER),
@@ -898,16 +904,20 @@ const struct MethodNameCode methodNameCodes[] = {
     METHOD_NAME_CODE(EQUIDISTANT_CYLINDRICAL_SPHERICAL),
     METHOD_NAME_CODE(HOTINE_OBLIQUE_MERCATOR_VARIANT_A),
     METHOD_NAME_CODE(HOTINE_OBLIQUE_MERCATOR_VARIANT_B),
-    METHOD_NAME_CODE(KROVAK_NORTH_ORIENTED), METHOD_NAME_CODE(KROVAK),
+    METHOD_NAME_CODE(KROVAK_NORTH_ORIENTED),
+    METHOD_NAME_CODE(KROVAK),
     METHOD_NAME_CODE(LAMBERT_AZIMUTHAL_EQUAL_AREA),
     METHOD_NAME_CODE(POPULAR_VISUALISATION_PSEUDO_MERCATOR),
-    METHOD_NAME_CODE(MERCATOR_VARIANT_A), METHOD_NAME_CODE(MERCATOR_VARIANT_B),
+    METHOD_NAME_CODE(MERCATOR_VARIANT_A),
+    METHOD_NAME_CODE(MERCATOR_VARIANT_B),
     METHOD_NAME_CODE(OBLIQUE_STEREOGRAPHIC),
     METHOD_NAME_CODE(AMERICAN_POLYCONIC),
     METHOD_NAME_CODE(POLAR_STEREOGRAPHIC_VARIANT_A),
     METHOD_NAME_CODE(POLAR_STEREOGRAPHIC_VARIANT_B),
-    METHOD_NAME_CODE(EQUAL_EARTH), METHOD_NAME_CODE(LABORDE_OBLIQUE_MERCATOR),
-    METHOD_NAME_CODE(VERTICAL_PERSPECTIVE), METHOD_NAME_CODE(COLOMBIA_URBAN),
+    METHOD_NAME_CODE(EQUAL_EARTH),
+    METHOD_NAME_CODE(LABORDE_OBLIQUE_MERCATOR),
+    METHOD_NAME_CODE(VERTICAL_PERSPECTIVE),
+    METHOD_NAME_CODE(COLOMBIA_URBAN),
     // Other conversions
     METHOD_NAME_CODE(CHANGE_VERTICAL_UNIT),
     METHOD_NAME_CODE(HEIGHT_DEPTH_REVERSAL),
@@ -940,11 +950,15 @@ const struct MethodNameCode methodNameCodes[] = {
     METHOD_NAME_CODE(MOLODENSKY_BADEKAS_PV_GEOCENTRIC),
     METHOD_NAME_CODE(MOLODENSKY_BADEKAS_PV_GEOGRAPHIC_2D),
     METHOD_NAME_CODE(MOLODENSKY_BADEKAS_PV_GEOGRAPHIC_3D),
-    METHOD_NAME_CODE(MOLODENSKY), METHOD_NAME_CODE(ABRIDGED_MOLODENSKY),
+    METHOD_NAME_CODE(MOLODENSKY),
+    METHOD_NAME_CODE(ABRIDGED_MOLODENSKY),
     METHOD_NAME_CODE(GEOGRAPHIC2D_OFFSETS),
     METHOD_NAME_CODE(GEOGRAPHIC2D_WITH_HEIGHT_OFFSETS),
-    METHOD_NAME_CODE(GEOGRAPHIC3D_OFFSETS), METHOD_NAME_CODE(VERTICAL_OFFSET),
-    METHOD_NAME_CODE(NTV2), METHOD_NAME_CODE(NTV1), METHOD_NAME_CODE(NADCON),
+    METHOD_NAME_CODE(GEOGRAPHIC3D_OFFSETS),
+    METHOD_NAME_CODE(VERTICAL_OFFSET),
+    METHOD_NAME_CODE(NTV2),
+    METHOD_NAME_CODE(NTV1),
+    METHOD_NAME_CODE(NADCON),
     METHOD_NAME_CODE(VERTCON),
     METHOD_NAME_CODE(GEOCENTRIC_TRANSLATION_BY_GRID_INTERPOLATION_IGN),
 };
@@ -963,7 +977,8 @@ const struct ParamNameCode paramNameCodes[] = {
     PARAM_NAME_CODE(LATITUDE_OF_NATURAL_ORIGIN),
     PARAM_NAME_CODE(LONGITUDE_OF_NATURAL_ORIGIN),
     PARAM_NAME_CODE(SCALE_FACTOR_AT_NATURAL_ORIGIN),
-    PARAM_NAME_CODE(FALSE_EASTING), PARAM_NAME_CODE(FALSE_NORTHING),
+    PARAM_NAME_CODE(FALSE_EASTING),
+    PARAM_NAME_CODE(FALSE_NORTHING),
     PARAM_NAME_CODE(LATITUDE_PROJECTION_CENTRE),
     PARAM_NAME_CODE(LONGITUDE_PROJECTION_CENTRE),
     PARAM_NAME_CODE(AZIMUTH_INITIAL_LINE),
@@ -994,21 +1009,32 @@ const struct ParamNameCode paramNameCodes[] = {
     PARAM_NAME_CODE(VERTICAL_OFFSET_FILE),
     PARAM_NAME_CODE(LATITUDE_DIFFERENCE_FILE),
     PARAM_NAME_CODE(LONGITUDE_DIFFERENCE_FILE),
-    PARAM_NAME_CODE(UNIT_CONVERSION_SCALAR), PARAM_NAME_CODE(LATITUDE_OFFSET),
-    PARAM_NAME_CODE(LONGITUDE_OFFSET), PARAM_NAME_CODE(VERTICAL_OFFSET),
-    PARAM_NAME_CODE(GEOID_UNDULATION), PARAM_NAME_CODE(A0), PARAM_NAME_CODE(A1),
-    PARAM_NAME_CODE(A2), PARAM_NAME_CODE(B0), PARAM_NAME_CODE(B1),
-    PARAM_NAME_CODE(B2), PARAM_NAME_CODE(X_AXIS_TRANSLATION),
-    PARAM_NAME_CODE(Y_AXIS_TRANSLATION), PARAM_NAME_CODE(Z_AXIS_TRANSLATION),
-    PARAM_NAME_CODE(X_AXIS_ROTATION), PARAM_NAME_CODE(Y_AXIS_ROTATION),
-    PARAM_NAME_CODE(Z_AXIS_ROTATION), PARAM_NAME_CODE(SCALE_DIFFERENCE),
+    PARAM_NAME_CODE(UNIT_CONVERSION_SCALAR),
+    PARAM_NAME_CODE(LATITUDE_OFFSET),
+    PARAM_NAME_CODE(LONGITUDE_OFFSET),
+    PARAM_NAME_CODE(VERTICAL_OFFSET),
+    PARAM_NAME_CODE(GEOID_UNDULATION),
+    PARAM_NAME_CODE(A0),
+    PARAM_NAME_CODE(A1),
+    PARAM_NAME_CODE(A2),
+    PARAM_NAME_CODE(B0),
+    PARAM_NAME_CODE(B1),
+    PARAM_NAME_CODE(B2),
+    PARAM_NAME_CODE(X_AXIS_TRANSLATION),
+    PARAM_NAME_CODE(Y_AXIS_TRANSLATION),
+    PARAM_NAME_CODE(Z_AXIS_TRANSLATION),
+    PARAM_NAME_CODE(X_AXIS_ROTATION),
+    PARAM_NAME_CODE(Y_AXIS_ROTATION),
+    PARAM_NAME_CODE(Z_AXIS_ROTATION),
+    PARAM_NAME_CODE(SCALE_DIFFERENCE),
     PARAM_NAME_CODE(RATE_X_AXIS_TRANSLATION),
     PARAM_NAME_CODE(RATE_Y_AXIS_TRANSLATION),
     PARAM_NAME_CODE(RATE_Z_AXIS_TRANSLATION),
     PARAM_NAME_CODE(RATE_X_AXIS_ROTATION),
     PARAM_NAME_CODE(RATE_Y_AXIS_ROTATION),
     PARAM_NAME_CODE(RATE_Z_AXIS_ROTATION),
-    PARAM_NAME_CODE(RATE_SCALE_DIFFERENCE), PARAM_NAME_CODE(REFERENCE_EPOCH),
+    PARAM_NAME_CODE(RATE_SCALE_DIFFERENCE),
+    PARAM_NAME_CODE(REFERENCE_EPOCH),
     PARAM_NAME_CODE(TRANSFORMATION_REFERENCE_EPOCH),
     PARAM_NAME_CODE(ORDINATE_1_EVAL_POINT),
     PARAM_NAME_CODE(ORDINATE_2_EVAL_POINT),
diff --git a/src/iso19111/operation/singleoperation.cpp b/src/iso19111/operation/singleoperation.cpp
index b32b61cd..6812819c 100644
--- a/src/iso19111/operation/singleoperation.cpp
+++ b/src/iso19111/operation/singleoperation.cpp
@@ -103,10 +103,8 @@ GridDescription::GridDescription(const GridDescription &) = default;
 GridDescription::GridDescription(GridDescription &&other) noexcept
     : shortName(std::move(other.shortName)),
       fullName(std::move(other.fullName)),
-      packageName(std::move(other.packageName)),
-      url(std::move(other.url)),
-      directDownload(other.directDownload),
-      openLicense(other.openLicense),
+      packageName(std::move(other.packageName)), url(std::move(other.url)),
+      directDownload(other.directDownload), openLicense(other.openLicense),
       available(other.available) {}
 
 //! @endcond
@@ -1108,8 +1106,8 @@ SingleOperation::parameterValue(const std::string &paramName,
  * @param epsg_code the parameter EPSG code
  * @return the value, or nullptr if not found.
  */
-const ParameterValuePtr &SingleOperation::parameterValue(int epsg_code) const
-    noexcept {
+const ParameterValuePtr &
+SingleOperation::parameterValue(int epsg_code) const noexcept {
     for (const auto &genOpParamvalue : parameterValues()) {
         auto opParamvalue = dynamic_cast<const OperationParameterValue *>(
             genOpParamvalue.get());
@@ -1160,8 +1158,8 @@ SingleOperation::parameterValueMeasure(int epsg_code) const noexcept {
 
 //! @cond Doxygen_Suppress
 
-double SingleOperation::parameterValueNumericAsSI(int epsg_code) const
-    noexcept {
+double
+SingleOperation::parameterValueNumericAsSI(int epsg_code) const noexcept {
     const auto &val = parameterValue(epsg_code);
     if (val && val->type() == ParameterValue::Type::MEASURE) {
         return val->value().getSIValue();
@@ -1179,8 +1177,8 @@ double SingleOperation::parameterValueNumeric(
 }
 
 double SingleOperation::parameterValueNumeric(
-    const char *param_name, const common::UnitOfMeasure &targetUnit) const
-    noexcept {
+    const char *param_name,
+    const common::UnitOfMeasure &targetUnit) const noexcept {
     const auto &val = parameterValue(param_name, 0);
     if (val && val->type() == ParameterValue::Type::MEASURE) {
         return val->value().convertToUnit(targetUnit);
diff --git a/src/iso19111/operation/transformation.cpp b/src/iso19111/operation/transformation.cpp
index 932b9e4e..984f2756 100644
--- a/src/iso19111/operation/transformation.cpp
+++ b/src/iso19111/operation/transformation.cpp
@@ -268,23 +268,20 @@ Transformation::getTOWGS84Parameters() const // throw(io::FormattingException)
                     } else if (epsg_code ==
                                EPSG_CODE_PARAMETER_X_AXIS_ROTATION) {
                         params[3] = fixNegativeZero(
-                            rotSign *
-                            measure.convertToUnit(
-                                common::UnitOfMeasure::ARC_SECOND));
+                            rotSign * measure.convertToUnit(
+                                          common::UnitOfMeasure::ARC_SECOND));
                         foundRotX = true;
                     } else if (epsg_code ==
                                EPSG_CODE_PARAMETER_Y_AXIS_ROTATION) {
                         params[4] = fixNegativeZero(
-                            rotSign *
-                            measure.convertToUnit(
-                                common::UnitOfMeasure::ARC_SECOND));
+                            rotSign * measure.convertToUnit(
+                                          common::UnitOfMeasure::ARC_SECOND));
                         foundRotY = true;
                     } else if (epsg_code ==
                                EPSG_CODE_PARAMETER_Z_AXIS_ROTATION) {
                         params[5] = fixNegativeZero(
-                            rotSign *
-                            measure.convertToUnit(
-                                common::UnitOfMeasure::ARC_SECOND));
+                            rotSign * measure.convertToUnit(
+                                          common::UnitOfMeasure::ARC_SECOND));
                         foundRotZ = true;
                     } else if (epsg_code ==
                                EPSG_CODE_PARAMETER_SCALE_DIFFERENCE) {
@@ -2178,14 +2175,13 @@ TransformationNNPtr Transformation::substitutePROJAlternativeGridNames(
         }
     }
     const auto &horizontalGridName =
-        !NTv1Filename.empty() ? NTv1Filename : !NTv2Filename.empty()
-                                                   ? NTv2Filename
-                                                   : lasFilename;
+        !NTv1Filename.empty()
+            ? NTv1Filename
+            : !NTv2Filename.empty() ? NTv2Filename : lasFilename;
 
-    if (!horizontalGridName.empty() &&
-        databaseContext->lookForGridAlternative(horizontalGridName,
-                                                projFilename, projGridFormat,
-                                                inverseDirection)) {
+    if (!horizontalGridName.empty() && databaseContext->lookForGridAlternative(
+                                           horizontalGridName, projFilename,
+                                           projGridFormat, inverseDirection)) {
 
         if (horizontalGridName == projFilename) {
             if (inverseDirection) {
@@ -2296,13 +2292,14 @@ TransformationNNPtr Transformation::substitutePROJAlternativeGridNames(
                         EPSG_CODE_PARAMETER_GEOID_CORRECTION_FILENAME)};
 #ifdef disabled_for_now
                 if (inverseDirection) {
-                    return create(createPropertiesForInverse(
-                                      self.as_nullable().get(), true, false),
-                                  targetCRS(), sourceCRS(), nullptr,
-                                  createSimilarPropertiesMethod(method()),
-                                  parameters, {ParameterValue::createFilename(
-                                                  projFilename)},
-                                  coordinateOperationAccuracies())
+                    return create(
+                               createPropertiesForInverse(
+                                   self.as_nullable().get(), true, false),
+                               targetCRS(), sourceCRS(), nullptr,
+                               createSimilarPropertiesMethod(method()),
+                               parameters,
+                               {ParameterValue::createFilename(projFilename)},
+                               coordinateOperationAccuracies())
                         ->inverseAsTransformation();
                 } else
 #endif
@@ -2373,13 +2370,14 @@ TransformationNNPtr Transformation::substitutePROJAlternativeGridNames(
                     createOpParamNameEPSGCode(
                         EPSG_CODE_PARAMETER_VERTICAL_OFFSET_FILE)};
                 if (inverseDirection) {
-                    return create(createPropertiesForInverse(
-                                      self.as_nullable().get(), true, false),
-                                  targetCRS(), sourceCRS(), nullptr,
-                                  createSimilarPropertiesMethod(method()),
-                                  parameters, {ParameterValue::createFilename(
-                                                  projFilename)},
-                                  coordinateOperationAccuracies())
+                    return create(
+                               createPropertiesForInverse(
+                                   self.as_nullable().get(), true, false),
+                               targetCRS(), sourceCRS(), nullptr,
+                               createSimilarPropertiesMethod(method()),
+                               parameters,
+                               {ParameterValue::createFilename(projFilename)},
+                               coordinateOperationAccuracies())
                         ->inverseAsTransformation();
                 } else {
                     return create(
@@ -2985,9 +2983,9 @@ void Transformation::_exportToPROJString(
     const auto &hGridShiftFilename =
         !HorizontalShiftGTIFFFilename.empty()
             ? HorizontalShiftGTIFFFilename
-            : !NTv1Filename.empty() ? NTv1Filename : !NTv2Filename.empty()
-                                                         ? NTv2Filename
-                                                         : CTABLE2Filename;
+            : !NTv1Filename.empty()
+                  ? NTv1Filename
+                  : !NTv2Filename.empty() ? NTv2Filename : CTABLE2Filename;
     if (!hGridShiftFilename.empty()) {
         auto sourceCRSGeog =
             extractGeographicCRSIfGeographicCRSOrEquivalent(sourceCRS());
@@ -3282,5 +3280,5 @@ void Transformation::_exportToPROJString(
     throw io::FormattingException("Unimplemented");
 }
 
-} // namespace crs
+} // namespace operation
 NS_PROJ_END