Coverage report

| %line | %branch
--- | --- | ---
tsukuba_bunko.peko.scenario.SceneContext |
0% |
0% |

1 |  |
     /*
2 |  |
      * All Rights Reserved.
3 |  |
      * Copyright (C) 1999-2005 Tsukuba Bunko.
4 |  |
      *
5 |  |
      * Licensed under the BSD License ("the License"); you may not use
6 |  |
      * this file except in compliance with the License.
7 |  |
      * You may obtain a copy of the License at
8 |  |
      *
9 |  |
      *       http://www.tsukuba-bunko.org/licenses/LICENSE.txt
10 |  |
      *
11 |  |
      * Unless required by applicable law or agreed to in writing, software
12 |  |
      * distributed under the License is distributed on an "AS IS" BASIS,
13 |  |
      * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 |  |
      * See the License for the specific language governing permissions and
15 |  |
      * limitations under the License.
16 |  |
      *
17 |  |
      * $Id: SceneContext.java,v 1.2 2005/07/23 19:06:28 ppoi Exp $
18 |  |
      */
19 |  |
     package tsukuba_bunko.peko.scenario;
20 |  |
21 |  |
     import	java.io.Serializable;
22 |  |
23 |  |
     import	java.util.List;
24 |  |
     import	java.util.Map;
25 |  |
     import	java.util.Set;
26 |  |
27 |  |
     import	tsukuba_bunko.peko.Logger;
28 |  |
29 |  |
     import	tsukuba_bunko.peko.session.Session;
30 |  |
31 |  |
32 |  |
     /**
33 |  |
      * シーン処理のコンテクストです。
34 |  |
      * @author	$Author: ppoi $
35 |  |
      * @version	$Revision: 1.2 $
36 |  |
      */
