Hello,
I understand that you are looking for a way to turn your struct back into a fully initialized object, even restoring private properties.
We know that the base-class approach won’t simply work as MATLAB enforces private‑property access before run-time. But we can give set access to the base class from “Property Access List”.
classdef XmlSerializable
methods
function obj = deserialize(obj, s)
% logic
end
end
end
classdef MyClass < XmlSerializable
properties (SetAccess = ?XmlSerializable)
% Now only MyClass and XmlSerializable may read or write
privateProperty
end
end
Now the following code will work
obj = MyClass();
obj.deserialize(s);
The serialization logic can be done in the following ways:
1. for loop
fn = fieldnames(s);
for k = 1:numel(fn)
obj.(fn{k}) = s.(fn{k});
end
Here, you iterate through the field names and assign the value to the corresponding object property. Since this assignment happens inside the class’s own method, it can legally access private properties.
2. set method
You can inherit your class form "matlab.mixin.SetGet" and perform deserialization in a single line.
set(obj, ([fieldnames(s), struct2cell(s)]'){:});
This snippet converts the struct into name-value pairs using "fieldnames" and "struct2cell", and set assigns all the properties in one batch. Again, since the call happens inside the class’s namespace, private and protected access is respected.
Additionally, you can extract the deserialization logic into a reusable helper method. However, the function call still needs to happen inside each user-created class separately.
To use a helper function, define it in a file that is added to the MATLAB path.
function obj = xmlDeserialize(obj, s)
% some logic
end
Now, you can call this helper function in your class.
If you do not want to explicitly update “Property Access List” and are okay with declaring serialization inside the class itself. You can do so in the constructor, a deserialize method, or a factory method.
classdef MyClass
methods
function obj = MyClass(s) % constructor
if nargin > 0
obj = MyClass();
obj = xmlDeserialize(obj, s);
end
end
function obj = load(obj, s) % class method
obj = MyClass();
obj = xmlDeserialize(obj, s);
end
end
methods (Static)
function obj = fromStruct(s) % factory method
obj = MyClass();
obj = xmlDeserialize(obj, s);
end
end
end
You can now deserialize the struct into your class, in the following ways.
s = struct('privateProperty', 'Hello', 'publicProperty', 'World');
obj1 = MyClass(s); % constructor
obj2 = MyClass();
obj2.load(s); % class method
obj3 = MyClass.fromStruct(s); % factory method
In summary
- A base class can’t legally set private/protected properties of subclasses unless it is given explicit access from “Property Access List”.
- To deserialize private properties, each class needs to define its own loading logic
- You can either loop manually over struct fields or use set if you inherit from matlab.mixin.SetGet for deserialization logic.
- You can decouple the looping logic into a helper, but the assignment must still happen inside each class.
Hope this helped.
