Résultats pour

WANG Zi-Xiang
Dernière activité le 19 Déc 2025 à 21:51

How to extend table functionalities when you can’t subclass

If you use tables extensively to perform data analysis, you may at some point have wanted to add new functionalities suited to your specific applications. One straightforward idea is to create a new class that subclasses the built-in table class. You would then benefit from all inherited existing methods.

Unfortunately, as has been observed, that is not possible because the table class is Sealed.

One workaround is to create a new class that wraps a table as a Property, and re-implement all the methods that you need and are already defined for table. The is not too difficult, except for the subsref method, for which I’ll provide the code below.

Class definition

Defining a wrapper of the table class is quite straightforward. In this example, I call the class “Report” because that is what I intend to use the class for, to compute and store reports. The constructor just takes a table as input:

classdef Rapport
    methods
        function obj = Report(t)
            if isa(t, 'Report')
                obj = t;
            else
                obj.t_ = t;
            end
        end
    end
    properties (GetAccess = private, SetAccess = private)
        t_ table = table();
    end
end

I designed the constructor so that it converts a table into a Report object, but also so that if we accidentally provide it with a Report object instead of a table, it will not generate an error.

Reproducing the behaviour of the table class

Implementing the existing methods of the table class for the Report class if pretty easy in most cases.

I made use of a method called “table” in order to be able to get the data back in table format instead of a Report, instead of accessing the property t_ of the object. That method can also be useful whenever you wish to use the methods or functions already existing for tables (such as writetable, rowfun, groupsummary…).

classdef Rapport
    ...
        methods
        function t = table(obj)
            t = obj.t_;
        end
        function r = eq(obj1,obj2)
            r = isequaln(table(obj1), table(obj2));
        end
        function ind = size(obj, varargin)
            ind = size(table(obj), varargin{:});
        end
        function ind = height(obj, varargin)
            ind = height(table(obj), varargin{:});
        end
        function ind = width(obj, varargin)
            ind = width(table(obj), varargin{:});
        end
        function ind = end(A,k,n)
            % ind = end(A.t_,k,n);
            sz = size(table(A));
            if k < n
                ind = sz(k);
            else
                ind = prod(sz(k:end));
            end
        end
        end
end

In the case of horzcat (same principle for vertcat), it is just a matter of converting back and forth between the table and Report classes:

classdef Rapport
    ...
    methods
        function r = horzcat(obj1,varargin)
            listT = cell(1, nargin);
            listT{1} = table(obj1);
            for k = 1:numel(varargin)
                kth = varargin{k};
                if isa(kth, 'Report')
                    listT{k+1} = table(kth);
                elseif isa(kth, 'table')
                    listT{k+1} = kth;
                else
                    error('Input must be a table or a Report');
                end
            end
            res = horzcat(listT{:});
            r = Report(res);
        end
    end
end

Adding a new method

The plus operator already exists for the table class and works when the table contains all numeric values. It sums columns as long as the tables have the same length.

Something I think would be nice would be to be able to write t1 + t2, and that would perform an outerjoin operation between the tables and any sizes having similar indexing columns.

That would be so concise, and that's what we’re going to implement for the Report class as an example. That is called “plus operator overloading”. Of course, you could imagine that the “+” operator is used to compute something else, for example adding columns together with regard to the keys index. That depends on your needs.

Here’s a unittest example:

classdef ReportTest < matlab.unittest.TestCase
    methods (Test)
        function testPlusOperatorOverload(testCase)
            t1 = array2table( ...
                { 'Smith', 'Male'  ...
                ; 'JACKSON', 'Male' ...
                ; 'Williams', 'Female' ...
                } , 'VariableNames', {'LastName' 'Gender'} ...
                );
            t2 = array2table( ...
                { 'Smith', 13  ...
                ; 'Williams', 6 ...
                ; 'JACKSON', 4 ...
                }, 'VariableNames', {'LastName' 'Age'} ...
                );
            r1 = Report(t1);
            r2 = Report(t2);
            tRes = r1 + r2;
            tExpected = Report( array2table( ...
                { 'JACKSON' , 'Male', 4 ...
                ; 'Smith'   , 'Male', 13  ...
                ; 'Williams', 'Female', 6 ...
                } , 'VariableNames', {'LastName' 'Gender' 'Age'} ...
                ) );
            testCase.verifyEqual(tRes, tExpected);
        end
    end
end

And here’s how I’d implement the plus operator in the Report class definition, so that it also works if I add a table and a Report:

classdef Rapport
    ...
    methods
        function r = plus(obj1,obj2)
            table1 = table(obj1);
            table2 = table(obj2);
            result = outerjoin(table1, table2 ...
                , 'Type', 'full', 'MergeKeys', true);
            r = reportingits.dom.Rapport(result);
        end
    end
end

The case of the subsref method

If we wish to access the elements of an instance the same way we would with regular tables, whether with parentheses, curly braces or directly with the name of the column, we need to implement the subsref and subsasgn methods. The second one, subsasgn is pretty easy, but subsref is a bit tricky, because we need to detect whether we’re directing towards existing methods or not.

Here’s the code:

classdef Rapport
    ...
    methods
        function A = subsasgn(A,S,B)
            A.t_ = subsasgn(A.t_,S,B);
        end
        function B = subsref(A,S)
            isTableMethod = @(m) ismember(m, methods('table'));
            isReportMethod = @(m) ismember(m, methods('Report'));
            switch true
                case strcmp(S(1).type, '.') && isReportMethod(S(1).subs)
                    methodName = S(1).subs;
                    B = A.(methodName)(S(2).subs{:});
                    if numel(S) > 2
                        B = subsref(B, S(3:end));
                    end
                case strcmp(S(1).type, '.') && isTableMethod (S(1).subs)
                    methodName = S(1).subs;
                    if ~isReportMethod(methodName)
                        error('The method "%s" needs to be implemented!', methodName)
                    end
                otherwise
                    B = subsref(table(A),S(1));
                    if istable(B)
                        B = Report(B);
                    end
                    if numel(S) > 1
                        B = subsref(B, S(2:end));
                    end
            end
        end
    end
end

Conclusion

I believe that the table class is Sealed because is case new methods are introduced in MATLAB in the future, the subclass might not be compatible if we created any or generate unexpected complexity.

The table class is a really powerful feature.

I hope this example has shown you how it is possible to extend the use of tables by adding new functionalities and maybe given you some ideas to simplify some usages. I’ve only happened to find it useful in very restricted cases, but was still happy to be able to do so.

In case you need to add other methods of the table class, you can see the list simply by calling methods(’table’).

Feel free to share your thoughts or any questions you might have! Maybe you’ll decide that doing so is a bad idea in the end and opt for another solution.

Filter By

Channel ClearFilters

Résultats pour