37 |  |
     public class SceneContext	implements Serializable	{
38 |  |
39 |  |
     	/**
40 |  |
     	 * serial version UID
41 |  |
     	 */
42 |  |
     	private static final long	serialVersionUID	= 1698890995605002291L;
43 |  |
44 |  |
     	/**
45 |  |
     	 * シーン名
46 |  |
     	 */
47 | 0 |
     	protected String	_sceneName = null;
48 |  |
49 |  |
     	/**
50 |  |
     	 * シーンタイトル
51 |  |
     	 */
52 | 0 |
     	protected String	_sceneTitle = null;
53 |  |
54 |  |
     	/**
55 |  |
     	 * シーンのプロパティ情報
56 |  |
     	 */
57 | 0 |
     	protected Map	_properties = null;
58 |  |
59 |  |
     	/**
60 |  |
     	 * シーン遷移先表
61 |  |
     	 */
62 | 0 |
     	protected NextSceneMapping	_nextSceneMapping = null;
63 |  |
64 |  |
     	/**
65 |  |
     	 * 現在位置
66 |  |
     	 */
67 | 0 |
     	transient protected Node	_current = null;
68 |  |
69 |  |
     	/**
70 |  |
     	 * 保存された最後の位置
71 |  |
     	 */
72 | 0 |
     	protected Node	_lastCommittedNode = null;
73 |  |
74 |  |
     	/**
75 |  |
     	 * シーンスコープ フラグ
76 |  |
     	 */
77 | 0 |
     	protected Set	_sceneScopeFlags = null;
78 |  |
79 |  |
     	/**
80 |  |
     	 * セッション
81 |  |
     	 */
82 | 0 |
     	transient protected Session	_session = null;
83 |  |
84 |  |
     	/**
85 |  |
     	 * このシーンを処理中の SceneProcessor
86 |  |
     	 */
87 | 0 |
     	transient protected SceneProcessor	_processor = null;
88 |  |
89 |  |
90 |  |
     	/**
91 |  |
     	 * <code>SceneContext</code> のインスタンスを生成します。
92 |  |
     	 * @param	sceneName	シーン名
93 |  |
     	 * @param	session	セッション
94 |  |
     	 * @param	processor	このシーンを処理するシーンプロセッサ
95 |  |
     	 */
96 |  |
     	public SceneContext( String sceneName, Session session, SceneProcessor processor )
97 | 0 |
     	{
98 | 0 |
     		_sceneName = sceneName;
99 | 0 |
     		_session = session;
100 | 0 |
     		_processor = processor;
101 |  |
102 | 0 |
     		SceneContext	previous = session.getSceneContext();
103 | 0 |
     		if( previous != null )	{
104 | 0 |
     			_lastCommittedNode = previous.getLastCommittedNode();
105 | 0 |
     			_properties = previous._properties;
106 | 0 |
     			_nextSceneMapping = previous.getNextSceneMapping();
107 | 0 |
     			_sceneScopeFlags = previous._sceneScopeFlags;
108 | 0 |
     		}
109 |  |
     		else	{
110 | 0 |
     			_nextSceneMapping = new NextSceneMapping();
111 | 0 |
     			_sceneScopeFlags = new java.util.HashSet();
112 |  |
     		}
113 | 0 |
     	}
114 |  |
115 |  |
116 |  |
     	/**
117 |  |
     	 * シーン名を取得します。
118 |  |
     	 * @return	シーン名
119 |  |
     	 */
120 |  |
     	public String getSceneName()
121 |  |
     	{
122 | 0 |
     		return _sceneName;
123 |  |
     	}
124 |  |
125 |  |
     	/**
126 |  |
     	 * シーンタイトルを設定します。
127 |  |
     	 * @param	title	シーンタイトル
128 |  |
     	 */
129 |  |
     	public void setSceneTitle( String title )
130 |  |
     	{
131 | 0 |
     		_sceneTitle = title;
132 | 0 |
     	}
133 |  |
134 |  |
     	/**
135 |  |
     	 * シーンタイトルを取得します。
136 |  |
     	 * @return	シーンタイトル
137 |  |
     	 */
138 |  |
     	public String getSceneTitle()
139 |  |
     	{
140 | 0 |
     		return _sceneTitle;
141 |  |
     	}
142 |  |
143 |  |
     	/**
144 |  |
     	 * セッションを取得します。
145 |  |
     	 * @return	セッション
146 |  |
     	 */
147 |  |
     	public Session getSession()
148 |  |
     	{
149 | 0 |
     		return _session;
150 |  |
     	}
151 |  |
152 |  |
     	/**
153 |  |
     	 * シーンプロセッサを取得します。
154 |  |
     	 * @return	シーンプロセッサ
155 |  |
     	 */
156 |  |
     	public SceneProcessor getSceneProcessor()
157 |  |
     	{
158 | 0 |
     		return _processor;
159 |  |
     	}
160 |  |
161 |  |
     	/**
162 |  |
     	 * シーンプロパティを設定します。
163 |  |
     	 * @param	name	プロパティ名
164 |  |
     	 * @param	value	プロパティ値
165 |  |
     	 */
166 |  |
     	public void setProperty( String name, String value )
167 |  |
     	{
168 | 0 |
     		if( _properties == null )	{
169 | 0 |
     			_properties = new java.util.HashMap( 17 );
170 |  |
     		}
171 | 0 |
     		_properties.put( name, value );
172 | 0 |
     	}
173 |  |
174 |  |
     	/**
175 |  |
     	 * シーンプロパティを取得します。
176 |  |
     	 * @param	name	プロパティ名
177 |  |
     	 * @return	プロパティ値。<code>name</code> で識別されるプロパティが設定されていない場合は <code>null</code>。
178 |  |
     	 */
179 |  |
     	public String getProperty( String name )
180 |  |
     	{
181 | 0 |
     		if( _properties == null )	{
182 | 0 |
     			return null;
183 |  |
     		}
184 |  |
     		else	{
185 | 0 |
     			return (String)_properties.get( name );
186 |  |
     		}
187 |  |
     	}
188 |  |
189 |  |
     	/**
190 |  |
     	 * 遷移先表を設定します。
191 |  |
     	 * @param	mapping	遷移先表
192 |  |
     	 */
193 |  |
     	public void setNextSceneMapping( NextSceneMapping mapping )
194 |  |
     	{
195 | 0 |
     		_nextSceneMapping = mapping;
196 | 0 |
     	}
197 |  |
198 |  |
     	/**
199 |  |
     	 * 遷移先表を取得します。
200 |  |
     	 * @return	遷移先表
201 |  |
     	 */
202 |  |
     	public NextSceneMapping getNextSceneMapping()
203 |  |
     	{
204 | 0 |
     		return _nextSceneMapping;
205 |  |
     	}
206 |  |
207 |  |
     	/**
208 |  |
     	 * 次のシーンを取得します。
209 |  |
     	 * @return	このシーンの処理後に遷移するシーンのシーン名
210 |  |
     	 */
211 |  |
     	public String getNextSceneName()
212 |  |
     	{
213 | 0 |
     		return _nextSceneMapping.getNextScene( this );
214 |  |
     	}
215 |  |
216 |  |
     	/**
217 |  |
     	 * 指定されたノードの処理が開始されたことを通知します。
218 |  |
     	 */
219 |  |
     	public void pushNode( String nodeName )
220 |  |
     	{
221 | 0 |
     		if( _current == null )	{
222 | 0 |
     			_current = new Node( null, nodeName.intern(), 1 );
223 | 0 |
     		}
224 |  |
     		else	{
225 | 0 |
     			int	position = _current.countSibling(nodeName) + 1;
226 | 0 |
     			Node	child = new Node( _current, nodeName.intern(), position );
227 | 0 |
     			_current.addChildNode( child );
228 | 0 |
     			_current = child;
229 |  |
     		}
230 | 0 |
     	}
231 |  |
232 |  |
     	/**
233 |  |
     	 * 現在のノードの処理が終了したことを通知します。
234 |  |
     	 */
235 |  |
     	public void popNode()
236 |  |
     	{
237 | 0 |
     		if( _current == null )	{
238 | 0 |
     			Logger.error( "[scenario] BUG! invalid state of SceneLog." );
239 | 0 |
     		}
240 |  |
     		else	{
241 | 0 |
     			_current.removeChildren();
242 | 0 |
     			_current = _current.getParentNode();
243 |  |
     		}
244 | 0 |
     	}
245 |  |
246 |  |
     	/**
247 |  |
     	 * 現在の位置を保存します。
248 |  |
     	 */
249 |  |
     	public void saveCurrentNode()
250 |  |
     	{
251 | 0 |
     		_lastCommittedNode = _current;
252 | 0 |
     	}
253 |  |
254 |  |
     	/**
255 |  |
     	 * 保存された最後の位置を取得します。
256 |  |
     	 * @return	保存された最後の位置
257 |  |
     	 */
258 |  |
     	public Node getLastCommittedNode()
259 |  |
     	{
260 | 0 |
     		return _lastCommittedNode;
261 |  |
     	}
262 |  |
263 |  |
     	/**
264 |  |
     	 * <code>node</code> が現在処理中のノードと同一であるかどうかを判定します。
265 |  |
     	 * @param	node	判定対象のノード
266 |  |
     	 * @return	同一での場合 <code>true</code>、それ以外の場合 <code>false</code>
267 |  |
     	 */
268 |  |
     	public boolean isCurrentNode( Node node )
269 |  |
     	{
270 | 0 |
     		if( node == _current )	{
271 | 0 |
     			return true;
272 |  |
     		}
273 | 0 |
     		else if( _current != null )	{
274 | 0 |
     			return _current.equals(node);
275 |  |
     		}
276 |  |
     		else {
277 | 0 |
     			return false;
278 |  |
     		}
279 |  |
     	}
280 |  |
281 |  |
     	/**
282 |  |
     	 * 現在処理中のノードのコピーを取得します。コピーには、子ノードリストは含まれません。
283 |  |
     	 * @return	現在処理中のノードのコピー
284 |  |
     	 */
285 |  |
     	public Node getCurrentNode()
286 |  |
     	{
287 | 0 |
     		Node	node = _current;
288 | 0 |
     		if( node == null )	{
289 | 0 |
     			return null;
290 |  |
     		}
291 |  |
     		else	{
292 | 0 |
     			Node	copy = new Node( null, node._nodeName, node._position );
293 | 0 |
     			Node	temp = copy;
294 | 0 |
     			while( (node = node.getParentNode()) != null )	{
295 | 0 |
     				temp._parent = new Node( null, node.getNodeName(), node.getPosition() );
296 | 0 |
     				temp = temp.getParentNode();
297 | 0 |
     			}
298 | 0 |
     			return copy;
299 |  |
     		}
300 |  |
     	}
301 |  |
302 |  |
     	/**
303 |  |
     	 * 現在処理中のパスを XPath で取得します。
304 |  |
     	 * @return	現在処理中のパス
305 |  |
     	 */
306 |  |
     	public String getCurrentPath()
307 |  |
     	{
308 | 0 |
     		if( _current != null )	{
309 | 0 |
     			return _current.getPath();
310 |  |
     		}
311 |  |
     		else	{
312 | 0 |
     			return "/";
313 |  |
     		}
314 |  |
     	}
315 |  |
316 |  |
317 |  |
     	/**
318 |  |
     	 * フラグを立てます。
319 |  |
     	 * @param	flagID	フラグ ID
320 |  |
     	 * @param	scope	フラグスコープ
321 |  |
     	 * @throws	IllegalArgumentException	<code>flagID</code> が <code>null</code> の場合
322 |  |
     	 */
323 |  |
     	public void declareFlag( String flagID, FlagScope scope )
324 |  |
     	{
325 | 0 |
     		if( flagID == null )	{
326 | 0 |
     			throw new IllegalArgumentException();
327 |  |
     		}
328 |  |
329 | 0 |
     		if( scope == FlagScope.SCENE )	{
330 | 0 |
     			_sceneScopeFlags.add( flagID );
331 | 0 |
     		}
332 | 0 |
     		else if( scope == FlagScope.SESSION )	{
333 | 0 |
     			_session.declareSessionFlag( flagID );
334 | 0 |
     		}
335 | 0 |
     		else if( scope == FlagScope.SYSTEM )	{
336 | 0 |
     			_session.declareSystemFlag( flagID );
337 |  |
     		}
338 | 0 |
     	}
339 |  |
340 |  |
     	/**
341 |  |
     	 * フラグをおろします。
342 |  |
     	 * @param	flagID	フラグ ID
343 |  |
     	 * @param	scope	フラグスコープ
344 |  |
     	 * @throws	IllegalArgumentException	<code>flagID</code> が <code>null</code> の場合
345 |  |
     	 */
346 |  |
     	public void undeclareFlag( String flagID, FlagScope scope )
347 |  |
     	{
348 | 0 |
     		if( flagID == null )	{
349 | 0 |
     			throw new IllegalArgumentException();
350 |  |
     		}
351 |  |
352 | 0 |
     		if( scope == FlagScope.SCENE )	{
353 | 0 |
     			_sceneScopeFlags.remove( flagID );
354 | 0 |
     		}
355 | 0 |
     		else if( scope == FlagScope.SESSION )	{
356 | 0 |
     			_session.undeclareSessionFlag( flagID );
357 | 0 |
     		}
358 | 0 |
     		else if( scope == FlagScope.SYSTEM )	{
359 | 0 |
     			_session.undeclareSystemFlag( flagID );
360 |  |
     		}
361 | 0 |
     	}
362 |  |
363 |  |
     	/**
364 |  |
     	 * スコープを問わず、フラグが立っているかどうかを判定します。
365 |  |
     	 * @param	flagID	フラグ ID
366 |  |
     	 */
367 |  |
     	public boolean isDeclaredFlag( String flagID )
368 |  |
     	{
369 | 0 |
     		if( _sceneScopeFlags.contains(flagID) )	{
370 | 0 |
     			return true;
371 |  |
     		}
372 | 0 |
     		else if( _session.isDeclaredSessionFlag(flagID) )	{
373 | 0 |
     			return true;
374 |  |
     		}
375 | 0 |
     		else if( _session.isDeclaredSystemFlag(flagID) )	{
376 | 0 |
     			return true;
377 |  |
     		}
378 |  |
     		else	{
379 | 0 |
     			return false;
380 |  |
     		}
381 |  |
     	}
382 |  |
383 |  |
     	/**
384 |  |
     	 * 指定されたスコープでフラグが立っているかどうかを判定します。
385 |  |
     	 * @param	flagID	フラグ ID
386 |  |
     	 * @param	scope	フラグスコープ
387 |  |
     	 * @return	指定されたフラグスコープでフラグが立っている場合 <code>true</code>、それ以外の場合 <code>false</code>
388 |  |
     	 */
389 |  |
     	public boolean isDeclaredFlag( String flagID, FlagScope scope )
390 |  |
     	{
391 | 0 |
     		if( scope == FlagScope.SCENE )	{
392 | 0 |
     			return _sceneScopeFlags.contains( flagID );
393 |  |
     		}
394 | 0 |
     		else if( scope == FlagScope.SESSION )	{
395 | 0 |
     			return _session.isDeclaredSessionFlag( flagID );
396 |  |
     		}
397 | 0 |
     		else if( scope == FlagScope.SYSTEM )	{
398 | 0 |
     			return _session.isDeclaredSystemFlag( flagID );
399 |  |
     		}
400 |  |
     		else	{
401 | 0 |
     			return false;
402 |  |
     		}
403 |  |
     	}
404 |  |
405 |  |
     //
406 |  |
     //	ノード
407 |  |
     //
408 |  |
     	/**
409 |  |
     	 * PSML Scene 文書を構成するノードです。
410 |  |
     	 */
411 |  |
     	public static class Node	implements Serializable	{
412 |  |
413 |  |
     		/**
414 |  |
     		 * serial version UID
415 |  |
     		 */
416 |  |
     		private static final long	serialVersionUID	= 7590190847826566241L;
417 |  |
418 |  |
     		/**
419 |  |
     		 * 親ノード
420 |  |
     		 */
421 |  |
     		protected Node	_parent = null;
422 |  |
423 |  |
     		/**
424 |  |
     		 * ノード名
425 |  |
     		 */
426 |  |
     		protected String	_nodeName = null;
427 |  |
428 |  |
     		/**
429 |  |
     		 * position
430 |  |
     		 */
431 |  |
     		protected int	_position = 0;
432 |  |
433 |  |
     		/**
434 |  |
     		 * 子ノードリスト
435 |  |
     		 */
436 |  |
     		protected List	_children = null;
437 |  |
438 |  |
439 |  |
     		/**
440 |  |
     		 * <code>SceneContext.Node</code> のインスタンスを生成します。
441 |  |
     		 */
442 |  |
     		public Node( Node parent, String nodeName, int position )
443 |  |
     		{
444 |  |
     			_parent = parent;
445 |  |
     			_nodeName = nodeName.intern();
446 |  |
     			_position = position;
447 |  |
     		}
448 |  |
449 |  |
     		/**
450 |  |
     		 * 親ノードを取得します。
451 |  |
     		 * @return	親ノード
452 |  |
     		 */
453 |  |
     		public Node getParentNode()
454 |  |
     		{
455 |  |
     			return _parent;
456 |  |
     		}
457 |  |
458 |  |
     		/**
459 |  |
     		 * ノード名を取得します。
460 |  |
     		 * @return	ノード名
461 |  |
     		 */
462 |  |
     		public String getNodeName()
463 |  |
     		{
464 |  |
     			return _nodeName;
465 |  |
     		}
466 |  |
467 |  |
     		/**
468 |  |
     		 * ポジションを取得します。
469 |  |
     		 * @return	ポジション
470 |  |
     		 */
471 |  |
     		public int getPosition()
472 |  |
     		{
473 |  |
     			return _position;
474 |  |
     		}
475 |  |
476 |  |
477 |  |
     		/**
478 |  |
     		 * 子ノードを追加します。
479 |  |
     		 * @param	child	子ノード
480 |  |
     		 */
481 |  |
     		public void addChildNode( Node child )
482 |  |
     		{
483 |  |
     			if( _children == null )	{
484 |  |
     				_children = new java.util.ArrayList();
485 |  |
     			}
486 |  |
     			_children.add( child );
487 |  |
     		}
488 |  |
489 |  |
     		/**
490 |  |
     		 * 子ノードのなかで、指定された名前のノードの数をカウントします。
491 |  |
     		 * @param	nodeName	子ノード名
492 |  |
     		 * @return	ノード数
493 |  |
     		 */
494 |  |
     		public int countSibling( String nodeName )
495 |  |
     		{
496 |  |
     			if( _children == null )	{
497 |  |
     				return 0;
498 |  |
     			}
499 |  |
     			else	{
500 |  |
     				String	symbol = nodeName.intern();
501 |  |
     				List	children = _children;
502 |  |
     				int	size = children.size();
503 |  |
     				Node	node = null;
504 |  |
     				int	count = 0;
505 |  |
     				for( int i = 0; i < size; ++i )	{
506 |  |
     					node = (Node)children.get( i );
507 |  |
     					if( node._nodeName == symbol )	{
508 |  |
     						count++;
509 |  |
     					}
510 |  |
     				}
511 |  |
     				return count;
512 |  |
     			}
513 |  |
     		}
514 |  |
515 |  |
     		/**
516 |  |
     		 * このノードをルートとするサブツリーを破棄します。
517 |  |
     		 */
518 |  |
     		public void removeChildren()
519 |  |
     		{
520 |  |
     			if( _children != null )	{
521 |  |
     				List	children = _children;
522 |  |
     				int	size = children.size();
523 |  |
     				for( int i = 0; i < size; ++i )	{
524 |  |
     					((Node)children.get(i)).removeChildren();
525 |  |
     				}
526 |  |
     				children.clear();
527 |  |
     				_children = null;
528 |  |
     			}
529 |  |
     		}
530 |  |
531 |  |
     		/**
532 |  |
     		 * このノードまでのパスを XPath 形式で取得します。
533 |  |
     		 * @return	このノードまでのパス
534 |  |
     		 */
535 |  |
     		public String getPath()
536 |  |
     		{
537 |  |
     			StringBuffer	sink = new StringBuffer();
538 |  |
     			Node	node = this;
539 |  |
     			while( node != null )	{
540 |  |
     				sink.insert( 0, node );
541 |  |
     				node = node.getParentNode();
542 |  |
     			}
543 |  |
     			return new String(sink);
544 |  |
     		}
545 |  |
546 |  |
     		public boolean equals( Object obj )
547 |  |
     		{
548 |  |
     			if( obj instanceof Node )	{
549 |  |
     				Node	target = (Node)obj;
550 |  |
     				Node	node = this;
551 |  |
     				while( (node != null) && (target != class="keyword">null) )	{
552 |  |
     					if( !node._nodeName.equals(target._nodeName) || (node._position != target._position) )	{
553 |  |
     						return false;
554 |  |
     					}
555 |  |
     					node = node._parent;
556 |  |
     					target = target._parent;
557 |  |
     				}
558 |  |
     				return ((node == null) && (target == class="keyword">null));
559 |  |
     			}
560 |  |
     			else	{
561 |  |
     				return false;
562 |  |
     			}
563 |  |
     		}
564 |  |
565 |  |
     		public String toString()
566 |  |
     		{
567 |  |
     			return "/" + _nodeName + "[" + _position + "]";
568 |  |
     		}
569 |  |
     	}
570 |  |
     }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.