/*  LISTTEM2.CPP

Esimerkki templaten k„yt”st„. Muutama ei-inline funktio luokkaan
Ks. LISTARR.CPP

vl 6.11.1993

Teht„vi„ 1) Peri luokasta luokka cList2, joka on kaksisuuntainen ja
            jossa voidaan siis liikkua kumpaankin suuntaan.

         2) Toteuta cList "oikeana" dynaamisena listana.

         3) Peri teht„v„n 2 listasta 2-suuntainen lista.
            Onnistuuko kunnolla?

         4) J„senfunktiot first,last ja next ovat oikeastaan
            tarpeettomia, koska sama ominaisuus saadaan aikaan
            tobegin, toend, forward ja current -funktioiden avulla.
            Kuitenkin joskus tarvitaan ainakin kahta toisistaan
            riippumattomasti listaa k„sittelev„„ "iteraattoria".
            Esit„ ratkaisuehdotus, jolla lista voidaan samanaikaisesti
            tulostaa sek„ alusta ett„ lopusta p„in, eli esim lista 1 2 3
            tulostuisi: 1 3 2 2 3 1
*/

#include <iostream.h>

inline int inside(int a,int x,int b) // x v„lille [a,b], jos b<a niin a
  { return b < a ? a : x < a ? a : x < b ? x : b; }

#define MAX_ELEM 100

template <class TYPE>

class cList {
protected:
  int nelem;             // Alkioiden lukum„„r„
  TYPE data[MAX_ELEM];   // Alkioden taulukko.
  int cursor;            // Sijainti listassa
public:
  cList()                 { nelem = 0; tobegin();                     }
  ~cList()                { nelem = 0;                                }

  int  out()       const { return ( cursor < 0 || nelem <= cursor ); }
  int  tobegin()         { cursor = 0;       return out();           }
  int  forward()         { ++cursor;         return out();           }
  int  toend()           { cursor = nelem-1; return out();           }
  TYPE current()   const { return data[inside(0,cursor,nelem-1)];    }
  TYPE first()           { tobegin(); return current();              }
  TYPE next()            { forward(); return current();              }
  TYPE last()            { toend();   return current();              }
  int  empty()     const;
  int  add(TYPE p);
}; /* cList */

template <class TYPE>
int  cList<TYPE>::empty() const {
  return ( nelem == 0 );
}

template <class TYPE>
int  cList<TYPE>::add(TYPE p)
{
  if ( nelem >= MAX_ELEM ) return 1;
  data[nelem++] = p;
  return 0;
}


/****************************************************************************/
class piste {
  int x,y;
public:
  piste(int ix=0, int iy=0) { x = ix; y = iy; }
  friend ostream &operator<< (ostream &stream, piste &p);
};

ostream &operator<< (ostream &stream, piste &p)   // Inserter
{
  stream << '(' << p.x << ',' << p.y << ')';
  return stream;
}


#define VIIVA "------------------------------------------------------------\n"
/****************************************************************************/
int main(void)
{
  cout << VIIVA;

  cList<char> lc; lc.add('a'); lc.add('b'); lc.add('c'); lc.add('d');

  for (char c=lc.first(); !lc.out(); c=lc.next() )
    cout << c << " ";

  cout << "\n" << VIIVA;

  cList<double> ld; ld.add(1.2); ld.add(20.3); ld.add(300.4); ld.add(400.5);

  for (double d=ld.first(); !ld.out(); d=ld.next() )
    cout << d << " ";

  cout << "\n" << VIIVA;

  cList<piste> lp; lp.add(piste(1,1)); lp.add(piste(2,4)); lp.add(piste(3,8));

  for (piste p=lp.first(); !lp.out(); p=lp.next() )
    cout << p << " ";

  cout << "\n" << VIIVA;

  cList<int> li; li.add(1); li.add(2); li.add(3);

  for (li.tobegin(); !li.out(); li.forward() )
    cout << li.current() << " ";

  cout << "\n" << VIIVA;
  return 0;
}