Skip to content

Commit 3ae6be9

Browse files
mpsonntagmpsonntag
committed
Merge pull request #83 from asobolev/master
Dimension staff on nix-mx side
2 parents d58e5fa + 82b1ece commit 3ae6be9

File tree

13 files changed

+221
-137
lines changed

13 files changed

+221
-137
lines changed

‎+nix/DataArray.m‎

Lines changed: 14 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -4,8 +4,9 @@
44
properties (Hidden)
55
% namespace reference for nix-mx functions
66
alias = 'DataArray'
7+
dimsCache
78
end
8-
9+
910
properties(Dependent)
1011
dimensions % should not be dynamic due to complex set operation
1112
end;
@@ -22,10 +23,21 @@
2223
nix.Dynamic.add_dyn_attr(obj, 'expansionOrigin', 'rw');
2324
nix.Dynamic.add_dyn_attr(obj, 'polynom_coefficients', 'rw');
2425
nix.Dynamic.add_dyn_attr(obj, 'shape', 'rw');
26+
27+
obj.dimsCache = nix.CacheStruct();
2528
end;
2629

2730
function dimensions = get.dimensions(obj)
28-
dimensions = obj.info.dimensions;
31+
if obj.dimsCache.lastUpdate ~= obj.updatedAt
32+
currList = nix_mx('DataArray::dimensions', obj.nix_handle);
33+
obj.dimsCache.data = cell(length(currList), 1);
34+
for i = 1:length(currList)
35+
% TODO convert to a proper type
36+
obj.dimsCache.data{i} = nix.SetDimension(currList{i});
37+
end;
38+
obj.dimsCache.lastUpdate = obj.updatedAt;
39+
end;
40+
dimensions = obj.dimsCache.data;
2941
end;
3042

3143
% -----------------

‎+nix/SetDimension.m‎

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
classdef SetDimension < nix.Entity
2+
%SetDimension nix SetDimension object
3+
4+
properties (Hidden)
5+
% namespace reference for nix-mx functions
6+
alias = 'SetDimension'
7+
end
8+
9+
methods
10+
function obj = SetDimension(h)
11+
[email protected](h);
12+
end
13+
14+
function ua = updatedAt(obj)
15+
ua = 0;
16+
end;
17+
end
18+
end
19+

‎nix_mx.cc‎

Lines changed: 39 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@
2020
#include "nixfeature.h"
2121
#include "nixtag.h"
2222
#include "nixmultitag.h"
23+
#include "nixdimensions.h"
2324

2425
#include <utils/glue.h>
2526

