Java Code Examples for java.util.regex.Matcher#group()

/**
 * Parse a jolokia property
 * @param converter the jolokia converter to use
 * @param key key
 * @param object value
 */
void parse(final JolokiaConverter converter, final Object key, final Object object) {
    if (logger.isTraceEnabled()) {
        logger.trace("Processing returned JSON Key {} with value: {}", key, object);
    }

    String jolokiaPropertyName = "";
    if (key instanceof String) {
        String tmp = (String) key;

        logger.trace("Checking property name/group {}", tmp);

        Pattern pattern = Pattern.compile(".*name=(.*),.*");
        Matcher matcher = pattern.matcher(tmp);

        if (matcher.matches()) {
            jolokiaPropertyName = matcher.group(1);

            logger.trace("Reading property name/group '{}'", jolokiaPropertyName);
        } else {
            jolokiaPropertyName = tmp;
        }
    }

    converter.convert(jolokiaPropertyName, object);
}
 

public Element(String name, String id) {
    // id
    final Matcher matcher = sIdPattern.matcher(id);
    if (matcher.find() && matcher.groupCount() > 0) {
        this.id = matcher.group(2);

        String androidNS = matcher.group(1);
        this.isAndroidNS = !(androidNS == null || androidNS.length() == 0);
    }

    // name
    String[] packages = name.split("\\.");
    if (packages.length > 1) {
        this.nameFull = name;
        this.name = packages[packages.length - 1];
    } else {
        this.nameFull = null;
        this.name = name;
    }

    this.fieldName = getFieldName();
}
 

/**
 *
 * @param input a comma-separated list of longitude,latitude pairs specifying a set of bounding boxes,
 *              with the southwest corner of the bounding box coming first
 *
 * @return a list of the Location instances represented by the provided input
 */
public static List<Location> parseLocations(final String input) {
    final List<Location> locations = new ArrayList<>();
    final Matcher locationsMatcher = LOCATIONS_PATTERN.matcher(input);
    if (locationsMatcher.matches()) {
        Matcher locationMatcher = LOCATION_PATTERN.matcher(input);
        while (locationMatcher.find()) {
            final String location = locationMatcher.group();
            locations.add(parseLocation(location));
        }
    } else {
        throw new IllegalStateException("The provided location string was invalid.");
    }

    return locations;
}
 

@Override
public void processNewLines(String[] lines) {
    for (String line : lines) {
        if (!line.isEmpty()) {
            if (line.startsWith(SUCCESS_OUTPUT)) {
                mErrorMessage = null;
            } else {
                Matcher m = FAILURE_PATTERN.matcher(line);
                if (m.matches()) {
                    mErrorMessage = m.group(1);
                } else {
                    mErrorMessage = "Unknown failure";
                }
            }
        }
    }
}
 

public String getDatabase(){
    String table = conf.get(CLI_P_TABLE);
    String database;
    if(null != table && table.contains(".") && !table.endsWith(".")){
        database = table.substring(0, table.indexOf("."));
    }else{
        Matcher m = urlRegexp.matcher(getConnectUrl());
        if (m.find()) {
            if (m.group(3) != null) {
                database = m.group(3);
            } else {
                database = DEFAULT_DATABASE;
            }
        } else {
            throw new IllegalArgumentException("Incorrect ClickHouse jdbc url: " + getConnectUrl());
        }
    }
    return database;
}
 

static String extractCharset(File dir, String filename) throws IOException {
    if(filename.contains("fra")){
        log.info("\n");
    }
    File metaFile = new File(dir,filename.replace("text","meta.txt"));
    FileInputStream fileIn = new FileInputStream(metaFile);
    InputStreamReader isReader = new InputStreamReader(fileIn);
    BufferedReader bufReader = new BufferedReader(isReader);
    try {
        while (true) {
            String line = bufReader.readLine();
            Pattern pattern = Pattern.compile("content encoding\\s+(\\S+)$");
            Matcher matcher = pattern.matcher(line);
            if (!matcher.find()) continue;
            bufReader.close();
            return matcher.group(1);
        }
    }
    catch(Exception ex){
        return "utf-8";
    }
}
 

