This example shows how to customize brace indexing in the ArrayofArrays
class. ArrayOfArrays
implements a 1-by-n
array of arrays. The contained arrays can be of different classes, shapes, and sizes. The class inherits from both matlab.mixin.indexing.RedefinesBrace
and matlab.mixin.indexing.RedefinesParen
. The brace indexing customization handles references and assignments to the contained arrays:
braceReference
: Handles brace references into the Arrays
property of the class. For example, the syntax instance
{idx
} accesses the contained array at index idx
in Arrays
.
braceAssign
: Handles brace assignments into the Arrays
property. For example, the syntax instance
{idx
} = A
assigns the value of A
to the contained array at index idx
in Arrays
. If idx
exceeds the current number of elements in Arrays
, braceAssign
creates the element and assigns A
to it.
braceListLength
: Determines the number of values to return from brace indexing expressions that return a comma-separated list.
ArrayOfArrays
also inherits from RedefinesParen
to support parentheses indexing in a way similar to cell arrays. For example, the syntax instance1
(
idx1
)
= instance2
(
idx2
)
assigns the contained array in instance2
at idx2
to idx1
in instance1
. To see the full list of abstract methods that must be implemented when customizing parentheses indexing, see matlab.mixin.indexing.RedefinesParen
.
The class definition of ArrayOfArrays
also includes two error-handling functions:
ErrorForUnsupportedIndexing:
Prevents any additional indexing after parentheses indexing in reference and assignment operations.
ErrorForUnexpectedRightHandSide:
Restricts parentheses assignments to cases when the right-hand side of the statement is an ArrayofArrays
instance.
Code for ArrayOfArrays
Class and Error-Handling Functions
classdef ArrayOfArrays < matlab.mixin.indexing.RedefinesParen & ...
matlab.mixin.indexing.RedefinesBrace
properties (Access=private)
Arrays (1,:) cell
end
methods (Access=protected)
function varargout = braceReference(obj,indexOp)
[varargout{1:nargout}] = obj.Arrays.(indexOp);
end
function obj = braceAssign(obj,indexOp,varargin)
if isscalar(indexOp)
[obj.Arrays.(indexOp)] = varargin{:};
return;
end
[obj.Arrays.(indexOp)] = varargin{:};
end
function n = braceListLength(obj,indexOp,indexContext)
n = listLength(obj.Arrays,indexOp,indexContext);
end
function out = parenReference(obj,indexOp)
ErrorForUnsupportedIndexing(indexOp);
out = obj;
out.Arrays = obj.Arrays.(indexOp);
end
function obj = parenAssign(obj,indexOp,in)
ErrorForUnsupportedIndexing(indexOp);
ErrorForUnexpectedRightHandSide(in);
obj.Arrays.(indexOp) = in.Arrays;
end
function n = parenListLength(~,~,~)
n = 1;
end
function obj = parenDelete(obj,indexOp)
obj.Arrays.(indexOp) = [];
end
end
methods (Access=public)
function obj = ArrayOfArrays(varargin)
if nargin > 0
obj.Arrays = varargin;
else
obj.Arrays = [];
end
end
function out = cat(~,varargin)
out = ArrayOfArrays;
for ix = 1:length(varargin)
tmp = varargin{ix};
if isa(tmp,'ArrayOfArrays')
out.Arrays = [out.Arrays,tmp.Arrays];
else
out.Arrays{end+1} = tmp;
end
end
end
function varargout = size(obj,varargin)
[varargout{1:nargout}] = size(obj.Arrays,varargin{:});
end
end
methods (Static)
function out = empty()
out = ArrayOfArrays();
end
end
end
function ErrorForUnsupportedIndexing(indexOp)
if ~isscalar(indexOp)
error('Indexing after parentheses indexing is not supported.');
end
end
function ErrorForUnexpectedRightHandSide(val)
if ~isa(val,'ArrayOfArrays')
error(['Parentheses assignment is only supported when the ' ...
'right-hand side is an ArrayOfArrays.']);
end
end
Use an ArrayOfArrays
Instance
Create an ArrayOfArrays
instance with two contained arrays, a 2-element vector and a 3-by-3 matrix.
Use brace indexing to view the second contained array. The braceReference
method accepts an IndexingOperation
object that identifies what field to access.
ans = 3×3
2 0 0
0 2 0
0 0 2
Use brace and parentheses indexing to extract the upper-right corner of the matrix in the second array. The class calls the braceReference
method to access the contained array at index 2 and then forwards the parentheses indexing to the matrix itself.
Add a third element to the instance using brace assignment. The braceAssign
method accepts an IndexingOperation
object, which describes the type of indexing operation (Brace
) and the indices referenced, and a second argument that contains the value to be assigned, in this case a cell array. Verify the addition.
ans=1×2 cell array
{[1 2 3 4 5]} {[6 7 8 9 10]}
Assign multiple new values to myArrays{3}
. Because the assignment involves multiple values, MATLAB® calls the braceListLength
method to determine how many elements need to be assigned before calling braceAssign
to handle the assignment operation.
ans=1×2 cell array
{[5]} {[5]}
The customized parentheses indexing implemented by the class enables parentheses references and assignment in a similar way to how this indexing works in cell arrays. Assign the contained arrays at indices 1 and 2 of myArrays
to a new ArrayOfArrays
instance, x
. The class calls parenReference
to perform the operation. Use brace indexing to verify the contents of x
.
ans = 3×3
2 0 0
0 2 0
0 0 2