/// <summary>
		/// Construct a NotifyCollectionChangedEventArgs that describes a one-item change. 
		/// </summary> 
		/// <param name="action">The action that caused the event.</param>
		/// <param name="changedItem">The item affected by the change.</param> 
		/// <param name="index">The index where the change occurred.</param>
		public NotifyCollectionChangedEventArgs(
			NotifyCollectionChangedAction action,
			object                        changedItem,
			int                           index)
			: this(action, changedItem == null? null: new[]{ changedItem }, index)
		{
		}

 public ControllerCollectionChangedEventArgs(Entity entity, AudioEmitterSoundController controller, AudioEmitterComponent component, NotifyCollectionChangedAction action)
 {
     Entity = entity;
     Controller = controller;
     EmitterComponent = component;
     Action = action;
 }

        /// <summary>
        /// Construct a NotifyCollectionChangedEventArgs that describes a reset change. 
        /// </summary> 
        /// <param name="action">The action that caused the event (must be Reset).
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action)
        {
            if (action != NotifyCollectionChangedAction.Reset)
                throw new ArgumentException("WrongActionForCtor, NotifyCollectionChangedAction.Reset", "action");

            InitializeAdd(action, null, -1);
        }

        //------------------------------------------------------
        //
        //  Constructors
        //
        //------------------------------------------------------
        /// <summary>
        /// Construct a NotifyCollectionChangedEventArgs that describes a reset change.
        /// </summary>
        /// <param name="action">The action that caused the event (must be Reset).</param>
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action)
        {
            if (action != NotifyCollectionChangedAction.Reset)
                throw new ArgumentException("This constructor can only be used with the Reset action.", "action");

            InitializeAdd(action, null, -1);
        }

 public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList changedItems, int index, int oldIndex) 
 {
     this.Action = action;
     this.NewItems = changedItems;
     this.NewStartingIndex = index;
     this.OldStartingIndex = oldIndex;
 }

 public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList changedItems)
 {
   this._newStartingIndex = -1;
   this._oldStartingIndex = -1;
   if (((action != NotifyCollectionChangedAction.Add) && (action != NotifyCollectionChangedAction.Remove)) && (action != NotifyCollectionChangedAction.Reset))
   {
     throw new ArgumentException("Must Be Reset Add Or Remove Action For Ctor", "action");
   }
   if (action == NotifyCollectionChangedAction.Reset)
   {
     if (changedItems != null)
     {
       throw new ArgumentException("Reset Action Requires Null Item", "action");
     }
     this.InitializeAdd(action, null, -1);
   }
   else
   {
     if (changedItems == null)
     {
       throw new ArgumentNullException("changed Items");
     }
     this.InitializeAddOrRemove(action, changedItems, -1);
   }
 }

 public CollectionChangedActionItem(IList list, NotifyCollectionChangedAction actionToUndo, IReadOnlyCollection<object> items, int index)
     : this(list, actionToUndo)
 {
     if (items == null) throw new ArgumentNullException("items");
     this.items = items;
     this.index = index;
 }

		public NotifyCollectionChangedEventArgs (NotifyCollectionChangedAction action, IList changedItems, int startingIndex)
		{
			this.action = action;

			if (action == NotifyCollectionChangedAction.Add || action == NotifyCollectionChangedAction.Remove) {
				if (changedItems == null)
					throw new ArgumentNullException ("changedItems");

				if (startingIndex < -1)
					throw new ArgumentException ("The value of startingIndex must be -1 or greater.", "startingIndex");

				if (action == NotifyCollectionChangedAction.Add)
					InitializeAdd (changedItems, startingIndex);
				else
					InitializeRemove (changedItems, startingIndex);
			} else if (action == NotifyCollectionChangedAction.Reset) {
				if (changedItems != null)
					throw new ArgumentException ("This constructor can only be used with the Reset action if changedItems is null", "changedItems");

				if (startingIndex != -1)
					throw new ArgumentException ("This constructor can only be used with the Reset action if startingIndex is -1", "startingIndex");
			} else {
				throw new ArgumentException ("This constructor can only be used with the Reset, Add, or Remove actions.", "action");
			}
		}

 internal ItemsChangedEventArgs(NotifyCollectionChangedAction action,
                                 GeneratorPosition position,
                                 int itemCount,
                                 int itemUICount) : this(action, position, new GeneratorPosition(-1, 0), itemCount, itemUICount)
          
 {
 }

 public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object changedItem, int index)
 {
     IList changedItems = new[] { changedItem };
     _action = action;
     if (action == NotifyCollectionChangedAction.Add)
     {
         InitializeAdd(changedItems, index);
     }
     else if (action == NotifyCollectionChangedAction.Remove)
     {
         InitializeRemove(changedItems, index);
     }
     else if (action == NotifyCollectionChangedAction.Reset)
     {
         if (changedItem != null)
         {
             throw new ArgumentException("This constructor can only be used with the Reset action if changedItem is null", "changedItem");
         }
         if (index != -1)
         {
             throw new ArgumentException("This constructor can only be used with the Reset action if index is -1", "index");
         }
     }
     else
     {
         throw new ArgumentException("This constructor can only be used with the Reset, Add, or Remove actions.", "action");
     }
 }

 public CollectionChangeOperation(IList list, NotifyCollectionChangedAction actionToUndo, IReadOnlyCollection<object> items, int index, IEnumerable<IDirtiable> dirtiables)
     : this(list, actionToUndo, dirtiables)
 {
     if (items == null) throw new ArgumentNullException(nameof(items));
     this.items = items;
     this.index = index;
 }

 internal DictionaryChangedEventArgs(NotifyCollectionChangedAction action, string key, object oldValue, object newValue)
 {
     this.Action = action;
     this.Key = key;
     this.OldValue = oldValue;
     this.NewValue = newValue;
 }

        //------------------------------------------------------
        //
        //  Constructors
        //
        //------------------------------------------------------

        /// <summary>
        /// Construct a NotifyCollectionChangedEventArgs that describes a reset change.
        /// </summary>
        /// <param name="action">The action that caused the event (must be Reset).</param>
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action)
        {
            if (action != NotifyCollectionChangedAction.Reset)
                throw new ArgumentException(SR.Format(SR.WrongActionForCtor, NotifyCollectionChangedAction.Reset), nameof(action));

            InitializeAdd(action, null, -1);
        }

 private NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IEnumerable<object> oldItems, int oldStartingIndex, IEnumerable<object> newItems, int newStartingIndex)
 {
     this.Action = action;
     this.OldItems = oldItems;
     this.OldStartingIndex = oldStartingIndex;
     this.NewItems = newItems;
     this.NewStartingIndex = newStartingIndex;
 }

 public NotifyCollectionChangedEventArgs (NotifyCollectionChangedAction action, int newStartingIndex, int oldStartingIndex, IList newItems, IList oldItems)
 {
   Action = action;
   NewStartingIndex = newStartingIndex;
   OldStartingIndex = oldStartingIndex;
   NewItems = newItems;
   OldItems = oldItems;
 }

 public AttributeEventArgs(Attribute _attribute, AttributeValue _newValue, AttributeValue _oldValue, NotifyCollectionChangedAction _action)
     : base()
 {
     this.attribute = _attribute;
     this.newValue = _newValue;
     this.oldValue = _oldValue;
     this.action = _action;
 }

 public MappingsEventArgs(NotifyCollectionChangedAction action,
    List<IMappingsConfiguration> added,
    List<IMappingsConfiguration> removed)
 {
     this.Action = action;
     this.AddedItems = added;
     this.RemovedItems = removed;
 }

		internal ItemsChangedEventArgs (NotifyCollectionChangedAction action, int itemCount, int itemUICount, GeneratorPosition oldPosition, GeneratorPosition position)
		{
			this.action = action;
			item_count = itemCount;
			item_ui_count = itemUICount;
			old_position = oldPosition;
			this.position = position;
		}

 public TrackingCollectionChangedEventArgs(NotifyCollectionChangedAction action, object item, object oldItem, int index = -1, bool collectionChanged = false)
 {
     Action = action;
     Item = item;
     OldItem = oldItem;
     Index = index;
     CollectionChanged = collectionChanged;
 }

 public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object item, int index, int oldIndex) 
 {
     Action = action;
     Item = item;
     Index = index;
     Length = 1;
     OldIndex = oldIndex;
 }