Simulate C++ template in MATLAB - matlab

Question

I am trying to figure out the best way to create an alternative to the C++ template or the Java generic objects. I have wanted to do this several times in the past for several different reasons, however right now what I want to do is related to creating the saveobj and loadobj functions for several related classes. The idea is that I want to have a generic set of routines to create a default struct and then manipulate that a little bit farther to get the structs the way I want them.
I cannot simply use an external function because I need access to all the public (not a problem) and protected (problem) non-transient properties of an object in order to create the loadobj and saveobj.
Then I considered using an abstract interface. However, using an abstract interface leaves me with the same problem; identical, copy an pasted code floating around in all of my object files. So then I thought of using some sort of full blown object combined with multiple inheritance (Most of my objects are already inheriting from a basic concretion of interfaces). I thought using a superclass would allow me to expose the subclass protected properties, but it doesn't seem to work that way. Any suggestions?
Here is a sample of the multiple inheritance approach (the closest thing I have so far) for the save obj approach.
Serializer.m
% Serializer.m
classdef Serializer
methods
function [saveObj] = saveobj( obj )
% Get metadata about the Object
meta = metaclass( obj );
meta = meta.PropertyList;
for p = meta'
if p.Transient | p.Dependent
continue; % Only serialize the correct fields
end
saveobj.(p.Name) = { obj.(p.Name) }; % Serialize
end % for ( property )
end % function ( saveobj )
end % methods
end % classdef ( Serializer )
TestSerializerA.m
% TestSerializerA.m
classdef TestSerializerA < Serializer
properties
PropA = 'a';
end % properties ( public )
properties( Access = protected )
HiddenA = 'ha'
end % properties ( protected )
end % classdef ( TestSerializerA )
TestSerializerB.m
% TestSerializerB.m
classdef TestSerializerB < TestSerializerA & Serializer
properties
PropB = 'b'
end
properties( Access = protected )
HiddenB = 'hb';
end % properties ( protected )
end % classdef ( TestSerializerB )

Answer 1

Solution
You can accomplish what you are looking to do by using Access lists. You can allow the Serializer class access to any protected/private class members you would like to be serialized. This allows each class to determine on its own which of its members are serialized. Since you are allowing access to Serializer, you do not want to inherit from it. If you do, all classes in the heirarchy will have access to those members. Here is the rewritten Serializer class:
classdef Serializer
methods
function SerializedObj = serialize(~, Obj)
% Get metadata about the Object
meta = metaclass(Obj);
meta = meta.PropertyList;
for p = meta' %'
if p.Transient || p.Dependent
continue; % Only serialize the correct fields
end
try
SerializedObj.(p.Name) = { Obj.(p.Name) }; % Serialize
catch Me
% the class has chosen not to allow this property to be
% serialized. decide how to handle it.
if ~strcmp(Me.identifier, 'MATLAB:class:GetProhibited')
Me.rethrow()
end
end
end
end
end
end
Note that you can decide how you want to handle the access restrictions. In the above example, I do nothing. But you could issue a warning, throw an error, etc... .
Now, instead of inheriting from Serializer, create an abstract Serializable class, which will enable serialization.
classdef (Abstract) Serializable
properties (Access = private)
Serializer_ = Serializer()
end
methods
function savedObj = saveobj(This)
savedObj = This.Serializer_.serialize(This);
end
end
end
Now any class you wish to enable serialization on will additionally inherit from Serializable. You can specify which protected/private members the Serializer has access to.
Examples
The following class has two serializable properties, and one hidden (not serializable) property.
classdef TestSerializerA < Serializable
properties
PropA = 'a';
end
properties( Access = {?TestSerializerA, ?Serializer} )
% This property is protected and serializable
SerializableA = 'sa'
end
properties (Access = private)
% This property is private and not serializable
HiddenA = 'ha';
end
end
This is the result from MATLAB:
>> Test = TestSerializerA
Test =
TestSerializerA with properties:
PropA: 'a'
>> b = saveobj(Test)
b =
PropA: {'a'}
SerializableA: {'sa'}
The next example inherits from TestSerializerA, and has an additional two serializable properties, and one hidden property.
classdef TestSerializerB < TestSerializerA & Serializable
properties
PropB = 'b';
end
properties (Access = {?TestSerializerB, ?Serializer})
% This property is protected and serializable.
SerializableB = 'sb';
end
properties (Access = protected)
% This property is protected and not serializable.
HiddenPropB = 'hb';
end
end
Note here that re-inheriting from Serializable is unnecessary, but makes for easier to read code.
Lastly, the result from MATLAB:
>> Test = TestSerializerB
Test =
TestSerializerB with properties:
PropB: 'b'
PropA: 'a'
>> b = saveobj(Test)
b =
PropB: {'b'}
SerializableB: {'sb'}
PropA: {'a'}
SerializableA: {'sa'}
I hope this helps!