-:-	begin_unit|revision:0.9.5;language:Java;cregit-version:0.0.1
-:-	begin_package
1:1	package|package
1:9	name|utility
1:16	package|;
-:-	end_package
-:-	begin_import
3:1	import|import
3:8	name|gnu
3:11	operator|.
3:12	name|trove
3:17	operator|.
3:18	name|TIntArrayList
3:31	import|;
-:-	end_import
-:-	begin_class
5:1	specifier|public
5:8	class|class
5:14	name|StringUtil
5:25	block|{
6:9	specifier|public
6:16	specifier|static
6:23	specifier|final
6:29	name|String
6:36	name|NewLineString
6:50	init|=
6:52	name|System
6:58	operator|.
6:59	name|getProperty
6:70	argument_list|(
6:71	literal|"line.separator"
6:87	argument_list|)
6:88	decl_stmt|;
6:90	comment|//$NON-NLS-1$
7:9	specifier|public
7:16	specifier|static
7:23	name|int
7:27	name|findAll
7:34	parameter_list|(
7:35	name|int
7:38	index|[]
7:41	name|poss
7:45	parameter_list|,
7:47	name|String
7:54	name|str
7:57	parameter_list|,
7:59	name|int
7:63	name|target
7:69	parameter_list|)
7:71	block|{
8:17	if|if
8:20	condition|(
8:21	name|poss
8:25	operator|.
8:26	name|length
8:33	operator|==
8:36	literal|0
8:37	condition|)
8:39	block|{
9:25	return|return
9:32	literal|0
9:33	return|;
10:17	block|}
12:17	name|int
12:21	name|i
12:23	init|=
12:25	literal|0
12:26	decl_stmt|;
13:17	name|int
13:21	name|count
13:27	init|=
13:29	literal|0
13:30	decl_stmt|;
14:17	while|while
14:23	condition|(
14:24	name|i
14:26	operator|<
14:28	name|str
14:31	operator|.
14:32	name|length
14:38	argument_list|()
14:40	condition|)
14:42	block|{
15:25	name|int
15:29	name|p
15:31	init|=
15:33	name|str
15:36	operator|.
15:37	name|indexOf
15:44	argument_list|(
15:45	name|target
15:51	argument_list|,
15:53	name|i
15:54	argument_list|)
15:55	decl_stmt|;
16:25	if|if
16:28	condition|(
16:29	name|p
16:31	operator|<
16:33	literal|0
16:34	condition|)
16:36	block|{
17:33	for|for
17:37	control|(
17:38	name|int
17:42	name|c
17:44	init|=
17:46	name|count
17:51	init|;
17:53	name|c
17:55	operator|<
17:57	name|poss
17:61	operator|.
17:62	name|length
17:68	condition|;
17:70	operator|++
17:72	name|c
17:73	control|)
17:75	block|{
18:41	name|poss
18:45	index|[
18:46	name|c
18:47	index|]
18:49	operator|=
18:51	operator|-
18:52	literal|1
18:53	expr_stmt|;
19:33	block|}
20:33	return|return
20:40	name|count
20:45	return|;
21:25	block|}
22:25	name|poss
22:29	index|[
22:30	name|count
22:35	index|]
22:37	operator|=
22:39	name|p
22:40	expr_stmt|;
23:25	operator|++
23:27	name|count
23:32	expr_stmt|;
24:25	name|i
24:27	operator|=
24:29	name|p
24:31	operator|+
24:33	literal|1
24:34	expr_stmt|;
25:17	block|}
26:17	return|return
26:24	name|count
26:29	return|;
27:9	block|}
28:9	specifier|public
28:16	specifier|static
28:23	name|String
28:29	index|[]
28:32	name|split
28:37	parameter_list|(
28:38	name|String
28:45	name|str
28:48	parameter_list|,
28:50	name|int
28:54	name|sepChar
28:61	parameter_list|)
28:63	block|{
29:17	name|TIntArrayList
29:31	name|sepPoss
29:39	init|=
29:41	operator|new
29:45	name|TIntArrayList
29:58	argument_list|()
29:60	decl_stmt|;
30:17	name|int
30:21	name|pos
30:25	init|=
30:27	literal|0
30:28	decl_stmt|;
31:17	while|while
31:23	condition|(
31:24	name|pos
31:28	operator|<
31:30	name|str
31:33	operator|.
31:34	name|length
31:40	argument_list|()
31:42	condition|)
31:44	block|{
32:25	name|int
32:29	name|q
32:31	init|=
32:33	name|str
32:36	operator|.
32:37	name|indexOf
32:44	argument_list|(
32:45	name|sepChar
32:52	argument_list|,
32:54	name|pos
32:57	argument_list|)
32:58	decl_stmt|;
33:25	if|if
33:28	condition|(
33:29	name|q
33:31	operator|!=
33:34	operator|-
33:35	literal|1
33:36	condition|)
33:38	block|{
34:33	name|sepPoss
34:40	operator|.
34:41	name|add
34:44	argument_list|(
34:45	name|q
34:46	argument_list|)
34:47	expr_stmt|;
35:33	name|pos
35:37	operator|=
35:39	name|q
35:41	operator|+
35:43	literal|1
35:44	expr_stmt|;
36:25	block|}
37:25	else|else
37:30	block|{
38:33	name|sepPoss
38:40	operator|.
38:41	name|add
38:44	argument_list|(
38:45	name|str
38:48	operator|.
38:49	name|length
38:55	argument_list|()
38:57	argument_list|)
38:58	expr_stmt|;
39:33	name|pos
39:37	operator|=
39:39	name|str
39:42	operator|.
39:43	name|length
39:49	argument_list|()
39:51	expr_stmt|;
40:25	block|}
41:17	block|}
42:17	name|int
42:20	index|[]
42:23	name|poss
42:28	init|=
42:30	name|sepPoss
42:37	operator|.
42:38	name|toNativeArray
42:51	argument_list|()
42:53	decl_stmt|;
43:17	name|String
43:23	index|[]
43:26	name|substrings
43:37	init|=
43:39	operator|new
43:43	name|String
43:49	index|[
43:50	name|poss
43:54	operator|.
43:55	name|length
43:61	index|]
43:62	decl_stmt|;
44:17	if|if
44:20	condition|(
44:21	name|poss
44:25	operator|.
44:26	name|length
44:33	operator|>=
44:36	literal|1
44:37	condition|)
44:39	block|{
45:25	name|int
45:29	name|i
45:31	init|=
45:33	literal|0
45:34	decl_stmt|;
46:25	name|substrings
46:35	index|[
46:36	name|i
46:37	index|]
46:39	operator|=
46:41	name|str
46:44	operator|.
46:45	name|substring
46:54	argument_list|(
46:55	literal|0
46:56	argument_list|,
46:58	name|poss
46:62	index|[
46:63	literal|0
46:64	index|]
46:65	argument_list|)
46:66	expr_stmt|;
47:25	operator|++
47:27	name|i
47:28	expr_stmt|;
48:25	for|for
48:29	control|(
48:30	init|;
48:32	name|i
48:34	operator|<
48:36	name|poss
48:40	operator|.
48:41	name|length
48:47	condition|;
48:49	operator|++
48:51	name|i
48:52	control|)
48:54	block|{
49:33	name|substrings
49:43	index|[
49:44	name|i
49:45	index|]
49:47	operator|=
49:49	name|str
49:52	operator|.
49:53	name|substring
49:62	argument_list|(
49:63	name|poss
49:67	index|[
49:68	name|i
49:70	operator|-
49:72	literal|1
49:73	index|]
49:75	operator|+
49:77	literal|1
49:78	argument_list|,
49:80	name|poss
49:84	index|[
49:85	name|i
49:86	index|]
49:87	argument_list|)
49:88	expr_stmt|;
50:25	block|}
51:17	block|}
52:17	return|return
52:24	name|substrings
52:34	return|;
53:9	block|}
55:9	specifier|public
55:16	specifier|static
55:23	name|String
55:30	name|join
55:34	parameter_list|(
55:35	name|String
55:41	index|[]
55:44	name|ary
55:47	parameter_list|,
55:49	name|String
55:56	name|with
55:60	parameter_list|)
55:62	block|{
56:17	name|StringBuffer
56:30	name|buf
56:34	init|=
56:36	operator|new
56:40	name|StringBuffer
56:52	argument_list|()
56:54	decl_stmt|;
57:17	for|for
57:21	control|(
57:22	name|int
57:26	name|i
57:28	init|=
57:30	literal|0
57:31	init|;
57:33	name|i
57:35	operator|<
57:37	name|ary
57:40	operator|.
57:41	name|length
57:47	condition|;
57:49	operator|++
57:51	name|i
57:52	control|)
57:54	block|{
58:25	if|if
58:28	condition|(
58:29	name|i
58:31	operator|>
58:33	literal|0
58:34	condition|)
58:36	block|{
59:33	name|buf
59:36	operator|.
59:37	name|append
59:43	argument_list|(
59:44	name|with
59:48	argument_list|)
59:49	expr_stmt|;
60:25	block|}
61:25	name|buf
61:28	operator|.
61:29	name|append
61:35	argument_list|(
61:36	name|ary
61:39	index|[
61:40	name|i
61:41	index|]
61:42	argument_list|)
61:43	expr_stmt|;
62:17	block|}
63:17	return|return
63:24	name|buf
63:27	operator|.
63:28	name|toString
63:36	argument_list|()
63:38	return|;
64:9	block|}
66:9	specifier|public
66:16	specifier|static
66:23	name|String
66:30	name|join
66:34	parameter_list|(
66:35	name|String
66:41	index|[]
66:44	name|ary
66:47	parameter_list|,
66:49	name|int
66:53	name|begin
66:58	parameter_list|,
66:60	name|int
66:64	name|end
66:67	parameter_list|,
66:69	name|String
66:76	name|with
66:80	parameter_list|)
66:82	block|{
67:17	if|if
67:20	condition|(
67:21	name|begin
67:27	operator|<
67:29	literal|0
67:30	condition|)
67:32	block|{
68:25	name|begin
68:31	operator|=
68:33	literal|0
68:34	expr_stmt|;
69:17	block|}
70:17	if|if
70:20	condition|(
70:21	name|end
70:25	operator|>
70:27	name|ary
70:30	operator|.
70:31	name|length
70:37	condition|)
70:39	block|{
71:25	name|end
71:29	operator|=
71:31	name|ary
71:34	operator|.
71:35	name|length
71:41	expr_stmt|;
72:17	block|}
73:17	name|StringBuffer
73:30	name|buf
73:34	init|=
73:36	operator|new
73:40	name|StringBuffer
73:52	argument_list|()
73:54	decl_stmt|;
74:17	for|for
74:21	control|(
74:22	name|int
74:26	name|i
74:28	init|=
74:30	name|begin
74:35	init|;
74:37	name|i
74:39	operator|<
74:41	name|end
74:44	condition|;
74:46	operator|++
74:48	name|i
74:49	control|)
74:51	block|{
75:25	if|if
75:28	condition|(
75:29	name|i
75:31	operator|>
75:33	name|begin
75:38	condition|)
75:40	block|{
76:33	name|buf
76:36	operator|.
76:37	name|append
76:43	argument_list|(
76:44	name|with
76:48	argument_list|)
76:49	expr_stmt|;
77:25	block|}
78:25	name|buf
78:28	operator|.
78:29	name|append
78:35	argument_list|(
78:36	name|ary
78:39	index|[
78:40	name|i
78:41	index|]
78:42	argument_list|)
78:43	expr_stmt|;
79:17	block|}
80:17	return|return
80:24	name|buf
80:27	operator|.
80:28	name|toString
80:36	argument_list|()
80:38	return|;
81:9	block|}
83:9	specifier|public
83:16	specifier|static
83:23	name|String
83:30	name|replaceFirst
83:42	parameter_list|(
83:43	name|String
83:50	name|str
83:53	parameter_list|,
83:55	name|String
83:62	name|pat
83:65	parameter_list|,
83:67	name|String
83:74	name|replacement
83:85	parameter_list|)
83:87	block|{
84:17	name|int
84:21	name|pos
84:25	init|=
84:27	name|str
84:30	operator|.
84:31	name|indexOf
84:38	argument_list|(
84:39	name|pat
84:42	argument_list|)
84:43	decl_stmt|;
85:17	if|if
85:20	condition|(
85:21	name|pos
85:25	operator|>=
85:28	literal|0
85:29	condition|)
85:31	block|{
86:25	return|return
86:32	name|str
86:35	operator|.
86:36	name|substring
86:45	argument_list|(
86:46	literal|0
86:47	argument_list|,
86:49	name|pos
86:52	argument_list|)
86:54	operator|+
86:56	name|replacement
86:68	operator|+
86:70	name|str
86:73	operator|.
86:74	name|substring
86:83	argument_list|(
86:84	name|pos
86:88	operator|+
86:90	name|pat
86:93	operator|.
86:94	name|length
86:100	argument_list|()
86:102	argument_list|)
86:103	return|;
87:17	block|}
87:19	else|else
87:24	block|{
88:25	return|return
88:32	name|str
88:35	return|;
89:17	block|}
90:9	block|}
92:1	comment|//      public static Double[] scanDoubleValues(String str, int sepChar) {
93:1	comment|//              String[] subs = StringUtil.split(str, sepChar);
94:1	comment|//              Double[] values = new Double[subs.length];
95:1	comment|//              for (int i = 0; i< subs.length; ++i) {
96:1	comment|//                      try {
97:1	comment|//                              double v = Double.parseDouble(subs[i]);
98:1	comment|//                              values[i] = v;
99:1	comment|//                      } catch (NumberFormatException e) {
100:1	comment|//                              values[i] = null;
101:1	comment|//                      }
102:1	comment|//              }
103:1	comment|//              return values;
104:1	comment|//      }
105:1	block|}
-:-	end_class
-:-	end_unit