@@ -142,7 +143,15 @@ void mexFunction(int nlhs,
142143
.reg("set_label", SETTER(const std::string&, nix::DataArray, label))
143144
.reg("set_none_label", SETTER(const boost::none_t, nix::DataArray, label))
144145
.reg("set_unit", SETTER(const std::string&, nix::DataArray, unit))
145-
.reg("set_none_unit", SETTER(const boost::none_t, nix::DataArray, unit));
146+
.reg("set_none_unit", SETTER(const boost::none_t, nix::DataArray, unit))
147+
.reg("dimensions", FILTER(std::vector<nix::Dimension>, nix::DataArray, , dimensions))
148+
.reg("append_set_dimension", &nix::DataArray::appendSetDimension)
149+
.reg("append_range_dimension", &nix::DataArray::appendRangeDimension)
150+
.reg("append_sampled_dimension", &nix::DataArray::appendSampledDimension)
151+
.reg("create_set_dimension", &nix::DataArray::createSetDimension)
152+
.reg("create_range_dimension", &nix::DataArray::createRangeDimension)
153+
.reg("create_sampled_dimension", &nix::DataArray::createSampledDimension)
154+
.reg("deleteDimension", &nix::DataArray::deleteDimension);
146155
methods->add("DataArray::readAll", nixdataarray::read_all);
147156
methods->add("DataArray::writeAll", nixdataarray::write_all);
148157
methods->add("DataArray::addSource", nixdataarray::add_source);
@@ -252,6 +261,35 @@ void mexFunction(int nlhs,
252261
methods->add("Property::values", nixproperty::values);
253262
methods->add("Property::updateValues", nixproperty::update_values);
254263

264+
classdef<nix::SetDimension>("SetDimension", methods)
265+
.desc(&nixdimensions::describe)
266+
.reg("set_labels", SETTER(const std::vector<std::string>&, nix::SetDimension, labels))
267+
.reg("set_none_labels", SETTER(const boost::none_t, nix::SetDimension, labels));
268+
269+
classdef<nix::SampledDimension>("SampledDimension", methods)
270+
.desc(&nixdimensions::describe)
271+
.reg("set_label", SETTER(const std::string&, nix::SampledDimension, label))
272+
.reg("set_none_label", SETTER(const boost::none_t, nix::SampledDimension, label))
273+
.reg("set_unit", SETTER(const std::string&, nix::SampledDimension, unit))
274+
.reg("set_none_unit", SETTER(const boost::none_t, nix::SampledDimension, unit))
275+
.reg("set_sampling", SETTER(double, nix::SampledDimension, samplingInterval))
276+
.reg("set_offset", SETTER(double, nix::SampledDimension, offset))
277+
.reg("set_none_offset", SETTER(const boost::none_t, nix::SampledDimension, offset))
278+
.reg("index_of", &nix::SampledDimension::indexOf)
279+
.reg("position_at", &nix::SampledDimension::positionAt)
280+
.reg("axis", &nix::SampledDimension::axis);
281+
282+
classdef<nix::RangeDimension>("RangeDimension", methods)
283+
.desc(&nixdimensions::describe)
284+
.reg("set_label", SETTER(const std::string&, nix::RangeDimension, label))
285+
.reg("set_none_label", SETTER(const boost::none_t, nix::RangeDimension, label))
286+
.reg("set_unit", SETTER(const std::string&, nix::RangeDimension, unit))
287+
.reg("set_none_unit", SETTER(const boost::none_t, nix::RangeDimension, unit))
288+
.reg("set_ticks", SETTER(const std::vector<double>&, nix::RangeDimension, ticks))
289+
.reg("index_of", &nix::RangeDimension::indexOf)
290+
.reg("tick_at", &nix::RangeDimension::tickAt)
291+
.reg("axis", &nix::RangeDimension::axis);
292+
255293
mexAtExit(on_exit);
256294
});
257295

‎src/nixdataarray.cc‎

Lines changed: 1 addition & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ namespace nixdataarray {
1515
mxArray *describe(const nix::DataArray &da)
1616
{
1717
struct_builder sb({ 1 }, { "id", "type", "name", "definition", "label",
18-
"shape", "unit", "dimensions", "polynom_coefficients" });
18+
"shape", "unit", "polynom_coefficients" });
1919

