template parameter representation

Consider:

# include <cstdio>
# include <string>
# include <sstream>
# include <vector>
# include <ctime>
# include <cassert>

template < typename T >
struct some_other_policy {};

template < typename T >
struct no_policy {};

template < typename UnsignedType,
           typename default_policy = no_policy < UnsignedType > ,
           unsigned base = 0, unsigned offset = 0 >
struct hw_default {
 // default implementation....
};

template < typename UnsignedType,
           typename default_policy = no_policy < UnsignedType > ,
           unsigned base = 0, unsigned offset = 0 >
struct hw_register_struct {
// implementation changes here..
};

template < bool val >
struct static_assert;

template <>
struct static_assert< true > {};

template < typename T >
struct strip_pod_type {};

#define STRIP_POD_TYPE(Int) \
 template <> \
 struct strip_pod_type< volatile Int > { \
   typedef Int type; \
 }; \
 template <> \
 struct strip_pod_type< Int > { \
   typedef Int type; \
 } \

STRIP_POD_TYPE( char );
STRIP_POD_TYPE( unsigned char );
STRIP_POD_TYPE( signed char );
STRIP_POD_TYPE( unsigned short );
STRIP_POD_TYPE( signed short );
///more

#undef STRIP_POD_TYPE

template < typename Type >
struct traits
{
 typedef typename strip_pod_type<Type>::type interface_type;

};

template < typename U, typename en, unsigned long base, unsigned
offset >
struct traits< hw_default <U,en,base,offset > >
{
 typedef typename strip_pod_type<U>::type interface_type;

};

template < typename UnsignedType, unsigned low, unsigned high >
class foo
 : static_assert< high <= CHAR_BIT *
   sizeof( typename traits< UnsignedType >::interface_type ) >
{
  typedef typename
   traits< UnsignedType >::interface_type interface_type;

  typedef UnsignedType host_type;
  host_type & host_obj;
public :
  foo ( host_type & in )
   : host_obj ( in )
  {}
  //more stuff..
};

typedef hw_default < volatile unsigned short > hw_default_type;

typedef hw_register_struct < volatile unsigned short,
                             some_other_policy < unsigned short >,
                             0x500,
                             0 > hw_register_struct_type;

int main()
{
  unsigned short aa ( 0 );
  foo < volatile unsigned short, 5, 6 > aa5_6 ( aa );

  hw_default_type ab ;
  foo < hw_default_type, 5, 6 > ab5_6 ( ab );

  //hw_register_struct_type ac ;
  //foo < hw_register_struct_type, 5, 6 > ac5_6 ( ac );

}

Apologies in advance if I'm not using the right C++ lingo. How could
i modify source above such that I could use the composite type
hw_register_struct_type? The code today is not extensible because
it's structured around the default - hw_default_type which works for
'most' cases.