Listing 1: A possible solution using Typelists

// policy templates //////////////////////////////////////////////////
struct ThreadingPolicyID {};

struct SingleThread {
  typedef ThreadingPolicyID PolicyID;
  // implementation...
};

struct ClassLocking {
  typedef ThreadingPolicyID PolicyID;
  // implementation...
};

// policy selection tool: ////////////////////////////////////////////

template < class PolicyList, 
           class PolicyID,
           class DefaultPolicy
         >
struct SelectPolicy
{
  typedef DefaultPolicy Result;
};


template < class Head,
           class Tail,
           class PolicyID,
           class DefaultPolicy
         >
struct SelectPolicy< Typelist< Head,Tail >, 
                     PolicyID, 
                     DefaultPolicy
                   >
{
  typedef Select< Conversion< PolicyID, Head::PolicyID >::sameType,
                  Head,
                  SelectPolicy< Tail, 
                                PolicyID, 
                                DefaultPolicy
                              >::Result
                >::Result
          Result;
};

// finally, FixedSizeArray implementation ////////////////////////////

template < class T, class PolicyList = NullType >
class FixedSizeArray {
  typedef SelectPolicy< PolicyList,
                        ThreadingPolicyID,
                        SingleThread >::Result ThreadingPolicy;
  typedef SelectPolicy< PolicyList,
                        RangeCheckPolicyID,
                        NoCheck >::Result RangeCheckingPolicy;
};
— End of Listing —