//******************************************************************************************************* // ProcessDictionary.cs - Gbtc // // Tennessee Valley Authority, 2009 // No copyright is claimed pursuant to 17 USC § 105. All Other Rights Reserved. // // This software is made freely available under the TVA Open Source Agreement (see below). // // Code Modification History: // ----------------------------------------------------------------------------------------------------- // 01/07/2006 - J. Ritchie Carroll // Generated original version of source code. // 08/17/2007 - Darrell Zuercher // Edited code comments. // 09/11/2008 - J. Ritchie Carroll // Converted to C#. // 02/19/2009 - Josh L. Patterson // Edited Code Comments. // 08/05/2009 - Josh L. Patterson // Edited Comments. // 09/14/2009 - Stephen C. Wills // Added new header and license agreement. // //******************************************************************************************************* #region [ TVA Open Source Agreement ] /* THIS OPEN SOURCE AGREEMENT ("AGREEMENT") DEFINES THE RIGHTS OF USE,REPRODUCTION, DISTRIBUTION, MODIFICATION AND REDISTRIBUTION OF CERTAIN COMPUTER SOFTWARE ORIGINALLY RELEASED BY THE TENNESSEE VALLEY AUTHORITY, A CORPORATE AGENCY AND INSTRUMENTALITY OF THE UNITED STATES GOVERNMENT ("GOVERNMENT AGENCY"). GOVERNMENT AGENCY IS AN INTENDED THIRD-PARTY BENEFICIARY OF ALL SUBSEQUENT DISTRIBUTIONS OR REDISTRIBUTIONS OF THE SUBJECT SOFTWARE. ANYONE WHO USES, REPRODUCES, DISTRIBUTES, MODIFIES OR REDISTRIBUTES THE SUBJECT SOFTWARE, AS DEFINED HEREIN, OR ANY PART THEREOF, IS, BY THAT ACTION, ACCEPTING IN FULL THE RESPONSIBILITIES AND OBLIGATIONS CONTAINED IN THIS AGREEMENT. Original Software Designation: openPDC Original Software Title: The GSF Open Source Phasor Data Concentrator User Registration Requested. Please Visit https://naspi.tva.com/Registration/ Point of Contact for Original Software: J. Ritchie Carroll 1. DEFINITIONS A. "Contributor" means Government Agency, as the developer of the Original Software, and any entity that makes a Modification. B. "Covered Patents" mean patent claims licensable by a Contributor that are necessarily infringed by the use or sale of its Modification alone or when combined with the Subject Software. C. "Display" means the showing of a copy of the Subject Software, either directly or by means of an image, or any other device. D. "Distribution" means conveyance or transfer of the Subject Software, regardless of means, to another. E. "Larger Work" means computer software that combines Subject Software, or portions thereof, with software separate from the Subject Software that is not governed by the terms of this Agreement. F. "Modification" means any alteration of, including addition to or deletion from, the substance or structure of either the Original Software or Subject Software, and includes derivative works, as that term is defined in the Copyright Statute, 17 USC § 101. However, the act of including Subject Software as part of a Larger Work does not in and of itself constitute a Modification. G. "Original Software" means the computer software first released under this Agreement by Government Agency entitled openPDC, including source code, object code and accompanying documentation, if any. H. "Recipient" means anyone who acquires the Subject Software under this Agreement, including all Contributors. I. "Redistribution" means Distribution of the Subject Software after a Modification has been made. J. "Reproduction" means the making of a counterpart, image or copy of the Subject Software. K. "Sale" means the exchange of the Subject Software for money or equivalent value. L. "Subject Software" means the Original Software, Modifications, or any respective parts thereof. M. "Use" means the application or employment of the Subject Software for any purpose. 2. GRANT OF RIGHTS A. Under Non-Patent Rights: Subject to the terms and conditions of this Agreement, each Contributor, with respect to its own contribution to the Subject Software, hereby grants to each Recipient a non-exclusive, world-wide, royalty-free license to engage in the following activities pertaining to the Subject Software: 1. Use 2. Distribution 3. Reproduction 4. Modification 5. Redistribution 6. Display B. Under Patent Rights: Subject to the terms and conditions of this Agreement, each Contributor, with respect to its own contribution to the Subject Software, hereby grants to each Recipient under Covered Patents a non-exclusive, world-wide, royalty-free license to engage in the following activities pertaining to the Subject Software: 1. Use 2. Distribution 3. Reproduction 4. Sale 5. Offer for Sale C. The rights granted under Paragraph B. also apply to the combination of a Contributor's Modification and the Subject Software if, at the time the Modification is added by the Contributor, the addition of such Modification causes the combination to be covered by the Covered Patents. It does not apply to any other combinations that include a Modification. D. The rights granted in Paragraphs A. and B. allow the Recipient to sublicense those same rights. Such sublicense must be under the same terms and conditions of this Agreement. 3. OBLIGATIONS OF RECIPIENT A. Distribution or Redistribution of the Subject Software must be made under this Agreement except for additions covered under paragraph 3H. 1. Whenever a Recipient distributes or redistributes the Subject Software, a copy of this Agreement must be included with each copy of the Subject Software; and 2. If Recipient distributes or redistributes the Subject Software in any form other than source code, Recipient must also make the source code freely available, and must provide with each copy of the Subject Software information on how to obtain the source code in a reasonable manner on or through a medium customarily used for software exchange. B. Each Recipient must ensure that the following copyright notice appears prominently in the Subject Software: No copyright is claimed pursuant to 17 USC § 105. All Other Rights Reserved. C. Each Contributor must characterize its alteration of the Subject Software as a Modification and must identify itself as the originator of its Modification in a manner that reasonably allows subsequent Recipients to identify the originator of the Modification. In fulfillment of these requirements, Contributor must include a file (e.g., a change log file) that describes the alterations made and the date of the alterations, identifies Contributor as originator of the alterations, and consents to characterization of the alterations as a Modification, for example, by including a statement that the Modification is derived, directly or indirectly, from Original Software provided by Government Agency. Once consent is granted, it may not thereafter be revoked. D. A Contributor may add its own copyright notice to the Subject Software. Once a copyright notice has been added to the Subject Software, a Recipient may not remove it without the express permission of the Contributor who added the notice. E. A Recipient may not make any representation in the Subject Software or in any promotional, advertising or other material that may be construed as an endorsement by Government Agency or by any prior Recipient of any product or service provided by Recipient, or that may seek to obtain commercial advantage by the fact of Government Agency's or a prior Recipient's participation in this Agreement. F. In an effort to track usage and maintain accurate records of the Subject Software, each Recipient, upon receipt of the Subject Software, is requested to register with Government Agency by visiting the following website: https://naspi.tva.com/Registration/. Recipient's name and personal information shall be used for statistical purposes only. Once a Recipient makes a Modification available, it is requested that the Recipient inform Government Agency at the web site provided above how to access the Modification. G. Each Contributor represents that that its Modification does not violate any existing agreements, regulations, statutes or rules, and further that Contributor has sufficient rights to grant the rights conveyed by this Agreement. H. A Recipient may choose to offer, and to charge a fee for, warranty, support, indemnity and/or liability obligations to one or more other Recipients of the Subject Software. A Recipient may do so, however, only on its own behalf and not on behalf of Government Agency or any other Recipient. Such a Recipient must make it absolutely clear that any such warranty, support, indemnity and/or liability obligation is offered by that Recipient alone. Further, such Recipient agrees to indemnify Government Agency and every other Recipient for any liability incurred by them as a result of warranty, support, indemnity and/or liability offered by such Recipient. I. A Recipient may create a Larger Work by combining Subject Software with separate software not governed by the terms of this agreement and distribute the Larger Work as a single product. In such case, the Recipient must make sure Subject Software, or portions thereof, included in the Larger Work is subject to this Agreement. J. Notwithstanding any provisions contained herein, Recipient is hereby put on notice that export of any goods or technical data from the United States may require some form of export license from the U.S. Government. Failure to obtain necessary export licenses may result in criminal liability under U.S. laws. Government Agency neither represents that a license shall not be required nor that, if required, it shall be issued. Nothing granted herein provides any such export license. 4. DISCLAIMER OF WARRANTIES AND LIABILITIES; WAIVER AND INDEMNIFICATION A. No Warranty: THE SUBJECT SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY OF ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR FREEDOM FROM INFRINGEMENT, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL BE ERROR FREE, OR ANY WARRANTY THAT DOCUMENTATION, IF PROVIDED, WILL CONFORM TO THE SUBJECT SOFTWARE. THIS AGREEMENT DOES NOT, IN ANY MANNER, CONSTITUTE AN ENDORSEMENT BY GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT OF ANY RESULTS, RESULTING DESIGNS, HARDWARE, SOFTWARE PRODUCTS OR ANY OTHER APPLICATIONS RESULTING FROM USE OF THE SUBJECT SOFTWARE. FURTHER, GOVERNMENT AGENCY DISCLAIMS ALL WARRANTIES AND LIABILITIES REGARDING THIRD-PARTY SOFTWARE, IF PRESENT IN THE ORIGINAL SOFTWARE, AND DISTRIBUTES IT "AS IS." B. Waiver and Indemnity: RECIPIENT AGREES TO WAIVE ANY AND ALL CLAIMS AGAINST GOVERNMENT AGENCY, ITS AGENTS, EMPLOYEES, CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT. IF RECIPIENT'S USE OF THE SUBJECT SOFTWARE RESULTS IN ANY LIABILITIES, DEMANDS, DAMAGES, EXPENSES OR LOSSES ARISING FROM SUCH USE, INCLUDING ANY DAMAGES FROM PRODUCTS BASED ON, OR RESULTING FROM, RECIPIENT'S USE OF THE SUBJECT SOFTWARE, RECIPIENT SHALL INDEMNIFY AND HOLD HARMLESS GOVERNMENT AGENCY, ITS AGENTS, EMPLOYEES, CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT, TO THE EXTENT PERMITTED BY LAW. THE FOREGOING RELEASE AND INDEMNIFICATION SHALL APPLY EVEN IF THE LIABILITIES, DEMANDS, DAMAGES, EXPENSES OR LOSSES ARE CAUSED, OCCASIONED, OR CONTRIBUTED TO BY THE NEGLIGENCE, SOLE OR CONCURRENT, OF GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT. RECIPIENT'S SOLE REMEDY FOR ANY SUCH MATTER SHALL BE THE IMMEDIATE, UNILATERAL TERMINATION OF THIS AGREEMENT. 5. GENERAL TERMS A. Termination: This Agreement and the rights granted hereunder will terminate automatically if a Recipient fails to comply with these terms and conditions, and fails to cure such noncompliance within thirty (30) days of becoming aware of such noncompliance. Upon termination, a Recipient agrees to immediately cease use and distribution of the Subject Software. All sublicenses to the Subject Software properly granted by the breaching Recipient shall survive any such termination of this Agreement. B. Severability: If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement. C. Applicable Law: This Agreement shall be subject to United States federal law only for all purposes, including, but not limited to, determining the validity of this Agreement, the meaning of its provisions and the rights, obligations and remedies of the parties. D. Entire Understanding: This Agreement constitutes the entire understanding and agreement of the parties relating to release of the Subject Software and may not be superseded, modified or amended except by further written agreement duly executed by the parties. E. Binding Authority: By accepting and using the Subject Software under this Agreement, a Recipient affirms its authority to bind the Recipient to all terms and conditions of this Agreement and that Recipient hereby agrees to all terms and conditions herein. F. Point of Contact: Any Recipient contact with Government Agency is to be directed to the designated representative as follows: J. Ritchie Carroll . */ #endregion using System; using System.Collections.Generic; using System.ComponentModel; namespace GSF.Collections { /// /// Represents a thread-safe (via locking) keyed collection of items, based on , that get processed on independent threads with a consumer provided function. /// /// Type of keys used to reference process items. /// Type of values to process. /// /// This class acts as a strongly-typed sorted dictionary of objects to be processed. /// /// Consumers are expected to create new instances of this class through the static construction functions (e.g., /// , /// , etc.) /// /// Note that the will not start processing until the Start method is called. /// Because this represents a dictionary style collection, all keys must be unique. /// /// Be aware that this class is based on a (i.e., a /// that implements ), and since items in this kind of list are automatically sorted, items will be processed /// in "sorted" order regardless of the order in which they are added to the list. /// /// /// Important note about using an "Integer" as the key for this class: because the base class must /// implement IList, a normal dictionary cannot be used for the base class. IDictionary implementations /// do not normally implement the IList interface because of ambiguity that is caused when implementing /// an integer key. For example, if you implement this class with a key of type "Integer," you will not /// be able to access items in the by index without "casting" the /// as IList. This is because the Item property in both the IDictionary and IList would /// have the same parameters (see the class for more details.). /// /// public class ProcessDictionary : ProcessList>, IDictionary { #region [ Members ] // Delegates /// /// Function signature that defines a method to process a key and value one at a time. /// /// key to be processed. /// value to be processed. /// /// Required unless is implemented. /// Used when creating a to process one item at a time. /// Asynchronous will process individual items on multiple threads /// public new delegate void ProcessItemFunctionSignature(TKey key, TValue value); /// /// Function signature that determines if a key and value can be currently processed. /// /// key to be checked for processing availablity. /// value to be checked for processing availablity. /// True, if key and value can be processed. /// /// Implementation of this function is optional. It will be assumed that an item can be processed if this /// function is not defined /// Items must eventually get to a state where they can be processed or they will remain in the /// indefinitely. /// /// Note that when this function is implemented and = ManyAtOnce (i.e., /// is defined), then each item presented /// for processing must evaluate as "CanProcessItem = True" before any items are processed. /// /// public new delegate bool CanProcessItemFunctionSignature(TKey key, TValue value); // Fields private ProcessItemFunctionSignature m_processItemFunction; private CanProcessItemFunctionSignature m_canProcessItemFunction; private bool m_disposed; #endregion #region [ Constructors ] /// /// Creates a based on the generic class. /// /// A delegate that defines a function signature to process a key and value one at a time. /// A delegate that determines of a key and value can currently be processed. /// A which represents the process interval. /// An that represents the max number of threads to use. /// An that represents the amount of time before a process times out. /// A value that indicates whether the process should requeue the item after a timeout. /// A value that indicates whether the process should requeue the item after an exception. protected ProcessDictionary(ProcessItemFunctionSignature processItemFunction, CanProcessItemFunctionSignature canProcessItemFunction, double processInterval, int maximumThreads, int processTimeout, bool requeueOnTimeout, bool requeueOnException) : base(null, null, null, new DictionaryList(), processInterval, maximumThreads, processTimeout, requeueOnTimeout, requeueOnException) { m_processItemFunction = processItemFunction; // Defining this function creates a ProcessingStyle = OneAtATime keyed process queue m_canProcessItemFunction = canProcessItemFunction; // Assigns translator functions for base class. base.ProcessItemFunction = ProcessKeyedItem; if ((object)m_canProcessItemFunction != null) base.CanProcessItemFunction = CanProcessKeyedItem; } /// /// Creates a bulk-item based on the generic class. /// /// A delegate ProcessItemsFunctionSignature that defines a function signature to process multiple items at once. /// A delegate that determines of a key and value can currently be processed. /// A which represents the process interval. /// An that represents the max number of threads to use. /// An that represents the amount of time before a process times out. /// A value that indicates whether the process should requeue the item after a timeout. /// A value that indicates whether the process should requeue the item after an exception. protected ProcessDictionary(ProcessItemsFunctionSignature processItemsFunction, CanProcessItemFunctionSignature canProcessItemFunction, double processInterval, int maximumThreads, int processTimeout, bool requeueOnTimeout, bool requeueOnException) : base(null, processItemsFunction, null, new DictionaryList(), processInterval, maximumThreads, processTimeout, requeueOnTimeout, requeueOnException) { m_canProcessItemFunction = canProcessItemFunction; // Assigns translator functions for base class. if ((object)m_canProcessItemFunction != null) base.CanProcessItemFunction = CanProcessKeyedItem; } #endregion #region [ Properties ] /// /// Gets or sets the user function used to process items in the list one at a time. /// /// /// This function and cannot be defined at the same time. /// A must be defined to process either a single item at a time or many items at once. /// Implementation of this function makes = OneAtATime. /// public virtual new ProcessItemFunctionSignature ProcessItemFunction { get { return m_processItemFunction; } set { if ((object)value != null) { m_processItemFunction = value; // Assigns translator function for base class. base.ProcessItemFunction = ProcessKeyedItem; } } } /// /// Gets or sets the user function used to process multiple items in the list at once. /// /// /// This function and cannot be defined at the same time. /// A must be defined to process either a single item at a time or many items at once. /// Implementation of this function makes = ManyAtOnce. /// public override ProcessItemsFunctionSignature ProcessItemsFunction { get { return base.ProcessItemsFunction; } set { if ((object)value != null) { m_processItemFunction = null; base.ProcessItemsFunction = value; } } } /// /// Gets or sets the user function used to determine if an item is ready to be processed. /// public virtual new CanProcessItemFunctionSignature CanProcessItemFunction { get { return m_canProcessItemFunction; } set { m_canProcessItemFunction = value; // Assigns translator function for base class. if ((object)m_canProcessItemFunction == null) base.CanProcessItemFunction = null; else base.CanProcessItemFunction = CanProcessKeyedItem; } } /// /// Gets the class name. /// /// Class name. /// /// This name is used for class identification in strings (e.g., used in error message). /// Derived classes should override this method with a proper class name. /// public override string Name { get { return this.GetType().Name; } } /// Gets or sets the value associated with the specified key. /// The value associated with the specified key. If the specified key is not found, a get operation /// throws a KeyNotFoundException, and a set operation creates a new element with the specified key. /// The key of the value to get or set. /// key is null. /// The property is retrieved and key does not exist in the collection. public TValue this[TKey key] { get { lock (SyncRoot) { return InternalDictionary[key]; } } set { lock (SyncRoot) { InternalDictionary[key] = value; DataAdded(); } } } /// Gets an ICollection containing the keys of the . /// An ICollection containing the keys of the . public ICollection Keys { get { return InternalDictionary.Keys; } } /// Gets an ICollection containing the values of the . /// An ICollection containing the values of the . public ICollection Values { get { return InternalDictionary.Values; } } /// /// Gets the internal sorted dictionary for direct use by derived classes. /// protected DictionaryList InternalDictionary { get { return (DictionaryList)InternalQueue; } } #endregion #region [ Methods ] /// /// Releases the unmanaged resources used by the object and optionally releases the managed resources. /// /// true to release both managed and unmanaged resources; false to release only unmanaged resources. protected override void Dispose(bool disposing) { if (!m_disposed) { try { if (disposing) { m_processItemFunction = null; m_canProcessItemFunction = null; } } finally { m_disposed = true; // Prevent duplicate dispose. base.Dispose(disposing); // Call base class Dispose(). } } } #region [ Item Processing Translation Functions ] // These functions act as intermediate "translators" between the delegate implementations of // ProcessQueue and ProcessDictionary. Users implementing a ProcessDictionary will likely be // thinking in terms of "keys" and "values", and not a KeyValuePair structure. Note that the // bulk item ProcessItems delegate is not translated since an array of KeyValuePair structures // would make more sense and be more efficient than two separate arrays of keys and values. private void ProcessKeyedItem(KeyValuePair item) { m_processItemFunction(item.Key, item.Value); } private bool CanProcessKeyedItem(KeyValuePair item) { return m_canProcessItemFunction(item.Key, item.Value); } //private void ProcessKeyedItems(KeyValuePair[] items) //{ // // Copies an array of KeyValuePairs into an array of keys and values. // TKey[] keys = new TKey[items.Length]; // TValue[] values = new TValue[items.Length]; // KeyValuePair kvPair; // for (int x = 0; x < items.Length; x++) // { // kvPair = items[x]; // keys[x] = kvPair.Key; // values[x] = kvPair.Value; // } // m_processItemsFunction(keys, values); //} #endregion #region [ Generic IDictionary(Of TKey, TValue) Implementation ] /// Adds an element with the provided key and value to the . /// The object to use as the value of the element to add. /// The object to use as the key of the element to add. /// The is read-only. /// An element with the same key already exists in the . /// key is null. public void Add(TKey key, TValue value) { lock (SyncRoot) { InternalDictionary.Add(key, value); DataAdded(); } } /// Determines whether the contains an element with the specified key. /// True, if the contains an element with the key; otherwise, false. /// The key to locate in the . /// key is null. public bool ContainsKey(TKey key) { lock (SyncRoot) { return InternalDictionary.ContainsKey(key); } } /// Determines whether the contains an element with the specified value. /// True, if the contains an element with the value; otherwise, false. /// The value to locate in the . public bool ContainsValue(TValue value) { lock (SyncRoot) { return InternalDictionary.ContainsValue(value); } } /// /// Searches for the specified key and returns the zero-based index within the entire . /// /// The key to locate in the . /// The zero-based index of key within the entire , if found; otherwise, -1. public int IndexOfKey(TKey key) { lock (SyncRoot) { return InternalDictionary.IndexOfKey(key); } } /// /// Searches for the specified value and returns the zero-based index of the first occurrence within the entire . /// /// The value to locate in the . The value can be null for reference types. /// The zero-based index of the first occurrence of value within the entire , if found; otherwise, -1. public int IndexOfValue(TValue value) { lock (SyncRoot) { return InternalDictionary.IndexOfValue(value); } } /// Removes the element with the specified key from the . /// The key of the element to remove. /// key is null. /// This method returns a value indicating whether the item was removed. public bool Remove(TKey key) { lock (SyncRoot) { return InternalDictionary.Remove(key); } } /// Gets the value associated with the specified key. /// True, if the contains an element with the specified key; otherwise, false. /// When this method returns, contains the value associated with the specified key, if the /// key is found; otherwise, the default value for the type of the value parameter. This parameter is passed /// uninitialized. /// The key of the value to get. /// key is null. public bool TryGetValue(TKey key, out TValue value) { lock (SyncRoot) { return InternalDictionary.TryGetValue(key, out value); } } #endregion #region [ Overriden List(T) Functions ] // Because consumers will be able to call these functions in their "dictionary" style queue, we'll make // sure they return something that makes sense in case they get called, but we will hide the functions from // the editor to help avoid confusion. /// /// This function doesn't have the same meaning in the as it does in /// , so it is marked as hidden from the editor. However it returns /// so that it returns a value that at least makes sense /// in case it gets called. /// /// The object to locate. The value can be null for reference types. /// This method returns an that is the index of the item.Key. [EditorBrowsable(EditorBrowsableState.Never)] public override int BinarySearch(KeyValuePair item) { return IndexOfKey(item.Key); } /// /// This function doesn't have the same meaning in the as it does in /// , so it is marked as hidden from the editor. However it returns /// so that it returns a value that at least makes sense /// in case it gets called. /// /// The object to locate. The value can be null for reference types. /// The Generic.IComparer implementation to use when comparing elements -or- /// null to use the default comparer: Generic.Comparer(Of T).Default /// This method returns an that is the index of the item.Key. [EditorBrowsable(EditorBrowsableState.Never)] public override int BinarySearch(KeyValuePair item, IComparer> comparer) { return IndexOfKey(item.Key); } /// /// This function doesn't have the same meaning in the as it does in /// , so it is marked as hidden from the editor. However it returns /// so that it returns a value that at least makes sense /// in case it gets called. /// /// The zero-based starting index of the range to search. /// The length of the range to search. /// The object to locate. The value can be null for reference types. /// The Generic.IComparer implementation to use when comparing elements -or- null to use /// the default comparer: Generic.Comparer(Of T).Default /// This method returns an that is the index of the item.Key. [EditorBrowsable(EditorBrowsableState.Never)] public override int BinarySearch(int index, int count, KeyValuePair item, IComparer> comparer) { return IndexOfKey(item.Key); } /// /// This function doesn't have the same meaning in the as it does in /// , so it is marked as hidden from the editor. However it returns /// so that it returns a value that at least makes sense /// in case it gets called. /// /// The object to locate in the . The value can be null for reference types. /// This method returns an that is the index of the item.Key. [EditorBrowsable(EditorBrowsableState.Never)] public override int IndexOf(KeyValuePair item) { return IndexOfKey(item.Key); } /// /// This function doesn't have the same meaning in the as it does in /// , so it is marked as hidden from the editor. However it returns /// so that it returns a value that at least makes sense /// in case it gets called. /// /// The number of elements in the section to search. /// The object to locate in the . The value can be null for reference types. /// The zero-based starting index of the search. /// This method returns an that is the index of the item.Key. [EditorBrowsable(EditorBrowsableState.Never)] public override int IndexOf(KeyValuePair item, int index, int count) { return IndexOfKey(item.Key); } /// /// This function doesn't have the same meaning in the as it does in /// , so it is marked as hidden from the editor. However it returns /// so that it returns a value that at least makes sense /// in case it gets called. /// /// The object to locate in the . The value can be null for reference types. /// This method returns an that is the index of the item.Key. [EditorBrowsable(EditorBrowsableState.Never)] public override int LastIndexOf(KeyValuePair item) { return IndexOfKey(item.Key); } /// /// This function doesn't have the same meaning in the as it does in /// , so it is marked as hidden from the editor. However it returns /// so that it returns a value that at least makes sense /// in case it gets called. /// /// The object to locate in the . The value can be null for reference types. /// The zero-based starting index of the backward search. /// This method returns an that is the index of the item.Key. [EditorBrowsable(EditorBrowsableState.Never)] public override int LastIndexOf(KeyValuePair item, int index) { return IndexOfKey(item.Key); } /// /// This function doesn't have the same meaning in the as it does in /// , so it is marked as hidden from the editor. However it returns /// so that it returns a value that at least makes sense /// in case it gets called. /// /// The object to locate in the . The value can be null for reference types. /// The zero-based starting index of the backward search. /// The number of elements in the section to search. /// This method returns an that is the index of the item.Key. [EditorBrowsable(EditorBrowsableState.Never)] public override int LastIndexOf(KeyValuePair item, int index, int count) { return IndexOfKey(item.Key); } /// /// is based on a which is already /// sorted, so calling this function has no effect. As a result this function is marked as hidden from the editor. /// [EditorBrowsable(EditorBrowsableState.Never)] public override void Sort() { // This list is already sorted. } /// /// is based on a which is already /// sorted, so calling this function has no effect. As a result this function is marked as hidden from the editor. /// /// The Generic.IComparer implementation to use when comparing elements -or- /// null to use the default comparer: Generic.Comparer(Of T).Default [EditorBrowsable(EditorBrowsableState.Never)] public override void Sort(IComparer> comparer) { // This list is already sorted. } /// /// is based on a which is already /// sorted, so calling this function has no effect. As a result this function is marked as hidden from the editor. /// /// The comparison to use when comparing elements. [EditorBrowsable(EditorBrowsableState.Never)] public override void Sort(System.Comparison> comparison) { // This list is already sorted. } /// /// is based on a which is already /// sorted, so calling this function has no effect. As a result this function is marked as hidden from the editor. /// /// The zero-based starting index of the range to search. /// The length of the range to search. /// The Generic.IComparer implementation to use when comparing elements -or- /// null to use the default comparer: Generic.Comparer(Of T).Default [EditorBrowsable(EditorBrowsableState.Never)] public override void Sort(int index, int count, IComparer> comparer) { // This list is already sorted. } #endregion #endregion #region [ Static ] #region [ Single-Item Processing Constructors ] /// /// Creates a new, keyed, asynchronous with the default settings: ProcessInterval = 100, /// MaximumThreads = 5, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False. /// /// Delegate which defines a method to process a key and value one at a time. /// Returns the process queue ProcessDictionary. public static ProcessDictionary CreateAsynchronousQueue(ProcessItemFunctionSignature processItemFunction) { return CreateAsynchronousQueue(processItemFunction, null, DefaultProcessInterval, DefaultMaximumThreads, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new, keyed, asynchronous with the default settings: ProcessInterval = 100, /// MaximumThreads = 5, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False. /// /// Delegate which defines a method to process a key and value one at a time. /// A delegate which defines a method to indicate whether a key and value can be processed at this time. /// Returns the process queue ProcessDictionary. public static ProcessDictionary CreateAsynchronousQueue(ProcessItemFunctionSignature processItemFunction, CanProcessItemFunctionSignature canProcessItemFunction) { return CreateAsynchronousQueue(processItemFunction, canProcessItemFunction, DefaultProcessInterval, DefaultMaximumThreads, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new, keyed, asynchronous with the default settings: ProcessInterval = 100, /// ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False. /// /// Delegate which defines a method to process a key and value one at a time. /// The maximum number of threads for the queue to use. /// Returns the process queue ProcessDictionary. public static ProcessDictionary CreateAsynchronousQueue(ProcessItemFunctionSignature processItemFunction, int maximumThreads) { return CreateAsynchronousQueue(processItemFunction, null, DefaultProcessInterval, maximumThreads, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new, keyed, asynchronous with the default settings: ProcessInterval = 100, /// ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False. /// /// Delegate which defines a method to process a key and value one at a time. /// A delegate which defines a method to indicate whether a key and value can be processed at this time. /// The maximum number of threads for the queue to use. /// Returns the process queue ProcessDictionary. public static ProcessDictionary CreateAsynchronousQueue(ProcessItemFunctionSignature processItemFunction, CanProcessItemFunctionSignature canProcessItemFunction, int maximumThreads) { return CreateAsynchronousQueue(processItemFunction, canProcessItemFunction, DefaultProcessInterval, maximumThreads, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new, keyed, asynchronous , using specified settings. /// /// Delegate which defines a method to process a key and value one at a time. /// a value which represents the process interval in milliseconds. /// The maximum number of threads for the queue to use. /// The number of seconds before a process should timeout. /// A value that indicates whether a process should requeue an item on timeout. /// A value that indicates whether a process should requeue after an exception. /// Returns the process queue ProcessDictionary. public static ProcessDictionary CreateAsynchronousQueue(ProcessItemFunctionSignature processItemFunction, double processInterval, int maximumThreads, int processTimeout, bool requeueOnTimeout, bool requeueOnException) { return CreateAsynchronousQueue(processItemFunction, null, processInterval, maximumThreads, processTimeout, requeueOnTimeout, requeueOnException); } /// /// Creates a new, keyed, asynchronous , using specified settings. /// /// Delegate which defines a method to process a key and value one at a time. /// A delegate which defines a method to indicate whether a key and value can be processed at this time. /// a value which represents the process interval in milliseconds. /// The maximum number of threads for the queue to use. /// The number of seconds before a process should timeout. /// A value that indicates whether a process should requeue an item on timeout. /// A value that indicates whether a process should requeue after an exception. /// Returns the process queue ProcessDictionary. public static ProcessDictionary CreateAsynchronousQueue(ProcessItemFunctionSignature processItemFunction, CanProcessItemFunctionSignature canProcessItemFunction, double processInterval, int maximumThreads, int processTimeout, bool requeueOnTimeout, bool requeueOnException) { return new ProcessDictionary(processItemFunction, canProcessItemFunction, processInterval, maximumThreads, processTimeout, requeueOnTimeout, requeueOnException); } /// /// Creates a new, keyed, synchronous (i.e., single process thread) with the default settings: /// ProcessInterval = 100, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False. /// /// Delegate which defines a method to process a key and value one at a time. /// Returns the process queue ProcessDictionary. public static ProcessDictionary CreateSynchronousQueue(ProcessItemFunctionSignature processItemFunction) { return CreateSynchronousQueue(processItemFunction, null, DefaultProcessInterval, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new, keyed, synchronous (i.e., single process thread) with the default settings: /// ProcessInterval = 100, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False. /// /// Delegate which defines a method to process a key and value one at a time. /// A delegate which defines a method to indicate whether a key and value can be processed at this time. /// Returns the process queue ProcessDictionary. public static ProcessDictionary CreateSynchronousQueue(ProcessItemFunctionSignature processItemFunction, CanProcessItemFunctionSignature canProcessItemFunction) { return CreateSynchronousQueue(processItemFunction, canProcessItemFunction, DefaultProcessInterval, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new, keyed, synchronous (i.e., single process thread), using specified settings. /// /// Delegate which defines a method to process a key and value one at a time. /// a value which represents the process interval in milliseconds. /// The number of seconds before a process should timeout. /// A value that indicates whether a process should requeue an item on timeout. /// A value that indicates whether a process should requeue after an exception. /// Returns the process queue ProcessDictionary. public static ProcessDictionary CreateSynchronousQueue(ProcessItemFunctionSignature processItemFunction, double processInterval, int processTimeout, bool requeueOnTimeout, bool requeueOnException) { return CreateSynchronousQueue(processItemFunction, null, processInterval, processTimeout, requeueOnTimeout, requeueOnException); } /// /// Creates a new, keyed, synchronous (i.e., single process thread), using specified settings. /// /// Delegate which defines a method to process a key and value one at a time. /// A delegate which defines a method to indicate whether a key and value can be processed at this time. /// a value which represents the process interval in milliseconds. /// The number of seconds before a process should timeout. /// A value that indicates whether a process should requeue an item on timeout. /// A value that indicates whether a process should requeue after an exception. /// Returns the process queue ProcessDictionary. public static ProcessDictionary CreateSynchronousQueue(ProcessItemFunctionSignature processItemFunction, CanProcessItemFunctionSignature canProcessItemFunction, double processInterval, int processTimeout, bool requeueOnTimeout, bool requeueOnException) { return new ProcessDictionary(processItemFunction, canProcessItemFunction, processInterval, 1, processTimeout, requeueOnTimeout, requeueOnException); } /// /// Creates a new, keyed, real-time with the default settings: ProcessTimeout = Infinite, /// RequeueOnTimeout = False, RequeueOnException = False. /// /// Delegate which defines a method to process a key and value one at a time. /// Returns the process queue ProcessDictionary. public static ProcessDictionary CreateRealTimeQueue(ProcessItemFunctionSignature processItemFunction) { return CreateRealTimeQueue(processItemFunction, null, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new, keyed, real-time with the default settings: ProcessTimeout = Infinite, /// RequeueOnTimeout = False, RequeueOnException = False. /// /// Delegate which defines a method to process a key and value one at a time. /// A delegate which defines a method to indicate whether a key and value can be processed at this time. /// Returns the process queue ProcessDictionary. public static ProcessDictionary CreateRealTimeQueue(ProcessItemFunctionSignature processItemFunction, CanProcessItemFunctionSignature canProcessItemFunction) { return CreateRealTimeQueue(processItemFunction, canProcessItemFunction, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new, keyed, real-time , using specified settings. /// /// Delegate which defines a method to process a key and value one at a time. /// The number of seconds before a process should timeout. /// A value that indicates whether a process should requeue an item on timeout. /// A value that indicates whether a process should requeue after an exception. /// Returns the process queue ProcessDictionary. public static ProcessDictionary CreateRealTimeQueue(ProcessItemFunctionSignature processItemFunction, int processTimeout, bool requeueOnTimeout, bool requeueOnException) { return CreateRealTimeQueue(processItemFunction, null, processTimeout, requeueOnTimeout, requeueOnException); } /// /// Creates a new, keyed, real-time , using the specified settings. /// /// Delegate which defines a method to process a key and value one at a time. /// A delegate which defines a method to indicate whether a key and value can be processed at this time. /// The number of seconds before a process should timeout. /// A value that indicates whether a process should requeue an item on timeout. /// A value that indicates whether a process should requeue after an exception. /// Returns the process queue ProcessDictionary. public static ProcessDictionary CreateRealTimeQueue(ProcessItemFunctionSignature processItemFunction, CanProcessItemFunctionSignature canProcessItemFunction, int processTimeout, bool requeueOnTimeout, bool requeueOnException) { return new ProcessDictionary(processItemFunction, canProcessItemFunction, RealTimeProcessInterval, 1, processTimeout, requeueOnTimeout, requeueOnException); } #endregion #region [ Multi-Item Processing Constructors ] /// /// Creates a new asynchronous bulk-item with the default settings: ProcessInterval = 100, /// MaximumThreads = 5, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False. /// /// Delegate which defines a method to process at once. /// Returns the process queue . public static new ProcessDictionary CreateAsynchronousQueue(ProcessItemsFunctionSignature processItemsFunction) { return CreateAsynchronousQueue(processItemsFunction, null, DefaultProcessInterval, DefaultMaximumThreads, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new asynchronous bulk-item with the default settings: ProcessInterval = 100, /// MaximumThreads = 5, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False. /// /// Delegate which defines a method to process at once. /// Delegate which defines a method to know if a key and value can currently be processed. /// Returns the process queue . public static ProcessDictionary CreateAsynchronousQueue(ProcessItemsFunctionSignature processItemsFunction, CanProcessItemFunctionSignature canProcessItemFunction) { return CreateAsynchronousQueue(processItemsFunction, canProcessItemFunction, DefaultProcessInterval, DefaultMaximumThreads, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new asynchronous bulk-item with the default settings: ProcessInterval = 100, /// ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False /// /// Delegate which defines a method to process at once. /// An value indicating the maximum number of threads to use for processing items. /// Returns the process queue . public static new ProcessDictionary CreateAsynchronousQueue(ProcessItemsFunctionSignature processItemsFunction, int maximumThreads) { return CreateAsynchronousQueue(processItemsFunction, null, DefaultProcessInterval, maximumThreads, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new asynchronous bulk-item with the default settings: ProcessInterval = 100, /// ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False. /// /// Delegate which defines a method to process at once. /// Delegate which defines a method to know if a key and value can currently be processed. /// An value indicating the maximum number of threads to use for processing items. /// Returns the process queue . public static ProcessDictionary CreateAsynchronousQueue(ProcessItemsFunctionSignature processItemsFunction, CanProcessItemFunctionSignature canProcessItemFunction, int maximumThreads) { return CreateAsynchronousQueue(processItemsFunction, canProcessItemFunction, DefaultProcessInterval, maximumThreads, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new asynchronous bulk-item , using specified settings. /// /// Delegate which defines a method to process at once. /// Number of milliseconds between each process. /// An value indicating the maximum number of threads to use for processing items. /// An value indicating the number of seconds to wait for a process timeout. /// A value that indicates whether a process should requeue an item on timeout. /// A value that indicates whether a process should requeue after an exception. /// Returns the process queue . public static new ProcessDictionary CreateAsynchronousQueue(ProcessItemsFunctionSignature processItemsFunction, double processInterval, int maximumThreads, int processTimeout, bool requeueOnTimeout, bool requeueOnException) { return CreateAsynchronousQueue(processItemsFunction, null, processInterval, maximumThreads, processTimeout, requeueOnTimeout, requeueOnException); } /// /// Creates a new asynchronous bulk-item , using specified settings. /// /// Delegate which defines a method to process at once. /// Delegate which defines a method to know if a key and value can currently be processed. /// Number of milliseconds between each process. /// An value indicating the maximum number of threads to use for processing items. /// An value indicating the number of seconds to wait for a process timeout. /// A value that indicates whether a process should requeue an item on timeout. /// A value that indicates whether a process should requeue after an exception. /// Returns the process queue . public static ProcessDictionary CreateAsynchronousQueue(ProcessItemsFunctionSignature processItemsFunction, CanProcessItemFunctionSignature canProcessItemFunction, double processInterval, int maximumThreads, int processTimeout, bool requeueOnTimeout, bool requeueOnException) { return new ProcessDictionary(processItemsFunction, canProcessItemFunction, processInterval, maximumThreads, processTimeout, requeueOnTimeout, requeueOnException); } /// /// Creates a new synchronous bulk-item (i.e., single process thread) with the default settings: /// ProcessInterval = 100, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False. /// /// Delegate which defines a method to process at once. /// Returns the process queue . public static new ProcessDictionary CreateSynchronousQueue(ProcessItemsFunctionSignature processItemsFunction) { return CreateSynchronousQueue(processItemsFunction, null, DefaultProcessInterval, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new synchronous bulk-item (i.e., single process thread) with the default settings: /// ProcessInterval = 100, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False. /// /// Delegate which defines a method to process at once. /// Delegate which defines a method to know if a key and value can currently be processed. /// Returns the process queue . public static ProcessDictionary CreateSynchronousQueue(ProcessItemsFunctionSignature processItemsFunction, CanProcessItemFunctionSignature canProcessItemFunction) { return CreateSynchronousQueue(processItemsFunction, canProcessItemFunction, DefaultProcessInterval, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new synchronous bulk-item (i.e., single process thread), using specified settings. /// /// Delegate which defines a method to process at once. /// Number of milliseconds between each process. /// An value indicating the number of seconds to wait for a process timeout. /// A value that indicates whether a process should requeue an item on timeout. /// A value that indicates whether a process should requeue after an exception. /// Returns the process queue . public static new ProcessDictionary CreateSynchronousQueue(ProcessItemsFunctionSignature processItemsFunction, double processInterval, int processTimeout, bool requeueOnTimeout, bool requeueOnException) { return CreateSynchronousQueue(processItemsFunction, null, processInterval, processTimeout, requeueOnTimeout, requeueOnException); } /// /// Creates a new synchronous bulk-item (i.e., single process thread), using specified settings. /// /// Delegate which defines a method to process at once. /// Delegate which defines a method to know if a key and value can currently be processed. /// Number of milliseconds between each process. /// An value indicating the number of seconds to wait for a process timeout. /// A value that indicates whether a process should requeue an item on timeout. /// A value that indicates whether a process should requeue after an exception. /// Returns the process queue . public static ProcessDictionary CreateSynchronousQueue(ProcessItemsFunctionSignature processItemsFunction, CanProcessItemFunctionSignature canProcessItemFunction, double processInterval, int processTimeout, bool requeueOnTimeout, bool requeueOnException) { return new ProcessDictionary(processItemsFunction, canProcessItemFunction, processInterval, 1, processTimeout, requeueOnTimeout, requeueOnException); } /// /// Creates a new real-time bulk-item with the default settings: ProcessTimeout = Infinite, /// RequeueOnTimeout = False, RequeueOnException = False. /// /// Delegate which defines a method to process at once. /// Returns the process queue . public static new ProcessDictionary CreateRealTimeQueue(ProcessItemsFunctionSignature processItemsFunction) { return CreateRealTimeQueue(processItemsFunction, null, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new real-time bulk-item with the default settings: ProcessTimeout = Infinite, /// RequeueOnTimeout = False, RequeueOnException = False. /// /// Delegate which defines a method to process at once. /// Delegate which defines a method to know if a key and value can currently be processed. /// Returns the process queue . public static ProcessDictionary CreateRealTimeQueue(ProcessItemsFunctionSignature processItemsFunction, CanProcessItemFunctionSignature canProcessItemFunction) { return CreateRealTimeQueue(processItemsFunction, canProcessItemFunction, DefaultProcessTimeout, DefaultRequeueOnTimeout, DefaultRequeueOnException); } /// /// Creates a new real-time bulk-item , using specified settings. /// /// Delegate which defines a method to process at once. /// An value indicating the number of seconds to wait for a process timeout. /// A value that indicates whether a process should requeue an item on timeout. /// A value that indicates whether a process should requeue after an exception. /// Returns the process queue . public static new ProcessDictionary CreateRealTimeQueue(ProcessItemsFunctionSignature processItemsFunction, int processTimeout, bool requeueOnTimeout, bool requeueOnException) { return CreateRealTimeQueue(processItemsFunction, null, processTimeout, requeueOnTimeout, requeueOnException); } /// /// Creates a new real-time bulk-item , using specified settings. /// /// Delegate which defines a method to process at once. /// Delegate which defines a method to know if a key and value can currently be processed. /// An value indicating the number of seconds to wait for a process timeout. /// A value that indicates whether a process should requeue an item on timeout. /// A value that indicates whether a process should requeue after an exception. /// Returns the process queue . public static ProcessDictionary CreateRealTimeQueue(ProcessItemsFunctionSignature processItemsFunction, CanProcessItemFunctionSignature canProcessItemFunction, int processTimeout, bool requeueOnTimeout, bool requeueOnException) { return new ProcessDictionary(processItemsFunction, canProcessItemFunction, RealTimeProcessInterval, 1, processTimeout, requeueOnTimeout, requeueOnException); } #endregion #endregion } }