问jheatbugs-2001-03-28中某些代码

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
% q6 T/ m' l$ A& E7 Q$ m2 [9 L! ]
public Object buildActions () {
& ^3 {% h9 q! |$ M, v9 `. x; G    super.buildActions();
( ]$ N! f# _- n) {   
    // Create the list of simulation actions. We put these in
    // an action group, because we want these actions to be
+ \8 X- f* _% `    // executed in a specific order, but these steps should
    // take no (simulated) time. The M(foo) means "The message
  B; V9 b$ C, j# }6 {/ Z- ~    // called <foo>". You can send a message To a particular
    // object, or ForEach object in a collection.
        
    // Note we update the heatspace in two phases: first run
    // diffusion, then run "updateWorld" to actually enact the
- E) Z7 Q$ O+ S3 q    // changes the heatbugs have made. The ordering here is
0 d2 z2 v$ k  m) y5 }, D1 l. Z    // significant!
$ o+ }5 n1 S# [3 n  P. |/ E        
2 ~: w! c1 A2 O& L6 w. m, h( L    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
    // their step rule.  This has the effect of removing any
    // systematic bias in the iteration throught the heatbug
6 Q1 P8 y7 G$ F0 \    // list from timestep to timestep
% \/ s! S& j" F) F& i        
) M9 L% G4 O6 Z2 e    // By default, all `createActionForEach' modelActions have
    // a default order of `Sequential', which means that the
5 H- h$ B/ P8 C7 o    // order of iteration through the `heatbugList' will be
    // identical (assuming the list order is not changed
& ]$ P: @3 i, ?: ]4 ~  q: _8 k    // indirectly by some other process).
   
* ]8 ~% D, O9 y. O! A3 C    modelActions = new ActionGroupImpl (getZone ());

5 r' h- x7 ?& c1 @    try {
      modelActions.createActionTo$message
% s, C+ O6 v6 |5 q0 m, Q/ F/ D; T        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
' X& B9 O' m0 W! @) d      System.err.println ("Exception stepRule: " + e.getMessage ());
    }

" \5 e$ I5 Z& n    try {
' s* Q* G9 C: [% h+ o0 Q      Heatbug proto = (Heatbug) heatbugList.get (0);
3 f3 Q: B, A' c0 J$ X/ ~      Selector sel =
0 o* p8 T. F/ v! x8 M( d: a        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
        modelActions.createFActionForEachHomogeneous$call
) A5 w; J" y) o        (heatbugList,
: P/ j3 b; c. X7 c" ]1 M# A5 c         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
    }
   
: [1 \, [$ L4 H  A- _3 a3 ?    syncUpdateOrder ();

+ S5 R, ?0 e, o" B+ `4 g  x, s* G    try {
      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
: u: o& ]' Y. @) D8 b& k    }
* b  M( L; Y/ z        
    // Then we create a schedule that executes the
( a. E* }, [3 O( Z9 T    // modelActions. modelActions is an ActionGroup, by itself it
- W; ~1 f$ g% K, v) z& X    // has no notion of time. In order to have it executed in
) f& ^5 U7 k% @6 z    // time, we create a Schedule that says to use the
    // modelActions ActionGroup at particular times.  This
    // schedule has a repeat interval of 1, it will loop every
9 _0 k6 c+ L1 O2 G    // time step.  The action is executed at time 0 relative to
4 V- ?! h9 F) d! F: l% F    // the beginning of the loop.
5 Y. D2 ^0 G8 ?& a7 H
    // This is a simple schedule, with only one action that is
( {1 H# \: m# d! B, O    // just repeated every time. See jmousetrap for more
7 h9 j- C  {0 i; [    // complicated schedules.
  
; s/ Q* U. P0 z& y  G; E6 |  j' c; B( J    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
        
7 U: U: o. r5 S* [& Z$ |1 o    return this;
2 Q$ h, X2 o2 Y7 U1 G* N  }