Re: A design problem: how to represent resource id's

From:

"Alf P. Steinbach" <alfps@start.no>

Newsgroups:

comp.os.ms-windows.programmer.win32,comp.programming,comp.lang.c++

Date:

Mon, 01 May 2006 20:51:35 +0200

Message-ID:

<4bn3lqF12cdogU1@individual.net>

* Lucian Wischik:

Grzegorz WrCbel </dev/null@localhost.localdomain> wrote:

HRSRC hres;
HGLOBAL hglob;
void* p;
hres = FindResource(GetModuleHandle(NULL),id,type);
hglob = LoadResource(GetModuleHandle(NULL),hres);
p = LockResource(hglob);
FreeResource(hRes);

You're not meant to use FreeResource. It does nothing. So just

HRSRC hres = FindResource(hInstance,id,type);
hglob = LoadResource(hInstance,hres);
void *p = LockResource(hglob)

and no need to free anything. I actually find these three lines rather
beautiful, clean, understandable and easy! Alf, in your quest to make
a framework/wrapper, I think that these three should be at the BOTTOM
of your priority list.

Perhaps. But add error checking and MAKEINTRESOURCE calls (converting
integers to kludgeon pointers). However, wrapping these three calls in a
single function is not a big deal; the problem lies not with
encapsulating the three calls above in a single function, i.e. not with
the procedural aspect, but with representing id+type as a cohesive unit
that can be safely passed around and that centralizes the
MAKEINTRESOURCE calls, perhaps also dealing with type safety of
resources, while not needlessly sacrificing efficiency.

At the lowest level, tackling just the kludgeon representation, I'm
thinking something like

     // The intent of this class is to provide safety & clarity
     // (especially wrt. string lifetime), while preserving efficiency
     // for integer atom-like names.
     class AtomLikeName
     {
     private:
         std::wstring myIdentifier;
         unsigned short myIntValue;

     public:
         AtomLikeName( std::wstring const& value )
             : myIdentifier( value )
             , myIntValue( 0 )
         {
             assert( myIdentifier.length() > 0 );
         }

         AtomLikeName( unsigned short value, bool isAtom = false )
             : myIntValue( value )
         {
             assert( 0 < myIntValue );
             assert( myIntValue <= (isAtom? 0xBFFF : 0x7FFF) );
         }

         bool isPseudoPointer() const { return (myIntValue != 0); }

         // Can be a pseudo-pointer:
         wchar_t const* value() const
         {
             return (isPseudoPointer()?
                 MAKEINTRESOURCE( myIntValue ) : myIdentifier.c_str()
                 );
         }

         // Comparision operations can be defined in terms of asString().
         std::wstring asString() const
         {
             return (isPseudoPointer()?
                 L"#" + stringFrom( myIntValue ) : myIdentifier
                 );
         }
     };

Then an id+type+(possible language)+(more remotely possible file spec)
can be added on top.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?