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

sybbk

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

public Object buildActions () {
+ |7 l& q2 B/ a  Y- O: z# r# l    super.buildActions();
7 O# R3 I3 x) e3 w" [' Y   
4 X9 Z; b9 x( [( n* n0 E    // 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
& T0 V, ]6 \/ K& x    // take no (simulated) time. The M(foo) means "The message
    // called <foo>". You can send a message To a particular
- v' X6 [7 n* s5 z* v, D    // object, or ForEach object in a collection.
        
% H7 w! W' J8 D. G    // Note we update the heatspace in two phases: first run
1 z8 s) L* `! u4 B( b    // diffusion, then run "updateWorld" to actually enact the
    // changes the heatbugs have made. The ordering here is
; g+ M0 v' M/ z/ a- z    // significant!
! B1 J+ C3 l, }        
, B0 {9 o5 ]' w# h1 h; m5 f3 ~, k    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
, R8 [) z% e/ ~" b4 O4 L. v    // their step rule.  This has the effect of removing any
    // systematic bias in the iteration throught the heatbug
    // list from timestep to timestep
8 \# K$ s# Q$ Z( M, u0 B        
0 p7 g5 D1 `# s# z# z    // By default, all `createActionForEach' modelActions have
% C  Q; L0 x3 V  M  Z. ?% Y    // a default order of `Sequential', which means that the
) d8 ?5 x1 F% X( m    // order of iteration through the `heatbugList' will be
8 A6 z* ~: t$ h$ R; O4 F/ Q" n% l) L    // identical (assuming the list order is not changed
    // indirectly by some other process).
   
) L3 ?' H  c7 n2 p* `0 O8 w) ~. h    modelActions = new ActionGroupImpl (getZone ());

8 C$ R4 L" T1 w  ^    try {
2 ]! @$ v$ v2 k6 y) ?6 ?      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
    }
9 J. g- w5 M$ n
    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
+ Q2 N/ ^4 L; J; h/ q      Selector sel =
, Z, b+ R: u2 {0 l" C        new Selector (proto.getClass (), "heatbugStep", false);
# t0 E' P7 Q9 M1 A% Z, G      actionForEach =
        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
0 y" X% p: d3 q         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
1 K+ E; D6 ~! K: E; m) L* ~! u      e.printStackTrace (System.err);
    }
   
5 \5 U  Y6 @/ Q    syncUpdateOrder ();

! _7 n" ]% J* Y: d    try {
4 s! C9 P2 h, ^  L2 i+ f      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
, ?1 o1 ]! T; a    }
: N* s) y( Y9 e, k+ K$ O: b# D7 c& B# N        
, I, y, A, ^) E5 n- H+ D7 v    // Then we create a schedule that executes the
- o7 s6 O! Y! \/ \; C5 N. K    // 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
* W# E3 c1 y/ F( O9 p! ?- [. O    // schedule has a repeat interval of 1, it will loop every
; }3 [7 i$ z( Z. \# u    // time step.  The action is executed at time 0 relative to
3 n" k4 J3 N) X    // the beginning of the loop.
* Z4 W" M. ]4 b( g( Y- i
    // This is a simple schedule, with only one action that is
5 j4 ^+ z9 {) ?5 g, w# c    // just repeated every time. See jmousetrap for more
- t# q8 W" B/ J( K# ^* p$ {    // complicated schedules.
0 h! }+ L3 q( D' f+ u, }# t  
5 b' _& z; |% F/ P; _$ t1 B    modelSchedule = new ScheduleImpl (getZone (), 1);
" \# g4 S6 J) ~$ D( p& `    modelSchedule.at$createAction (0, modelActions);
        
    return this;
0 \; @# l$ n% w! }) a  }