{"id":924,"date":"2012-07-05T09:42:52","date_gmt":"2012-07-04T21:42:52","guid":{"rendered":"https:\/\/www.deltics.co.nz\/blog\/?p=924"},"modified":"2012-07-05T09:43:13","modified_gmt":"2012-07-04T21:43:13","slug":"cfstringref-and-tcfstrings","status":"publish","type":"post","link":"https:\/\/www.deltics.co.nz\/blog\/posts\/924\/","title":{"rendered":"CFStringRef and TCFString(s)"},"content":{"rendered":"[Estimated Reading Time: <\/span> 4<\/span> minutes]<\/span><\/span>

In the comments on yesterdays initial post in a series following the experiences of porting an Objective-C<\/em> sample to XE2, a number of people have asked why I didn’t use the TCFString<\/strong> record type in System.Mac.CFUtils<\/strong> to get the CFStringRef references that I required. The reason is embarrassingly simple.<\/p>\n

I didn’t know about it at the time. \ud83d\ude42<\/p>\n

But now that I do, I am now curious as to how anyone does<\/em> stumble across it. Even more curious as to the experiences of people have found if\/when they use it.<\/p>\n

First of all, there is no mention of it’s contents or relevance in the XE2 documentation. There is not even a passing reference to it in the help page specifically about “Mac OS X Application Development<\/a>” or any of the linked articles discussing “Considerations for Cross-Platform Applications<\/em>“.<\/p>\n

In fact, the only mention of it is in the list of unit names and scopes<\/a>.<\/p>\n

However, being now aware of it I took a look and quickly concluded that this unit was not a serious attempt to expose these CoreFoundation<\/em> types to XE2 developers – more likely it looks like a unit that was created to prop up the FireMonkey<\/em> developers (i.e. the creators, not consumers, of the FireMonkey<\/em> framework) but not intended for general purpose use.<\/p>\n

Not only are the encapsulations incomplete they are also dangerously naive – there is a complete lack of error checking. They are essentially the XE2 equivalent of StrPCopy()<\/strong> (and when was the last time you used that?)<\/p>\n

Even if that were not the case, this sort of thing has a really, really bad smell about it to me:<\/p>\n

\r\n  var\r\n    s: String;\r\n    str: CFStringRef;\r\n  begin\r\n     :\r\n    s   := 'The quick brown fox...';\r\n    str := TCFString.Create(s).Value;\r\n     :\r\n  end;\r\n<\/pre>\n
Didn’t we just leak a TCFString<\/strong> ?<\/p>\n
No, we didn’t, because TCFString<\/strong> is a record type, not a class.  It’s just that to use this “type” we are forced to write code that smells really, really bad and is visually indistinguishable from flat out wrong code.<\/p>\n
However, inside that TCFString<\/strong> record is a CFStringRef<\/strong> value, and on the CoreFoundation<\/em> side of things we do (I think) need to call CFRelease()<\/strong> on that reference at some point.  Curiously as far as I can tell this won’t happen when the TCFString<\/strong> record is disposed and one of the omissions in the implementation of this “encapsulation” is the absence of any explicit “Release” method which you might expect to exist.  You can indicate that you want the ref to be Release’d as part of conversion to a String or a Char, but that’s it.<\/p>\n
Would You Expect Your Dog to Eat This ?<\/h3>\n
Perhaps if we look at the way this type is used within the Delphi RTL<\/em> code itself, we will get a better idea of how it should be used.  Without documentation “Use the Source” has always been a great way to learn such things, thanks to the availability of the RTL\/VCL<\/em> source code.<\/p>\n
(Apologies to users of the Starter Editions… you are expected to get “Started” without even this assistance)<\/em><\/p>\n
So let’s find a few usages of TCFString<\/strong> in the RTL\/FMX<\/em> code to look at …<\/p>\n
Oh.<\/p>\n
There’s actually only one<\/em> area where this is used at all: System.DateUtils<\/strong><\/p>\n
And it isn’t used to convert from a Delphi String<\/strong> to a CFStringRef<\/strong> but rather the exact opposite – to capture a CFStringRef<\/strong> temporarily for the purposes of converting to a Delphi String<\/strong>.<\/p>\n
Well, maybe FireMonkey<\/em> doesn’t need to do this string-type shuffle at all ?  Maybe this TCFString<\/strong> type is provided as a convenience for the rest of us but wasn’t actually needed in FMX<\/em> after all.<\/p>\n
Well, no.<\/p>\n
If we search for calls to CFRelease()<\/strong> (notably missing from TCFString<\/strong> remember) in the FMX<\/em> source, then we find numerous calls involving strings, and those strings are CFStringRef<\/strong> values that are initialised using the CoreFoundation<\/em> CFStringCreate…<\/strong> factory functions.<\/p>\n
The Real Question …<\/h3>\n
The question perhaps shouldn’t be why don’t *I* use TCFString<\/strong> for such things, but rather why don’t Embarcadero use it themselves<\/em> ?<\/p>\n
I at least have the excuse that Embarcadero didn’t tell me about it or show me how to use it.  They have no such excuse.<\/p>\n
Could You Pass the Smelling Salts Please … ?<\/h3>\n
But if the smell so far is bad, it’s about to get even worse, because in searching for “TCFString” we find that there are not one but TWO<\/em><\/strong> TCFString<\/strong> record types with this name.<\/p>\n
There is the one in System.Mac.CFUtils<\/strong> but there is also one in System.SysUtils<\/strong>.  This one is a private implementation detail to this unit and provides only a subset of the “real” TCFString<\/strong>.<\/p>\n
This is perhaps a clumsy attempt to avoid a circular unit reference or some awkward name-spacing issue with the units as the SysUtils<\/strong> unit would otherwise have to use the Mac.CFUtils<\/strong> unit which itself already uses the SysUtils<\/strong> unit ?<\/p>\n
I suspect that the developers working on SysUtils<\/strong> fell foul of the admonishment in the source to avoid adding any units to the implementation uses clause and so fell back on good old “Copy\/Paste” code re-use.<\/p>\n
Ah, progress in robust software development practices.  Who needs it ?<\/p>\n
Ironically, if instead of creating a new, undocumented unit the TCFString<\/strong> type and it’s brethren had been put in the unit that would make most sense (to me), i.e. MacAPI.CoreFoundation<\/strong>, there would have been no need for such bad odours as SysUtils<\/strong> already uses this unit.<\/p>\n
Are You Eating the Food that Embarcadero Can’t Bring Themselves to Eat?<\/h3>\n
So, I am curious – is anyone<\/em> using TCFString<\/strong> for anything other than converting CFStringRef<\/strong> values to Delphi strings, and if so, how are you finding it ?<\/p>\n","protected":false},"excerpt":{"rendered":"
[Estimated Reading Time: <\/span>  4<\/span> minutes]<\/span><\/span>In the comments on yesterdays initial post in a series following the experiences of porting an Objective-C sample to XE2, a number of people have asked why I didn’t use the TCFString record type in System.Mac.CFUtils to get the CFStringRef references that I required. The reason is embarrassingly simple.<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[4,143],"tags":[161,162,159,94,292,138],"class_list":["post-924","post","type-post","status-publish","format-standard","hentry","category-delphi","category-xe2-delphi","tag-cfstring","tag-cfstringref","tag-corefoundation","tag-cross-platform","tag-delphi","tag-osx"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_shortlink":"https:\/\/wp.me\/p1TKYv-eU","jetpack_sharing_enabled":true,"jetpack-related-posts":[],"_links":{"self":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/924","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/comments?post=924"}],"version-history":[{"count":10,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/924\/revisions"}],"predecessor-version":[{"id":934,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/924\/revisions\/934"}],"wp:attachment":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/media?parent=924"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/categories?post=924"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/tags?post=924"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}