static void Main(string[] args) { System.Collections.Specialized.StringCollection stringCollection = new System.Collections.Specialized.StringCollection(); String[] Cities = new String[] { "Hyderabad", "Delhi", "Mumbai", "Banglore", "Chennai", "Kolkatta" }; stringCollection.AddRange(Cities); // Display the contents of the collection using foreach. Console.WriteLine("Displays the elements using foreach:"); foreach (String obj in stringCollection) { Console.WriteLine(" {0}", obj); } Console.WriteLine(); stringCollection.Add("Pune"); stringCollection.Add("Vizag"); stringCollection.Remove("Chennai"); Console.WriteLine("After Updating Collection:"); foreach (String obj in stringCollection) { Console.WriteLine(" {0}", obj); } Console.WriteLine(); // Copy the collection to a new array starting at index 0. String[] CitiesArray = new String[stringCollection.Count]; stringCollection.CopyTo(CitiesArray, 0); Console.WriteLine("The new array contains:"); for (int i = 0; i < CitiesArray.Length; i++) { Console.WriteLine(" [{0}] {1}", i, CitiesArray[i]); } Console.WriteLine(); Console.ReadLine(); }
private void UnregisterToCleanup(string artifactName, StringCollection cleanupList) { lock (_syncObject) { cleanupList.Remove(artifactName); } }
/// <summary> /// Adds a string to the list and positions it in the recent list /// </summary> /// <param name="text">The string that should be added</param> public void AddString(string text) { if (m_List.Contains(text)) { m_List.Remove(text); m_List.Insert(0, text); } else { if (m_List.Count == m_Capacity) { m_List.RemoveAt(m_List.Count - 1); } m_List.Insert(0, text); } }
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; }
private void OnInferParametersButtonClick(object sender, EventArgs e) { if (this._commandTextBox.Text.Trim().Length == 0) { UIServiceHelper.ShowError(base.ServiceProvider, System.Design.SR.GetString("SqlDataSourceQueryEditorForm_InferNeedsCommand")); } else { Parameter[] parameterArray = this._sqlDataSourceDesigner.InferParameterNames(this._dataConnection, this._commandTextBox.Text, this._commandType); if (parameterArray != null) { Parameter[] parameters = this._parameterEditorUserControl.GetParameters(); StringCollection strings = new StringCollection(); foreach (Parameter parameter in parameters) { strings.Add(parameter.Name); } bool flag = true; try { flag = SqlDataSourceDesigner.SupportsNamedParameters(SqlDataSourceDesigner.GetDbProviderFactory(this._dataConnection.ProviderName)); } catch { } if (flag) { List<Parameter> list = new List<Parameter>(); foreach (Parameter parameter2 in parameterArray) { if (!strings.Contains(parameter2.Name)) { list.Add(parameter2); } else { strings.Remove(parameter2.Name); } } this._parameterEditorUserControl.AddParameters(list.ToArray()); } else { List<Parameter> list2 = new List<Parameter>(); foreach (Parameter parameter3 in parameterArray) { list2.Add(parameter3); } foreach (Parameter parameter4 in parameters) { Parameter item = null; foreach (Parameter parameter6 in list2) { if (parameter6.Direction == parameter4.Direction) { item = parameter6; break; } } if (item != null) { list2.Remove(item); } } this._parameterEditorUserControl.AddParameters(list2.ToArray()); } } } }
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> /// This method is called by the ReversalEntriesText virtual handler when text may have changed in the /// property, in order to update the actual list of reversal entries appropriately. /// </summary> /// <param name="tssVal">The new string.</param> /// <param name="ws">The ws.</param> public void CommitReversalEntriesText(ITsString tssVal, int ws) { LexSenseReversalEntriesTextHandler vh = BaseVirtualHandler.GetInstalledHandler(m_cache, "LexSense", LexSenseReversalEntriesTextHandler.StandardFieldName) as LexSenseReversalEntriesTextHandler; Debug.Assert(vh != null, "The 'LexSenseReversalEntriesTextHandler' virtual handler has to be created at application startup now."); ITsString tssOld = vh.GetValue(m_hvo, ws); // The old and new values could be in another order, and this test won't catch that case. // That condition won't be fatal, however, so don't fret about it. if (tssOld.Equals(tssVal)) return; // no change has occurred string val = tssVal.Text; if (val == null) val = ""; // This will effectively cause any extant entries for the given 'ws' to be removed in the end. StringCollection formsColl = new StringCollection(); foreach (string form in val.Split(';')) { // These strings will be null, if there are two semi-colons together. // Or, it may be just whitespace, if it is '; ;'. if (form == null || form.Trim().Length == 0) continue; formsColl.Add(form.Trim()); } int[] senseEntries = ReversalEntriesRC.HvoArray; int originalSenseEntriesCount = senseEntries.Length; int indexId; DbOps.ReadOneIntFromCommand(m_cache, "SELECT id FROM ReversalIndex WHERE WritingSystem=?", ws, out indexId); ReversalIndex revIndex; if (indexId == 0) { // Create the missing reversal index instead of crashing. See LT-10186. ILgWritingSystem lgws = LgWritingSystem.CreateFromDBObject(m_cache, ws); IReversalIndex newIdx = m_cache.LangProject.LexDbOA.ReversalIndexesOC.Add(new ReversalIndex()); newIdx.WritingSystemRA = lgws; // Copy any and all alternatives from lgws.Name to newIdx.Name foreach (ILgWritingSystem lgwsLoop in m_cache.LanguageEncodings) { string lgsNameAlt = lgws.Name.GetAlternative(lgwsLoop.Hvo); if (lgsNameAlt != null && lgsNameAlt.Length > 0) newIdx.Name.SetAlternative(lgsNameAlt, lgws.Hvo); } revIndex = (ReversalIndex)newIdx; } else { revIndex = (ReversalIndex)CmObject.CreateFromDBObject(m_cache, indexId, false); } // We need the list of ReversalIndexEntries that this sense references, but which belong // to another reversal index. Those hvos, plus any entry hvos from the given 'ws' that are reused, // get put into 'survivingEntries'. Set<int> survivingEntries = new Set<int>(originalSenseEntriesCount + formsColl.Count); // 'entriesNeedingPropChangeBackRef' will hold the hvos of all ReversalIndexEntry objects that need to have // their 'ReferringSenses' virtual property (re)computed. // Any reversal index entry that gains or loses a reference will need this (re)computing. List<int> entriesNeedingPropChangeBackRef = new List<int>(originalSenseEntriesCount + formsColl.Count); foreach (int entryHvo in senseEntries) { // Use 'cheapo' FDO object maker, since it is supposed to all be in the cache already. ReversalIndexEntry rie = (ReversalIndexEntry)CmObject.CreateFromDBObject(m_cache, entryHvo, false); int wsIndex = 0; int hvoIndex = m_cache.GetOwnerOfObjectOfClass(rie.Hvo, ReversalIndex.kclsidReversalIndex); if (hvoIndex != 0) wsIndex = m_cache.GetIntProperty(hvoIndex, (int)ReversalIndex.ReversalIndexTags.kflidWritingSystem); if (wsIndex == ws) { string form = rie.LongName; if (formsColl.Contains(form)) { // Recycling an entry. survivingEntries.Add(rie.Hvo); formsColl.Remove(form); // Don't need to mess with it later on. } else { // It is being removed from the extant reference property, // so needs to recompute its back ref virtual handler. entriesNeedingPropChangeBackRef.Add(rie.Hvo); } } else { // These are all in some other ws, so they certainly must survive (cf. LT-3391). // Any entries that are reused will get added to this array later on. survivingEntries.Add(rie.Hvo); } } // Start Undoable section of code. m_cache.BeginUndoTask(Strings.ksUndoMakeRevEntries, Strings.ksRedoMakeRevEntries); ISilDataAccess sda = m_cache.MainCacheAccessor; IActionHandler acth = sda.GetActionHandler(); try { // add undo actions to reload the virtual handler and send prop changes to update displays if (acth != null) { List<PropChangedInfo> pciList = new List<PropChangedInfo>(); pciList.Add(new PropChangedInfo(m_hvo, vh.Tag, ws, 0, 0)); acth.AddAction(new PropChangedUndoAction(m_cache, true, PropChangeType.kpctNotifyAll, pciList)); acth.AddAction(new ReloadVirtualHandlerUndoAction(m_cache, true, vh, m_hvo, vh.Tag, ws)); } int cOldEntries = revIndex.EntriesOC.Count; foreach (string currentForm in formsColl) { int idRevEntry = revIndex.FindOrCreateReversalEntry(currentForm); entriesNeedingPropChangeBackRef.Add(idRevEntry); survivingEntries.Add(idRevEntry); } // Notify everyone, and his brother, about the changes done here. // PropChanged (1 of 3) Main: Replace main sense property with current set of entries. sda.Replace(m_hvo, (int)LexSense.LexSenseTags.kflidReversalEntries, 0, originalSenseEntriesCount, survivingEntries.ToArray(), survivingEntries.Count); sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll, m_hvo, (int)LexSense.LexSenseTags.kflidReversalEntries, 0, survivingEntries.Count, originalSenseEntriesCount); // remove entries from the index that are no longer valid foreach (int rieHvo in senseEntries) { if (!survivingEntries.Contains(rieHvo)) { // the entry is no longer a reversal entry for this sense ReversalIndexEntry rie = new ReversalIndexEntry(m_cache, rieHvo); if (rie.SenseIds.Count == 0) // the entry is longer a reversal entry for any sense revIndex.EntriesOC.Remove(rie); } } // PropChanged (2 of 3) Affected Entries: (Re)compute // on the virtual property of select reversal index entries. ReversalIndexEntry.ResetReferringSenses(m_cache, entriesNeedingPropChangeBackRef); // PropChanged (3 of 3) Index Entries: Simulate a complete replacement of the entries collection, // BUT only if new entries were added in this method. int cNewEntries = revIndex.EntriesOC.Count; if (cNewEntries > cOldEntries) { sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll, indexId, (int)ReversalIndex.ReversalIndexTags.kflidEntries, 0, cNewEntries, cOldEntries); } // add redo actions to reload the virtual handler and send prop changes to update displays if (acth != null) { acth.AddAction(new ReloadVirtualHandlerUndoAction(m_cache, false, vh, m_hvo, vh.Tag, ws)); List<PropChangedInfo> pciList = new List<PropChangedInfo>(); pciList.Add(new PropChangedInfo(m_hvo, vh.Tag, ws, 0, 0)); acth.AddAction(new PropChangedUndoAction(m_cache, false, PropChangeType.kpctNotifyAll, pciList)); } } finally { if (acth != null && Marshal.IsComObject(acth)) Marshal.ReleaseComObject(acth); } // End undoable section of code. m_cache.EndUndoTask(); }
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> /// Check for changed (or missing) files in the Extensions subdirectory (as /// compared to the corresponding "Available Plugins" subdirectory). /// </summary> /// <param name="paths"></param> /// <param name="pluginBaseDir"></param> /// <param name="extensionBaseDir"></param> private void UpdateExtensionFilesIfNeeded(StringCollection paths, string pluginBaseDir, string extensionBaseDir) { if (paths.Count == 0) return; List<string> obsoletePaths = new List<string>(); foreach (string extensionPath in paths) { string pluginPathname = Path.Combine(pluginBaseDir, extensionPath); pluginPathname = pluginPathname.Replace("Extensions", "Available Plugins"); if (File.Exists(pluginPathname)) { string extensionPathname = Path.Combine(extensionBaseDir, extensionPath); Debug.Assert(File.Exists(extensionPathname)); if (!FileUtils.AreFilesIdentical(pluginPathname, extensionPathname)) { string extensionDir = Path.GetDirectoryName(extensionPathname); Directory.Delete(extensionDir, true); Directory.CreateDirectory(extensionDir); File.Copy(pluginPathname, extensionPathname); File.SetAttributes(extensionPathname, FileAttributes.Normal); // plug-ins usually have localization strings-XX.xml files. foreach (string pluginFile in Directory.GetFiles(Path.GetDirectoryName(pluginPathname), "strings-*.xml")) { string extensionFile = Path.Combine(extensionDir, Path.GetFileName(pluginFile)); File.Copy(pluginFile, extensionFile); File.SetAttributes(extensionFile, FileAttributes.Normal); } } } else { obsoletePaths.Add(extensionPath); } } foreach (string badPath in obsoletePaths) paths.Remove(badPath); }
/// <summary> /// Decodes the commands and if necessary (re)starts the Attack. /// Works with the Captures from RegEx. /// </summary> /// <param name="cmds">the CaptureCollection containing a collection of commands</param> /// <param name="vals">the CaptureCollection containing a collection of values corresponding to the commands.</param> /// <returns>True if the commands were successfully loaded. False in case of any error.</returns> private bool parseOLUrlCmd(CaptureCollection cmds, CaptureCollection vals) { bool ret = false; if ((cmds.Count == vals.Count) && (cmds.Count > 0)) { StringCollection defaults = new StringCollection(); defaults.Add("targetip"); defaults.Add("targethost"); defaults.Add("timeout"); defaults.Add("subsite"); defaults.Add("message"); defaults.Add("port"); defaults.Add("method"); defaults.Add("threads"); defaults.Add("wait"); defaults.Add("random"); defaults.Add("speed"); defaults.Add("sockspthread"); defaults.Add("useget"); defaults.Add("usegzip"); int num = 0; bool isnum = false; bool restart = false; bool ctdwndn = false; string tval = ""; string tcmd = ""; for (int i = 0; i < cmds.Count; i++) { tval = vals[i].Value.Trim(); tcmd = cmds[i].Value.Trim(); defaults.Remove(tcmd); switch (tcmd.ToLowerInvariant()) { case "targetip": if (txtTargetIP.Text != tval) { txtTargetIP.Text = tval; LockOnIP(true); restart = true; } ret = true; break; case "targethost": if (txtTargetURL.Text != tval) { txtTargetURL.Text = tval; LockOnURL(true); restart = true; } ret = true; break; case "timeout": isnum = int.TryParse(tval, out num); if (isnum) { if (txtTimeout.Text != num.ToString()) { txtTimeout.Text = num.ToString(); restart = true; } } break; case "subsite": tval = Uri.UnescapeDataString(tval); if (txtSubsite.Text != tval) { txtSubsite.Text = tval; restart = true; } break; case "message": if (txtData.Text != tval) { txtData.Text = tval; restart = true; } break; case "port": if (txtPort.Text != tval) { txtPort.Text = tval; restart = true; } break; case "method": int index = cbMethod.FindString(tval); if (index != -1) { if (cbMethod.SelectedIndex != index) { cbMethod.SelectedIndex = index; restart = true; } } break; case "threads": if (Functions.ParseInt(tval, 1, 99, out num)) { if (txtThreads.Text != num.ToString()) { txtThreads.Text = num.ToString(); if(cbMethod.SelectedIndex >= 3) restart = true; } } break; case "wait": if (tval.ToLowerInvariant() == "true") { if (!chkWaitReply.Checked) restart = true; chkWaitReply.Checked = true; } else if (tval.ToLowerInvariant() == "false") { if (chkWaitReply.Checked) restart = true; chkWaitReply.Checked = false; } break; case "random": if (tval.ToLowerInvariant() == "true") { if (!chkRandom.Checked || !chkMsgRandom.Checked) restart = true; chkRandom.Checked = true; //HTTP chkMsgRandom.Checked = true; //TCP_UDP } else if (tval.ToLowerInvariant() == "false") { if (chkRandom.Checked || chkMsgRandom.Checked) restart = true; chkRandom.Checked = false; //HTTP chkMsgRandom.Checked = false; //TCP_UDP } break; case "speed": if (Functions.ParseInt(tval, tbSpeed.Minimum, tbSpeed.Maximum, out num)) { if (tbSpeed.Value != num) { tbSpeed.Value = num; restart = true; } } break; case "hivemind": string[] sp = tval.Split(':'); if (sp.Length > 1) { txtIRCserver.Text = sp[0]; string[] spt = sp[1].Split('#'); if (spt.Length > 1) { txtIRCport.Text = spt[0]; txtIRCchannel.Text = '#' + spt[1]; enableHive.Checked = true; return true; } } //ret = true; break; case "time": // might be not a bad idea to include a NTP-lookup before this? System.Globalization.CultureInfo ci = System.Globalization.CultureInfo.CurrentCulture; DateTime dtGo = DateTime.Parse(tval, ci.DateTimeFormat, System.Globalization.DateTimeStyles.AssumeUniversal); DateTime dtNow = DateTime.UtcNow; long tdiff = dtGo.Ticks - dtNow.Ticks; tdiff /= TimeSpan.TicksPerMillisecond; ret = true; tZergRush.Stop(); if (tdiff > 0) { tZergRush.Interval = (int)tdiff; tZergRush.Start(); this.Text = String.Format("{0} | U dun goofed | v. {1} | Next Raid: {2}", Application.ProductName, Application.ProductVersion, dtGo.ToString("MM-dd HH:mm")); restart = true; } else { ctdwndn = true; this.Text = String.Format("{0} | U dun goofed | v. {1}", Application.ProductName, Application.ProductVersion); } ret = true; break; case "useget": if (tval.ToLowerInvariant() == "true") chkUseGet.Checked = true; else if (tval.ToLowerInvariant() == "false") chkUseGet.Checked = false; break; case "usegzip": if (tval.ToLowerInvariant() == "true") chkAllowGzip.Checked = true; else if (tval.ToLowerInvariant() == "false") chkAllowGzip.Checked = false; break; case "sockspthread": if (Functions.ParseInt(tval, 1, 99, out num)) txtSLSpT.Text = num.ToString(); break; } } // let's reset the other values -.- for (int i = 0; i < defaults.Count; i++) { switch (defaults[i]) { case "targetip": txtTargetIP.Text = ""; break; case "targethost": txtTargetURL.Text = ""; break; case "timeout": txtTimeout.Text = "30"; break; case "subsite": txtSubsite.Text = "/"; break; case "message": txtData.Text = "U dun goofed"; break; case "port": txtPort.Text = "80"; break; case "method": int index = cbMethod.FindString("TCP"); if (index != -1) { cbMethod.SelectedIndex = index; } break; case "threads": txtThreads.Text = "10"; break; case "wait": chkWaitReply.Checked = true; break; case "random": chkRandom.Checked = false; chkMsgRandom.Checked = false; break; case "speed": tbSpeed.Value = 0; break; case "sockspthread": txtSLSpT.Text = "25"; break; case "useget": chkUseGet.Checked = false; break; case "usegzip": chkAllowGzip.Checked = false; break; } } if (restart) { Attack(false, false, true); if(!tZergRush.Enabled) Attack(false, true, true); } else if (ctdwndn && (cmdAttack.Text == AttackText)) { Attack(false, true, true); } if(!tZergRush.Enabled) this.Text = String.Format("{0} | U dun goofed | v. {1}", Application.ProductName, Application.ProductVersion); } return ret; }
// generic method to add a string to a history item private void AddSearchHistoryItem(StringCollection history, string toAdd) { // add the item to the find history if (history.Contains(toAdd)) { // remove it so it gets added at the top history.Remove(toAdd); } // make sure there is only 20 if (history.Count == historyLimit) { history.RemoveAt(historyLimit - 1); } history.Insert(0, toAdd); // update the drop down for the combobox ListStore store = new ListStore (typeof (string)); for (int i = 0; i < history.Count; i ++) store.AppendValues (history[i]); if (history == findHistory) searchPatternEntry.Completion.Model = store; else if( history == replaceHistory) replacePatternEntry.Completion.Model = store; }
// subtract existing rights from the ones we want to set public static string SubtractRights(string sExistingRights, string sNewRights) { StringCollection existingRights = new StringCollection(); existingRights.AddRange(sExistingRights.Split('|')); StringCollection newRights = new StringCollection(); newRights.AddRange(sNewRights.Split('|')); foreach (string sExistingRight in existingRights) { if (newRights.Contains(sExistingRight)) newRights.Remove(sExistingRight); } string sResult = ""; foreach (string sVal in newRights) sResult += sVal + "|"; return sResult; }
// generic method to add a string to a history item private void AddSearchHistoryItem(StringCollection history, string toAdd) { // add the item to the find history if (history.Contains(toAdd)) { // remove it so it gets added at the top history.Remove(toAdd); } // make sure there is only 20 if (history.Count == HISTORY_LIMIT) { history.RemoveAt(HISTORY_LIMIT - 1); } history.Insert(0, toAdd); // update the drop down for the combobox string[] stringArray = new string[history.Count]; history.CopyTo(stringArray, 0); if (history == findHistory) { searchPatternComboBox.SetPopdownStrings(stringArray); } else if( history == replaceHistory) { replacePatternComboBox.SetPopdownStrings(stringArray); } }
/// <summary> /// Checks to see if the string collection contains the key file, and if it does /// loads it and removes it from the collection. /// </summary> /// <param name="files">The list of files</param> /// <param name="file">The key file to process</param> private void ProcessFile(StringCollection files, string file) { if (files.Contains(file)) { // Create the key, add it to our collection, and remove the // file from the list as we've loaded it. Key key = new Key(file); keys.Add(key); files.Remove(file); } }
/// <summary> /// This returns a StringCollection with the names of recently used settings /// for the given report /// /// </summary> /// <returns>the list of names of recently used settings, which exist at the moment /// </returns> public StringCollection GetRecentlyUsedSettings() { StringCollection ReturnValue; String SettingName; StringCollection AvailableSettings; System.Int32 Counter; ReturnValue = new StringCollection(); if (("RptStg" + FReportName).Length > 32) { throw new Exception(String.Format("Report name ({0}) is too long for the settings", FReportName)); } // get names of recently used settings from the database ReturnValue = StringHelper.StrSplit(TUserDefaults.GetStringDefault("RptStg" + FReportName, ""), ","); // remove settings that are not available anymore AvailableSettings = GetAvailableSettings(); Counter = 0; while (Counter < ReturnValue.Count) { SettingName = ReturnValue[Counter]; if (!AvailableSettings.Contains(SettingName)) { ReturnValue.Remove(SettingName); } else { Counter = Counter + 1; } } // we might to fill up with reports from the directory, that have not been used yet Counter = 0; while ((Counter < AvailableSettings.Count) && (ReturnValue.Count < MAX_NUMBER_OF_RECENT_SETTINGS)) { SettingName = AvailableSettings[Counter]; if (!ReturnValue.Contains(SettingName)) { ReturnValue.Add(SettingName); } Counter = Counter + 1; } return ReturnValue; }
public static StringCollection FindProductTemplates() { StringCollection result = new StringCollection(); result = ListFolders("BVModules\\ProductTemplates", "Product.aspx"); result.Remove("FixedPriceGiftCertificate"); result.Remove("ArbitraryPriceGiftCertificate"); return result; }
///////////////////////////////////////////////////// // // // GetNextAvailableDriveLetter() // // // ///////////////////////////////////////////////////// //Description: Finds the next available drive letter // on the current system. //Returns: the drive letter w/o a colon ///////////////////////////////////////////////////// public static string GetNextAvailableDriveLetter() { // build a string collection representing the alphabet StringCollection alphabet = new StringCollection(); int lowerBound = Convert.ToInt16('g'); int upperBound = Convert.ToInt16('z'); for (int i = lowerBound; i < upperBound; i++) { char driveLetter = (char)i; alphabet.Add(driveLetter.ToString()); } // get all current drives DriveInfo[] drives = DriveInfo.GetDrives(); foreach (DriveInfo drive in drives) { alphabet.Remove(drive.Name.Substring(0, 1).ToLower()); } //if there is one available, return it; else null if (alphabet.Count > 0) return alphabet[0]; else return null; }
public StringCollection GetImgLinks(string image) { StringCollection a = new StringCollection(); string src; do { WebRequest(queryurl + "?what=imagelinks&titles=" + image + "&format=xml"); HttpWebResponse webResp1 = (HttpWebResponse)WebReq.GetResponse(); Stream srcstrm = webResp1.GetResponseStream(); StreamReader work = new StreamReader(srcstrm); src = work.ReadToEnd(); MatchCollection mcpt = Ptitle.Matches(src); foreach (Match m in mcpt) { string ms = m.Value; ms = Regex.Replace(ms, "</il>", ""); ms = Regex.Replace(ms, "<il n?s?=?\"?[0|1|2|3|4|5|6|7|8|9]*?\"? ?id=\"[0|1|2|3|4|5|6|7|8|9]*\">", ""); a.Add(ms); } } while (NextPortion.IsMatch(src)); a.Remove(image); return a; }
/// <summary> /// Removes all the element from the IScope object. /// </summary> public void Flush() { TraceUtil.Log("Flush session scope."); StringCollection toRemove = new StringCollection(); StringCollection names = (StringCollection)WebUtil.GetCurrentHttpContext().Items[COMPONENT_NAMES]; foreach (string name in names) { WebUtil.GetCurrentHttpContext().Session.Remove(SESSION_SCOPE_SUFFIX + name); toRemove.Remove(name); } names.Clear(); }
public static int Main(string[] argv) { #if TEST AutoTest.TestSuite(); #endif int result = 1; StringCollection parameters = new StringCollection(); parameters.AddRange(argv); AppDomain.CurrentDomain.AppendPrivatePath(Environment.CurrentDirectory); AppDomain.CurrentDomain.AppendPrivatePath(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)); try { EntryPoint entryPoint = new EntryPoint(); if (parameters.Contains(DebugOption)) { // Handle debug mode AspectDngConfig.Instance.debug = true; parameters.Remove(DebugOption); } if (parameters.Contains(QueryOption) && parameters.Count >= 3) { // Handle query mode parameters.Remove(QueryOption); Cil.Init(parameters[0], parameters[0]); parameters.RemoveAt(0); string[] array = new string[parameters.Count]; parameters.CopyTo(array, 0); string xpath = string.Join(" ", array); Console.WriteLine("\nReal XPath query:\n{0}", xpath); ICollection results = Cil.TargetNavigator.SelectList(xpath); Console.WriteLine("{0} results", results.Count); foreach (Navigator nav in results) { Console.WriteLine("[" + nav.Name + "] " + nav); } } else if (parameters.Contains(IlmlDumpOption) && parameters.Count == 3) { // Handle ilml mode parameters.Remove(IlmlDumpOption); Cil.Init(parameters[0], parameters[0]); parameters.RemoveAt(0); // Apply XSLT to Assembly XslTransform ilmlDump = new XslTransform(); ilmlDump.Load(new XmlTextReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("IlmlDump.xsl")), null, null); XmlTextWriter writer = new XmlTextWriter(parameters[0], Encoding.Unicode); writer.Formatting = Formatting.Indented; ilmlDump.Transform(new Navigator(Cil.TargetAssembly), null, writer, null); writer.Close(); } else { // Handle weave mode long Start = DateTime.Now.Ticks; // Interpret parameters if (parameters.Count > 0) { string firstArg = parameters[0]; if (firstArg.EndsWith(".xml")) { Log.Debug("Weaving as specified in " + firstArg); entryPoint.Weave(firstArg); result = 0; } else if (firstArg.EndsWith(".dll") || firstArg.EndsWith(".exe")) { if (parameters.Count == 1) entryPoint.DirectWeave(firstArg); else if (parameters.Count == 2) { string secondArg = parameters[1]; entryPoint.DirectWeave(firstArg, secondArg); } result = 0; } else entryPoint.PrintUsage(); } else entryPoint.PrintUsage(); if (result == 0) { Log.Debug("aspectdng took in {0} millis to weave {1} aspects", (DateTime.Now.Ticks - Start) / 10000, AspectDngConfig.Instance.Advice.Count); Log.Save(); } } } catch (ConfigurationException e) { Log.Error(e.Message); } catch (AdviceException e) { Log.Error(e.Message); } catch (Exception e) { Log.Error(e.Message); Log.Error(e.StackTrace); } return result; }
private void AddPathToHistory(StringCollection list, string entry) { if (list == null) return; foreach (string item in list) { if (item == entry) { list.Remove(item); break; } } while (list.Count >= 5) list.RemoveAt(list.Count - 1); list.Insert(0, entry); }
/// <summary> /// The enabled key. /// </summary> /// <param name="disabledKey"> /// The disabled key. /// </param> /// <param name="fieldName"> /// The field name. /// </param> public void EnabledKey(string disabledKey, string fieldName) { var currentDisabledKeys = new StringCollection(); if (this.disabledKeys.ContainsKey(fieldName)) { currentDisabledKeys = this.disabledKeys[fieldName] as StringCollection; this.disabledKeys.Remove(fieldName); } if (currentDisabledKeys != null && currentDisabledKeys.Contains(disabledKey)) { currentDisabledKeys.Remove(disabledKey); } this.disabledKeys.Add(fieldName, currentDisabledKeys); }