public String match(String agentString) {
	Matcher matcher = pattern.matcher(agentString);

	if (!matcher.find()) {
		return null;
	}

	String family = null;
	if (familyReplacement != null) {
		if (familyReplacement.contains("$1")
				&& matcher.groupCount() >= 1
				&& matcher.group(1) != null) {
			family = familyReplacement.replaceFirst("\\$1",
					Matcher.quoteReplacement(matcher.group(1)));
		} else {
			family = familyReplacement;
		}
	} else if (matcher.groupCount() >= 1) {
		family = matcher.group(1);
	}
	return family;
}
 

@NotNull
private static Module.Key parseModuleKey(String streamName, String moduleName) {
    String versionAndVersionType = streamName.replace(moduleName + "-", "");
    Matcher matcher = Pattern.compile("(.*)-([^-]+)$").matcher(versionAndVersionType);
    if (!matcher.matches()) {
        throw new IllegalArgumentException(INVALID_STREAM_NAME_ERROR_MSG);
    }
    TemplateContainer.VersionType versionType;
    try {
        versionType = TemplateContainer.VersionType.fromMinimizedForm(matcher.group(2));
    } catch (InvalidParameterException e) {
        throw new IllegalArgumentException(INVALID_STREAM_NAME_ERROR_MSG);
    }
    return new Module.Key(moduleName, matcher.group(1), versionType);
}
 

/**
 * Create an image name with a tag. If a tag is provided (i.e. is not null) then this tag is used.
 * Otherwise the tag of the provided name is used (if any).
 *
 * @param fullName The fullname of the image in Docker format. I
 * @param givenTag tag to use. Can be null in which case the tag specified in fullName is used.
 */
public ImageName(String fullName, String givenTag) {
    if (fullName == null) {
        throw new NullPointerException("Image name must not be null");
    }

    // set digest to null as default
    digest = null;
    // check if digest is part of fullName, if so -> extract it
    if(fullName.contains("@sha256")) { // Of it contains digest
        String[] digestParts = fullName.split("@");
        digest = digestParts[1];
        fullName = digestParts[0];
    }

    // check for tag
    Pattern tagPattern = Pattern.compile("^(.+?)(?::([^:/]+))?$");
    Matcher matcher = tagPattern.matcher(fullName);
    if (!matcher.matches()) {
        throw new IllegalArgumentException(fullName + " is not a proper image name ([registry/][repo][:port]");
    }
    // extract tag if it exists
    tag = givenTag != null ? givenTag : matcher.group(2);
    String rest = matcher.group(1);

    // extract registry, repository, user
    parseComponentsBeforeTag(rest);

    /*
     * set tag to latest if tag AND digest are null
     * if digest is not null but tag is -> leave it!
     *  -> in case of "image_name@sha256" it is not required to get resolved to "latest"
     */
    if (tag == null && digest == null) {
        tag = "latest";
    }

    doValidate();
}
 

private static String findDate(String str) {
    Pattern pattern = Pattern.compile("[0-9]{4}_[0-9]{2}_[0-9]{2}");
    Matcher matcher = pattern.matcher(str);
    if (matcher.find()) {
        return matcher.group();
    }
    return "";
}
 

/**
 * Read process info for the running Application.
 * The Application writes its info to a file with this format:
 * shutdownPort=42994
 * pid=19597
 * done
 *
 * The final "done" is used to make sure the complete file has been written
 * before we try to read it.
 * This function will wait until the file is available.
 *
 * @param filename Path to file to read.
 * @return The ProcessInfo containing pid and shutdownPort.
 */
