try renaming ParameterType to Parameter

Author: tomjnixon

include/adm/detail/auto_base.hpp

@@ -159,28 +159,28 @@ namespace adm {
 
     /// base class which has methods for each type in a variant parameter.
     ///
-    /// This should be used in HasParameters, with ParameterType being a
+    /// This should be used in HasParameters, with Parameter being a
     /// parameter like OptionalParameter<V>, where V is a boost::variant.
     ///
     /// When using this with OptionalParameter<V>, the following classes should
     /// be explicitly instantiated:
     /// - OptionalParameter<V>
     /// - One VariantTypeParameter<OptionalParameter<V>, T> for each T in V.
     /// - VariantParameter<OptionalParameter<V>>
-    template <typename ParameterType,
-              typename Variant = typename ParameterType::ParameterType>
+    template <typename Parameter,
+              typename Variant = typename Parameter::ParameterType>
     class VariantParameter;
 
     /// Base class for one type within a variant.
     ///
-    /// ParameterType should be a parameter type like
+    /// Parameter should be a parameter type like
     /// OptionalParameter<boost::variant<...>>, and T should be one of the
     /// types of the variant.
     ///
     /// this uses CRTP with VariantParameter to access the Variant type
-    template <typename ParameterType, typename T>
+    template <typename Parameter, typename T>
     class VariantTypeParameter {
-      using Base = VariantParameter<ParameterType>;
+      using Base = VariantParameter<Parameter>;
       using Tag = typename detail::ParameterTraits<T>::tag;
 
       Base& base() { return static_cast<Base&>(*this); }
@@ -212,28 +212,28 @@ namespace adm {
     };
 
     // implementation of VariantParameter; see above
-    template <typename ParameterType, typename... Options>
-    class VariantParameter<ParameterType, boost::variant<Options...>>
-        : public ParameterType,
-          public VariantTypeParameter<ParameterType, Options>... {
+    template <typename Parameter, typename... Options>
+    class VariantParameter<Parameter, boost::variant<Options...>>
+        : public Parameter,
+          public VariantTypeParameter<Parameter, Options>... {
      public:
       using Variant = boost::variant<Options...>;
       using VariantTag = typename detail::ParameterTraits<Variant>::tag;
 
-      using ParameterType::get;
-      using VariantTypeParameter<ParameterType, Options>::get...;
+      using Parameter::get;
+      using VariantTypeParameter<Parameter, Options>::get...;
 
-      using ParameterType::set;
-      using VariantTypeParameter<ParameterType, Options>::set...;
+      using Parameter::set;
+      using VariantTypeParameter<Parameter, Options>::set...;
 
-      using ParameterType::has;
-      using VariantTypeParameter<ParameterType, Options>::has...;
+      using Parameter::has;
+      using VariantTypeParameter<Parameter, Options>::has...;
 
-      using ParameterType::isDefault;
-      using VariantTypeParameter<ParameterType, Options>::isDefault...;
+      using Parameter::isDefault;
+      using VariantTypeParameter<Parameter, Options>::isDefault...;
 
-      using ParameterType::unset;
-      using VariantTypeParameter<ParameterType, Options>::unset...;
+      using Parameter::unset;
+      using VariantTypeParameter<Parameter, Options>::unset...;
     };
 
     /// Helper containing templated wrapper methods like `has<Param>()` around