internal static System.String GetFileName ( System.String name ) { if ( name==null || name.Length==0 ) return name; name = name.Replace("\t", ""); try { name = System.IO.Path.GetFileName(name); } catch ( System.ArgumentException ) { // Remove invalid chars foreach ( char ichar in System.IO.Path.GetInvalidPathChars() ) { name = name.Replace ( ichar.ToString(), System.String.Empty ); } name = System.IO.Path.GetFileName(name); } try { System.IO.FileInfo fi = new System.IO.FileInfo(name); if ( fi!=null ) fi = null; } catch ( System.ArgumentException ) { name = null; #if LOG if ( log.IsErrorEnabled ) { log.Error(System.String.Concat("Filename [", name, "] is not allowed by the filesystem")); } #endif } return name; }
/// <summary> /// /// </summary> /// <param name="s"></param> /// <returns></returns> public static System.Single Parse(System.String s) { if (s.EndsWith("f") || s.EndsWith("F")) return System.Single.Parse(s.Substring(0, s.Length - 1).Replace(".", CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator)); else return System.Single.Parse(s.Replace(".", CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator)); }
public void Should_replace_an_item_with_a_sequence_of_items() { var items = new[] {1, 2, 3, 1, 5}; var replaced = items.Replace(1, 6, 7).ToArray(); Assert.That(replaced, Is.EquivalentTo(new[] {6, 7, 2, 3, 6, 7, 5})); }
/// <summary>Initialize member variable setting the base file path</summary> /// <param name="basePath">representing base path location /// </param> public FileGenerator(System.String basePath) { // make sure there is a \ appended to ouput director path System.Console.Out.WriteLine(basePath); this.basePath = basePath.Replace('\\', '/'); if ((basePath[basePath.Length - 1]) != '/') basePath = basePath + "/"; }
public void GeneralityOfReplace() { var input = new[] { "Hello", "World", "Bye", "Again" }; var replaced = input.Replace(x => x.StartsWith("A"), x => new[] { x.ToLower()}); var result = string.Join(", ", replaced); Assert.AreEqual("Hello, World, Bye, again", result); }
public void ReplaceStringInSequence() { var seq = new[] { "foo", "bar", "baz", "qux", "corge", "grault" }; var actual = seq.Replace("quux", "qux"); Assert.Equal( new[] { "foo", "bar", "baz", "quux", "corge", "grault" }, actual); }
public static System.Double Parse(System.String s) { try { return System.Double.Parse(s.Replace(".", CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator)); } catch (OverflowException) { return System.Double.MaxValue; } }
/// <summary> /// Parse a rfc 2822 date and time specification. rfc 2822 section 3.3 /// </summary> /// <param name="date">rfc 2822 date-time</param> /// <returns>A <see cref="System.DateTime" /> from the parsed header body</returns> public static System.DateTime parseDate( System.String date ) { if ( date==null || date.Equals(System.String.Empty) ) return System.DateTime.MinValue; System.DateTime msgDateTime; date = anmar.SharpMimeTools.SharpMimeTools.uncommentString (date); msgDateTime = new System.DateTime (0); try { // TODO: Complete the list date = date.Replace("UT", "+0000"); date = date.Replace("GMT", "+0000"); date = date.Replace("EDT", "-0400"); date = date.Replace("EST", "-0500"); date = date.Replace("CDT", "-0500"); date = date.Replace("MDT", "-0600"); date = date.Replace("MST", "-0600"); date = date.Replace("EST", "-0700"); date = date.Replace("PDT", "-0700"); date = date.Replace("PST", "-0800"); date = date.Replace("AM", System.String.Empty); date = date.Replace("PM", System.String.Empty); int rpos = date.LastIndexOfAny(new Char[]{' ', '\t'}); if (rpos>0 && rpos != date.Length - 6) date = date.Substring(0, rpos + 1) + "-0000"; date = date.Insert(date.Length-2, ":"); msgDateTime = DateTime.ParseExact(date, _date_formats, System.Globalization.CultureInfo.CreateSpecificCulture("en-us"), System.Globalization.DateTimeStyles.AllowInnerWhite); #if LOG } catch ( System.Exception e ) { if ( log.IsErrorEnabled ) log.Error(System.String.Concat("Error parsing date: [", date, "]"), e); #else } catch ( System.Exception ) { #endif msgDateTime = new System.DateTime (0); } return msgDateTime; }
/// <summary> /// Gets the loader specified in the configuration file. /// </summary> /// <returns>TemplateLoader</returns> public static ResourceLoader getLoader(RuntimeServices rs, System.String loaderClassName) { ResourceLoader loader = null; try { // since properties are parsed into arrays with commas, something else needed to be used loaderClassName = loaderClassName.Replace(';', ','); Type loaderType = System.Type.GetType(loaderClassName); Object o = System.Activator.CreateInstance(loaderType); loader = (ResourceLoader) o; rs.info("Resource Loader Instantiated: " + loader.GetType().FullName); return loader; } catch (System.Exception e) { rs.error("Problem instantiating the template loader.\n" + "Look at your properties file and make sure the\n" + "name of the template loader is correct. Here is the\n" + "error: " + StringUtils.stackTrace(e)); throw new System.Exception("Problem initializing template loader: " + loaderClassName + "\nError is: " + StringUtils.stackTrace(e)); } }
public static System.String escape(System.String text, EncodingCharacters encChars) { //First, take all special characters and replace them with something that is garbled for(int i=0;i<SPECIAL_ENCODING_VALUES.Length;i++) { string specialValues = SPECIAL_ENCODING_VALUES[i]; text = text.Replace(specialValues, EncodeSpecialCharacters(i.ToString())); } //Encode each escape character System.Collections.Hashtable esc = getEscapeSequences(encChars); System.Text.StringBuilder result = new System.Text.StringBuilder(); SupportClass.SetSupport keys = new SupportClass.HashSetSupport(esc.Keys); System.String escChar = System.Convert.ToString(encChars.EscapeCharacter); int position = 0; while (position < text.Length) { System.Collections.IEnumerator it = keys.GetEnumerator(); bool isReplaced = false; while (it.MoveNext() && !isReplaced) { System.String seq = (System.String) it.Current; System.String val = (System.String) esc[seq]; if (text.Substring(position, 1).Equals(val)) { result.Append(seq); isReplaced = true; } } if (!isReplaced) { result.Append(text.Substring(position, 1)); } position++; } //Replace each garbled entry with the correct special value for(int i=0;i<SPECIAL_ENCODING_VALUES.Length;i++) { string specialValues = SPECIAL_ENCODING_VALUES[i]; result.Replace(EncodeSpecialCharacters(i.ToString()), specialValues); } return result.ToString(); }
/// <summary>this method writes the GeneratedClass object to disk</summary> /// <param name="gc">the object to be written to disk /// </param> /// <param name="packageName">representing the packageName /// </param> /// <param name="fileName">representing the file name /// </param> /// <exception cref="IOException">if unable to create file /// </exception> public virtual void storeFile(GeneratedClass gc, System.String packageName, System.String fileName) { //format package name packageName = packageName.Replace('.', '/'); // set the file path fileName = Regex.Replace(fileName, " ", "") + ".java"; System.String filePath = basePath + "/" + packageName + "/" + fileName; System.IO.FileInfo f = new System.IO.FileInfo(filePath); System.Text.StringBuilder dir = new System.Text.StringBuilder(); //check if file exist // TODO: Reactivate this once everything works! //if(f.exists()) // throw new IOException("File already exists"); //create subfolders int i = 0; while (i < filePath.Length) { if (filePath[i] != '/') { dir.Append(filePath[i]); } else { dir.Append(filePath[i]); System.IO.FileInfo d = new System.IO.FileInfo(dir.ToString()); System.IO.Directory.CreateDirectory(d.FullName); } ++i; } System.IO.FileStream fstream = new System.IO.FileStream(f.FullName, System.IO.FileMode.Create); /* open file stream */ System.IO.BinaryWriter ostream = new System.IO.BinaryWriter(fstream); /* open object stream */ ostream.Write(gc.ToString()); /* clean-up */ ostream.Flush(); fstream.Close(); }
internal void ReplaceFieldKey(ref System.Text.StringBuilder builder, TemplateOptions options) { object refVal = this.Value ?? options.NullDisplayText; string replacementValue = (this.HasFormatString) ? string.Format(CultureInfo.CurrentUICulture, this.FormatString, (refVal ?? "")) : (refVal ?? "").ToString(); builder.Replace(this.fieldKey.ToString(), replacementValue); }
private System.String ReplaceUrlTokens(System.String url, SharpAttachment attachment) { if (string.IsNullOrEmpty(url) || url.IndexOf('[') == -1 || url.IndexOf(']') == -1) return url; if (url.IndexOf("[MessageID]", System.StringComparison.Ordinal) != -1) { url = url.Replace("[MessageID]", System.Web.HttpUtility.UrlEncode(MimeTools.Rfc2392Url(this.MessageID))); } if (attachment != null && attachment.ContentID != null) { if (url.IndexOf("[ContentID]", System.StringComparison.Ordinal) != -1) { url = url.Replace("[ContentID]", System.Web.HttpUtility.UrlEncode(MimeTools.Rfc2392Url(attachment.ContentID))); } if (url.IndexOf("[Name]", System.StringComparison.Ordinal) != -1) { url = url.Replace("[Name]", attachment.SavedFile != null ? System.Web.HttpUtility.UrlEncode(attachment.SavedFile.Name) : System.Web.HttpUtility.UrlEncode(attachment.Name)); } } return url; }
public void Replace_SourceIsNull_NullIsReplaced() { string[] chars = new[] {"a", null, "c"}; var actual = chars.Replace(null, "b"); AssertEx.AreEquivalent(actual, "a", "b", "c"); }
public void Replace_ReplacementIsNull_ReplacedWithNull() { string[] chars = new[] {"a", "b", "c"}; var actual = chars.Replace("b", null); AssertEx.AreEquivalent(actual, "a", null, "c"); }
private System.String ReplaceUrlTokens( System.String url, anmar.SharpMimeTools.SharpAttachment attachment ) { if ( url==null || url.Length==0 || url.IndexOf('[')==-1 || url.IndexOf(']')==-1 ) return url; if ( url.IndexOf("[MessageID]")!=-1 ) { url = url.Replace("[MessageID]", System.Web.HttpUtility.UrlEncode(anmar.SharpMimeTools.SharpMimeTools.Rfc2392Url(this.MessageID))); } if ( attachment!=null && attachment.ContentID!=null ) { if ( url.IndexOf("[ContentID]")!=-1 ) { url = url.Replace("[ContentID]", System.Web.HttpUtility.UrlEncode(anmar.SharpMimeTools.SharpMimeTools.Rfc2392Url(attachment.ContentID))); } if ( url.IndexOf("[Name]")!=-1 ) { if ( attachment.SavedFile!=null ) { url = url.Replace("[Name]", System.Web.HttpUtility.UrlEncode(attachment.SavedFile.Name)); } else { url = url.Replace("[Name]", System.Web.HttpUtility.UrlEncode(attachment.Name)); } } } return url; }
/// <summary> /// Parse and decode rfc 2047 header body /// </summary> /// <param name="header">header body to parse</param> /// <returns>parsed <see cref="System.String" /></returns> public static System.String parserfc2047Header( System.String header ) { header = header.Replace ("\"", System.String.Empty); header = anmar.SharpMimeTools.SharpMimeTools.rfc2047decode(header); return header; }
public void ReplaceNumberInSequence() { var seq = new[] { 4, 2, 42, 1337, 7 }; var actual = seq.Replace(9, i => i == 2); Assert.Equal(new[] { 4, 9, 42, 1337, 7 }, actual); }
public static System.String Uid2url(System.String uid) { System.String url = uid.Replace('\u0000', '/'); // replace nulls with slashes return url.Substring(0, (url.LastIndexOf('/')) - (0)); // remove date from end }
/// <summary> /// Normalizes lines to account for platform differences. Macs use /// a single \r, DOS derived operating systems use \r\n, and Unix /// uses \n. Replace each with a single \n. /// </summary> /// <author> <a href="mailto:[email protected]">Sam Ruby</a> /// </author> /// <returns> /// source with all line terminations changed to Unix style /// </returns> protected internal virtual System.String normalizeNewlines(System.String source) { //TODO: //return perl.substitute("s/\r[\n]/\n/g", source); return source.Replace(Environment.NewLine, "|").Replace("\n", "|"); }
public virtual double ParseDouble(System.String value_Renamed) { return System.Double.Parse(value_Renamed.Replace(".", System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator)); }
public static void insert(System.String mac, int offset, byte[] bytes) { mac = mac.Replace(":", "").Replace("-",""); long l = System.Convert.ToInt64(mac, 16); ArrayHelper.insertLong(bytes, l, offset, 6); }
/// <summary> /// Replaces characters that are not necessary for comparing (like whitespaces) and diacritics. The result is returned as <see cref="string.ToLowerInvariant"/>. /// </summary> /// <param name="name">Name to clean up</param> /// <returns>Cleaned string</returns> protected string RemoveCharacters(string name) { string result = new[] { "-", ",", "/", ":", " ", " ", ".", "'" }.Aggregate(name, (current, s) => current.Replace(s, "")); result = result.Replace("&", "and"); return StringUtils.RemoveDiacritics(result.ToLowerInvariant()); }
/// <summary> Return a package name as a relative path name /// * /// </summary> /// <param name="String">package name to convert to a directory. /// </param> /// <returns>String directory path. /// /// </returns> public static System.String getPackageAsPath(System.String pckge) { return pckge.Replace('.', System.IO.Path.DirectorySeparatorChar.ToString()[0]) + System.IO.Path.DirectorySeparatorChar.ToString(); }
/// <summary> /// Encodes a Message-ID or Content-ID following RFC 2392 rules. /// </summary> /// <param name="input"><see cref="System.String" /> with the Message-ID or Content-ID.</param> /// <returns><see cref="System.String" /> with the value encoded as RFC 2392 dictates.</returns> public static System.String Rfc2392Url( System.String input) { if ( input==null || input.Length<4 ) return input; if ( input.Length>2 && input[0]=='<' && input[input.Length-1]=='>' ) input = input.Substring(1, input.Length-2); if ( input.IndexOf('/')!=-1 ) { input = input.Replace("/", "%2f"); } return input; }
public void Replace_MoreOccurrenceForReplacedElement_AllReplacedWithOneElement() { char[] chars = new[] {'a', 'b', 'b'}; var actual = chars.Replace('b', 'x').ToArray(); AssertEx.AreEquivalent(actual, 'a', 'x', 'x'); }
internal virtual System.Windows.Forms.MenuItem MenuItem(System.String txt, int key, System.Drawing.Image icon, System.Windows.Forms.KeyEventArgs accel) { System.Windows.Forms.MenuItem mi = new System.Windows.Forms.MenuItem(txt.Replace("" + (char) key, "&" + (char) key)); mi.Click += new System.EventHandler(this.actionPerformed); SupportClass.CommandManager.CheckCommand(mi); if (icon != null) { //UPGRADE_ISSUE: Method 'javax.swing.AbstractButton.setIcon' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javaxswingAbstractButtonsetIcon_javaxswingIcon'" // mi.setIcon(icon); } // Handled by the designer code now. //if (accel != null) //{ // //UPGRADE_WARNING: Method 'javax.swing.JMenuItem.setAccelerator' was converted to 'System.Windows.Forms.MenuItem.Shortcut' which may throw an exception. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1101'" // // mi.Shortcut = (System.Windows.Forms.Shortcut.) accel.Key.KeyData; //} return mi; }
public void Replace_NoOccurrence_SameElementsReturned() { char[] chars = new[] {'a', 'b', 'c'}; var actual = chars.Replace('x', 'y'); AssertEx.AreEquivalent(actual, 'a', 'b', 'c'); }
public static bool TryParse(System.String s, out float f) { bool ok = false; if (s.EndsWith("f") || s.EndsWith("F")) ok = System.Single.TryParse(s.Substring(0, s.Length - 1).Replace(".", CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator), out f); else ok = System.Single.TryParse(s.Replace(".", CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator), out f); return ok; }
public void Replace_OneOccurrenceForReplacedElement_ElementReplaced() { char[] chars = new[] {'a', 'b', 'c'}; var actual = chars.Replace('b', 'x'); AssertEx.AreEquivalent(actual, 'a', 'x', 'c'); }