N-API mapnik.Map.queryPoint mapnik.Map.queryMapPoint (WIP) [skip ci]

Author: artemp

src/mapnik_featureset.hpp

@@ -4,10 +4,12 @@
 #include <napi.h>
 
 using featureset_ptr =  mapnik::featureset_ptr;
+namespace detail { struct AsyncQueryPoint;}
 
 class Featureset : public Napi::ObjectWrap<Featureset>
 {
     friend class Datasource;
+    friend struct detail::AsyncQueryPoint;
 public:
     // initialiser
     static Napi::Object Initialize(Napi::Env env, Napi::Object exports);

src/mapnik_map.hpp

@@ -80,7 +80,7 @@ class Map : public Napi::ObjectWrap<Map>
 private:
     inline bool acquire() {return not_in_use_.fetch_and(0);}
     inline void release() {not_in_use_ = 1;}
-
+    Napi::Value query_point_impl(Napi::CallbackInfo const& info, bool geo_coords);
     static Napi::FunctionReference constructor;
     map_ptr map_;
     std::atomic<int> not_in_use_{1};

src/mapnik_map_query_point.cpp

@@ -1,19 +1,102 @@
 #include "mapnik_map.hpp"
+#include "mapnik_featureset.hpp"
+#include <mapnik/map.hpp>
+#include <mapnik/layer.hpp>
+
+namespace detail {
+
+struct AsyncQueryPoint : Napi::AsyncWorker
+{
+    using Base = Napi::AsyncWorker;
+    AsyncQueryPoint(map_ptr const& map, double x, double y, int layer_idx, bool geo_coords, Napi::Function const& callback)
+        : Base(callback),
+          map_(map),
+          x_(x),
+          y_(y),
+          layer_idx_(layer_idx),
+          geo_coords_(geo_coords) {}
+
+    void Execute() override
+    {
+        try
+        {
+            std::vector<mapnik::layer> const& layers = map_->layers();
+            if (layer_idx_ >= 0)
+            {
+                mapnik::featureset_ptr fs;
+                if (geo_coords_)
+                {
+                    fs = map_->query_point(layer_idx_, x_, y_);
+                }
+                else
+                {
+                    fs = map_->query_map_point(layer_idx_, x_, y_);
+                }
+                mapnik::layer const& lyr = layers[layer_idx_];
+                featuresets_.insert(std::make_pair(lyr.name(),fs));
+            }
+            else
+            {
+                // query all layers
+                unsigned idx = 0;
+                for (mapnik::layer const& lyr : layers)
+                {
+                    mapnik::featureset_ptr fs;
+                    if (geo_coords_)
+                    {
+                        fs = map_->query_point(idx, x_, y_);
+                    }
+                    else
+                    {
+                        fs = map_->query_map_point(idx, x_, y_);
+                    }
+                    featuresets_.insert(std::make_pair(lyr.name(),fs));
+                    ++idx;
+                }
+            }
+        }
+        catch (std::exception const& ex)
+        {
+            SetError(ex.what());
+        }
+    }
+
+    std::vector<napi_value> GetResult(Napi::Env env) override
+    {
+        std::size_t num_result = featuresets_.size();
+        if (num_result >= 1)
+        {
+            Napi::Array arr = Napi::Array::New(env, num_result);
+            typedef std::map<std::string,mapnik::featureset_ptr> fs_itr;
+            fs_itr::iterator it = featuresets_.begin();
+            fs_itr::iterator end = featuresets_.end();
+            unsigned idx = 0;
+            for (; it != end; ++it)
+            {
+                Napi::Object obj = Napi::Object::New(env);
+                obj.Set("layer", Napi::String::New(env, it->first));
+                Napi::Value arg = Napi::External<mapnik::featureset_ptr>::New(env, &it->second);
+                obj.Set("featureset", Featureset::constructor.New({arg}));
+                arr.Set(idx, obj);
+                ++idx;
+            }
+            featuresets_.clear();
+            return { env.Undefined(), arr };
+        }
+        return Base::GetResult(env);
+    }
+
+private:
+    map_ptr map_;
+    double x_;
+    double y_;
+    int layer_idx_;
+    bool geo_coords_;
+    std::map<std::string, mapnik::featureset_ptr> featuresets_;
+};
+
+}
 
-/*
-typedef struct {
-    uv_work_t request;
-    Map *m;
-    std::map<std::string,mapnik::featureset_ptr> featuresets;
-    int layer_idx;
-    bool geo_coords;
-    double x;
-    double y;
-    bool error;
-    std::string error_name;
-    Napi::FunctionReference cb;
-} query_map_baton_t;
-*/
 
 /**
  * Query a `Mapnik#Map` object to retrieve layer and feature data based on an
@@ -48,8 +131,7 @@ typedef struct {
 
 Napi::Value Map::queryMapPoint(Napi::CallbackInfo const& info)
 {
-    //abstractQueryPoint(info,false);
-    return info.Env().Undefined();
+    return query_point_impl(info,false);
 }
 
 /**
@@ -85,25 +167,25 @@ Napi::Value Map::queryMapPoint(Napi::CallbackInfo const& info)
 
 Napi::Value Map::queryPoint(Napi::CallbackInfo const& info)
 {
-    //abstractQueryPoint(info,true);
-    return info.Env().Undefined();
+    return query_point_impl(info, true);
 }
-/*
-Napi::Value Map::abstractQueryPoint(Napi::CallbackInfo const& info, bool geo_coords)
+
+Napi::Value Map::query_point_impl(Napi::CallbackInfo const& info, bool geo_coords)
 {
+    Napi::Env env = info.Env();
     Napi::HandleScope scope(env);
     if (info.Length() < 3)
     {
-        Napi::Error::New(env, "requires at least three arguments, a x,y query and a callback").ThrowAsJavaScriptException();
-
+        Napi::Error::New(env, "requires at least three arguments, a x,y query and a callback")
+            .ThrowAsJavaScriptException();
         return env.Undefined();
     }
 
-    double x,y;
+    double x;
+    double y;
     if (!info[0].IsNumber() || !info[1].IsNumber())
     {
         Napi::TypeError::New(env, "x,y arguments must be numbers").ThrowAsJavaScriptException();
-
         return env.Undefined();
     }
     else
@@ -112,36 +194,34 @@ Napi::Value Map::abstractQueryPoint(Napi::CallbackInfo const& info, bool geo_coo
         y = info[1].As<Napi::Number>().DoubleValue();
     }
 
-    Map* m = info.Holder().Unwrap<Map>();
-
     Napi::Object options = Napi::Object::New(env);
     int layer_idx = -1;
 
     if (info.Length() > 3)
     {
         // options object
-        if (!info[2].IsObject()) {
+        if (!info[2].IsObject())
+        {
             Napi::TypeError::New(env, "optional third argument must be an options object").ThrowAsJavaScriptException();
-
             return env.Undefined();
         }
 
-        options = info[2].ToObject(Napi::GetCurrentContext());
-
-        if ((options).Has(Napi::String::New(env, "layer")).FromMaybe(false))
+        options = info[2].As<Napi::Object>();
+        if (options.Has("layer"))
         {
-            std::vector<mapnik::layer> const& layers = m->map_->layers();
-            Napi::Value layer_id = (options).Get(Napi::String::New(env, "layer"));
-            if (! (layer_id.IsString() || layer_id.IsNumber()) ) {
+            std::vector<mapnik::layer> const& layers = map_->layers();
+            Napi::Value layer_id = options.Get("layer");
+            if (!(layer_id.IsString() || layer_id.IsNumber()) )
+            {
                 Napi::TypeError::New(env, "'layer' option required for map query and must be either a layer name(string) or layer index (integer)").ThrowAsJavaScriptException();
-
                 return env.Undefined();
             }
 
-            if (layer_id.IsString()) {
+            if (layer_id.IsString())
+            {
                 bool found = false;
                 unsigned int idx(0);
-                std::string layer_name = TOSTR(layer_id);
+                std::string layer_name = layer_id.As<Napi::String>();
                 for (mapnik::layer const& lyr : layers)
                 {
                     if (lyr.name() == layer_name)
@@ -157,7 +237,6 @@ Napi::Value Map::abstractQueryPoint(Napi::CallbackInfo const& info, bool geo_coo
                     std::ostringstream s;
                     s << "Layer name '" << layer_name << "' not found";
                     Napi::TypeError::New(env, s.str().c_str()).ThrowAsJavaScriptException();
-
                     return env.Undefined();
                 }
             }
@@ -178,10 +257,11 @@ Napi::Value Map::abstractQueryPoint(Napi::CallbackInfo const& info, bool geo_coo
                     {
                         s << "no layers found in map";
                     }
-                    Napi::TypeError::New(env, s.str().c_str()).ThrowAsJavaScriptException();
-
+                    Napi::TypeError::New(env, s.str()).ThrowAsJavaScriptException();
                     return env.Undefined();
-                } else if (layer_idx >= static_cast<int>(layer_num)) {
+                }
+                else if (layer_idx >= static_cast<int>(layer_num))
+                {
                     std::ostringstream s;
                     s << "Zero-based layer index '" << layer_idx << "' not valid, ";
                     if (layer_num > 0)
@@ -192,130 +272,20 @@ Napi::Value Map::abstractQueryPoint(Napi::CallbackInfo const& info, bool geo_coo
                     {
                         s << "no layers found in map";
                     }
-                    Napi::TypeError::New(env, s.str().c_str()).ThrowAsJavaScriptException();
-
+                    Napi::TypeError::New(env, s.str()).ThrowAsJavaScriptException();
                     return env.Undefined();
                 }
             }
         }
     }
-
     // ensure function callback
     Napi::Value callback = info[info.Length() - 1];
-    if (!callback->IsFunction()) {
+    if (!callback.IsFunction())
+    {
         Napi::TypeError::New(env, "last argument must be a callback function").ThrowAsJavaScriptException();
-
         return env.Undefined();
     }
-
-    query_map_baton_t *closure = new query_map_baton_t();
-    closure->request.data = closure;
-    closure->m = m;
-    closure->x = x;
-    closure->y = y;
-    closure->layer_idx = static_cast<std::size_t>(layer_idx);
-    closure->geo_coords = geo_coords;
-    closure->error = false;
-    closure->cb.Reset(callback.As<Napi::Function>());
-    uv_queue_work(uv_default_loop(), &closure->request, EIO_QueryMap, (uv_after_work_cb)EIO_AfterQueryMap);
-    m->Ref();
+    auto * worker = new detail::AsyncQueryPoint(map_, x, y, layer_idx, geo_coords, callback.As<Napi::Function>());
+    worker->Queue();
     return env.Undefined();
 }
-
-void Map::EIO_QueryMap(uv_work_t* req)
-{
-    query_map_baton_t *closure = static_cast<query_map_baton_t *>(req->data);
-
-    try
-    {
-        std::vector<mapnik::layer> const& layers = closure->m->map_->layers();
-        if (closure->layer_idx >= 0)
-        {
-            mapnik::featureset_ptr fs;
-            if (closure->geo_coords)
-            {
-                fs = closure->m->map_->query_point(closure->layer_idx,
-                                                   closure->x,
-                                                   closure->y);
-            }
-            else
-            {
-                fs = closure->m->map_->query_map_point(closure->layer_idx,
-                                                       closure->x,
-                                                       closure->y);
-            }
-            mapnik::layer const& lyr = layers[closure->layer_idx];
-            closure->featuresets.insert(std::make_pair(lyr.name(),fs));
-        }
-        else
-        {
-            // query all layers
-            unsigned idx = 0;
-            for (mapnik::layer const& lyr : layers)
-            {
-                mapnik::featureset_ptr fs;
-                if (closure->geo_coords)
-                {
-                    fs = closure->m->map_->query_point(idx,
-                                                       closure->x,
-                                                       closure->y);
-                }
-                else
-                {
-                    fs = closure->m->map_->query_map_point(idx,
-                                                           closure->x,
-                                                           closure->y);
-                }
-                closure->featuresets.insert(std::make_pair(lyr.name(),fs));
-                ++idx;
-            }
-        }
-    }
-    catch (std::exception const& ex)
-    {
-        closure->error = true;
-        closure->error_name = ex.what();
-    }
-}
-
-void Map::EIO_AfterQueryMap(uv_work_t* req)
-{
-    Napi::HandleScope scope(env);
-    Napi::AsyncResource async_resource(__func__);
-    query_map_baton_t *closure = static_cast<query_map_baton_t *>(req->data);
-    if (closure->error) {
-        Napi::Value argv[1] = { Napi::Error::New(env, closure->error_name.c_str()) };
-        async_resource.runInAsyncScope(Napi::GetCurrentContext()->Global(), Napi::New(env, closure->cb), 1, argv);
-    } else {
-        std::size_t num_result = closure->featuresets.size();
-        if (num_result >= 1)
-        {
-            Napi::Array a = Napi::Array::New(env, num_result);
-            typedef std::map<std::string,mapnik::featureset_ptr> fs_itr;
-            fs_itr::const_iterator it = closure->featuresets.begin();
-            fs_itr::const_iterator end = closure->featuresets.end();
-            unsigned idx = 0;
-            for (; it != end; ++it)
-            {
-                Napi::Object obj = Napi::Object::New(env);
-                (obj).Set(Napi::String::New(env, "layer"), Napi::String::New(env, it->first));
-                (obj).Set(Napi::String::New(env, "featureset"), Featureset::NewInstance(it->second));
-                (a).Set(idx, obj);
-                ++idx;
-            }
-            closure->featuresets.clear();
-            Napi::Value argv[2] = { env.Null(), a };
-            async_resource.runInAsyncScope(Napi::GetCurrentContext()->Global(), Napi::New(env, closure->cb), 2, argv);
-        }
-        else
-        {
-            Napi::Value argv[2] = { env.Null(), env.Undefined() };
-            async_resource.runInAsyncScope(Napi::GetCurrentContext()->Global(), Napi::New(env, closure->cb), 2, argv);
-        }
-    }
-
-    closure->m->Unref();
-    closure->cb.Reset();
-    delete closure;
-}
-*/