nodenetcdf 4.9.3

package/src/Variable.h

@@ -0,0 +1,88 @@
+#ifndef NODENETCDFJS_VARIABLE_H
+#define NODENETCDFJS_VARIABLE_H
+
+#include <array>
+#include <netcdf.h>
+#include <node.h>
+#include <node_object_wrap.h>
+
+
+namespace nodenetcdfjs
+{
+
+class Variable : public node::ObjectWrap
+{
+  public:
+    static void Init(v8::Local<v8::Object> exports);
+    Variable(int id_, int parent_id_) noexcept;
+
+    [[nodiscard]] bool get_name(char *name) const noexcept;
+
+  private:
+    // Delete copy and move operations for safety
+    Variable(const Variable &) = delete;
+    Variable &operator=(const Variable &) = delete;
+    Variable(Variable &&) = delete;
+    Variable &operator=(Variable &&) = delete;
+
+    static void Read(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void ReadSlice(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void ReadStridedSlice(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void Write(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void WriteSlice(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void WriteStridedSlice(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void AddAttribute(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetId(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void GetType(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void GetDimensions(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void GetAttributes(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void GetName(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void SetName(v8::Local<v8::String> property, v8::Local<v8::Value> val,
+                        const v8::PropertyCallbackInfo<void> &info);
+    static void GetEndianness(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void SetEndianness(v8::Local<v8::String> property, v8::Local<v8::Value> val,
+                              const v8::PropertyCallbackInfo<void> &info);
+    static void GetChecksumMode(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void SetChecksumMode(v8::Local<v8::String> property, v8::Local<v8::Value> val,
+                                const v8::PropertyCallbackInfo<void> &info);
+    static void GetChunkMode(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void SetChunkMode(v8::Local<v8::String> property, v8::Local<v8::Value> val,
+                             const v8::PropertyCallbackInfo<void> &info);
+    static void GetChunkSizes(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void SetChunkSizes(v8::Local<v8::String> property, v8::Local<v8::Value> val,
+                              const v8::PropertyCallbackInfo<void> &info);
+    static void GetFillMode(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void SetFillMode(v8::Local<v8::String> property, v8::Local<v8::Value> val,
+                            const v8::PropertyCallbackInfo<void> &info);
+    static void GetFillValue(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void SetFillValue(v8::Local<v8::String> property, v8::Local<v8::Value> val,
+                             const v8::PropertyCallbackInfo<void> &info);
+    static void GetCompressionShuffle(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void SetCompressionShuffle(v8::Local<v8::String> property, v8::Local<v8::Value> val,
+                                      const v8::PropertyCallbackInfo<void> &info);
+    static void GetCompressionDeflate(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void SetCompressionDeflate(v8::Local<v8::String> property, v8::Local<v8::Value> val,
+                                      const v8::PropertyCallbackInfo<void> &info);
+    static void GetCompressionLevel(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void SetCompressionLevel(v8::Local<v8::String> property, v8::Local<v8::Value> val,
+                                    const v8::PropertyCallbackInfo<void> &info);
+    static void Inspect(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static v8::Persistent<v8::Function> constructor;
+
+    // Use constexpr arrays for compile-time constants
+    static constexpr std::array<unsigned char, 11> type_sizes = {1, 1, 2, 4, 4, 8, 1, 2, 4, 8, 0};
+
+    static constexpr std::array<const char *, 11> type_names = {"byte",  "char",   "short", "int",   "float", "double",
+                                                                "ubyte", "ushort", "uint",  "int64", "string"};
+
+    int id{-1};
+    int parent_id{-1};
+    nc_type type{NC_NAT};
+    int ndims{0};
+};
+
+} // namespace nodenetcdfjs
+
+#endif

package/src/nodenetcdfjs.cpp

@@ -0,0 +1,24 @@
+#include "Attribute.h"
+#include "Dimension.h"
+#include "File.h"
+#include "Group.h"
+#include "Variable.h"
+#include <node.h>
+
+
+namespace nodenetcdfjs
+{
+void InitAll(v8::Local<v8::Object> exports)
+{
+    File::Init(exports);
+    Variable::Init(exports);
+    Group::Init(exports);
+    Dimension::Init(exports);
+    Attribute::Init(exports);
+}
+
+NODE_MODULE_INIT()
+{
+    InitAll(exports);
+}
+} // namespace nodenetcdfjs

package/src/nodenetcdfjs.h

@@ -0,0 +1,37 @@
+#ifndef NODENETCDFJS_H
+#define NODENETCDFJS_H
+
+#include <netcdf.h>
+#include <node.h>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+
+namespace nodenetcdfjs
+{
+
+inline void throw_netcdf_error(v8::Isolate *isolate, int retval) noexcept(false)
+{
+    isolate->ThrowException(v8::Exception::TypeError(
+        v8::String::NewFromUtf8(isolate, nc_strerror(retval), v8::NewStringType::kNormal).ToLocalChecked()));
+}
+
+[[nodiscard]] constexpr int get_type(std::string_view type_str) noexcept
+{
+    constexpr std::pair<std::string_view, int> type_map[] = {
+        {"byte", NC_BYTE},     {"char", NC_CHAR},   {"short", NC_SHORT},   {"int", NC_INT},   {"float", NC_FLOAT},
+        {"double", NC_DOUBLE}, {"ubyte", NC_UBYTE}, {"ushort", NC_USHORT}, {"uint", NC_UINT}, {"string", NC_STRING}};
+
+    for (const auto &[key, value] : type_map)
+    {
+        if (type_str == key)
+        {
+            return value;
+        }
+    }
+    return NC_NAT;
+}
+
+} // namespace nodenetcdfjs
+
+#endif

package/test/attribute.js

@@ -0,0 +1,36 @@
+var expect = require("chai").expect,
+    nodenetcdf = require("../build/Release/nodenetcdf.node");
+
+describe('Attribute', function() {
+    describe('name', function() {
+        it('should read group attribute name', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            var attributes = file.root.subgroups["mozaic_flight_2012030419144751_ascent"].attributes;
+            expect(attributes["airport_dep"].name).to.equal("airport_dep");
+        });
+    });
+
+    describe('value', function() {
+        it('should read group attribute value', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            var attributes = file.root.subgroups["mozaic_flight_2012030419144751_ascent"].attributes;
+            expect(attributes["airport_dep"].value).to.equal("FRA");
+        });
+    });
+
+    describe('name', function() {
+        it('should read variable attribute name', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            var attributes = file.root.subgroups["mozaic_flight_2012030419144751_ascent"].variables["air_press"].attributes;
+            expect(attributes["name"].name).to.equal("name");
+        });
+    });
+
+    describe('value', function() {
+        it('should read variable attribute name', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            var attributes = file.root.subgroups["mozaic_flight_2012030419144751_ascent"].variables["air_press"].attributes;
+            expect(attributes["name"].value).to.equal("air_pressure");
+        });
+    });
+});

package/test/dimension.js

@@ -0,0 +1,18 @@
+var expect = require("chai").expect,
+    nodenetcdf = require("../build/Release/nodenetcdf.node");
+
+describe('Dimension', function() {
+    describe('name', function() {
+        it('should read name', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            expect(file.root.dimensions["recNum"].name).to.equal("recNum");
+        });
+    });
+
+    describe('length', function() {
+        it('should read length', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            expect(file.root.dimensions["recNum"].length).to.equal(74);
+        });
+    });
+});

package/test/file.js

@@ -0,0 +1,19 @@
+var expect = require("chai").expect,
+    nodenetcdf = require("../build/Release/nodenetcdf.node");
+
+describe('File', function() {
+    describe('new', function() {
+        it('should throw an error when file not found', function() {
+            expect(function() {
+                var file = new nodenetcdf.File("DOESNOTEXIST", "r");
+            }).to.throw("No such file or directory");
+        });
+
+        it('should throw an error for wrong file mode', function() {
+            expect(function() {
+                var file = new nodenetcdf.File("test/testrh.nc", "WRONG");
+            }).to.throw("Unknown file mode");
+        });
+    });
+
+});

package/test/group.js

@@ -0,0 +1,57 @@
+var expect = require("chai").expect,
+    nodenetcdf = require("../build/Release/nodenetcdf.node");
+
+describe('Group', function() {
+    describe('variables', function() {
+        it('should read list of variables', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            expect(file.root.variables).to.have.property("UTC_time");
+        });
+    });
+
+    describe('dimensions', function() {
+        it('should read list of dimensions', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            expect(file.root.dimensions).to.have.property("recNum");
+        });
+    });
+
+    describe('subgroups', function() {
+        it('should read list of subgroups', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            var subgroups = file.root.subgroups;
+            expect(subgroups).to.have.property("mozaic_flight_2012030319051051_descent");
+            expect(subgroups).to.have.property("mozaic_flight_2012030319051051_descent");
+            expect(subgroups).to.have.property("mozaic_flight_2012030321335035_descent");
+            expect(subgroups).to.have.property("mozaic_flight_2012030403540535_ascent");
+            expect(subgroups).to.have.property("mozaic_flight_2012030403540535_descent");
+            expect(subgroups).to.have.property("mozaic_flight_2012030412545335_ascent");
+            expect(subgroups).to.have.property("mozaic_flight_2012030419144751_ascent");
+            expect(subgroups["mozaic_flight_2012030419144751_ascent"].constructor.name).to.equal("Group");
+        });
+    });
+
+    describe('attributes', function() {
+        it('should read list of attributes', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            var attributes = file.root.subgroups["mozaic_flight_2012030419144751_ascent"].attributes;
+            expect(attributes).to.have.property("airport_dep");
+            expect(attributes).to.have.property("flight");
+            expect(attributes).to.have.property("level");
+            expect(attributes).to.have.property("airport_arr");
+            expect(attributes).to.have.property("mission");
+            expect(attributes).to.have.property("time_dep");
+            expect(attributes).to.have.property("aircraft");
+            expect(attributes).to.have.property("link");
+            expect(attributes).to.have.property("phase");
+            expect(attributes).to.have.property("time_arr");
+        });
+    });
+
+    describe('name', function() {
+        it('should read name', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            expect(file.root.name).to.equal("/");
+        });
+    });
+});

package/test/variable.js

@@ -0,0 +1,16 @@
+var expect = require("chai").expect,
+    nodenetcdf = require("../build/Release/nodenetcdf.node");
+
+describe('Variable', function() {
+  it('should read a slice', function() {
+      var file = new nodenetcdf.File("test/testrh.nc", "r");
+      var results = Array.from(file.root.variables.var1.readSlice(0, 4));
+      expect(results).to.deep.equal([420, 197, 391.5, 399]);
+  });
+
+  it('should read a strided slice', function() {
+      var file = new nodenetcdf.File("test/testrh.nc", "r");
+      var results = Array.from(file.root.variables.var1.readStridedSlice(0, 2, 2));
+        expect(results).to.deep.equal([420, 391.5]);
+  });
+});