{"id":916,"date":"2017-04-04T14:18:26","date_gmt":"2017-04-04T18:18:26","guid":{"rendered":"https:\/\/blogs.mathworks.com\/developer\/?p=916"},"modified":"2017-04-04T16:09:59","modified_gmt":"2017-04-04T20:09:59","slug":"properties-of-properties","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/developer\/2017\/04\/04\/properties-of-properties\/","title":{"rendered":"Properties of properties"},"content":{"rendered":"

A while ago we discussed a good reason to appreciate and use MATLAB's model for properties. It had to do with encapsulation if you remember<\/a>, and we discussed how MATLAB's properties are inherently encapsulated, preventing the need to write a bunch of boiler plate setters and getters.<\/p>

There's more goodness where that came from! Another reason to use MATLAB's properties is to benefit directly from the fact that everything in MATLAB is considered an array that can be sliced and diced however you please.<\/p>

The beauty if MATLAB is in its simplicity of handling arrays. Rather than requiring some external container like a List<\/tt> or a Vector<\/tt> of something, everything is inherently already a list and a vector! With this you can be free to vectorize to your heart's content, as well as index into your array using the powerful MATLAB syntax we all know and love.<\/p>

This gets us back to object properties. If you use properties instead of setter and getter methods you benefit from all this indexing sugar for free.<\/p>

Pulling on strings<\/b><\/p>

Case in point: Let's say we love the new string class in MATLAB. After all what's not to love? The new MATLAB strings are rational and array oriented, opening us to fast and powerful manipulation techniques. A quick point is that we can indeed leverage this \"arrayness\" directly in the string class itself without writing our own object code. For example, if you wanted to quickly do some manipulation on a given string in order to get your priorities straight you can do so quite easily. Let's start by creating a string scalar:<\/p>

openingLine = \"It was the best of times it was the worst of times\"<\/span>\r\n<\/pre>
\r\nopeningLine = \r\n\r\n    \"It was the best of times it was the worst of times\"\r\n\r\n<\/pre>
This is great, we can operate on this as a single string rather than the old character vector approach where each character is an element of the array. However, right now, I'd like to operate on this as an array of words, so let's split it up:<\/p>
openingLine = split(openingLine)\r\n<\/pre>
\r\nopeningLine = \r\n\r\n  12×1 string array\r\n\r\n    \"It\"\r\n    \"was\"\r\n    \"the\"\r\n    \"best\"\r\n    \"of\"\r\n    \"times\"\r\n    \"it\"\r\n    \"was\"\r\n    \"the\"\r\n    \"worst\"\r\n    \"of\"\r\n    \"times\"\r\n\r\n<\/pre>
Now that this is an array of words, we can easily have it conform to our nefarious demands! We can replace \"times\" with \"blogs\" simply using the power of indexing:<\/p>
openingLine(contains(openingLine, \"times\"<\/span>)) = \"blogs\"<\/span>\r\n<\/pre>
\r\nopeningLine = \r\n\r\n  12×1 string array\r\n\r\n    \"It\"\r\n    \"was\"\r\n    \"the\"\r\n    \"best\"\r\n    \"of\"\r\n    \"blogs\"\r\n    \"it\"\r\n    \"was\"\r\n    \"the\"\r\n    \"worst\"\r\n    \"of\"\r\n    \"blogs\"\r\n\r\n<\/pre>
Note for MATLAB strings the replace<\/tt> function is actually easier than this, but I wanted to show the broader context of array indexing. In practice with strings we should use replace<\/tt>.<\/p>
openingLine = \"It was the best of times it was the worst of times\"<\/span>\r\nopeningLine = split(openingLine)\r\nopeningLine = replace(openingLine, \"times\"<\/span>, \"blogs\"<\/span>)\r\n<\/pre>
\r\nopeningLine = \r\n\r\n    \"It was the best of times it was the worst of times\"\r\n\r\n\r\nopeningLine = \r\n\r\n  12×1 string array\r\n\r\n    \"It\"\r\n    \"was\"\r\n    \"the\"\r\n    \"best\"\r\n    \"of\"\r\n    \"times\"\r\n    \"it\"\r\n    \"was\"\r\n    \"the\"\r\n    \"worst\"\r\n    \"of\"\r\n    \"times\"\r\n\r\n\r\nopeningLine = \r\n\r\n  12×1 string array\r\n\r\n    \"It\"\r\n    \"was\"\r\n    \"the\"\r\n    \"best\"\r\n    \"of\"\r\n    \"blogs\"\r\n    \"it\"\r\n    \"was\"\r\n    \"the\"\r\n    \"worst\"\r\n    \"of\"\r\n    \"blogs\"\r\n\r\n<\/pre>
Make it your own<\/b><\/p>
Alright, vectorization and indexing are powerful in the MATLAB environment, but how do we leverage this in our own objects? The answer is to use properties! Let's say we want to create our own fancy<\/i> string class which adds to the capabilities of the string class we see in MATLAB. Perhaps we want to keep the underlying text content of the string pure an unchanged, but we want to add specific meta-data to individual elements. For example, in environments that support hyperlinks (like the MATLAB command window) I may want to add a hyperlink, but I don't want this hyperlink to modify the real text content. Maybe I'd like to print that to a text file and the hyperlink would get in the way. Let's look at how we can do this, and benefit from the indexing behavior of MATLAB's properties.<\/p>
First, we should create our FancyString<\/tt> class. Note we leverage composition over inheritance (remember<\/a>?) and we hold on to the \"plain\" string. However, the constructor passes all values through to the string constructor so that it feels like a normal string. Note we can also add converter methods for char, string, and cellstr so that we can combine these values together effortlessly.<\/p>
\r\nclassdef<\/span> FancyString \r\n    \r\n    properties<\/span>\r\n        PlainValue\r\n    end<\/span>\r\n\r\n    \r\n    methods<\/span>\r\n        function<\/span> fancyString = FancyString(varargin)\r\n            if<\/span> nargin < 1\r\n                % Supporting a zero argument constructor allows us to<\/span>\r\n                % preallocate. This is very powerful when creating arrays.<\/span>\r\n                % Note this constructor itself preallocates below.<\/span>\r\n                return<\/span> \r\n            end<\/span>\r\n                        \r\n            % Create the plain string<\/span>\r\n            plainValue = string(varargin{:}); \r\n            % Create the array of FancyStrings to match. <\/span>\r\n            fancyString(numel(plainValue)) = FancyString; \r\n\r\n            % Each element of this FancyString array holds onto (composes)<\/span>\r\n            % a regular string scalar. Send each element of the string<\/span>\r\n            % array to each element of the FancyString array<\/span>\r\n            plainValueCell = num2cell(plainValue);\r\n            [fancyString.PlainValue] = deal(plainValueCell{:});\r\n        end<\/span>\r\n            \r\n        function<\/span> c = char(fancyString) % Allow conversion from char<\/span>\r\n            c = char(fancyString.PlainValue);\r\n        end<\/span>\r\n        function<\/span> c = cellstr(fancyString) % Allow conversion from cellstrs<\/span>\r\n            c = cellstr({fancyString.PlainValue});\r\n        end<\/span>\r\n        function<\/span> s = string(fancyString) % Allow conversion from strings<\/span>\r\n            s = [fancyString.PlainValue];\r\n        end<\/span>\r\n    end<\/span>\r\nend<\/span>\r\n\r\n<\/pre>
Does this work? Let's try it out with our string<\/p>
fancyString = FancyString(openingLine);\r\n[fancyString.PlainValue]'\r\n<\/pre>
\r\nans = \r\n\r\n  12×1 string array\r\n\r\n    \"It\"\r\n    \"was\"\r\n    \"the\"\r\n    \"best\"\r\n    \"of\"\r\n    \"blogs\"\r\n    \"it\"\r\n    \"was\"\r\n    \"the\"\r\n    \"worst\"\r\n    \"of\"\r\n    \"blogs\"\r\n\r\n<\/pre>
Alright, so far so good. Now we can start adding our fanciness! What I'd like to do is add the ability to decorate each string element with a decorator, and introduce the notion of a decorated value of the string. It is here I'd like to add the hyperlinks. Then, when I want to send the output to the Command Window I send the decorated value, but when I want to send the output to a text file I print the plain text. First's let's add the notion of a default decorator<\/i>, which does nothing when decorated:<\/p>
\r\nclassdef<\/span> DefaultDecorator\r\n    \r\n    methods<\/span>\r\n        function<\/span> decoratedString = decorate(~, undecoratedString)\r\n            decoratedString =  undecoratedString;\r\n        end<\/span>\r\n    end<\/span>       \r\n\r\nend<\/span>\r\n\r\n<\/pre>
Now let's add a hyperlink decorator which decorates the string with a hyperlink tag. In this case we need the link target, but the link text should be taken as the value of the underlying string. I love how we can simply add these strings together to do this decoration!<\/p>
\r\nclassdef<\/span> HyperlinkDecorator\r\n   \r\n    properties<\/span>\r\n        LinkTarget\r\n    end<\/span>\r\n    \r\n    methods<\/span>\r\n        function<\/span> decorator = HyperlinkDecorator(linkTarget)\r\n            decorator.LinkTarget = linkTarget;\r\n        end<\/span>\r\n        function<\/span> decoratedString = decorate(decorator, undecoratedString)\r\n            decoratedString = \"<a href=\"\"\"<\/span> + decorator.LinkTarget + \"\"\">\"<\/span> + undecoratedString + \"<\/a>\"<\/span>;\r\n        end<\/span>\r\n    end<\/span>       \r\n    \r\n    \r\nend<\/span>\r\n\r\n<\/pre>
Alright, we are now set with our two decorators, let's use them with the FancyString:<\/p>
\r\nclassdef<\/span> FancyString \r\n    \r\n    properties<\/span>\r\n        PlainValue\r\n        \r\n        % Each element uses the \"do nothing\" decorator by default<\/span>\r\n        Decorator = DefaultDecorator; \r\n    end<\/span>\r\n    \r\n    properties<\/span>(Dependent)\r\n        DecoratedValue\r\n    end<\/span>\r\n    \r\n    \r\n    methods<\/span>\r\n        function<\/span> fancyString = FancyString(varargin)\r\n            if<\/span> nargin < 1\r\n                return<\/span>\r\n            end<\/span>\r\n                        \r\n            plainValue = string(varargin{:});\r\n            fancyString(numel(plainValue)) = FancyString;\r\n\r\n            plainValueCell = num2cell(plainValue);\r\n            [fancyString.PlainValue] = deal(plainValueCell{:});\r\n        end<\/span>\r\n\r\n        function<\/span> decorated = get.DecoratedValue(fancyString)\r\n            % The decorated value returns whatever the decorator adds to<\/span>\r\n            % the plain string.<\/span>\r\n            decorated = fancyString.Decorator.decorate(fancyString.PlainValue);\r\n        end<\/span>\r\n            \r\n        function<\/span> c = char(fancyString)\r\n            c = char(fancyString.PlainValue);\r\n        end<\/span>\r\n        function<\/span> c = cellstr(fancyString)\r\n            c = cellstr({fancyString.PlainValue});\r\n        end<\/span>\r\n        function<\/span> s = string(fancyString)\r\n            s = [fancyString.PlainValue];\r\n        end<\/span>\r\n    end<\/span>\r\nend<\/span>\r\n\r\n<\/pre>
We've added a Decorator<\/tt> property as well as a dependent DecoratedValue<\/tt> property. Since MATLAB is built for arrays this property is inherently array oriented. Each element of the FancyString has it's own Decorator. Also, when we access the DecoratedValue<\/tt> property on the array, each element of the array get's it own call to the get.DecoratedValue<\/tt> function to return the correct property. Let's see this beauty in action.<\/p>
First we can create the FancyString<\/tt> again, but this time add a decorator to make it interesting. Let's add a hyperlink to the blog everywhere we see the word \"blogs\" in the plain value.<\/p>
fancyString = FancyString(openingLine);\r\n[fancyString(contains([fancyString.PlainValue], \"blogs\"<\/span>)).Decorator] = deal(HyperlinkDecorator(\"https:\/\/blogs.mathworks.com\/developer\"<\/span>));\r\n<\/pre>
Using MATLAB properties when writing the class, we've just leveraged indexing to add the desired hyperlink to those elements of the FancyString<\/tt> that contain the word blogs. Did it work?<\/p>
decoratedValue = join([fancyString.DecoratedValue])\r\ndecorator = fancyString(end).Decorator\r\n<\/pre>
\r\ndecoratedValue = \r\n\r\n    \"It was the best of blogs<\/a> it was the worst of blogs<\/a>\"\r\n\r\n\r\ndecorator = \r\n\r\n  HyperlinkDecorator with properties:\r\n\r\n    LinkTarget: \"https:\/\/blogs.mathworks.com\/developer\"\r\n\r\n<\/pre>
\"\" <\/p>
Note the real underlying string is still available, unchanged and ready to display as well<\/p>
plainValue = join([fancyString.PlainValue])\r\n<\/pre>
\r\nplainValue = \r\n\r\n    \"It was the best of blogs it was the worst of blogs\"\r\n\r\n<\/pre>
Are you leveraging MATLAB properties effectively in your MATLAB objects? Are you leveraging the inherent benefits of their arrayness? Do tell!<\/p>