/* jasen.cpp */
/****************************************************************************/
/*
** J„sen-luokan toteutus
**
**  Tekij„t:          Vesa Lappalainen
**                    Ohjelmointikurssi 1991
**  Tehty:            20.12.1991
**  Muutettu:         09.12.1995
**  Mit„ muutettu:    + Muutettu C++ luokaksi
**  Muutettu:         28.12.1995
**  Mit„ muutettu:    + Lis„tty kentt„tietoja palauttavia metodeja
**  Muutettu:         11.01.1996
**  Mit„ muutettu:    + J„senen tunniste-tietojen yll„pito
**                    + tyhja-metodi, joka kertoo onko j„sen tyhj„ vai ei
**
**
** Public-metodeja:
** ================
**
**  cJasen()
**   - alustaa j„senen tyhj„ksi
**
**  void alusta();
**   - alustaa j„senen tyhj„ksi
**
**  void alusta(const char *rivi);
**  void alusta(const string &st);
**   - alustaa j„senen merkkijonolla Ankka Aku|0....|..
**
**  cJasen(const cJasen &jasen)
**   - alustaa j„senen toisen j„senen tiedoilla
**
**  const cJasen &operator=(const cJasen &jasen)
**   - sijoitaa j„sen tiedot toiseen j„seneen
**
**  const cJasen &sijoita(const cJasen &jasen);
**   - sijoitaa j„sen tiedot toiseen j„seneen
**
**  void vastaa_aku_ankka();
**   - t„ytt„„ j„senen Aku Ankan tiedoilla (testitarkoituksiin)
**
**  int operator==(const cJasen &jasen) const;
**   - tutkii onko kaksi j„sent„ samat ( 0 = ei, 1 = juu )
**
**  void tulosta(ostream &os) const;
**   - tulostaa j„senen valittuun tietovirtaan (tiedostoon) "tarra"-muodossa
**
**  friend ostream &operator<<(ostream &os,const cJasen &jasen);
**   - tulostaa j„senen rivimuodossa tietovirtaan
**
**  friend istream &operator>>(istream &is,cJasen &jasen);
**   - ottaa rivimuodossa olevan j„senen tietovirrasta
**
**  const string kentta_jonoksi(int k) const
**   - paluttaa k:n kent„n merkkijonona
**
**  int sijoita(int k,const string &st)
**   - sijoittaa merkkijonon k:nteen kentt„„n
**
**  const char *kysymys(int k) const
**   - paluttaa k:ta kentt„„ vastaavan kysymyksen
**
**  int kenttia() const
**   - palauttaa j„senen kenttien lukum„„r„n
**
**  int tyhjenna_omat()
**   - tyhjent„„ j„senen ne tiedot, jotka ovat omia uudelle
**     j„senelle
**
**  int sama_rekisteri(const cJasen &jasen);
**   - onko jasen rekisteroity samaksi jaseneksi kuin tama jasen.
**     J„senill„ on kullakin om rekisteritunniste, jonka avulla voidaan
**     tunnistaa onko esim. korjailtu j„sen sama kuin alkuper„inen.
**
**  void rekisteroi();
**   - jokainen uusi j„sen rekisteroidaan ennen lisaamista ja
**     nain kullekin jasenelle tulee ikioma tunniste.
**     Rekister”im„tt”m„ll„ j„senell„ tunniste = -1
**
**
** J„senen rivimuoto:
** ==================
**  Ankka Aku          |010245-123U|Ankkakuja 6 |12345|...
**
*/

#include <iostream.h>
#include <strstream.h>
#include <stdlib.h>
#include <string>
#include "jasen.h"
#include "mjonot.h"

//============================================================================
// J„sen-luokan luokkamuuttujat:
//============================================================================
char cJasen::erotin = '|';
char cJasen::erottimet[] = "|";
int  cJasen::suurin_tunniste = 0;

//============================================================================
// J„sen-luokan public-metodeja:
//============================================================================

//----------------------------------------------------------------------------
int cJasen::tyhjenna_omat()
{
  nimi        = "";
  hetu        = "";
  autopuhelin = "";
  lisatietoja = "";
  ei_rekisteroity();
  return 0;
}


//----------------------------------------------------------------------------
int cJasen::alusta(const char *rivi)
{
//  for (k=0; k<kenttia(); k++)
//    kentta(k)->tiedot = &kenttataulukko[k];
//
  char *urivi = tee_jono(rivi); // Kopio, koska ei ole const char * alustajaa
  istrstream sstr(urivi);       // merkkivirralle
  sstr >> *this;
  free(urivi);
  ei_rekisteroity();
  return 0;
}


