/// <summary>
 ///		Returns the zero-based index of the first occurrence of a <see cref="eServiceCategory"/>
 ///		in the <c>ServiceCategoryCollection</c>.
 /// </summary>
 /// <param name="item">The <see cref="eServiceCategory"/> to locate in the <c>ServiceCategoryCollection</c>.</param>
 /// <returns>
 ///		The zero-based index of the first occurrence of <paramref name="item"/>
 ///		in the entire <c>ServiceCategoryCollection</c>, if found; otherwise, -1.
 ///	</returns>
 public virtual int IndexOf(eServiceCategory item)
 {
     for (int i = 0; i != m_count; ++i)
     {
         if (m_array[i].Equals(item))
         {
             return(i);
         }
     }
     return(-1);
 }
 /// <summary>
 ///		Determines whether a given <see cref="eServiceCategory"/> is in the <c>ServiceCategoryCollection</c>.
 /// </summary>
 /// <param name="item">The <see cref="eServiceCategory"/> to check for.</param>
 /// <returns><c>true</c> if <paramref name="item"/> is found in the <c>ServiceCategoryCollection</c>; otherwise, <c>false</c>.</returns>
 public virtual bool Contains(eServiceCategory item)
 {
     for (int i = 0; i != m_count; ++i)
     {
         if (m_array[i].Equals(item))
         {
             return(true);
         }
     }
     return(false);
 }
        /// <summary>
        ///		Removes the first occurrence of a specific <see cref="eServiceCategory"/> from the <c>ServiceCategoryCollection</c>.
        /// </summary>
        /// <param name="item">The <see cref="eServiceCategory"/> to remove from the <c>ServiceCategoryCollection</c>.</param>
        /// <exception cref="ArgumentException">
        ///		The specified <see cref="eServiceCategory"/> was not found in the <c>ServiceCategoryCollection</c>.
        /// </exception>
        public virtual void Remove(eServiceCategory item)
        {
            int i = IndexOf(item);

            if (i < 0)
            {
                throw new System.ArgumentException("Cannot remove the specified item because it was not found in the specified Collection.");
            }

            ++m_version;
            RemoveAt(i);
        }
        /// <summary>
        ///		Adds a <see cref="eServiceCategory"/> to the end of the <c>ServiceCategoryCollection</c>.
        /// </summary>
        /// <param name="item">The <see cref="eServiceCategory"/> to be added to the end of the <c>ServiceCategoryCollection</c>.</param>
        /// <returns>The index at which the value has been added.</returns>
        public virtual int Add(eServiceCategory item)
        {
            if (m_count == m_array.Length)
            {
                EnsureCapacity(m_count + 1);
            }

            m_array[m_count] = item;
            m_version++;

            return(m_count++);
        }
            public override void Remove(eServiceCategory x)
            {
                rwLock.AcquireWriterLock(timeout);

                try
                {
                    collection.Remove(x);
                }
                finally
                {
                    rwLock.ReleaseWriterLock();
                }
            }
            public override void Insert(int pos, eServiceCategory x)
            {
                rwLock.AcquireWriterLock(timeout);

                try
                {
                    collection.Insert(pos, x);
                }
                finally
                {
                    rwLock.ReleaseWriterLock();
                }
            }
            public override int IndexOf(eServiceCategory x)
            {
                int result = 0;

                rwLock.AcquireReaderLock(timeout);

                try
                {
                    result = collection.IndexOf(x);
                }
                finally
                {
                    rwLock.ReleaseReaderLock();
                }

                return(result);
            }
            public override bool Contains(eServiceCategory x)
            {
                bool result = false;

                rwLock.AcquireReaderLock(timeout);

                try
                {
                    result = collection.Contains(x);
                }
                finally
                {
                    rwLock.ReleaseReaderLock();
                }

                return(result);
            }
            public override int Add(eServiceCategory x)
            {
                int result = 0;

                rwLock.AcquireWriterLock(timeout);

                try
                {
                    result = collection.Add(x);
                }
                finally
                {
                    rwLock.ReleaseWriterLock();
                }

                return(result);
            }
        /// <summary>
        ///		Removes the element at the specified index of the <c>ServiceCategoryCollection</c>.
        /// </summary>
        /// <param name="index">The zero-based index of the element to remove.</param>
        /// <exception cref="ArgumentOutOfRangeException">
        ///		<para><paramref name="index"/> is less than zero</para>
        ///		<para>-or-</para>
        ///		<para><paramref name="index"/> is equal to or greater than <see cref="ServiceCategoryCollection.Count"/>.</para>
        /// </exception>
        public virtual void RemoveAt(int index)
        {
            ValidateIndex(index);             // throws

            m_count--;

            if (index < m_count)
            {
                Array.Copy(m_array, index + 1, m_array, index, m_count - index);
            }

            // We can't set the deleted entry equal to null, because it might be a value type.
            // Instead, we'll create an empty single-element array of the right type and copy it
            // over the entry we want to erase.
            eServiceCategory[] temp = new eServiceCategory[1];
            Array.Copy(temp, 0, m_array, m_count, 1);
            m_version++;
        }
        /// <summary>
        ///		Inserts an element into the <c>ServiceCategoryCollection</c> at the specified index.
        /// </summary>
        /// <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
        /// <param name="item">The <see cref="eServiceCategory"/> to insert.</param>
        /// <exception cref="ArgumentOutOfRangeException">
        ///		<para><paramref name="index"/> is less than zero</para>
        ///		<para>-or-</para>
        ///		<para><paramref name="index"/> is equal to or greater than <see cref="ServiceCategoryCollection.Count"/>.</para>
        /// </exception>
        public virtual void Insert(int index, eServiceCategory item)
        {
            ValidateIndex(index, true);             // throws

            if (m_count == m_array.Length)
            {
                EnsureCapacity(m_count + 1);
            }

            if (index < m_count)
            {
                Array.Copy(m_array, index, m_array, index + 1, m_count - index);
            }

            m_array[index] = item;
            m_count++;
            m_version++;
        }
 public override void Remove(eServiceCategory x)
 {
     throw new NotSupportedException("This is a Read Only Collection and can not be modified");
 }
 public override int IndexOf(eServiceCategory x)
 {
     return(m_collection.IndexOf(x));
 }
 public override bool Contains(eServiceCategory x)
 {
     return(m_collection.Contains(x));
 }