HeatbugModelSwarm中buildActions部分,3个try分别是做什么?查了下refbook-java-2.2,解释太简略,还是不懂,高手指点,谢谢!代码如下:
# T3 ]- W4 g/ N4 e6 v
+ ]; z3 C. l! K public Object buildActions () {8 w( G9 o7 o9 x0 I3 U
super.buildActions();! B U# [ g1 y2 l3 B. w
; a5 t2 R4 I" d+ s8 _+ y5 S# v1 t, b // Create the list of simulation actions. We put these in
! Y- i: P5 x6 I: }; n // an action group, because we want these actions to be' Y; b3 h J7 s1 N
// executed in a specific order, but these steps should
: O2 g/ k3 Q3 V4 f // take no (simulated) time. The M(foo) means "The message
' s# n9 A F7 P9 ^2 [2 ? // called <foo>". You can send a message To a particular
) H1 I/ w0 p1 j) S8 H // object, or ForEach object in a collection.+ m% Q9 [7 y* V" ?* |
; m# | {: ?/ F! ?& s P
// Note we update the heatspace in two phases: first run
! [/ q9 O! q& Q) T4 V9 o) q // diffusion, then run "updateWorld" to actually enact the% a' \6 F/ L+ ]
// changes the heatbugs have made. The ordering here is
& {# k! A# S \2 U1 t' e // significant!2 Y5 n7 c! J7 I0 Y, B* |
; p2 s: [$ Q* W. b# \* R6 }3 e7 y // Note also, that with the additional
, f/ _# J) ~% y* L5 z // `randomizeHeatbugUpdateOrder' Boolean flag we can. L: B7 n6 j" D$ k
// randomize the order in which the bugs actually run
) S6 ~2 L/ A7 B0 P9 N# W& z Y1 R // their step rule. This has the effect of removing any
$ E4 N9 }: b2 E o- O // systematic bias in the iteration throught the heatbug
% T! Z3 U9 e. K. b# f // list from timestep to timestep/ c1 D V( j1 s! v1 v
/ |6 t H5 R/ B( v
// By default, all `createActionForEach' modelActions have5 @0 A7 G! I1 \ x% D- i i
// a default order of `Sequential', which means that the
& Y2 _4 B+ K( D# x& z3 |% S: R' D s* S // order of iteration through the `heatbugList' will be6 A. l6 L0 r$ r$ d6 D
// identical (assuming the list order is not changed2 u, r( O9 {6 D# _0 B, B
// indirectly by some other process). u0 B9 u3 F( R" S% _, N; o* H+ M! {
. J P$ w. X/ Q& j' L modelActions = new ActionGroupImpl (getZone ());
+ z( J( ^6 r% |& w. X- _! S2 ` S$ j+ I9 h( G3 K9 ]
try {
: w/ `; s' r" Z4 T. k) P u8 a modelActions.createActionTo$message& z5 j) B) X. H; v# ?0 c
(heat, new Selector (heat.getClass (), "stepRule", false));; u& z& _$ r7 F) t
} catch (Exception e) {
. ~4 E0 x* {' l' P3 q System.err.println ("Exception stepRule: " + e.getMessage ());0 H& P/ F+ _: z9 r% z6 E$ I" |% ?2 v
}# t3 G) m8 I5 v+ y1 `! g
2 e ^6 D: M- e
try {
: k7 ~, u- @0 V+ n Heatbug proto = (Heatbug) heatbugList.get (0);
3 W( p: N* E7 [/ ? Selector sel =
5 u& l8 E { y+ x: U new Selector (proto.getClass (), "heatbugStep", false);
% V4 m! }/ x1 V* v4 R5 | H' L actionForEach =$ e, A; G x" M1 { A5 l, M
modelActions.createFActionForEachHomogeneous$call* s7 z' }7 W9 q- g- \8 [' B% F
(heatbugList,! y! e4 i; ]+ W' B- L" P' e
new FCallImpl (this, proto, sel,! z$ v a) ?1 S
new FArgumentsImpl (this, sel)));4 B; H3 Y; {0 ^3 {$ p2 O0 [+ X' i
} catch (Exception e) {
& I% n6 R+ `& {. ]* h e.printStackTrace (System.err);: G' D3 ?3 z9 u6 s' u$ w* P: D
}1 c/ ], F& k* Z
2 s/ T% G8 J/ Q5 r syncUpdateOrder ();$ U/ j) A/ w; d; v) m/ r' }
+ a- c* |7 F/ }; d. ^* t9 X try {
% t% y" ^9 `7 U( K. Y modelActions.createActionTo$message
8 D$ t' U" n) \, j$ ~ (heat, new Selector (heat.getClass (), "updateLattice", false));5 f3 Q$ N# h. b. x
} catch (Exception e) {# [4 s9 B2 v8 c" F1 g
System.err.println("Exception updateLattice: " + e.getMessage ());2 I: E# n1 s/ P2 A4 Q
}
. |( Q9 R% f9 k$ K y" \ : p+ \5 G$ u7 q2 @3 ?$ [4 H
// Then we create a schedule that executes the" E8 K3 G. j' @- [" ~- \& x& C
// modelActions. modelActions is an ActionGroup, by itself it1 s2 q0 I, b% M/ l0 }1 [
// has no notion of time. In order to have it executed in
3 r: [- M5 n; b9 `6 q7 j4 q+ x // time, we create a Schedule that says to use the
3 M h7 O5 y3 q6 t8 m' K0 M4 O // modelActions ActionGroup at particular times. This$ D" m: P2 {# E+ Q
// schedule has a repeat interval of 1, it will loop every0 m* m# A# h p, e
// time step. The action is executed at time 0 relative to, s7 `3 u+ F& N4 H3 \. F# J& J/ ]
// the beginning of the loop.
! y9 ?; m! e, ?- }: ^: K$ R4 a4 E5 ~ @/ G$ M$ Y
// This is a simple schedule, with only one action that is1 C% j& E* J1 ]& a; d% W. v" P
// just repeated every time. See jmousetrap for more
( J1 |5 G' S" O) U/ P // complicated schedules.
1 {5 s1 z# {6 x; w. @ " R5 o/ b* `) R/ c' B+ b* F# q
modelSchedule = new ScheduleImpl (getZone (), 1);
/ d$ X" V0 N$ Y* M modelSchedule.at$createAction (0, modelActions);* ^/ { m! s0 w; z. o. e
: \6 f( s2 g. b ~% }7 ]+ P2 D6 c/ g1 b8 k
return this;
9 D; O/ Q6 Y( L7 e8 D/ X; j+ V6 A } |