Java MalformedPatternException类代码示例

import org.apache.oro.text.regex.MalformedPatternException; //导入依赖的package包/类
/**
 * Creates SSHShell.
 *
 * @param host the host name
 * @param port the ssh port
 * @param userName the ssh user name
 * @param sshPrivateKey the ssh password
 * @return the shell
 * @throws JSchException
 * @throws IOException
 */
private SSHShell(String host, int port, String userName, byte[] sshPrivateKey)
    throws JSchException, IOException {
    Closure expectClosure = getExpectClosure();
    for (String linuxPromptPattern : new String[]{"\\>", "#", "~#", "~\\$"}) {
        try {
            Match match = new RegExpMatch(linuxPromptPattern, expectClosure);
            linuxPromptMatches.add(match);
        } catch (MalformedPatternException malformedEx) {
            throw new RuntimeException(malformedEx);
        }
    }
    JSch jsch = new JSch();
    jsch.setKnownHosts(System.getProperty("user.home") + "/.ssh/known_hosts");
    jsch.addIdentity(host, sshPrivateKey, (byte[]) null, (byte[]) null);
    this.session = jsch.getSession(userName, host, port);
    this.session.setConfig("StrictHostKeyChecking", "no");
    this.session.setConfig("PreferredAuthentications", "publickey,keyboard-interactive,password");
    session.connect(60000);
    this.channel = (ChannelShell) session.openChannel("shell");
    this.expect = new Expect4j(channel.getInputStream(), channel.getOutputStream());
    channel.connect();
}
 

import org.apache.oro.text.regex.MalformedPatternException; //导入依赖的package包/类
/**
 * Creates SSHShell.
 *
 * @param host the host name
 * @param port the ssh port
 * @param userName the ssh user name
 * @param password the ssh password
 * @return the shell
 * @throws JSchException
 * @throws IOException
 */
private SshShell(String host, int port, String userName, String password)
        throws JSchException, IOException {
    Closure expectClosure = getExpectClosure();
    for (String linuxPromptPattern : new String[]{"\\>","#", "~#", "~\\$"}) {
        try {
            Match match = new RegExpMatch(linuxPromptPattern, expectClosure);
            linuxPromptMatches.add(match);
        } catch (MalformedPatternException malformedEx) {
            throw new RuntimeException(malformedEx);
        }
    }
    JSch jsch = new JSch();
    this.session = jsch.getSession(userName, host, port);
    session.setPassword(password);
    Hashtable<String,String> config = new Hashtable<>();
    config.put("StrictHostKeyChecking", "no");
    session.setConfig(config);
    session.connect(60000);
    this.channel = (ChannelShell) session.openChannel("shell");
    this.expect = new Expect4j(channel.getInputStream(), channel.getOutputStream());
    channel.connect();
}
 

import org.apache.oro.text.regex.MalformedPatternException; //导入依赖的package包/类
/**
 * Creates SSHShell.
 *
 * @param host the host name
 * @param port the ssh port
 * @param userName the ssh user name
 * @param password the ssh password
 * @return the shell
 * @throws JSchException
 * @throws IOException
 */
private SSHShell(String host, int port, String userName, String password)
        throws JSchException, IOException {
    Closure expectClosure = getExpectClosure();
    for (String linuxPromptPattern : new String[]{"\\>", "#", "~#", "~\\$"}) {
        try {
            Match match = new RegExpMatch(linuxPromptPattern, expectClosure);
            linuxPromptMatches.add(match);
        } catch (MalformedPatternException malformedEx) {
            throw new RuntimeException(malformedEx);
        }
    }
    JSch jsch = new JSch();
    this.session = jsch.getSession(userName, host, port);
    session.setPassword(password);
    Hashtable<String, String> config = new Hashtable<>();
    config.put("StrictHostKeyChecking", "no");
    session.setConfig(config);
    session.connect(60000);
    this.channel = (ChannelShell) session.openChannel("shell");
    this.expect = new Expect4j(channel.getInputStream(), channel.getOutputStream());
    channel.connect();
}
 

