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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：

public Object buildActions () {
    super.buildActions();
   
    // Create the list of simulation actions. We put these in
    // an action group, because we want these actions to be
% M0 d: G; Z7 s    // executed in a specific order, but these steps should
# n" n6 e2 E- N4 _, v$ i    // take no (simulated) time. The M(foo) means "The message
    // called <foo>". You can send a message To a particular
3 f) z* h; g: H4 t3 j/ A    // object, or ForEach object in a collection.
/ ?6 v* X3 O9 ~+ j$ f' C2 w; X        
    // Note we update the heatspace in two phases: first run
    // diffusion, then run "updateWorld" to actually enact the
    // changes the heatbugs have made. The ordering here is
    // significant!
        
' n$ N$ e" e- \    // 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
1 i* ~+ [5 I! R( t2 _    // list from timestep to timestep
        
    // By default, all `createActionForEach' modelActions have
) t/ p# s" k* |0 |6 @" E- b    // a default order of `Sequential', which means that the
( K9 ?7 ]$ n7 f; C    // order of iteration through the `heatbugList' will be
    // identical (assuming the list order is not changed
    // indirectly by some other process).
   
    modelActions = new ActionGroupImpl (getZone ());
# w6 _, }* X9 X( b; x* K
# f# A6 ~6 E8 M    try {
* R& H0 t6 O5 i7 B% |2 s, y. A      modelActions.createActionTo$message
8 j0 r: ?/ |# s9 L( s+ s! m        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
    }
5 m4 z* u9 h  ~- {
# s- a( A' {& }& K: y    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
8 f# K1 G) n7 w7 ~1 }5 l& u* M/ o4 G      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
0 M6 ?! N. T2 T; S3 `. H6 N         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
# K3 O" M( ~7 _+ s5 |- m    } catch (Exception e) {
      e.printStackTrace (System.err);
    }
   
    syncUpdateOrder ();

    try {
      modelActions.createActionTo$message
9 y4 E; K8 L/ Q; i  R        (heat, new Selector (heat.getClass (), "updateLattice", false));
$ d2 R& S7 \# @8 U4 w- O6 |2 V    } catch (Exception e) {
& P( r6 k$ M, d+ |( t      System.err.println("Exception updateLattice: " + e.getMessage ());
$ {6 a6 N# |2 g& @5 f    }
        
. h. |9 s" f' F7 a    // Then we create a schedule that executes the
1 ]9 T0 Y  n5 C  ]1 ~6 `" @$ @    // modelActions. modelActions is an ActionGroup, by itself it
4 Z9 v8 {8 r! B) }& E; |    // has no notion of time. In order to have it executed in
    // time, we create a Schedule that says to use the
( P7 l! G3 P0 G# D  l. N    // modelActions ActionGroup at particular times.  This
    // schedule has a repeat interval of 1, it will loop every
    // time step.  The action is executed at time 0 relative to
. a* D5 J- U5 Q, ^- R    // the beginning of the loop.
/ {: U  }2 U3 [
    // This is a simple schedule, with only one action that is
2 [" I. V: T/ d; o& a# m" }1 m* Q/ Y    // just repeated every time. See jmousetrap for more
    // complicated schedules.
' e8 ^  B/ B2 B6 z% x  
" k7 v+ y; O6 e9 H9 M7 U7 Z0 e1 L    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
" Z6 k: |+ z& V* ^$ V. _        
6 U7 k& Z: ~  h0 X* J/ e    return this;
# \1 F$ F6 k0 s) Q% [1 E6 s' X, U  }