{"id":507,"date":"2009-09-14T23:21:02","date_gmt":"2009-09-14T11:21:02","guid":{"rendered":"https:\/\/www.deltics.co.nz\/blog\/?p=507"},"modified":"2009-09-14T23:30:40","modified_gmt":"2009-09-14T11:30:40","slug":"mind-the-gaps","status":"publish","type":"post","link":"https:\/\/www.deltics.co.nz\/blog\/posts\/507\/","title":{"rendered":"Mind the Gap(s)"},"content":{"rendered":"[Estimated Reading Time: <\/span> 4<\/span> minutes]<\/span><\/span>

This is what I love about Delphi. \u00a0After almost 15 years of Delphi’ing there’s still new things to learn, and I don’t just mean new features in the latest releases. \u00a0I mean, basic, fundamental things that have been there for years, just undiscovered (by me). \u00a0In this case the discovery was a little annoying, but never-the-less\u00a0educational.<\/p>\n

<\/p>\n

In the case in question I was creating some library code for myself to help with some resource manipulation code that I have in mind. \u00a0As part of this I wanted an enum type to represent the normal resource types found in Windows code:<\/p>\n

\r\n  type\r\n    TResourceType = (\r\n                      rtCURSOR = 1,\r\n                      rtBITMAP,\r\n                      rtICON,\r\n                      rtMENU,\r\n                      rtDIALOG,\r\n                      rtSTRING,\r\n                      rtFONTDIR,\r\n                      rtFONT,\r\n                      rtACCELERATOR,\r\n                      rtRCDATA,\r\n                      rtMESSAGETABLE,\r\n                      rtGROUP_CURSOR,\r\n                      rtGROUP_ICON = 14,\r\n                      rtVERSION = 16,\r\n                      rtDLGINCLUDE,\r\n                      rtPLUGPLAY = 19,\r\n                      rtVXD,\r\n                      rtANICURSOR,\r\n                      rtANIICON,\r\n                      rtHTML,\r\n                      rtMANIFEST\r\n                    );\r\n    TResourceTypes = set of TResourceType;\r\n<\/pre>\n
I used specific ordinal assignments to some of the enum members to create the necessary “gaps” for the resource type values that aren’t (currently) meaningful in Windows and ensure that the ordinal values of the enum members corresponded exactly to Windows resource type values.<\/p>\n
The enum member names are also carefully chosen so that they may be quickly converted to the symbolic names of the corresponding Windows resource type identifiers, e.g.:<\/p>\n
rtCURSOR        >>  RT_CURSOR
\nrtGROUP_ICON  >> RT_GROUP_ICON
\netc<\/p>\n
The plan was to have a function to take a TResourceType<\/strong> value, convert to the enum name and change the “rt” prefix to “RT_”.  This is not exactly rocket science and I did not anticipate any problems.<\/p>\n
So I was somewhat surprised to find myself thwarted by a compilation error in the code:<\/p>\n
\r\n      sName := GetEnumName(TypeInfo(TResourceType), Ord(aValue));\r\n<\/pre>\n
ERROR: E2134 – Type ‘TResourceType’ has no typeinfo’<\/span><\/strong><\/span><\/p>\n
It took me a while to chase this down – my initial thought was to suspect that there was some other definition of a TResourceType<\/strong> type that was hiding my type.  That was soon ruled out and a big of further digging eventually revealed the answer.<\/p>\n
It turns out that assigning specific ordinal values to enum members (if they are different to the ordinals that the compiler would normally assign automatically) defeats the RTTI system and prevents the creation of type info for the type. \u00a0Sadly this doesn’t seem to be mentioned in the documentation, not even for the E2134<\/strong> error itself which would seem to be an ideal help topic to contain this useful piece of information.<\/p>\n
The solution in my case was quite simple. \u00a0The number of “unused” members was small so I could change my enum type to:<\/p>\n
\r\n  type\r\n    TResourceType = (\r\n                      rtNotUsed1,    \/\/ = 0\r\n                      rtCURSOR,\r\n                      rtBITMAP,\r\n                      rtICON,\r\n                      rtMENU,\r\n                      rtDIALOG,\r\n                      rtSTRING,\r\n                      rtFONTDIR,\r\n                      rtFONT,\r\n                      rtACCELERATOR,\r\n                      rtRCDATA,\r\n                      rtMESSAGETABLE,\r\n                      rtGROUP_CURSOR,\r\n                      rtNotUsed2,    \/\/ = 13\r\n                      rtGROUP_ICON,\r\n                      rtNotUsed3,    \/\/ = 15\r\n                      rtVERSION,\r\n                      rtDLGINCLUDE,\r\n                      rtNotUsed4,    \/\/ = 18\r\n                      rtPLUGPLAY,\r\n                      rtVXD,\r\n                      rtANICURSOR,\r\n                      rtANIICON,\r\n                      rtHTML,\r\n                      rtMANIFEST\r\n                    );\r\n    TResourceTypes = set of TResourceType;\r\n<\/pre>\n
Notice the additional rtNotUsedN<\/strong> members which fill in the gaps.<\/p>\n
This created a slight problem for me in that now I had some undesirable names “polluting” my enum space.  In this case I was not too concerned about that – they are self documenting after all (“NotUsed” is pretty unambiguous on that score).<\/p>\n
But there were occasions in my code where I was going to wish to test some TResourceType<\/strong> value to ensure that it was valid.<\/p>\n
A simple pair of sets helped out with this:<\/p>\n
\r\n  const\r\n    rtInvalid = [rtNotUsed1, rtNotUsed2, rtNotUsed3, rtNotUsed4];\r\n    rtValidResourceTypes  = [Low(TResourceType)..High(TResourceType)] - rtInvalid;\r\n<\/pre>\n
Which allowed me to perform runtime checking of some arbitrary TResourceType<\/strong> value:<\/p>\n
\r\n    if NOT (aValue in rtValidResourceTypes) then\r\n      \/\/ Invalid resource type ... !\r\n<\/pre>\n
Or of course alternatively:<\/p>\n
\r\n    if (aValue in rtInvalid) then\r\n      \/\/ Invalid resource type ... !\r\n<\/pre>\n
According to taste (you can probably tell which I prefer as the choice of names for the sets yields one which reads quite fluently and naturally, whilst the other is awkward and stilted in comparison, albeit more brief).  \ud83d\ude42<\/p>\n
We Don’t Know What We Don’t Know<\/h2>\n
It’s really quite astonishing to me that in almost 15 years of working with Delphi I’ve not previously encountered this limitation of the type information system (as it relates to enum types).  So astonishing that I thought it worth not just blogging about but also posting to stackoverflow<\/a> as a question with a ready made answer.<\/p>\n
I’ve only recently started using stackoverflow seriously – I hope this sort of self-answering isn’t an abuse of the system.  I thought it a useful way of adding to the “knowledgebase”.<\/p>\n
In any event, Barry Kelly, a CodeGear compiler engineer who works on the Delphi compiler itself no less (some guys get all the luck!) responded to my stackoverflow question+answer by explaining some of the internal details of the RTTI system that makes typeinfo  difficult\/impossible for such non-contiguous enum types, and offered the opinion that it probably wasn’t worth going to too much bother for since the times when it would be useful were so rare.<\/p>\n
I’d have to agree with him.<\/p>\n
It’s taken me 15 years to stumble across it – I think I can manage without a “fix” in this case.<\/p>\n
Footnote<\/h2>\n
If this had been a somewhat simpler case where I simply wanted the initial member of the enum to have a value such as 1 (one) rather than the usual 0 (zero), I could have achieved type safety with a simple subrange type (thanks to Ulrich for pointing this out on stackoverflow) renaming the underlying type and using the subrange type as the “concrete” representation of my enum throughout my code (having established the principle, in this final example I have artifically reduced the number of members in the enum type, simply to keep it short and concise):<\/p>\n
\r\n  type\r\n    TResourceTypeValue = (\r\n                            rtUnused,\r\n                            rtCURSOR,\r\n                            rtBITMAP,\r\n                            rtICON,\r\n                            rtMENU\r\n                 );\r\n    TResourceType = rtCURSOR..High(TResourceTypeValue);\r\n    TResourceTypes = set of TResourceType;\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
[Estimated Reading Time: <\/span> 4<\/span> minutes]<\/span><\/span> This is what I love about Delphi. \u00a0After almost 15 years of Delphi’ing there’s still new things to learn, and I don’t just mean new features in the latest releases. \u00a0I mean, basic, fundamental things that have been there for years, just undiscovered (by me). \u00a0In this case the discovery was a little annoying, but […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"jetpack_publicize_message":"","jetpack_is_tweetstorm":false,"jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":[]},"categories":[4],"tags":[292,88,87,86],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_shortlink":"https:\/\/wp.me\/p1TKYv-8b","jetpack_sharing_enabled":true,"jetpack-related-posts":[{"id":586,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/586\/","url_meta":{"origin":507,"position":0},"title":"Absolute (for) Beginners","date":"15 Oct 2009","format":false,"excerpt":"I casually suggested the use of the \"absolute\" keyword in response to a question on the NZ DUG mailing list today. \u00a0I thought nothing of it but someone mentioned that it had been years since he'd seen anyone use it, so I thought maybe it was worth bringing to wider\u2026","rel":"","context":"In "Delphi"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":760,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/760\/","url_meta":{"origin":507,"position":1},"title":"Platform Independence Version Dependencies in the XE2 RTL","date":"14 Sep 2011","format":false,"excerpt":"So I have spent about a week now with XE2 and FireMonkey and thought I would share some of the experience so far. After an initial peek and poke around, the first order of business for me was to migrate some of my existing code to the new RTL. First\u2026","rel":"","context":"In "Delphi"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":1397,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/1397\/","url_meta":{"origin":507,"position":2},"title":"Qualified Enum Reference That Fails to Compile in XE4 (and rightly so)","date":"01 May 2013","format":false,"excerpt":"Running through some of my code last night, putting them through the new XE4 compiler, threw up a real oddity: Some code that used to compile just fine, which no longer compiles in XE4 and which should not have compiled before! It's an odd one, because the code previously compiled\u2026","rel":"","context":"In "Delphi"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":426,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/426\/","url_meta":{"origin":507,"position":3},"title":"The “Big Switch”","date":"28 Apr 2009","format":false,"excerpt":"Much has been made in the past and again more recently, about the lack of a compiler switch in Delph 2009 to govern the behaviour of the String type. CodeGear have repeatedly said that it was not possible\/practical to provide such a switch, but their advice to anyone concerned about\u2026","rel":"","context":"In "Delphi"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":338,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/338\/","url_meta":{"origin":507,"position":4},"title":"Delphi 2009 – A Heads-Up for Low-Level Coders","date":"13 Sep 2008","format":false,"excerpt":"Prompted by a conversation with some colleagues where-in we collectively speculated about the implementation details of a generic class and what impact - if any - this might have on performance vs a \"traditional\" polymorphic equivalent, I threw together a quick performance test case in my Smoketest framework, and as\u2026","rel":"","context":"In "Delphi"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":563,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/563\/","url_meta":{"origin":507,"position":5},"title":"Delphi Unicode = Wide-ANSI","date":"26 Sep 2009","format":false,"excerpt":"Be careful what you wish for. A lot of people were overjoyed to hear that Unicode support was coming to Delphi. Some were skeptical of the chosen implementation approach however, it all seemed just a little bit too easy. I was one, and sadly it seems I was right. I've\u2026","rel":"","context":"In "Delphi"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]}],"_links":{"self":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/507"}],"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=507"}],"version-history":[{"count":21,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/507\/revisions"}],"predecessor-version":[{"id":527,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/507\/revisions\/527"}],"wp:attachment":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/media?parent=507"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/categories?post=507"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/tags?post=507"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}