weka.core.FastVector Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of weka-dev Show documentation
The Waikato Environment for Knowledge Analysis (WEKA), a machine learning workbench. This version represents the developer version, the "bleeding edge" of development, you could say. New functionality gets added to this version.
There is a newer version: 3.9.6
Show newest version
/*
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program.  If not, see .
 */

/*
 *    FastVector.java
 *    Copyright (C) 1999-2012 University of Waikato, Hamilton, New Zealand
 *
 */

package weka.core;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;

/**
 * Simple extension of ArrayList. Exists for legacy reasons.
 * 
 * @author Eibe Frank ([email protected])
 * @version $Revision: 10203 $
 */
@Deprecated
public class FastVector extends ArrayList implements Copyable,
  RevisionHandler {

  /** for serialization */
  private static final long serialVersionUID = -2173635135622930169L;

  /**
   * Constructs an empty vector with initial capacity zero.
   */
  public FastVector() {
    super();
  }

  /**
   * Constructs a vector with the given capacity.
   * 
   * @param capacity the vector's initial capacity
   */
  public FastVector(int capacity) {
    super(capacity);
  }

  /**
   * Adds an element to this vector. Increases its capacity if its not large
   * enough.
   * 
   * @param element the element to add
   */
  public final void addElement(E element) {
    add(element);
  }

  /**
   * Produces a shallow copy of this vector.
   * 
   * @return the new vector
   */
  @Override
  public final FastVector copy() {
    return Utils.cast(clone());
  }

  /**
   * Clones the vector and shallow copies all its elements. The elements have to
   * implement the Copyable interface.
   * 
   * @return the new vector
   */
  public final FastVector copyElements() {

    FastVector copy = copy();
    for (int i = 0; i < size(); i++) {
      copy.set(i, Utils. cast(((Copyable) get(i)).copy()));
    }
    return copy;
  }

  /**
   * Returns the element at the given position.
   * 
   * @param index the element's index
   * @return the element with the given index
   */
  public final E elementAt(int index) {
    return get(index);
  }

  /**
   * Returns an enumeration of this vector.
   * 
   * @return an enumeration of this vector
   */
  public final Enumeration elements() {
    return new WekaEnumeration(this);
  }

  /**
   * Returns an enumeration of this vector, skipping the element with the given
   * index.
   * 
   * @param index the element to skip
   * @return an enumeration of this vector
   */
  public final Enumeration elements(int index) {
    return new WekaEnumeration(this, index);
  }

  /**
   * Returns the first element of the vector.
   * 
   * @return the first element of the vector
   */
  public final E firstElement() {
    return get(0);
  }

  /**
   * Inserts an element at the given position.
   * 
   * @param element the element to be inserted
   * @param index the element's index
   */
  public final void insertElementAt(E element, int index) {
    add(index, element);
  }

  /**
   * Returns the last element of the vector.
   * 
   * @return the last element of the vector
   */
  public final E lastElement() {
    return get(size() - 1);
  }

  /**
   * Deletes an element from this vector.
   * 
   * @param index the index of the element to be deleted
   */
  public final void removeElementAt(int index) {
    remove(index);
  }

  /**
   * Removes all components from this vector and sets its size to zero.
   */
  public final void removeAllElements() {
    clear();
  }

  /**
   * Appends all elements of the supplied vector to this vector.
   * 
   * @param toAppend the FastVector containing elements to append.
   */
  public final void appendElements(Collection toAppend) {
    addAll(toAppend);
  }

  /**
   * Sets the vector's capacity to the given value.
   * 
   * @param capacity the new capacity
   */
  public final void setCapacity(int capacity) {
    ensureCapacity(capacity);
  }

  /**
   * Sets the element at the given index.
   * 
   * @param element the element to be put into the vector
   * @param index the index at which the element is to be placed
   */
  public final void setElementAt(E element, int index) {
    set(index, element);
  }

  /**
   * Swaps two elements in the vector.
   * 
   * @param first index of the first element
   * @param second index of the second element
   */
  public final void swap(int first, int second) {

    E in = get(first);
    set(first, get(second));
    set(second, in);
  }

  /**
   * Returns the revision string.
   * 
   * @return the revision
   */
  @Override
  public String getRevision() {
    return RevisionUtils.extract("$Revision: 10203 $");
  }
}