public static ProcessInfo readProcessInfo(String filename) throws Throwable {
    System.out.println("Reading port and pid from file: " + filename);
    File file = new File(filename);
    String content = null;

    // Read file or wait for it to be created.
    while (true) {
        content = readFile(file);
        if (content != null && content.indexOf("done") >= 0) {
            break;
        }
        Thread.sleep(100);
    }

    ProcessInfo info = new ProcessInfo();
    // search for a line with format: key=nnn
    Pattern pattern = Pattern.compile("(\\w*)=([0-9]+)\\r?\\n");
    Matcher matcher = pattern.matcher(content);
    while (matcher.find()) {
        String key = matcher.group(1);
        int value  = Integer.parseInt(matcher.group(2));
        if ("pid".equals(key)) {
            info.pid = value;
        } else if ("shutdownPort".equals(key)) {
            info.shutdownPort = value;
        }
    }
    System.out.println("processInfo.pid:" + info.pid);
    System.out.println("processInfo.shutdownPort:" + info.shutdownPort);
    return info;
}
 

/**
 * Parses a String containing zero or more PEM-encoded X509 certificates into an array of {@link X509Certificate}.
 * Everything outside of BEGIN CERTIFICATE and END CERTIFICATE lines will be ignored.
 *
 * @param pemEncodedCAs a String containing PEM-encoded certficiates
 * @return array containing certificates in the String
 */
public static X509Certificate[] readX509CertificatesFromPem(String pemEncodedCAs) {
    List<X509Certificate> certificates = new ArrayList<>(500);

    Matcher pemMatcher = CA_PEM_PATTERN.matcher(pemEncodedCAs);

    while (pemMatcher.find()) {
        String singleCAPem = pemMatcher.group();

        X509Certificate certificate = readSingleX509Certificate(singleCAPem);
        certificates.add(certificate);
    }

    return certificates.toArray(new X509Certificate[0]);
}
 

private static void cleanupModifier(StringBuffer result, String modifier) {
	Matcher m = FUZZY_MODIFIDER.matcher(modifier);
	if (m.matches()) {
		modifier = m.group(1);
	}
	for (int i = 0; i < modifier.length(); i++) {
		char c = modifier.charAt(i);
		if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z')
				|| (c >= 'A' && c <= 'Z') || c == '_' || c == '-') {
			result.append(c);
		}
	}
}
 

private String getDbRealAddress(String url, String dsType) throws Exception {
    Matcher matcher;
    Matcher matcherServiceName = null;
    String host;
    String port;
    String resultOri = "";
    String resultIp = "";
    String serviceName = null;
    if (dsType.equalsIgnoreCase("oracle")) {
        matcher = ORACLE_URL_PATTERN.matcher(url);
        matcherServiceName = ORACLE_SERVICE_PATTERN.matcher(url);
        if (matcherServiceName.find()) {
            serviceName = matcherServiceName.group(1);
        }
    } else {
        matcher = MYSQL_URL_PATTERN.matcher(StringUtils.lowerCase(url));
    }
    while (matcher.find()) {
        host = matcher.group(1);
        port = matcher.group(2);
        if (StringUtils.isNotBlank(resultOri)) {
            resultOri = resultOri + "," + host + ":" + port;
            resultIp = resultIp + "," + getIpByHostName(host) + ":" + port;
        } else {
            resultOri = host + ":" + port;
            resultIp = getIpByHostName(host) + ":" + port;
        }
        if (serviceName != null) {
            resultOri = resultOri + ":" + matcherServiceName.group(1);
            resultIp = resultIp + ":" + matcherServiceName.group(1);
        }
    }
    return resultOri + "&" + resultIp;
}
 

