- Prefer the $WM_PROJECT_VERSION from the environment, since this
  is consistent with the foamEtcFile script, and matches better to
  user expectations.

- For compatibility, access to the old global names is provided via
  macros
        #define FOAMversion     foamVersion::version
        #define FOAMbuild       foamVersion::build
        #define FOAMbuildArch   foamVersion::buildArch

- this isolation makes it easier to provide additional scoped methods
  for dealing with version related information.  Eg, printBuildInfo()

- foamVersion.H now includes stdFoam.H for consistent use
  of compatibility compiler defines.

- move forward declaration of Detail, Module namespaces to stdFoam.H

- doxygen documentation of Foam namespace in stdFoam.H

- generalize output text wrapping, use for usage notes

- add -help-man option for generating manpage content for any OpenFOAM
  application or solver.

  bin/tools/foamCreateManpage as helper

- 'unfriend' operators on dimensionSet, since they operate without
  requiring access to non-public members.

- add missing invTransform() function for dimensionSet.

- make inv(const dimensionSet&) available as
  operator~(const dimensionSet&), which can be used instead
  of (dimless/ds).

- writing of dictionary entry with the name of the dimensionedType
  suppressed if it is identical to the keyword.
  This corresponds to the input requirements.

- deprecate dimensionedType constructors using an Istream in favour of
  versions accepting a keyword and a dictionary.

  Dictionary entries are almost the exclusive means of read
  constructing a dimensionedType. By construct from the dictionary
  entry instead of doing a lookup() first, we can detect possible
  input errors such as too many tokens as a result of a input syntax
  error.

  Constructing a dimensionedType from a dictionary entry now has
  two forms.

  1.  dimensionedType(key, dims, dict);

      This is the constructor that will normally be used.

      It accepts entries with optional leading names and/or
      dimensions. If the entry contains dimensions, they are
      verified against the expected dimensions and an IOError is
      raised if they do not correspond. On conclusion, checks the
      token stream for any trailing rubbish.

  2.  dimensionedType(key, dict);

      This constructor is used less frequently.

      Similar to the previous description, except that it is initially
      dimensionless. If entry contains dimensions, they are used
      without further verification. The constructor also includes a
      token stream check.

      This constructor is useful when the dimensions are entirely
      defined from the dictionary input, but also when handling
      transition code where the input dimensions are not obvious from
      the source.

      This constructor can also be handy when obtaining values from
      a dictionary without needing to worry about the input dimensions.
      For example,

         Info<< "rho: " << dimensionedScalar("rho", dict).value() << nl;

      This will accept a large range of inputs without hassle.

ENH: consistent handling of dimensionedType for inputs (#1083)

BUG: incorrect Omega dimensions (fixes #2084)

- check Istream in readBool in operator>> variant (#1033)

- fix range checks

- use forwarding templates for the factory method

- avoid double use of dynamic_cast.
  Don't need implicit use in isA<>, can use result directly

STYLE: updated iteration over HashTable of mesh objects

- was using coordinate-system and transform() which is the
  local-to-global mapping, whereas it should be invTransform() which
  is the global-to-local mapping

- easier when making modifications

STYLE: spelling in topoSetSource comments

- this seems to be the only reliable means of obtaining the values.

  Using typeName_() yields the wrong value.

  Using the typeName causes initialization issues
  (segfault when executing on some systems).

- resolves better on some compilers.

- support name filtering by class based on <Type> or predicates.
  Eg,

      objects.sortedNames<volScalarField>(namePattern);
  vs  objects.sortedNames(volScalarField::typeName, namePattern);

  These can also be used directly for untyped name matching.
  Eg,
      objects.sortedNames<void>(namePattern);

  Can also use a predicate:

      objects.sortedNames(wordRe("vol.*Field"), namePattern);
      objects.sortedNames
      (
          [](const word& clsName){ return clsName.startsWith("vol"); },
          namePattern
      );

- add IOobjectList::count() methods

- lookupClass<Type>() to use types instead of class variables.

- additional helpers for parallel: allNames(), checkNames()

- provide filterClasses() and filterObjects(), prune_0() method
  forwarding to HashTable methods for easier access.

- can be useful for obtaining information about number of fields.
  Eg,

       nScalar = mesh.count<volScalarField>(wordre);

- replace explicit use of wordRe, wordRes, wordHashSet as filters
  with a MatchPredicate.

- support filtering by class based on <Type> or predicates

- in parameter form, check if it headerClassName() corresponds to the
  specified class name

- in templated form, check if headerClassName() corresponds to the
  Type:typeName value.
  Specialization for <void> always returns true (ie, no checks)

- replace explicit use of word, wordRe, wordRes, wordHashSet as filters
  with a MatchPredicate, since they all satisfy the requirements for
  use a predicate. This change reduces code duplication, allows other
  matcher types (eg, keyType) as well as lambda functions.

- add special treatment for a 'const char*' parameter
  for lookupClass() and the now-deprecated single item lookup() method
  to promote these parameters to 'word'.

- naming similar to objectRegistry, with unambiguous resolution.
  The lookup() methods have different return types depending on the
  calling parameter.

STYLE: use IOobjectListTemplates.C for implementations

- previously included as local definition within IOobjectList.C,
  but will be adding more templated methods soon.

- adjust parameters (eg, matchName instead of matcher) to show their
  function

ENH: handle objectRegistry::names<void>(...)

- this is equivalent to no Type restriction, and can be used when
  filtering names. Eg,

     obr.names<void>(wordRe..);

- Start brief descriptions with 'Deprecated(YYYY-MM)' so that it is
  readily visible in the short method description. Consistent date
  format (YYYY-MM), placed immediately after the \deprecated tag.

- returns indices of matching entries.