Remove json from mongo expression header (PDAL#4725)

* Remove private functions from stac reader header.

* Move interface functions out of EsriReader.

* Make writeHierarchy a non-member.

* Add missed file.

* Move functions/data to Private.

* Remove handleReaderArgs() and setReaderOptions() from header.

* Move JSON functions to cpp file.

Author: abellgithub

filters/MongoExpressionFilter.cpp

@@ -50,31 +50,42 @@ static const StaticPluginInfo s_info
 
 CREATE_STATIC_STAGE(MongoExpressionFilter, s_info);
 
+struct MongoExpressionFilter::Args
+{
+    NL::json m_json;
+};
+
+struct MongoExpressionFilter::Private
+{
+    Expression m_expression;
+};
+
 std::string MongoExpressionFilter::getName() const
 {
     return s_info.name;
 }
 
-MongoExpressionFilter::MongoExpressionFilter()
+MongoExpressionFilter::MongoExpressionFilter() :
+    m_args(new Args()),
+    m_p(new Private())
 {}
 
 MongoExpressionFilter::~MongoExpressionFilter()
 {}
 
 void MongoExpressionFilter::addArgs(ProgramArgs& args)
 {
-    args.add("expression", "Logical query expression", m_json).setPositional();
+    args.add("expression", "Logical query expression", m_args->m_json).setPositional();
 }
 
 void MongoExpressionFilter::prepared(PointTableRef table)
 {
-    log()->get(LogLevel::Debug) << "Building expression from: " << m_json <<
+    log()->get(LogLevel::Debug) << "Building expression from: " << m_args->m_json <<
         std::endl;
 
-    m_expression = makeUnique<Expression>(*table.layout(), m_json);
+    m_p->m_expression = Expression(table.layout(), m_args->m_json);
 
-    log()->get(LogLevel::Debug) << "Built expression: " << *m_expression <<
-        std::endl;
+    log()->get(LogLevel::Debug) << "Built expression: " << m_p->m_expression << std::endl;
 }
 
 PointViewSet MongoExpressionFilter::run(PointViewPtr inView)
@@ -97,7 +108,7 @@ PointViewSet MongoExpressionFilter::run(PointViewPtr inView)
 
 bool MongoExpressionFilter::processOne(PointRef& pr)
 {
-    return m_expression->check(pr);
+    return m_p->m_expression.check(pr);
 }
 
 } // namespace pdal

filters/MongoExpressionFilter.hpp

@@ -35,7 +35,6 @@
 #pragma once
 
 #include <pdal/Filter.hpp>
-#include <pdal/JsonFwd.hpp>
 #include <pdal/Streamable.hpp>
 
 namespace pdal
@@ -57,8 +56,11 @@ class PDAL_EXPORT MongoExpressionFilter : public Filter, public Streamable
     virtual void prepared(PointTableRef table) override;
     virtual PointViewSet run(PointViewPtr view) override;
 
-    NL::json m_json;
-    std::unique_ptr<Expression> m_expression;
+    struct Args;
+    std::unique_ptr<Args> m_args;
+
+    struct Private;
+    std::unique_ptr<Private> m_p;
 };
 
 } // namespace pdal

filters/private/mongoexpression/Comparison.cpp

