/// <summary> /// Evaulate the path string in relation to the current item /// </summary> /// <param name="context">The Revolver context to evaluate the path against</param> /// <param name="path">The path to evaulate. Can either be absolute or relative</param> /// <returns>The full sitecore path to the target item</returns> public static string EvaluatePath(Context context, string path) { if (ID.IsID(path)) return path; string workingPath = string.Empty; if (!path.StartsWith("/")) workingPath = context.CurrentItem.Paths.FullPath + "/" + path; else workingPath = path; // Strip any language and version tags if (workingPath.IndexOf(':') >= 0) workingPath = workingPath.Substring(0, workingPath.IndexOf(':')); // Make relative paths absolute string[] parts = workingPath.Split('/'); StringCollection targetParts = new StringCollection(); targetParts.AddRange(parts); while (targetParts.Contains("..")) { int ind = targetParts.IndexOf(".."); targetParts.RemoveAt(ind); if (ind > 0) { targetParts.RemoveAt(ind - 1); } } if (targetParts[targetParts.Count - 1] == ".") targetParts.RemoveAt(targetParts.Count - 1); // Remove empty elements while (targetParts.Contains("")) { targetParts.RemoveAt(targetParts.IndexOf("")); } string[] toRet = new string[targetParts.Count]; targetParts.CopyTo(toRet, 0); return "/" + string.Join("/", toRet); }
/// <summary> /// get a value from a row, position given by AColumnNames /// </summary> protected static string GetValue(StringCollection AColumnNames, string[] ACurrentRow, string AColumnName) { int index = AColumnNames.IndexOf(AColumnName); if (index == -1) { throw new Exception("TFixData.GetValue: Problem with unknown column name " + AColumnName); } return ACurrentRow[index]; }
/// <summary> /// set a value of a row, position given by AColumnNames /// </summary> protected static void SetValue(StringCollection AColumnNames, ref string[] ACurrentRow, string AColumnName, string ANewValue) { int index = AColumnNames.IndexOf(AColumnName); if (index == -1) { throw new Exception("TFixData.SetValue: Problem with unknown column name " + AColumnName); } ACurrentRow[index] = ANewValue; }
public PickListForm(string strTitle, string strCurrent, StringCollection strc) { // // Required for Windows Form Designer support // InitializeComponent(); // // TODO: Add any constructor code after InitializeComponent call // listBox1.DataSource = strc; listBox1.SelectedIndex = strCurrent == "" ? -1 : strc.IndexOf(strCurrent); Text = strTitle; label1.Text = label1.Text.Replace("$1", strTitle); }
public Settings() { InitializeComponent(); Closing += PreventTermination; planetList = Properties.Settings.Default.planets; System.Collections.IEnumerator se = Constraints.PLANETS.GetEnumerator(); while (se.MoveNext()) { string pl = (string)se.Current; CheckBox tmp = new CheckBox(); tmp.Checked += delegate(object s, RoutedEventArgs e) { if(planetList.IndexOf(pl) == -1) planetList.Add(pl); }; tmp.Unchecked += delegate(object s, RoutedEventArgs e) { if(planetList.IndexOf(pl) > -1) planetList.Remove(pl); }; tmp.IsChecked = planetList.IndexOf(pl) > -1; StackPanel sp = new StackPanel(); sp.Orientation = Orientation.Horizontal; sp.Children.Add(tmp); Label lbl = new Label(); lbl.Content = pl; sp.Children.Add(lbl); planets.Children.Add(sp); } closetaskbar.IsChecked = Properties.Settings.Default.closeToTaskbar; mintaskbar.IsChecked = Properties.Settings.Default.minimizeToTaskbar; notify.IsChecked = Properties.Settings.Default.notify; hasrewards.IsChecked = Properties.Settings.Default.hasRewards; reward.Text = Properties.Settings.Default.rewardContains.ToLower(); credits.Text = Properties.Settings.Default.credits.ToString(); usefilter.IsChecked = Properties.Settings.Default.useFilter; }
public static int TextHasErrors(ref HyperComponents.WebUI.CustomSpellChecker.SpellChecker c, string v) { System.Collections.Specialized.StringCollection badWords = new System.Collections.Specialized.StringCollection(); BadWord badWord = null; badWords.Clear(); //check some text. c.Check(v); int nbErrors = 0; //iterate through all bad words in the text. while ((badWord = c.NextBadWord()) != null) { if (badWords.IndexOf(badWord.Word) < 0) { //Trace.Warn(" -> " + badWord.Word + " - " + badWord.Reason.ToString()); nbErrors++; badWords.Add(badWord.Word); } } return(nbErrors); }
public int ParseFileSection(StringCollection sec, PySection section, int begin, int end) { // sec collection, doesn't contain # --- begin / # --- end int count = begin; for (int j=begin; j<end; j++) { string item = sec[j]; if (item.Contains("# begin")) { // here's we have a new section string trimstr = item.Trim(); string nn = trimstr.Substring(7); section.Children.Add(new PySection(nn.Trim())); PySection child = (PySection)section.Children[section.Children.Count - 1]; child.Begin = count; // find the end... string ends = item.Replace("begin", "end"); int end_idx = sec.IndexOf(ends); if ((end_idx >= begin) || (end_idx <= end)) { child.Size = end_idx - child.Begin - 1; ParseFileSection(sec, child, count + 1, end_idx); j = end_idx; count = end_idx; } else { // Not found error... } } else if (item.Contains("# end")) { // DO NOTHING } else { section.Lines.Add(item); } count++; } return count; }
void SavePdb(string strPdbFile) { // Make a list of unique sound files PdbPacker pdbp = new PdbPacker(); int cSfx = m_alsNames.Count; StringCollection strcUniqueSounds = new StringCollection(); ArrayList alsPcm = new ArrayList(); for (int iSfx = 0; iSfx < cSfx; iSfx++) { if (!listViewSfx.Items[iSfx].Checked) continue; if (!(bool)m_alsSfxEnabled[iSfx]) continue; string strFile = listViewSfx.Items[iSfx].SubItems[1].Text; if (strFile == null) continue; strFile.Trim(); if (strFile.Length == 0) continue; int istr = strcUniqueSounds.IndexOf(strFile); if (istr == -1) istr = strcUniqueSounds.Add(strFile); } // Serialize names out ArrayList alsStringOffsets = new ArrayList(); BinaryWriter bwtr = new BinaryWriter(new MemoryStream()); bwtr.Write(Misc.SwapUShort((ushort)strcUniqueSounds.Count)); for (int iSound = 0; iSound < strcUniqueSounds.Count; iSound++) { alsStringOffsets.Add(bwtr.BaseStream.Position); string strFile = Path.ChangeExtension(strcUniqueSounds[iSound], ".snd"); char[] sz = strFile.ToCharArray(); bwtr.Write(sz); bwtr.Write((byte)0); } byte[] abSoundFiles = new byte[bwtr.BaseStream.Length]; bwtr.BaseStream.Seek(0, SeekOrigin.Begin); bwtr.BaseStream.Read(abSoundFiles, 0, (int)bwtr.BaseStream.Length); bwtr.Close(); // soundfiles file PdbPacker.File fileSounds = new PdbPacker.File("soundfiles", abSoundFiles); pdbp.Add(fileSounds); // Now serialize the sfx entries in the order of the names bwtr = new BinaryWriter(new MemoryStream()); for (int iName = 0; iName < m_alsNames.Count; iName++) { // Need to find the entry in listViewSfx for this name since the persist // order needs to match soundeffects.h. string strName = ((StringCollection)m_alsNames[iName])[0]; int iSfx; bool fFound = false; for (iSfx = 0; iSfx < cSfx; iSfx++) { if (strName == listViewSfx.Items[iSfx].SubItems[0].Text) { fFound = true; break; } } if (!fFound) throw new Exception("Internal error"); string strFile = listViewSfx.Items[iSfx].SubItems[1].Text; if (!listViewSfx.Items[iSfx].Checked) strFile = null; if (!(bool)m_alsSfxEnabled[iSfx]) strFile = null; if (strFile == null) { bwtr.Write((byte)0xff); } else { strFile.Trim(); if (strFile.Length == 0) { bwtr.Write((byte)0xff); } else { bwtr.Write((byte)strcUniqueSounds.IndexOf(strFile)); } } bwtr.Write((byte)0); // bwtr.Write(byte.Parse(listViewSfx.Items[iSfx].SubItems[2].Text)); int nPriority = m_strcPriorities.IndexOf(listViewSfx.Items[iSfx].SubItems[3].Text); if (nPriority < 0) { MessageBox.Show("Warning: " + listViewSfx.Items[iSfx].SubItems[0].Text + " has an unfamiliar priority."); } bwtr.Write((byte)nPriority); } byte[] abSfxEntries = new byte[bwtr.BaseStream.Length]; bwtr.BaseStream.Seek(0, SeekOrigin.Begin); bwtr.BaseStream.Read(abSfxEntries, 0, (int)bwtr.BaseStream.Length); bwtr.Close(); PdbPacker.File fileSfxEntries = new PdbPacker.File("SfxEntries", abSfxEntries); pdbp.Add(fileSfxEntries); // Now add in all the sounds for (int istrFile = 0; istrFile < strcUniqueSounds.Count; istrFile++) { string strFile = Path.GetFullPath(textBoxSoundsDir.Text) + "\\" + strcUniqueSounds[istrFile]; Pcm pcm = new Pcm(strFile); PdbPacker.File fileT = new PdbPacker.File(); fileT.str = Path.ChangeExtension(strcUniqueSounds[istrFile], ".snd"); fileT.ab = pcm.GetSndEncoding(); fileT.fCompress = false; pdbp.Add(fileT); } // Ready to save pdb pdbp.Save(strPdbFile, "WARI"); }
public void Test01() { IntlStrings intl; StringCollection sc; string itm; // returned value of Item // simple string values string[] values = { "", " ", "a", "aa", "text", " spaces", "1", "$%^#", "2222222222222222222222222", System.DateTime.Today.ToString(), Int32.MaxValue.ToString() }; intl = new IntlStrings(); // [] StringCollection Item is returned as expected //----------------------------------------------------------------- sc = new StringCollection(); // exception expected // all indexes should be invalid for empty collection // // [] Invalid parameter - set Item() on empty collection // itm = intl.GetRandomString(MAX_LEN); Assert.Throws<ArgumentOutOfRangeException>(() => { sc[-1] = itm; }); Assert.Throws<ArgumentOutOfRangeException>(() => { sc[0] = itm; }); Assert.Throws<ArgumentOutOfRangeException>(() => { sc[0] = null; }); // [] set Item() on collection filled with simple strings // sc.Clear(); sc.AddRange(values); int cnt = values.Length; if (sc.Count != cnt) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", sc.Count, cnt)); } for (int i = 0; i < cnt; i++) { sc[i] = values[cnt - i - 1]; if (String.Compare(sc[i], values[cnt - i - 1]) != 0) { Assert.False(true, string.Format("Error, value is {1} instead of {2}", i, sc[i], values[cnt - i - 1])); } } // // Intl strings // [] set Item() on collection filled with Intl strings // string[] intlValues = new string[values.Length]; // fill array with unique strings // for (int i = 0; i < values.Length; i++) { string val = intl.GetRandomString(MAX_LEN); while (Array.IndexOf(intlValues, val) != -1) val = intl.GetRandomString(MAX_LEN); intlValues[i] = val; } int len = values.Length; Boolean caseInsensitive = false; for (int i = 0; i < len; i++) { if (intlValues[i].Length != 0 && intlValues[i].ToLower() == intlValues[i].ToUpper()) caseInsensitive = true; } sc.Clear(); cnt = intlValues.Length; sc.AddRange(intlValues); if (sc.Count != intlValues.Length) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", sc.Count, intlValues.Length)); } for (int i = cnt; i < cnt; i++) { sc[i] = intlValues[cnt - i - 1]; if (String.Compare(sc[i], intlValues[cnt - i - 1]) != 0) { Assert.False(true, string.Format("Error, actual item is {1} instead of {2}", i, sc[i], intlValues[cnt - i - 1])); } } // // [] Case sensitivity // string intlStrUpper = intlValues[0]; intlStrUpper = intlStrUpper.ToUpper(); string intlStrLower = intlStrUpper.ToLower(); sc.Clear(); sc.AddRange(values); sc.Add(intlStrUpper); if (sc.Count != values.Length + 1) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", sc.Count, values.Length + 1)); } // verify that Item returns intl string in a case sensitive way // // set simple to intl lower // sc[0] = intlStrLower; if (!caseInsensitive && (String.Compare(sc[0], intlStrUpper) == 0)) { Assert.False(true, string.Format("Error, set to uppercase when should have to lower")); } if (String.Compare(sc[0], intlStrLower) != 0) { Assert.False(true, string.Format("Error, didn't set to lower")); } // // set intlUpper to intl lower // sc[sc.Count - 1] = intlStrLower; if (!caseInsensitive && (String.Compare(sc[sc.Count - 1], intlStrUpper) == 0)) { Assert.False(true, string.Format("Error, didn't set from uppercase to lowercase ")); } if (String.Compare(sc[sc.Count - 1], intlStrLower) != 0) { Assert.False(true, string.Format("Error, didn't set to lower")); } // // set to null - it's legal - return value will be null // [] set Item() to null // if (sc.Count < 1) sc.AddRange(values); // // set middle item to null // int ind = sc.Count / 2; sc[ind] = null; if (sc[ind] != null) { Assert.False(true, string.Format("Error, failed to set to null")); } if (!sc.Contains(null)) { Assert.False(true, string.Format("Error, Contains() didn't return true for null")); } if (sc.IndexOf(null) != ind) { Assert.False(true, string.Format("Error, IndexOf() returned {0} instead of {1}", sc.IndexOf(null), ind)); } // // [] Invalid parameter - for filled collection // sc.Clear(); sc.AddRange(intlValues); Assert.Throws<ArgumentOutOfRangeException>(() => { sc[-1] = intlStrUpper; }); Assert.Throws<ArgumentOutOfRangeException>(() => { sc[sc.Count] = intlStrUpper; }); Assert.Throws<ArgumentOutOfRangeException>(() => { sc[sc.Count + 1] = intlStrUpper; }); Assert.Throws<ArgumentOutOfRangeException>(() => { sc[sc.Count] = null; }); }
public StringCollection controlMatchingBetweenDataAndProfile(String dataFile, String profileFile) { StringCollection errors = new StringCollection(); CsvArchiveDocuments ad = new CsvArchiveDocuments(); if (traceActions) ad.setTracesWriter(tracesWriter); ad.loadFile(dataFile); /* StringCollection erreursDonnees = ad.getErrorsList(); if (erreursDonnees.Count != 0) { foreach (String st in erreursDonnees) { errors.Add(st); } } */ RngProfileController rpc = new RngProfileController(); if (traceActions) rpc.setTracesWriter(tracesWriter); rpc.controlProfileFile(profileFile); /* StringCollection erreursProfil = rpc.getErrorsList(); if (erreursProfil.Count != 0) { foreach (String st in erreursProfil) { errors.Add(st); } } */ String str; StringCollection tagsForKeys = ad.getTagsListForKeys(); StringCollection tagsForDocs = ad.getTagsListForDocuments(); StringCollection expectedTags = rpc.getExpectedTagsListList(); StringCollection expectedTagsForDocs = new StringCollection(); foreach (String st in expectedTags) { if (st.StartsWith("document: ")) { expectedTagsForDocs.Add(st.Substring(10)); } } foreach (String st in expectedTagsForDocs) { expectedTags.Remove("document: " + st); } StringCollection tagsForKeysModified = new StringCollection(); foreach (String st in tagsForKeys) { str = Regex.Replace(st, @"#KeywordContent\[#[0-9]+\]", "#KeywordContent"); tagsForKeysModified.Add(str); } StringCollection tagsForDocsModified = new StringCollection(); foreach (String st in tagsForDocs) { str = Regex.Replace(st, @"#KeywordContent(\[[^]]+\])?\[#[0-9]+\]", "#KeywordContent$1"); tagsForDocsModified.Add(str); } if (traceActions) { if (tagsForKeysModified.Count != 0) { tracesWriter.WriteLine("\ntagsForKeysModified"); foreach (String st in tagsForKeysModified) { tracesWriter.WriteLine(st); } } if (tagsForDocsModified.Count != 0) { tracesWriter.WriteLine("\ntagsForDocsModified"); foreach (String st in tagsForDocsModified) { tracesWriter.WriteLine(st); } } if (expectedTags.Count != 0) { tracesWriter.WriteLine("\nexpectedTags"); foreach (String st in expectedTags) { tracesWriter.WriteLine(st); } } if (expectedTagsForDocs.Count != 0) { tracesWriter.WriteLine("\nexpectedTagsForDocs"); foreach (String st in expectedTagsForDocs) { tracesWriter.WriteLine(st); } } tracesWriter.WriteLine(""); } // Test des clés foreach (String st in tagsForKeysModified) { str = Regex.Replace(st, @"\[#\d+\]", "[#1]"); str = Regex.Replace(str, @"#KeywordContent\[#[0-9]+\]", "#KeywordContent"); if (expectedTags.IndexOf(str) == -1) errors.Add("La clé '" + st + "' fournie par les données métier n'est pas attendue par le profil"); } // Test des documents foreach (String st in tagsForDocsModified) { str = Regex.Replace(st, @"\[#\d+\]", "[#1]"); str = Regex.Replace(str, @"#KeywordContent(\[[^]]+\])?\[#[0-9]+\]", "#KeywordContent$1"); if (expectedTagsForDocs.IndexOf(str) == -1) errors.Add("Le document typé par le tag '" + st + "' n'est pas attendu par le profil"); } // Test du profil foreach (String st in expectedTags) { if (tagsForKeysModified.IndexOf(st) == -1) { errors.Add("Dans le profil, le tag '" + st + "' ne trouve pas de correspondance dans les données métier"); } } foreach (String st in expectedTagsForDocs) { if (tagsForDocsModified.IndexOf(st) == -1) { errors.Add("Dans le profil, le tag de document '" + st + "' ne trouve pas de correspondance dans les données métier"); } } return errors; }
/// <summary> /// Tries to find and remove a word from the word list. /// </summary> /// <param name="wordList">The word list.</param> /// <param name="word">The word to find and remove.</param> /// <returns>Whether or not the word was found and removed.</returns> private static bool TryFindAndRemoveWord(StringCollection wordList, string word) { bool removed = false; int wordIndex = wordList.IndexOf(word); if (wordIndex >= 0) { wordList.RemoveAt(wordIndex); removed = true; } return removed; }
private static StringCollection GetFilteredFileList(DirectoryInfo sourceDirectory, ArrayList includes, ArrayList excludes) { StringCollection fileList = new StringCollection(); foreach (FileFilter fileFilter in includes) { FileInfo[] files = sourceDirectory.GetFiles(fileFilter.Mask); if (files.Length <= 0) { if (fileFilter.FailOnEmpty) GenError("File by mask '{0}' not found in directory '{1}' !", fileFilter.Mask, sourceDirectory.FullName); } else for (int i = 0; i < files.Length; ++i) { string fileFullName = files[i].FullName; int fileIndex = fileList.IndexOf(fileFullName); // Защита от дублирования if (fileIndex < 0) fileList.Add(fileFullName); else { Console.Error.WriteLine( "WixGen.exe : warning WGEN1002: File '{0}' already included.\r\nDetail info: Directory '{1}', Filter '{2}'\r\n", fileFullName, sourceDirectory.FullName, fileFilter.Mask); } } } foreach (FileFilter fileFilter in excludes) { FileInfo[] files = sourceDirectory.GetFiles(fileFilter.Mask); for (int i = 0; i < files.Length; ++i) { int fileIndex = fileList.IndexOf(files[i].FullName); if (fileIndex >= 0) fileList.RemoveAt(fileIndex); } } return fileList; }
public void Test01() { IntlStrings intl; StringCollection sc; // simple string values string[] values = { "", " ", "a", "aa", "text", " spaces", "1", "$%^#", "2222222222222222222222222", System.DateTime.Today.ToString(), Int32.MaxValue.ToString() }; int cnt = 0; // Count // initialize IntStrings intl = new IntlStrings(); // [] StringCollection is constructed as expected //----------------------------------------------------------------- sc = new StringCollection(); // [] Remove() from empty collection // for (int i = 0; i < values.Length; i++) { sc.Remove(values[i]); if (sc.Count != 0) { Assert.False(true, string.Format("Error, Remove changed Count for empty collection", i)); } } // [] Remove() from collection filled with simple strings // sc.Clear(); sc.AddRange(values); if (sc.Count != values.Length) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", sc.Count, values.Length)); } for (int i = 0; i < values.Length; i++) { // verify that collection contains all added items // if (!sc.Contains(values[i])) { Assert.False(true, string.Format("Error, doesn't contain {0} item", i)); } cnt = sc.Count; // Remove each item // sc.Remove(values[i]); if (sc.Count != cnt - 1) { Assert.False(true, string.Format("Error, didn't remove anything", i)); } if (sc.Contains(values[i])) { Assert.False(true, string.Format("Error, removed wrong item", i)); } } // // Intl strings // [] Remove() from collection filled with Intl strings // string[] intlValues = new string[values.Length]; // fill array with unique strings // for (int i = 0; i < values.Length; i++) { string val = intl.GetRandomString(MAX_LEN); while (Array.IndexOf(intlValues, val) != -1) val = intl.GetRandomString(MAX_LEN); intlValues[i] = val; } int len = values.Length; Boolean caseInsensitive = false; for (int i = 0; i < len; i++) { if (intlValues[i].Length != 0 && intlValues[i].ToLower() == intlValues[i].ToUpper()) caseInsensitive = true; } sc.Clear(); sc.AddRange(intlValues); if (sc.Count != intlValues.Length) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", sc.Count, intlValues.Length)); } for (int i = 0; i < intlValues.Length; i++) { // verify that collection contains all added items // if (!sc.Contains(intlValues[i])) { Assert.False(true, string.Format("Error, doesn't contain {0} item", i)); } cnt = sc.Count; // Remove each item // sc.Remove(intlValues[i]); if (sc.Count != cnt - 1) { Assert.False(true, string.Format("Error, didn't remove anything", i)); } if (sc.Contains(intlValues[i])) { Assert.False(true, string.Format("Error, removed wrong item", i)); } } // // duplicate strings // [] Remove() from filled collection with duplicate strings // sc.Clear(); string intlStr = intlValues[0]; sc.Add(intlStr); // index 0 sc.AddRange(values); sc.AddRange(intlValues); // second index values.Length + 1 cnt = values.Length + 1 + intlValues.Length; if (sc.Count != cnt) { Assert.False(true, string.Format("Error, count is {1} instead of {2}", sc.Count, cnt)); } // verify Index of newly added item // if (sc.IndexOf(intlStr) != 0) { Assert.False(true, string.Format("Error, IndexOf returned {0} instead of {1}", sc.IndexOf(intlStr), 0)); } // remove // sc.Remove(intlStr); if (!sc.Contains(intlStr)) { Assert.False(true, string.Format("Error, removed both duplicates")); } // second string should still be present if (sc.IndexOf(intlStr) != values.Length) { Assert.False(true, string.Format("Error, IndexOf returned {0} instead of {1}", sc.IndexOf(intlStr), values.Length)); } // verify that items were moved // for (int i = 0; i < values.Length; i++) { if (sc.IndexOf(values[i]) != i) { Assert.False(true, string.Format("Error, IndexOf {0} item returned {1} ", i, sc.IndexOf(values[i]))); } if (sc.IndexOf(intlValues[i]) != i + values.Length) { Assert.False(true, string.Format("Error, IndexOf {1} item returned {2} ", i, i + values.Length, sc.IndexOf(intlValues[i]))); } } // // [] Case sensitivity: search should be case-sensitive // sc.Clear(); sc.Add(intlStr.ToUpper()); sc.AddRange(values); sc.Add(intlStr.ToLower()); cnt = values.Length + 2; if (sc.Count != cnt) { Assert.False(true, string.Format("Error, count is {1} instead of {2} ", sc.Count, cnt)); } // remove lowercase item // intlStr = intlStr.ToLower(); cnt = sc.Count; sc.Remove(intlStr); if (sc.Count != cnt - 1) { Assert.False(true, string.Format("Error, didn't remove anything")); } if (!caseInsensitive && sc.Contains(intlStr)) { Assert.False(true, string.Format("Error, didn't remove lowercase ")); } // but should still contain Uppercase if (!sc.Contains(intlValues[0].ToUpper())) { Assert.False(true, string.Format("Error, removed uppercase ")); } // // remove item that is not in the collection // sc.Clear(); sc.AddRange(values); cnt = values.Length; if (sc.Count != cnt) { Assert.False(true, string.Format("Error, count is {1} instead of {2} ", sc.Count, cnt)); } // remove non-existing item // intlStr = "Hello"; cnt = sc.Count; sc.Remove(intlStr); if (sc.Count != cnt) { Assert.False(true, string.Format("Error, removed something")); } }
/// <summary> /// Updates the terrain toolbar with properties from the edit control. /// </summary> private void SyncTerrainToolbar() { this.toolStripTextBoxHeightLevel.TextChanged -= this.ToolStripTextBoxHeightLevel_TextChanged; this.toolStripComboBoxSeason.SelectedIndexChanged -= this.ToolStripComboBoxSeason_SelectedIndexChanged; this.toolStripButtonHideBaseSeasonTerrain.Click -= this.ToolStripButtonHideBaseSeasonTerrain_Click; this.toolStripButtonSelect.Click -= this.ToolStripButtonSelect_Click; this.toolStripButtonRaise.Click -= this.ToolStripButtonRaise_Click; this.toolStripButtonLower.Click -= this.ToolStripButtonLower_Click; this.toolStripButtonFlatten.Click -= this.ToolStripButtonFlatten_Click; this.toolStripButtonSmooth.Click -= this.ToolStripButtonSmooth_Click; this.toolStripTextBoxCursorSize.TextChanged -= this.ToolStripTextBoxCursorSize_TextChanged; this.toolStripTextBoxIntensity.TextChanged -= this.ToolStripTextBoxIntensity_TextChanged; this.toolStripButtonApplyTerrainType.Click -= this.ToolStripButtonApplyTerrainType_Click; this.toolStripComboBoxApplyTerrainType.SelectedIndexChanged -= this.ToolStripComboBoxApplyTerrainType_SelectedIndexChanged; if (this.toolStripComboBoxSeason.Items.Count == 0) { this.toolStripComboBoxSeason.Items.AddRange(SeasonExtensions.GetSortedList()); } if (this.toolStripComboBoxApplyTerrainType.Items.Count == 0) { this.toolStripComboBoxApplyTerrainType.Items.AddRange(TerrainTypeExtensions.GetSortedList()); } this.toolStripButtonHideBaseSeasonTerrain.Checked = this.terrainControl.HideBaseSeasonTerrain; this.toolStripTextBoxHeightLevel.Text = this.terrainControl.CurrentHeightLevel.ToString(CultureInfo.InvariantCulture); this.toolStripTextBoxCursorSize.Text = this.terrainControl.CursorSize.ToString(CultureInfo.InvariantCulture); this.toolStripTextBoxIntensity.Text = this.terrainControl.Intensity.ToString(CultureInfo.InvariantCulture); this.toolStripButtonSelect.Checked = this.terrainControl.TerrainTool.IsSet(TerrainControlTools.Select); this.toolStripButtonRaise.Checked = this.terrainControl.TerrainTool.IsSet(TerrainControlTools.Raise); this.toolStripButtonLower.Checked = this.terrainControl.TerrainTool.IsSet(TerrainControlTools.Lower); this.toolStripButtonFlatten.Checked = this.terrainControl.TerrainTool.IsSet(TerrainControlTools.Flatten); this.toolStripButtonSmooth.Checked = this.terrainControl.TerrainTool.IsSet(TerrainControlTools.Smooth); this.toolStripButtonApplyTerrainType.Checked = this.terrainControl.TerrainTool.IsSet(TerrainControlTools.TerrainType); this.toolStripTextBoxCursorSize.Enabled = !this.terrainControl.TerrainTool.IsSet(TerrainControlTools.Select) || this.terrainControl.TerrainTool.IsSet(TerrainControlTools.TerrainType); this.toolStripTextBoxIntensity.Enabled = !this.terrainControl.TerrainTool.IsSet(TerrainControlTools.Select); this.toolStripComboBoxApplyTerrainType.Enabled = this.terrainControl.TerrainTool.IsSet(TerrainControlTools.TerrainType); StringCollection seasons = new StringCollection(); seasons.AddRange(SeasonExtensions.GetSortedList()); this.toolStripComboBoxSeason.SelectedIndex = seasons.IndexOf(this.terrainControl.CurrentSeason.ToString()); StringCollection terrainTypes = new StringCollection(); terrainTypes.AddRange(TerrainTypeExtensions.GetSortedList()); this.toolStripComboBoxApplyTerrainType.SelectedIndex = terrainTypes.IndexOf(this.terrainControl.ApplyTerrainType.ToString()); this.toolStripTextBoxHeightLevel.TextChanged += this.ToolStripTextBoxHeightLevel_TextChanged; this.toolStripComboBoxSeason.SelectedIndexChanged += this.ToolStripComboBoxSeason_SelectedIndexChanged; this.toolStripButtonHideBaseSeasonTerrain.Click += this.ToolStripButtonHideBaseSeasonTerrain_Click; this.toolStripButtonSelect.Click += this.ToolStripButtonSelect_Click; this.toolStripButtonRaise.Click += this.ToolStripButtonRaise_Click; this.toolStripButtonLower.Click += this.ToolStripButtonLower_Click; this.toolStripButtonFlatten.Click += this.ToolStripButtonFlatten_Click; this.toolStripButtonSmooth.Click += this.ToolStripButtonSmooth_Click; this.toolStripTextBoxCursorSize.TextChanged += this.ToolStripTextBoxCursorSize_TextChanged; this.toolStripTextBoxIntensity.TextChanged += this.ToolStripTextBoxIntensity_TextChanged; this.toolStripButtonApplyTerrainType.Click += this.ToolStripButtonApplyTerrainType_Click; this.toolStripComboBoxApplyTerrainType.SelectedIndexChanged += this.ToolStripComboBoxApplyTerrainType_SelectedIndexChanged; }
public int LoadSelections (String [] Selectionen, int NumberOfEntries, DateTime FromDate, DateTime ToDate, String Format) { String SelectStatementPart; if ((Selectionen.Length == 0) || ((Selectionen.Length == 1) && (Selectionen [0] == "All"))) { SelectStatementPart = ""; } else { SelectStatementPart = ""; foreach (String Entry in Selectionen) { if (SelectStatementPart == "") SelectStatementPart += "and ((ZuordnungName = '" + Basics.RemoveMaliciousSQLContent (Entry) + "') "; else SelectStatementPart += " or (ZuordnungName = '" + Basics.RemoveMaliciousSQLContent (Entry) + "') "; } SelectStatementPart += ") "; } String SelectStatement = ""; if ((Format == "") || (Format == "Full")) { if (NumberOfEntries > 0) SelectStatement = String.Format (CVM.CommonValues.SELECT_ARCHIVE_ENTRIES, "top (" + Convert.ToString (NumberOfEntries + 1) + ")", ToDate.ToString ("yyyy.MM.dd HH:mm:ss"), SelectStatementPart); else SelectStatement = String.Format (CVM.CommonValues.SELECT_ARCHIVE_ENTRIES, "", ToDate.ToString ("yyyy.MM.dd HH:mm:ss"), SelectStatementPart); } if (Format == "Grid") { SelectStatement = String.Format (CVM.CommonValues.SELECT_ARCHIVE_ENTRIES_LIST, ToDate.ToString ("yyyy.MM.dd HH:mm:ss"), SelectStatementPart); } try { m_ArchivDataSet = WPMediaDataBase.GetCommonDataSet (SelectStatement); } catch (Exception Exc) { String Reason = Exc.ToString(); return 0; } if (m_ArchivDataSet == null) return 0; if (m_ArchivDataSet.Tables ["BeitraegeAusArchiv"] == null) return 0; int NumberOfReadedEntries = m_ArchivDataSet.Tables ["BeitraegeAusArchiv"].Rows.Count; if (m_ArchivDataSet.Tables ["BeitraegeAusArchiv"].Rows.Count > NumberOfEntries) m_MoreEntriesAvailable = true; StringCollection UniqueBeitrag = new StringCollection (); foreach (DataRow Row in m_ArchivDataSet.Tables ["BeitraegeAusArchiv"].Rows) { String BeitragID = Row ["BeitragID"].ToString (); if (UniqueBeitrag.IndexOf (BeitragID) == -1) { UniqueBeitrag.Add (BeitragID); } else { Row.Delete (); } } m_ArchivDataSet.Tables ["BeitraegeAusArchiv"].AcceptChanges (); return m_ArchivDataSet.Tables ["BeitraegeAusArchiv"].Rows.Count; }
protected string extractUrlFromSwfHtml(string swfHtml) { try { StringCollection videoURLsBrut = new StringCollection(); StringCollection videoURLs = new StringCollection(); String[] separateur = new String[1]; StringCollection paramNames; separateur[0] = Settings.Default.separateurUrlYoutube; int index = -1; swfHtml = swfHtml.Substring(swfHtml.IndexOf(Settings.Default.debutUrlYoutube) + Settings.Default.debutUrlYoutube.Length); swfHtml = swfHtml.Substring(swfHtml.IndexOf(separateur[0]) + separateur[0].Length); swfHtml = swfHtml.Substring(0, swfHtml.IndexOf(Settings.Default.finSwfHtmlRelevant)); paramNames = GetAllParamNames(swfHtml); videoURLsBrut.AddRange(swfHtml.Split(separateur, StringSplitOptions.RemoveEmptyEntries)); foreach (String chaine in videoURLsBrut) { if (chaine.StartsWith("http")) { String videoUrl = chaine.Trim(); separateur[0] = ","; videoUrl = RemoveExtraParams(videoUrl, Settings.Default.paramNamesToRemoveYoutube.Split(separateur, StringSplitOptions.RemoveEmptyEntries)); int indexLastComa = chaine.LastIndexOf(","); if (indexLastComa == videoUrl.Length - 1) videoUrl = videoUrl.Substring(0, indexLastComa); videoURLs.Add(videoUrl); } } int currentTagPriorite = 998; foreach (String url in videoURLs) { int itagIndex = url.IndexOf(Settings.Default.itagParam); if (itagIndex != -1) { itagIndex += Settings.Default.itagParam.Length; int indexSeparator = url.IndexOf(Settings.Default.paramSeparator, itagIndex); String itagString = url.Substring(itagIndex, indexSeparator - itagIndex); int itag = Convert.ToInt32(itagString); int priorite = manager.getPrioriteFromFormatTag(itag); if (priorite < currentTagPriorite) { currentTagPriorite = priorite; index = videoURLs.IndexOf(url); } } } /*separateur[0] = ","; String resultUrl = RemoveExtraParams(videoURLs[index], null);*/ return videoURLs[index]; //Settings.Default.paramNamesToRemoveYoutube.Split(separateur, StringSplitOptions.RemoveEmptyEntries)); /* int nombreParamNamesAEnlever = (Settings.Default.paramNamesToRemoveYoutube.Split(separateur, StringSplitOptions.RemoveEmptyEntries)).Length; for (int i = 0; i < nombreParamNamesAEnlever; i++) { paramNames.RemoveAt(paramNames.Count - 1); } return videoURLs[index].Substring(0, GetIndexFinParams(videoURLs[index], paramNames)); * */ } catch (Exception ex) { AddErrorMsg("YoutubeDownload.extractUrlFromSwfHtml swfHtml= " + swfHtml, ex); return null; } }
public void Test01() { IntlStrings intl; StringCollection sc; // simple string values string[] values = { "", " ", "a", "aa", "text", " spaces", "1", "$%^#", "2222222222222222222222222", System.DateTime.Today.ToString(), Int32.MaxValue.ToString() }; // [] initialize IntStrings intl = new IntlStrings(); // [] StringCollection is constructed as expected //----------------------------------------------------------------- sc = new StringCollection(); // [] RemoveAt() for empty collection // if (sc.Count > 0) sc.Clear(); Assert.Throws<ArgumentOutOfRangeException>(() => { sc.RemoveAt(0); }); // [] RemoveAt() on filled collection // sc.Clear(); sc.AddRange(values); if (sc.Count != values.Length) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", sc.Count, values.Length)); } sc.RemoveAt(0); if (sc.Count != values.Length - 1) { Assert.False(true, string.Format("Error, Count returned {0} instead of {1}", sc.Count, values.Length - 1)); } if (sc.Contains(values[0])) { Assert.False(true, string.Format("Error, removed wrong item")); } // check that all init items were moved for (int i = 0; i < values.Length; i++) { if (sc.IndexOf(values[i]) != i - 1) { Assert.False(true, string.Format("Error, IndexOf returned {1} instead of {2}", i, sc.IndexOf(values[i]), i - 1)); } } sc.Clear(); sc.AddRange(values); if (sc.Count != values.Length) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", sc.Count, values.Length)); } sc.RemoveAt(values.Length - 1); if (sc.Count != values.Length - 1) { Assert.False(true, string.Format("Error, Count returned {0} instead of {1}", sc.Count, values.Length - 1)); } if (sc.Contains(values[values.Length - 1])) { Assert.False(true, string.Format("Error, removed wrong item")); } // check that all init items were moved for (int i = 0; i < values.Length - 1; i++) { if (sc.IndexOf(values[i]) != i) { Assert.False(true, string.Format("Error, IndexOf returned {1} instead of {2}", i, sc.IndexOf(values[i]), i)); } } sc.Clear(); sc.AddRange(values); if (sc.Count != values.Length) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", sc.Count, values.Length)); } sc.RemoveAt(values.Length / 2); if (sc.Count != values.Length - 1) { Assert.False(true, string.Format("Error, Count returned {0} instead of {1}", sc.Count, values.Length - 1)); } if (sc.Contains(values[values.Length / 2])) { Assert.False(true, string.Format("Error, removed wrong item")); } // check that all init items were moved for (int i = 0; i < values.Length; i++) { int expected = i; if (i == values.Length / 2) expected = -1; else if (i > values.Length / 2) expected = i - 1; if (sc.IndexOf(values[i]) != expected) { Assert.False(true, string.Format("Error, IndexOf returned {1} instead of {2}", i, sc.IndexOf(values[i]), expected)); } } // // [] RemoveAt() on collection with identical items // sc.Clear(); string intlStr = intl.GetRandomString(MAX_LEN); sc.Add(intlStr); // index 0 sc.AddRange(values); sc.Add(intlStr); // second index values.Length + 1 if (sc.Count != values.Length + 2) { Assert.False(true, string.Format("Error, count is {1} instead of {2}", sc.Count, values.Length + 2)); } // remove // sc.RemoveAt(values.Length + 1); if (!sc.Contains(intlStr)) { Assert.False(true, string.Format("Error, removed both duplicates")); } // second string should still be present if (sc.IndexOf(intlStr) != 0) { Assert.False(true, string.Format("Error, removed 1st instance")); } // // [] Invalid parameter // sc.Clear(); sc.AddRange(values); Assert.Throws<ArgumentOutOfRangeException>(() => { sc.RemoveAt(-1); }); sc.Clear(); sc.AddRange(values); Assert.Throws<ArgumentOutOfRangeException>(() => { sc.RemoveAt(sc.Count); }); sc.Clear(); sc.AddRange(values); Assert.Throws<ArgumentOutOfRangeException>(() => { sc.RemoveAt(sc.Count + 1); }); }
public void Test01() { IntlStrings intl; StringCollection sc; // simple string values string[] values = { "", " ", "a", "aa", "text", " spaces", "1", "$%^#", "2222222222222222222222222", System.DateTime.Today.ToString(), Int32.MaxValue.ToString() }; int cnt = 0; // Count // initialize IntStrings intl = new IntlStrings(); // [] StringCollection is constructed as expected //----------------------------------------------------------------- sc = new StringCollection(); // [] for empty collection // for (int i = 0; i < values.Length; i++) { if (sc.IndexOf(values[i]) != -1) { Assert.False(true, string.Format("Error, returned {1} for empty collection", i, sc.IndexOf(values[i]))); } } // // [] add simple strings and verify IndexOf() cnt = sc.Count; sc.AddRange(values); if (sc.Count != values.Length) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", sc.Count, values.Length)); } for (int i = 0; i < values.Length; i++) { // verify that collection contains all added items // if (sc.IndexOf(values[i]) != i) { Assert.False(true, string.Format("Error, IndexOf returned {1} instead of {0}", i, sc.IndexOf(values[i]))); } } // // Intl strings // [] add Intl strings and verify IndexOf() // string[] intlValues = new string[values.Length]; // fill array with unique strings // for (int i = 0; i < values.Length; i++) { string val = intl.GetRandomString(MAX_LEN); while (Array.IndexOf(intlValues, val) != -1) val = intl.GetRandomString(MAX_LEN); intlValues[i] = val; } int len = values.Length; Boolean caseInsensitive = false; for (int i = 0; i < len; i++) { if (intlValues[i].Length != 0 && intlValues[i].ToLower() == intlValues[i].ToUpper()) caseInsensitive = true; } cnt = sc.Count; sc.AddRange(intlValues); if (sc.Count != (cnt + intlValues.Length)) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", sc.Count, cnt + intlValues.Length)); } for (int i = 0; i < intlValues.Length; i++) { // verify that collection contains all added items // if (sc.IndexOf(intlValues[i]) != values.Length + i) { Assert.False(true, string.Format("Error, IndexOf returned {1} instead of {2}", i, sc.IndexOf(intlValues[i]), values.Length + i)); } } // // [] duplicate strings // sc.Clear(); string intlStr = intlValues[0]; sc.Add(intlStr); // index 0 sc.AddRange(values); sc.AddRange(intlValues); // second index values.Length + 1 cnt = values.Length + 1 + intlValues.Length; if (sc.Count != cnt) { Assert.False(true, string.Format("Error, count is {1} instead of {2}", sc.Count, cnt)); } // verify Index of newly added item // if (sc.IndexOf(intlStr) != 0) { Assert.False(true, string.Format("Error, IndexOf returned {0} instead of {1}", sc.IndexOf(intlStr), 0)); } sc.Clear(); sc.AddRange(values); sc.AddRange(intlValues); // second index values.Length + 1 sc.Add(intlStr); // index values.Length + intlValues.Length cnt = values.Length + 1 + intlValues.Length; if (sc.Count != cnt) { Assert.False(true, string.Format("Error, count is {1} instead of {2}", sc.Count, cnt)); } // verify Index of newly added item // if (sc.IndexOf(intlStr) != values.Length) { Assert.False(true, string.Format("Error, IndexOf returned {0} instead of {1}", sc.IndexOf(intlStr), values.Length)); } // // [] Case sensitivity: search should be case-sensitive // sc.Clear(); sc.Add(intlValues[0].ToUpper()); sc.AddRange(values); sc.Add(intlValues[0].ToLower()); cnt = values.Length + 2; if (sc.Count != cnt) { Assert.False(true, string.Format("Error, count is {1} instead of {2} ", sc.Count, cnt)); } // look for lowercase item - should be (values.Length + 1) index // intlStr = intlValues[0].ToLower(); if (!caseInsensitive && (sc.IndexOf(intlStr) != values.Length + 1)) { Assert.False(true, string.Format("Error, IndexOf() returned {0} instead of {1} ", sc.IndexOf(intlStr), values.Length + 1)); } // string half_upper+half_lower should not be found // if (intlStr.Length > 2) { int mid = intlStr.Length / 2; String strTemp = intlStr.Substring(0, mid).ToLower() + intlStr.Substring(mid, intlStr.Length - mid).ToUpper(); if (strTemp != intlStr.ToUpper() && strTemp != intlStr.ToLower() && !caseInsensitive) { intlStr = strTemp; if (sc.IndexOf(intlStr) != -1) { Assert.False(true, string.Format("Error, IndexOf() returned {0} instead of -1 ", sc.IndexOf(intlStr))); } } } }
public void Test01() { IntlStrings intl; StringCollection sc; // simple string values string[] values = { "", " ", "a", "aa", "text", " spaces", "1", "$%^#", "2222222222222222222222222", System.DateTime.Today.ToString(), Int32.MaxValue.ToString() }; int cnt = 0; // Count int ind = 0; // Index // initialize IntStrings intl = new IntlStrings(); // [] StringCollection is constructed as expected //----------------------------------------------------------------- sc = new StringCollection(); // [] Add() simple strings // for (int i = 0; i < values.Length; i++) { cnt = sc.Count; sc.Add(values[i]); if (sc.Count != cnt + 1) { Assert.False(true, string.Format("Error, count is {1} instead of {2}", i, sc.Count, cnt + 1)); } // verify that collection contains newly added item // if (!sc.Contains(values[i])) { Assert.False(true, string.Format("Error, collection doesn't contain new item", i)); } // verify that item was added at the end // ind = sc.IndexOf(values[i]); if (ind != sc.Count - 1) { Assert.False(true, string.Format("Error, returned index {1} instead of {2}", i, ind, sc.Count - 1)); } // access the item // if (ind != -1) { if (String.Compare(sc[ind], values[i]) != 0) { Assert.False(true, string.Format("Error, returned item \"{1}\" instead of \"{2}\"", i, sc[ind], values[i])); } } } // // Intl strings // [] Add() Intl strings // string[] intlValues = new string[values.Length]; // fill array with unique strings // for (int i = 0; i < values.Length; i++) { string val = intl.GetRandomString(MAX_LEN); while (Array.IndexOf(intlValues, val) != -1) val = intl.GetRandomString(MAX_LEN); intlValues[i] = val; } for (int i = 0; i < intlValues.Length; i++) { cnt = sc.Count; sc.Add(intlValues[i]); if (sc.Count != cnt + 1) { Assert.False(true, string.Format("Error, count is {1} instead of {2}", i, sc.Count, cnt + 1)); } // verify that collection contains newly added item // if (!sc.Contains(intlValues[i])) { Assert.False(true, string.Format("Error, collection doesn't contain new item", i)); } // verify that item was added at the end // ind = sc.IndexOf(intlValues[i]); if (ind != sc.Count - 1) { Assert.False(true, string.Format("Error, returned index {1} instead of {2}", i, ind, sc.Count - 1)); } // access the item // if (ind != -1) { if (String.Compare(sc[ind], intlValues[i]) != 0) { Assert.False(true, string.Format("Error, returned item \"{1}\" instead of \"{2}\"", i, sc[ind], intlValues[i])); } } } // // add very long string // [] Add() very long string // cnt = sc.Count; string intlStr = intlValues[0]; while (intlStr.Length < 10000) intlStr += intlStr; sc.Add(intlStr); if (sc.Count != cnt + 1) { Assert.False(true, string.Format("Error, count is {1} instead of {2}", sc.Count, cnt + 1)); } // verify that collection contains newly added item // if (!sc.Contains(intlStr)) { Assert.False(true, string.Format("Error, collection doesn't contain new item")); } // verify that item was added at the end // ind = sc.IndexOf(intlStr); if (ind != sc.Count - 1) { Assert.False(true, string.Format("Error, returned index {1} instead of {2}", ind, sc.Count - 1)); } // access the item // if (ind != -1) { if (String.Compare(sc[ind], intlStr) != 0) { Assert.False(true, string.Format("Error, returned item \"{1}\" instead of \"{2}\"", sc[ind], intlStr)); } } }
/// <summary> /// Adds the passed hif name / version number to the list of hifs installed on /// the module. Both arrays must be the same length. /// </summary> /// <param name="hifs">The hifs to add</param> /// <param name="versions">The version numbers of the hifs</param> public void AddInstalledHakInfos(string[] hifs, float[] versions) { // Get the current values if any. string[] currentHifs; float[] currentVersions; GetInstalledHakInfos(out currentHifs, out currentVersions); // Create StringCollections for them so we can use IndexOf() for searching. StringCollection colHifs = new StringCollection(); colHifs.AddRange(currentHifs); ArrayList colVersions = new ArrayList(); colVersions.AddRange(currentVersions); // Check for duplicates, pruning duplicates out of the current list. foreach (string hif in hifs) { // Find the hif in the current values, if we don't find it then // skip it. int index = colHifs.IndexOf(hif); if (-1 == index) continue; // Remove it from the current list. colHifs.RemoveAt(index); colVersions.RemoveAt(index); } // Now build a string with all of the current hifs/version numbers then // all of the added hif/version numbers. System.Text.StringBuilder b = new StringBuilder(); for (int i = 0; i < colHifs.Count; i++) { if (b.Length > 0) b.Append(";"); b.AppendFormat("{0};{1}", colHifs[i], colVersions[i].ToString()); } for (int i = 0; i < hifs.Length; i++) { if (b.Length > 0) b.Append(";"); b.AppendFormat("{0};{1}", hifs[i], versions[i].ToString()); } // Get the schema for the field and get it, creating it if it is not there. // Then save the StringBuilder text as the field's value. GffFieldSchema schema = properties["installedhifs"]; GffExoStringField field = (GffExoStringField) GetField(schema); field.Value = b.ToString(); }
public bool ValueExists(string Section, string Ident) { StringCollection Idents = new StringCollection(); ReadSection(Section, Idents); return Idents.IndexOf(Ident) > -1; }
/// <summary> /// This method updates the cache and hak list properties in the module /// info, adding the passed array of strings to the appropriate property. /// Both of these lists consist of an array of structures with 1 string /// item in each struture. /// </summary> /// <param name="listTag">The property name for the list</param> /// <param name="entryTag">The property name for each string in the list's /// structures</param> /// <param name="structID">The structure ID of the structures in the list</param> /// <param name="stringType">The data type of the string in the list, either /// ExoString or ResRef</param> /// <param name="values">The array of strings to add, duplicates are pruned</param> private void UpdateList(string listTag, string entryTag, uint structID, GffFieldType stringType, string[] values) { // Get the array of elements in the list. GffListField listField = (GffListField) GetField(properties[listTag]); GffFieldCollection list = listField.Value; // Create a string collection containing lower case copies of all of // the strings. StringCollection strings = new StringCollection(); strings.AddRange(values); for (int i = 0; i < strings.Count; i ++) strings[i] = strings[i].ToLower(); // Make a first pass and eliminate any strings that are already // in the module. foreach (GffStructField field in list) { // Get the string entry for the value. GffFieldDictionary dict = field.Value; GffField structValue = dict[entryTag]; // Check to see if the hak is in the list of haks to add if it is // then remove it. int index = strings.IndexOf((string) structValue.Value); if (-1 != index) strings.RemoveAt(index); } // Now loop through all of the remaining strings and add them to the // beginning of the list. We walk the list backwards adding the items // to the beginning of the list's collection, so when we are done // all of the added items are in order at the FRONT of the list. for (int i = strings.Count - 1; i >= 0; i--) { // Create a ExoString field for the hak file name. GffField structValue = GffFieldFactory.CreateField(stringType); structValue.Value = strings[i]; // Create a GffStructField for the new list element and // save the exoString hak name in it. GffStructField listStruct = (GffStructField) GffFieldFactory.CreateField(GffFieldType.Struct); listStruct.StructureType = structID; listStruct.Value = new GffFieldDictionary(); listStruct.Value.Add(entryTag, structValue); // Add the structure to the list. list.Insert(0, listStruct); } }
public bool SectionExists(String Section) { StringCollection Sections = new StringCollection(); ReadSections(Sections); return Sections.IndexOf(Section) > -1; }
protected string extractUrlFromBrutSwfHtml(string swfHtml) { try { StringCollection videoURLsBrut = new StringCollection(); String[] separateurs = new String[1]; separateurs[0] = ","; int index = -1; swfHtml = swfHtml.Substring(swfHtml.IndexOf(Settings.Default.debutUrlYoutube) + Settings.Default.debutUrlYoutube.Length); swfHtml = swfHtml.Substring(swfHtml.IndexOf("\"") + 1); swfHtml = swfHtml.Substring(0, swfHtml.IndexOf(Settings.Default.finSwfHtmlRelevant)); videoURLsBrut.AddRange(swfHtml.Split(separateurs, StringSplitOptions.RemoveEmptyEntries)); int currentTagPriorite = 998; foreach (String chaine in videoURLsBrut) { String temp = chaine.Replace("\\u0026", "&"); int itagIndex = temp.IndexOf(Settings.Default.itagParam); if (itagIndex != -1) { itagIndex += Settings.Default.itagParam.Length; int indexSeparator = temp.IndexOf("&", itagIndex); String itagString; if (indexSeparator == -1) itagString = temp.Substring(itagIndex); else itagString = temp.Substring(itagIndex, indexSeparator - itagIndex); int itag = Convert.ToInt32(itagString); int priorite = manager.getPrioriteFromFormatTag(itag); if (priorite < currentTagPriorite) { currentTagPriorite = priorite; index = videoURLsBrut.IndexOf(chaine); } } } if (index != -1) { String chaine = videoURLsBrut[index].Replace("\\u0026", "&"); int indexDebutSignature = chaine.IndexOf(Settings.Default.youtubeSignatureParam) + Settings.Default.youtubeSignatureParam.Length; int indexFinSignature = chaine.IndexOf("&", indexDebutSignature); String signature; if (indexFinSignature == -1) signature = chaine.Substring(indexDebutSignature); else signature = chaine.Substring(indexDebutSignature, indexFinSignature - indexDebutSignature); int indexDebutUrl = chaine.IndexOf(Settings.Default.separateurUrlYoutube) + Settings.Default.separateurUrlYoutube.Length; int indexFinUrl = chaine.IndexOf("&", indexDebutUrl); String videoUrl; if (indexFinUrl == -1) videoUrl = chaine.Substring(indexDebutUrl); else videoUrl = chaine.Substring(indexDebutUrl, indexFinUrl - indexDebutUrl); videoUrl = CleanASCIICoding(videoUrl) + "&" + Settings.Default.youtubeSignatureParamOut + "=" + signature; return videoUrl; } else { AddInfoMsg("YoutubeDownload.extractUrlFromBrutSwfHtml index = -1 for swfHtml= " + swfHtml); return null; } } catch (Exception ex) { AddErrorMsg("YoutubeDownload.extractUrlFromSwfHtml swfHtml= " + swfHtml, ex); return null; } }
/// <summary> /// Remove an element from an array by value and optionally a number of elements after it. /// </summary> /// <param name="array">The array to remove the value from</param> /// <param name="value">The value to remove</param> /// <param name="count">The number of elements after the value to remove aswell</param> /// <returns>An array without the value</returns> public static string[] RemoveParameter(string[] array, string value, int count) { if (Array.IndexOf(array, value) < 0) return array; else { StringCollection coll = new StringCollection(); coll.AddRange(array); int ind = coll.IndexOf(value); for (int i = ind + count; i >= ind; i--) coll.RemoveAt(ind); string[] output = new string[coll.Count]; coll.CopyTo(output, 0); return output; } }
public void AddRecentlyUsedFile(FileInfo newFile) { StringCollection recent = new StringCollection(); recent.AddRange(data.RecentOpenedFiles); while(recent.IndexOf(newFile.FullName) >= 0) { recent.Remove(newFile.FullName); } recent.Insert(0, newFile.FullName); while (recent.Count > 16) { recent.RemoveAt(16); } string[] result = new string[recent.Count]; recent.CopyTo(result, 0); data.RecentOpenedFiles = result; }
/// <summary> /// Extract flags, named and numbered parameters from a string array of arguments /// </summary> /// <param name="named">The found named parameters</param> /// <param name="numbered">The found numbered parameters</param> /// <param name="input">The arguments</param> /// <param name="flags">Allowed flags to find</param> public static void ExtractParameters(out StringDictionary named, out string[] numbered, string[] input, string[] flags) { named = new StringDictionary(); StringCollection numberedColl = new StringCollection(); StringCollection args = new StringCollection(); args.AddRange(input); // Pull out flags first if (flags != null) { for (int i = 0; i < flags.Length; i++) { int ind = -1; if ((ind = args.IndexOf("-" + flags[i])) >= 0) { named.Add(flags[i], string.Empty); // args.RemoveAt(ind); args[ind] = null; } } } // pull out named parameters StringEnumerator e = args.GetEnumerator(); string name = string.Empty; while (e.MoveNext()) { if (e.Current != null) { if (name != string.Empty) { string nextname = string.Empty; string value = e.Current; if (value == null) value = string.Empty; if (value.StartsWith("-") && value.Length > 1) { nextname = value.Substring(1); value = string.Empty; } if (value.StartsWith("\\-")) value = "-" + value.Substring(2); named.Add(name, value); if (nextname != string.Empty) name = nextname; else name = string.Empty; } else if (e.Current.StartsWith("-") && e.Current.Length > 1) name = e.Current.Substring(1); else { string value = e.Current; if (value.StartsWith("\\-")) value = "-" + value.Substring(2); numberedColl.Add(value); } } else { if (name != string.Empty) { named.Add(name, string.Empty); name = string.Empty; } } } if (name != string.Empty) named.Add(name, string.Empty); // Pull out numbered parameters numbered = new string[numberedColl.Count]; numberedColl.CopyTo(numbered, 0); }
void LightAndRunScene(string sceneName) { string vsceneName = Path.ChangeExtension(Path.GetFileName(sceneName), ".vscene"); DeleteLitFileForScene(sceneName); // before the scene starts CommonSubtestInit(sceneName); int iFrameCount = 2000; VisionEngineManager em = (VisionEngineManager)EditorManager.EngineManager; StringCollection names = new StringCollection(); em.GetReplacementRenderLoopEffects(names); int iLightShading = names.IndexOf("Lighting Only"); Assert.IsTrue(iLightShading >= 0, "Lighting only shading not available"); // render frames EditorManager.Scene.ResetStaticLighting(); for (int i = 0; i < iFrameCount; i++) { EditorManager.EngineManager.WriteText2D(10.0f, 10.0f, "Unlit version of the scene", VisionColors.White); EditorManager.ActiveView.UpdateView(true); } // get the currently set lighting tool (might be Beast or something) IStaticLightingTool lt = EditorManager.LightingTool; // set vLux as the current tool EditorManager.LightingTool = new VLux.VLuxLightingTool (); Assert.IsTrue(EditorApp.Scene.UpdateStaticLighting(false, null, true)); // without dialog // reset to the original lighting tool EditorManager.LightingTool = lt; for (int i = 0; i < iFrameCount; i++) { EditorManager.EngineManager.WriteText2D(10.0f, 10.0f, "..after vLux lighting", VisionColors.White); EditorManager.ActiveView.UpdateView(true); } em.SetReplacementRenderLoopEffect(iLightShading); for (int i = 0; i < iFrameCount; i++) { EditorManager.EngineManager.WriteText2D(10.0f, 10.0f, "..after vLux lighting light shading only", VisionColors.White); EditorManager.ActiveView.UpdateView(true); } em.SetReplacementRenderLoopEffect(-1); // now export and see whether projector looks identically EditorManager.Scene.ExportScene(null, null); EditorManager.Scene.Close(); TestManager.Helpers.LoadExportedScene(vsceneName); for (int i = 0; i < iFrameCount; i++) { EditorManager.EngineManager.WriteText2D(10.0f, 10.0f, "This is the exported version", VisionColors.White); EditorManager.ActiveView.UpdateView(true); } TestManager.Helpers.CloseExportedScene(); // reload the scene CommonSubtestInit(sceneName); // render frames EditorManager.Scene.ResetStaticLighting(); for (int i = 0; i < iFrameCount; i++) { EditorManager.EngineManager.WriteText2D(10.0f, 10.0f, "Unlit version of the scene (again)", VisionColors.White); EditorManager.ActiveView.UpdateView(true); } // export again to restore SVN files EditorManager.Scene.ExportScene(null, null); CommonSubtestDeInit(); }
/// <summary> /// The process button. /// </summary> /// <param name="indexOfUserData"> /// The index of user data. /// </param> /// <param name="indexOfString"> /// The index of string. /// </param> /// <param name="attributes"> /// The attributes. /// </param> /// <param name="values"> /// The values. /// </param> private void ProcessButton(string indexOfUserData, string indexOfString, StringCollection attributes, StringCollection values) { if (attributes.Contains(indexOfUserData)) { var processName = values[attributes.IndexOf(indexOfUserData)]; var content = attributes.Contains(indexOfString) ? values[attributes.IndexOf(indexOfString)] : "Button ??"; if (!Utilities.IsNumber(processName)) { DebugViewModel.Instance.ProcessAnalysisViewModel.LoadProcessFromExpression( SourceDefinition.Button, SourceDefinition.Process, processName, this, content); } } }
public void Test01() { IntlStrings intl; StringCollection sc; // simple string values string[] values = { "", " ", "a", "aa", "text", " spaces", "1", "$%^#", "2222222222222222222222222", System.DateTime.Today.ToString(), Int32.MaxValue.ToString() }; // initialize IntStrings intl = new IntlStrings(); // [] StringCollection is constructed as expected //----------------------------------------------------------------- sc = new StringCollection(); // [] Insert into empty collection // for (int i = 0; i < values.Length; i++) { if (sc.Count > 0) sc.Clear(); sc.Insert(0, values[i]); if (sc.Count != 1) { Assert.False(true, string.Format("Error, Count {1} instead of 1", i, sc.Count)); } if (!sc.Contains(values[i])) { Assert.False(true, string.Format("Error, doesn't contain just inserted item", i)); } } // // [] Insert into filled collection sc.Clear(); sc.AddRange(values); if (sc.Count != values.Length) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", sc.Count, values.Length)); } // string to insert string val = intl.GetRandomString(MAX_LEN); sc.Insert(0, val); if (sc.Count != values.Length + 1) { Assert.False(true, string.Format("Error, Count returned {0} instead of {1}", sc.Count, values.Length + 1)); } if (sc.IndexOf(val) != 0) { Assert.False(true, string.Format("Error, IndexOf returned {0} instead of {1}", sc.IndexOf(val), 0)); } // check that all init items were moved for (int i = 0; i < values.Length; i++) { if (sc.IndexOf(values[i]) != i + 1) { Assert.False(true, string.Format("Error, IndexOf returned {1} instead of {2}", i, sc.IndexOf(values[i]), i + 1)); } } sc.Clear(); sc.AddRange(values); if (sc.Count != values.Length) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", sc.Count, values.Length)); } sc.Insert(values.Length, val); if (sc.Count != values.Length + 1) { Assert.False(true, string.Format("Error, Count returned {0} instead of {1}", sc.Count, values.Length + 1)); } if (sc.IndexOf(val) != values.Length) { Assert.False(true, string.Format("Error, IndexOf returned {0} instead of {1}", sc.IndexOf(val), values.Length)); } // check that all init items were moved for (int i = 0; i < values.Length; i++) { if (sc.IndexOf(values[i]) != i) { Assert.False(true, string.Format("Error, IndexOf returned {1} instead of {2}", i, sc.IndexOf(values[i]), i)); } } sc.Clear(); sc.AddRange(values); if (sc.Count != values.Length) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", sc.Count, values.Length)); } sc.Insert(values.Length / 2, val); if (sc.Count != values.Length + 1) { Assert.False(true, string.Format("Error, Count returned {0} instead of {1}", sc.Count, values.Length + 1)); } if (sc.IndexOf(val) != values.Length / 2) { Assert.False(true, string.Format("Error, IndexOf returned {0} instead of {1}", sc.IndexOf(val), values.Length / 2)); } // check that all init items were moved for (int i = 0; i < values.Length; i++) { int expected = i; if (i >= values.Length / 2) expected = i + 1; if (sc.IndexOf(values[i]) != expected) { Assert.False(true, string.Format("Error, IndexOf returned {1} instead of {2}", i, sc.IndexOf(values[i]), expected)); } } // // [] Invalid parameter // Assert.Throws<ArgumentOutOfRangeException>(() => { sc.Insert(-1, val); }); Assert.Throws<ArgumentOutOfRangeException>(() => { sc.Insert(sc.Count + 1, val); }); Assert.Throws<ArgumentOutOfRangeException>(() => { sc.Insert(sc.Count + 2, val); }); }
/// <summary> /// Insert a table into the project database . /// </summary> /// <param name="dataTable">Insert this table to the project database.</param> /// <param name="pathDB">Path to the database.</param> /// <param name="requiredCols">Collection of required columns.</param> public static bool CreateTable(DataTable dataTable, string pathDB, params IAccessColumn[] requiredCols) { //Validate the table; if (dataTable == null || string.IsNullOrEmpty(dataTable.TableName)) { //ActiveStatus.UpdateStatus(new DataStatus("The table is not valid and cannot be parsed. The table may not be named.", Environment.StackTrace, "Unknown Table")); return false; } //List of column names and indices; StringCollection colName = new StringCollection(); StringCollection primaryKey = new StringCollection(); StringCollection unique = new StringCollection(); //Check if the required columns exists; if (requiredCols != null) foreach (IAccessColumn col in requiredCols) { //Check if the column exists; if (!dataTable.Columns.Contains(col.ColumnName)) { //ActiveStatus.UpdateStatus(new DataStatus("The table is missing a required column and cannot be parsed. The names of the columns are case-sensitive.", Environment.StackTrace, dataTable.TableName)); return false; } //Store the name of the column; colName.Add(col.ColumnName); //Store the indices; if (col.PrimaryKey) primaryKey.Add(col.ColumnName); if (col.Unique) unique.Add(col.ColumnName); } //Remove the existing table; string sql = string.Format("drop table if exists {0};", dataTable.TableName); //Create the new table declaration; sql += string.Format("create table {0}(", dataTable.TableName); //Declare the columns; for (int i = 0; i < dataTable.Columns.Count; i++) { //Give priority to pre-defined columns; if (colName.Contains(dataTable.Columns[i].ColumnName)) sql += BuildColumnDefinition(requiredCols[colName.IndexOf(dataTable.Columns[i].ColumnName)]); else sql += BuildColumnDefinition(dataTable.Columns[i]); //Append a comma or close the bracket; if (i < dataTable.Columns.Count - 1) sql += ","; else { //Add constraints; if (primaryKey.Count > 0) { string[] sz = new string[primaryKey.Count]; primaryKey.CopyTo(sz, 0); sql += string.Format(",primary key ({0}) on conflict ignore", string.Join(",", sz).ToString()); } if (unique.Count > 0) { string[] sz = new string[unique.Count]; unique.CopyTo(sz, 0); sql += string.Format(",unique ({0}) on conflict ignore", string.Join(",", sz)); } //Close command; sql += ");"; } } //Establish the connection; SQLiteConnection conn = Query.OpenConnection(pathDB) as SQLiteConnection; //Begin a transaction; if (conn != null) using (SQLiteTransaction t = conn.BeginTransaction()) { //Create the table; SQLiteCommand cmd = new SQLiteCommand(sql, conn, t); try { cmd.ExecuteNonQuery(); } catch { return false; } //Import the data; foreach (DataRow dr in dataTable.Rows) { cmd.CommandText = string.Format("insert into {0} values(", dataTable.TableName); for (int i = 0; i < dataTable.Columns.Count; i++) { //Append the value; Type dataType = dataTable.Columns[i].DataType; if (colName.Contains(dataTable.Columns[i].ColumnName)) dataType = requiredCols[colName.IndexOf(dataTable.Columns[i].ColumnName)].Type; if (dataType == typeof(float) || dataType == typeof(double) || dataType == typeof(int)) cmd.CommandText += dr[i].ToString(); else cmd.CommandText += string.Format("'{0}'", dr[i].ToString()); //Append comma or else bracket at the end of the line; if (i < dataTable.Columns.Count - 1) cmd.CommandText += ","; else cmd.CommandText += ");"; } try { cmd.ExecuteNonQuery(); } catch { return false; } } //Close the transation; t.Commit(); //Return; //ActiveStatus.UpdateStatus(new DataStatus(string.Format("The table {0} was successfully parsed to: {1}", dataTable.TableName, pathDB), Environment.StackTrace, dataTable.TableName)); return true; } //Return false if the transaction was not initialized or else did not complete; return false; }