001/**
002 *  '$Author: welker $'
003 *  '$Date: 2010-05-06 05:21:26 +0000 (Thu, 06 May 2010) $'
004 *  '$Revision: 24234 $'
005 *
006 *  For Details:
007 *  http://www.kepler-project.org
008 *
009 *  Copyright (c) 2009-2010 The Regents of the
010 *  University of California. All rights reserved. Permission is hereby granted,
011 *  without written agreement and without license or royalty fees, to use, copy,
012 *  modify, and distribute this software and its documentation for any purpose,
013 *  provided that the above copyright notice and the following two paragraphs
014 *  appear in all copies of this software. IN NO EVENT SHALL THE UNIVERSITY OF
015 *  CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL,
016 *  OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
017 *  DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE
018 *  POSSIBILITY OF SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY
019 *  DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
020 *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
021 *  SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
022 *  CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
023 *  ENHANCEMENTS, OR MODIFICATIONS.
024 */
025
026package org.kepler.workflowrunmanager;
027
028import java.util.regex.Matcher;
029import java.util.regex.Pattern;
030
031public class ExecIdQueryParse {
032
033        // pattern for one execId e.g.: 5
034        String singleExecIdRegEx = "\\s*([0-9]+)\\s*";
035        String oneExecIdRegEx = "\\s*"+singleExecIdRegEx;
036        Pattern oneExecIdPattern = Pattern.compile(oneExecIdRegEx);
037
038        // pattern for one execId with operator. e.g.: > 5
039        String oneExecIdWithOpRegEx = "\\s*([><])\\s*" + singleExecIdRegEx;
040        Pattern oneExecIdWithOpPattern = Pattern.compile(oneExecIdWithOpRegEx);
041
042        // pattern for execId range. e.g.: 5 - 7
043        String execIdRangeRegEx = singleExecIdRegEx + "\\s*"+WRMDefaults.RANGE_SEPARATOR+"\\s*"
044                        + singleExecIdRegEx;
045        Pattern execIdRangePattern = Pattern.compile(execIdRangeRegEx);
046        
047        private boolean isValid = false;
048        private boolean isRange = false;
049        private String operator = null;
050        private int numExecIds = 0;
051        private String completeText = "";
052
053        private static final String LESS_THAN = "<";
054        private static final String GREATER_THAN = ">";
055        
056        // we could let users specify multiple ranges with a bit more work
057        // elsewhere...
058        private static int numAllowedExecIds = 2;
059        public Integer[] parsedExecIds = new Integer[numAllowedExecIds];
060
061        public ExecIdQueryParse(String execIdQuery) {
062
063                Matcher oneExecIdMatcher = oneExecIdPattern.matcher(execIdQuery);
064                Matcher oneExecIdWithOpMatcher = oneExecIdWithOpPattern
065                                .matcher(execIdQuery);
066                Matcher execIdRangeMatcher = execIdRangePattern.matcher(execIdQuery);
067
068
069                if (execIdRangeMatcher.matches()) {
070                        isValid = true;
071                        isRange = true;
072
073                        for (int i = 0, j = 1; i < numAllowedExecIds; i++, j++) {
074                                numExecIds = i + 1;
075                                parsedExecIds[i] = new Integer(execIdRangeMatcher.group(j));
076                                
077                                if (i % 2 == 0) {
078                                        completeText += parsedExecIds[i] + " "
079                                                        + WRMDefaults.RANGE_SEPARATOR + " ";
080                                } else {
081                                        //comma here if we allow >1 range
082                                        completeText += parsedExecIds[i];
083                                }       
084                        }
085
086                } else if (oneExecIdWithOpMatcher.matches()) {
087                        isRange = false;
088                        operator = oneExecIdWithOpMatcher.group(1);
089                        numExecIds = 1;
090                        isValid = true;
091                        parsedExecIds[0] = new Integer(oneExecIdWithOpMatcher.group(2));
092                        completeText = operator + " " + parsedExecIds[0];
093                }
094                else if (oneExecIdMatcher.matches()){ 
095                        isRange = false;
096                        numExecIds = 1;
097                        isValid = true;
098                        parsedExecIds[0] = new Integer(oneExecIdMatcher.group(1));
099                        completeText = ""+parsedExecIds[0];
100                }
101
102        }
103
104        public boolean isValid(){
105                return isValid;
106        }
107        public boolean isRange(){
108                return isRange;
109        }
110        public String getOperator(){
111                return operator;
112        }
113        public int getNumItems(){
114                return numExecIds;
115        }
116
117        public String getCompleteText(){
118                return completeText;
119        }
120        
121        /**
122         * Check if execId passes filter.
123         * 
124         * @param inputExecId
125         * @return
126         */
127        public boolean passesFilter(int inputExecId){
128                if (isValid()){
129                        if (isRange()){
130                                if ( (parsedExecIds[0] <= inputExecId) && 
131                                                (parsedExecIds[1] >= inputExecId)){
132                                        return true;
133                                }
134                        }
135                        else{
136                                if (getOperator() != null){
137                                        if (getOperator().equals(GREATER_THAN)){
138                                                if (inputExecId > parsedExecIds[0]){
139                                                        return true;
140                                                }
141                                        }
142                                        else if (getOperator().equals(LESS_THAN)){
143                                                if (inputExecId < parsedExecIds[0]){
144                                                        return true;
145                                                }
146                                        }
147                                }
148                                else{
149                                        if (inputExecId == parsedExecIds[0]){
150                                                return true;
151                                        }
152                                }
153                        }
154                }
155                
156                return false;
157        }
158        
159}