//----------------------------------------------------------------------------
void cJasen::vastaa_aku_ankka()
{
  char apuhetu[50];
  sprintf(apuhetu,"%02d%02d%02d-%03d%c",
          rand()%31+1,rand()%12+1,rand()%91+1,rand()%1000,rand()%25+'A');
  apuhetu[11]=0;

  nimi           = "Ankka Aku";
  hetu           = apuhetu;
  katuosoite     = "Ankkakuja 6";
  postinumero    = "12345";
  postiosoite    = "ANKKALINNA";
  kotipuhelin    = "12-1234";
  tyopuhelin     = "";
  autopuhelin    = "";
  liittymisvuosi = 1996;
  jmaksu         = 50.00;
  maksu          = 30.00;
  lisatietoja    = "Velkaa Roopelle";
  ei_rekisteroity();
}


//----------------------------------------------------------------------------
void cJasen::tulosta(ostream &os) const
{
  os << "  " << nimi << "  " << hetu << endl;
  os << "  " << katuosoite << "  " <<
                postinumero << " " << postiosoite << endl;
  os << "  k: " << kotipuhelin <<
         " t: " << tyopuhelin  <<
         " a: " << autopuhelin << endl;
  os << "  Liittynyt "  << liittymisvuosi << "."
        "  J„senmaksu " << jmaksu << " mk."
        "  Maksettu "   << maksu  << " mk." << endl;
  os << "  " << lisatietoja << endl;
}


//----------------------------------------------------------------------------
int cJasen::operator==(const cJasen &jasen) const
// Verrataan onko tiedot samat
{
  int kenttia=jasen.kenttia();
  const cKentta *k1;

  for (int k=0; k<kenttia; k++) {
    k1 = kentta(k);
    if ( k1->jonoksi() != jasen[k].jonoksi() ) return 0;
  }
  return 1;
}


//----------------------------------------------------------------------------
const cJasen &cJasen::sijoita(const cJasen &jasen)
// Sijoitetaan kentt„ kerrallaan.  Sijoitus voidaan tehd„ vain
// jos molemmat j„senet on rekister”im„tt„ (l„hinn„ alustus)
// tai vasen puoli on rekister”im„tt„. Tai kent„t ovat samoja (muutos)
//
//   *this   jasen   sijoitus
//  -------------------------
//    rek ==  rek      joo        (muutos)
//    rek !=  rek      ei
//    rek !=  ei       ei
//     ei !=  rek      joo        (alustus)
//     ei ==  ei       joo        (alustus)
{
  int kenttia=jasen.kenttia();
  cKentta *k1;

  if ( sama_rekisteri(jasen) == 0 && onko_rekisteroity() ) return *this;

  for (int k=0; k<kenttia; k++) {
    k1 = kentta(k);
    k1->sijoita(jasen[k]);
  }
  tunniste = jasen.tunniste;
  return *this;
}


//----------------------------------------------------------------------------
ostream &operator<<(ostream &os,const cJasen &jasen)
{
  int k,kenttia=jasen.kenttia();

  for (k=0; k<kenttia; k++)
    os << jasen[k] << jasen.erotin;

  return os;
}

//----------------------------------------------------------------------------
istream &operator>>(istream &is,cJasen &jasen)
{
  int k,kenttia=jasen.kenttia();

  for (k=0; k<kenttia; k++) {
    jasen[k].ota_seuraava(is,jasen.erottimet);
  }
  tyhjenna(is);  // ohittaa loppurivin
  jasen.ei_rekisteroity();
  return is;
}


//----------------------------------------------------------------------------
static cVirheKentta VirheKentta("VIRHE");

//----------------------------------------------------------------------------
const cKentta *cJasen::pkentta(int k) const
{
  switch ( k ) {
    case  0: return &nimi;
    case  1: return &hetu;
    case  2: return &katuosoite;
    case  3: return &postinumero;
    case  4: return &postiosoite;
    case  5: return &kotipuhelin;
    case  6: return &tyopuhelin;
    case  7: return &autopuhelin;
    case  8: return &liittymisvuosi;
    case  9: return &jmaksu;
    case 10: return &maksu;
    case 11: return &lisatietoja;
    default: return &VirheKentta;
  }
}


//----------------------------------------------------------------------------
const char *cJasen::kysymys(int k) const
{
  switch ( k ) {
    case  0: return "J„senen nimi";
    case  1: return "Hetu";
    case  2: return "Katuosoite";
    case  3: return "Postinumero";
    case  4: return "Postiosoite";
    case  5: return "Kotipuhelin";
    case  6: return "Ty”puhelin";
    case  7: return "Autopuhelin";
    case  8: return "Liittymisvuosi";
    case  9: return "J„senmaksu mk";
    case 10: return "Maksettu maksu mk";
    case 11: return "Lis„tietoja";
    default: return "VIRHE!";
  }
}