Skip to content

Commit b1eaec6

Browse files
mpsonntagmpsonntag
committed
[matlab] Consistently use entity alias func calls
Consistently use entity alias in functions calls to C++ to reduce redundancy and increase code readability.
1 parent 73a2fc1 commit b1eaec6

17 files changed

+440
-312
lines changed

‎+nix/Block.m‎

Lines changed: 74 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
% LICENSE file in the root of the Project.
88

99
classdef Block < nix.NamedEntity & nix.MetadataMixIn
10-
%Block nix Block object
10+
% Block nix Block object
1111

1212
properties (Hidden)
1313
% namespace reference for nix-mx functions
@@ -32,50 +32,58 @@
3232
% -----------------
3333

3434
function r = group_count(obj)
35-
r = nix_mx('Block::groupCount', obj.nix_handle);
35+
fname = strcat(obj.alias, '::groupCount');
36+
r = nix_mx(fname, obj.nix_handle);
3637
end
3738

3839
function r = create_group(obj, name, nixtype)
39-
h = nix_mx('Block::createGroup', obj.nix_handle, name, nixtype);
40+
fname = strcat(obj.alias, '::createGroup');
41+
h = nix_mx(fname, obj.nix_handle, name, nixtype);
4042
r = nix.Group(h);
4143
end
4244

4345
function r = has_group(obj, id_or_name)
44-
r = nix_mx('Block::hasGroup', obj.nix_handle, id_or_name);
46+
fname = strcat(obj.alias, '::hasGroup');
47+
r = nix_mx(fname, obj.nix_handle, id_or_name);
4548
end
4649

4750
function r = get_group(obj, id_or_name)
48-
r = nix.Utils.open_entity(obj, 'Block::getGroup', id_or_name, @nix.Group);
51+
fname = strcat(obj.alias, '::getGroup');
52+
r = nix.Utils.open_entity(obj, fname, id_or_name, @nix.Group);
4953
end
5054

5155
function r = open_group_idx(obj, idx)
52-
r = nix.Utils.open_entity(obj, 'Block::openGroupIdx', idx, @nix.Group);
56+
fname = strcat(obj.alias, '::openGroupIdx');
57+
r = nix.Utils.open_entity(obj, fname, idx, @nix.Group);
5358
end
5459

5560
function r = delete_group(obj, del)
56-
r = nix.Utils.delete_entity(obj, del, 'nix.Group', 'Block::deleteGroup');
61+
fname = strcat(obj.alias, '::deleteGroup');
62+
r = nix.Utils.delete_entity(obj, del, 'nix.Group', fname);
5763
end
5864

5965
function r = filter_groups(obj, filter, val)
60-
r = nix.Utils.filter(obj, filter, val, 'Block::groupsFiltered', @nix.Group);
66+
fname = strcat(obj.alias, '::groupsFiltered');
67+
r = nix.Utils.filter(obj, filter, val, fname, @nix.Group);
6168
end
6269

6370
% -----------------
6471
% DataArray methods
6572
% -----------------
6673

6774
function r = data_array_count(obj)
68-
r = nix_mx('Block::dataArrayCount', obj.nix_handle);
75+
fname = strcat(obj.alias, '::dataArrayCount');
76+
r = nix_mx(fname, obj.nix_handle);
6977
end
7078

7179
function r = data_array(obj, id_or_name)
72-
r = nix.Utils.open_entity(obj, ...
73-
'Block::openDataArray', id_or_name, @nix.DataArray);
80+
fname = strcat(obj.alias, '::openDataArray');
81+
r = nix.Utils.open_entity(obj, fname, id_or_name, @nix.DataArray);
7482
end
7583

7684
function r = open_data_array_idx(obj, idx)
77-
r = nix.Utils.open_entity(obj, ...
78-
'Block::openDataArrayIdx', idx, @nix.DataArray);
85+
fname = strcat(obj.alias, '::openDataArrayIdx');
86+
r = nix.Utils.open_entity(obj, fname, idx, @nix.DataArray);
7987
end
8088

8189
function r = create_data_array(obj, name, nixtype, datatype, shape)
@@ -95,8 +103,8 @@
95103
errorStruct.message = 'Writing Strings to DataArrays is not supported as of yet.';
96104
error(errorStruct);
97105
else
98-
h = nix_mx('Block::createDataArray', obj.nix_handle, ...
99-
name, nixtype, lower(datatype.char), shape);
106+
fname = strcat(obj.alias, '::createDataArray');
107+
h = nix_mx(fname, obj.nix_handle, name, nixtype, lower(datatype.char), shape);
100108
r = nix.DataArray(h);
101109
end
102110
end
@@ -129,49 +137,57 @@
129137
end
130138