import org.apache.oro.text.regex.MalformedPatternException; //导入依赖的package包/类
/**
 * 把字符串转成Pattern和UrlType
 * 
 * @param perl5RegExp
 * @return
 */
private URLPatternHolder convertStringToPattern(String line) {
    URLPatternHolder holder = new URLPatternHolder();
    Pattern compiledPattern;
    Perl5Compiler compiler = new Perl5Compiler();
    String perl5RegExp = line;
    try {
        compiledPattern = compiler.compile(perl5RegExp, Perl5Compiler.READ_ONLY_MASK);
        holder.setCompiledPattern(compiledPattern);
    } catch (MalformedPatternException mpe) {
        throw new IllegalArgumentException("Malformed regular expression: " + perl5RegExp);
    }

    if (logger.isDebugEnabled()) {
        logger.debug("Added regular expression: " + compiledPattern.getPattern().toString());
    }
    return holder;
}
 

import org.apache.oro.text.regex.MalformedPatternException; //导入依赖的package包/类
public static Pattern makeOroPattern(String sqlLike) {
    Perl5Util perl5Util = new Perl5Util();
    try {
        sqlLike = perl5Util.substitute("s/([$^.+*?])/\\\\$1/g", sqlLike);
        sqlLike = perl5Util.substitute("s/%/.*/g", sqlLike);
        sqlLike = perl5Util.substitute("s/_/./g", sqlLike);
    } catch (Throwable t) {
        String errMsg = "Error in ORO pattern substitution for SQL like clause [" + sqlLike + "]: " + t.toString();
        Debug.logError(t, errMsg, module);
        throw new IllegalArgumentException(errMsg);
    }
    try {
        return PatternFactory.createOrGetPerl5CompiledPattern(sqlLike, true);
    } catch (MalformedPatternException e) {
        Debug.logError(e, module);
    }
    return null;
}
 

import org.apache.oro.text.regex.MalformedPatternException; //导入依赖的package包/类
/**
 * Compiles and caches a Perl5 regexp pattern for the given string pattern.
 * This would be of no benefits (and may bloat memory usage) if stringPattern is never the same.
 * @param stringPattern a Perl5 pattern string
 * @param caseSensitive case sensitive true/false
 * @return a <code>Pattern</code> instance for the given string pattern
 * @throws MalformedPatternException
 */

public static Pattern createOrGetPerl5CompiledPattern(String stringPattern, boolean caseSensitive) throws MalformedPatternException {
    Pattern pattern = compiledPerl5Patterns.get(stringPattern);
    if (pattern == null) {
        Perl5Compiler compiler = new Perl5Compiler();
        if (caseSensitive) {
            pattern = compiler.compile(stringPattern, Perl5Compiler.READ_ONLY_MASK); // READ_ONLY_MASK guarantees immutability
        } else {
            pattern = compiler.compile(stringPattern, Perl5Compiler.CASE_INSENSITIVE_MASK | Perl5Compiler.READ_ONLY_MASK);
        }
        pattern = compiledPerl5Patterns.putIfAbsentAndGet(stringPattern, pattern);
        if (Debug.verboseOn()) {
            Debug.logVerbose("Compiled and cached the pattern: '" + stringPattern, module);
        }
    }
    return pattern;
}
 

import org.apache.oro.text.regex.MalformedPatternException; //导入依赖的package包/类
/**
 * @param wildcard
 * @throws MalformedPatternException
 */
public WildCardFilter(String wildcard,boolean ignoreCase) throws MalformedPatternException {
    this.wildcard=wildcard;
    this.ignoreCase=ignoreCase;
    StringBuffer sb = new StringBuffer(wildcard.length());
    int len=wildcard.length();
    
    for(int i=0;i<len;i++) {
        char c = wildcard.charAt(i);
        if(c == '*')sb.append(".*");
        else if(c == '?') sb.append('.');
        else if(specials.indexOf(c)!=-1)sb.append('\\').append(c);
        else sb.append(c);
    }
    pattern=new Perl5Compiler().compile(ignoreCase?sb.toString().toLowerCase():sb.toString());
}
 

