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

sybbk

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

public Object buildActions () {
% m- `! I* ]' Y. m$ O9 k    super.buildActions();
$ J5 N! `5 I# n( H( N   
    // Create the list of simulation actions. We put these in
    // an action group, because we want these actions to be
    // executed in a specific order, but these steps should
& }) H# |7 c& f5 I    // take no (simulated) time. The M(foo) means "The message
1 s- Z1 C2 J+ n, B" P2 H    // called <foo>". You can send a message To a particular
0 S3 p1 j! K, B    // object, or ForEach object in a collection.
: o! H2 `5 t) f6 j        
    // 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!
) t5 D" o8 O+ U5 V1 W        
' L8 m9 }4 K  g3 m5 v  K1 D    // 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
" g! h' v4 R( q: z6 s    // systematic bias in the iteration throught the heatbug
) A) z; u6 v5 o2 \  U5 D$ u5 E    // list from timestep to timestep
        
9 D6 }/ X; M: P- y    // By default, all `createActionForEach' modelActions have
/ E# u, L0 T1 k, l/ x    // a default order of `Sequential', which means that the
    // order of iteration through the `heatbugList' will be
) R" ~2 f  o0 |9 v! L7 o) s7 q5 q    // identical (assuming the list order is not changed
    // indirectly by some other process).
   
    modelActions = new ActionGroupImpl (getZone ());
; r4 r/ Y9 ?, Y# g2 d
  `' Y- D$ I2 C; `    try {
      modelActions.createActionTo$message
$ \1 |: ~9 _; S% q+ w        (heat, new Selector (heat.getClass (), "stepRule", false));
; |! l0 I5 e/ R    } catch (Exception e) {
$ z! X. f9 l9 V+ Z2 O      System.err.println ("Exception stepRule: " + e.getMessage ());
6 C/ {* I% f" X' O    }

  }9 x9 R9 \5 }5 v$ T# x6 p    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
$ ^: F  l, L  d$ C% Q      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
        modelActions.createFActionForEachHomogeneous$call
0 d3 S6 ~: C" Q; g& i        (heatbugList,
         new FCallImpl (this, proto, sel,
0 \( T1 e  v- W2 b  L6 R4 `& \                        new FArgumentsImpl (this, sel)));
+ {; x6 k8 }, M, V    } catch (Exception e) {
9 J( K/ r+ o/ z      e.printStackTrace (System.err);
    }
   
1 i& y* X6 C7 i    syncUpdateOrder ();

    try {
      modelActions.createActionTo$message
9 G- m5 T. L8 i        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
  g/ p7 ^0 D- o1 |4 A0 ]6 \    }
; ?# L/ ]7 I; A! k: j3 g        
    // Then we create a schedule that executes the
    // modelActions. modelActions is an ActionGroup, by itself it
    // has no notion of time. In order to have it executed in
    // 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
    // time step.  The action is executed at time 0 relative to
    // the beginning of the loop.

% l+ p- B& I' h1 l2 d    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
, u5 Y* x* b4 k, a1 w/ ~( }    // complicated schedules.
  
    modelSchedule = new ScheduleImpl (getZone (), 1);
9 ^0 j0 {. z+ r  S# {9 t    modelSchedule.at$createAction (0, modelActions);
" c! [+ y2 j* w- V2 c        
5 l" j& x3 p- A" M% J# A- j! ^2 E    return this;
  }