/*
    * Copyright (c) 1998, 2005 Gargoyle Software Inc. All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    *
    * 1. Redistributions of source code must retain the above copyright notice,
    *    this list of conditions and the following disclaimer.
    * 2. Redistributions in binary form must reproduce the above copyright notice,
   *    this list of conditions and the following disclaimer in the documentation
   *    and/or other materials provided with the distribution.
   * 3. The end-user documentation included with the redistribution, if any, must
   *    include the following acknowledgment:
   *
   *       "This product includes software developed by Gargoyle Software Inc.
   *        (http://www.GargoyleSoftware.com/)."
   *
   *    Alternately, this acknowledgment may appear in the software itself, if
   *    and wherever such third-party acknowledgments normally appear.
   * 4. The name "Gargoyle Software" must not be used to endorse or promote
   *    products derived from this software without prior written permission.
   *    For written permission, please contact info@GargoyleSoftware.com.
   * 5. Products derived from this software may not be called "GSBase", nor may
   *    "GSBase" appear in their name, without prior written permission of
   *    Gargoyle Software Inc.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARGOYLE
   * SOFTWARE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
   * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
   * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package com.gargoylesoftware.base.collections;
  
  import com.gargoylesoftware.base.util.DetailedIllegalArgumentException;
  import com.gargoylesoftware.base.util.DetailedNullPointerException;
  import java.util.Collections;
  import java.util.EventObject;
  import java.util.List;
  
  /***
   * An event that is fired when a NotificationList changes.
   *
   * @version $Revision: 1.5 $
   * @author <a href="mailto:mbowler@GargoyleSoftware.com">Mike Bowler</a>
   */
  public class NotificationListEvent extends EventObject {
      private static final long serialVersionUID = -1402888290373923581L;
  	/***
       * Action indicating that an item was inserted into the list.
       */
      public static final int INSERT = 1;
      /***
       * Action indicating that an item was removed from the list.
       */
      public static final int REMOVE = 2;
      /***
       * Action indicating that an item in the list was change.
       */
      public static final int CHANGE = 3;
  
      private final int startIndex_;
      private final int endIndex_;
      private final int action_;
      private final List oldValues_;
      private final List newValues_;
  
      /***
       * Create a new event.
       * @param source The NotificationList
       * @param action The action that occured.  This will be one of INSERT, REMOVE or CHANGE.
       * @param startIndex The index of the first item that is affected.
       * @param endIndex The index of the last item that is affected.
       * @param oldValues The original values.
       * @param newValues The new values.
       */
      public NotificationListEvent( final NotificationList source,
                                    final int action,
                                    final int startIndex,
                                    final int endIndex,
                                    final List oldValues,
                                    final List newValues) {
          super(source);
          startIndex_ = startIndex;
          endIndex_ = endIndex;
          if( oldValues.size() == 0 ) {
              oldValues_ = Collections.EMPTY_LIST;
          }
          else {
              oldValues_ = Collections.unmodifiableList(oldValues);
          }
  
          if( newValues.size() == 0 ) {
              newValues_ = Collections.EMPTY_LIST;
         }
         else {
             newValues_ = Collections.unmodifiableList(newValues);
         }
 
         action_ = action;
 
         switch( action ) {
         case INSERT:
         case REMOVE:
         case CHANGE:
             // Normal
             break;
 
         default:
             throw new DetailedIllegalArgumentException("action", new Integer(action), "Unexpected value");
         }
 
         if( startIndex < 0 ) {
             throw new DetailedIllegalArgumentException("startIndex", new Integer(startIndex), "less than zero");
         }
 
         if( endIndex < startIndex ) {
             throw new IllegalArgumentException("endIndex<startIndex: "
                                                + endIndex
                                                + "<"
                                                + startIndex);
         }
 
         assertNotNull("oldValues", oldValues);
         assertNotNull("newValues", newValues);
     }
 
     /***
      * Return the start index.
      * @return The start index.
      */
     public int getStartIndex() {
         return startIndex_;
     }
 
     /***
      * Return the end index.
      * @return The end index.
      */
     public int getEndIndex() {
         return endIndex_;
     }
 
     /***
      * Return the action which will be one of INSERT, REMOVE, CHANGE.
      * @return The action.
      */
     public int getAction() {
         return action_;
     }
 
     /***
      * Return the new values
      * @return The new values.
      */
     public List getNewValues() {
         return newValues_;
     }
 
     /***
      * Return the old values.
      * @return The old values.
      */
     public List getOldValues() {
         return oldValues_;
     }
 
 
     /***
      * Throw an exception if the specified object is null
      * @param fieldName The name of the paremeter we are checking
      * @param object The value of the parameter we are checking
      */
     protected final void assertNotNull( final String fieldName, final Object object ) {
         if( object == null ) {
             throw new DetailedNullPointerException(fieldName);
         }
     }
 }