131139
function r = has_data_array(obj, id_or_name)
132-
r = nix_mx('Block::hasDataArray', obj.nix_handle, id_or_name);
140+
fname = strcat(obj.alias, '::hasDataArray');
141+
r = nix_mx(fname, obj.nix_handle, id_or_name);
133142
end
134143

135144
function r = delete_data_array(obj, del)
136-
r = nix.Utils.delete_entity(obj, ...
137-
del, 'nix.DataArray', 'Block::deleteDataArray');
145+
fname = strcat(obj.alias, '::deleteDataArray');
146+
r = nix.Utils.delete_entity(obj, del, 'nix.DataArray', fname);
138147
end
139148

140149
function r = filter_data_arrays(obj, filter, val)
141-
r = nix.Utils.filter(obj, filter, val, ...
142-
'Block::dataArraysFiltered', @nix.DataArray);
150+
fname = strcat(obj.alias, '::dataArraysFiltered');
151+
r = nix.Utils.filter(obj, filter, val, fname, @nix.DataArray);
143152
end
144153

145154
% -----------------
146155
% Sources methods
147156
% -----------------
148157

149158
function r = source_count(obj)
150-
r = nix_mx('Block::sourceCount', obj.nix_handle);
159+
fname = strcat(obj.alias, '::sourceCount');
160+
r = nix_mx(fname, obj.nix_handle);
151161
end
152162

153163
function r = create_source(obj, name, type)
154-
r = nix.Source(nix_mx('Block::createSource', obj.nix_handle, name, type));
164+
fname = strcat(obj.alias, '::createSource');
165+
r = nix.Source(nix_mx(fname, obj.nix_handle, name, type));
155166
end
156167

157168
function r = has_source(obj, id_or_name)
158-
r = nix_mx('Block::hasSource', obj.nix_handle, id_or_name);
169+
fname = strcat(obj.alias, '::hasSource');
170+
r = nix_mx(fname, obj.nix_handle, id_or_name);
159171
end
160172

161173
function r = delete_source(obj, del)
162-
r = nix.Utils.delete_entity(obj, del, 'nix.Source', 'Block::deleteSource');
174+
fname = strcat(obj.alias, '::deleteSource');
175+
r = nix.Utils.delete_entity(obj, del, 'nix.Source', fname);
163176
end
164177

165178
function r = open_source(obj, id_or_name)
166-
r = nix.Utils.open_entity(obj, 'Block::openSource', id_or_name, @nix.Source);
179+
fname = strcat(obj.alias, '::openSource');
180+
r = nix.Utils.open_entity(obj, fname, id_or_name, @nix.Source);
167181
end
168182

169183
function r = open_source_idx(obj, idx)
170-
r = nix.Utils.open_entity(obj, 'Block::openSourceIdx', idx, @nix.Source);
184+
fname = strcat(obj.alias, '::openSourceIdx');
185+
r = nix.Utils.open_entity(obj, fname, idx, @nix.Source);
171186
end
172187

173188
function r = filter_sources(obj, filter, val)
174-
r = nix.Utils.filter(obj, filter, val, 'Block::sourcesFiltered', @nix.Source);
189+
fname = strcat(obj.alias, '::sourcesFiltered');
190+
r = nix.Utils.filter(obj, filter, val, fname, @nix.Source);
175191
end
176192

177193
% maxdepth is an index
@@ -181,62 +197,72 @@
181197

182198
% maxdepth is an index
183199
function r = find_filtered_sources(obj, max_depth, filter, val)
184-
r = nix.Utils.find(obj, ...
185-
max_depth, filter, val, 'Block::findSources', @nix.Source);
200+
fname = strcat(obj.alias, '::findSources');
201+
r = nix.Utils.find(obj, max_depth, filter, val, fname, @nix.Source);
186202
end
187203

188204
% -----------------
189205
% Tags methods
190206
% -----------------
191207

192208
function r = tag_count(obj)
193-
r = nix_mx('Block::tagCount', obj.nix_handle);
209+
fname = strcat(obj.alias, '::tagCount');
210+
r = nix_mx(fname, obj.nix_handle);
194211
end
195212

196213
function r = has_tag(obj, id_or_name)
197-
r = nix_mx('Block::hasTag', obj.nix_handle, id_or_name);
214+
fname = strcat(obj.alias, '::hasTag');
215+
r = nix_mx(fname, obj.nix_handle, id_or_name);
198216
end
199217

200218
function r = open_tag(obj, id_or_name)
201-
r = nix.Utils.open_entity(obj, 'Block::openTag', id_or_name, @nix.Tag);
219+
fname = strcat(obj.alias, '::openTag');
220+
r = nix.Utils.open_entity(obj, fname, id_or_name, @nix.Tag);
202221
end
203222

