trunk/proteinstructure/NodeSet.java

package proteinstructure;

import java.util.TreeSet;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class NodeSet extends TreeSet<Integer> {

        private static final long serialVersionUID = 1L;
        
        /**
         * Returns the set as a vector of intervals of consecutive elements.
         * @return
         */
        public Vector<Interval> getIntervals() {
                Vector<Interval> intervals = new Vector<Interval>();
                if(this.size() == 0) return intervals;
                // assuming that this set is sorted, otherwise sort it
                int last = this.first();        // previous element
                int start = last;                       // start if current interval
                for(int i:this) {
                        if(i > last+1) {
                                // output interval and start new one
                                intervals.add(new Interval(start, last));
                                start = i;
                                last = i;
                        } else
                        if(i == last) {
                                // can that even happen?
                        } else
                        if(i == last+1) {
                                last = i;
                        }
                }
                // output last interval
                intervals.add(new Interval(start, last));
                return intervals;
        }
        
        /**
         * Returns true if selStr is a valid selection string in 'comma-hyphen' syntax, e.g. 1-3,5,7-8.
         * @return true if selStr is a syntactically correct selection string, false otherwise
         */
        public static boolean isValidSelectionString(String selStr) {
                Pattern p = Pattern.compile("\\d+(-\\d+)?(,\\d+(-\\d+)?)*");
                Matcher m = p.matcher(selStr);
                return m.matches();
        }
        
        /**
         * Create a new NodeSet from a selection string in 'comma-hyphen' nomenclature, e.g. 1-3,5,7-8.
         * The validity of a selection string can be checked by isValidSelectionString().
         * @return A node set corresponding to the given selection string or null of string is invalid.
         */
        public static NodeSet parseSelectionString(String selStr) {
                if(!isValidSelectionString(selStr)) return null;
                NodeSet newSet = new NodeSet();
                String[] tokens = selStr.split(",");
                for(String t:tokens) {
                        if(t.contains("-")) {
                                String[] range = t.split("-");
                                int from = Integer.parseInt(range[0]);
                                int to = Integer.parseInt(range[1]);
                                for(int i=from; i <= to; i++) {
                                        newSet.add(i);
                                }
                                
                        } else {
                                int num = Integer.parseInt(t);
                                newSet.add(num);
                        }
                }
                return newSet;
        }
        
}
Revision:	325
Committed:	Thu Sep 20 10:48:55 2007 UTC (17 years ago) by stehr
File size:	2182 byte(s)
Log Message:	added parsing of residue selection strings
Line	User	Rev	File contents
1	stehr	230	package proteinstructure;
2
3			import java.util.TreeSet;
4			import java.util.Vector;
5	stehr	325	import java.util.regex.Matcher;
6			import java.util.regex.Pattern;
7	stehr	230
8			public class NodeSet extends TreeSet<Integer> {
9
10			private static final long serialVersionUID = 1L;
11	stehr	325
12	stehr	230	/**
13			* Returns the set as a vector of intervals of consecutive elements.
14			* @return
15			*/
16			public Vector<Interval> getIntervals() {
17			Vector<Interval> intervals = new Vector<Interval>();
18			if(this.size() == 0) return intervals;
19			// assuming that this set is sorted, otherwise sort it
20			int last = this.first(); // previous element
21			int start = last; // start if current interval
22			for(int i:this) {
23			if(i > last+1) {
24			// output interval and start new one
25			intervals.add(new Interval(start, last));
26			start = i;
27			last = i;
28			} else
29			if(i == last) {
30			// can that even happen?
31			} else
32			if(i == last+1) {
33			last = i;
34			}
35			}
36			// output last interval
37			intervals.add(new Interval(start, last));
38			return intervals;
39			}
40
41	stehr	325	/**
42			* Returns true if selStr is a valid selection string in 'comma-hyphen' syntax, e.g. 1-3,5,7-8.
43			* @return true if selStr is a syntactically correct selection string, false otherwise
44			*/
45			public static boolean isValidSelectionString(String selStr) {
46			Pattern p = Pattern.compile("\\d+(-\\d+)?(,\\d+(-\\d+)?)*");
47			Matcher m = p.matcher(selStr);
48			return m.matches();
49			}
50
51			/**
52			* Create a new NodeSet from a selection string in 'comma-hyphen' nomenclature, e.g. 1-3,5,7-8.
53			* The validity of a selection string can be checked by isValidSelectionString().
54			* @return A node set corresponding to the given selection string or null of string is invalid.
55			*/
56			public static NodeSet parseSelectionString(String selStr) {
57			if(!isValidSelectionString(selStr)) return null;
58			NodeSet newSet = new NodeSet();
59			String[] tokens = selStr.split(",");
60			for(String t:tokens) {
61			if(t.contains("-")) {
62			String[] range = t.split("-");
63			int from = Integer.parseInt(range[0]);
64			int to = Integer.parseInt(range[1]);
65			for(int i=from; i <= to; i++) {
66			newSet.add(i);
67			}
68
69			} else {
70			int num = Integer.parseInt(t);
71			newSet.add(num);
72			}
73			}
74			return newSet;
75			}
76
77	stehr	230	}