/// <summary> /// Returns a combined INI file formed by merging the specified INI files. /// <para> /// The result of this method is formed by merging the specified files together. /// The files are combined in order forming a chain. /// The first file in the list has the lowest priority. /// The last file in the list has the highest priority. /// </para> /// <para> /// The algorithm starts with all the sections and properties from the highest priority file. /// It then adds any sections or properties from subsequent files that are not already present. /// </para> /// <para> /// The algorithm can be controlled by providing a '[chain]' section. /// Within the 'chain' section, if 'chainNextFile' is 'false', then processing stops, /// and lower priority files are ignored. If the 'chainRemoveSections' property is specified, /// the listed sections are ignored from the files lower in the chain. /// /// </para> /// </summary> /// <param name="resources"> the INI file resources to read </param> /// <returns> the combined chained INI file </returns> /// <exception cref="UncheckedIOException"> if an IO error occurs </exception> /// <exception cref="IllegalArgumentException"> if the configuration is invalid </exception> public static IniFile combinedIniFile(IList <ResourceLocator> resources) { ArgChecker.notNull(resources, "resources"); IDictionary <string, PropertySet> sectionMap = new LinkedHashMap <string, PropertySet>(); foreach (ResourceLocator resource in resources) { IniFile file = IniFile.of(resource.CharSource); if (file.contains(CHAIN_SECTION)) { PropertySet chainSection = file.section(CHAIN_SECTION); // remove everything from lower priority files if not chaining if (chainSection.contains(CHAIN_NEXT) && bool.Parse(chainSection.value(CHAIN_NEXT)) == false) { sectionMap.Clear(); } else { // remove sections from lower priority files //JAVA TO C# CONVERTER TODO TASK: There is no .NET equivalent to the java.util.Collection 'removeAll' method: sectionMap.Keys.removeAll(chainSection.valueList(CHAIN_REMOVE)); } } // add entries, replacing existing data foreach (string sectionName in file.asMap().Keys) { if (!sectionName.Equals(CHAIN_SECTION)) { //JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter: sectionMap.merge(sectionName, file.section(sectionName), PropertySet::overrideWith); } } } return(IniFile.of(sectionMap)); }
/// <summary>This method sends the remove stream for all accumulated events. </summary> protected void SendRemoveStream() { _callbackScheduledTime = -1; // If there are child views and the batch was filled, fireStatementStopped Update method if (HasViews) { // Convert to object arrays EventBean[] oldData = null; if (_currentBatch.IsNotEmpty()) { oldData = _currentBatch.Keys.ToArray(); } if (oldData != null) { using (Instrument.With( i => i.QViewIndicate(this, _factory.ViewName, null, oldData), i => i.AViewIndicate())) { UpdateChildren(null, oldData); } } } _currentBatch.Clear(); }
public void HandleClearAllCaches(ClearAllCachesEvent evnt) { lock (writeLock) { privilegeCache.Clear(); entityTypePrivilegeCache.Clear(); } }
public void Clear() { IDictionary<string, Player> lhm = new LinkedHashMap<string, Player>(); Player p = new Player("78945", "Someone"); lhm[p.Id] = p; lhm.Clear(); Assert.AreEqual(0, lhm.Count); foreach (KeyValuePair<string, Player> pair in lhm) Assert.Fail("Should not be any entries but found Key = " + pair.Key + " and Value = " + pair.Value); }
public void Clear() { IDictionary <string, Player> lhm = new LinkedHashMap <string, Player>(); Player p = new Player("78945", "Someone"); lhm[p.Id] = p; lhm.Clear(); Assert.AreEqual(0, lhm.Count); foreach (KeyValuePair <string, Player> pair in lhm) { Assert.Fail("Should not be any entries but found Key = " + pair.Key + " and Value = " + pair.Value); } }
/// <summary> /// This method sends the remove stream for all accumulated events. /// </summary> private void SendRemoveStream() { _callbackScheduledTime = -1; // If there are child views and the batch was filled, fireStatementStopped update method var child = Child; if (child != null) { // Convert to object arrays EventBean[] oldData = null; if (!_currentBatch.IsEmpty()) { oldData = _currentBatch.Keys.ToArray(); } if (oldData != null) { _agentInstanceContext.InstrumentationProvider.QViewIndicate(_factory, null, oldData); child.Update(null, oldData); _agentInstanceContext.InstrumentationProvider.AViewIndicate(); } } _currentBatch.Clear(); }
public void Performance() { // Take care with this test because the result is not the same every times int numOfRuns = 4; int numOfEntries = Int16.MaxValue; long[] dictPopulateTicks = new long[numOfRuns]; long[] dictItemTicks = new long[numOfRuns]; long[] linkPopulateTicks = new long[numOfRuns]; long[] linkItemTicks = new long[numOfRuns]; for (int runIndex = 0; runIndex < numOfRuns; runIndex++) { string key; object value; IDictionary<string, object> dictionary = new Dictionary<string, object>(); IDictionary<string, object> linked = new LinkedHashMap<string, object>(); long dictStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { dictionary.Add("test" + i, new object()); } dictPopulateTicks[runIndex] = DateTime.Now.Ticks - dictStart; dictStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { key = "test" + i; value = dictionary[key]; } dictItemTicks[runIndex] = DateTime.Now.Ticks - dictStart; dictionary.Clear(); long linkStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { linked.Add("test" + i, new object()); } linkPopulateTicks[runIndex] = DateTime.Now.Ticks - linkStart; linkStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { key = "test" + i; value = linked[key]; } linkItemTicks[runIndex] = DateTime.Now.Ticks - linkStart; linked.Clear(); } for (int runIndex = 0; runIndex < numOfRuns; runIndex++) { decimal linkPopulateOverhead = (linkPopulateTicks[runIndex] / (decimal)dictPopulateTicks[runIndex]); decimal linkItemOverhead = (linkItemTicks[runIndex] / (decimal)dictItemTicks[runIndex]); string message = string.Format("LinkedHashMap vs Dictionary (Run-{0}) :",runIndex+1); message += "\n POPULATE:"; message += "\n\t linked took " + linkPopulateTicks[runIndex] + " ticks."; message += "\n\t dictionary took " + dictPopulateTicks[runIndex] + " ticks."; message += "\n\t for an overhead of " + linkPopulateOverhead; message += "\n RETRIVE:"; message += "\n\t linked took " + linkItemTicks[runIndex] + " ticks."; message += "\n\t dictionary took " + dictItemTicks[runIndex] + " ticks."; message += "\n\t for an overhead of " + linkItemOverhead; Console.Out.WriteLine(message); Console.Out.WriteLine(); } }
public void Performance() { // Take care with this test because the result is not the same every times int numOfRuns = 4; int numOfEntries = Int16.MaxValue; long[] dictPopulateTicks = new long[numOfRuns]; long[] dictItemTicks = new long[numOfRuns]; long[] linkPopulateTicks = new long[numOfRuns]; long[] linkItemTicks = new long[numOfRuns]; for (int runIndex = 0; runIndex < numOfRuns; runIndex++) { string key; object value; IDictionary <string, object> dictionary = new Dictionary <string, object>(); IDictionary <string, object> linked = new LinkedHashMap <string, object>(); long dictStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { dictionary.Add("test" + i, new object()); } dictPopulateTicks[runIndex] = DateTime.Now.Ticks - dictStart; dictStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { key = "test" + i; value = dictionary[key]; } dictItemTicks[runIndex] = DateTime.Now.Ticks - dictStart; dictionary.Clear(); long linkStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { linked.Add("test" + i, new object()); } linkPopulateTicks[runIndex] = DateTime.Now.Ticks - linkStart; linkStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { key = "test" + i; value = linked[key]; } linkItemTicks[runIndex] = DateTime.Now.Ticks - linkStart; linked.Clear(); } for (int runIndex = 0; runIndex < numOfRuns; runIndex++) { decimal linkPopulateOverhead = (linkPopulateTicks[runIndex] / (decimal)dictPopulateTicks[runIndex]); decimal linkItemOverhead = (linkItemTicks[runIndex] / (decimal)dictItemTicks[runIndex]); string message = string.Format("LinkedHashMap vs Dictionary (Run-{0}) :", runIndex + 1); message += "\n POPULATE:"; message += "\n\t linked took " + linkPopulateTicks[runIndex] + " ticks."; message += "\n\t dictionary took " + dictPopulateTicks[runIndex] + " ticks."; message += "\n\t for an overhead of " + linkPopulateOverhead; message += "\n RETRIVE:"; message += "\n\t linked took " + linkItemTicks[runIndex] + " ticks."; message += "\n\t dictionary took " + dictItemTicks[runIndex] + " ticks."; message += "\n\t for an overhead of " + linkItemOverhead; Console.Out.WriteLine(message); Console.Out.WriteLine(); } }
public void Clear() { RefSet.Clear(); _array = null; }
public void Clear() { OuterInstance.Clear(); }
public void Dispose() { if (disposed || disposing) { return; } ILogger log; IServiceContext[] childrenCopy = null; writeLock.Lock(); try { if (disposed || disposing) { return; } log = GetService <ILoggerCache>().GetCachedLogger(this, typeof(ServiceContext)); if (log.DebugEnabled) { // Safe the toString-method for debugging purpose. Because this is not possible anymore if the context // has been disposed and all bean-references have been cleared toStringBackup = StringBuilderUtil.Concat(delegate(StringBuilder sb) { PrintContent(sb); }); } else { toStringBackup = "n/a"; } disposing = true; if (children != null && children.Count > 0) { childrenCopy = new IServiceContext[children.Count]; children.CopyTo(childrenCopy, 0); children.Clear(); } } finally { writeLock.Unlock(); } if (childrenCopy != null) { foreach (IServiceContext childContext in childrenCopy) { try { childContext.Dispose(); } catch (Exception e) { if (log.ErrorEnabled) { log.Error(e); } } } } writeLock.Lock(); try { if (parent != null) { parent.ChildContextDisposed(this); parent = null; } if (this.linkContainers != null) { IList <ILinkContainer> linkContainers = this.linkContainers; this.linkContainers = null; for (int a = linkContainers.Count; a-- > 0;) { ILinkContainer listenerContainer = linkContainers[a]; try { listenerContainer.Unlink(); } catch (System.Exception e) { if (failOnError) { throw; } if (log.ErrorEnabled) { log.Error(e); } } } } if (this.disposableObjects != null) { IList <Object> disposableObjects = this.disposableObjects; this.disposableObjects = null; for (int a = disposableObjects.Count; a-- > 0;) { Object disposableObject = disposableObjects[a]; if (disposableObject is WeakReference) { disposableObject = ((WeakReference)disposableObject).Target; } if (disposableObject is IDisposableBean) { try { ((IDisposableBean)disposableObject).Destroy(); } catch (System.Exception e) { if (failOnError) { throw; } if (log.ErrorEnabled) { log.Error(e); } } } else if (disposableObject is IDisposable) { try { ((IDisposable)disposableObject).Dispose(); } catch (System.Exception e) { if (failOnError) { throw; } if (log.ErrorEnabled) { log.Error(e); } } } else if (disposableObject is IBackgroundWorkerParamDelegate <IServiceContext> ) { try { ((IBackgroundWorkerParamDelegate <IServiceContext>)disposableObject).Invoke(this); } catch (System.Exception e) { if (failOnError) { throw; } if (log.ErrorEnabled) { log.Error(e); } } } } } if (nameToServiceDict != null) { nameToServiceDict.Clear(); } typeToServiceDict.Clear(); if (postProcessors != null) { postProcessors.Clear(); } if (preProcessors != null) { preProcessors.Clear(); } beanContextFactory.Dispose(); } finally { writeLock.Unlock(); beanContextFactory = null; linkContainers = null; nameToServiceDict = null; postProcessors = null; preProcessors = null; parent = null; disposed = true; running = false; } }
public virtual void Clear() { refSet.Clear(); _array = null; }
public static void Reset() { index = 0; time.Clear(); count.Clear(); }