@Override
public Object execute(TransitionSystem ts, Unifier un, Term[] args) throws Exception {
    checkArguments(args);
    StringBuffer sb = new StringBuffer();
    for (Term term : args) {
        if (!term.isString()) {
            continue;
        }
        StringTerm st = (StringTerm) term;
        Matcher matcher = regex.matcher(st.getString());

        while (matcher.find()) {

            //System.out.println("I found the text \""+matcher.group()+ "\"starting at index "+matcher.start()+ " and ending at index "+matcher.end());

            String sVar = matcher.group();
            sVar = sVar.substring(2, sVar.length() - 1);
            try {
                Term t = null;
                if (sVar.startsWith("_") && sVar.length() > 1) // deals with unnamed vars, where we cannot use parseTerm
                    t = new UnnamedVar( Integer.valueOf( sVar.substring(1)));
                else
                    t = ASSyntax.parseTerm(sVar);

                //We use t.apply to evaluate any logical or arithmetic expression in Jason
                t = t.capply(un);
                matcher.appendReplacement(sb, t.isString() ? ((StringTerm)t).getString() : t.toString());
            } catch (ParseException pe) {
                // TODO: handle exception
                // TODO: Decide whether or not we should ignore the exception and print the call instead
                // Right now, if I get a parse error from ASSyntax, I just print the original escaped
                // sequence, so a user can see that his/her expression was problematic
                matcher.appendReplacement(sb, "#{"+sVar+"}");
            }

        }
        matcher.appendTail(sb);
    }

    if (args[args.length - 1].isVar()) {
        StringTerm stRes = new StringTermImpl(sb.toString());
        return un.unifies(stRes, args[args.length - 1]);
    } else {
        ts.getLogger().info(sb.toString());
        return true;
    }
}
 

protected String fixMissingNamespaces(String descriptorXml, DescriptorBindingException ex) {
    // Windows: org.fourthline.cling.binding.xml.DescriptorBindingException: Could not parse device descriptor: org.seamless.xml.ParserException: org.xml.sax.SAXParseException: The prefix "dlna" for element "dlna:X_DLNADOC" is not bound.
    // Android: org.xmlpull.v1.XmlPullParserException: undefined prefix: dlna (position:START_TAG <{null}dlna:X_DLNADOC>@19:17 in java.io.StringReader@406dff48)

    // We can only handle certain exceptions, depending on their type and message
    Throwable cause = ex.getCause();
    if (!((cause instanceof SAXParseException) || (cause instanceof ParserException)))
        return null;
    String message = cause.getMessage();
    if (message == null)
        return null;

    Pattern pattern = Pattern.compile("The prefix \"(.*)\" for element"); // Windows
    Matcher matcher = pattern.matcher(message);
    if (!matcher.find() || matcher.groupCount() != 1) {
        pattern = Pattern.compile("undefined prefix: ([^ ]*)"); // Android
        matcher = pattern.matcher(message);
        if (!matcher.find() || matcher.groupCount() != 1)
            return null;
    }

    String missingNS = matcher.group(1);
    log.warning("Fixing missing namespace declaration for: " + missingNS);

    // Extract <root> attributes
    pattern = Pattern.compile("<root([^>]*)");
    matcher = pattern.matcher(descriptorXml);
    if (!matcher.find() || matcher.groupCount() != 1) {
        log.fine("Could not find <root> element attributes");
        return null;
    }

    String rootAttributes = matcher.group(1);
    log.fine("Preserving existing <root> element attributes/namespace declarations: " + matcher.group(0));

    // Extract <root> body
    pattern = Pattern.compile("<root[^>]*>(.*)</root>", Pattern.DOTALL);
    matcher = pattern.matcher(descriptorXml);
    if (!matcher.find() || matcher.groupCount() != 1) {
        log.fine("Could not extract body of <root> element");
        return null;
    }

    String rootBody = matcher.group(1);

    // Add missing namespace, it only matters that it is defined, not that it is correct
    return "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>"
        + "<root "
        + String.format("xmlns:%s=\"urn:schemas-dlna-org:device-1-0\"", missingNS) + rootAttributes + ">"
        + rootBody
        + "</root>";

    // TODO: Should we match different undeclared prefixes with their correct namespace?
    // So if it's "dlna" we use "urn:schemas-dlna-org:device-1-0" etc.
}
 

