Should help keep clang-tidy jobs to a reasonable runtime.

The superbuild has learned how to name based on a file inside of the
directory.

The backtrace is from HDF5 during program shutdown. It seems like it
ends up being ordered after `malloc` has been destructed. Just ignore it
and file an issue for now.

This gets Xcode 16.1-compiled bundles and synchronizes all
configurations on the same commit.

Code can be reverted; remove to avoid confusion of the status.

PowerShell scripts are not inherently executable and therefore should not have
the executable bit set.

The `set` command in `cmd` has terrible properties in that there's no
real structure to it. Sensitive sequences in values or variable names
that are escaping sequences can be interpreted at the wrong time or
things like newlines in values are not escaped at all and cause
ambiguities in parsing. Avoid all of that and use PowerShell to use JSON
as a communication mechanism.

It doesn't actually seem necessary, but leave it in the history in case
it becomes relevant again in the future.

Due to updating to ParaView 5.12.1 (both ParaView and VTK deprecations) as well as
those coming from BOOST

Also made changes need to use nlohman JSON 3.11.3

Updated CI assets based on 9/5/2024

Fixed Clang Tidy Warnings - this included adding a filter to ignore warnings from VTK generated files

Changed WorkletPanel Test XML to work around an issue with ParaView's PluginManagerDialog's pqFileDialog not being named - this will need to be undone when ParaView fixes it on its end.

This is no longer needed.  Commented out the relevant sections in case
we want to add support for another version of ParaView in the future.

Needed to use the latest version of Units Library that supports "*" units.

This updates the bundle to agree with the Xcode usage now deployed on
machines.

Ryan Krattiger authored 1 year ago and Ben Boeckel committed 1 year ago

(cherry picked from commit 3a5e09fe)

With each entry on its own line, the differences are easier to see.

This will let SMTK have Python enabled as well.

Units is now built as a shared library.

Attribute Definition Processing has been split into 3 parts:
1. processDefinitionAtts which processes all of the XML Attributes assigned on the Definition XML node
2. prcoessDefinitionContents which processes all of the XML children nodes of  the Definition XML node
3. processDefinitionChildNode which will processes a single child of the Definition XML node

This will allow Definition to eventually use Template Blocks

Also refactored Category Processing into a similar pattern:
1. processCategoryAtts - processes all of the XML Attributes on a Attribute/Item Definition  XML Node
2. processOldStyleCategoryNode - processes the content of an old style "Categories" node
3. processItemDefCategoryInfoNode - processes the content of the current style "CategoryInfo" node

Added processItemDefCategoryInfoNode and processDefCategoryInfoNode for processing Category Information
for Item and Attribute Definitions respectively

XmlDocV1Parser refactored the following methods:

* processItemDef - split into the following:
  * processItemDef
  * processItemDefAtts - for processing XML Attributes on the ItemDefinition Node
  * processItemDefContents - for processing the children nodes of the ItemDefinition Node
  * processItemDefChildNode - for processing a child node of the ItemDefiniiton Node

* processStringDef - split into the following:
  * processStringDef
  * processStringDefAtts - for processing XML Attributes on the StringItemDefinition Node
  * processStringDefContents - for processing the children nodes of the StringItemDefinition Node
  * processStringDefChildNode - for processing a child node of the StringItemDefinition Node

* processDoubleDef - split into the following:
  * processDoubleDef
  * processDoubleDefContents - for processing the children nodes of the DoubleItemDefinition Node
  * processDoubleDefChildNode - for processing a child node of the DoubleItemDefinition Node

* processIntDef - split into the following:
  * processIntDef
  * processIntDefContents - for processing the children nodes of the IntItemDefinition Node
  * processIntDefChildNode - for processing a child node of the IntItemDefinition Node

Renamed internal helper template function processDerivedValueDef to processDerivedValueDefChildNode
which now returns a boolean

Also fixed sbt files that contained bad default value elements caught by these new changes.

Starting with Version 7 XML attribute template files, SMTK now supports Templates.  Templates are an extension to the existing ItemBlock concept.  The main difference between an ItemBlock and a Template is that a Template's contents can be parameterized.  When a Template is instantiated, these parameters can be assigned different values and will thereby change the information being copied.  a Template's parameter can also be given a default value.

**Note**  All parameters that do not have a default value must be given values when the Template is instanced.

Here is an example:

. code-block:: xml

  <Templates>

    <Template Name="SimpleStringDefault">
      <Parameters>
        <Param Name="a">dog</Param>
      </Parameters>
      <Contents>
        <DefaultValue>{a}</DefaultValue>
      </Contents>
    </Template>

    <Template Name="SimpleAttribute">
      <Parameters>
        <Param Name="type"/>
      </Parameters>
      <Contents>
        <AttDef Type="{type}">
          <ItemDefinitions>
            <String Name="s1">
              <Template Name="SimpleStringDefault">
                <Param Name="a">cat</Param>
              </Template>
            </String>
            <String Name="s2">
              <Template Name="SimpleStringDefault"/>
            </String>
            <String Name="s3">
              <Template Name="DiscreteStringInfo">
                <Param Name="defaultIndex">1</Param>
              </Template>
            </String>
          </ItemDefinitions>
        </AttDef>
      </Contents>
    </Template>
  </Templates>

  <Definitions>
    <Template Name="SimpleAttribute">
      <Param Name="type">A</Param>
    </Template>
  </Definitions>

See data/attribute/attribute_collection/TemplateTest.sbt and smtk/attribute/testing/cxx/unitTemplates.cxx for examples.  You can also read the discourse on the topic here: https://discourse.kitware.com/t/adding-parameterized-blocks-to-sbt-files/1013/4.

Windows test failures are expected until images are bumped again.

Disable fedora33_vtk_python3 until the base image is updated

Expanding Units Support in Attribute Resource
---------------------------------------------

SMTK's Attribute DoubleItems and DoubleItemDefinitions can now support units specified as Defaults
as well as values.  When a default's or value's units differ from those defined by the Item's Definition,
they are converted into the Definition's units.  If no conversion is possible then the method assigning
the default or value will fail.

The Item's value(...) methods will always return the value in the units specified in its Definition.
The Item's valueAsString(...) methods will always return a string based on the unconverted value

Developer changes
~~~~~~~~~~~~~~~~~~

SMTK Resources can now hold a units::System.  In the case of an Attribute Resource, it will have a
default units::System associated with it at construction time; however, this can be replaced as long
as there are no Definitions defined within the Resource.

New Resource Methods:
* setUnitsSystem(const shared_ptr<units::System> & unitsSystem)
* const shared_ptr<units::System> & unitsSystem() const;

All ItemDefintions now hold onto a units::System.  The methods are protected and are identical to the ones added to Resource.

DoubleItemDefinition has the following new methods:

* bool setDefaultValue(const double& val, const std::string& units);
* bool setDefaultValue(const std::vector<double>& vals, const std::string& units);
* bool setDefaultValueAsString(const std::string& val);
* bool setDefaultValueAsString(const std::vector<std::string>& vals);
* const std::string defaultValueAsString(std::size_t element = 0) const;
* const std::vector<std::string> defaultValuesAsStrings() const;

DoubleItem has the following new methods:

* bool setValue(std::size_t element, const double& val, const std::string& units);

In addition, DoubleItem::setValueFromString method can now handle strings that include a double
followed by an option units.  For example "20 m/s".

**See** smtk/attribute/testing/cxx/unitDoubleItem.cxx for an example of the new API.

ParaView 5.9 is only used for ace3p