Reverse-engineering MAT-files
Part 3: Classes with attributes

In part 2 of this series we discovered how simple classes are stored in MAT v7.3. We did so by looking at a few very simple classes and examining how our MAT-file changes when we, say, alter the class structure a bit, or when we add more objects of the same class.

The simple examples we considered merely scratch the surface of what is possible in MATLAB’s class system. MATLAB supports many features typical of an object-oriented programming language, such as abstract classes, inheritance, private and protected attributes, operator overloading, and so on and so forth.

Luckily for us, most of these features do not seem to influence the way that MATLAB stores the object in a MAT-file. There are, however, a few exceptions to this, and the goal of this post is to highlight these exceptions.

More concretely, we will look at classes exhibiting the following features:

• Default values
• Constant and dependent values
• Properties with specified type and/or size

Preliminary: Arrays of classes

Before looking at classes, we need to talk about arrays.

Arrays of primitive objects such as doubles and chars are stored in a straightforward way. Consider the following example.

>> x = rand(1, 2, 3);
>> save('out.mat', 'x', '-v7.3');

Our MAT-file consists of a single 🔢 dataset x:

julia> read(h["x"])
1×2×3 Array{Float64, 3}:
[:, :, 1] =
 0.815771  0.804843

[:, :, 2] =
 0.360404  0.913814

[:, :, 3] =
 0.288316  0.165002

The only exception to this logic is if our array has size zero in some dimension. In MATLAB, an ‘empty’ array of size 3 by 0 is different from an array of size 0 by 3. Yet we evidently cannot distinguish them by their content, since there is no content! Here’s what MATLAB does instead.

>> x = rand(9001, 0, 9002);
>> save('out.mat', 'x', '-v7.3');

julia> read(h["x"])
3-element Vector{UInt64}:
 0x0000000000002329
 0x0000000000000000
 0x000000000000232a

If at least one of the sizes of an array is zero, MATLAB does a ‘fallback’ by saving the size of the array in the form of 64-bit integers.^{Note 1} The type that the elements would have had if there were elements can be inferred from the MATLAB_class attribute. This allows us to distinguish, for instance, a 3×0 character array from a 3×0 array of doubles.

Now what would happen if we take say a 1×2×3 array of objects?

We define the following simple class which we’ll use throughout this post.

classdef MyClass
   properties
       Foo
   end
   methods
       function obj = MyClass(x)
           obj.Foo = x;
       end
   end
end

Now consider the following:

x = [MyClass(9001) MyClass(9002) MyClass(9003) MyClass(9004) MyClass(9005) MyClass(9006)];
x = reshape(x, 1, 2, 3);
save('out.mat', 'x', '-v7.3');

So far, our classes had always been represented by a length-six vector of integers, of which the last two encode object ID and class ID. So should we now expect a 6×1×2×3 array of integers instead?

julia> read(h["x"])
12×1 Matrix{UInt32}:
 0xdd000000
 0x00000003
 0x00000001
 0x00000002
 0x00000003
 0x00000001
 0x00000002
 0x00000003
 0x00000004
 0x00000005 
 0x00000006
 0x00000001

This is altogether different. For convenience, I’ve indicated in mint a new component which we haven’t elaborated on before. This component indicates the size of the array of objects. Specifically, it tells us that we’re dealing with a 3-dimensional array of size 1×2×3. After that, the object ID of each object in the array is listed in column-major order, and finally, we specify the class ID of the objects.

Until this point, objects have always been represented with six integers, of which the first four seemed fixed. In hindsight, you’ll be able to recognise that the second, third and fourth integer simply told us that the object was a 2-dimensional array of size 1×1.

Before moving on to the next section, I leave you with one example. Can you guess how MATLAB encodes the following? For a hint, see Note 2.

>> x = MyClass.empty; % This returns a 0×0 array of objects of type MyClass
>> save('out.mat', 'x', '-v7.3');

Default values

Consider the following class.

classdef MyClassWithDefault
   properties
       Bar = MyClass(9001)
   end
end

As you’d probably expect, if I create a variable x = MyClassWithDefault(), the field Bar will obtain the default value MyClass(9001).

Let’s take a look at the MAT-file that we get upon saving x.

🗂️ HDF5.File: (read-only) out.mat
├─ 📂 #refs#
│  ├─ 🔢 a
│  │  ├─ 🏷️ MATLAB_class
│  │  └─ 🏷️ MATLAB_empty
│  ├─ 🔢 b
│  │  ├─ 🏷️ H5PATH
│  │  └─ 🏷️ MATLAB_class
│  ├─ 🔢 c
│  │  ├─ 🏷️ H5PATH
│  │  └─ 🏷️ MATLAB_class
│  ├─ 🔢 d
│  │  ├─ 🏷️ H5PATH
│  │  └─ 🏷️ MATLAB_class
│  ├─ 🔢 e
│  │  ├─ 🏷️ H5PATH
│  │  └─ 🏷️ MATLAB_class
│  ├─ 🔢 f
│  │  ├─ 🏷️ H5PATH
│  │  ├─ 🏷️ MATLAB_class
│  │  └─ 🏷️ MATLAB_empty
│  ├─ 📂 g
│  │  ├─ 🏷️ H5PATH
│  │  ├─ 🏷️ MATLAB_class
│  │  └─ 🔢 Bar
│  │     ├─ 🏷️ H5PATH
│  │     └─ 🏷️ MATLAB_class
│  └─ 🔢 h
│     ├─ 🏷️ H5PATH
│     ├─ 🏷️ MATLAB_class
│     └─ 🏷️ MATLAB_empty
├─ 📂 #subsystem#
│  └─ 🔢 MCOS
│     ├─ 🏷️ MATLAB_class
│     └─ 🏷️ MATLAB_object_decode
└─ 🔢 x
   ├─ 🏷️ MATLAB_class
   └─ 🏷️ MATLAB_object_decode