#include <iostream.h>
#include <iomanip.h>
#include <string.h>
#include <assert.h>
#include "napis.h"

//konstruktor przeksztalacajacy : konwersja char * na napis
napis::napis( const char *s ) : dlugosc( strlen( s ) )
{
 cout << "Konstruktor przeksztalcajacy: " << s << "\n";
 ustawNapis( s ); // wywolanie funkcji narzedziowej 
}

//Konstruktor kopiujacy
napis::napis( const napis &kopia ) : dlugosc( kopia.dlugosc )
{
 cout << "konstruktor kopiujacy: " << kopia.sPtr << '\n';
 ustawNapis( kopia.sPtr ); //wywolanie funkcji narzedziowej
}

//destruktor 
napis::~napis()
{
 cout << "destruktor: " << sPtr << '\n';
 delete [] sPtr;
}

//przeciazony operator = ; unikanie samoprzypisania 
const napis &napis::operator=( const napis &prawy)
{
 cout << "wywolany operator +\n";
 if ( &prawy != this )  // unikanie samoprzypisania 
 {
  delete [] sPtr;	//usuniecie zbedenej kopii napisu
  dlugosc = prawy.dlugosc; // nowa dlugosc napisu 
  ustawNapis( prawy.sPtr ); // wywolanie funkcji narzedziowej 
 }
 else
 {
  cout << " Proba przypisania obiektu samemu sobie\n"; 
 }
 return *this; //odblokowanie przypisania kaskadowego 
}

// konkatenacja operandu prawy z obiektem this oraz przechowywanie 
// w nim rezultatu 
const napis &napis::operator+=( const napis &prawy )
 {
  char *tymczasowyPtr = sPtr; // zapamietaj aby usunac 
  dlugosc += prawy.dlugosc;  // nowa dlugosc napisu 
  sPtr = new char[ dlugosc + 1 ]; // zaalokuj pamiec 
  assert ( sPtr !=0 ); // koniec jezeli nie zaalokowano 
  strcpy( sPtr, tymczasowyPtr ); //lewa czesc nowego napisu 
  strcat( sPtr, prawy.sPtr ); // prawa czaesc nowego napisu
  delete [] tymczasowyPtr; // zwolnij stara pamiec 
  return *this; 
 }

// czy napis jest pusty ? 
bool napis::operator!() const 
 { 
  return dlugosc == 0;  
 }

// czy napis jest rowny napisowi podanemu jako prawy argument 
bool napis::operator==( const napis &prawy ) const
 { 
  return strcmp( sPtr, prawy.sPtr ) == 0; 
 }

// czy napis jest minejszy od napisu podanego jako prawy argument 
bool napis::operator<( const napis &prawy ) const
 { 
  return strcmp( sPtr, prawy.sPtr ) < 0; 
 } 


// zwroc referencje do znaku w napise jako lvalue 
char &napis::operator[](int indeks)
 { 
  // najpierw sprawdz czy indeks ma odpowiednia wartosc 
  assert (indeks>=0 && indeks < dlugosc);
  return sPtr[indeks ]; // utworzenie lvalue 
 }

// zwroc referencje do znaku w napisie jako rvalue 
const char &napis::operator[]( int indeks ) const
 { 
  // najpierw sprawdz czy indeks ma odpowiednia wartosc 
  assert( indeks >=0 && indeks < dlugosc );
  return sPtr[indeks]; //utworzenie rvalue
 } 

// zwroc podnapis , rozpoczynajacy sie na pozycji indeks o dlugosci 
// dlugoscPodl jako referencje obiektu Napis
napis &napis::operator() (int indeks , int dlugoscPodn)
 {
  //sprawdz czy indeks oraz dlugosc podnapisu sa odpowiednie 
  assert(indeks>=0 && indeks < dlugosc && dlugoscPodn >=0);
  napis *podnPtr = new napis;
  assert (podnPtr !=0 ); // sprawdz czy napis zostal zaalokowany
  // okreslenie dlugosci podnapisu 
  if ((dlugoscPodn==0) || (indeks + dlugoscPodn > dlugosc)) 
   { 
    podnPtr->dlugosc = dlugosc - indeks +1 ;
   }
  else 
   { 
    podnPtr->dlugosc = dlugoscPodn +1 ; 
   } 
  // zaalokuje pamiec na podnapis 
  delete podnPtr->sPtr; // usun z obiektu tablcie znakow 
  podnPtr->sPtr = new char[ podnPtr->dlugosc];
// {orginal z ksiazki }  assert (podlPtr->sPtr != 0);  
  assert (podnPtr->sPtr != 0); // sprawdz czy pamiec jest zaalokowana 
  //skopiuje podnapis do nowego napisu 
  strncpy(podnPtr->sPtr, &sPtr[indeks], podnPtr->dlugosc);
  podnPtr->sPtr[podnPtr->dlugosc] = '\0' ; // zakoncz napis
  return *podnPtr;
 }
// zwroc dlugosc napisu 

int napis::pobierzDlugosc() const 
 { 
  return dlugosc;
 } 
 

//funkcja narzedziowa wywowywana przez konstruktory oraz operatory przypisania 
void napis::ustawNapis( const char *napis2)
 { 
  sPtr = new char [ dlugosc + 1]; //zaalokuj pamiec 
  assert( sPtr!=0 );  // koniec jezeli pamiec jest nie zaalokowana
  strcpy(sPtr , napis2) ; // skopiuj do obiektu 
 }

// przeciazony operator wyjscia 
ostream &operator<<(ostream &wyjscie , const napis &s)
 { 
  wyjscie << s.sPtr;
  return wyjscie; // umozliwia kaskadowe wywolywanie ; 
 } 
 
// przeciazony operator wejscia 
istream &operator>>(istream &wejscie , napis &s)
 { 
  char tymczas[ 100 ] ; //bufor przechowujacy dane wejsciowe 
  wejscie >> setw( 100 ) >> tymczas ;
  s= tymczas;
  return wejscie ;
 }