Discussions

MATLABs Constant properties can be rather difficult to deal with at times. For those unfamiliar there are two distinct behaviors when accessing constant properties of a class. If a "static" pattern is used ClassName.PropName the the value, as it was assigned to the property is returned; that is to say that you will have a nargout of 1. But, rather frustratingly, if an instance of the class is used when accessing the constant property, such as ArrayOfClassName.PropName then your nargout will be equivalent to the number of elements in the array; this means that functionally the constant property accessing scheme is identical to that of the element wise properties you find on "instance" properties.

This can be frustraing since constant properties are conceptually designed to tie data to a class. You could see this design pattern being useful where a super class were to define an abstract constant property, that would drive the behavior of subclasses; the subclasses define the value of the property and the super class uses it. I would like to use this design to develop a custom display "MatrixDisplay" focused mixin (like the internal matlab.mixin.internal.MatrixDisplay). The idea is that missing element labels, invalid handle element labels, and other semantic values can be configured by the subclasses, conveniently just by setting the constant properties; these properties will be used by the super class to substitute the display strings of appropriate elements. Most of the processing will happen within the super class as to enable simple, low-investment, opt-in display options for array style classes.

The issue is that you can not rely on constant property access to return the appropriate value when the instance you've been passed is empty. This also happens with excessive outputs when the instance is non-scalar, but those extra values from the CSL are just ignored, while Id imagine there is an effect on performance from generating the excess outputs (assuming theres no internal optimization for the unused outputs), this case still functions appropriately. As I enjoying exploring MATLAB, I found an internal indexing mixing class in the past that provides far greater control of do indexing; I've done a good deal of neat things with it, though at the cost of great overhead when getting implementing cool "proof of concept/showcase" examples. Today I used it to quickly implement a mix in that "fixes" constant properties such that they always return as though they were called statically from the class name, as opposed to an instance.

To do this I just intercepted the property indexing, checked if it was constant, and used the DefaultValue property of the metadata to return the value. This works nicely since we are required to attempt to initialize a "dummy" scalar array, or generate a function handle; both of those would likely be slower, and in the former case, may not be possible depending on the subclass implementation. It is worth noting that this method of querying the value from metadata is safe because constant properties are immutable and thus must be established as the class is loaded. Below is the small utility class I have implemented to get predictable constant variable access into classes that benefit from it. Lastly it is worth noting that I've not torture testing the rerouting of the indexing we aren't intercepting, in my limited play its behaved as expected but it may be worth looking over if you end up playing around with this and notice abnormal property assignment or reading from non-constant properties.

classdef(Abstract, HandleCompatible) ConstantProperty < matlab.mixin.internal.indexing.RedefinesDotProperties

%ConstantProperty Returns instance indexed constant properties as though they were statically indexed.

% This class overloads property access to check if the indexed property is constant and return it properly.

%% Property membership utility methods

methods(Access=private)

function [isConst, isProp] = isConstantProp(obj, prop, options)

%isConstantProp Determine if the input property names are constant properties of the input

arguments

obj mixin.ConstantProperty;

prop string;

options.Flatten (1, 1) logical = false;

end

% Store the cache to avoid rechecking string membership and parsing metadata

persistent class_cache

% Initialize cache for all subclasses to maintain their own caches

if(isempty(class_cache))

class_cache = configureDictionary("string", "dictionary");

end

% Gather the current class being analyzed

classname = string(class(obj));

% Check if the current class has a cache, if not make one

if(~isKey(class_cache, classname))

class_cache(classname) = configureDictionary("string", "struct");

end

% Alias the current classes cache

prop_cache = class_cache(classname);

% Check which inputs are already cached

isCached = isKey(prop_cache, prop);

% Add any values that have yet to be cached to the cache

if(any(~isCached, "all"))

% Flatten cache additions

props = row(prop(~isCached));

% Gather the meta-property data of the input object and determine if inputs are listed properties

mc_props = metaclass(obj).PropertyList;

% Determine which properties are keys

[isConst, idx] = ismember(props, string({mc_props.Name}));

idx = idx(isConst);

% Check which of the inputs are constant properties

isConst = repmat(isConst, 2, 1);

