/** * 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(""); }
public String toString() { StringBuilder outputString = new StringBuilder(); outputString.append("Country Code: ").append(countryCode_); outputString.append(" National Number: ").append(nationalNumber_); if (hasItalianLeadingZero() && isItalianLeadingZero()) { outputString.append(" Leading Zero: true"); } if (hasExtension()) { outputString.append(" Extension: ").append(extension_); } if (hasCountryCodeSource()) { outputString.append(" Country Code Source: ").append(Enum.GetName(typeof(CountryCodeSource), countryCodeSource_)); } if (hasPreferredDomesticCarrierCode()) { outputString.append(" Preferred Domestic Carrier Code: "). append(preferredDomesticCarrierCode_); } return(outputString.toString()); }
private void appendSubsequentLocalePart(String subsequentLocalePart, StringBuilder fullLocale) { if (subsequentLocalePart.length() > 0) { fullLocale.append('_').append(subsequentLocalePart); } }
/** * 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); }
public override void sendValue(object obj, DataOutputStream dos) { if (obj is object[]) { object[] objArray = (object[]) obj; if (objArray.Length > (int) byte.MaxValue) { string str = new StringBuilder().append("Cannot write ").append(obj).append(" as ").append(this.__\u003C\u003Ename).append(". Arrays have a max length of 255 values").toString(); Throwable.__\u003CsuppressFillInStackTrace\u003E(); throw new IOException(str); } else { dos.writeByte(objArray.Length); for (int index = 0; index < objArray.Length; ++index) this.elementType.sendValue(objArray[index], dos); } } else { string str = new StringBuilder().append("Cannot write ").append(obj).append(" as ").append(this.__\u003C\u003Ename).toString(); Throwable.__\u003CsuppressFillInStackTrace\u003E(); throw new IOException(str); } }
public MessageBox(View view, string message) { View v = view; if (v == null) { v = ApplicationActivity.MainView; } bool err = (v == null); if (!err) { err = (message == null); } if (err) { ConsoleMessage c = new ConsoleMessage("ERROR in MessageBox: MainView is null", "ERROR", 0, ConsoleMessage.MessageLevel.ERROR); return; } java.lang.StringBuilder sb = new java.lang.StringBuilder(message); Toast.makeText(view.getContext(), sb, Toast.LENGTH_SHORT).show(); }
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 string test(string s1, string s2) { SB sb = new SB(s1); sb.append(s2); return(sb.toString()); }
private StringBuilder constructFullLocale(String language, String script, String region) { StringBuilder fullLocale = new StringBuilder(language); appendSubsequentLocalePart(script, fullLocale); appendSubsequentLocalePart(region, fullLocale); return(fullLocale); }
private string compactString([In] string obj0) { string str = new StringBuilder().append("[").append(String.instancehelper_substring(obj0, this.fPrefix, String.instancehelper_length(obj0) - this.fSuffix + 1)).append("]").toString(); if (this.fPrefix > 0) str = new StringBuilder().append(this.computeCommonPrefix()).append(str).toString(); if (this.fSuffix > 0) str = new StringBuilder().append(str).append(this.computeCommonSuffix()).toString(); return str; }
public static void setTeam(int team) { StringBuilder stringBuilder = new StringBuilder().append("10.").append(team / 100).append("."); int num1 = team; int num2 = 100; int num3 = -1; int num4 = num2 != num3 ? num1 % num2 : 0; Robot.setHost(stringBuilder.append(num4).append(".2").toString()); }
public override string getSaveValue() { string str = ""; int[] numArray = this.getValue(); for (int index = 0; index < numArray.Length; ++index) { if (index > 0) str = new StringBuilder().append(str).append(this.valueSplit).toString(); str = new StringBuilder().append(str).append(numArray[index]).toString(); } return str; }
public override void sendValue([In] object obj0, [In] DataOutputStream obj1) { if (obj0 is Double) { obj1.writeDouble(((Double) obj0).doubleValue()); } else { string str = new StringBuilder().append("Cannot write ").append(obj0).append(" as ").append(this.__\u003C\u003Ename).toString(); Throwable.__\u003CsuppressFillInStackTrace\u003E(); throw new IOException(str); } }
private string join(Iterable<String> items, int limit) { StringBuilder sb = new StringBuilder(); int count = 0; foreach (string item in items) { if (count > 0) sb.append(", "); sb.append(item); if (limit > 0 && count == limit) break; count++; } return sb.toString(); }
public void HeavyCall() { var sb = new StringBuilder(); DateTime start = DateTime.Now; for (int i = 0; i < 1000000; i++) { sb.append('a'); } DateTime end = DateTime.Now; Console.WriteLine(end - start); }
/// <summary>Returns a string containing the tokens joined by delimiters.</summary> /// <remarks>Returns a string containing the tokens joined by delimiters.</remarks> /// <param name="tokens"> /// an array objects to be joined. Strings will be formed from /// the objects by calling object.toString(). /// </param> public static string join (CharSequence delimiter, Iterable<CharSequence> tokens) { StringBuilder sb = new StringBuilder (); bool firstTime = true; foreach (object token in Sharpen.IterableProxy.Create(tokens)) { if (firstTime) { firstTime = false; } else { sb.append (delimiter); } sb.append (token); } return sb.ToString (); }
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(); }
private String findBestMatchingLanguageCode( Set <String> setOfLangs, String language, String script, String region) { StringBuilder fullLocale = constructFullLocale(language, script, region); String fullLocaleStr = fullLocale.toString(); String normalizedLocale = LOCALE_NORMALIZATION_MAP.get(fullLocaleStr); if (normalizedLocale != null) { if (setOfLangs.contains(normalizedLocale)) { return(normalizedLocale); } } if (setOfLangs.contains(fullLocaleStr)) { return(fullLocaleStr); } if (onlyOneOfScriptOrRegionIsEmpty(script, region)) { if (setOfLangs.contains(language)) { return(language); } } else if (script.length() > 0 && region.length() > 0) { StringBuilder langWithScript = new StringBuilder(language).append('_').append(script); String langWithScriptStr = langWithScript.toString(); if (setOfLangs.contains(langWithScriptStr)) { return(langWithScriptStr); } StringBuilder langWithRegion = new StringBuilder(language).append('_').append(region); String langWithRegionStr = langWithRegion.toString(); if (setOfLangs.contains(langWithRegionStr)) { return(langWithRegionStr); } if (setOfLangs.contains(language)) { return(language); } } return(""); }
public override string ToString() { java.lang.StringBuilder builder = new java.lang.StringBuilder(GetClassName()); builder.append(": ").append(Message); if (innerException != null) { builder.append(" ---> ").append(innerException.ToString()) .append(Environment.NewLine).append(Local.GetText(" --- End of inner exception stack trace ---")); } if (StackTrace != null) { builder.append(Environment.NewLine).append(StackTrace); } return(builder.ToString()); }
public String toString() { StringBuilder sb = new StringBuilder(); sb.append("java.util.regex.Matcher"); sb.append("[pattern=" + pattern()); sb.append(" region="); sb.append(regionStart() + "," + regionEnd()); sb.append(" lastmatch="); if ((first >= 0) && (group() != null)) { sb.append(group()); } sb.append("]"); return(sb.toString()); }
public override string format(LogRecord logrecord) { var stringbuilder = new StringBuilder(); stringbuilder.append(dateFormat.format(Long.valueOf(logrecord.getMillis()))); Level level = logrecord.getLevel(); if (level == Level.FINEST) { stringbuilder.append(" [FINEST] "); } else if (level == Level.FINER) { stringbuilder.append(" [FINER] "); } else if (level == Level.FINE) { stringbuilder.append(" [FINE] "); } else if (level == Level.INFO) { stringbuilder.append(" [INFO] "); } else if (level == Level.WARNING) { stringbuilder.append(" [WARNING] "); } else if (level == Level.SEVERE) { stringbuilder.append(" [SEVERE] "); } else if (level == Level.SEVERE) { stringbuilder.append( (new StringBuilder()).append(" [").append(level.getLocalizedName()).append("] ").toString()); } stringbuilder.append(logrecord.getMessage()); stringbuilder.append('\n'); var throwable = logrecord.getThrown() as Throwable; if (throwable != null) { var stringwriter = new StringWriter(); throwable.printStackTrace(new PrintWriter(stringwriter)); stringbuilder.append(stringwriter.toString()); } Debug.WriteLine(stringbuilder.toString()); return stringbuilder.toString(); }
internal static boolean isNationalPrefixPresentIfRequired(PhoneNumber number, PhoneNumberUtil util) { // First, check how we deduced the country code. If it was written in international format, then // the national prefix is not required. if (number.getCountryCodeSource() != CountryCodeSource.FROM_DEFAULT_COUNTRY) { return(true); } String phoneNumberRegion = util.getRegionCodeForCountryCode(number.getCountryCode()); PhoneMetadata metadata = util.getMetadataForRegion(phoneNumberRegion); if (metadata == null) { return(true); } // Check if a national prefix should be present when formatting this number. String nationalNumber = util.getNationalSignificantNumber(number); NumberFormat formatRule = util.chooseFormattingPatternForNumber(metadata.numberFormats(), nationalNumber); // To do this, we check that a national prefix formatting rule was present and that it wasn't // just the first-group symbol ($1) with punctuation. if ((formatRule != null) && formatRule.getNationalPrefixFormattingRule().length() > 0) { if (formatRule.isNationalPrefixOptionalWhenFormatting()) { // The national-prefix is optional in these cases, so we don't need to check if it was // present. return(true); } if (PhoneNumberUtil.formattingRuleHasFirstGroupOnly( formatRule.getNationalPrefixFormattingRule())) { // National Prefix not needed for this number. return(true); } // Normalize the remainder. String rawInputCopy = PhoneNumberUtil.normalizeDigitsOnly(number.getRawInput()); StringBuilder rawInput = new StringBuilder(rawInputCopy); // Check if we found a national prefix and/or carrier code at the start of the raw input, and // return the result. return(util.maybeStripNationalPrefixAndCarrierCode(rawInput, metadata, null)); } return(true); }
/** * Returns a string representing the data in this class. The string contains one line for each * country calling code. The country calling code is followed by a '|' and then a list of * comma-separated languages sorted in ascending order. */ public String toString() { StringBuilder output = new StringBuilder(); for (int i = 0; i < numOfEntries; i++) { output.append(countryCallingCodes[i]); output.append('|'); SortedSet <String> sortedSetOfLangs = new TreeSet <String>(availableLanguages.get(i)); foreach (String lang in sortedSetOfLangs) { output.append(lang); output.append(','); } output.append('\n'); } return(output.toString()); }
internal static boolean allNumberGroupsRemainGrouped(PhoneNumberUtil util, PhoneNumber number, StringBuilder normalizedCandidate, String[] formattedNumberGroups) { int fromIndex = 0; // Check each group of consecutive digits are not broken into separate groupings in the // {@code normalizedCandidate} string. for (int i = 0; i < formattedNumberGroups.length(); i++) { // Fails if the substring of {@code normalizedCandidate} starting from {@code fromIndex} // doesn't contain the consecutive digits in formattedNumberGroups[i]. fromIndex = normalizedCandidate.indexOf(formattedNumberGroups[i], fromIndex); if (fromIndex < 0) { return(false); } // Moves {@code fromIndex} forward. fromIndex += formattedNumberGroups[i].length(); if (i == 0 && fromIndex < normalizedCandidate.length()) { // We are at the position right after the NDC. We get the region used for formatting // information based on the country code in the phone number, rather than the number itself, // as we do not need to distinguish between different countries with the same country // calling code and this is faster. String region = util.getRegionCodeForCountryCode(number.getCountryCode()); if (util.getNddPrefixForRegion(region, true) != null && Character.isDigit(normalizedCandidate.charAt(fromIndex))) { // This means there is no formatting symbol after the NDC. In this case, we only // accept the number if there is no formatting symbol at all in the number, except // for extensions. This is only important for countries with national prefixes. String nationalSignificantNumber = util.getNationalSignificantNumber(number); return(normalizedCandidate.substring(fromIndex - formattedNumberGroups[i].length()) .startsWith(nationalSignificantNumber)); } } } // The check here makes sure that we haven't mistakenly already used the extension to // match the last group of the subscriber number. Note the extension cannot have // formatting in-between digits. return(normalizedCandidate.substring(fromIndex).contains(number.getExtension())); }
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()); }
protected internal NamedDataType(string name, Class defaultWidget, params DataType[] parents) : base(name, defaultWidget, parents) { NamedDataType namedDataType = this; if (name == null) { string str = "Name can not be null"; Throwable.__\u003CsuppressFillInStackTrace\u003E(); throw new IllegalArgumentException(str); } else if (NamedDataType.map.containsKey((object) name)) { string str = new StringBuilder().append("Given name \"").append(name).append("\" has already been claimed").toString(); Throwable.__\u003CsuppressFillInStackTrace\u003E(); throw new IllegalArgumentException(str); } else NamedDataType.map.put((object) name, (object) this); }
protected internal virtual void printFailures(Result result) { List failures = result.getFailures(); if (failures.size() == 0) return; if (failures.size() == 1) this.getWriter().println(new StringBuilder().append("There was ").append(failures.size()).append(" failure:").toString()); else this.getWriter().println(new StringBuilder().append("There were ").append(failures.size()).append(" failures:").toString()); int num1 = 1; Iterator iterator = failures.iterator(); while (iterator.hasNext()) { Failure each = (Failure) iterator.next(); StringBuilder stringBuilder = new StringBuilder().append(""); int num2 = num1; ++num1; string prefix = stringBuilder.append(num2).toString(); this.printFailure(each, prefix); } }
internal static boolean allNumberGroupsAreExactlyPresent(PhoneNumberUtil util, PhoneNumber number, StringBuilder normalizedCandidate, String[] formattedNumberGroups) { String[] candidateGroups = PhoneNumberUtil.NON_DIGITS_PATTERN.split(normalizedCandidate.toString()); // Set this to the last group, skipping it if the number has an extension. int candidateNumberGroupIndex = number.hasExtension() ? candidateGroups.length() - 2 : candidateGroups.length() - 1; // First we check if the national significant number is formatted as a block. // We use contains and not equals, since the national significant number may be present with // a prefix such as a national number prefix, or the country code itself. if (candidateGroups.length() == 1 || candidateGroups[candidateNumberGroupIndex].contains( util.getNationalSignificantNumber(number))) { return(true); } // Starting from the end, go through in reverse, excluding the first group, and check the // candidate and number groups are the same. for (int formattedNumberGroupIndex = (formattedNumberGroups.length() - 1); formattedNumberGroupIndex > 0 && candidateNumberGroupIndex >= 0; formattedNumberGroupIndex--, candidateNumberGroupIndex--) { if (!candidateGroups[candidateNumberGroupIndex].equals( formattedNumberGroups[formattedNumberGroupIndex])) { return(false); } } // Now check the first group. There may be a national prefix at the start, so we only check // that the candidate group ends with the formatted number group. return(candidateNumberGroupIndex >= 0 && candidateGroups[candidateNumberGroupIndex].endsWith(formattedNumberGroups[0])); }
public static void failSame(string message) { string str = ""; if (message != null) str = new StringBuilder().append(message).append(" ").toString(); Assert.fail(new StringBuilder().append(str).append("expected not same").toString()); }
public static void failNotSame(string message, object expected, object actual) { string str = ""; if (message != null) str = new StringBuilder().append(message).append(" ").toString(); Assert.fail(new StringBuilder().append(str).append("expected same:<").append(expected).append("> was not:<").append(actual).append(">").toString()); }
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 static DataType getType(object value) { if (value == null) { string str = "Can not be given null value"; Throwable.__\u003CsuppressFillInStackTrace\u003E(); throw new IllegalArgumentException(str); } else if (value is ITable) { ITable table = (ITable) value; if (!table.containsKey("~TYPE~")) return DataType.__\u003C\u003ETABLE; return (DataType) NamedDataType.get(table.getString("~TYPE~")); } else { if (value is Double) return DataType.__\u003C\u003ENUMBER; if (value is Boolean) return DataType.__\u003C\u003EBOOLEAN; if (value is string) return DataType.__\u003C\u003ESTRING; string str = new StringBuilder().append("Can not get type for class:").append(Object.instancehelper_getClass(value).getName()).toString(); Throwable.__\u003CsuppressFillInStackTrace\u003E(); throw new IllegalArgumentException(str); } }
/** * Returns true if the groups of digits found in our candidate phone number match our * expectations. * * @param number the original number we found when parsing * @param normalizedCandidate the candidate number, normalized to only contain ASCII digits, * but with non-digits (spaces etc) retained * @param expectedNumberGroups the groups of digits that we would expect to see if we * formatted this number */ internal boolean checkGroups(PhoneNumberUtil util, PhoneNumber number, StringBuilder normalizedCandidate, String[] expectedNumberGroups) { return(checkGroupsFunk(util, number, normalizedCandidate, expectedNumberGroups)); }
public static string format(string message, object expected, object actual) { string str = ""; if (message != null) str = new StringBuilder().append(message).append(" ").toString(); return new StringBuilder().append(str).append("expected:<").append(expected).append("> but was:<").append(actual).append(">").toString(); }
private int readUTFChar(StringBuilder sbuf, long utflen) { int b1, b2, b3; b1 = readByte() & 0xFF; switch (b1 >> 4) { case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: // 1 byte format: 0xxxxxxx sbuf.append((char) b1); return 1; case 12: case 13: // 2 byte format: 110xxxxx 10xxxxxx if (utflen < 2) { throw new Exception(); } b2 = readByte(); if ((b2 & 0xC0) != 0x80) { throw new Exception(); } sbuf.append((char) (((b1 & 0x1F) << 6) | ((b2 & 0x3F) << 0))); return 2; case 14: // 3 byte format: 1110xxxx 10xxxxxx 10xxxxxx if (utflen < 3) { if (utflen == 2) { readByte(); // consume remaining byte } throw new Exception(); } b2 = readByte(); b3 = readByte(); if ((b2 & 0xC0) != 0x80 || (b3 & 0xC0) != 0x80) { throw new Exception(); } sbuf.append((char) (((b1 & 0x0F) << 12) | ((b2 & 0x3F) << 6) | ((b3 & 0x3F) << 0))); return 3; default: // 10xx xxxx, 1111 xxxx throw new Exception(); } }
public void save(IFile file) { try { var document = XmlHelper.load(new StringReader(EMPTY_DOC)); var libs = (Element)document.getElementsByTagName("libraries").item(0); foreach (var lib in this.Libraries) { var e = document.createElement("library"); libs.appendChild(e); e.setAttribute("name", lib.Path); if (!lib.Enabled) { e.setAttribute("enabled", "false"); } } if (this.PreprocessorSymbols.any()) { var sb = new StringBuilder(); var first = true; foreach (String s in this.PreprocessorSymbols) { if (first) { first = false; } else { sb.append(';'); } sb.append(s); } var e = document.createElement("preprocessorSymbols"); document.getDocumentElement().appendChild(e); e.setTextContent(sb.toString()); } var outputElt = document.createElement("outputPath"); document.getDocumentElement().appendChild(outputElt); outputElt.setTextContent(this.OutputPath); var writer = new StringWriter(); XmlHelper.save(document, writer); var bytes = writer.toString().getBytes("UTF-8"); var stream = new ByteArrayInputStream(bytes); if (file.exists()) { file.setContents(stream, IResource.FORCE, null); } else { file.create(stream, true, null); } } catch (Exception e) { Environment.logException(e); } }
public override object internalizeValue(string str, object obj1, object obj2) { if (this.externalArrayType.isInstance(obj1)) { ArrayData arrayData = (ArrayData) obj1; object[] objArray1; if (obj2 is object[] && (objArray1 = (object[]) obj2).Length == arrayData.size()) { ByteCodeHelper.arraycopy((object) arrayData.getDataArray(), 0, (object) objArray1, 0, objArray1.Length); return (object) objArray1; } else { object[] objArray2 = new object[arrayData.size()]; ByteCodeHelper.arraycopy((object) arrayData.getDataArray(), 0, (object) objArray2, 0, objArray2.Length); return (object) objArray2; } } else { string str1 = str; string str2 = new StringBuilder().append(obj1).append(" is not a ").append((object) this.externalArrayType).toString(); Throwable.__\u003CsuppressFillInStackTrace\u003E(); throw new TableKeyExistsWithDifferentTypeException(str1, (NetworkTableEntryType) this, str2); } }
private static String getIdString(MethodInfo method) { var p = method.getUserData(typeof(PropertyMemberInfo)); var sb = new StringBuilder(); if (p != null) { sb.append("P:"); sb.append(getIdName(method.DeclaringType)).append('.'); sb.append(p.Name); return sb.toString(); } var i = method.getUserData(typeof(IndexerMemberInfo)); int nparams = method.Parameters.count(); if (i != null) { sb.append("P:"); if (method.ReturnType == method.ReturnType.Library.VoidType) { nparams--; } } else { sb.append("M:"); } sb.append(getIdName(method.DeclaringType)).append('.'); sb.append((method.Name.equals("<init>")) ? "#init" : method.Name); if (method.Parameters.any()) { sb.append('('); var first = true; foreach (var t in method.Parameters.take(nparams).select(p => p.Type)) { if (first) { first = false; } else { sb.append(","); } sb.append(getIdName(t)); } sb.append(')'); } return sb.toString(); }
public override void exportValue(string str, object obj1, object obj2) { if (!this.externalArrayType.isInstance(obj2)) { string str1 = str; string str2 = new StringBuilder().append(obj2).append(" is not a ").append((object) this.externalArrayType).toString(); Throwable.__\u003CsuppressFillInStackTrace\u003E(); throw new TableKeyExistsWithDifferentTypeException(str1, (NetworkTableEntryType) this, str2); } else if (!(obj1 is object[])) { string str1 = str; string str2 = new StringBuilder().append("Internal data: ").append(obj1).append(" is not an array").toString(); Throwable.__\u003CsuppressFillInStackTrace\u003E(); throw new TableKeyExistsWithDifferentTypeException(str1, (NetworkTableEntryType) this, str2); } else { object[] objArray = (object[]) obj1; ArrayData arrayData = (ArrayData) obj2; arrayData.setSize(objArray.Length); ByteCodeHelper.arraycopy((object) objArray, 0, (object) arrayData.getDataArray(), 0, objArray.Length); } }
private static String getIdName(TypeInfo type) { switch (type.TypeKind) { case Boolean: return "boolean"; case Byte: return "byte"; case Char: return "char"; case Double: return "double"; case Float: return "float"; case Int: return "int"; case Long: return "long"; case Short: return "short"; case Void: return "void"; case Array: return getIdName(type.ElementType) + "[]"; default: var result = type.FullName.replace('/', '.').replace('$', '.'); if (type.OriginalTypeDefinition != type && type.GenericArguments.any()) { var sb = new StringBuilder(); sb.append(result).append('{'); var first = true; foreach (var t in type.GenericArguments) { if (first) { first = false; } else { sb.append(", "); } sb.append(getIdName(t)); } sb.append('}'); result = sb.toString(); } return result; } }
//void readFloats(float[] v, int off, int len) { // int span, endoff = off + len; // while (off < endoff) { // if (!blkmode) { // span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 2); // @in.readFully(buf, 0, span << 2); // pos = 0; // } else if (end - pos < 4) { // v[off++] = din.readFloat(); // continue; // } else { // span = Math.min(endoff - off, ((end - pos) >> 2)); // } // bytesToFloats(buf, pos, v, off, span); // off += span; // pos += span << 2; // } //} //void readLongs(long[] v, int off, int len) { // int stop, endoff = off + len; // while (off < endoff) { // if (!blkmode) { // int span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 3); // @in.readFully(buf, 0, span << 3); // stop = off + span; // pos = 0; // } else if (end - pos < 8) { // v[off++] = din.readLong(); // continue; // } else { // stop = Math.min(endoff, off + ((end - pos) >> 3)); // } // while (off < stop) { // v[off++] = Bits.getLong(buf, pos); // pos += 8; // } // } //} //void readDoubles(double[] v, int off, int len) { // int span, endoff = off + len; // while (off < endoff) { // if (!blkmode) { // span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 3); // @in.readFully(buf, 0, span << 3); // pos = 0; // } else if (end - pos < 8) { // v[off++] = din.readDouble(); // continue; // } else { // span = Math.min(endoff - off, ((end - pos) >> 3)); // } // bytesToDoubles(buf, pos, v, off, span); // off += span; // pos += span << 3; // } //} //String readLongUTF() { // return readUTFBody(readLong()); //} private String readUTFBody(long utflen) { StringBuilder sbuf = new StringBuilder(); if (!blkmode) { end = pos = 0; } while (utflen > 0) { int avail = end - pos; if (avail >= 3 || (long) avail == utflen) { utflen -= readUTFSpan(sbuf, utflen); } else { if (blkmode) { // near block boundary, read one byte at a time utflen -= readUTFChar(sbuf, utflen); } else { // shift and refill buffer manually if (avail > 0) { System.Array.Copy(buf, pos, buf, 0, avail); } pos = 0; end = (int) Math.min(MAX_BLOCK_SIZE, (int)utflen); @in.readFully(buf, avail, end - avail); } } } return sbuf.toString(); }
public static String unescapeString(char[] text, int offset, int length) { var sb = new StringBuilder(); var end = offset + length; for (var i = offset; i < end; i++) { var c = text[i]; if (c == '\\') { switch (c = text[++i]) { case '"': case '\\': case '\'': sb.append(c); break; case '0': sb.append((char)0); break; case 'a': sb.append((char)7); break; case 'b': sb.append((char)8); break; case 'f': sb.append((char)12); break; case 'n': sb.append((char)10); break; case 'r': sb.append((char)13); break; case 't': sb.append((char)9); break; case 'v': sb.append((char)11); break; case 'u': { var value = 0; for (var j = 0; j < 4; j++) { value = value * 16 + ParserHelper.scanHexDigit(text[++i]); } sb.append((char)value); break; } case 'U': { var value = 0; for (var j = 0; j < 4; j++) { value = value * 16 + ParserHelper.scanHexDigit(text[++i]); } sb.append((char)value); value = 0; for (int j = 0; j < 4; j++) { value = value * 16 + ParserHelper.scanHexDigit(text[++i]); } sb.append((char)value); break; } case 'x': { var value = ParserHelper.scanHexDigit(text[++i]); var d = ParserHelper.scanHexDigit(text[i + 1]); if (d > -1) { value = value * 16 + d; if ((d = ParserHelper.scanHexDigit(text[++i + 1])) > -1) { value = value * 16 + d; if ((d = ParserHelper.scanHexDigit(text[++i + 1])) > -1) { value = value * 16 + d; i++; } } } sb.append((char)value); break; } } } else { sb.append(c); } } return sb.toString(); }
private long readUTFSpan(StringBuilder sbuf, long utflen) { int cpos = 0; int start = pos; int avail = Math.min(end - pos, CHAR_BUF_SIZE); // stop short of last char unless all of utf bytes @in buffer int stop = pos + ((utflen > avail) ? avail - 2 : (int) utflen); boolean outOfBounds = false; try { while (pos < stop) { int b1, b2, b3; b1 = buf[pos++] & 0xFF; switch (b1 >> 4) { case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: // 1 byte format: 0xxxxxxx cbuf[cpos++] = (char) b1; break; case 12: case 13: // 2 byte format: 110xxxxx 10xxxxxx b2 = buf[pos++]; if ((b2 & 0xC0) != 0x80) { throw new Exception(); } cbuf[cpos++] = (char) (((b1 & 0x1F) << 6) | ((b2 & 0x3F) << 0)); break; case 14: // 3 byte format: 1110xxxx 10xxxxxx 10xxxxxx b3 = buf[pos + 1]; b2 = buf[pos + 0]; pos += 2; if ((b2 & 0xC0) != 0x80 || (b3 & 0xC0) != 0x80) { throw new Exception(); } cbuf[cpos++] = (char) (((b1 & 0x0F) << 12) | ((b2 & 0x3F) << 6) | ((b3 & 0x3F) << 0)); break; default: // 10xx xxxx, 1111 xxxx throw new Exception(); } } } catch (Exception) { outOfBounds = true; } finally { if (outOfBounds || (pos - start) > utflen) { /* * Fix for 4450867: if a malformed utf char causes the * conversion loop to scan past the expected end of the utf * string, only consume the expected number of utf bytes. */ pos = start + (int) utflen; throw new Exception(); } } sbuf.append(cbuf, 0, cpos); return pos - start; }
public static String unescapeVerbatimString(char[] text, int offset, int length) { var sb = new StringBuilder(); var end = offset + length; for (var i = offset; i < end; i++) { var c = text[i]; if (c == '"') { i++; } sb.append(c); } return sb.toString(); }
public String toString() { StringBuilder sb = new StringBuilder(); sb.append("java.util.regex.Matcher"); sb.append("[pattern=" + pattern()); sb.append(" region="); sb.append(regionStart() + "," + regionEnd()); sb.append(" lastmatch="); if ((first >= 0) && (group() != null)) { sb.append(group()); } sb.append("]"); return sb.toString(); }
public static void unescapeIdentifier(StringBuilder sb, char[] text, int offset, int length) { var end = offset + length; if (text[offset] == '@') { offset++; } for (var i = offset; i < end; i++) { var c = text[i]; if (c == '\\') { c = text[++i]; if (c == 'u') { var value = 0; for (var j = 0; j < 4; j++) { value = value * 16 + ParserHelper.scanHexDigit(text[++i]); } sb.append((char)value); } else { var value = 0; for (var j = 0; j < 4; j++) { value = value * 16 + ParserHelper.scanHexDigit(text[++i]); } sb.append((char)value); value = 0; for (int j = 0; j < 4; j++) { value = value * 16 + ParserHelper.scanHexDigit(text[++i]); } sb.append((char)value); } } else { sb.append(c); } } }
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 static String decodeDocumentation(char[] text, int offset, int length) { var end = offset + length; offset++; var sb = new StringBuilder(); if (text[offset] == '*') { offset += 2; for (var i = offset; i < end; i++) { var c = text[i]; switch (c) { case '\r': sb.append(c); if (text[i + 1] == '\n') { i++; } goto case '\n'; case '\u2028': case '\u2029': case '\n': sb.append(c); var done = false; while (i + 1 < end && !done) { switch (text[i + 1]) { case ' ': case '\t': case '\v': case '\f': i++; break; case '*': if (text[i + 2] != '/') { i++; if (text[i + 1] == ' ') { i++; } } goto default; default: done = true; break; } } break; case '*': if (text[i + 1] != '/') { sb.append(c); } else { i++; } break; default: sb.append(c); break; } } } else { offset += 2; if (offset < end && text[offset] == ' ') { offset++; } for (var i = offset; i < end; i++) { var c = text[i]; switch (c) { case '\r': sb.append(c); if (text[i + 1] == '\n') { c = '\n'; i++; } goto case '\n'; case '\u2028': case '\u2029': case '\n': sb.append(c); do { i++; } while (i < end && text[i] != '/'); i += 2; if (i + 1 < end && text[i + 1] == ' ') { i++; } break; default: sb.append(c); break; } } } return sb.toString(); }