[Dimensions] hide optional arguments for now

Author: jgrewe

+nix/DataArray.m

@@ -135,69 +135,49 @@
             % Example:  dim = currDataArray.appendSetDimension();
             %
             % See also nix.SetDimension.
-
+          
             fname = strcat(obj.alias, '::appendSetDimension');
             h = nix_mx(fname, obj.nixhandle);
             r = nix.Utils.createEntity(h, @nix.SetDimension);
         end
 
-        function r = appendSampledDimension(obj, interval, label, unit, offset)
+        function r = appendSampledDimension(obj, interval)
             % Append a new SampledDimension as last entry to the list of 
             % existing dimension descriptors of the invoking DataArray.
             %
             % Used to describe the regularly sampled dimension of data.
             %
             % interval (double):  The sampling interval of the Dimension to create.
-            % label (string): The label used for the described axis, default empty.
-            % unit (string): The unit of the axis, default empty.
-            % offset (double): The offset of the dimension, default 0.0.
             %
             % Returns:  (nix.SampledDimension) The newly created SampledDimension.
             %
             % Example:  stepSize = 5;
-            %           label = "time";
-            %           unit = "s";
-            %           offset = 1.0;
-            %           dim = currDataArray.appendSampledDimension(stepSize, label, unit, offset);
+            %          
+            %           dim = currDataArray.appendSampledDimension(stepSize);
             %
             % See also nix.SampledDimension.
-            if nargin < 3
-                label = "";
-            end
-            if nargin < 4
-                unit = "";
-            end
-            if nargin < 5
-                offset = 0.0;
-            end
+           
             fname = strcat(obj.alias, '::appendSampledDimension');
-            h = nix_mx(fname, obj.nixhandle, interval, label, unit, offset);
+            h = nix_mx(fname, obj.nixhandle, interval);
             r = nix.Utils.createEntity(h, @nix.SampledDimension);
         end
 
-        function r = appendRangeDimension(obj, ticks, label, unit)
+        function r = appendRangeDimension(obj, ticks)
             % Append a new SampledDimension as last entry to the list of 
             % existing dimension descriptors of the invoking DataArray.
             %
             % Used to describe the irregularly sampled dimension of data.
             %
             % ticks ([double]):  The ticks of the RangeDimension.
-            % label (string): The label used to describe this dimension, default empty
-            % unit (string): The unit of the ticks stored in  this dimsension, default empty
             %
             % Returns:  (nix.RangeDimension) The newly created RangeDimension.
             %
             % Example:  dim = currDataArray.appendRangeDimension([1 10 21 15]);
             %
             % See also nix.SampledDimension.
-            if nargin < 3
-                label = "";
-            end
-            if nargin < 4
-                unit = "";
-            end
+           
             fname = strcat(obj.alias, '::appendRangeDimension');
-            h = nix_mx(fname, obj.nixhandle, ticks, label, unit);
+            h = nix_mx(fname, obj.nixhandle, ticks);
             r = nix.Utils.createEntity(h, @nix.RangeDimension);
         end
 

nix_mx.cc

@@ -242,6 +242,9 @@ void mexFunction(int            nlhs,
             .add("openDimensionIdx", nixdataarray::openDimensionIdx)
             .add("compare", nixdataarray::compare)
             .add("sourcesFiltered", nixdataarray::sourcesFiltered)
+            .add("appendSampledDimension", nixdataarray::arrayAppendSampledDimension)
+            .add("appendSetDimension", nixdataarray::arrayAppendSetDimension)
+            .add("appendRangeDimension", nixdataarray::arrayAppendRangeDimension)
             .reg("sources", IDATAARRAY(std::vector<nix::Source>, EntityWithSources, std::function<bool(const nix::Source &)>, sources, const))
             .reg("openMetadataSection", IDATAARRAY(nix::Section, EntityWithMetadata, , metadata, const))
             .reg("setMetadata", IDATAARRAY(void, EntityWithMetadata, const std::string&, metadata, ))
@@ -257,10 +260,10 @@ void mexFunction(int            nlhs,
             .reg("setNoneExpansionOrigin", SETTER(boost::none_t, nix::DataArray, expansionOrigin))
             .reg("setNonePolynomCoefficients", SETTER(boost::none_t, nix::DataArray, polynomCoefficients))
             .reg("dimensions", FILTER(std::vector<nix::Dimension>, nix::DataArray, , dimensions))
-            .reg("appendSetDimension", &nix::DataArray::appendSetDimension)
-            .reg("appendRangeDimension", &nix::DataArray::appendRangeDimension)
+            //.reg("appendSetDimension", &nix::DataArray::appendSetDimension)
+            //.reg("appendRangeDimension", &nix::DataArray::appendRangeDimension)
             .reg("appendAliasRangeDimension", &nix::DataArray::appendAliasRangeDimension)
-            .reg("appendSampledDimension", &nix::DataArray::appendSampledDimension)
+            //.reg("appendSampledDimension", &nix::DataArray::appendSampledDimension)
             .reg("createSetDimension", &nix::DataArray::createSetDimension)
             .reg("createRangeDimension", &nix::DataArray::createRangeDimension)
             .reg("createAliasRangeDimension", &nix::DataArray::createAliasRangeDimension)

src/nixdataarray.cc

@@ -185,4 +185,23 @@ namespace nixdataarray {
         output.set(0, res);
     }
 
+    void arrayAppendSampledDimension(const extractor &input, infusor &output) {
+        nix::DataArray currObj = input.entity<nix::DataArray>(1);
+        double si = static_cast<double>(input.num<double>(2));
+        nix::SampledDimension d = currObj.appendSampledDimension(si);
+        output.set(0, d);
+    }
+
+    void arrayAppendSetDimension(const extractor &input, infusor &output) {
+        nix::DataArray currObj = input.entity<nix::DataArray>(1);
+        nix::SetDimension d = currObj.appendSetDimension();
+        output.set(0, d);
+    }
+
+    void arrayAppendRangeDimension(const extractor &input, infusor &output) {
+        nix::DataArray currObj = input.entity<nix::DataArray>(1);
+        std::vector<double> ticks = input.vec<double>(2);
+        nix::RangeDimension d = currObj.appendRangeDimension(ticks);
+        output.set(0, d);
+    }
 } // namespace nixdataarray

src/nixdataarray.h

@@ -49,6 +49,12 @@ namespace nixdataarray {
 
     void sourcesFiltered(const extractor &input, infusor &output);
 
+    void arrayAppendSampledDimension(const extractor &input, infusor &output);
+
+    void arrayAppendRangeDimension(const extractor &input, infusor &output);
+
+    void arrayAppendSetDimension(const extractor &input, infusor &output);
+
 } // namespace nixdataarray
 
 #endif