Question

I’m trying to use C++ Template ‘mixins’ to create some new VCL components with shared additional functionality. Example…

template <class T> class Mixin : public T
{
private:
  typedef T inherited;

// ...additional methods

public:
  Mixin(TComponent *owner) : inherited(owner)
  {
  // .. do stuff here
  };
};

Used like this:

class MyLabel : public Mixin<TLabel>
{
  ....
}

class MyEdit : public Mixin<TEdit>
{
  ....
}

Now, everything compiles fine, and the mixin stuff seems to work – until I try and save the component to a stream using TStream->WriteComponent, where the inherited properties (eg TLabel.Width/Height/etc.) don’t get written. This is even with a ‘null’ mixin like the one shown above.

My code works fine when just deriving classes directly from TForm, TEdit, etc – and the class is correctly registered with the streaming system.

Answer 1

The quick/simple answer is: no; when dealing with a template, the compiler won’t generate the proper descriptors to make streaming working. However, since this has come up before, I peeked under the cover to find out what’s missing. And what I found is that it’s almost there. So here’s a little more information.

Upfront the compiler will never treat a template-based type as a Delphi. For example, do something like this:

void testing()
{
  __classid(Mixin<Stdctrls::TLabel>); // Error Here
}

… and you’ll see the error

“Error E2242 test.cpp 53: __classid requires Delphi style class type (i.e. class marked __declspec(delphiclass) or derived from System::TObject) in function testing()”

This basically says the compiler does not consider this type/class as compatible with Delphi-classes [i.e. those that derive from TObject]. Internally there’s just a flag on the symbol that says whether the type is delphi-compatible or not. And I noticed that I could trick the compiler into marking the type as delphi-style if I forced it to walk up the hierarchy.. which is something it has to do if I create an instance of the object. So, with this hack the error goes away:

void testing()
{
  typedef Mixin<Stdctrls::TLabel> __ttype;
  std::auto_ptr<__ttype> c2(new __ttype(0));
  __classid(Mixin<Stdctrls::TLabel>); // No more errors here
}

But much nicer was actually to use the __declspec(delphiclass) directly on the template, as in:

template <class T> 
class __declspec(delphiclass) Mixin : public T {
private:
  int i;
  typedef T inherited;
public:
  __fastcall Mixin(TComponent *owner) : inherited(owner) {};
};

So now that the compiler treats the type as a delphi-style class without hacks, I peeked a little more and found the issue you’re probably running into: Delphi classes have the TTypeData.PropCount field – http://docwiki.embarcadero.com/VCL/en/TypInfo.TTypeData – which is a sum of the class’ properties, including those of its base classes. Due to the way the various pieces of information are computed, the compiler writes out a ‘0’ for that field when a template is involved:(

You can see this by printing out the PropCount, as in:

#include <Stdctrls.hpp>
#include <cstdio>
#include <memory>
#include <utilcls.h>

class TCppComp : public Classes::TComponent {
  int i;
public:
  __fastcall TCppComp(TComponent* owner): Classes::TComponent(owner) {};
__published:
  __property int AAAA = {read=i, write=i};
};

template <class T> 
class __declspec(delphiclass) Mixin : public T {
private:
  int i;
  typedef T inherited;
public:
  __fastcall Mixin(TComponent *owner) : inherited(owner) {};
};

typedef Mixin<TCppComp> TMixinComp;

void showProps(TClass meta) {
  PTypeInfo pInfo = PTypeInfo(meta->ClassInfo());
  int Count = GetPropList(pInfo, tkAny, NULL);
  TAPtr<PPropInfo> List(new PPropInfo[Count]);
  std::printf("Class: %s - Total Props:%d\n", 
                   AnsiString(pInfo->Name).c_str(), Count);  
  GetPropList(pInfo, tkAny, *(reinterpret_cast<PPropList*>(&List)));
  for (int i = 0; i < Count; i++) {
    AnsiString propName(List[i]->Name);
    std::printf("\t%s\n", propName.c_str());
  }
}

void test() {
  showProps(__classid(TCppComp));
  showProps(__classid(TMixinComp));
}

int main() {
  test();
  return 0;
}

When run the above prints:

  Class: TCppComp - Total Props:3
    AAAA
    Name
    Tag
  Class: @%Mixin$8TCppComp% - Total Props:0

IOW, Mixin shows up with ‘0’ published properties while its base type has 3:(

I suspect the streaming system relies on this count and that’s why inherited properties are not being written out in your setup.

I considered tweaking the generated descriptors at runtime but since we write them to _TEXT it’s bound to trigger DEP.

I’ll look at the logic that computes the PropCount to see if there’s some way to get it to compute the correct number. If time allows, please do open a QC for this: now that I’ve peek underneath, I believe it would not require much effort to get this working as expected.

Cheers,

Bruneau

PS: In my sample I even had the Mixin publish a property and the compiler generated the correct descriptor for that property; however, the total count was still zero.