import org.apache.oro.text.regex.MalformedPatternException; //导入依赖的package包/类
@Nullable
private Pattern getTaskPattern(String pattern) {
  if (!Comparing.strEqual(pattern, myPattern)) {
    myCompiledPattern = null;
    myPattern = pattern;
  }
  if (myCompiledPattern == null) {
    final String regex = "^.*" + NameUtil.buildRegexp(pattern, 0, true, true);

    final Perl5Compiler compiler = new Perl5Compiler();
    try {
      myCompiledPattern = compiler.compile(regex);
    }
    catch (MalformedPatternException ignored) {
    }
  }
  return myCompiledPattern;
}
 

import org.apache.oro.text.regex.MalformedPatternException; //导入依赖的package包/类
@Override
public Regex create(String pattern) {
    org.apache.oro.text.regex.Perl5Compiler perl5Compiler = new org.apache.oro.text.regex.Perl5Compiler();
    org.apache.oro.text.regex.Perl5Matcher perl5Matcher = new org.apache.oro.text.regex.Perl5Matcher();
    org.apache.oro.text.regex.Pattern regexpr;
    try {
        regexpr = perl5Compiler.compile(pattern);
    } catch (MalformedPatternException e) {
        throw new IllegalArgumentException(e);
    }
    
    return new Regex() {
        @Override
        public boolean containsMatch(String string) {
            return perl5Matcher.matches(string, regexpr);
        }
    };
}
 

import org.apache.oro.text.regex.MalformedPatternException; //导入依赖的package包/类
/**
 * @param wildcard
 * @throws MalformedPatternException
 */
public WildCardFilter(String wildcard,boolean ignoreCase) throws MalformedPatternException {
    this.wildcard=wildcard;
    StringBuilder sb = new StringBuilder(wildcard.length());
    int len=wildcard.length();
    
    for(int i=0;i<len;i++) {
        char c = wildcard.charAt(i);
        if(c == '*')sb.append(".*");
        else if(c == '?') sb.append('.');
        else if(specials.indexOf(c)!=-1)sb.append('\\').append(c);
        else sb.append(c);
    }
    
    this.ignoreCase=ignoreCase;
    pattern=new Perl5Compiler().compile(ignoreCase?StringUtil.toLowerCase(sb.toString()):sb.toString());
}
 

import org.apache.oro.text.regex.MalformedPatternException; //导入依赖的package包/类
/**
 * return index of the first occurence of the pattern in input text
 * @param strPattern pattern to search
 * @param strInput text to search pattern
 * @param offset 
 * @param caseSensitive
 * @return position of the first occurence
 * @throws MalformedPatternException
*/
public static int indexOf(String strPattern, String strInput, int offset, boolean caseSensitive) throws MalformedPatternException {
       //Perl5Compiler compiler = new Perl5Compiler();
       PatternMatcherInput input = new PatternMatcherInput(strInput);
       Perl5Matcher matcher = new Perl5Matcher();
       
       int compileOptions=caseSensitive ? 0 : Perl5Compiler.CASE_INSENSITIVE_MASK;
       compileOptions+=Perl5Compiler.SINGLELINE_MASK;
       if(offset < 1) offset = 1;
       
       Pattern pattern = getPattern(strPattern,compileOptions);
       //Pattern pattern = compiler.compile(strPattern,compileOptions);
       

       if(offset <= strInput.length()) input.setCurrentOffset(offset - 1);
       
       if(offset <= strInput.length() && matcher.contains(input, pattern)) {
           return matcher.getMatch().beginOffset(0) + 1; 
       }
       return 0;
   }
 

