Line data    Source code

       1             : // Author(s): Wieger Wesselink
       2             : // Copyright: see the accompanying file COPYING or copy at
       3             : // https://github.com/mCRL2org/mCRL2/blob/master/COPYING
       4             : //
       5             : // Distributed under the Boost Software License, Version 1.0.
       6             : // (See accompanying file LICENSE_1_0.txt or copy at
       7             : // http://www.boost.org/LICENSE_1_0.txt)
       8             : //
       9             : /// \file mcrl2/lps/traverser.h
      10             : /// \brief add your file description here.
      11             : 
      12             : // To avoid circular inclusion problems
      13             : 
      14             : #ifndef MCRL2_LPS_TRAVERSER_H
      15             : #define MCRL2_LPS_TRAVERSER_H
      16             : 
      17             : #include "mcrl2/lps/stochastic_specification.h"
      18             : #include "mcrl2/process/traverser.h"
      19             : 
      20             : namespace mcrl2
      21             : {
      22             : 
      23             : namespace lps
      24             : {
      25             : 
      26             : //--- start generated add_traverser_sort_expressions code ---//
      27             : template <template <class> class Traverser, class Derived>
      28             : struct add_traverser_sort_expressions: public Traverser<Derived>
      29             : {
      30             :   typedef Traverser<Derived> super;
      31             :   using super::enter;
      32             :   using super::leave;
      33             :   using super::apply;
      34             : 
      35        2357 :   void apply(const lps::deadlock& x)
      36             :   {
      37        2357 :     static_cast<Derived&>(*this).enter(x);
      38        2357 :     if (x.has_time())
      39             :     {
      40         401 :       static_cast<Derived&>(*this).apply(x.time());
      41             :     }
      42        2357 :     static_cast<Derived&>(*this).leave(x);
      43        2357 :   }
      44             : 
      45        6108 :   void apply(const lps::multi_action& x)
      46             :   {
      47        6108 :     static_cast<Derived&>(*this).enter(x);
      48        6108 :     static_cast<Derived&>(*this).apply(x.actions());
      49        6108 :     if (x.has_time())
      50             :     {
      51         890 :       static_cast<Derived&>(*this).apply(x.time());
      52             :     }
      53        6108 :     static_cast<Derived&>(*this).leave(x);
      54        6108 :   }
      55             : 
      56        2357 :   void apply(const lps::deadlock_summand& x)
      57             :   {
      58        2357 :     static_cast<Derived&>(*this).enter(x);
      59        2357 :     static_cast<Derived&>(*this).apply(x.summation_variables());
      60        2357 :     static_cast<Derived&>(*this).apply(x.condition());
      61        2357 :     static_cast<Derived&>(*this).apply(x.deadlock());
      62        2357 :     static_cast<Derived&>(*this).leave(x);
      63        2357 :   }
      64             : 
      65         739 :   void apply(const lps::action_summand& x)
      66             :   {
      67         739 :     static_cast<Derived&>(*this).enter(x);
      68         739 :     static_cast<Derived&>(*this).apply(x.summation_variables());
      69         739 :     static_cast<Derived&>(*this).apply(x.condition());
      70         739 :     static_cast<Derived&>(*this).apply(x.multi_action());
      71         739 :     static_cast<Derived&>(*this).apply(x.assignments());
      72         739 :     static_cast<Derived&>(*this).leave(x);
      73         739 :   }
      74             : 
      75         275 :   void apply(const lps::process_initializer& x)
      76             :   {
      77         275 :     static_cast<Derived&>(*this).enter(x);
      78         275 :     static_cast<Derived&>(*this).apply(x.expressions());
      79         275 :     static_cast<Derived&>(*this).leave(x);
      80         275 :   }
      81             : 
      82         275 :   void apply(const lps::linear_process& x)
      83             :   {
      84         275 :     static_cast<Derived&>(*this).enter(x);
      85         275 :     static_cast<Derived&>(*this).apply(x.process_parameters());
      86         275 :     static_cast<Derived&>(*this).apply(x.deadlock_summands());
      87         275 :     static_cast<Derived&>(*this).apply(x.action_summands());
      88         275 :     static_cast<Derived&>(*this).leave(x);
      89         275 :   }
      90             : 
      91         275 :   void apply(const lps::specification& x)
      92             :   {
      93         275 :     static_cast<Derived&>(*this).enter(x);
      94         275 :     static_cast<Derived&>(*this).apply(x.action_labels());
      95         275 :     static_cast<Derived&>(*this).apply(x.global_variables());
      96         275 :     static_cast<Derived&>(*this).apply(x.process());
      97         275 :     static_cast<Derived&>(*this).apply(x.initial_process());
      98         275 :     static_cast<Derived&>(*this).leave(x);
      99         275 :   }
     100             : 
     101        7875 :   void apply(const lps::stochastic_distribution& x)
     102             :   {
     103        7875 :     static_cast<Derived&>(*this).enter(x);
     104        7875 :     static_cast<Derived&>(*this).apply(x.variables());
     105        7875 :     if (x.is_defined()) { static_cast<Derived&>(*this).apply(x.distribution()); }
     106        7875 :     static_cast<Derived&>(*this).leave(x);
     107        7875 :   }
     108             : 
     109        5369 :   void apply(const lps::stochastic_action_summand& x)
     110             :   {
     111        5369 :     static_cast<Derived&>(*this).enter(x);
     112        5369 :     static_cast<Derived&>(*this).apply(x.summation_variables());
     113        5369 :     static_cast<Derived&>(*this).apply(x.condition());
     114        5369 :     static_cast<Derived&>(*this).apply(x.multi_action());
     115        5369 :     static_cast<Derived&>(*this).apply(x.assignments());
     116        5369 :     static_cast<Derived&>(*this).apply(x.distribution());
     117        5369 :     static_cast<Derived&>(*this).leave(x);
     118        5369 :   }
     119             : 
     120        2506 :   void apply(const lps::stochastic_linear_process& x)
     121             :   {
     122        2506 :     static_cast<Derived&>(*this).enter(x);
     123        2506 :     static_cast<Derived&>(*this).apply(x.process_parameters());
     124        2506 :     static_cast<Derived&>(*this).apply(x.deadlock_summands());
     125        2506 :     static_cast<Derived&>(*this).apply(x.action_summands());
     126        2506 :     static_cast<Derived&>(*this).leave(x);
     127        2506 :   }
     128             : 
     129        2506 :   void apply(const lps::stochastic_specification& x)
     130             :   {
     131        2506 :     static_cast<Derived&>(*this).enter(x);
     132        2506 :     static_cast<Derived&>(*this).apply(x.action_labels());
     133        2506 :     static_cast<Derived&>(*this).apply(x.global_variables());
     134        2506 :     static_cast<Derived&>(*this).apply(x.process());
     135        2506 :     static_cast<Derived&>(*this).apply(x.initial_process());
     136        2506 :     static_cast<Derived&>(*this).leave(x);
     137        2506 :   }
     138             : 
     139        2506 :   void apply(const lps::stochastic_process_initializer& x)
     140             :   {
     141        2506 :     static_cast<Derived&>(*this).enter(x);
     142        2506 :     static_cast<Derived&>(*this).apply(x.expressions());
     143        2506 :     static_cast<Derived&>(*this).apply(x.distribution());
     144        2506 :     static_cast<Derived&>(*this).leave(x);
     145        2506 :   }
     146             : 
     147             : };
     148             : 
     149             : /// \\brief Traverser class
     150             : template <typename Derived>
     151             : struct sort_expression_traverser: public add_traverser_sort_expressions<process::sort_expression_traverser, Derived>
     152             : {
     153             : };
     154             : //--- end generated add_traverser_sort_expressions code ---//
     155             : 
     156             : //--- start generated add_traverser_data_expressions code ---//
     157             : template <template <class> class Traverser, class Derived>
     158             : struct add_traverser_data_expressions: public Traverser<Derived>
     159             : {
     160             :   typedef Traverser<Derived> super;
     161             :   using super::enter;
     162             :   using super::leave;
     163             :   using super::apply;
     164             : 
     165        1296 :   void apply(const lps::deadlock& x)
     166             :   {
     167        1296 :     static_cast<Derived&>(*this).enter(x);
     168        1296 :     if (x.has_time())
     169             :     {
     170         112 :       static_cast<Derived&>(*this).apply(x.time());
     171             :     }
     172        1296 :     static_cast<Derived&>(*this).leave(x);
     173        1296 :   }
     174             : 
     175       17983 :   void apply(const lps::multi_action& x)
     176             :   {
     177       17983 :     static_cast<Derived&>(*this).enter(x);
     178       17983 :     static_cast<Derived&>(*this).apply(x.actions());
     179       17983 :     if (x.has_time())
     180             :     {
     181         485 :       static_cast<Derived&>(*this).apply(x.time());
     182             :     }
     183       17983 :     static_cast<Derived&>(*this).leave(x);
     184       17983 :   }
     185             : 
     186        1294 :   void apply(const lps::deadlock_summand& x)
     187             :   {
     188        1294 :     static_cast<Derived&>(*this).enter(x);
     189        1294 :     static_cast<Derived&>(*this).apply(x.condition());
     190        1294 :     static_cast<Derived&>(*this).apply(x.deadlock());
     191        1294 :     static_cast<Derived&>(*this).leave(x);
     192        1294 :   }
     193             : 
     194          90 :   void apply(const lps::action_summand& x)
     195             :   {
     196          90 :     static_cast<Derived&>(*this).enter(x);
     197          90 :     static_cast<Derived&>(*this).apply(x.condition());
     198          90 :     static_cast<Derived&>(*this).apply(x.multi_action());
     199          90 :     static_cast<Derived&>(*this).apply(x.assignments());
     200          90 :     static_cast<Derived&>(*this).leave(x);
     201          90 :   }
     202             : 
     203          18 :   void apply(const lps::process_initializer& x)
     204             :   {
     205          18 :     static_cast<Derived&>(*this).enter(x);
     206          18 :     static_cast<Derived&>(*this).apply(x.expressions());
     207          18 :     static_cast<Derived&>(*this).leave(x);
     208          18 :   }
     209             : 
     210          53 :   void apply(const lps::linear_process& x)
     211             :   {
     212          53 :     static_cast<Derived&>(*this).enter(x);
     213          53 :     static_cast<Derived&>(*this).apply(x.deadlock_summands());
     214          53 :     static_cast<Derived&>(*this).apply(x.action_summands());
     215          53 :     static_cast<Derived&>(*this).leave(x);
     216          53 :   }
     217             : 
     218          18 :   void apply(const lps::specification& x)
     219             :   {
     220          18 :     static_cast<Derived&>(*this).enter(x);
     221          18 :     static_cast<Derived&>(*this).apply(x.process());
     222          18 :     static_cast<Derived&>(*this).apply(x.initial_process());
     223          18 :     static_cast<Derived&>(*this).leave(x);
     224          18 :   }
     225             : 
     226        3302 :   void apply(const lps::stochastic_distribution& x)
     227             :   {
     228        3302 :     static_cast<Derived&>(*this).enter(x);
     229        3302 :     if (x.is_defined()) { static_cast<Derived&>(*this).apply(x.distribution()); }
     230        3302 :     static_cast<Derived&>(*this).leave(x);
     231        3302 :   }
     232             : 
     233        3171 :   void apply(const lps::stochastic_action_summand& x)
     234             :   {
     235        3171 :     static_cast<Derived&>(*this).enter(x);
     236        3171 :     static_cast<Derived&>(*this).apply(x.condition());
     237        3171 :     static_cast<Derived&>(*this).apply(x.multi_action());
     238        3171 :     static_cast<Derived&>(*this).apply(x.assignments());
     239        3171 :     static_cast<Derived&>(*this).apply(x.distribution());
     240        3171 :     static_cast<Derived&>(*this).leave(x);
     241        3171 :   }
     242             : 
     243         824 :   void apply(const lps::stochastic_linear_process& x)
     244             :   {
     245         824 :     static_cast<Derived&>(*this).enter(x);
     246         824 :     static_cast<Derived&>(*this).apply(x.deadlock_summands());
     247         824 :     static_cast<Derived&>(*this).apply(x.action_summands());
     248         824 :     static_cast<Derived&>(*this).leave(x);
     249         824 :   }
     250             : 
     251         823 :   void apply(const lps::stochastic_specification& x)
     252             :   {
     253         823 :     static_cast<Derived&>(*this).enter(x);
     254         823 :     static_cast<Derived&>(*this).apply(x.process());
     255         823 :     static_cast<Derived&>(*this).apply(x.initial_process());
     256         823 :     static_cast<Derived&>(*this).leave(x);
     257         823 :   }
     258             : 
     259         823 :   void apply(const lps::stochastic_process_initializer& x)
     260             :   {
     261         823 :     static_cast<Derived&>(*this).enter(x);
     262         823 :     static_cast<Derived&>(*this).apply(x.expressions());
     263         823 :     static_cast<Derived&>(*this).apply(x.distribution());
     264         823 :     static_cast<Derived&>(*this).leave(x);
     265         823 :   }
     266             : 
     267             : };
     268             : 
     269             : /// \\brief Traverser class
     270             : template <typename Derived>
     271             : struct data_expression_traverser: public add_traverser_data_expressions<process::data_expression_traverser, Derived>
     272             : {
     273             : };
     274             : //--- end generated add_traverser_data_expressions code ---//
     275             : 
     276             : //--- start generated add_traverser_variables code ---//
     277             : template <template <class> class Traverser, class Derived>
     278             : struct add_traverser_variables: public Traverser<Derived>
     279             : {
     280             :   typedef Traverser<Derived> super;
     281             :   using super::enter;
     282             :   using super::leave;
     283             :   using super::apply;
     284             : 
     285          84 :   void apply(const lps::deadlock& x)
     286             :   {
     287          84 :     static_cast<Derived&>(*this).enter(x);
     288          84 :     if (x.has_time())
     289             :     {
     290           0 :       static_cast<Derived&>(*this).apply(x.time());
     291             :     }
     292          84 :     static_cast<Derived&>(*this).leave(x);
     293          84 :   }
     294             : 
     295         616 :   void apply(const lps::multi_action& x)
     296             :   {
     297         616 :     static_cast<Derived&>(*this).enter(x);
     298         616 :     static_cast<Derived&>(*this).apply(x.actions());
     299         616 :     if (x.has_time())
     300             :     {
     301           4 :       static_cast<Derived&>(*this).apply(x.time());
     302             :     }
     303         616 :     static_cast<Derived&>(*this).leave(x);
     304         616 :   }
     305             : 
     306          81 :   void apply(const lps::deadlock_summand& x)
     307             :   {
     308          81 :     static_cast<Derived&>(*this).enter(x);
     309          81 :     static_cast<Derived&>(*this).apply(x.summation_variables());
     310          81 :     static_cast<Derived&>(*this).apply(x.condition());
     311          81 :     static_cast<Derived&>(*this).apply(x.deadlock());
     312          81 :     static_cast<Derived&>(*this).leave(x);
     313          81 :   }
     314             : 
     315         579 :   void apply(const lps::action_summand& x)
     316             :   {
     317         579 :     static_cast<Derived&>(*this).enter(x);
     318         579 :     static_cast<Derived&>(*this).apply(x.summation_variables());
     319         579 :     static_cast<Derived&>(*this).apply(x.condition());
     320         579 :     static_cast<Derived&>(*this).apply(x.multi_action());
     321         579 :     static_cast<Derived&>(*this).apply(x.assignments());
     322         579 :     static_cast<Derived&>(*this).leave(x);
     323         579 :   }
     324             : 
     325         130 :   void apply(const lps::process_initializer& x)
     326             :   {
     327         130 :     static_cast<Derived&>(*this).enter(x);
     328         130 :     static_cast<Derived&>(*this).apply(x.expressions());
     329         130 :     static_cast<Derived&>(*this).leave(x);
     330         130 :   }
     331             : 
     332         130 :   void apply(const lps::linear_process& x)
     333             :   {
     334         130 :     static_cast<Derived&>(*this).enter(x);
     335         130 :     static_cast<Derived&>(*this).apply(x.process_parameters());
     336         130 :     static_cast<Derived&>(*this).apply(x.deadlock_summands());
     337         130 :     static_cast<Derived&>(*this).apply(x.action_summands());
     338         130 :     static_cast<Derived&>(*this).leave(x);
     339         130 :   }
     340             : 
     341         130 :   void apply(const lps::specification& x)
     342             :   {
     343         130 :     static_cast<Derived&>(*this).enter(x);
     344         130 :     static_cast<Derived&>(*this).apply(x.global_variables());
     345         130 :     static_cast<Derived&>(*this).apply(x.process());
     346         130 :     static_cast<Derived&>(*this).apply(x.initial_process());
     347         130 :     static_cast<Derived&>(*this).leave(x);
     348         130 :   }
     349             : 
     350          21 :   void apply(const lps::stochastic_distribution& x)
     351             :   {
     352          21 :     static_cast<Derived&>(*this).enter(x);
     353          21 :     static_cast<Derived&>(*this).apply(x.variables());
     354          21 :     if (x.is_defined()) { static_cast<Derived&>(*this).apply(x.distribution()); }
     355          21 :     static_cast<Derived&>(*this).leave(x);
     356          21 :   }
     357             : 
     358          10 :   void apply(const lps::stochastic_action_summand& x)
     359             :   {
     360          10 :     static_cast<Derived&>(*this).enter(x);
     361          10 :     static_cast<Derived&>(*this).apply(x.summation_variables());
     362          10 :     static_cast<Derived&>(*this).apply(x.condition());
     363          10 :     static_cast<Derived&>(*this).apply(x.multi_action());
     364          10 :     static_cast<Derived&>(*this).apply(x.assignments());
     365          10 :     static_cast<Derived&>(*this).apply(x.distribution());
     366          10 :     static_cast<Derived&>(*this).leave(x);
     367          10 :   }
     368             : 
     369           1 :   void apply(const lps::stochastic_linear_process& x)
     370             :   {
     371           1 :     static_cast<Derived&>(*this).enter(x);
     372           1 :     static_cast<Derived&>(*this).apply(x.process_parameters());
     373           1 :     static_cast<Derived&>(*this).apply(x.deadlock_summands());
     374           1 :     static_cast<Derived&>(*this).apply(x.action_summands());
     375           1 :     static_cast<Derived&>(*this).leave(x);
     376           1 :   }
     377             : 
     378           1 :   void apply(const lps::stochastic_specification& x)
     379             :   {
     380           1 :     static_cast<Derived&>(*this).enter(x);
     381           1 :     static_cast<Derived&>(*this).apply(x.global_variables());
     382           1 :     static_cast<Derived&>(*this).apply(x.process());
     383           1 :     static_cast<Derived&>(*this).apply(x.initial_process());
     384           1 :     static_cast<Derived&>(*this).leave(x);
     385           1 :   }
     386             : 
     387           1 :   void apply(const lps::stochastic_process_initializer& x)
     388             :   {
     389           1 :     static_cast<Derived&>(*this).enter(x);
     390           1 :     static_cast<Derived&>(*this).apply(x.expressions());
     391           1 :     static_cast<Derived&>(*this).apply(x.distribution());
     392           1 :     static_cast<Derived&>(*this).leave(x);
     393           1 :   }
     394             : 
     395             : };
     396             : 
     397             : /// \\brief Traverser class
     398             : template <typename Derived>
     399             : struct variable_traverser: public add_traverser_variables<process::variable_traverser, Derived>
     400             : {
     401             : };
     402             : //--- end generated add_traverser_variables code ---//
     403             : 
     404             : //--- start generated add_traverser_identifier_strings code ---//
     405             : template <template <class> class Traverser, class Derived>
     406             : struct add_traverser_identifier_strings: public Traverser<Derived>
     407             : {
     408             :   typedef Traverser<Derived> super;
     409             :   using super::enter;
     410             :   using super::leave;
     411             :   using super::apply;
     412             : 
     413         288 :   void apply(const lps::deadlock& x)
     414             :   {
     415         288 :     static_cast<Derived&>(*this).enter(x);
     416         288 :     if (x.has_time())
     417             :     {
     418           0 :       static_cast<Derived&>(*this).apply(x.time());
     419             :     }
     420         288 :     static_cast<Derived&>(*this).leave(x);
     421         288 :   }
     422             : 
     423        2959 :   void apply(const lps::multi_action& x)
     424             :   {
     425        2959 :     static_cast<Derived&>(*this).enter(x);
     426        2959 :     static_cast<Derived&>(*this).apply(x.actions());
     427        2959 :     if (x.has_time())
     428             :     {
     429          36 :       static_cast<Derived&>(*this).apply(x.time());
     430             :     }
     431        2959 :     static_cast<Derived&>(*this).leave(x);
     432        2959 :   }
     433             : 
     434         288 :   void apply(const lps::deadlock_summand& x)
     435             :   {
     436         288 :     static_cast<Derived&>(*this).enter(x);
     437         288 :     static_cast<Derived&>(*this).apply(x.summation_variables());
     438         288 :     static_cast<Derived&>(*this).apply(x.condition());
     439         288 :     static_cast<Derived&>(*this).apply(x.deadlock());
     440         288 :     static_cast<Derived&>(*this).leave(x);
     441         288 :   }
     442             : 
     443         488 :   void apply(const lps::action_summand& x)
     444             :   {
     445         488 :     static_cast<Derived&>(*this).enter(x);
     446         488 :     static_cast<Derived&>(*this).apply(x.summation_variables());
     447         488 :     static_cast<Derived&>(*this).apply(x.condition());
     448         488 :     static_cast<Derived&>(*this).apply(x.multi_action());
     449         488 :     static_cast<Derived&>(*this).apply(x.assignments());
     450         488 :     static_cast<Derived&>(*this).leave(x);
     451         488 :   }
     452             : 
     453         209 :   void apply(const lps::process_initializer& x)
     454             :   {
     455         209 :     static_cast<Derived&>(*this).enter(x);
     456         209 :     static_cast<Derived&>(*this).apply(x.expressions());
     457         209 :     static_cast<Derived&>(*this).leave(x);
     458         209 :   }
     459             : 
     460         209 :   void apply(const lps::linear_process& x)
     461             :   {
     462         209 :     static_cast<Derived&>(*this).enter(x);
     463         209 :     static_cast<Derived&>(*this).apply(x.process_parameters());
     464         209 :     static_cast<Derived&>(*this).apply(x.deadlock_summands());
     465         209 :     static_cast<Derived&>(*this).apply(x.action_summands());
     466         209 :     static_cast<Derived&>(*this).leave(x);
     467         209 :   }
     468             : 
     469         209 :   void apply(const lps::specification& x)
     470             :   {
     471         209 :     static_cast<Derived&>(*this).enter(x);
     472         209 :     static_cast<Derived&>(*this).apply(x.action_labels());
     473         209 :     static_cast<Derived&>(*this).apply(x.global_variables());
     474         209 :     static_cast<Derived&>(*this).apply(x.process());
     475         209 :     static_cast<Derived&>(*this).apply(x.initial_process());
     476         209 :     static_cast<Derived&>(*this).leave(x);
     477         209 :   }
     478             : 
     479        2789 :   void apply(const lps::stochastic_distribution& x)
     480             :   {
     481        2789 :     static_cast<Derived&>(*this).enter(x);
     482        2789 :     static_cast<Derived&>(*this).apply(x.variables());
     483        2789 :     if (x.is_defined()) { static_cast<Derived&>(*this).apply(x.distribution()); }
     484        2789 :     static_cast<Derived&>(*this).leave(x);
     485        2789 :   }
     486             : 
     487        2471 :   void apply(const lps::stochastic_action_summand& x)
     488             :   {
     489        2471 :     static_cast<Derived&>(*this).enter(x);
     490        2471 :     static_cast<Derived&>(*this).apply(x.summation_variables());
     491        2471 :     static_cast<Derived&>(*this).apply(x.condition());
     492        2471 :     static_cast<Derived&>(*this).apply(x.multi_action());
     493        2471 :     static_cast<Derived&>(*this).apply(x.assignments());
     494        2471 :     static_cast<Derived&>(*this).apply(x.distribution());
     495        2471 :     static_cast<Derived&>(*this).leave(x);
     496        2471 :   }
     497             : 
     498         319 :   void apply(const lps::stochastic_linear_process& x)
     499             :   {
     500         319 :     static_cast<Derived&>(*this).enter(x);
     501         319 :     static_cast<Derived&>(*this).apply(x.process_parameters());
     502         319 :     static_cast<Derived&>(*this).apply(x.deadlock_summands());
     503         319 :     static_cast<Derived&>(*this).apply(x.action_summands());
     504         319 :     static_cast<Derived&>(*this).leave(x);
     505         319 :   }
     506             : 
     507         318 :   void apply(const lps::stochastic_specification& x)
     508             :   {
     509         318 :     static_cast<Derived&>(*this).enter(x);
     510         318 :     static_cast<Derived&>(*this).apply(x.action_labels());
     511         318 :     static_cast<Derived&>(*this).apply(x.global_variables());
     512         318 :     static_cast<Derived&>(*this).apply(x.process());
     513         318 :     static_cast<Derived&>(*this).apply(x.initial_process());
     514         318 :     static_cast<Derived&>(*this).leave(x);
     515         318 :   }
     516             : 
     517         318 :   void apply(const lps::stochastic_process_initializer& x)
     518             :   {
     519         318 :     static_cast<Derived&>(*this).enter(x);
     520         318 :     static_cast<Derived&>(*this).apply(x.expressions());
     521         318 :     static_cast<Derived&>(*this).apply(x.distribution());
     522         318 :     static_cast<Derived&>(*this).leave(x);
     523         318 :   }
     524             : 
     525             : };
     526             : 
     527             : /// \\brief Traverser class
     528             : template <typename Derived>
     529             : struct identifier_string_traverser: public add_traverser_identifier_strings<process::identifier_string_traverser, Derived>
     530             : {
     531             : };
     532             : //--- end generated add_traverser_identifier_strings code ---//
     533             : 
     534             : //--- start generated add_traverser_action_labels code ---//
     535             : template <template <class> class Traverser, class Derived>
     536             : struct add_traverser_action_labels: public Traverser<Derived>
     537             : {
     538             :   typedef Traverser<Derived> super;
     539             :   using super::enter;
     540             :   using super::leave;
     541             :   using super::apply;
     542             : 
     543           0 :   void apply(const lps::multi_action& x)
     544             :   {
     545           0 :     static_cast<Derived&>(*this).enter(x);
     546           0 :     static_cast<Derived&>(*this).apply(x.actions());
     547           0 :     static_cast<Derived&>(*this).leave(x);
     548           0 :   }
     549             : 
     550           0 :   void apply(const lps::action_summand& x)
     551             :   {
     552           0 :     static_cast<Derived&>(*this).enter(x);
     553           0 :     static_cast<Derived&>(*this).apply(x.multi_action());
     554           0 :     static_cast<Derived&>(*this).leave(x);
     555           0 :   }
     556             : 
     557           0 :   void apply(const lps::linear_process& x)
     558             :   {
     559           0 :     static_cast<Derived&>(*this).enter(x);
     560           0 :     static_cast<Derived&>(*this).apply(x.action_summands());
     561           0 :     static_cast<Derived&>(*this).leave(x);
     562           0 :   }
     563             : 
     564           0 :   void apply(const lps::specification& x)
     565             :   {
     566           0 :     static_cast<Derived&>(*this).enter(x);
     567           0 :     static_cast<Derived&>(*this).apply(x.action_labels());
     568           0 :     static_cast<Derived&>(*this).apply(x.process());
     569           0 :     static_cast<Derived&>(*this).leave(x);
     570           0 :   }
     571             : 
     572           0 :   void apply(const lps::stochastic_action_summand& x)
     573             :   {
     574           0 :     static_cast<Derived&>(*this).enter(x);
     575           0 :     static_cast<Derived&>(*this).apply(x.multi_action());
     576           0 :     static_cast<Derived&>(*this).leave(x);
     577           0 :   }
     578             : 
     579           0 :   void apply(const lps::stochastic_linear_process& x)
     580             :   {
     581           0 :     static_cast<Derived&>(*this).enter(x);
     582           0 :     static_cast<Derived&>(*this).apply(x.action_summands());
     583           0 :     static_cast<Derived&>(*this).leave(x);
     584           0 :   }
     585             : 
     586           0 :   void apply(const lps::stochastic_specification& x)
     587             :   {
     588           0 :     static_cast<Derived&>(*this).enter(x);
     589           0 :     static_cast<Derived&>(*this).apply(x.action_labels());
     590           0 :     static_cast<Derived&>(*this).apply(x.process());
     591           0 :     static_cast<Derived&>(*this).leave(x);
     592           0 :   }
     593             : 
     594             : };
     595             : 
     596             : /// \\brief Traverser class
     597             : template <typename Derived>
     598             : struct action_label_traverser: public add_traverser_action_labels<process::action_label_traverser, Derived>
     599             : {
     600             : };
     601             : //--- end generated add_traverser_action_labels code ---//
     602             : 
     603             : } // namespace lps
     604             : 
     605             : } // namespace mcrl2
     606             : 
     607             : #endif // MCRL2_LPS_TRAVERSER_H