HeatbugModelSwarm中buildActions部分,3个try分别是做什么?查了下refbook-java-2.2,解释太简略,还是不懂,高手指点,谢谢!代码如下:6 s1 V% j6 U! h7 o; D7 s
1 r: [9 i, i) t0 U! K* I. k public Object buildActions () {" b0 ]! O6 a6 \9 E* _- L( ~3 C
super.buildActions();( ~- M3 l, B7 A0 n/ N. h( H8 r
; X' C0 A# V) T) v; A; Z; f // Create the list of simulation actions. We put these in4 z) i, D) G8 i" O1 s. r! \) _
// an action group, because we want these actions to be$ a/ f. ^9 Y& K' I! S! y
// executed in a specific order, but these steps should
( `! l& E1 E) u6 D7 _9 K // take no (simulated) time. The M(foo) means "The message
+ Y- o6 f0 ~9 g+ ~7 } // called <foo>". You can send a message To a particular
9 i0 |* i4 D. N% I5 W) m- Q& p# ` // object, or ForEach object in a collection.
% l3 O7 \* P! G' i" m
) Z6 I- r7 h! O // Note we update the heatspace in two phases: first run
9 W* t( m, u, m$ F ~ // diffusion, then run "updateWorld" to actually enact the6 u( O( [. P% w$ W( a
// changes the heatbugs have made. The ordering here is* [# ]# s- _5 G; Z* j
// significant!6 w/ V3 E& T! Q6 n+ W
2 x9 W% f8 r2 c! H$ l$ N1 \ // Note also, that with the additional
0 X3 g( V) n* N1 Y9 g // `randomizeHeatbugUpdateOrder' Boolean flag we can
& ^1 y9 V/ u! x: a // randomize the order in which the bugs actually run
7 q$ e e5 @- I8 I6 `9 p f // their step rule. This has the effect of removing any
% u0 k# Z, g' h( i' h) r6 { // systematic bias in the iteration throught the heatbug* T* V( n0 ~! J$ _( D
// list from timestep to timestep
; o# I2 z0 v4 m* P8 x
0 d3 }& @/ m3 S: o // By default, all `createActionForEach' modelActions have
d j+ N2 V) ^ // a default order of `Sequential', which means that the* r, b6 [# R! O; y) t
// order of iteration through the `heatbugList' will be- ~4 L& _$ t2 T% K/ X
// identical (assuming the list order is not changed# t W% b) y$ P0 K; I
// indirectly by some other process).
`& U6 X' ^+ g! E$ v
$ u# B: [- D" Z* {. E7 O ~ modelActions = new ActionGroupImpl (getZone ());
, y8 ~0 O" D4 l) k, `* M# T; O
4 H8 {0 h& ?! S! m2 { try {# ?' U& h; U5 ]# ?2 ]7 o% d
modelActions.createActionTo$message
9 }& x$ h9 {. [* {: l (heat, new Selector (heat.getClass (), "stepRule", false));
* s" z! q6 E( M* x } catch (Exception e) {1 _! T& F( u$ H3 ~) X+ E
System.err.println ("Exception stepRule: " + e.getMessage ());
: C. _# r# ?0 b8 R+ z; [ }
7 u5 |' F% t, t$ ~, w: [
: [" s7 B2 ` s5 D3 L try {
- b8 x% g$ R- Q2 e; s Heatbug proto = (Heatbug) heatbugList.get (0);
" r' b+ U8 F! H9 W Selector sel = 2 z [+ u, x( Z3 y
new Selector (proto.getClass (), "heatbugStep", false);% G9 l' X2 E! `; L
actionForEach =
. ^# r! Z, a1 E. @5 M# H& C modelActions.createFActionForEachHomogeneous$call
$ v" m0 p* O0 F) w8 K: n- R (heatbugList,
1 m7 [' S: K+ H9 w1 z4 l' f2 W, Q new FCallImpl (this, proto, sel,
. I4 u d$ r: {- F new FArgumentsImpl (this, sel)));
7 t: }/ S# _0 T8 e3 C } catch (Exception e) { P5 R+ u9 ~, U: `8 u% v
e.printStackTrace (System.err);& p) O: K5 b7 s& q& h
}
! y7 g; C1 A+ N
. H" l! P! |# }8 L2 y; n syncUpdateOrder ();
7 ?) J6 f/ z( W# F5 F% v
7 K, k/ l6 E7 u+ M, ^$ p0 g ^: w try {! C) F+ N0 \2 W: E6 z P5 c7 Z
modelActions.createActionTo$message 1 c5 `4 s* n' k' c' s+ S& c$ c
(heat, new Selector (heat.getClass (), "updateLattice", false));1 q/ {; Y: ^ G0 y1 N: O
} catch (Exception e) {
" D, ]8 A- v) g) J System.err.println("Exception updateLattice: " + e.getMessage ());
* ]8 m7 B+ e# G# V. ] K }
* H2 }1 C1 C5 ^: g, f$ b 3 p) z+ T3 u) L$ T& N
// Then we create a schedule that executes the1 W' b: T4 C9 `7 Z/ X/ I8 v
// modelActions. modelActions is an ActionGroup, by itself it5 a7 m+ e; t7 B- t% m, n& r: n
// has no notion of time. In order to have it executed in' ^+ K% ?9 C3 C( z8 P, g# `4 D
// time, we create a Schedule that says to use the
) T1 {& O3 v1 _6 r! i6 [ // modelActions ActionGroup at particular times. This
* F4 s8 j+ v8 @5 B( S/ D // schedule has a repeat interval of 1, it will loop every; I8 q$ o- F/ F
// time step. The action is executed at time 0 relative to b0 w' |5 }5 {- [- i4 U
// the beginning of the loop.6 a, x2 ^& W; G) ]
8 o7 N' v% R; ]% _- ]* l( _ // This is a simple schedule, with only one action that is: J# h1 I+ f( w* q# Y% {3 J) B2 q" @
// just repeated every time. See jmousetrap for more; s6 D6 `) [- W$ W3 t
// complicated schedules.
& h# l+ g }! X- G8 t4 g- b 8 w6 d; E' r$ j1 a0 x8 r+ [3 |
modelSchedule = new ScheduleImpl (getZone (), 1);* P+ I- [; `4 m7 D7 _
modelSchedule.at$createAction (0, modelActions);. ?! b& s+ A6 T8 Q
0 f+ L' v9 c" ?4 m( J2 f
return this;: i) X4 j: N( N; Q6 i* ]/ z
} |