Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
Pattern	23	78	43	0.00%	Show methods

Class Pattern

Class Pattern	Line # 23	Total Statements 78	Complexity 43	TOTAL Coverage 0.00%
getNext() : Pattern   getNext() : Pattern	5151	1.01	3.03	0.0 0.00%
setParent(Pattern) : void   setParent(Pattern) : void	6161	3.03	2.02	0.0 0.00%
nextMatch(int,Pthings) : int   nextMatch(int,Pthings) : int	7878	2.02	2.02	0.0 0.00%
nextString() : String   nextString() : String	9191	3.03	2.02	0.0 0.00%
inString(char,String) : boolean   inString(char,String) : boolean	101101	5.05	3.03	0.0 0.00%
protect(String,String,char) : String   protect(String,String,char) : String	119119	9.09	3.03	0.0 0.00%
match(StringLike,Pthings) : int   match(StringLike,Pthings) : int	139139	1.01	1.01	0.0 0.00%
matchAt(StringLike,int,Pthings) : int   matchAt(StringLike,int,Pthings) : int	147147	6.06	4.04	0.0 0.00%
Masked(int,Pthings) : boolean   Masked(int,Pthings) : boolean	162162	1.01	2.02	0.0 0.00%
add(Pattern) : Pattern   add(Pattern) : Pattern	168168	8.08	3.03	0.0 0.00%
minChars() : patInt   minChars() : patInt	190190	1.01	1.01	0.0 0.00%
maxChars() : patInt   maxChars() : patInt	198198	1.01	1.01	0.0 0.00%
countMinChars() : patInt   countMinChars() : patInt	204204	6.06	2.02	0.0 0.00%
countMaxChars() : patInt   countMaxChars() : patInt	217217	6.06	2.02	0.0 0.00%
testMatch(Pattern,int,Pthings) : int   testMatch(Pattern,int,Pthings) : int	235235	10.010	5.05	0.0 0.00%
clone1(Hashtable) : Pattern   clone1(Hashtable) : Pattern	262262	1.01	1.01	0.0 0.00%
clone(Hashtable) : Pattern   clone(Hashtable) : Pattern	269269	13.013	5.05	0.0 0.00%
equals(Object) : boolean   equals(Object) : boolean	294294	1.01	1.01	0.0 0.00%

 

Contributing tests

Source view

1		//
2		// This software is now distributed according to
3		// the Lesser Gnu Public License. Please see
4		// http://www.gnu.org/copyleft/lesser.txt for
5		// the details.
6		// -- Happy Computing!
7		//
8		package com.stevesoft.pat;
9
10		import jalview.util.MessageManager;
11
12		import java.util.Hashtable;
13
14		/**
15		Shareware: package pat
16		<a href="copyright.html">Copyright 2001, Steven R. Brandt</a>
17		*/
18		/**
19		* Class Pattern is the base class on which all the other pattern elements are
20		* built.
21		*/
22
		0% Uncovered Elements: 144 (144) Complexity: 43 Complexity Density: 0.55
