Merge branch 'hotfix/1.29.1'

Author: pmaciel

VERSION

@@ -1 +1 @@
-1.29.0
+1.29.1

src/eckit/geo/CMakeLists.txt

@@ -109,10 +109,6 @@ list(APPEND eckit_geo_srcs
     iterator/Unstructured.h
     order/HEALPix.cc
     order/HEALPix.h
-    order/ReducedScan.cc
-    order/ReducedScan.h
-    order/RegularScan.cc
-    order/RegularScan.h
     order/Scan.cc
     order/Scan.h
     polygon/Polygon.cc

src/eckit/geo/Exceptions.cc

@@ -21,8 +21,8 @@ AreaError::AreaError(const std::string& what, const CodeLocation& loc) : Excepti
 };
 
 
-ReorderError::ReorderError(const std::string& what, const CodeLocation& loc) {
-    reason("ReorderError: [" + what + "], in " + loc.asString());
+OrderError::OrderError(const std::string& what, const CodeLocation& loc) {
+    reason("OrderError: [" + what + "], in " + loc.asString());
 }
 
 

src/eckit/geo/Exceptions.h

@@ -38,10 +38,10 @@ class AreaError : public geo::Exception {
 };
 
 
-class ReorderError : public geo::Exception {
+class OrderError : public geo::Exception {
 public:
 
-    explicit ReorderError(const std::string&, const CodeLocation&);
+    explicit OrderError(const std::string&, const CodeLocation&);
 };
 
 

src/eckit/geo/Grid.cc

@@ -124,17 +124,17 @@ std::pair<std::vector<double>, std::vector<double> > Grid::to_latlons() const {
 }
 
 
-Grid::order_type Grid::order() const {
+const Grid::order_type& Grid::order() const {
     NOTIMP;
 }
 
 
-Reordering Grid::reorder(order_type) const {
+Reordering Grid::reorder(const order_type&) const {
     NOTIMP;
 }
 
 
-Grid* Grid::make_grid_reordered(order_type) const {
+Grid* Grid::make_grid_reordered(const order_type&) const {
     NOTIMP;
 }
 

src/eckit/geo/Grid.h

@@ -159,8 +159,8 @@ class Grid {
     [[nodiscard]] virtual std::vector<Point> to_points() const;
     [[nodiscard]] virtual std::pair<std::vector<double>, std::vector<double>> to_latlons() const;
 
-    virtual order_type order() const;
-    virtual Reordering reorder(order_type) const;
+    virtual const order_type& order() const;
+    virtual Reordering reorder(const order_type&) const;
 
     virtual const Area& area() const;
     virtual Reordering crop(const Area&) const;
@@ -170,7 +170,7 @@ class Grid {
     virtual const area::BoundingBox& boundingBox() const;
     [[nodiscard]] virtual area::BoundingBox* calculate_bbox() const;
 
-    [[nodiscard]] virtual Grid* make_grid_reordered(order_type) const;
+    [[nodiscard]] virtual Grid* make_grid_reordered(const order_type&) const;
     [[nodiscard]] virtual Grid* make_grid_cropped(const Area&) const;
 
     // -- Class methods

src/eckit/geo/Order.cc

@@ -20,6 +20,7 @@
 #include "eckit/geo/Spec.h"
 #include "eckit/geo/spec/Layered.h"
 #include "eckit/geo/util/mutex.h"
+#include "eckit/parser/YAMLParser.h"
 
 
 namespace eckit::geo {
@@ -36,26 +37,34 @@ class lock_type {
 };
 
 
-std::map<std::string, size_t> ORDERING_INDEX;
-std::map<size_t, std::string> ORDERING_NAME;
+std::map<std::string, size_t> ORDER_INDEX;
+std::map<size_t, std::string> ORDER_NAME;
 
 
 }  // namespace
 
 
-std::string Order::className() {
-    static const std::string ordering = "ordering";
-    return ordering;
+const Spec& Order::spec() const {
+    if (!spec_) {
+        spec_ = std::make_shared<spec::Custom>();
+        ASSERT(spec_);
+
+        auto& custom = *spec_;
+        fill_spec(custom);
+    }
+
+    return *spec_;
 }
 
 
-Order::value_type Order::make_ordering_from_spec(const Spec&) {
-    NOTIMP;
+std::string Order::className() {
+    static const std::string order = "order";
+    return order;
+}
+
 
-    // int key = (spec.get_bool("scan_i_plus", true) ? 0 : 1) + (spec.get_bool("scan_j_plus", false) ? 1 << 1 : 0) +
-    //           (spec.get_bool("scan_ij", true) ? 0 : 1 << 2) + (spec.get_bool("scan_alternating", false) ? 1 << 3 :
-    //           0);
-    // return static_cast<value_type>(key);
+Order::value_type Order::make_order_from_spec(const Spec& spec) {
+    return std::unique_ptr<const Order>(OrderFactory::build(spec))->order();
 }
 
 
@@ -66,69 +75,59 @@ Reordering Order::no_reorder(size_t size) {
 }
 
 
-void Order::fill_spec(spec::Custom& custom) const {
-    if (order() != order_default()) {
-        custom.set("type", type());
-        custom.set("order", order());
-    }
-}
-
-
 void Order::register_ordering(const std::string& name) {
     lock_type lock;
 
-    auto index = ORDERING_INDEX.size();
-
-    ASSERT(ORDERING_INDEX.emplace(name, index).second);
-    ASSERT(ORDERING_NAME.emplace(index, name).second);
+    auto index = ORDER_INDEX.size();
+    ASSERT(ORDER_INDEX.try_emplace(name, index).second == ORDER_NAME.try_emplace(index, name).second);
 }
 
 
-const Order* ReorderFactory::make_from_string(const std::string&) {
-    // FIXME
-    NOTIMP;
+const Order* OrderFactory::make_from_string(const std::string& str) {
+    std::unique_ptr<Spec> spec(spec::Custom::make_from_value(YAMLParser::decodeString(str)));
+    return instance().make_from_spec_(*spec);
 }
 
 
-ReorderFactory& ReorderFactory::instance() {
-    static ReorderFactory obj;
+OrderFactory& OrderFactory::instance() {
+    static OrderFactory obj;
     return obj;
 }
 
 
-const Order* ReorderFactory::make_from_spec_(const Spec& spec) const {
+const Order* OrderFactory::make_from_spec_(const Spec& spec) const {
     lock_type lock;
 
     std::unique_ptr<Spec> cfg(make_spec_(spec));
 
     if (std::string type; cfg->get("type", type)) {
-        return ReorderFactoryType::instance().get(type).create(*cfg);
+        return OrderFactoryType::instance().get(type).create(*cfg);
     }
 
-    list(Log::error() << "Reorder: cannot build ordering without 'type', choices are: ");
-    throw exception::SpecError("Reorder: cannot build ordering without 'type'", Here());
+    list(Log::error() << "Order: cannot build order without 'type', choices are: ");
+    throw exception::SpecError("Order: cannot build order without 'type'", Here());
 }
 
 
-Spec* ReorderFactory::make_spec_(const Spec& spec) const {
+Spec* OrderFactory::make_spec_(const Spec& spec) const {
     lock_type lock;
 
     auto* cfg = new spec::Layered(spec);
     ASSERT(cfg != nullptr);
 
 
-    // hardcoded, interpreted options (contributing to orderingspec)
+    // hardcoded, interpreted options (contributing to orderspec)
 
-    // cfg->push_back(new spec::Custom{{"type", ""}});
+    cfg->push_back(new spec::Custom{{"type", "scan"}});
 
     return cfg;
 }
 
 
-std::ostream& ReorderFactory::list_(std::ostream& out) const {
+std::ostream& OrderFactory::list_(std::ostream& out) const {
     lock_type lock;
 
-    out << ReorderFactoryType::instance() << std::endl;
+    out << OrderFactoryType::instance() << std::endl;
 
     return out;
 }

src/eckit/geo/Order.h

@@ -14,14 +14,19 @@
 
 #include <memory>
 #include <string>
-#include <type_traits>
 
 #include "eckit/geo/spec/Custom.h"
 #include "eckit/geo/spec/Generator.h"
 #include "eckit/memory/Builder.h"
 #include "eckit/memory/Factory.h"
 
 
+namespace eckit::geo::grid {
+class Regular;
+class Reduced;
+}  // namespace eckit::geo::grid
+
+
 namespace eckit::geo {
 
 
@@ -39,13 +44,6 @@ class Order {
 
     // -- Constructors
 
-    template <typename... Args>
-    explicit Order(Args&&... args) {
-        static_assert((std::is_convertible_v<Args, value_type> && ...),
-                      "Reorder: arguments must be convertible to value_type");
-        (register_ordering(std::forward<Args>(args)), ...);
-    }
-
     Order() noexcept    = default;
     Order(const Order&) = default;
     Order(Order&&)      = default;
@@ -61,19 +59,27 @@ class Order {
 
     // -- Methods
 
+    [[nodiscard]] const Spec& spec() const;
+    std::string spec_str() const { return spec().str(); }
+
     virtual const std::string& type() const = 0;
 
-    virtual const value_type& order_default() const        = 0;
     virtual const value_type& order() const                = 0;
     virtual Reordering reorder(const value_type& to) const = 0;
 
     // -- Class methods
 
     static std::string className();
 
-    [[nodiscard]] static value_type make_ordering_from_spec(const Spec&);
+    [[nodiscard]] static value_type make_order_from_spec(const Spec&);
     [[nodiscard]] static Reordering no_reorder(size_t);
 
+protected:
+
+    // -- Class methods
+
+    static void register_ordering(const std::string&);
+
 private:
 
     // -- Members
@@ -82,19 +88,23 @@ class Order {
 
     // -- Methods
 
-    void fill_spec(spec::Custom&) const;
+    virtual void fill_spec(spec::Custom&) const = 0;
 
-    void register_ordering(const std::string&);
+    // -- Friends
+
+    friend class grid::Reduced;
+    friend class grid::Regular;
 };
 
 
-using ReorderFactoryType = Factory<Order>;
+using OrderFactoryType = Factory<Order>;
+
 
 template <typename T>
-using ReorderRegisterType = ConcreteBuilderT1<Order, T>;
+using OrderRegisterType = ConcreteBuilderT1<Order, T>;
 
 
-struct ReorderFactory {
+struct OrderFactory {
     [[nodiscard]] static const Order* build(const Spec& spec) { return instance().make_from_spec_(spec); }
 
     [[nodiscard]] static const Order* make_from_string(const std::string&);
@@ -104,7 +114,7 @@ struct ReorderFactory {
 
 private:
 
-    static ReorderFactory& instance();
+    static OrderFactory& instance();
 
     [[nodiscard]] const Order* make_from_spec_(const Spec&) const;
     [[nodiscard]] Spec* make_spec_(const Spec&) const;

src/eckit/geo/area/library/Shapefile.h

@@ -48,7 +48,7 @@ class Shapefile : public Library {
 
     // -- Destructor
 
-    ~Shapefile();
+    ~Shapefile() override;
 
     // -- Operators