private:
+ /**
+ * Template class that declares
+ * in inner typedef with the
+ * following semantics: if the
+ * first template parameter is
+ * @p{true}, then the inner
+ * typedef is @p{volatile T},
+ * otherwise @p{T}. We achieve
+ * this behavior by partial
+ * specialization of the general
+ * template for both values of
+ * the boolean argument.
+ *
+ * This trick is used to declare
+ * the type of the counter
+ * variable to be eiter volatile
+ * or not, depending on whether
+ * we are in multithreaded mode
+ * or not. (If we are in MT mode,
+ * then we need the @p{volatile}
+ * specifier since more than one
+ * thread my modify the counter
+ * at the same time.
+ *
+ * Since we only partially
+ * specialize the case that the
+ * boolean template argument is
+ * @p{false}, this general
+ * template catches the case that
+ * it is @p{true}, i.e. in a
+ * sense it is also a
+ * specialization since a
+ * @p{bool} can only have two
+ * states.
+ *
+ * @author Wolfgang Bangerth, 2003
+ */
+ template <bool, typename T> struct PossiblyVolatile
+ {
+ typedef volatile T type;
+ };
+
+ /**
+ * Specialization of the template
+ * for the case that the first
+ * template argument is
+ * @p{false}, i.e. the
+ * non-volatile case.
+ */
+ template <typename T> struct PossiblyVolatile<false,T>
+ {
+ typedef T type;
+ };
+
+
/**
- * Store the number of objects which
- * subscribed to this object. Initialally,
- * this number is zero, and upon
- * destruction it shall be zero again
- * (i.e. all objects which subscribed
- * should have unsubscribed again).
+ * Store the number of objects
+ * which subscribed to this
+ * object. Initialally, this
+ * number is zero, and upon
+ * destruction it shall be zero
+ * again (i.e. all objects which
+ * subscribed should have
+ * unsubscribed again).
+ *
+ * The creator (and owner) of an
+ * object is not counted.
*
- * The creator (and owner) of an object
- * is not counted.
+ * We use the @p{mutable} keyword
+ * in order to allow subscription
+ * to constant objects also.
*
- * We use the @p{mutable} keyword in order
- * to allow subscription to constant
- * objects also.
+ * In multithreaded mode, this
+ * counter may be modified by
+ * different threads. We thus
+ * have to mark it
+ * @p{volatile}. However, this is
+ * counter-productive in non-MT
+ * mode since it may pessimize
+ * code. So use the above
+ * template class to selectively
+ * add volatility.
*/
- mutable unsigned int counter;
+ mutable PossiblyVolatile<DEAL_II_USE_MT,unsigned int>::type counter;
/**
* Pointer to the typeinfo object