@Override
boolean matchesCachedFile(final Matcher matcher, final String url) {
	final String hash = matcher.group("hash");

	return url.hashCode() == Integer.parseInt(hash);
}
 

public static void main(String[] args) throws Exception {

        String[][] kdcs = {
                {"simple.host", null},  // These are legal settings
                {"simple.host", ""},
                {"simple.host", "8080"},
                {"0.0.0.1", null},
                {"0.0.0.1", ""},
                {"0.0.0.1", "8080"},
                {"1::1", null},
                {"[1::1]", null},
                {"[1::1]", ""},
                {"[1::1]", "8080"},
                {"[1::1", null},        // Two illegal settings
                {"[1::1]abc", null},
        };
        // Prepares a krb5.conf with every kind of KDC settings
        PrintStream out = new PrintStream(new FileOutputStream("ipv6.conf"));
        out.println("[libdefaults]");
        out.println("default_realm = V6");
        out.println("kdc_timeout = 1");
        out.println("[realms]");
        out.println("V6 = {");
        for (String[] hp: kdcs) {
            if (hp[1] != null) out.println("    kdc = "+hp[0]+":"+hp[1]);
            else out.println("    kdc = " + hp[0]);
        }
        out.println("}");
        out.close();

        System.setProperty("sun.security.krb5.debug", "true");
        System.setProperty("java.security.krb5.conf", "ipv6.conf");

        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        PrintStream po = new PrintStream(bo);
        PrintStream oldout = System.out;
        System.setOut(po);

        try {
            Subject subject = new Subject();
            Krb5LoginModule krb5 = new Krb5LoginModule();
            Map<String, String> map = new HashMap<>();
            Map<String, Object> shared = new HashMap<>();

            map.put("debug", "true");
            map.put("doNotPrompt", "true");
            map.put("useTicketCache", "false");
            map.put("useFirstPass", "true");
            shared.put("javax.security.auth.login.name", "any");
            shared.put("javax.security.auth.login.password", "any".toCharArray());
            krb5.initialize(subject, null, shared, map);
            krb5.login();
        } catch (Exception e) {
            // Ignore
        }

        po.flush();

        System.setOut(oldout);
        BufferedReader br = new BufferedReader(new StringReader(
                new String(bo.toByteArray())));
        int cc = 0;
        Pattern r = Pattern.compile(".*KrbKdcReq send: kdc=(.*) UDP:(\\d+),.*");
        String line;
        while ((line = br.readLine()) != null) {
            Matcher m = r.matcher(line.subSequence(0, line.length()));
            if (m.matches()) {
                System.out.println("------------------");
                System.out.println(line);
                String h = m.group(1), p = m.group(2);
                String eh = kdcs[cc][0], ep = kdcs[cc][1];
                if (eh.charAt(0) == '[') {
                    eh = eh.substring(1, eh.length()-1);
                }
                System.out.println("Expected: " + eh + " : " + ep);
                System.out.println("Actual: " + h + " : " + p);
                if (!eh.equals(h) ||
                        (ep == null || ep.length() == 0) && !p.equals("88") ||
                        (ep != null && ep.length() > 0) && !p.equals(ep)) {
                    throw new Exception("Mismatch");
                }
                cc++;
            }
        }
        if (cc != kdcs.length - 2) {    // 2 illegal settings at the end
            throw new Exception("Not traversed");
        }
    }
 

