public static String getDirectoryName(String path) { if (path != null) { int index = path.lastIndexOf(DIRECTORY_SEPARATOR_CHAR); int index2 = path.lastIndexOf(ALT_DIRECTORY_SEPARATOR_CHAR); if (index2 > index) { index = index2; } if (index != -1) { if (index == path.length() - 1) { if (path.indexOf(VOLUME_SEPARATOR_CHAR) == index - 1) { return null; } else { path = path.substring(0, index); } } else { if (path.indexOf(VOLUME_SEPARATOR_CHAR) == index - 1) { path = path.substring(0, index + 1); } else { path = path.substring(0, index); } } if (path.length() == 2 && path[1] == VOLUME_SEPARATOR_CHAR) { return ""; } } return path; } return null; }
public void StringConstructor() { var s = new String("Tetsts"); Assert.IsTrue("Tetsts".Equals(s)); Assert.IsTrue(s.Equals("Tetsts")); }
public void stringArray() { String[] objects = new String[3]; objects[0] = "test6857"; String[] res = testInstance.stringArray(objects); Assert.AreEqual((String)"test6857", res[1]); }
internal static boolean checkNumberGroupingIsValid( PhoneNumber number, String candidate, PhoneNumberUtil util, NumberGroupingChecker checker) { // TODO: Evaluate how this works for other locales (testing has been limited to NANPA regions) // and optimise if necessary. StringBuilder normalizedCandidate = PhoneNumberUtil.normalizeDigits(candidate, true /* keep non-digits */); String[] formattedNumberGroups = getNationalNumberGroups(util, number, null); if (checker.checkGroups(util, number, normalizedCandidate, formattedNumberGroups)) { return(true); } // If this didn't pass, see if there are any alternate formats, and try them instead. PhoneMetadata alternateFormats = MetadataManager.getAlternateFormatsForCountry(number.getCountryCode()); if (alternateFormats != null) { foreach (NumberFormat alternateFormat in alternateFormats.numberFormats()) { formattedNumberGroups = getNationalNumberGroups(util, number, alternateFormat); if (checker.checkGroups(util, number, normalizedCandidate, formattedNumberGroups)) { return(true); } } } return(false); }
public static void Main(string[] args) { try { var minecraftserver = new MinecraftServer(); if (!GraphicsEnvironment.isHeadless() && ((args.Length <= 0) || !String.instancehelper_equals(args[0], "nogui"))) { ServerGUI.initGui(minecraftserver); } new ThreadServerApplication("Server thread", minecraftserver).start(); } catch (java.lang.Exception exception1) { var local1 = ByteCodeHelper.MapException <java.lang.Exception>(exception1, ByteCodeHelper.MapFlags.None); if (local1 == null) { throw; } java.lang.Exception exception = local1; java.lang.Exception exception2 = exception; logger.log(Level.SEVERE, "Failed to start the minecraft server", exception2); return; } }
internal static boolean containsOnlyValidXChars( PhoneNumber number, String candidate, PhoneNumberUtil util) { // The characters 'x' and 'X' can be (1) a carrier code, in which case they always precede the // national significant number or (2) an extension sign, in which case they always precede the // extension number. We assume a carrier code is more than 1 digit, so the first case has to // have more than 1 consecutive 'x' or 'X', whereas the second case can only have exactly 1 'x' // or 'X'. We ignore the character if it appears as the last character of the string. for (int index = 0; index < candidate.length() - 1; index++) { char charAtIndex = candidate.charAt(index); if (charAtIndex == 'x' || charAtIndex == 'X') { char charAtNextIndex = candidate.charAt(index + 1); if (charAtNextIndex == 'x' || charAtNextIndex == 'X') { // This is the carrier code case, in which the 'X's always precede the national // significant number. index++; if (util.isNumberMatch(number, candidate.substring(index)) != MatchType.NSN_MATCH) { return(false); } // This is the extension sign case, in which the 'x' or 'X' should always precede the // extension number. } else if (!PhoneNumberUtil.normalizeDigitsOnly(candidate.substring(index)).equals( number.getExtension())) { return(false); } } } return(true); }
public static void main(String[] args) { System.out.println(); System.out.println(); var result = new Application().run(args); System.out.println("Done("+result+")"); System.exit(result); }
/** * Helper method to get the national-number part of a number, formatted without any national * prefix, and return it as a set of digit blocks that would be formatted together. */ private static String[] getNationalNumberGroups(PhoneNumberUtil util, PhoneNumber number, NumberFormat formattingPattern) { if (formattingPattern == null) { // This will be in the format +CC-DG;ext=EXT where DG represents groups of digits. String rfc3966Format = util.format(number, PhoneNumberFormat.RFC3966); // We remove the extension part from the formatted string before splitting it into different // groups. int endIndex = rfc3966Format.indexOf(';'); if (endIndex < 0) { endIndex = rfc3966Format.length(); } // The country-code will have a '-' following it. int startIndex = rfc3966Format.indexOf('-') + 1; return(rfc3966Format.substring(startIndex, endIndex).split("-")); } else { // We format the NSN only, and split that according to the separator. String nationalSignificantNumber = util.getNationalSignificantNumber(number); return(util.formatNsnUsingPattern(nationalSignificantNumber, formattingPattern, PhoneNumberFormat.RFC3966).split("-")); } }
LocalInfo(TypeInfo type, String name, int index, Label beginLabel, Label endLabel) { this.type = type; this.name = name; this.index = index; this.beginLabel = beginLabel; this.endLabel = endLabel; }
/** * Extracts the country calling code from the beginning of nationalNumber to * prefixBeforeNationalNumber when they are available, and places the remaining input into * nationalNumber. * * @return true when a valid country calling code can be found. */ private boolean attemptToExtractCountryCallingCode() { if (nationalNumber.length() == 0) { return(false); } StringBuilder numberWithoutCountryCallingCode = new StringBuilder(); int countryCode = phoneUtil.extractCountryCode(nationalNumber, numberWithoutCountryCallingCode); if (countryCode == 0) { return(false); } nationalNumber.setLength(0); nationalNumber.append(numberWithoutCountryCallingCode); String newRegionCode = phoneUtil.getRegionCodeForCountryCode(countryCode); if (PhoneNumberUtil.REGION_CODE_FOR_NON_GEO_ENTITY.equals(newRegionCode)) { currentMetadata = phoneUtil.getMetadataForNonGeographicalRegion(countryCode); } else if (!newRegionCode.equals(defaultCountry)) { currentMetadata = getMetadataForRegion(newRegionCode); } String countryCodeString = Integer.toString(countryCode); prefixBeforeNationalNumber.append(countryCodeString).append(SEPARATOR_BEFORE_NATIONAL_NUMBER); return(true); }
/** * Attempts to find the next subsequence in the searched sequence on or after {@code searchIndex} * that represents a phone number. Returns the next match, null if none was found. * * @param index the search index to start searching at * @return the phone number match found, null if none can be found */ private PhoneNumberMatch find(int index) { Matcher matcher = PATTERN.matcher(text); while ((maxTries > 0) && matcher.find(index)) { int start = matcher.start(); CharSequence candidate = text.subSequence(start, matcher.end()); // Check for extra numbers at the end. // TODO: This is the place to start when trying to support extraction of multiple phone number // from split notations (+41 79 123 45 67 / 68). candidate = trimAfterFirstMatch(PhoneNumberUtil.SECOND_NUMBER_START_PATTERN, candidate); PhoneNumberMatch match = extractMatch(candidate, start); if (match != null) { return(match); } index = start + candidate.length(); maxTries--; } return(null); }
private boolean createFormattingTemplate(NumberFormat format) { String numberPattern = format.getPattern(); // The formatter doesn't format numbers when numberPattern contains "|", e.g. // (20|3)\d{4}. In those cases we quickly return. if (numberPattern.indexOf('|') != -1) { return(false); } // Replace anything in the form of [..] with \d numberPattern = CHARACTER_CLASS_PATTERN.matcher(numberPattern).replaceAll("\\\\d"); // Replace any standalone digit (not the one in d{}) with \d numberPattern = STANDALONE_DIGIT_PATTERN.matcher(numberPattern).replaceAll("\\\\d"); formattingTemplate.setLength(0); String tempTemplate = getFormattingTemplate(numberPattern, format.getFormat()); if (tempTemplate.length() > 0) { formattingTemplate.append(tempTemplate); return(true); } return(false); }
private void appendSubsequentLocalePart(String subsequentLocalePart, StringBuilder fullLocale) { if (subsequentLocalePart.length() > 0) { fullLocale.append('_').append(subsequentLocalePart); } }
/** * Gets the name of the file that contains the mapping data for the {@code countryCallingCode} in * the language specified. * * @param countryCallingCode the country calling code of phone numbers which the data file * contains * @param language two-letter lowercase ISO language codes as defined by ISO 639-1 * @param script four-letter titlecase (the first letter is uppercase and the rest of the letters * are lowercase) ISO script codes as defined in ISO 15924 * @param region two-letter uppercase ISO country codes as defined by ISO 3166-1 * @return the name of the file, or empty string if no such file can be found */ internal String getFileName(int countryCallingCode, String language, String script, String region) { if (language.length() == 0) { return(""); } int index = Arrays.binarySearch(countryCallingCodes, countryCallingCode); if (index < 0) { return(""); } Set <String> setOfLangs = availableLanguages.get(index); if (setOfLangs.size() > 0) { String languageCode = findBestMatchingLanguageCode(setOfLangs, language, script, region); if (languageCode.length() > 0) { StringBuilder fileName = new StringBuilder(); fileName.append(countryCallingCode).append('_').append(languageCode); return(fileName.toString()); } } return(""); }
// Returns true if a new template is created as opposed to reusing the existing template. private boolean maybeCreateNewTemplate() { // When there are multiple available formats, the formatter uses the first format where a // formatting template could be created. Iterator <NumberFormat> it = possibleFormats.iterator(); while (it.hasNext()) { NumberFormat numberFormat = it.next(); String pattern = numberFormat.getPattern(); if (currentFormattingPattern.equals(pattern)) { return(false); } if (createFormattingTemplate(numberFormat)) { currentFormattingPattern = pattern; shouldAddSpaceAfterNationalPrefix = NATIONAL_PREFIX_SEPARATORS_PATTERN.matcher( numberFormat.getNationalPrefixFormattingRule()).find(); // With a new formatting template, the matched position using the old template needs to be // reset. lastMatchPosition = 0; return(true); } else // Remove the current number format from possibleFormats. { it.remove(); } } ableToFormat = false; return(false); }
/** * Attempts to extract a match from a {@code candidate} character sequence. * * @param candidate the candidate text that might contain a phone number * @param offset the offset of {@code candidate} within {@link #text} * @return the match found, null if none can be found */ private PhoneNumberMatch extractMatch(CharSequence candidate, int offset) { // Skip a match that is more likely a publication page reference or a date. if (PUB_PAGES.matcher(candidate).find() || SLASH_SEPARATED_DATES.matcher(candidate).find()) { return(null); } // Skip potential time-stamps. if (TIME_STAMPS.matcher(candidate).find()) { String followingText = text.toString().substring(offset + candidate.length()); if (TIME_STAMPS_SUFFIX.matcher(followingText).lookingAt()) { return(null); } } // Try to come up with a valid match given the entire candidate. String rawString = candidate.toString(); PhoneNumberMatch match = parseAndVerify(rawString, offset); if (match != null) { return(match); } // If that failed, try to find an "inner match" - there might be a phone number within this // candidate. return(extractInnerMatch(rawString, offset)); }
void buildPackageDocumentation(String packageName, PackageDeclarationNode packageDeclaration) { var comment = ParserHelper.decodeDocumentation(context.Text, packageDeclaration.DocumentationOffset, packageDeclaration.DocumentationLength); memberKind = null; node = packageDeclaration; appendDocumentation("N:" + packageName, comment); }
// Returns the national prefix extracted, or an empty string if it is not present. private String removeNationalPrefixFromNationalNumber() { int startOfNationalNumber = 0; if (isNanpaNumberWithNationalPrefix()) { startOfNationalNumber = 1; prefixBeforeNationalNumber.append('1').append(SEPARATOR_BEFORE_NATIONAL_NUMBER); isCompleteNumber = true; } else if (currentMetadata.hasNationalPrefixForParsing()) { Pattern nationalPrefixForParsing = regexCache.getPatternForRegex(currentMetadata.getNationalPrefixForParsing()); Matcher m = nationalPrefixForParsing.matcher(nationalNumber); // Since some national prefix patterns are entirely optional, check that a national prefix // could actually be extracted. if (m.lookingAt() && m.end() > 0) { // When the national prefix is detected, we use international formatting rules instead of // national ones, because national formatting rules could contain local formatting rules // for numbers entered without area code. isCompleteNumber = true; startOfNationalNumber = m.end(); prefixBeforeNationalNumber.append(nationalNumber.substring(0, startOfNationalNumber)); } } String nationalPrefix = nationalNumber.substring(0, startOfNationalNumber); nationalNumber.delete(0, startOfNationalNumber); return(nationalPrefix); }
/** * Returns the description of the geographical area the {@code number} corresponds to. This method * distinguishes the case of an invalid prefix and a prefix for which the name is not available in * the current language. If the description is not available in the current language an empty * string is returned. If no description was found for the provided number, null is returned. * * @param number the phone number to look up * @return the description of the geographical area */ internal String lookup(PhoneNumber number) { int numOfEntries = areaCodeMapStorage.getNumOfEntries(); if (numOfEntries == 0) { return(null); } long phonePrefix = Long.parseLong(number.getCountryCode() + phoneUtil.getNationalSignificantNumber(number)); int currentIndex = numOfEntries - 1; SortedSet <Integer> currentSetOfLengths = areaCodeMapStorage.getPossibleLengths(); while (currentSetOfLengths.size() > 0) { Integer possibleLength = currentSetOfLengths.last(); String phonePrefixStr = String.valueOf(phonePrefix); if (phonePrefixStr.length() > possibleLength) { phonePrefix = Long.parseLong(phonePrefixStr.substring(0, possibleLength)); } currentIndex = binarySearch(0, currentIndex, phonePrefix); if (currentIndex < 0) { return(null); } int currentPrefix = areaCodeMapStorage.getPrefix(currentIndex); if (phonePrefix == currentPrefix) { return(areaCodeMapStorage.getDescription(currentIndex)); } currentSetOfLengths = currentSetOfLengths.headSet(possibleLength); } return(null); }
internal static void fail(BufferN b, String expected, char expectedChar, String got, char gotChar) { if (b is ByteBufferN) { var bb = (ByteBufferN)b; int n = Math.Min(16, bb.limit()); for (int i = 0; i < n; i++) { outt.print(" " + Integer.toHexString(bb.get(i) & 0xff)); } outt.println(); } /*if (b is CharBuffer) { * CharBuffer bb = (CharBuffer)b; * int n = Math.min(16, bb.limit()); * for (int i = 0; i < n; i++) * outt.print(" " + Integer.toHexString(bb.get(i) & 0xffff)); * outt.println(); * }*/ throw new RuntimeException(toString(b) + ": Expected '" + expectedChar + "'=0x" + expected + ", got '" + gotChar + "'=0x" + got); }
/** * Attempts to extract a match from {@code candidate} if the whole candidate does not qualify as a * match. * * @param candidate the candidate text that might contain a phone number * @param offset the current offset of {@code candidate} within {@link #text} * @return the match found, null if none can be found */ private PhoneNumberMatch extractInnerMatch(String candidate, int offset) { // Try removing either the first or last "group" in the number and see if this gives a result. // We consider white space to be a possible indication of the start or end of the phone number. Matcher groupMatcher = GROUP_SEPARATOR.matcher(candidate); if (groupMatcher.find()) { // Try the first group by itself. CharSequence firstGroupOnly = candidate.substring(0, groupMatcher.start()); firstGroupOnly = trimAfterFirstMatch(PhoneNumberUtil.UNWANTED_END_CHAR_PATTERN, firstGroupOnly); PhoneNumberMatch match = parseAndVerify(firstGroupOnly.toString(), offset); if (match != null) { return(match); } maxTries--; int withoutFirstGroupStart = groupMatcher.end(); // Try the rest of the candidate without the first group. CharSequence withoutFirstGroup = candidate.substring(withoutFirstGroupStart); withoutFirstGroup = trimAfterFirstMatch(PhoneNumberUtil.UNWANTED_END_CHAR_PATTERN, withoutFirstGroup); match = parseAndVerify(withoutFirstGroup.toString(), offset + withoutFirstGroupStart); if (match != null) { return(match); } maxTries--; if (maxTries > 0) { int lastGroupStart = withoutFirstGroupStart; while (groupMatcher.find()) { // Find the last group. lastGroupStart = groupMatcher.start(); } CharSequence withoutLastGroup = candidate.substring(0, lastGroupStart); withoutLastGroup = trimAfterFirstMatch(PhoneNumberUtil.UNWANTED_END_CHAR_PATTERN, withoutLastGroup); if (withoutLastGroup.equals(firstGroupOnly)) { // If there are only two groups, then the group "without the last group" is the same as // the first group. In these cases, we don't want to re-check the number group, so we exit // already. return(null); } match = parseAndVerify(withoutLastGroup.toString(), offset); if (match != null) { return(match); } maxTries--; } } return(null); }
private StringBuilder constructFullLocale(String language, String script, String region) { StringBuilder fullLocale = new StringBuilder(language); appendSubsequentLocalePart(script, fullLocale); appendSubsequentLocalePart(region, fullLocale); return(fullLocale); }
public NumberFormat addLeadingDigitsPattern(String value) { if (value == null) { throw new NullPointerException(); } leadingDigitsPattern_.add(value); return this; }
public CodeError(String filename, int id, int level, String message, int line, int column) { this.Filename = filename; this.Id = id; this.Level = level; this.Message = message; this.Line = line; this.Column = column; }
/* public void writeFloat(float v) { writeInt(Float.floatToIntBits(v)); } public void writeDouble(double v) { writeLong(Double.doubleToLongBits(v)); } */ public void writeBytes(String s) { int len = s.length(); for (int i = 0 ; i < len ; i++) { @out.write((byte)s.charAt(i)); } incCount(len); }
public static String StrongJ2CpString(JNIEnv env, JniLocalHandle obj) { if (JniHandle.IsNull(obj)) { return(null); } return(String.CreateProxy(env, obj)); }
public NumberFormat addLeadingDigitsPattern(String value) { if (value == null) { throw new NullPointerException(); } leadingDigitsPattern_.add(value); return(this); }
public static UnicodeProp forPOSIXName(String propName) { propName = posix.get(propName.toUpperCase()); if (propName == null) { return(null); } return(valueOf(propName)); }
static PhoneNumberMatcher() { /* Builds the MATCHING_BRACKETS and PATTERN regular expressions. The building blocks below exist * to make the pattern more easily understood. */ String openingParens = "(\\[\uFF08\uFF3B"; String closingParens = ")\\]\uFF09\uFF3D"; String nonParens = "[^" + openingParens + closingParens + "]"; /* Limit on the number of pairs of brackets in a phone number. */ String bracketPairLimit = limit(0, 3); /* * An opening bracket at the beginning may not be closed, but subsequent ones should be. It's * also possible that the leading bracket was dropped, so we shouldn't be surprised if we see a * closing bracket first. We limit the sets of brackets in a phone number to four. */ MATCHING_BRACKETS = Pattern.compile( "(?:[" + openingParens + "])?" + "(?:" + nonParens + "+" + "[" + closingParens + "])?" + nonParens + "+" + "(?:[" + openingParens + "]" + nonParens + "+[" + closingParens + "])" + bracketPairLimit + nonParens + "*"); /* Limit on the number of leading (plus) characters. */ String leadLimit = limit(0, 2); /* Limit on the number of consecutive punctuation characters. */ String punctuationLimit = limit(0, 4); /* The maximum number of digits allowed in a digit-separated block. As we allow all digits in a * single block, set high enough to accommodate the entire national number and the international * country code. */ int digitBlockLimit = PhoneNumberUtil.MAX_LENGTH_FOR_NSN + PhoneNumberUtil.MAX_LENGTH_COUNTRY_CODE; /* Limit on the number of blocks separated by punctuation. Uses digitBlockLimit since some * formats use spaces to separate each digit. */ String blockLimit = limit(0, digitBlockLimit); /* A punctuation sequence allowing white space. */ String punctuation = "[" + PhoneNumberUtil.VALID_PUNCTUATION + "]" + punctuationLimit; /* A digits block without punctuation. */ String digitSequence = "\\p{Nd}" + limit(1, digitBlockLimit); String leadClassChars = openingParens + PhoneNumberUtil.PLUS_CHARS; String leadClass = "[" + leadClassChars + "]"; LEAD_CLASS = Pattern.compile(leadClass); GROUP_SEPARATOR = Pattern.compile("\\p{Z}" + "[^" + leadClassChars + "\\p{Nd}]*"); /* Phone number pattern allowing optional punctuation. */ PATTERN = Pattern.compile( "(?:" + leadClass + punctuation + ")" + leadLimit + digitSequence + "(?:" + punctuation + digitSequence + ")" + blockLimit + "(?:" + PhoneNumberUtil.EXTN_PATTERNS_FOR_MATCHING + ")?", PhoneNumberUtil.REGEX_FLAGS); }
public PhoneNumber setRawInput(String value) { if (value == null) { throw new NullPointerException(); } _hasRawInput = true; rawInput_ = value; return(this); }
/* * public void writeFloat(float v) { * writeInt(Float.floatToIntBits(v)); * } * public void writeDouble(double v) { * writeLong(Double.doubleToLongBits(v)); * } */ public void writeBytes(String s) { int len = s.length(); for (int i = 0; i < len; i++) { @out.write((byte)s.charAt(i)); } incCount(len); }
public static bool hasNature(IProject project, String natureId) { if (project.exists() && project.isOpen()) { try { return project.hasNature(natureId); } catch (CoreException e) { Environment.logException(e); } } return false; }
public String getMessage(Locale locale, String key, params Object[] args) { var rb = getResourceBundle(locale); if (rb != null) { try { return MessageFormat.format(rb.getString(key), args); } catch { } } return key; }
public PhoneNumber setPreferredDomesticCarrierCode(String value) { if (value == null) { throw new NullPointerException(); } _hasPreferredDomesticCarrierCode = true; preferredDomesticCarrierCode_ = value; return(this); }
public PhoneNumber setExtension(String value) { if (value == null) { throw new NullPointerException(); } _hasExtension = true; extension_ = value; return(this); }
/** * Trims away any characters after the first match of {@code pattern} in {@code candidate}, * returning the trimmed version. */ private static CharSequence trimAfterFirstMatch(Pattern pattern, CharSequence candidate) { Matcher trailingCharsMatcher = pattern.matcher(candidate); if (trailingCharsMatcher.find()) { candidate = candidate.subSequence(0, trailingCharsMatcher.start()); } return(candidate); }
internal static string GetString(this Object target, string columnName) { var getString = target .getClass() .getMethods() .Single(x => x.getName() == Constants.Methods.GetString && x.GetSignature() == Constants.MethodSignatures.String_String); java.lang.String result = (java.lang.String)getString.invoke(target, new[] { JNIEnv.ThreadEnv.NewString(columnName) }); return(result); }
public Pattern getPatternForRegex(String regex) { Pattern pattern = cache.get(regex); if (pattern == null) { pattern = Pattern.compile(regex); cache.put(regex, pattern); } return(pattern); }
public static sbyte[] ToByteArray(string e, string charset) { sbyte[] u = null; try { u = new java.lang.String(e).getBytes(charset); } catch { } return(u); }
: super(typeSystem, name) { this.typeSystem = typeSystem; this.descriptor = "L" + name + ";"; numericTypeKind = TypeKinds[name]; if (numericTypeKind == null) { numericTypeKind = NumericTypeKind.None; } new ClassReader(bytes).accept(new OutlineVisitor(this), ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES); this.genericsScope = new Scope<String, TypeInfo>(); this.genericsScope.enterScope(); }
/** * Creates a new match. * * @param start the start index into the target text * @param rawString the matched substring of the target text * @param number the matched phone number */ internal PhoneNumberMatch(int start, String rawString, PhoneNumber number) { if (start < 0) { throw new IllegalArgumentException("Start index must be >= 0."); } if (rawString == null || number == null) { throw new NullPointerException(); } this._start = start; this._rawString = rawString; this._number = number; }
public static MemberInfo getInfo(MethodInfo getAccessor, MethodInfo setAccessor, String name) { var result = (getAccessor ?? setAccessor).getUserData(typeof(PropertyMemberInfo)); if (result == null) { result = new PropertyMemberInfo(getAccessor, setAccessor, name); if (getAccessor != null) { getAccessor.addUserData(result); } if (setAccessor != null) { setAccessor.addUserData(result); } } return result; }
public static String getFileName(String path) { if (path != null) { int index = path.lastIndexOf(DIRECTORY_SEPARATOR_CHAR); if (index == -1) { index = path.lastIndexOf(ALT_DIRECTORY_SEPARATOR_CHAR); } if (index == -1) { return path; } return path.substring(index + 1); } return null; }
public static String quoteReplacement(String s) { if ((s.indexOf('\\') == -1) && (s.indexOf('$') == -1)) return s; StringBuilder sb = new StringBuilder(); for (int i=0; i<s.length(); i++) { char c = s.charAt(i); if (c == '\\' || c == '$') { sb.append('\\'); } sb.append(c); } return sb.toString(); }
public void testArrays() { var c = new Container(); var obj = new Object(); var str = "abc"; var arr = new String[] { "a", "b", "c" }; c.addUserData(obj); c.addUserData(str); c.addUserData(arr); Assert.assertEquals(obj, c.getUserData(typeof(Object))); Assert.assertEquals("abc", c.getUserData(typeof(String))); Assert.assertEquals((Object)arr, c.getUserData(typeof(String[]))); }
public void addTypeToTypeRelation(String referencingType, String referencedType) { var referencing = referencingTypes.get(referencedType); if (referencing == null) { referencing = new HashSet<String>(); referencingTypes[referencedType] = referencing; } referencing.add(referencingType); var referenced = referencedTypes.get(referencingType); if (referenced == null) { referenced = new HashSet<String>(); referencedTypes[referencingType] = referenced; } referenced.add(referencedType); }
public void addFileToTypeRelation(String fileName, String typeName) { var contents = fileContents.get(fileName); if (contents == null) { contents = new HashSet<String>(); fileContents[fileName] = contents; } contents.add(typeName); var locations = typeLocations.get(typeName); if (locations == null) { locations = new HashSet<String>(); typeLocations[typeName] = locations; } locations.add(fileName); }
public static long decodeHexadecimalLong(String value) { long result = 0; var ndigits = 0; for (var i = 2; i < value.length(); i++) { var digit = ParserHelper.scanHexDigit(value[i]); if (ndigits == 0 && digit == 0) { continue; } result <<= 4; result |= digit; if (++ndigits == 17) { throw new NumberFormatException(value); } } return result; }
public static String getFileNameWithoutExtension(String path) { if (path != null) { int index = path.lastIndexOf(DIRECTORY_SEPARATOR_CHAR); if (index == -1) { index = path.lastIndexOf(ALT_DIRECTORY_SEPARATOR_CHAR); } if (index != -1) { path = path.substring(index + 1); } index = path.lastIndexOf('.'); if (index == -1) { return path; } return path.substring(0, index); } return null; }
public Library(String[] classPath, Library parent) { this.classPath = new ArrayList<String>(); foreach(string path in classPath) this.classPath.add(path); this.fileClasses = new HashMap<String, File>(128); int capacity = (parent == null) ? 0x5000 : 128; this.jarClasses = new HashMap<String, ZipFile>(capacity); this.classNames = new ArrayList<String>(capacity); this.typeInfos = new HashMap<String, TypeInfo>(); this.constructedGenericTypes = new HashMap<TypeInfo, ArrayList<TypeInfo>>(); this.constructedGenericMethods = new HashMap<MethodInfo, ArrayList<MethodInfo>>(); this.parent = parent; if (parent == null) { initializeBootClasses(); } foreach (var path in classPath) { explorePath(path); } }
public bool load(IFile file) { if (file.exists()) { try { var libraries = new ArrayList<ProjectLibrary>(); var preprocessorSymbols = new HashSet<String>(); var outputPath = "bin"; var document = XmlHelper.load(new InputStreamReader(file.getContents())); var nodeList = document.getElementsByTagName("library"); int length = nodeList.getLength(); for (int i = 0; i < length; i++) { var e = (Element)nodeList.item(i); var lib = new ProjectLibrary(e.getAttribute("name")); var enabled = e.getAttribute("enabled"); lib.setEnabled(enabled.length() == 0 || !enabled.equals("false")); libraries.add(lib); } nodeList = document.getElementsByTagName("preprocessorSymbols"); if (nodeList.getLength() == 1) { foreach (var s in nodeList.item(0).getTextContent().split(";")) { preprocessorSymbols.add(s.trim()); } } nodeList = document.getElementsByTagName("outputPath"); if (nodeList.getLength() == 1) { outputPath = nodeList.item(0).getTextContent(); } this.Libraries = libraries; this.PreprocessorSymbols = preprocessorSymbols; this.OutputPath = outputPath; return true; } catch (Exception e) { Environment.logException(e); } } this.Libraries = Query.empty<ProjectLibrary>(); this.PreprocessorSymbols = Query.empty<String>(); return false; }
public String group(String name) { if (name == null) throw new NullReferenceException("Null group name"); if (first < 0) throw new InvalidOperationException("No match found"); if (!parentPattern.namedGroups().containsKey(name)) throw new IllegalArgumentException("No group with name <" + name + ">"); int group = parentPattern.namedGroups().get(name); if ((groups[group*2] == -1) || (groups[group*2+1] == -1)) return null; return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString(); }
public ProjectLibrary(String path) { this.Path = path; this.Enabled = true; }
public void addGenericConstraint(String name, TypeInfo bound) { checkCreated(); foreach (var arg in genericArguments) { if (arg.FullName.equals(name)) { ((GenericParameterType)arg).genericParameterBounds.add(bound); return; } } throw new IllegalStateException("Generic parameter " + name+ " not found"); }
public TypeInfo addGenericArgument(String name) { checkCreated(); var type = new GenericParameterType(this.Library, name, null); genericArguments.add(type); return type; }
public String replaceAll(String replacement) { reset(); boolean result = find(); if (result) { StringBuffer sb = new StringBuffer(); do { appendReplacement(sb, replacement); result = find(); } while (result); appendTail(sb); return sb.toString(); } return text.toString(); }
public String replaceFirst(String replacement) { if (replacement == null) throw new NullPointerException("replacement"); reset(); if (!find()) return text.toString(); StringBuffer sb = new StringBuffer(); appendReplacement(sb, replacement); appendTail(sb); return sb.toString(); }
public void setSourceFile(String sourceFile) { this.sourceFile = sourceFile; }
public Matcher appendReplacement(StringBuffer sb, String replacement) { // If no match, return error if (first < 0) throw new InvalidOperationException("No match available"); // Process substitution string to replace group references with groups int cursor = 0; StringBuilder result = new StringBuilder(); while (cursor < replacement.length()) { char nextChar = replacement.charAt(cursor); if (nextChar == '\\') { cursor++; nextChar = replacement.charAt(cursor); result.append(nextChar); cursor++; } else if (nextChar == '$') { // Skip past $ cursor++; // A StringIndexOutOfBoundsException is thrown if // this "$" is the last character in replacement // string in current implementation, a IAE might be // more appropriate. nextChar = replacement.charAt(cursor); int refNum = -1; if (nextChar == '{') { cursor++; StringBuilder gsb = new StringBuilder(); while (cursor < replacement.length()) { nextChar = replacement.charAt(cursor); if (ASCII.isLower(nextChar) || ASCII.isUpper(nextChar) || ASCII.isDigit(nextChar)) { gsb.append(nextChar); cursor++; } else { break; } } if (gsb.length() == 0) throw new IllegalArgumentException( "named capturing group has 0 length name"); if (nextChar != '}') throw new IllegalArgumentException( "named capturing group is missing trailing '}'"); String gname = gsb.toString(); if (ASCII.isDigit(gname.charAt(0))) throw new IllegalArgumentException( "capturing group name {" + gname + "} starts with digit character"); if (!parentPattern.namedGroups().containsKey(gname)) throw new IllegalArgumentException( "No group with name {" + gname + "}"); refNum = parentPattern.namedGroups().get(gname); cursor++; } else { // The first number is always a group refNum = (int)nextChar - '0'; if ((refNum < 0)||(refNum > 9)) throw new IllegalArgumentException( "Illegal group reference"); cursor++; // Capture the largest legal group string boolean done = false; while (!done) { if (cursor >= replacement.length()) { break; } int nextDigit = replacement.charAt(cursor) - '0'; if ((nextDigit < 0)||(nextDigit > 9)) { // not a number break; } int newRefNum = (refNum * 10) + nextDigit; if (groupCount() < newRefNum) { done = true; } else { refNum = newRefNum; cursor++; } } } // Append group if (start(refNum) != -1 && end(refNum) != -1) result.append(text, start(refNum), end(refNum)); } else { result.append(nextChar); cursor++; } } // Append the intervening text sb.append(text, lastAppendPosition, first); // Append the match substitution sb.append(result); lastAppendPosition = last; return this; }
public void setSourceDebugExtension(String sourceDebugExtension) { this.sourceDebugExtension = sourceDebugExtension; }