import org.apache.oro.text.regex.MalformedPatternException; //导入依赖的package包/类
public synchronized List<String> get(String wildcard) throws MalformedPatternException, IOException {
	synchronized (data) {
		List<String> list=new ArrayList<String>();
		Iterator<Entry<String, String>> it = data.entrySet().iterator();
		WildCardFilter filter=new WildCardFilter( wildcard);
		Entry<String, String> entry;
		String value;
		while(it.hasNext()) {
			entry = it.next();
			value= entry.getValue();
			if(filter.accept(value)){
				list.add(entry.getKey());
				it.remove();
			}
		}
		if(list.size()>0)JavaConverter.serialize(data, file);
		return list;
	}
}
 

import org.apache.oro.text.regex.MalformedPatternException; //导入依赖的package包/类
/**
 * @param wildcard
 * @throws MalformedPatternException
 */
public WildCardFilter(String wildcard,boolean ignoreCase) throws MalformedPatternException {
    this.wildcard=wildcard;
    this.ignoreCase=ignoreCase;
    StringBuilder sb = new StringBuilder(wildcard.length());
    int len=wildcard.length();
    
    for(int i=0;i<len;i++) {
        char c = wildcard.charAt(i);
        if(c == '*')sb.append(".*");
        else if(c == '?') sb.append('.');
        else if(specials.indexOf(c)!=-1)sb.append('\\').append(c);
        else sb.append(c);
    }
    pattern=new Perl5Compiler().compile(ignoreCase?sb.toString().toLowerCase():sb.toString());
}
 

import org.apache.oro.text.regex.MalformedPatternException; //导入依赖的package包/类
protected String doRereplace( String _theString, String _theRE, String _theSubstr, boolean _casesensitive, boolean _replaceAll ) throws cfmRunTimeException{
	int replaceCount = _replaceAll ? Util.SUBSTITUTE_ALL : 1; 
	PatternMatcher matcher = new Perl5Matcher();
	Pattern pattern = null;
	PatternCompiler compiler = new Perl5Compiler();
   
	try {
		if ( _casesensitive ){
			pattern = compiler.compile( _theRE, Perl5Compiler.SINGLELINE_MASK );
		}else{
			pattern = compiler.compile( _theRE, Perl5Compiler.CASE_INSENSITIVE_MASK | Perl5Compiler.SINGLELINE_MASK );
		}
		
	} catch(MalformedPatternException e){ // definitely should happen since regexp is hardcoded
		cfCatchData catchD = new cfCatchData();
		catchD.setType( "Function" );
		catchD.setMessage( "Internal Error" );
		catchD.setDetail( "Invalid regular expression ( " + _theRE + " )" );
		throw new cfmRunTimeException( catchD );
	}

	// Perform substitution and print result.
	return Util.substitute(matcher, pattern, new Perl5Substitution( processSubstr( _theSubstr ) ), _theString, replaceCount );
}
 

import org.apache.oro.text.regex.MalformedPatternException; //导入依赖的package包/类
/**
 * 读入模版并将参数代进去.
 * 
 * @param fileName
 *            the file name
 * @param pattern
 *            the pattern
 * @param values
 *            the values
 * @return the string
 * @throws MalformedPatternException
 *             the malformed pattern exception
 */
public static String convertTemplate(String fileName, String pattern, HashMap values) throws MalformedPatternException {
	String record = null;
	StringBuffer sb = new StringBuffer();
	// int recCount = 0;
	try {
		FileReader fr = new FileReader(fileName);
		BufferedReader br = new BufferedReader(fr);
		record = new String();
		while ((record = br.readLine()) != null) {
			// recCount++;
			// System.out.println(recCount + ": " + record);
			sb.append(StringUtil.convert(record, pattern, values) + "\n");
		}
		br.close();
		fr.close();
	} catch (IOException e) {
		System.out.println("oh! no, got an IOException error!");
		e.printStackTrace();
	}
	return sb.toString();
}