HeatbugModelSwarm中buildActions部分,3个try分别是做什么?查了下refbook-java-2.2,解释太简略,还是不懂,高手指点,谢谢!代码如下:
5 J# `1 @4 P" }3 j. }$ `# E8 d2 H) _ r8 m
public Object buildActions () {5 e' O* t8 _ b1 w
super.buildActions();5 B/ |: g; x% ], M
) {0 j2 j2 h, D( x
// Create the list of simulation actions. We put these in9 @0 v8 R# a9 D6 F6 y7 S4 B4 c! n, \+ `
// an action group, because we want these actions to be
6 h; a/ p# K4 U) n' |( P // executed in a specific order, but these steps should
: `- D7 r0 z+ L: s; f2 Z // take no (simulated) time. The M(foo) means "The message d. [% Z# h; q2 U& i( T" w- f
// called <foo>". You can send a message To a particular
7 x/ ]6 Z1 x1 U6 A% K // object, or ForEach object in a collection.
$ Z8 \) |0 _ n4 e- A& K% M! Q
! M, A3 J& Y' c // Note we update the heatspace in two phases: first run7 C0 W7 M- }5 y5 i" Y
// diffusion, then run "updateWorld" to actually enact the# _) k" h8 w" y
// changes the heatbugs have made. The ordering here is& N z; s; g1 C% M F* H8 y4 a
// significant!% j0 |& I7 Q' b9 J: a6 T) r0 G' @
p; z( R8 q) j, v3 r( c# G
// Note also, that with the additional, [+ S1 x% G, _" S6 {8 S3 `/ J
// `randomizeHeatbugUpdateOrder' Boolean flag we can6 W( U0 N, G, m C2 S7 W
// randomize the order in which the bugs actually run
- f0 w; [4 x. o1 p b4 K: g6 C // their step rule. This has the effect of removing any
, y& r' G+ n6 ~, h( ^ // systematic bias in the iteration throught the heatbug' [. i: p7 c8 f p% k4 a( ]' a- f9 X
// list from timestep to timestep S" _/ f+ O7 s- [8 q A
+ A* _4 a8 D; k) L4 ? // By default, all `createActionForEach' modelActions have# W; g, b) Z- }/ V
// a default order of `Sequential', which means that the3 v$ }" p" Z/ t4 I! H$ {% H
// order of iteration through the `heatbugList' will be
& O( Z) E" I! Y; B3 | // identical (assuming the list order is not changed1 m( a9 T; K) O, L
// indirectly by some other process).8 `5 @! n% l( f% ^& y& T3 U, r
$ U: i, j( ]& s8 d- E
modelActions = new ActionGroupImpl (getZone ());
/ Q8 x1 N5 W' A# F1 @$ s) J4 M5 p& U& z, `. O" @5 t c
try {+ d+ h, ~$ C# `& \) o% ?* t
modelActions.createActionTo$message
2 Q2 |: j* g9 e( i7 k$ Q* l% } (heat, new Selector (heat.getClass (), "stepRule", false));
' w" T3 \1 K! t1 d* @0 P } catch (Exception e) {
6 l5 P% V4 L/ R* ~: L4 d* N System.err.println ("Exception stepRule: " + e.getMessage ());* T4 P4 A* l7 W/ F
} h: j/ t6 K) o: [3 J0 Z( I
$ g9 e6 h* x" e# x1 r n: b( B try {( F! ~' H) q# f: [% c
Heatbug proto = (Heatbug) heatbugList.get (0);
% h5 H; {! C) U& c. i Selector sel = ' A) Z5 z. m; y- h
new Selector (proto.getClass (), "heatbugStep", false);
7 Z9 j# c" S4 [* v. _7 t5 [6 J actionForEach =. L* Y; L; `# _+ d: Q' @
modelActions.createFActionForEachHomogeneous$call
0 ^+ i, J+ o5 v+ P& l! Y6 y' z- [ (heatbugList,' M% ~% J( K/ F! b: {+ f7 K0 v7 @
new FCallImpl (this, proto, sel,6 _( \ ?& X* V' Y5 N2 P
new FArgumentsImpl (this, sel)));8 Z5 I- E- r. t0 B+ S/ L |
} catch (Exception e) {
, w6 R4 K, F& {+ Y1 ~8 H e.printStackTrace (System.err);
! o: V; {# ?! l8 L. l }
* T1 ^& @: P" W9 i1 x! {
; X# H) ?/ l. X L9 k' d syncUpdateOrder ();
; O0 Q# p( C! H$ m/ J2 I$ W8 B
+ Z# \1 M. Y, S0 R/ R: d try {( A( t& ~2 Y* T5 k! P4 j
modelActions.createActionTo$message
7 s. O. N; Z4 R: l* O, x% W& y, M (heat, new Selector (heat.getClass (), "updateLattice", false));" U( ` I. n. e, I, n5 _, \
} catch (Exception e) { b, @8 `! G& |/ y7 A! [
System.err.println("Exception updateLattice: " + e.getMessage ());8 \/ ?8 l% G3 r, Q
}- p# g1 E( |3 Z! z( k, r% B& E
7 q4 H/ ]* i) o, o) ?/ B
// Then we create a schedule that executes the9 {% R( y, E L& {$ h' a0 e
// modelActions. modelActions is an ActionGroup, by itself it) R: E$ r( g) |- [/ q w8 F6 }
// has no notion of time. In order to have it executed in
1 T9 V* S; p( i' w. U5 }+ z // time, we create a Schedule that says to use the
7 N3 _: `* A3 J* y; N9 Y% | // modelActions ActionGroup at particular times. This' {/ |3 A; g/ A4 {: e7 v
// schedule has a repeat interval of 1, it will loop every
, z: V; ^7 a0 h6 Z // time step. The action is executed at time 0 relative to
0 w( C6 x* S) a/ t // the beginning of the loop.
r8 q6 M# }' ^: y
8 q! r4 b! I2 t( V4 q4 C // This is a simple schedule, with only one action that is& L8 y( [! R, c! H) k' v. \
// just repeated every time. See jmousetrap for more
! A/ P8 h6 T7 S7 e- g, U // complicated schedules.; ]! P8 W3 P: a: k/ P
; C# { u1 T" u) B7 u% n modelSchedule = new ScheduleImpl (getZone (), 1);% E3 r) y2 ^, B! d9 j! m
modelSchedule.at$createAction (0, modelActions);: N3 Q0 d7 X$ u0 L
" [' {4 T" _4 |! A return this;
: Z* L: n, Y& a* @& i } |