HeatbugModelSwarm中buildActions部分,3个try分别是做什么?查了下refbook-java-2.2,解释太简略,还是不懂,高手指点,谢谢!代码如下:
+ z9 M' m' Q# b* {8 V: v. B" X
5 _% f2 m" {1 I3 \! o public Object buildActions () {0 `% [# v) y) ^7 _
super.buildActions();. n5 g. L' b+ C
+ @# C3 p" L5 m) y
// Create the list of simulation actions. We put these in% c7 d2 T' z" K9 b% j
// an action group, because we want these actions to be
$ s" _8 ~) y/ @1 o% u6 I4 r m8 c // executed in a specific order, but these steps should
9 @! Y/ Y0 d9 m1 C& a5 T9 {1 ~5 x // take no (simulated) time. The M(foo) means "The message
" r: A. z% K" q3 k+ C9 | // called <foo>". You can send a message To a particular
' I/ Z6 e9 C2 `# H u! ? // object, or ForEach object in a collection.6 M. I% P; _" Q% G+ @! O8 b% v
* F& t' e/ E6 A3 G5 C
// Note we update the heatspace in two phases: first run S* `# M+ m) \ W5 b0 v
// diffusion, then run "updateWorld" to actually enact the7 N, ]6 k6 b2 f" ]
// changes the heatbugs have made. The ordering here is' w: X$ F8 ]1 U) T: L
// significant!, ?3 n7 \$ q/ q
5 {0 j9 O" e! z }/ J) o // Note also, that with the additional) W ^) m% g3 h! M2 |1 F9 t
// `randomizeHeatbugUpdateOrder' Boolean flag we can
- X( W' V* |( e. N* Z! g4 f // randomize the order in which the bugs actually run% K, H7 m6 F, M, K
// their step rule. This has the effect of removing any: A& Y' u0 ^; _% I1 ?* ?& Q5 q9 p
// systematic bias in the iteration throught the heatbug, \! x0 {. V8 R
// list from timestep to timestep* I% S4 c, H# S. d, G
$ [# U# b% v6 F/ H
// By default, all `createActionForEach' modelActions have
6 A5 _7 x7 t5 V0 t" K# Z // a default order of `Sequential', which means that the7 `1 Y4 L7 V0 N" y5 Y2 n
// order of iteration through the `heatbugList' will be$ R' E$ d9 o. r5 L, s
// identical (assuming the list order is not changed
1 a' ]5 \6 K* F+ f P1 u // indirectly by some other process).
3 S5 ^$ A( ~9 l! I, D / j7 B7 \7 _, k t& k
modelActions = new ActionGroupImpl (getZone ());
8 B8 Z9 g3 h1 r% m) U+ c$ Z3 h
0 |% Q' S" f6 ~+ d1 W try {& r+ f: e8 H) }0 B/ d9 ~
modelActions.createActionTo$message
6 D! k P. ^/ l. p* R (heat, new Selector (heat.getClass (), "stepRule", false));
$ I( V" W7 d$ w# t* d3 P) m* d4 [ } catch (Exception e) {
1 a% H: y# a2 l, ^8 n! G System.err.println ("Exception stepRule: " + e.getMessage ());
: j$ N+ Z' Q) E6 I: V }
6 a: ^% s% U+ \: d- x3 H* M) [
+ q3 j/ Z7 T% E try {
7 B/ }& u0 ]$ H& p4 g! F6 { Heatbug proto = (Heatbug) heatbugList.get (0);
" g5 Z/ Y7 j, A Selector sel = + ?* O! A9 p/ m! E: a
new Selector (proto.getClass (), "heatbugStep", false);+ V, O' f6 i, e r- h8 Z
actionForEach =/ G% l& ^+ ~- F) W! a K8 X" o G8 F. E
modelActions.createFActionForEachHomogeneous$call
4 R1 p5 H/ ^5 n2 U8 U( Z2 i( | (heatbugList,1 Q+ s6 ]' n4 Z3 y/ o8 z, E. k
new FCallImpl (this, proto, sel,0 f: m7 R+ @" D+ ?
new FArgumentsImpl (this, sel)));3 K) E" q8 p7 v: @/ L
} catch (Exception e) {
& S+ Y) f( `) N7 k4 Y' r e.printStackTrace (System.err);3 ]/ [3 p- g- [' k
}: X6 U- t- w; x1 W
/ `% E( b, _: C2 @ syncUpdateOrder ();
9 |( ^5 }5 A1 o& {- o2 a" h3 v6 Y" f8 f* l
try {
3 S, ?% r+ S) a9 j modelActions.createActionTo$message , N0 u8 i) C5 l# O, O- p3 o, r
(heat, new Selector (heat.getClass (), "updateLattice", false));
6 h# ]6 e, h; `% A } catch (Exception e) {
! H. v' o" y& n; {' v+ E! n1 \ System.err.println("Exception updateLattice: " + e.getMessage ());: N8 W& H) K0 E' U! i5 g" E. y2 p, `
}
: |+ b" t$ Q- P: ` $ q9 U& M* P$ D
// Then we create a schedule that executes the
; `+ A/ c5 X/ H: r$ i9 I // modelActions. modelActions is an ActionGroup, by itself it u% w8 [) A- U- d2 H* u; }' V% b
// has no notion of time. In order to have it executed in2 v4 G& B( k/ ]0 v8 M$ |$ S
// time, we create a Schedule that says to use the
s( |# [" P/ m1 o: m. { // modelActions ActionGroup at particular times. This# x9 W8 R# F0 V4 B7 a' b# {
// schedule has a repeat interval of 1, it will loop every
+ S- _* x% `6 L! {% \- p // time step. The action is executed at time 0 relative to0 I4 r( l& ^) x. ^
// the beginning of the loop.) z$ z/ X' E) }. h0 G
7 F8 u; m: n, ~, F% |9 S
// This is a simple schedule, with only one action that is
+ O( q* m" C( Q" c2 ?( g; u: { // just repeated every time. See jmousetrap for more
+ f$ q2 h+ q$ t. F# X. k // complicated schedules.
2 ?+ y" R! ^, |$ L
- j/ S( Q/ ^/ P2 A. b modelSchedule = new ScheduleImpl (getZone (), 1);
V# U# g; v( T modelSchedule.at$createAction (0, modelActions);1 {6 R- c. D- O$ e
% P% b$ M$ w4 u/ q return this;, a4 o, i9 \* y5 G- K2 S
} |