class QString {
      public:inline QString(const int i);
};
class QGenericArgument {
};
class ExtensionOption {
};
template < typename T2 > struct if_ {
	typedef T2 type;
};
template < typename T > struct c_imp {
	typedef const T & param_type;
};
template < typename T > struct call_traits {
	typedef typename c_imp < T >::param_type param_type;
};
class object;
template < class T > struct rvalue_from_python_data {
	~rvalue_from_python_data();
};
template < class T > struct extract_rvalue {
	typedef typename if_ < typename call_traits <
	    T >::param_type >::type result_type;
	mutable rvalue_from_python_data < T > m_data;
};
template < class T > struct select_extract {
	typedef typename if_ < extract_rvalue < T > >::type type;
};
template < class T > struct extract:select_extract < T >::type {
      private:typedef typename select_extract < T >::type base;
      public:typedef typename base::result_type result_type;
	operator  result_type() const {
	} extract(object const &);
};
template < class Key, class T > class QHash {
      public:inline QHash() {
	}
	T & operator[](const Key & key);
};

class type_details {
	typedef QGenericArgument(*func_python_to_cpp_type) (const object &);
      public: template < typename T >
	    static type_details *create_value_type_details() {
		type_details *self = new type_details();
		 self->m_func_python_to_cpp = &python_to_value_type < T >;
	} func_python_to_cpp_type m_func_python_to_cpp;
	template < class T >
	    static QGenericArgument python_to_value_type(const object & obj) {
		T *val = new T(extract < T > (obj));
	}
};

class type_manager {
      public:static type_manager & instance();
	 template < typename T > void register_value_type() {
		m_type_map[0] =
		    type_details::create_value_type_details < T > ();
	} QHash < QString, type_details * >m_type_map;
};

void foo()
{
	type_manager::instance().register_value_type < ExtensionOption > ();
}