Introduction
Ever wonder what those Microsoft MFC message mapping macros did under the covers? It was always black magic to me - how clicking a button caused a function to be called. Luckily for the curious, Visual Studio lets you sleuth through the macros by using "Go to Definition" from the context menu.
I recently had a need to convert a structure to XML and vice versa in order to allow a web server to send TCP/IP messages to my server process - the messages would be formatted in XML, but the server would of course need to have access to the parsed XML elements in some sort of structure. There are a lot of XML parsers out there, including ActiveX controls - and so I make a disclaimer here that this is not intended to be a full featured parser. Our XML needs were very simple, and this is a simple solution.
But the purpose of the article is not really about XML parsing - it is about mapping the members of a class - either data or function - to a list, which contains information about the members, and associations to some function, so you can do something useful with the class members without having to write a bunch of code for each of your derived classes.
To better illustrate the point, take a look at the Microsoft message mapping macros (afxwin.h). There are four basic macro functions at work here.
We will use the following code as an example:
BEGIN_MESSAGE_MAP( CMyClass, CFrameWnd )
ON_MESSAGE(CM_SOCKET_EVENT, OnSocketEvent)
ON_MESSAGE(CM_FOLDER_CHANGED, OnFolderChanged )
END_MESSAGE_MAP()
DECLARE_MESSAGE_MAP() - This goes in the class declaration - the header file. It declares a hidden array of structures, each of which contains information about how to handle a particular Windows message. It also declares a function that returns a pointer to the array of structures, so Windows can walk this list when a Windows message arrives and call the appropriate handler. These members are declared as static - and so they must be defined in the source file, as all statics must be. This generates the following code declarations in the header file: private:
static const AFX_MSGMAP_ENTRY _messageEntries[];
protected:
static
const AFX_MSGMAP messageMap;
virtual
const
AFX_MSGMAP* GetMessageMap()
const;
BEGIN_MESSAGE_MAP() - This defines the body of the function to retrieve the list of structures, and also defines the array itself, but leaves it open ended, like so: const AFX_MSGMAP* CMyClass::GetMessageMap() const
{ return &CMyClass::messageMap; }
AFX_COMDAT const AFX_MSGMAP CMyClass::messageMap =
{ &CFrameWnd::messageMap, &CMyClass::_messageEntries[0] };
AFX_COMDAT const AFX_MSGMAP_ENTRY theClass::_messageEntries[] =
{
ON_MESSAGE( event, function ) - There are many variants, such as ON_COMMAND, etc. These macros add a structure to the array with initialization values:
{ CM_SOCKET_EVENT, 0, 0, 0, AfxSig_lwl,(AFX_PMSG)(AFX_PMSGW)(
static_cast< LRESULT (AFX_MSG_CALL CWnd::*)
(WPARAM, LPARAM) >(OnSocketEvent)) },
END_MESSAGE_MAP() - This simply adds a zero filled termination structure to the array. {0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 }};
That's basically all there is. In our XML mapping example, we use the mapping macros to create structures that describe the member variables. This initial version supports the following basic types, but can easily be extended for support of other atomic data types like float, etc.
Integers
- Integer
- Integer Pointer
- Integer Array
- Integer Pointer Array
Strings (CStrings, but could be ported to use any string type)
CString
CString Pointer
CString Array
CString Pointer Array
Classes - Must be derived from the CXMLMessage class
- Class
- Class Pointer
- Class Pointer Array
- Class Array is not supported - this is possible, but extremely complicated, and not worth the coding effort.
New Features for Version 1.01 (November 16, 2004)
- Base class function to generate XML Schema Definition file -
CXMLMessage::GenerateXSD()
- Base class function to generate Document Type Definition file -
CXMLMessage::GenerateDTD()
- No longer need to pass in a buffer to
Deflate function
- Copy constructor automatically defined for derived classes
- Member initialization and cleanup automatically performed for derived classes.
New Features for Version 1.2 (November 18, 2004)
- Support for derived classes
- Inflate functions from a file handle or filename. This is useful when using XML for a configuration file.
Background
Familiarity with Windows message handling, using the Windows macros described above.
Using the code
The XML mapping macros in this example are very easy to use. Exporting a class to XML is done using the Deflate() function, and Importing from XML is done using the Inflate() function.
Here is an example of the XML map, which is in the CPP file for the derived class.
Note: The syntax for Inflate and Deflate has changed for V1.01 - much simpler to use.
BEGIN_XML_MAP( CMsgDestinationInfo, _T("destinationInfo") )
XML_ELEMENT_DTYPE( _T("destination"), m_destination, XML_STRING )
XML_ELEMENT_DTYPE( _T("filePathRoot"), m_filePathRoot, XML_STRING )
END_XML_MAP()
Version 1.2 now supports derived classes. Use the BEGIN_XMP_MAP2 macro for these. You can derive as many levels as you need to. Each derived class will include the XML mapped members from its base class. In this example, CMsgFTPDestinationInfo will have the members "destination" and "filePathRoot" included from CMsgDestinationInfo.
BEGIN_XML_MAP2( CMsgFTPDestinationInfo, _T("ftpDestinationInfo"),
CMsgDestinationInfo )
XML_ELEMENT_DTYPE( _T("username"), m_username, XML_STRING )
XML_ELEMENT_DTYPE( _T("password"), m_password, XML_STRING )
END_XML_MAP()
And the header file for our class - with map declaration. Note: constructors and destructors are automatically provided by the macros. If you need special behavior here, override Initialize() or Cleanup() in your derived class.
class CMsgDestinationInfo : public CXMLMessage
{
public:
CString m_destination;
CString m_filePathRoot;
DECLARE_XML_MAP(CMsgDestinationInfo);
};
Or in the case of a derived class:
class CMsgFTPDestinationInfo : public CMsgDestinationInfo
{
public:
CString m_destination;
CString m_filePathRoot;
DECLARE_XML_MAP(CMsgFTPDestinationInfo );
};
I'll spare you the initialization of the class members, but assuming that is done, here is how you generate the XML:
CMsgFTPDestinationInfo message1;
int size = 0;
TCHAR* ptr = 0;
if ( message1.Deflate( ptr, size ) != 0 )
return 1;
And here is how you load the class members from an XML buffer (read from a file, socket, etc.):
CMsgFTPDestinationInfo message2;
if ( message2.Inflate( ptr, size ) != 0 )
return 1;
Generating schema definition files is easy:
CMsgFTPDestinationInfo message3;
if ( message3.GenerateDTD() != 0 )
return 1;
if ( message3.GenerateXSD() != 0 )
return 1;
Points of Interest
I enjoy doing things you aren't supposed to be able to do - like manipulating and recasting pointers. Everything that is done in software is done by interpreting the meaning of a block of memory. And trying to understand how the compiler interprets pointers and what expects to find in a block of memory is always a fun challenge.
History
- Nov 10 2004 - Article submitted.
- Nov 16 2004 - Version 1.01 submitted - XSD and DSD generation, initialization, cleanup and copy constructors.
- Nov 18 2004 - Version 1.2 submitted - support for derived classes.
| You must Sign In to use this message board. |
|
|
 |