isConst(1, isConst(1, :)) = [mc_props(idx).Constant];

% Parse the results into structs for caching

cache_values = cell2struct(num2cell(isConst), ["isConst"; "isProp"]);

prop_cache(props) = row(cache_values);

% Re-sync the cache

class_cache(classname) = prop_cache;

end

% Extract results from the cache

values = prop_cache(prop);

if(options.Flatten)

% Split and reshape output data

sz = size(prop);

isConst = reshape(values.isConst, sz);

isProp = reshape(values.isProp, sz);

else

isConst = struct2cell(values);

end

function [isConst, isProp] = isConstantIdxOp(obj, idxOp)

%isConstantIdxOp Determines if the idxOp is referencing a constant property.

arguments

obj mixin.ConstantProperty;

idxOp (1, :) matlab.indexing.IndexingOperation;

end

import matlab.indexing.IndexingOperationType;

if(idxOp(1).Type == IndexingOperationType.Dot)

[isConst, isProp] = isConstantProp(obj, idxOp(1).Name);

else

[isConst, isProp] = deal(false);

end

function A = getConstantProperty(obj, idxOp)

%getConstantProperty Returns the value of a constant property using a static reference pattern.

arguments

obj mixin.ConstantProperty;

idxOp (1, :) matlab.indexing.IndexingOperation;

end

A = findobj(metaclass(obj).PropertyList, "Name", idxOp(1).Name).DefaultValue;

end

%% Dot indexing methods

methods(Access = protected)

function A = dotReference(obj, idxOp)

arguments(Input)

obj mixin.ConstantProperty;

idxOp (1, :) matlab.indexing.IndexingOperation;

end

arguments(Output, Repeating)

A

end

% Force at least one output

N = max(1, nargout);

% Check if the indexing operation is a property, and if that property is constant

[isConst, isProp] = isConstantIdxOp(obj, idxOp);

if(~isProp)

% Error on invalid properties

throw(MException( ...

"JB:mixin:ConstantProperty:UnrecognizedProperty", ...

"Unrecognized property '%s'.", ...

idxOp(1).Name ...

));

elseif(isConst)

% Handle forwarding indexing operations

if(isscalar(idxOp))

% Direct assignment

[A{1:N}] = getConstantProperty(obj, idxOp);

else

% First extract constant property then forward indexing operations

tmp = getConstantProperty(obj, idxOp);

[A{1:N}] = tmp.(idxOp(2:end));

end

else

% Handle forwarding indexing operations

if(isscalar(idxOp))

% Unfortunately we can't just recall obj.(idxOp) to use default/built-in so we manually extract

[A{1:N}] = obj.(idxOp.Name);

else

% Otherwise let built-in handling proceed

tmp = obj.(idxOp(1).Name);

[A{1:N}] = tmp.(idxOp(2:end));

end

function obj = dotAssign(obj, idxOp, values)

arguments(Input)

obj mixin.ConstantProperty;

idxOp (1, :) matlab.indexing.IndexingOperation;

end

arguments(Input, Repeating)

values

end

% Handle assignment based on presence of forward indexing

if(isscalar(idxOp))

% Simple broadcasted assignment

[obj.(idxOp.Name)] = deal(values{:});

else

% Initialize the intermediate values and expand the values for assignment

tmp = {obj.(idxOp(1).Name)};

[tmp.(idxOp(2:end))] = deal(values{:});

% Reassign the modified data to the output object

[obj.(idxOp(1).Name)] = deal(tmp{:});

end

function n = dotListLength(obj, idxOp, idxCnt)

arguments(Input)

obj mixin.ConstantProperty;

idxOp (1, :) matlab.indexing.IndexingOperation;

idxCnt (1, :) matlab.indexing.IndexingContext;

end

if(isConstantIdxOp(obj, idxOp))

if(isscalar(idxOp))

% Constant properties will also be 1

n = 1;

else

% Checking forwarded indexing operations on the scalar constant property

n = listLength(obj.(idxOp(1).Name), idxOp(2:end), idxCnt);

end

else

% Check the indexing operation normally

% n = listLength(obj, idxOp, idxCnt);

n = numel(obj);

end

Filter By

Channel

Results for

MATLAB Constant Properties