Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "Attributes.h"
      11             : 
      12             : #include "TaggingInterface.h"
      13             : #include "BoundaryRestrictable.h"
      14             : #include "BlockRestrictable.h"
      15             : #include "SetupInterface.h"
      16             : #include "MooseVariableInterface.h"
      17             : #include "MooseVariableFE.h"
      18             : #include "ElementUserObject.h"
      19             : #include "SideUserObject.h"
      20             : #include "InternalSideUserObject.h"
      21             : #include "InterfaceUserObject.h"
      22             : #include "NodalUserObject.h"
      23             : #include "GeneralUserObject.h"
      24             : #include "ThreadedGeneralUserObject.h"
      25             : #include "ShapeUserObject.h"
      26             : #include "ShapeSideUserObject.h"
      27             : #include "ShapeElementUserObject.h"
      28             : #include "Reporter.h"
      29             : #include "SystemBase.h"
      30             : #include "DomainUserObject.h"
      31             : #include "MortarUserObject.h"
      32             : #include "FVInterpolationMethod.h"
      33             : #include "ExecFlagRegistry.h"
      34             : 
      35             : #include <algorithm>
      36             : 
      37             : const ExecFlagType AttribExecOns::EXEC_ALL = registerExecFlag("ALL");
      38             : 
      39             : std::ostream &
      40           0 : operator<<(std::ostream & os, Interfaces & iface)
      41             : {
      42           0 :   os << "Interfaces(";
      43           0 :   if (static_cast<bool>(iface & Interfaces::UserObject))
      44           0 :     os << "|UserObject";
      45           0 :   if (static_cast<bool>(iface & Interfaces::ElementUserObject))
      46           0 :     os << "|ElementUserObject";
      47           0 :   if (static_cast<bool>(iface & Interfaces::SideUserObject))
      48           0 :     os << "|SideUserObject";
      49           0 :   if (static_cast<bool>(iface & Interfaces::InternalSideUserObject))
      50           0 :     os << "|InternalSideUserObject";
      51           0 :   if (static_cast<bool>(iface & Interfaces::NodalUserObject))
      52           0 :     os << "|NodalUserObject";
      53           0 :   if (static_cast<bool>(iface & Interfaces::GeneralUserObject))
      54           0 :     os << "|GeneralUserObject";
      55           0 :   if (static_cast<bool>(iface & Interfaces::ThreadedGeneralUserObject))
      56           0 :     os << "|ThreadedGeneralUserObject";
      57           0 :   if (static_cast<bool>(iface & Interfaces::ShapeElementUserObject))
      58           0 :     os << "|ShapeElementUserObject";
      59           0 :   if (static_cast<bool>(iface & Interfaces::ShapeSideUserObject))
      60           0 :     os << "|ShapeSideUserObject";
      61           0 :   if (static_cast<bool>(iface & Interfaces::Postprocessor))
      62           0 :     os << "|Postprocessor";
      63           0 :   if (static_cast<bool>(iface & Interfaces::VectorPostprocessor))
      64           0 :     os << "|VectorPostprocessor";
      65           0 :   if (static_cast<bool>(iface & Interfaces::InterfaceUserObject))
      66           0 :     os << "|InterfaceUserObject";
      67           0 :   if (static_cast<bool>(iface & Interfaces::Reporter))
      68           0 :     os << "|Reporter";
      69           0 :   if (static_cast<bool>(iface & Interfaces::DomainUserObject))
      70           0 :     os << "|DomainUserObject";
      71           0 :   if (static_cast<bool>(iface & Interfaces::MortarUserObject))
      72           0 :     os << "|MortarUserObject";
      73           0 :   if (static_cast<bool>(iface & Interfaces::FVInterpolationMethod))
      74           0 :     os << "|FVInterpolationMethod";
      75           0 :   os << ")";
      76           0 :   return os;
      77             : }
      78             : 
      79             : bool
      80       41291 : AttribTagBase::isMatch(const Attribute & other) const
      81             : {
      82       41291 :   auto a = dynamic_cast<const AttribTagBase *>(&other);
      83       41291 :   if (!a)
      84           0 :     return false;
      85       41291 :   if (a->_vals.size() == 0)
      86           0 :     return true; // the condition is empty tags - which we take to mean any tag should match
      87             : 
      88             :   // return true if any single tag matches between the two attribute objects
      89       42321 :   for (auto val : _vals)
      90       41267 :     if (std::find(a->_vals.begin(), a->_vals.end(), val) != a->_vals.end())
      91       40237 :       return true;
      92        1054 :   return false;
      93             : }
      94             : 
      95             : bool
      96     7214512 : AttribTagBase::isEqual(const Attribute & other) const
      97             : {
      98     7214512 :   auto a = dynamic_cast<const AttribTagBase *>(&other);
      99     7214512 :   if (!a || a->_vals.size() != _vals.size())
     100           0 :     return false;
     101             : 
     102    24290462 :   for (size_t i = 0; i < a->_vals.size(); i++)
     103    17075950 :     if (a->_vals[i] != _vals[i])
     104           0 :       return false;
     105     7214512 :   return true;
     106             : }
     107             : 
     108             : void
     109      310924 : AttribMatrixTags::initFrom(const MooseObject * obj)
     110             : {
     111      310924 :   _vals.clear();
     112      310924 :   auto t = dynamic_cast<const TaggingInterface *>(obj);
     113      310924 :   if (t)
     114             :   {
     115      458568 :     for (auto & tag : t->getMatrixTags({}))
     116      273905 :       _vals.push_back(static_cast<int>(tag));
     117             :   }
     118      310924 : }
     119             : 
     120             : void
     121      310924 : AttribVectorTags::initFrom(const MooseObject * obj)
     122             : {
     123      310924 :   _vals.clear();
     124      310924 :   auto t = dynamic_cast<const TaggingInterface *>(obj);
     125      310924 :   if (t)
     126             :   {
     127      373071 :     for (auto & tag : t->getVectorTags({}))
     128      188408 :       _vals.push_back(static_cast<int>(tag));
     129             :   }
     130      310924 : }
     131             : 
     132             : void
     133      310924 : AttribExecOns::initFrom(const MooseObject * obj)
     134             : {
     135      310924 :   _vals.clear();
     136      310924 :   if (const auto sup = dynamic_cast<const SetupInterface *>(obj))
     137             :   {
     138      264138 :     const auto & current_items = sup->getExecuteOnEnum();
     139      264138 :     _vals.reserve(current_items.size());
     140      357552 :     for (auto & on : current_items)
     141       93414 :       _vals.push_back(on);
     142             :   }
     143      310924 : }
     144             : 
     145             : bool
     146     3150183 : AttribExecOns::isMatch(const Attribute & other) const
     147             : {
     148     3150183 :   auto a = dynamic_cast<const AttribExecOns *>(&other);
     149     3150183 :   if (!a || a->_vals.empty())
     150           0 :     return false;
     151     3150183 :   auto cond = a->_vals[0];
     152     3150183 :   if (cond == EXEC_ALL)
     153        1092 :     return true;
     154             : 
     155     5205855 :   for (const auto val : _vals)
     156     3740021 :     if (val == EXEC_ALL || val == cond)
     157     1683257 :       return true;
     158     1465834 :   return false;
     159             : }
     160             : 
     161             : bool
     162    32345128 : AttribExecOns::isEqual(const Attribute & other) const
     163             : {
     164    32345128 :   auto a = dynamic_cast<const AttribExecOns *>(&other);
     165    32345128 :   if (!a || a->_vals.size() != _vals.size())
     166           0 :     return false;
     167             : 
     168    64690256 :   for (size_t i = 0; i < a->_vals.size(); i++)
     169    32345128 :     if (a->_vals[i] != _vals[i])
     170           0 :       return false;
     171    32345128 :   return true;
     172             : }
     173             : 
     174             : void
     175      310924 : AttribSubdomains::initFrom(const MooseObject * obj)
     176             : {
     177      310924 :   _vals.clear();
     178      310924 :   auto blk = dynamic_cast<const BlockRestrictable *>(obj);
     179      310924 :   if (blk && blk->blockRestricted())
     180             :   {
     181       36675 :     for (auto id : blk->blockIDs())
     182       20399 :       _vals.push_back(id);
     183             :   }
     184             :   else
     185      294648 :     _vals.push_back(Moose::ANY_BLOCK_ID);
     186      310924 : }
     187             : 
     188             : bool
     189     1030922 : AttribSubdomains::isMatch(const Attribute & other) const
     190             : {
     191     1030922 :   auto a = dynamic_cast<const AttribSubdomains *>(&other);
     192     1030922 :   if (!a || a->_vals.size() < 1)
     193           0 :     return false;
     194             : 
     195     1030922 :   auto cond = a->_vals[0];
     196     1030922 :   if (cond == Moose::ANY_BLOCK_ID)
     197           0 :     return true;
     198     1030922 :   else if (cond == Moose::INVALID_BLOCK_ID)
     199        6578 :     return false;
     200             : 
     201     1170982 :   for (auto id : _vals)
     202             :   {
     203     1073366 :     if (id == cond || id == Moose::ANY_BLOCK_ID)
     204      926728 :       return true;
     205             :   }
     206       97616 :   return false;
     207             : }
     208             : 
     209             : bool
     210     5968609 : AttribSubdomains::isEqual(const Attribute & other) const
     211             : {
     212     5968609 :   auto a = dynamic_cast<const AttribSubdomains *>(&other);
     213     5968609 :   if (!a || a->_vals.size() != _vals.size())
     214           0 :     return false;
     215             : 
     216    11937218 :   for (size_t i = 0; i < a->_vals.size(); i++)
     217     5968609 :     if (a->_vals[i] != _vals[i])
     218           0 :       return false;
     219     5968609 :   return true;
     220             : }
     221             : 
     222             : void
     223      310924 : AttribBoundaries::initFrom(const MooseObject * obj)
     224             : {
     225      310924 :   _vals.clear();
     226      310924 :   auto bnd = dynamic_cast<const BoundaryRestrictable *>(obj);
     227      310924 :   if (bnd && bnd->boundaryRestricted())
     228             :   {
     229      210498 :     for (auto & bound : bnd->boundaryIDs())
     230      118565 :       _vals.push_back(bound);
     231             :   }
     232             :   else
     233      218991 :     _vals.push_back(Moose::ANY_BOUNDARY_ID);
     234      310924 : }
     235             : 
     236             : bool
     237      716449 : AttribBoundaries::isMatch(const Attribute & other) const
     238             : {
     239      716449 :   auto a = dynamic_cast<const AttribBoundaries *>(&other);
     240      716449 :   if (!a || a->_vals.size() < 1)
     241           0 :     return false;
     242             : 
     243             :   // return true if a single tag matches between the two attribute objects
     244      984126 :   for (auto val : _vals)
     245             :   {
     246      798168 :     if (!a->_must_be_restricted && (val == Moose::ANY_BOUNDARY_ID))
     247      530491 :       return true;
     248      353499 :     if (std::find(a->_vals.begin(), a->_vals.end(), val) != a->_vals.end())
     249       80944 :       return true;
     250      272555 :     else if (std::find(a->_vals.begin(), a->_vals.end(), Moose::ANY_BOUNDARY_ID) != a->_vals.end())
     251        4878 :       return true;
     252             :   }
     253      185958 :   return false;
     254             : }
     255             : 
     256             : bool
     257    10170008 : AttribBoundaries::isEqual(const Attribute & other) const
     258             : {
     259    10170008 :   auto a = dynamic_cast<const AttribBoundaries *>(&other);
     260    10170008 :   if (!a || a->_vals.size() != _vals.size())
     261           0 :     return false;
     262             : 
     263    20340016 :   for (size_t i = 0; i < a->_vals.size(); i++)
     264    10170008 :     if (a->_vals[i] != _vals[i])
     265           0 :       return false;
     266    10170008 :   return true;
     267             : }
     268             : 
     269             : void
     270      310924 : AttribThread::initFrom(const MooseObject * obj)
     271             : {
     272      621848 :   _val = obj->getParam<THREAD_ID>("_tid");
     273      310924 : }
     274             : bool
     275    25173903 : AttribThread::isMatch(const Attribute & other) const
     276             : {
     277    25173903 :   auto a = dynamic_cast<const AttribThread *>(&other);
     278    25173903 :   return a && (a->_val == _val);
     279             : }
     280             : bool
     281    22011356 : AttribThread::isEqual(const Attribute & other) const
     282             : {
     283    22011356 :   return isMatch(other);
     284             : }
     285             : 
     286             : void
     287      310924 : AttribExecutionOrderGroup::initFrom(const MooseObject * obj)
     288             : {
     289      310924 :   const auto * uo = dynamic_cast<const UserObjectBase *>(obj);
     290      386564 :   _val = uo ? uo->getParam<int>("execution_order_group") : 0;
     291      310924 : }
     292             : bool
     293    10209655 : AttribExecutionOrderGroup::isMatch(const Attribute & other) const
     294             : {
     295    10209655 :   auto a = dynamic_cast<const AttribExecutionOrderGroup *>(&other);
     296    10209655 :   return a && (a->_val == _val);
     297             : }
     298             : bool
     299     8776765 : AttribExecutionOrderGroup::isEqual(const Attribute & other) const
     300             : {
     301     8776765 :   return isMatch(other);
     302             : }
     303             : 
     304             : void
     305      310924 : AttribSysNum::initFrom(const MooseObject * obj)
     306             : {
     307      621848 :   auto * sys = obj->getParam<SystemBase *>("_sys");
     308             : 
     309      310924 :   if (sys)
     310      310495 :     _val = sys->number();
     311      310924 : }
     312             : 
     313             : bool
     314     8880237 : AttribSysNum::isMatch(const Attribute & other) const
     315             : {
     316     8880237 :   auto a = dynamic_cast<const AttribSysNum *>(&other);
     317     8880237 :   return a && (a->_val == _val);
     318             : }
     319             : 
     320             : bool
     321     8156839 : AttribSysNum::isEqual(const Attribute & other) const
     322             : {
     323     8156839 :   return isMatch(other);
     324             : }
     325             : 
     326             : void
     327      310924 : AttribPreIC::initFrom(const MooseObject * /*obj*/)
     328             : {
     329      310924 : }
     330             : bool
     331       15361 : AttribPreIC::isMatch(const Attribute & other) const
     332             : {
     333       15361 :   auto a = dynamic_cast<const AttribPreIC *>(&other);
     334       15361 :   return a && (a->_val == _val);
     335             : }
     336             : 
     337             : bool
     338          61 : AttribPreIC::isEqual(const Attribute & other) const
     339             : {
     340          61 :   return isMatch(other);
     341             : }
     342             : 
     343             : bool
     344      179255 : AttribPreAux::isMatch(const Attribute & other) const
     345             : {
     346      179255 :   const auto a = dynamic_cast<const AttribPreAux *>(&other);
     347             : 
     348      179255 :   bool is_match = false;
     349             : 
     350      179255 :   if (a && !_vals.empty() && !a->_vals.empty())
     351             :   {
     352       57422 :     is_match = std::includes(_vals.begin(), _vals.end(), a->_vals.begin(), a->_vals.end()) ||
     353        3954 :                std::includes(a->_vals.begin(), a->_vals.end(), _vals.begin(), _vals.end());
     354             :   }
     355             : 
     356      179255 :   return is_match;
     357             : }
     358             : 
     359             : bool
     360     9242481 : AttribPreAux::isEqual(const Attribute & other) const
     361             : {
     362     9242481 :   const auto a = dynamic_cast<const AttribPreAux *>(&other);
     363     9242481 :   return a && a->_vals == _vals;
     364             : }
     365             : 
     366             : void
     367      310924 : AttribPreAux::initFrom(const MooseObject * /*obj*/)
     368             : {
     369      310924 : }
     370             : 
     371             : bool
     372     1486259 : AttribPostAux::isMatch(const Attribute & other) const
     373             : {
     374     1486259 :   const auto a = dynamic_cast<const AttribPostAux *>(&other);
     375             : 
     376     1486259 :   bool is_match = false;
     377             : 
     378     1486259 :   if (a && !_vals.empty() && !a->_vals.empty())
     379             :   {
     380     1493317 :     is_match = std::includes(_vals.begin(), _vals.end(), a->_vals.begin(), a->_vals.end()) ||
     381       11912 :                std::includes(a->_vals.begin(), a->_vals.end(), _vals.begin(), _vals.end());
     382             :   }
     383             : 
     384     1486259 :   return is_match;
     385             : }
     386             : 
     387             : bool
     388    17668541 : AttribPostAux::isEqual(const Attribute & other) const
     389             : {
     390    17668541 :   const auto a = dynamic_cast<const AttribPostAux *>(&other);
     391    17668541 :   return a && a->_vals == _vals;
     392             : }
     393             : 
     394             : void
     395      310924 : AttribPostAux::initFrom(const MooseObject * /*obj*/)
     396             : {
     397      310924 : }
     398             : 
     399             : void
     400      310924 : AttribName::initFrom(const MooseObject * obj)
     401             : {
     402      310924 :   _val = obj->name();
     403      310924 : }
     404             : bool
     405     1495278 : AttribName::isMatch(const Attribute & other) const
     406             : {
     407     1495278 :   auto a = dynamic_cast<const AttribName *>(&other);
     408     1495278 :   return a && (a->_val == _val);
     409             : }
     410             : 
     411             : bool
     412     1264793 : AttribName::isEqual(const Attribute & other) const
     413             : {
     414     1264793 :   return isMatch(other);
     415             : }
     416             : 
     417             : void
     418      310924 : AttribSystem::initFrom(const MooseObject * obj)
     419             : {
     420      310924 :   _val = obj->parameters().getSystemAttributeName();
     421      310924 : }
     422             : 
     423             : bool
     424    71855597 : AttribSystem::isMatch(const Attribute & other) const
     425             : {
     426    71855597 :   auto a = dynamic_cast<const AttribSystem *>(&other);
     427    71855597 :   return a && (a->_val == _val);
     428             : }
     429             : 
     430             : bool
     431    49624317 : AttribSystem::isEqual(const Attribute & other) const
     432             : {
     433    49624317 :   return isMatch(other);
     434             : }
     435             : 
     436             : void
     437      310924 : AttribKokkos::initFrom(const MooseObject * obj)
     438             : {
     439             : #ifdef MOOSE_KOKKOS_ENABLED
     440      237311 :   _val = obj->isKokkosObject();
     441             : #else
     442             :   static_cast<void>(obj);
     443       73613 :   _val = false;
     444             : #endif
     445      310924 : }
     446             : 
     447             : bool
     448      277211 : AttribKokkos::isMatch(const Attribute & other) const
     449             : {
     450      277211 :   auto a = dynamic_cast<const AttribKokkos *>(&other);
     451      277211 :   return a && (a->_val == _val);
     452             : }
     453             : 
     454             : bool
     455      256938 : AttribKokkos::isEqual(const Attribute & other) const
     456             : {
     457      256938 :   return isMatch(other);
     458             : }
     459             : 
     460             : void
     461      310924 : AttribResidualObject::initFrom(const MooseObject * obj)
     462             : {
     463      621848 :   _val = obj->getParam<bool>("_residual_object");
     464      310924 :   _initd = true;
     465      310924 : }
     466             : 
     467             : bool
     468           0 : AttribResidualObject::isMatch(const Attribute & other) const
     469             : {
     470           0 :   auto a = dynamic_cast<const AttribResidualObject *>(&other);
     471           0 :   return _initd && a && a->_initd && (a->_val == _val);
     472             : }
     473             : 
     474             : bool
     475           0 : AttribResidualObject::isEqual(const Attribute & other) const
     476             : {
     477           0 :   return isMatch(other);
     478             : }
     479             : 
     480             : void
     481      310924 : AttribVar::initFrom(const MooseObject * obj)
     482             : {
     483      310924 :   auto vi = dynamic_cast<const MooseVariableInterface<Real> *>(obj);
     484      310924 :   if (vi)
     485      208400 :     _val = static_cast<int>(vi->mooseVariableBase()->number());
     486      310924 : }
     487             : bool
     488      189469 : AttribVar::isMatch(const Attribute & other) const
     489             : {
     490      189469 :   auto a = dynamic_cast<const AttribVar *>(&other);
     491      189469 :   return a && (_val != -1) && (a->_val == _val);
     492             : }
     493             : 
     494             : bool
     495      128534 : AttribVar::isEqual(const Attribute & other) const
     496             : {
     497      128534 :   return isMatch(other);
     498             : }
     499             : 
     500             : void
     501      310924 : AttribInterfaces::initFrom(const MooseObject * obj)
     502             : {
     503      310924 :   _val = 0;
     504             :   // clang-format off
     505      310924 :   _val |= (unsigned int)Interfaces::UserObject                * (dynamic_cast<const UserObjectBase *>(obj) != nullptr);
     506      310924 :   _val |= (unsigned int)Interfaces::ElementUserObject         * (dynamic_cast<const ElementUserObject *>(obj) != nullptr);
     507      310924 :   _val |= (unsigned int)Interfaces::SideUserObject            * (dynamic_cast<const SideUserObject *>(obj) != nullptr);
     508      310924 :   _val |= (unsigned int)Interfaces::InternalSideUserObject    * (dynamic_cast<const InternalSideUserObject *>(obj) != nullptr);
     509      310924 :   _val |= (unsigned int)Interfaces::InterfaceUserObject       * (dynamic_cast<const InterfaceUserObject *>(obj) != nullptr);
     510      310924 :   _val |= (unsigned int)Interfaces::NodalUserObject           * (dynamic_cast<const NodalUserObject *>(obj) != nullptr);
     511      310924 :   _val |= (unsigned int)Interfaces::GeneralUserObject         * (dynamic_cast<const GeneralUserObject *>(obj) != nullptr);
     512      310924 :   _val |= (unsigned int)Interfaces::ThreadedGeneralUserObject * (dynamic_cast<const ThreadedGeneralUserObject *>(obj) != nullptr);
     513      310924 :   _val |= (unsigned int)Interfaces::ShapeElementUserObject    * (dynamic_cast<const ShapeElementUserObject *>(obj) != nullptr);
     514      310924 :   _val |= (unsigned int)Interfaces::ShapeSideUserObject       * (dynamic_cast<const ShapeSideUserObject *>(obj) != nullptr);
     515      310924 :   _val |= (unsigned int)Interfaces::Postprocessor             * (dynamic_cast<const Postprocessor *>(obj) != nullptr);
     516      310924 :   _val |= (unsigned int)Interfaces::VectorPostprocessor       * (dynamic_cast<const VectorPostprocessor *>(obj) != nullptr);
     517      310924 :   _val |= (unsigned int)Interfaces::BlockRestrictable         * (dynamic_cast<const BlockRestrictable *>(obj) != nullptr);
     518      310924 :   _val |= (unsigned int)Interfaces::BoundaryRestrictable      * (dynamic_cast<const BoundaryRestrictable *>(obj) != nullptr);
     519      310924 :   _val |= (unsigned int)Interfaces::Reporter                  * (dynamic_cast<const Reporter *>(obj) != nullptr);
     520      310924 :   _val |= (unsigned int)Interfaces::DomainUserObject          * (dynamic_cast<const DomainUserObject *>(obj) != nullptr);
     521      310924 :   _val |= (unsigned int)Interfaces::MortarUserObject          * (dynamic_cast<const MortarUserObject *>(obj) != nullptr);
     522      310924 :   _val |= (unsigned int)Interfaces::FVInterpolationMethod     * (dynamic_cast<const FVInterpolationMethod *>(obj) != nullptr);
     523             :   // clang-format on
     524      310924 : }
     525             : 
     526             : bool
     527     5309346 : AttribInterfaces::isMatch(const Attribute & other) const
     528             : {
     529     5309346 :   auto a = dynamic_cast<const AttribInterfaces *>(&other);
     530     5309346 :   return a && (a->_val & _val);
     531             : }
     532             : 
     533             : bool
     534    15038517 : AttribInterfaces::isEqual(const Attribute & other) const
     535             : {
     536    15038517 :   auto a = dynamic_cast<const AttribInterfaces *>(&other);
     537    15038517 :   return a && (a->_val == _val);
     538             : }
     539             : 
     540             : void
     541      310924 : AttribDisplaced::initFrom(const MooseObject * obj)
     542             : {
     543      568748 :   _val = obj->parameters().have_parameter<bool>("use_displaced_mesh") &&
     544      826572 :          obj->getParam<bool>("use_displaced_mesh");
     545      310924 : }
     546             : 
     547             : bool
     548     6988454 : AttribDisplaced::isMatch(const Attribute & other) const
     549             : {
     550     6988454 :   auto a = dynamic_cast<const AttribDisplaced *>(&other);
     551     6988454 :   return a && (a->_val == _val);
     552             : }
     553             : 
     554             : bool
     555     6947277 : AttribDisplaced::isEqual(const Attribute & other) const
     556             : {
     557     6947277 :   return isMatch(other);
     558             : }