23		public abstract class Pattern
24		{
25		/**
26		* The ESC character, the user can provide his own value for the escape
27		* character through regex.esc
28		*/
29		public final static char ESC = '\\';
30
31		final static String PROTECT_THESE = "[]{}(),$,-\"^.";
32
33		/**
34		* The interal match function, it must be provided by any class which wishes
35		* to extend Pattern.
36		*/
37		public abstract int matchInternal(int i, Pthings p);
38
39		public abstract String toString();
40
41		// Class Pattern is a singly linked list
42		// chained together by member next. The member
43		// parent is used so that sub patterns can access
44		// the chain they are branching from.
45		Pattern next = null, parent = null;
46
47		/**
48		* This gets the next element of a Pattern that we wish to match. If we are at
49		* the end of a subchain of patterns, it will return us to the parent chain.
50		*/
		0% Uncovered Elements: 5 (5) Complexity: 3 Complexity Density: 3
51	0	public Pattern getNext()...
52		{
53	0	return next != null ? next : (parent == null ? null : parent.getNext());
54		}
55
56		/**
57		* Call this method if you have a pattern element that takes a sub pattern
58		* (such as Or), and after you have added a sub pattern to the current pattern
59		* element.
60		*/
		0% Uncovered Elements: 5 (5) Complexity: 2 Complexity Density: 0.67
61	0	public void setParent(Pattern p)...
62		{
63	0	if (next != null)
64		{
65	0	next.setParent(p);
66		}
67		else
68		{
69	0	parent = p;
70		}
71		}
72
73		/**
74		* This determines if the remainder of a Pattern matches. Type "return
75		* nextMatch" from within matchInternal if the current Pattern matches.
76		* Otherwise, return a -1.
77		*/
		0% Uncovered Elements: 4 (4) Complexity: 2 Complexity Density: 1
78	0	public int nextMatch(int i, Pthings pt)...
79		{
80	0	Pattern p = getNext();
81		/*
82		* if(p == null) return i; return p.matchInternal(i,pt);
83		*/
84	0	return p == null ? i : p.matchInternal(i, pt);
85		}
86
87		/**
88		* This is a toString() for the remainder of the Pattern elements after this
89		* one. use this when overriding toString(). Called from within toString().
90		*/
		0% Uncovered Elements: 5 (5) Complexity: 2 Complexity Density: 0.67
91	0	public String nextString()...
92		{
93	0	if (next == null)
94		{
95	0	return "";
96		}
97	0	return next.toString();
98		}
99
100		/** a method to detect whether char c is in String s */
		0% Uncovered Elements: 9 (9) Complexity: 3 Complexity Density: 0.6
101	0	final static boolean inString(char c, String s)...
102		{
103	0	int i;
104	0	for (i = 0; i < s.length(); i++)
105		{
106	0	if (s.charAt(i) == c)
107		{
108	0	return true;
109		}
110		}
111	0	return false;
112		}
113
114		/**
115		* A method to create a string that protects the characters listed in
116		* PROTECT_THESE by prepending the esc character. The esc character itself is
117		* automatically protected.
118		*/
		0% Uncovered Elements: 13 (13) Complexity: 3 Complexity Density: 0.33
119	0	final static String protect(String s, String PROTECT_THESE, char esc)...
120		{
121	0	int i;
122	0	StringBuffer sb = new StringBuffer();
123	0	String p = PROTECT_THESE + esc;
124	0	for (i = 0; i < s.length(); i++)
125		{
126	0	char c = s.charAt(i);
127	0	if (inString(c, p))
128		{
129	0	sb.append(esc);
130		}
131	0	sb.append(c);
132		}
133	0	return sb.toString();
134		}
135
136		/**
137		* This can be used to perform a match test from within class Pattern.
138		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
139	0	public int match(StringLike s, Pthings pt)...
140		{
141	0	return matchAt(s, 0, pt);
142		}
143
144		/**
145		* This can be used to perform a match test from within class Pattern.
146		*/
		0% Uncovered Elements: 12 (12) Complexity: 4 Complexity Density: 0.67
147	0	public int matchAt(StringLike s, int i, Pthings pt)...
148		{
149	0	pt.src = s;
150	0	int r = matchInternal(i, pt);
151	0	if (r < 0)
152		{
153	0	return -1;
154		}
155	0	mfrom = r < i ? r + 1 : i;
156	0	return r < i ? i - r - 1 : r - i;
157		}
158
159		int mfrom = 0;
160
161		// Detect masked characters
		0% Uncovered Elements: 3 (3) Complexity: 2 Complexity Density: 2
162	0	final boolean Masked(int i, Pthings pt)...
163		{
164	0	return pt.cbits == null ? false : pt.cbits.get(i);
165		}
166
167		/** add a Pattern to the singly-linked Pattern chain. */
		0% Uncovered Elements: 12 (12) Complexity: 3 Complexity Density: 0.38
168	0	public Pattern add(Pattern p)...
169		{
170	0	if (next == null)
171		{
172	0	if (p == null)
173		{
174	0	return this;
175		}
176	0	next = p;
177	0	p.parent = parent;
178	0	parent = null;
179		}
180		else
181		{
182	0	next.add(p);
183		}
184	0	return this;
185		}
186
187		/**
188		* The minimum number of characters which this pattern element can match.
189		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
190	0	public patInt minChars()...
191		{
192	0	return new patInt(0);
193		}
194
195		/**
196		* The maximum number of characters which this pattern element can match.
197		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
198	0	public patInt maxChars()...
199		{
200	0	return new patInf();
201		}
202
203		/** return minimum number of characters in pattern */
		0% Uncovered Elements: 8 (8) Complexity: 2 Complexity Density: 0.33
204	0	public final patInt countMinChars()...
205		{
206	0	Pattern p = this;
207	0	patInt sum = new patInt(0);
208	0	while (p != null)
209		{
210	0	sum.pluseq(p.minChars());
211	0	p = p.next;
212		}
213	0	return sum;
214		}
215
216		/** return maximum number of characters in pattern */
		0% Uncovered Elements: 8 (8) Complexity: 2 Complexity Density: 0.33
217	0	public final patInt countMaxChars()...
218		{
219	0	Pattern p = this;
220	0	patInt sum = new patInt(0);
221	0	while (p != null)
222		{
223	0	sum.pluseq(p.maxChars());
224	0	p = p.next;
225		}
226	0	return sum;
227		}
228
229		// This method is only needed by Multi_stage2 so far...
230		// the reason is that it may try something else after a
231		// match succeeds. OrMark will only record the last thing
232		// tried in marks, so we need to backup the result of the
233		// last successful match and restore it if the next one
234		// does not succeed.
		0% Uncovered Elements: 16 (16) Complexity: 5 Complexity Density: 0.5
235	0	final int testMatch(Pattern p, int pos, Pthings pt)...
236		{
237	0	int[] tab = null;
238	0	if (pt.marks != null)
239		{
240	0	try
241		{
242	0	tab = new int[pt.marks.length];
243	0	for (int i = 0; i < tab.length; i++)
244		{
245	0	tab[i] = pt.marks[i];
246		}
247		} catch (Throwable t)
248		{
249		}
250		}
251	0	int ret = p.matchInternal(pos, pt);
252	0	if (ret < 0)
253		{
254	0	pt.marks = tab;
255		}
256	0	return ret;
257		}
258
259		/**
260		* Clones this pattern elements without cloning others in the linked list.
261		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
262	0	Pattern clone1(Hashtable h)...
263		{
264	0	throw new Error(MessageManager.formatMessage(
265		"error.no_such_method_as_clone1_for", new String[]
266		{ getClass().getName() }));
267		}
268
		0% Uncovered Elements: 21 (21) Complexity: 5 Complexity Density: 0.38
269	0	Pattern clone(Hashtable h)...
270		{
271	0	Pattern p = (Pattern) h.get(this);
272	0	if (p != null)
273		{
274	0	return p;
275		}
276	0	p = clone1(h);
277	0	if (p == null)
278		{
279	0	throw new Error(MessageManager.getString("error.null_from_clone1"));
280		}
281	0	h.put(this, p);
282	0	h.put(p, p);
283	0	if (next != null)
284		{
285	0	p.next = next.clone(h);
286		}
287	0	if (parent != null)
288		{
289	0	p.parent = parent.clone(h);
290		}
291	0	return p;
292		}
293
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
294	0	public boolean equals(Object o)...
295		{
296	0	return o == this;
297		}
298		};