204223
function r = open_tag_idx(obj, idx)
205-
r = nix.Utils.open_entity(obj, 'Block::openTagIdx', idx, @nix.Tag);
224+
fname = strcat(obj.alias, '::openTagIdx');
225+
r = nix.Utils.open_entity(obj, fname, idx, @nix.Tag);
206226
end
207227

208228
function r = create_tag(obj, name, type, position)
209-
h = nix_mx('Block::createTag', obj.nix_handle, name, type, position);
210-
r = nix.Tag(h);
229+
fname = strcat(obj.alias, '::createTag');
230+
h = nix_mx(fname, obj.nix_handle, name, type, position);
231+
r = nix.Tag(h);
211232
end
212233

213234
function r = delete_tag(obj, del)
214-
r = nix.Utils.delete_entity(obj, del, 'nix.Tag', 'Block::deleteTag');
235+
fname = strcat(obj.alias, '::deleteTag');
236+
r = nix.Utils.delete_entity(obj, del, 'nix.Tag', fname);
215237
end
216238

217239
function r = filter_tags(obj, filter, val)
218-
r = nix.Utils.filter(obj, filter, val, 'Block::tagsFiltered', @nix.Tag);
240+
fname = strcat(obj.alias, '::tagsFiltered');
241+
r = nix.Utils.filter(obj, filter, val, fname, @nix.Tag);
219242
end
220243

221244
% -----------------
222245
% MultiTag methods
223246
% -----------------
224247

225248
function r = multi_tag_count(obj)
226-
r = nix_mx('Block::multiTagCount', obj.nix_handle);
249+
fname = strcat(obj.alias, '::multiTagCount');
250+
r = nix_mx(fname, obj.nix_handle);
227251
end
228252

229253
function r = has_multi_tag(obj, id_or_name)
230-
r = nix_mx('Block::hasMultiTag', obj.nix_handle, id_or_name);
254+
fname = strcat(obj.alias, '::hasMultiTag');
255+
r = nix_mx(fname, obj.nix_handle, id_or_name);
231256
end
232257

233258
function r = open_multi_tag(obj, id_or_name)
234-
r = nix.Utils.open_entity(obj, ...
235-
'Block::openMultiTag', id_or_name, @nix.MultiTag);
259+
fname = strcat(obj.alias, '::openMultiTag');
260+
r = nix.Utils.open_entity(obj, fname, id_or_name, @nix.MultiTag);
236261
end
237262

238263
function r = open_multi_tag_idx(obj, idx)
239-
r = nix.Utils.open_entity(obj, 'Block::openMultiTagIdx', idx, @nix.MultiTag);
264+
fname = strcat(obj.alias, '::openMultiTagIdx');
265+
r = nix.Utils.open_entity(obj, fname, idx, @nix.MultiTag);
240266
end
241267

242268
%-- Creating a multitag requires an already existing data array
@@ -247,18 +273,19 @@
247273
addID = add_data_array;
248274
end
249275

250-
h = nix_mx('Block::createMultiTag', obj.nix_handle, name, type, addID);
276+
fname = strcat(obj.alias, '::createMultiTag');
277+
h = nix_mx(fname, obj.nix_handle, name, type, addID);
251278
r = nix.MultiTag(h);
252279
end
253280

254281
function r = delete_multi_tag(obj, del)
255-
r = nix.Utils.delete_entity(obj, ...
256-
del, 'nix.MultiTag', 'Block::deleteMultiTag');
282+
fname = strcat(obj.alias, '::deleteMultiTag');
283+
r = nix.Utils.delete_entity(obj, del, 'nix.MultiTag', fname);
257284
end
258285

259286
function r = filter_multi_tags(obj, filter, val)
260-
r = nix.Utils.filter(obj, filter, val, ...
261-
'Block::multiTagsFiltered', @nix.MultiTag);
287+
fname = strcat(obj.alias, '::multiTagsFiltered');
288+
r = nix.Utils.filter(obj, filter, val, fname, @nix.MultiTag);
262289
end
263290
end
264291

‎+nix/DataArray.m‎

Lines changed: 26 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,8 @@
3838

3939
function dimensions = get.dimensions(obj)
4040
dimensions = {};
41-
currList = nix_mx('DataArray::dimensions', obj.nix_handle);
41+
fname = strcat(obj.alias, '::dimensions');
42+
currList = nix_mx(fname, obj.nix_handle);
4243
for i = 1:length(currList)
4344
switch currList(i).dtype
4445
case 'set'
@@ -54,34 +55,34 @@
5455
end
5556

