/**
  * Copyright (c): Uwe Schmidt, FH Wedel
  *
  * You may study, modify and distribute this source code
  * FOR NON-COMMERCIAL PURPOSES ONLY.
  * This copyright message has to remain unchanged.
  *
  * Note that this document is provided 'as is',
  * WITHOUT WARRANTY of any kind either expressed or implied.
  */

/**
 *
 * @author Uwe Schmidt
 *
 * die Vector Klasse erweitert
 * um die Ordnungsfunktionen
 *
 * hier muss mit der Schnittstelle Ordering
 * gearbeitet werden
 *
 * es wird angenommen, dass die Elemente im Vektor
 * die Ordering Schnittstelle implementieren
 *
 */

//--------------------

import java.util.Vector;

//--------------------

public
class List
  extends    Vector
  implements Ordering
{
  //--------------------
  // ein Konstrukor fuer leere Liste

  public
  List() {
    super();
  }

  //--------------------
  // die Vergleichsoperationen
  // die 2 Basis Operationen

  public
  boolean eq(Object v2) {
    List
      l2 = (List)v2;

    if ( elementCount != l2.elementCount )
      // Laengen verschieden
      return
	false;

    for(int i = 0;
	i < elementCount;
	++i) {

      Ordering
	e1 = (Ordering)(elementAt(i));

      if ( e1.ne(l2.elementAt(i)) )
	// ein Element verschieden
	return
	  false;
    }

    // alle Elemente gleich
    return
      true;
  }

  //--------------------
  // lexikographische Ordnung

  public
  boolean ge(Object v2) {
    List l2 = (List)v2;

    int len1 = elementCount;
    int len2 = l2.elementCount;

    for(int i = 0; ; ++i) {
      if ( i == len2 ) // l2 leer
	return
	  true;

      if ( i == len1 ) // l2 nicht leer, l1 leer
	return
	  false;

      // l1 und l2 nicht leer
      {
	Ordering
	  e1 = (Ordering)(elementAt(i));

	Object
	  e2 = l2.elementAt(i);

	if ( e1.ne(e2) )
	  // l1(i) != l2(i) --> Resultat steht fest
	  return
	    e1.ge(e2);

	// l1(i) == l2(i) --> naechstes Element vergleichen
      }
    }
  }

  //--------------------
  // die anderen 4 Operationen
  // werden aus AbstractOrdering kopiert
  // das geht nicht anders !!!

  public
  boolean ne(Object v2) {
    return
      ! eq(v2);
  }

  public
  boolean gr(Object v2) {
    return
      ge(v2) && ! eq(v2);
  }

  public
  boolean le(Object v2) {
    return
      ! gr(v2);
  }

  public
  boolean lt(Object v2) {
    return
      ! ge(v2);
  }

}

//--------------------