/* dyntaul.h */
/****************************************************************************
  Sis„lt„„ m„„ritykset yleisille dynaamisille taulukoille:

  cDynTaul<TYYPPI>:      - pelkk„ taulukko
  ==========================================================================
    julkiset metodit:
      int lisaa(const TYYPPI &n);
      const TYYPPI &anna(int i) const;
      int etsi(const TYYPPI &e,itn alku=0) const;
      const cDynTaul operator=(const cDynTaul);

    taulukkoon voidaan tallettaa olioita, joissa on seuraavat

      operator==(const cOlio &) - vertaa oliota

  cDynTaul_r<TYYPPI>:    - taulukko, joka osaa lukea itsens„ tiedosta
  ==========================================================================
    julkiset metodit:
      int lue(const char *nimi);
      friend istream &operator>>(istream &is,cDynTaulu_r<TYYPPI> &taul);

    taulukkoon voidaan tallettaa olioita, joissa on aikaisemman lis„ksi
    seuraavat julkiset metodit:

      cOlio()                   - oletus rakentaja
      operator<<(istream &os, cOlio &olio)

  cDynTaul_rw<TYYPPI>:   - taulukko, joka osaa kirjoittaa itsens„ tiedostoon
  ==========================================================================
    julkiset metodit:
      int kirjoita(const char *nimi=NULL,const char *ero=NULL);
      string Erotin(const string *ero);
        - vaihtaa erottimen, joka laitetaan alkioiden v„liin
          palauttaa edellisen erottimen
      ostream &tulosta(ostream &os,const char *erotin=NULL) const;
      friend ostream &operator<<(ostream &os,const cDynTaulu_rw<TYYPPI> &taul);

    taulukkoon voidaan tallettaa olioita, joissa on aikaisemman lis„ksi
    seuraavat julkiset metodit:

      operator>>(ostream &os, const cOlio &olio)

  Vesa Lappalainen 12.4.1996

*****************************************************************************/
//---------------------------------------------------------------------------
#ifndef __DYNTAUL_H
#define __DYNTAUL_H

#include <fstream.h>
#include <string>


// Tehd„„n yleinen malliluokka osoitintaulukosta:
template <class TYYPPI>
class cDynTaulu {
protected:
  int max_koko;
  int lkm;
  TYYPPI **alkiot;
  int varaa(int koko) {
    lkm = 0; max_koko = 0;
    if ( koko <= 0 ) return 0;
    alkiot = new TYYPPI*[koko];
    if ( alkiot ) max_koko = koko;
    return max_koko == 0;
  }
public:
  void vapauta();
  cDynTaulu(int koko=0) { varaa(koko);  }
  cDynTaulu(const cDynTaulu &taulu) { varaa(0); sijoita(taulu); }
  ~cDynTaulu() { vapauta(); }
  int lisaa(const TYYPPI &n) {
    if ( lkm >= max_koko ) return 1;
    TYYPPI *uusi = new TYYPPI(n);
    if ( !uusi ) return 1;
    alkiot[lkm++] = uusi;
    return 0;
  }
  const TYYPPI&anna(int i) const {
    if (i<0 || lkm <= i ) return *alkiot[0];
    return *alkiot[i];
  }
  cDynTaulu &sijoita(const cDynTaulu &taulu);
  cDynTaulu &operator=(const cDynTaulu &taulu) { return sijoita(taulu); }
  int etsi(const TYYPPI &etsittava,int alku=0) const;
};

template <class TYYPPI>
void cDynTaulu<TYYPPI>::vapauta()
{
  for (int i=0; i< lkm; i++) delete alkiot[i];
  if ( max_koko > 0 ) delete [] alkiot;
  lkm = 0; max_koko = 0;
}

template <class TYYPPI>
cDynTaulu<TYYPPI> &cDynTaulu<TYYPPI>::sijoita(const cDynTaulu<TYYPPI> &taulu)
{
  if ( this == &taulu ) return *this;
  vapauta(); varaa(taulu.max_koko);
  for (int i=0; i<taulu.lkm; i++)
    lisaa(*taulu.alkiot[i]);
  return *this;
}


template <class TYYPPI>
int cDynTaulu<TYYPPI>::etsi(const TYYPPI &etsittava, int alku) const
{
  for (int i=alku; i < lkm; i++)
    if ( *alkiot[i] == etsittava ) return i;
  return -1;
}



//---------------------------------------------------------------------------
// Osoitintaulukko, joka osaa lukea itsens„ tiedosta
template <class TYYPPI>
class cDynTaulu_r : public cDynTaulu<TYYPPI> {
protected:
  string tiedosto;
public:
  cDynTaulu_r(int koko=0) : tiedosto(""), cDynTaulu<TYYPPI>(koko) {;}
  int lue(const char *nimi);
  friend istream &operator>>(istream &is,cDynTaulu_r<TYYPPI> &taul);
};

template <class TYYPPI>
istream &operator>>(istream &is,cDynTaulu_r<TYYPPI> &taul)
{
  TYYPPI alkio;

  while ( is ) {
    is >> alkio;
    if ( is.fail() ) { is.clear(); break; }
    taul.lisaa(alkio);
  }
  return is;
}

template <class TYYPPI>
int cDynTaulu_r<TYYPPI>::lue(const char *nimi)
{
  ifstream f(nimi); tiedosto = nimi;

  if ( !f ) return 1;
  f >> *this;

  return 0;
}

//---------------------------------------------------------------------------
// Osoitintaulukko, joka osaa lis„ksi kirjoitaa itsens„ tiedostoon
template <class TYYPPI>
class cDynTaulu_rw : public cDynTaulu_r<TYYPPI> {
  string erotin;   // Tulostuksessa alkioiden v„linen erotin
public:
  cDynTaulu_rw(int koko=0,const char *ero=" ") :
    cDynTaulu_r<TYYPPI>(koko), erotin(ero) {;}
  int kirjoita(const char *nimi=NULL,const char *ero=NULL);
  string Erotin(const string &ero) { string old; erotin = ero; return old; }
  ostream &tulosta(ostream &os,const char *erotin=NULL) const;
  friend ostream &operator<<(ostream &os,const cDynTaulu_rw<TYYPPI> &taul);
};

template <class TYYPPI>
ostream &cDynTaulu_rw<TYYPPI>::tulosta(ostream &os, const char *ero) const
{
  const char *e = ero; if ( !e ) e = erotin.c_str();
  for (int i=0; i<lkm; i++)
    os << anna(i) << e;
  return os;
}

template <class TYYPPI>
ostream &operator<<(ostream &os,const cDynTaulu_rw<TYYPPI> &taul) {
  return taul.tulosta(os,taul.erotin.c_str());
}

template <class TYYPPI>
int cDynTaulu_rw<TYYPPI>::kirjoita(const char *nimi,const char *ero)
{
  if ( nimi != NULL ) tiedosto = nimi;
  ofstream f(tiedosto.c_str());

  if ( !f ) return 1;

  const char *e = ero; if ( !e ) e = erotin.c_str();
  tulosta(f,e);

  return 0;
}

#endif /* __DYNTAUL_H */