5657
function r = append_set_dimension(obj)
57-
func_name = strcat(obj.alias, '::appendSetDimension');
58-
h = nix_mx(func_name, obj.nix_handle);
58+
fname = strcat(obj.alias, '::appendSetDimension');
59+
h = nix_mx(fname, obj.nix_handle);
5960
r = nix.SetDimension(h);
6061
end
6162

6263
function r = append_sampled_dimension(obj, interval)
63-
func_name = strcat(obj.alias, '::appendSampledDimension');
64-
h = nix_mx(func_name, obj.nix_handle, interval);
64+
fname = strcat(obj.alias, '::appendSampledDimension');
65+
h = nix_mx(fname, obj.nix_handle, interval);
6566
r = nix.SampledDimension(h);
6667
end
6768

6869
function r = append_range_dimension(obj, ticks)
69-
func_name = strcat(obj.alias, '::appendRangeDimension');
70-
h = nix_mx(func_name, obj.nix_handle, ticks);
70+
fname = strcat(obj.alias, '::appendRangeDimension');
71+
h = nix_mx(fname, obj.nix_handle, ticks);
7172
r = nix.RangeDimension(h);
7273
end
7374

7475
function r = append_alias_range_dimension(obj)
75-
func_name = strcat(obj.alias, '::appendAliasRangeDimension');
76-
h = nix_mx(func_name, obj.nix_handle);
76+
fname = strcat(obj.alias, '::appendAliasRangeDimension');
77+
h = nix_mx(fname, obj.nix_handle);
7778
r = nix.RangeDimension(h);
7879
end
7980

8081
function r = open_dimension_idx(obj, idx)
8182
% Getting the dimension by index starts with 1
8283
% instead of 0 compared to all other index functions.
83-
func_name = strcat(obj.alias, '::openDimensionIdx');
84-
dim = nix_mx(func_name, obj.nix_handle, idx);
84+
fname = strcat(obj.alias, '::openDimensionIdx');
85+
dim = nix_mx(fname, obj.nix_handle, idx);
8586
switch(dim.dimension_type)
8687
case 'set'
8788
r = nix.SetDimension(dim.handle);
@@ -93,23 +94,25 @@
9394
end
9495

9596
function r = delete_dimensions(obj)
96-
func_name = strcat(obj.alias, '::deleteDimensions');
97-
r = nix_mx(func_name, obj.nix_handle);
97+
fname = strcat(obj.alias, '::deleteDimensions');
98+
r = nix_mx(fname, obj.nix_handle);
9899
end
99100

100101
function r = dimension_count(obj)
101-
r = nix_mx('DataArray::dimensionCount', obj.nix_handle);
102+
fname = strcat(obj.alias, '::dimensionCount');
103+
r = nix_mx(fname, obj.nix_handle);
102104
end
103105

104106
% -----------------
105107
% Data access methods
106108
% -----------------
107109

108110
function r = read_all(obj)
109-
data = nix_mx('DataArray::readAll', obj.nix_handle);
111+
fname = strcat(obj.alias, '::readAll');
112+
data = nix_mx(fname, obj.nix_handle);
110113

111-
% data must agree with file & dimensions; see mkarray.cc(42)
112-
r = permute(data, length(size(data)):-1:1);
114+
% data must agree with file & dimensions; see mkarray.cc(42)
115+
r = permute(data, length(size(data)):-1:1);
113116
end
114117

115118
%-- TODO add (optional) offset
@@ -138,14 +141,16 @@
138141
errorStruct.message = ('Writing char/string DataArrays is not supported as of yet.');
139142
error(errorStruct);
140143
else
144+
fname = strcat(obj.alias, '::writeAll');
141145
% data must agree with file & dimensions; see mkarray.cc(42)
142146
tmp = permute(data, length(size(data)):-1:1);
143-
nix_mx('DataArray::writeAll', obj.nix_handle, tmp);
147+
nix_mx(fname, obj.nix_handle, tmp);
144148
end
145149
end
146150

147151
function r = datatype(obj)
148-
r = nix_mx('DataArray::dataType', obj.nix_handle);
152+
fname = strcat(obj.alias, '::dataType');
153+
r = nix_mx(fname, obj.nix_handle);
149154
end
150155

151156
% Set data extent enables to increase the original size
@@ -158,7 +163,8 @@
158163
% shape, existing data that does not fit into the new shape
159164
% will be lost!
160165
function [] = set_data_extent(obj, extent)
161-
nix_mx('DataArray::setDataExtent', obj.nix_handle, extent);
166+
fname = strcat(obj.alias, '::setDataExtent');
167+
nix_mx(fname, obj.nix_handle, extent);
162168
% update changed dataExtent in obj.info
163169
obj.info = nix_mx(strcat(obj.alias, '::describe'), obj.nix_handle);
164170
end

0 commit comments

Comments
 (0)