private void useReleases( ModifiedPomXMLEventReader pom, MavenProject project )
    throws XMLStreamException, MojoExecutionException, ArtifactMetadataRetrievalException
{
    String version = project.getVersion();
    Matcher versionMatcher = matchSnapshotRegex.matcher( version );
    if ( versionMatcher.matches() )
    {
        String releaseVersion = versionMatcher.group( 1 );

        VersionRange versionRange;
        try
        {
            versionRange = VersionRange.createFromVersionSpec( releaseVersion );
        }
        catch ( InvalidVersionSpecificationException e )
        {
            throw new MojoExecutionException( "Invalid version range specification: " + version, e );
        }

        Artifact artifact = artifactFactory.createDependencyArtifact( getProject().getParent().getGroupId(),
                                                                      getProject().getParent().getArtifactId(),
                                                                      versionRange, "pom", null, null );
        if ( !isIncluded( artifact ) )
        {
            return;
        }

        getLog().debug( "Looking for a release of " + toString( project ) );
        // Force releaseVersion version because org.apache.maven.artifact.metadata.MavenMetadataSource does not
        // retrieve release version if provided snapshot version.
        artifact.setVersion( releaseVersion );
        ArtifactVersions versions = getHelper().lookupArtifactVersions( artifact, false );
        if ( !allowRangeMatching ) // standard behaviour
        {
            if ( versions.containsVersion( releaseVersion ) )
            {
                if ( PomHelper.setProjectParentVersion( pom, releaseVersion ) )
                {
                    getLog().info( "Updated " + toString( project ) + " to version " + releaseVersion );
                }
            }
            else if ( failIfNotReplaced )
            {
                throw new NoSuchElementException( "No matching release of " + toString( project )
                    + " found for update." );
            }
        }
        else
        {
            ArtifactVersion finalVersion = null;
            for ( ArtifactVersion proposedVersion : versions.getVersions( false ) )
            {
                if ( proposedVersion.toString().startsWith( releaseVersion ) )
                {
                    getLog().debug( "Found matching version for " + toString( project ) + " to version "
                        + releaseVersion );
                    finalVersion = proposedVersion;
                }
            }

            if ( finalVersion != null )
            {
                if ( PomHelper.setProjectParentVersion( pom, finalVersion.toString() ) )
                {
                    getLog().info( "Updated " + toString( project ) + " to version " + finalVersion.toString() );
                }
            }
            else
            {
                getLog().info( "No matching release of " + toString( project ) + " to update via rangeMatching." );
                if ( failIfNotReplaced )
                {
                    throw new NoSuchElementException( "No matching release of " + toString( project )
                        + " found for update via rangeMatching." );
                }
            }

        }
    }
}
 

public RangeExpression(final Matcher m, final int field) throws ParseException {

            super(field);

            startWeekDay = m.group(1);
            endWeekDay = m.group(2);


            if (field == Calendar.DAY_OF_MONTH) {

                final Matcher startWeekDayMatcher = WEEKDAY.matcher(m.group(1));
                final Matcher endWeekDayMatcher = WEEKDAY.matcher(m.group(2));

                final Matcher startDaysFromLastDayMatcher = DAYS_TO_LAST.matcher(m.group(1));
                final Matcher endDaysFromLastDayMatcher = DAYS_TO_LAST.matcher(m.group(2));

                if (startWeekDayMatcher.matches()) {
                    startWeekdayExpr = new WeekdayExpression(startWeekDayMatcher);

                }

                if (endWeekDayMatcher.matches()) {
                    endWeekdayExpr = new WeekdayExpression(endWeekDayMatcher);
                }

                if (startDaysFromLastDayMatcher.matches()) {
                    startDaysFromLastDayExpr = new DaysFromLastDayExpression(startDaysFromLastDayMatcher);
                }

                if (endDaysFromLastDayMatcher.matches()) {
                    endDaysFromLastDayExpr = new DaysFromLastDayExpression(endDaysFromLastDayMatcher);
                }


                if (startWeekdayExpr != null || endWeekdayExpr != null || startDaysFromLastDayExpr != null
                    || endDaysFromLastDayExpr != null || startWeekDay.equals(LAST_IDENTIFIER) || endWeekDay.equals(LAST_IDENTIFIER)) {

                    isDynamicRangeExpression = true;
                    return;
                }

            }

            //not a dynamic range expression, go ahead to init start and end values without a calendar
            initStartEndValues(null);


        }