2020
sb.set(da.id());
2121
sb.set(da.type());
@@ -24,31 +24,6 @@ namespace nixdataarray {
2424
sb.set(da.label());
2525
sb.set(da.dataExtent());
2626
sb.set(da.unit());
27-
28-
size_t ndims = da.dimensionCount();
29-
30-
mxArray *dims = mxCreateCellMatrix(1, ndims);
31-
std::vector<nix::Dimension> da_dims = da.dimensions();
32-
33-
for (size_t i = 0; i < ndims; i++) {
34-
mxArray *ca;
35-
36-
switch (da_dims[i].dimensionType()) {
37-
case nix::DimensionType::Set:
38-
ca = dim_to_struct(da_dims[i].asSetDimension());
39-
break;
40-
case nix::DimensionType::Range:
41-
ca = dim_to_struct(da_dims[i].asRangeDimension());
42-
break;
43-
case nix::DimensionType::Sample:
44-
ca = dim_to_struct(da_dims[i].asSampledDimension());
45-
break;
46-
}
47-
48-
mxSetCell(dims, i, ca);
49-
}
50-
51-
sb.set(dims);
5227
sb.set(da.polynomCoefficients());
5328

5429
return sb.array();

‎src/nixdimensions.cc‎

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
#include "nixtag.h"
2+
#include "nixgen.h"
3+
4+
#include "mex.h"
5+
6+
#include <nix.hpp>
7+
8+
#include "handle.h"
9+
#include "arguments.h"
10+
#include "struct.h"
11+
12+
namespace nixdimensions {
13+
14+
mxArray *describe(const nix::SetDimension &dim)
15+
{
16+
struct_builder sb({ 1 }, { "dim_type", "labels" });
17+
18+
sb.set(dim.dimensionType());
19+
sb.set(dim.labels());
20+
21+
return sb.array();
22+
}
23+
24+
mxArray *describe(const nix::SampledDimension &dim)
25+
{
26+
struct_builder sb({ 1 }, { "dim_type", "label", "unit", "sampling_interval", "offset" });
27+
28+
sb.set(dim.dimensionType());
29+
sb.set(dim.label());
30+
sb.set(dim.unit());
31+
sb.set(dim.samplingInterval());
32+
sb.set(dim.offset());
33+
34+
return sb.array();
35+
}
36+
37+
mxArray *describe(const nix::RangeDimension &dim)
38+
{
39+
struct_builder sb({ 1 }, { "dim_type", "label", "unit", "ticks" });
40+
41+
sb.set(dim.dimensionType());
42+
sb.set(dim.label());
43+
sb.set(dim.unit());
44+
sb.set(dim.ticks());
45+
46+
return sb.array();
47+
}
48+
} // namespace nixtag

‎src/nixdimensions.h‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
#ifndef NIX_MX_DIMENSIONS
2+
#define NIX_MX_DIMENSIONS
3+
4+
#include "arguments.h"
5+
6+
namespace nixdimensions {
7+
8+
mxArray *describe(const nix::SetDimension &dim);
9+
10+
mxArray *describe(const nix::SampledDimension &dim);
11+
12+
mxArray *describe(const nix::RangeDimension &dim);
13+
14+
} // namespace nixtag
15+
16+
#endif

‎src/nixsection.cc‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -68,7 +68,7 @@ void create_property(const extractor &input, infusor &output)
6868
void create_property_with_value(const extractor &input, infusor &output)
6969
{
7070
nix::Section currObj = input.entity<nix::Section>(1);
71-
std::vector<nix::Value> currVec = input.extractFromCells(3);
71+
std::vector<nix::Value> currVec = input.vec(3);
7272

7373
nix::Property p = currObj.createProperty(input.str(2), currVec);
7474
output.set(0, handle(p));

‎src/utils/arguments.h‎

Lines changed: 0 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -193,70 +193,6 @@ class extractor : public argument_helper<const mxArray> {
193193
return mxGetPr(array[pos]);
194194
}
195195

196-
std::vector<nix::Value> extractFromCells(size_t pos) const {
197-
198-
std::vector<nix::Value> vals;
199-
200-
mwSize total_num_of_cells = mxGetNumberOfElements(array[pos]);
201-
for (mwIndex index = 0; index<total_num_of_cells; index++) {
202-
const mxArray *cell_element_ptr = mxGetCell(array[pos], index);
203-
204-
nix::Value currVal;
205-
206-
switch (mxGetClassID(cell_element_ptr)) {
207-
case mxLOGICAL_CLASS:
208-
{
209-
const mxLogical *curr = mxGetLogicals(cell_element_ptr);
210-
currVal.set(curr[0]); break; }
211-
case mxDOUBLE_CLASS:
212-
{
213-
double curr;
214-
const void *data = mxGetData(cell_element_ptr);
215-
memcpy(&curr, data, sizeof(double));
216-
currVal.set(curr); break; }
217-
case mxUINT32_CLASS:
218-
{
219-
uint32_t curr;
220-
const void *data = mxGetData(cell_element_ptr);
221-
memcpy(&curr, data, sizeof(uint32_t));
222-
currVal.set(curr); break; }
223-
case mxINT32_CLASS:
224-
{
225-
int32_t curr;
226-
const void *data = mxGetData(cell_element_ptr);
227-
memcpy(&curr, data, sizeof(int32_t));
228-
currVal.set(curr); break; }
229-
case mxUINT64_CLASS:
230-
{
231-
uint64_t curr;
232-
const void *data = mxGetData(cell_element_ptr);
233-
memcpy(&curr, data, sizeof(uint64_t));
234-
currVal.set(curr); break; }
235-
case mxINT64_CLASS:
236-
{
237-
int64_t curr;
238-
const void *data = mxGetData(cell_element_ptr);
239-
memcpy(&curr, data, sizeof(int64_t));
240-
currVal.set(curr); break; }
241-
242-
case mxCHAR_CLASS:
243-
{
244-
char *tmp = mxArrayToString(cell_element_ptr);
245-
std::string curr_string = tmp;
246-
currVal.set(curr_string);
247-
mxFree(tmp);
248-
break;
249-
}
250-
case mxUNKNOWN_CLASS:
251-
{ mexWarnMsgTxt("Unknown class."); break; }
252-
default:
253-
{ mexWarnMsgTxt("Unsupported class."); break; }
254-
}
255-
vals.push_back(currVal);
256-
}
257-
return vals;
258-
}
259-
260196
std::vector<nix::Value> extractFromStruct(size_t pos) const {
261197

262198
// Note: nix::Value is not able to its attributes "uncertainty"

‎src/utils/handle.h‎

Lines changed: 39 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -63,6 +63,30 @@ struct entity_to_id<nix::Property> {
6363
static const int value = 8;
6464
};
6565

66+
/*
67+
Use value > 100 for entities that do NOT
68+
inherit from nix::Entity
69+
*/
70+
71+
template<>
72+
struct entity_to_id<nix::SetDimension> {
73+
static const bool is_valid = true;
74+
static const int value = 101;
75+
};
76+
77+
template<>
78+
struct entity_to_id<nix::SampledDimension> {
79+
static const bool is_valid = true;
80+
static const int value = 102;
81+
};
82+
83+
template<>
84+
struct entity_to_id<nix::RangeDimension> {
85+
static const bool is_valid = true;
86+
static const int value = 103;
87+
};
88+
89+
6690
class handle {
6791
public:
6892
struct entity {
@@ -124,7 +148,7 @@ class handle {
124148
}
125149

126150
private:
127-
template<typename T>
151+
template<typename T, typename Enable = void>
128152
struct cell : public entity {
129153
cell(const T &obj) : entity(obj), obj(obj) { }
130154

@@ -139,6 +163,20 @@ class handle {
139163
T obj;
140164
};
141165

166+
template<typename T>
167+
struct cell<T, typename std::enable_if<entity_to_id<T>::value >= 100>::type> : public entity{
168+
cell(const T &obj) : entity(obj), obj(obj) { }
169+
170+
virtual void destory() override {
171+
obj = nix::none;
172+
}
173+
174+
virtual time_t updated_at() const override {
175+
return 0;
176+
}
177+
178+
T obj;
179+
};
142180

143181
entity *et;
144182
};

‎src/utils/mkarray.cc‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,20 @@ mxArray* make_mx_array(const nix::LinkType &ltype)
2828
return data;
2929
}
3030

31+
mxArray* make_mx_array(const nix::DimensionType &dtype)
32+
{
33+
uint8_t d_type;
34+
35+
switch (dtype) {
36+
case nix::DimensionType::Set: d_type = 0; break;
37+
case nix::DimensionType::Sample: d_type = 1; break;
38+
case nix::DimensionType::Range: d_type = 2; break;
39+
default: throw std::invalid_argument("unkown dimension type");
40+
}
41+
mxArray *data = mxCreateDoubleScalar(d_type);
42+
43+
return data;
44+
}
3145

3246
mxArray* make_mx_array(const nix::Value &v)
3347
{

0 commit comments

Comments
 (0)