How to overload subsref / numArgumentsFromSubscript for functions which have zero output arguments?

Question

I would like to have a class which wraps up a containers.Map. In addition, I want to be able use () indexing to access the sub-map from the parent class, for example:

>> map = containers.Map('Foo', 'Bar');
>> ex = Example(map);
>> ex('Foo')

ans =

Bar

The code for this is below, and it works well. The only problem I am having is with other methods defined on the class. According to the docs, I understand I need to override numArgumentsFromSubscript (somehow?) to help nargout. My crude attempt at simply using numel(obj) as I've seen mentioned online works in most cases, but not when the function you are calling has no output arguments (in which case numel(obj) == 1 ~= 0).

Using the example code below,

>> ex.outGoodbye

ans =

Goodbye

Great! However,

>> ex.sayHello
Error using Example/sayHello
Too many output arguments.

Error in Example/subsref (line 17)
                 [varargout{1:nargout}] = builtin('subsref', obj, struct);

How can you fix this?

classdef Example
    % =====================================================================
    properties
        map
    end
    % =====================================================================
    methods
        % -----------------------------------------------------------------
        function obj = Example(map)
            obj.map = map;
        end
        % -----------------------------------------------------------------
        function varargout = subsref(obj, struct)
            if strcmp(struct(1).type, '()')
                 [varargout{1:nargout}] = builtin('subsref', obj.map, struct);
            else
                 [varargout{1:nargout}] = builtin('subsref', obj, struct);
            end
        end
        % -----------------------------------------------------------------
        function n = numArgumentsFromSubscript(obj, struct, indexingContext)
            n = numel(obj); % Necessary to overload subsref - for some reason
        end
        % -----------------------------------------------------------------
        function obj = subsasgn(obj, struct, varargin)
            if strcmp(struct(1).type, '()')
                obj = builtin('subsasgn', obj.map, struct, varargin{:});
                obj = Example(obj);
            else
                obj = builtin('subsasgn', obj, struct, varargin{:});
            end
        end
        % -----------------------------------------------------------------
        function sayHello(obj)
            disp('Hello'); % nargout == 0. Does NOT work
        end
        % -----------------------------------------------------------------
        function out = outGoodbye(obj)
            out = 'Goodbye'; % nargout > 0. Works
        end
        % -----------------------------------------------------------------
    end
    % =====================================================================
end

Answer 1

So digging into this a little further, you have a few options for how to get around this behavior.

method(obj) Calling Convention

You could simply change the way that you're calling the class method. Instead of using the dot notation, you could simply use the standard function notation.

sayHello(ex)

%// vs.

ex.sayHello()

This will avoid calling subsref when calling a method. Also, this is actually the fastest way to call a method of a class in the current iteration of MATLAB's OOP. Additionally, this would require no changes to your current code.

Use nargout to determine number of method outputs

Another option is to add a special case in subsref or numArgumentsFromSubscript that looks for methods called using the dot notation. Then you can explicitly determine the number of output arguments of the method using the following call to nargout.

nArgs = nargout('classname>classname.methodname');

Then you would use that rather than numel(obj). This could be implemented in either numArgumentsFromSubscript or subsref.

numArgumentsFromSubscript

function n = numArgumentsFromSubscript(obj, struct, indexingContext)
    %// Check if we are calling obj.method
    if strcmp(struct(1).type, '.') && ...
        ischar(struct(1).subs) && ismember(struct(1).subs, methods(obj))

        %// Determine the package (if any)
        cls = class(obj);
        parts = regexp(cls, '\.', 'split');

        %// Import the package (if any) just into the namespace of this method
        if numel(parts) > 1
            import(cls);
        end

        %// Determine number of outputs for this method
        n = nargout(sprintf('%s>%s.%s', parts{[end end]}, struct(1).subs));
    else
        %// Default to numel(obj)
        n = numel(obj);
    end
end

subsref

function varargout = subsref(obj, struct)
    if strcmp(struct(1).type, '()')
         [varargout{1:nargout}] = builtin('subsref', obj.map, struct);

    %// Check if we are calling obj.method
    elseif strcmp(struct(1).type, '.') && ...
           ischar(struct(1).subs) && ismember(struct(1).subs, methods(obj))

        %// Determine the package (if any)
        cls = class(obj);
        parts = regexp(cls, '\.', 'split');

        %// Import the package (if any) just into the namespace of this method
        if numel(parts) > 1
            import(cls);
        end

        %// Determine number of outputs for this method
        nout = nargout(sprintf('%s>%s.%s', parts{[end end]}, struct(1).subs));         

        %// Call builtin subsref with this number of outputs
        [varargout{1:nout}] = builtin('subsref', obj, struct);

    else
        [varargout{1:nargout}] = builtin('subsref', obj, struct);
    end
end

Summary

subsref is a pain and a lot of times you end up with a lot of logic to determine what is being called and you'll be right only about 80% of the time. I think that the first approach is the most straightforward, would likely be the most performant (you skip all of the checks in subsref) and deals better with arrays of objects.

If you really wanted to keep the obj.method notation, I would probably recommend changing numArgumentsFromSubscript (rather than subsref) to keep the number of output argument stuff in one place.

Update

Based upon your feedback that the nargout trick doesn't work in cases where the class is contained within a package (foo.bar.Example). I have added a workaround to the above examples. The trick is to call import('foo.bar.Example') prior to calling nargout('Example>Example.sayHello').