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

sybbk

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

- K6 ?) T/ B1 n  j1 ^3 j4 | public Object buildActions () {
4 P; d' S4 z! ~5 w" }    super.buildActions();
& o3 s* r; j0 p# M# r: Z; ]   
( O, d/ |+ B& |  F    // Create the list of simulation actions. We put these in
9 P1 T; M* z! p  N, Z" ?    // an action group, because we want these actions to be
# w" u3 ^- ?% R$ z! y, l+ f& a6 L    // executed in a specific order, but these steps should
    // take no (simulated) time. The M(foo) means "The message
4 u4 R5 Y4 R, A. F" u* N    // called <foo>". You can send a message To a particular
3 F* ?4 X2 z0 n2 ]3 {    // object, or ForEach object in a collection.
3 m/ d1 Q; E# N5 M/ q        
1 v/ e7 Y* ^( b( b    // 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!
3 ?9 Z- N( n7 S  J        
, c6 }9 }! H/ d, ^; t- W; ]% x    // Note also, that with the additional
3 u9 F5 G+ k8 z    // `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
% y" F1 X( c) W! d4 ?3 ^! v/ Y    // list from timestep to timestep
        
    // By default, all `createActionForEach' modelActions have
    // a default order of `Sequential', which means that the
    // order of iteration through the `heatbugList' will be
    // identical (assuming the list order is not changed
& t9 X( W/ }: m! n5 I' `4 T    // indirectly by some other process).
0 F2 L0 g* `# u" m5 ]7 u7 P   
    modelActions = new ActionGroupImpl (getZone ());
6 ~/ z; _3 H) v( K- O; s
    try {
      modelActions.createActionTo$message
% a& V1 w  ?6 o0 E/ m7 _        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
# P# F0 S/ y9 x4 p& `    }

    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
3 o& ~3 q/ n3 m5 p" F' _  k; V      actionForEach =
2 U1 y* C: ~$ R7 ~& u        modelActions.createFActionForEachHomogeneous$call
6 {: x3 p$ T6 J+ k3 e7 N        (heatbugList,
/ R& d& T7 S  H         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
% i3 K* I; w6 S7 J/ n    }
   
    syncUpdateOrder ();

3 j* C% j2 Y) I, J9 N& p$ A    try {
0 s. e+ |$ W$ |& x( g) V      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
, N: D3 i2 Z4 \8 H' c3 T        
    // Then we create a schedule that executes the
    // modelActions. modelActions is an ActionGroup, by itself it
% m, I: h) R1 `4 r! Y. v    // 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.
; c8 x% W/ h, Q; h+ C+ Y2 t
3 \" }$ r) Y& G% z0 c. r3 i    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
* a" Y# p. s! g4 r  N. }; h    // complicated schedules.
  
. e$ Q! A. u8 X' x  O! H    modelSchedule = new ScheduleImpl (getZone (), 1);
* M8 J* D+ H# r7 f; S: W    modelSchedule.at$createAction (0, modelActions);
5 b' v4 o/ D4 N+ u, z$ V0 [5 C        
    return this;
: G: y: G7 @4 ]8 V# s' }: W  }