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

sybbk

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

public Object buildActions () {
* x. p! U) h& L- p! `    super.buildActions();
$ P, ?/ ~, v# ^/ W  X  V   
5 M' b. H( H  R; C" s5 M    // 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
    // take no (simulated) time. The M(foo) means "The message
. F$ I; K: P4 s7 i    // called <foo>". You can send a message To a particular
  w) a  t/ x! _4 w0 g    // object, or ForEach object in a collection.
0 J1 d9 s! O2 W- r( R, ]        
    // 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!
        
    // Note also, that with the additional
/ H5 p" q, ^$ t    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
5 {- ^! |' n6 ]% }2 r    // their step rule.  This has the effect of removing any
    // systematic bias in the iteration throught the heatbug
$ [) u5 \5 T  L- }) H; H; j    // list from timestep to timestep
        
    // By default, all `createActionForEach' modelActions have
    // a default order of `Sequential', which means that the
0 x) T$ o+ _7 V' ?7 q% I8 T* I6 H    // order of iteration through the `heatbugList' will be
1 A' |& S" D6 g( {9 t2 E. @    // identical (assuming the list order is not changed
1 u. G0 p4 y3 e  g: M* A    // indirectly by some other process).
   
    modelActions = new ActionGroupImpl (getZone ());

4 |+ Z9 \/ H6 ~3 q$ b3 g    try {
8 D; k$ p! {5 g      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "stepRule", false));
+ u3 v& N5 q+ h: u- T    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
    }

+ J+ h4 ]/ E8 J1 |0 ?    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
      Selector sel =
1 `( }( ?$ e3 W        new Selector (proto.getClass (), "heatbugStep", false);
/ S! h2 ?" l) A/ Q! E; i      actionForEach =
+ I( \$ X% S/ C( s" T        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
         new FCallImpl (this, proto, sel,
1 J; A5 D7 v/ z2 c& H% [' K                        new FArgumentsImpl (this, sel)));
( h! M- ~8 j  _/ A5 W: p    } catch (Exception e) {
      e.printStackTrace (System.err);
    }
   
% w9 T% y. Y( b) ?3 I  l    syncUpdateOrder ();

+ E/ Q0 x4 m4 C: C, w3 W3 \    try {
* }% R: X5 W. E' x3 E; f- J      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
7 Q: n3 ?; {+ h8 E    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
2 F, M6 h2 G- |1 ^) \        
; C0 p! Q9 z+ x) }9 P  I    // Then we create a schedule that executes the
    // modelActions. modelActions is an ActionGroup, by itself it
( s* \) _& q: l    // has no notion of time. In order to have it executed in
    // time, we create a Schedule that says to use the
0 s& P" y8 M+ V    // modelActions ActionGroup at particular times.  This
4 x! Z  n; p" Z+ r! B9 i4 a; A    // schedule has a repeat interval of 1, it will loop every
: A5 `) G( Z! c" h    // time step.  The action is executed at time 0 relative to
- \; G- m+ x. g8 R/ Y1 x8 t    // the beginning of the loop.

    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
. M3 `; F) v, ]! r) d7 p    // complicated schedules.
  
1 m2 [& Z. ~4 J- c/ Y  L    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
0 _8 a: p% n( W" t6 O% {        
    return this;
  }