@@ -72,17 +72,17 @@ std::unique_ptr<Comparison> Comparison::create(const PointLayout& layout,
         switch (co)
         {
         case ComparisonType::eq:
-            return makeUnique<ComparisonEqual>(dimId, op);
+            return std::make_unique<ComparisonEqual>(dimId, op);
         case ComparisonType::gt:
-            return makeUnique<ComparisonGreater>(dimId, op);
+            return std::make_unique<ComparisonGreater>(dimId, op);
         case ComparisonType::gte:
-            return makeUnique<ComparisonGreaterEqual>(dimId, op);
+            return std::make_unique<ComparisonGreaterEqual>(dimId, op);
         case ComparisonType::lt:
-            return makeUnique<ComparisonLess>(dimId, op);
+            return std::make_unique<ComparisonLess>(dimId, op);
         case ComparisonType::lte:
-            return makeUnique<ComparisonLessEqual>(dimId, op);
+            return std::make_unique<ComparisonLessEqual>(dimId, op);
         case ComparisonType::ne:
-            return makeUnique<ComparisonNotEqual>(dimId, op);
+            return std::make_unique<ComparisonNotEqual>(dimId, op);
         default:
             throw pdal_error("Invalid single comparison operator");
         }
@@ -100,9 +100,9 @@ std::unique_ptr<Comparison> Comparison::create(const PointLayout& layout,
         switch (co)
         {
         case ComparisonType::in:
-            return makeUnique<ComparisonAny>(dimId, ops);
+            return std::make_unique<ComparisonAny>(dimId, ops);
         case ComparisonType::nin:
-            return makeUnique<ComparisonNone>(dimId, ops);
+            return std::make_unique<ComparisonNone>(dimId, ops);
         default:
             throw pdal_error("Invalid multi comparison operator");
         }

filters/private/mongoexpression/Expression.cpp

@@ -80,7 +80,7 @@ void Expression::build(LogicGate& gate, const NL::json& json)
         else if (!val.is_object() || val.size() == 1)
         {
             // A comparison object.
-            active->push(Comparison::create(m_layout, key, val));
+            active->push(Comparison::create(*m_layout, key, val));
         }
         else
         {
@@ -96,7 +96,7 @@ void Expression::build(LogicGate& gate, const NL::json& json)
             {
                 NL::json nest;
                 nest[inner.key()] = inner.value();
-                active->push(Comparison::create(m_layout, key, nest));
+                active->push(Comparison::create(*m_layout, key, nest));
             }
         }
     }

filters/private/mongoexpression/Expression.hpp

@@ -43,7 +43,10 @@ namespace pdal
 class Expression
 {
 public:
-    Expression(const PointLayout& layout, const NL::json& json)
+    Expression() : m_layout(nullptr)
+    {}
+
+    Expression(const PointLayout *layout, const NL::json& json)
         : m_layout(layout)
     {
         build(m_root, json);
@@ -62,7 +65,7 @@ class Expression
 private:
     void build(LogicGate& gate, const NL::json& json);
 
-    const PointLayout& m_layout;
+    const PointLayout *m_layout;
     LogicalAnd m_root;
 };
 

filters/private/mongoexpression/LogicGate.cpp

@@ -39,10 +39,10 @@ namespace pdal
 
 std::unique_ptr<LogicGate> LogicGate::create(const LogicalOperator type)
 {
-    if (type == LogicalOperator::lAnd) return makeUnique<LogicalAnd>();
-    if (type == LogicalOperator::lNot) return makeUnique<LogicalNot>();
-    if (type == LogicalOperator::lOr) return makeUnique<LogicalOr>();
-    if (type == LogicalOperator::lNor) return makeUnique<LogicalNor>();
+    if (type == LogicalOperator::lAnd) return std::make_unique<LogicalAnd>();
+    if (type == LogicalOperator::lNot) return std::make_unique<LogicalNot>();
+    if (type == LogicalOperator::lOr) return std::make_unique<LogicalOr>();
+    if (type == LogicalOperator::lNor) return std::make_unique<LogicalNor>();
     throw pdal_error("Invalid logic gate type");
 }
 

filters/private/mongoexpression/LogicGate.hpp

@@ -76,7 +76,10 @@ inline std::string opToString(LogicalOperator o)
 class LogicGate : public Filterable
 {
 public:
-    virtual ~LogicGate() { }
+    LogicGate() = default;
+    LogicGate(LogicGate&&) = default;
+    LogicGate& operator=(LogicGate&&) = default;
+    virtual ~LogicGate() = default;
 
     static std::unique_ptr<LogicGate> create(std::string s)
     {

filters/private/mongoexpression/Support.hpp

@@ -62,11 +62,5 @@ class Comparable : public Loggable
     virtual bool operator()(double v) const = 0;
 };
 
-template<typename T, typename... Args>
-std::unique_ptr<T> makeUnique(Args&&... args)
-{
-    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-}
-
 } // namespace pdal