/**
   * Adds or updates an item in the series and sends a {@link SeriesChangeEvent} to all registered
   * listeners.
   *
   * @param item the data item (<code>null</code> not permitted).
   * @return A copy of the overwritten data item, or <code>null</code> if no item was overwritten.
   * @since 1.0.14
   */
  public XYDataItem addOrUpdate(XYDataItem item) {
    ParamChecks.nullNotPermitted(item, "item");
    if (this.allowDuplicateXValues) {
      add(item);
      return null;
    }

    // if we get to here, we know that duplicate X values are not permitted
    XYDataItem overwritten = null;
    int index = indexOf(item.getX());
    if (index >= 0) {
      XYDataItem existing = (XYDataItem) this.data.get(index);
      overwritten = (XYDataItem) existing.clone();
      // figure out if we need to iterate through all the y-values
      boolean iterate = false;
      double oldY = existing.getYValue();
      if (!Double.isNaN(oldY)) {
        iterate = oldY <= this.minY || oldY >= this.maxY;
      }
      existing.setY(item.getY());

      if (iterate) {
        findBoundsByIteration();
      } else if (item.getY() != null) {
        double yy = item.getY().doubleValue();
        this.minY = minIgnoreNaN(this.minY, yy);
        this.maxY = maxIgnoreNaN(this.maxY, yy);
      }
    } else {
      // if the series is sorted, the negative index is a result from
      // Collections.binarySearch() and tells us where to insert the
      // new item...otherwise it will be just -1 and we should just
      // append the value to the list...
      item = (XYDataItem) item.clone();
      if (this.autoSort) {
        this.data.add(-index - 1, item);
      } else {
        this.data.add(item);
      }
      updateBoundsForAddedItem(item);

      // check if this addition will exceed the maximum item count...
      if (getItemCount() > this.maximumItemCount) {
        XYDataItem removed = (XYDataItem) this.data.remove(0);
        updateBoundsForRemovedItem(removed);
      }
    }
    fireSeriesChanged();
    return overwritten;
  }
  /**
   * Creates a new series by copying a subset of the data in this time series.
   *
   * @param start the index of the first item to copy.
   * @param end the index of the last item to copy.
   * @return A series containing a copy of this series from start until end.
   * @throws CloneNotSupportedException if there is a cloning problem.
   */
  public XYSeries createCopy(int start, int end) throws CloneNotSupportedException {

    XYSeries copy = (XYSeries) super.clone();
    copy.data = new java.util.ArrayList();
    if (this.data.size() > 0) {
      for (int index = start; index <= end; index++) {
        XYDataItem item = (XYDataItem) this.data.get(index);
        XYDataItem clone = (XYDataItem) item.clone();
        try {
          copy.add(clone);
        } catch (SeriesException e) {
          System.err.println("Unable to add cloned data item.");
        }
      }
    }
    return copy;
  }
 /**
  * Adds a data item to the series and, if requested, sends a {@link SeriesChangeEvent} to all
  * registered listeners.
  *
  * @param item the (x, y) item (<code>null</code> not permitted).
  * @param notify a flag that controls whether or not a {@link SeriesChangeEvent} is sent to all
  *     registered listeners.
  */
 public void add(XYDataItem item, boolean notify) {
   ParamChecks.nullNotPermitted(item, "item");
   item = (XYDataItem) item.clone();
   if (this.autoSort) {
     int index = Collections.binarySearch(this.data, item);
     if (index < 0) {
       this.data.add(-index - 1, item);
     } else {
       if (this.allowDuplicateXValues) {
         // need to make sure we are adding *after* any duplicates
         int size = this.data.size();
         while (index < size && item.compareTo(this.data.get(index)) == 0) {
           index++;
         }
         if (index < this.data.size()) {
           this.data.add(index, item);
         } else {
           this.data.add(item);
         }
       } else {
         throw new SeriesException("X-value already exists.");
       }
     }
   } else {
     if (!this.allowDuplicateXValues) {
       // can't allow duplicate values, so we need to check whether
       // there is an item with the given x-value already
       int index = indexOf(item.getX());
       if (index >= 0) {
         throw new SeriesException("X-value already exists.");
       }
     }
     this.data.add(item);
   }
   updateBoundsForAddedItem(item);
   if (getItemCount() > this.maximumItemCount) {
     XYDataItem removed = (XYDataItem) this.data.remove(0);
     updateBoundsForRemovedItem(removed);
   }
   if (notify) {
     fireSeriesChanged();
   }
 }
 /**
  * Return the data item with the specified index.
  *
  * @param index the index.
  * @return The data item with the specified index.
  */
 public XYDataItem getDataItem(int index) {
   XYDataItem item = (XYDataItem) this.data.get(index);
   return (XYDataItem) item.clone();
 }