Basically, I'm working on data structure design whereby all the objects
in my data structure have their properties referenced by integer ids.
Property values are also always integral.  The naive implementation
would be to store all properties in an int-to-int map, and let any
object hold any value for any property.

Unfortunately, maps are problematic for two simple reasons: size and
speed.  The application needs to work with 100s of 1000s of objects,
and each object can have up to 12 properties (although most only have 4
or 5).  It needs to be able to very very rapidly access basically every
property of every object, and not impose unreasonable memory
requirements.  The performance testing I did basically ruled out maps
on this basis.

Now much of the time the properties required are known at compile time.
 That is, I might have code like:

int color = object.property(property_color);

Basically, I need this to compile to code that isn't measurably slower
than a direct reference to a data member, e.g.:

int color = object.color;

Furthermore, in order to reduce memory requirements, I've worked out
how pack all the possible properties into either 16 or 8 bit integers,
some of them signed, some of them unsigned.

I also know that each object has a key property - "type" - that
determines which other properties make sense for an object.  So an
object of type, say, "sound" doesn't have a color, whereas an object of
type "car" would.

With this in mind I came up with a system of macros that allows me to
do the following:

template <bool get>
inline void getset(Object& obj, int prop, int& value, int type = 0)
{
        if (type == 0) type = obj.props[0];
        switch (type)
        {
        case objectSound:
                GETSETPROP3(
                        int16_t,        propPitch,
                        uint16_t,       propDuration,
                        uint16_t,       propVolume);
        case objectCar:
                GETSETPROP4(
                        uint16_t,       propColor,
                        uint8_t,        propCylinders,
                        uint8_t,        propDoors,
                        uint16_t,       propEngineSize);
//      etc.etc.;
        }

The part I don't like about it is the GETSETPROP# macros, which need to
be defined for every number between 1 and 12, and use some slightly
ugly casting, e.g.:

#define SPROP(P, N) case P: assign<get>(p->m##N, value); return;
#define GETSETPROP4(t1, p1, t2, p2, t3, p3, t4, p4) \
{       \
 struct p_ { int16_t pad; t1 m1; t2 m2; t3 m3; t4 m4; }; \
 p_* p = reinterpret_cast<p_*>(&obj); \
 switch (prop) { SPROP(p1, 1) SPROP(p2, 2) SPROP(p3, 3) SPROP(p4,  4)

The obvious question is how much of this can be done with just template
meta-programming?  I know you can define type chains and the like, but
I couldn't really see how it would help me here.

If I can scrap the macros entirely I would be very happy, but
everything I've tried so far has failed to get me anywhere.