|
|
In XMLMacros.h, there are references made to how to assign Attributes to Elements [commented section in the bottom portion of the file]. The Define for XML_ATTRIBUTE is present but there are no other references in the body of the sources that I can find that _use_ XML_ATTRIBUTE. The comments led me to believe the functionality was available, but I do not believe this to be the case.
Can you please clarify/correct my confusion and/or provide us with the updated sources??
Thanks!
Scott
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
Hi Scott,
It's been a year and a half since I wrote this, so I can only guess what my former self was thinking. There never was code to support XML_ATTRIBUTE - just the place holder as a bitmask, but as I ( vaguely ) recall the intention was to eventually support the XML Attribute ( vs. Element ) syntax in the generated .xml file itself. Anything that can be represented as an Attribute can also be represented as an Element, and so I never pursued this optional representation.
If you feel inspired, implement this and let me know how it turned out!
Steve
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
An interesting idea to use macros for XML handling in C++, thanks for presenting it. I made some tests with the code, played with another simple data structure, and produced some XML output ("deflating" the data structure). Inspecting the XML output I found a problem with integers. After some debugging I got into
CXMLMessage::DeflateInteger
to the line (nice casts, indeed  )
intVal = (int) *((char*) this + a_entry->m_offset );
which causes the problem (wrong int values in the XML; e.g. 1234 mutates to -46). I changed the line into
intVal = *(int*)( (char*)this + a_entry->m_offset );
what solved my problem.
OKN
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
|
|
|
Great job, Steve. I found this article really informative, not because I was interested in XML, but because I was looking for an example of how to keep a table of class members for serialization purposes. Your macros are just what I was looking for!
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
I'm interested in understanding if this approach can be used for embeded collections (data members of eith CArray, CList OR fixed length arrays of structures). It isn't obvious to me how a compile-time mapping can accomodate such a problem.
Thanks!
Scott
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
Hi Scott,
Yes and No. All arrays supported are implemented using CArray. You can use CArray for class pointers, but NOT CArray of classes. You could probably extend the code to do this. ( No guarantees, but give it a try ).
Look in CXMLMessage::InflateClass(). Under the array section, you will see where an array of class objects are not supported, ( but array of class pointers are ). In this section you could try:
CArray *array = ( CArray* )((char*) this + a_entry->m_offset );
while(1)
{
// Call the create function to return a pointer to the derived class.
// This create function is declared and
// defined by the macros DECLARE_XML_MAP and BEGIN_XML_MAP.
CXFUNC func = a_entry->m_fpCreate;
CXMLMessage* newClass = (*func)();
array->Add( *newClass ); // Now add class instead of class pointer.
// Recurse for this class
if ((rc = newClass->Inflate( a_buffer, a_limit, a_size, tag.GetBuffer()) != 0 ))
return rc;
// Peek ahead at next element - same type?
if ( CheckTag( a_buffer, a_limit, a_size, tag ) != 0 )
{
// No, end of array
return 0;
}
}
You will also need the inverse for CXMLMessage::DeflateClass()
Also check the mapping macros to allow for non-pointers to be
declared for class arrays. I will let you figure it out, but here is the
current macro, which as you can see forces the pointer attribute:
// Member variable is a class. Only class pointers are supported for arrays.
#define XML_ELEMENT_CLASS( token, memberElement, classType, flags ) \
{ token, MEMBER_OFFSET( memberElement ), \
flags | XML_CLASS | ((flags & XML_ARRAY ) ? XML_POINTER : 0 ), \
(CXFUNC) (reinterpret_cast< CXMLMessage* (*)() > \
(classType::newInstance)) }, \
Here is sample code for CArray of class pointers. You should be able to
figure out how to change for CArray of class.
// header file:
class CGroupList : public CXMLMessage
{
public:
CArray m_groups;
DECLARE_XML_MAP(CGroupList);
};
// source file:
BEGIN_XML_MAP( CGroupList, _T("CGroupList") )
XML_ELEMENT_CLASS( _T("group"), m_groups, CGroup, XML_ARRAY | XML_OCCUR_0M )
END_XML_MAP()
You would want to change the macro statement so this would have to read as follows if you
were using class pointers, and unchanged ( as above ) if you were using class.
XML_ELEMENT_CLASS( _T("group"), m_groups, CGroup, XML_ARRAY | XML_POINTER | XML_OCCUR_0M )
Good Luck!
Steve
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
( Sorry, previous reply had XML tagging enabled, which removed important stuff from the post. )
Hi Scott,
Yes and No. All arrays supported are implemented using CArray. You can use CArray for class pointers, but NOT CArray of classes. You could probably extend the code to do this. ( No guarantees, but give it a try ).
Look in CXMLMessage::InflateClass(). Under the array section, you will see where an array of class objects are not supported, ( but array of class pointers are ). In this section you could try:
CArray<CXMLMessage> *array = ( CArray<CXMLMessage>* )((char*) this + a_entry->m_offset );
while(1)
{
// Call the create function to return a pointer to the derived class.
// This create function is declared and
// defined by the macros DECLARE_XML_MAP and BEGIN_XML_MAP.
CXFUNC func = a_entry->m_fpCreate;
CXMLMessage* newClass = (*func)();
array->Add( *newClass ); // Now add class instead of class pointer.
// Recurse for this class
if ((rc = newClass->Inflate( a_buffer, a_limit, a_size, tag.GetBuffer()) != 0 ))
return rc;
// Peek ahead at next element - same type?
if ( CheckTag( a_buffer, a_limit, a_size, tag ) != 0 )
{
// No, end of array
return 0;
}
}
You will also need the inverse for CXMLMessage::DeflateClass()
Also check the mapping macros to allow for non-pointers to be
declared for class arrays. I will let you figure it out, but here is the
current macro, which as you can see forces the pointer attribute:
// Member variable is a class. Only class pointers are supported for arrays.
#define XML_ELEMENT_CLASS( token, memberElement, classType, flags ) \
{ token, MEMBER_OFFSET( memberElement ), \
flags | XML_CLASS | ((flags & XML_ARRAY ) ? XML_POINTER : 0 ), \
(CXFUNC) (reinterpret_cast< CXMLMessage* (*)() > \
(classType::newInstance)) }, \
Here is sample code for CArray of class pointers. You should be able to
figure out how to change for CArray of class.
// header file:
class CGroupList : public CXMLMessage
{
public:
CArray<CGroup*,CGroup*> m_groups;
DECLARE_XML_MAP(CGroupList);
};
// source file:
BEGIN_XML_MAP( CGroupList, _T("CGroupList") )
XML_ELEMENT_CLASS( _T("group"), m_groups, CGroup, XML_ARRAY | XML_OCCUR_0M )
END_XML_MAP()
You would want to change the macro statement so this would have to read as follows if you
were using class pointers, and unchanged ( as above ) if you were using class.
XML_ELEMENT_CLASS( _T("group"), m_groups, CGroup, XML_ARRAY | XML_POINTER | XML_OCCUR_0M )
Good Luck!
Steve
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
Scott,
Sorry, disregard the previous suggestion. I now remember why it can't work.
The cast:
CArray<CXMLMessage> *array = ( CArray<CXMLMessage>* )((char*) this + a_entry->m_offset );
won't work, because it is a cast to the BASE class, which is smaller
than the derived class you are trying to inflate. Casting to CArray of class pointers
works because the size of a pointer is the same regardless of the derived class type.
Just use a CArray of class pointers and you'll be all set.
Steve
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
Hi!
I've made some improvements to use multiple inheritance. Example:
class CXMLVehicle : public CXMLMessage
{
int m_iHorsePower;
CString m_strType;
//Colors for RGB
int m_iClr_Red;
int m_iClr_Gren;
int m_iClr_Blue;
};
class CXMLSportsCar : public CXMLVehicle
{
// ... any other members here
}
there was no simple way to Deflate the members
from the base class (CXMLVehicle)
Add the following code:
in XMLMacros.h
#define MAP_CXMLMessage
#define IMPLEMENT_XML_MAP( derived, base, tagExpr) \
BEGIN_XML_MAP( ##derived, _T(tagExpr)) \
MAP_##base \
MAP_##derived \
END_XML_MAP()
Instead of the BEGIN_XML_MAP(...) and END_XML_MAP() macros use the IMPLEMENT_XML_MAP(...) macro
in your headerfile write a #define statement like
#define MAP_YourClassName \
XML_ELEMENT_DTYPE( ... )\
XML_ELEMENT_CLASS( ... )\
to define your map. This macro is used by the IMPLEMENT_XMP_MAL macro
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
Thanks for the suggestion! I was actually just finishing up the latest version which supports derived classes. This is version 1.2 which should be posted sometime today. The C++ header still looks just as you have suggested for CXMLSportsCar. The only change to the message map is as follows:
BEGIN_XML_MAP( CXMLVehicle, _T("Vehicle"))
XML_ELEMENT_DTYPE( ...... )
END_XML_MAP
and for the derived class:
BEGIN_XML_MAP2( CXMLSportsCar, _T("SportsCar"), CXMLVehicle)
XML_ELEMENT_DTYPE( ...... )
END_XML_MAP
The Deflate, Inflate, and Copy functions automatically process the members of the base class. This is not multiple inheritence, but you can derive linearly as many times as you like. Base class elements are processed recursively.
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
|
|
|
# define _CLASSMEMBER(clas,member,fieldtype,count,flags) \
{fieldtype, #member, count, flags, offsetof(clas,member)}
# define DEFINE_CLASSMEMBER(clas,member,ftype) \
_CLASSMEMBER(clas, member, ftype, 1, 0)
|
| Sign In·View Thread·PermaLink | 1.00/5 |
|
|
|
|
|
|
