#include <string>

using std::string;

///Klasse um ein einzelnes Wort mit dem Caesarchiffre zu verschluesseln

/**
* Einer Instanz dieser Klasse kann ein string uebergeben werden, welcher
* danach mithilfe der Methoden 'encode()' und 'decode()' ver- und entschluesselt
* werden kann. Nach der Instanzierung ist der String leer.
*/
class cesar
{

private:
        /// Variable, die den aktuellen string haelt.
        /**
        * Die Variable 'phrase' hält den aktuellen string, egal ob
        * verschluesselt oder unverschluesselt. In welchem Zustand sich der
        * String befindet wird in der Variable 'code_status' festgehalten
        */
        string phrase;
        /// Enthaelt die Länge der Variable 'phrase'
        int length;
        /// Unterscheidet zwischen ver- und entschluesseltem String
        /**
        * Wenn code_status den Wert 1 hat, dann ist 'string' verschluesselt
        * Wenn code_status den Wert 0 hat, dann ist 'string' entschluesselt
        */
        bool code_status;
        /// Konstanten für 'code_status'
        static const bool ENCODED = true;
        static const bool DECODED = false;

public:
       /// Setzt einen neuen Wert als string
       /**
       * Mithilfe dieser Methode kann entweder ein neuer zu verschluesselnder 
       * String angegeben werden oder aber ein zu entschluesselnder String
       */
       void setphrase(string newphrase)
       {
            phrase = newphrase;
            length = (int)phrase.length();
            code_status = DECODED;
       }

       /// Gibt den aktuellen String zurueck
       /**
       * Gibt den aktuell gespeicherten String zurueck. Ob dieser ver- oder
       * entschluesselt ist, kann mithilfe der Methode isencoded() abgefragt
       * werden.
       */
       string getphrase()
       {
              return phrase;
       }

       /// Liefert den Status des Strings zurueck
       /**
       * Gibt den aktuellen Kodierungsstatus des Strings zurueck,
       * der mithilfe der Methode getphrase() abgefragt werden kann.
       */
       bool isencoded()
       {
        return code_status;
       }

       /// Verschluesselt den aktuellen String
       /**
       * Wird kein Schluesselwert in Form
       * eines Integers uebergeben, so wird die Laenge des Strings als
       * Schluesselwert benutzt. Ausserdem wird ueberprueft, ob der String
       * bereits als verschluesselter Text vorliegt. Ist dies der Fall, so
       * bleibt dieser unveraendert. Somit kann keine doppelte Verschluesse-
       * lung realisiert werden.
       */
       void encode()
       {
        if(code_status==DECODED)
        {
          int ASCII[255];
          int newASCII;
          
          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Array mit ASCII-Werten der Zeichen fuellen
              ASCII[recentLetter-1]=(int)phrase[recentLetter-1];
          }
          
          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Wenn es sich um einen Buchstaben handelt, wird er verschluesselt
              if((ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123)
                 ||(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91))
              newASCII = ASCII[recentLetter-1]+length;
              // Ansonsten wird nichts veraendert
              else newASCII = ASCII[recentLetter-1];
              // Fängt ASCII-Werte groesser als Z/z ab und beginnt
              // wieder bei A/a
              // Wenn es sich um Kleinbuchstaben handelt, ist 122 der Grenzwert
              if(ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123
                 &&newASCII>122)
                               newASCII=newASCII-26;
              // Wenn es sich um Kleinbuchstaben handelt, ist 90 der Grenzwert
              if(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91
                 &&newASCII>90)
                               newASCII=newASCII-26;
              // ASCII-Wert wird wieder in Char umgewandelt
              phrase[recentLetter-1]=(char)newASCII;
          }
          code_status = ENCODED;
        }
       }

       /// Entschluesselt den aktuellen String
       /**
       * Wird kein Schluesselwert in Form
       * eines Integers uebergeben, so wird die Laenge des Strings als
       * Schluesselwert benutzt. Ausserdem wird ueberprueft, ob der String
       * bereits als entschluesselter Text vorliegt. Ist dies der Fall, so
       * bleibt dieser unveraendert. Somit kann keine doppelte Entschluesse-
       * lung realisiert werden.
       */
       void decode()
       {
        if(code_status==ENCODED)
        {
          int ASCII[255];
          int newASCII;
          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Array mit ASCII-Werten der Zeichen füllen
              ASCII[recentLetter-1]=(int)phrase[recentLetter-1];
          }
          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Wenn es sich um einen Buchstaben handelt, wird er verschluesselt
              if((ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123)
                 ||(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91))
              newASCII = ASCII[recentLetter-1]-length;
              // Ansonsten wird nichts veraendert
              else newASCII = ASCII[recentLetter-1];
              // Fängt ASCII-Werte kleiner als A/a ab und beginnt
              // wieder bei Z/z
              // Wenn es sich um Kleinbuchstaben handelt, ist 96 der Grenzwert
              if(ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123
                 &&newASCII<96)
                               newASCII=newASCII+26;
              // Wenn es sich um Kleinbuchstaben handelt, ist 64 der Grenzwert
              if(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91
                 &&newASCII<64)
                               newASCII=newASCII+26;
              // ASCII-Wert wird wieder in Char umgewandelt
              phrase[recentLetter-1]=(char)newASCII;
          }
          code_status = DECODED;
        }
       }
       
       /// Verschluesselt den aktuellen String
       /**
       * Der Parameter 'key' gibt den
       * Schluesselwert an. Ausserdem wird ueberprueft, ob der String
       * bereits als verschluesselter Text vorliegt. Ist dies der Fall, so
       * bleibt dieser unveraendert. Somit kann keine doppelte Verschluesse-
       * lung realisiert werden.
       */
       void encode(int key)
       {
        if(code_status==DECODED)
        {
          int ASCII[255];
          int newASCII;

          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Array mit ASCII-Werten der Zeichen fuellen
              ASCII[recentLetter-1]=(int)phrase[recentLetter-1];
          }

          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Wenn es sich um einen Buchstaben handelt, wird er verschluesselt
              if((ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123)
                 ||(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91))
              newASCII = ASCII[recentLetter-1]+key;
              // Ansonsten wird nichts veraendert
              else newASCII = ASCII[recentLetter-1];
              // Fängt ASCII-Werte groesser als Z/z ab und beginnt
              // wieder bei A/a
              // Wenn es sich um Kleinbuchstaben handelt, ist 122 der Grenzwert
              if(ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123
                 &&newASCII>122)
                               newASCII=newASCII-26;
              // Wenn es sich um Kleinbuchstaben handelt, ist 90 der Grenzwert
              if(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91
                 &&newASCII>90)
                               newASCII=newASCII-26;
              // ASCII-Wert wird wieder in Char umgewandelt
              phrase[recentLetter-1]=(char)newASCII;
          }
          code_status = ENCODED;
        }
       }

       /// Entschluesselt den aktuellen String
       /**
       * Der Parameter 'key' gibt den
       * Schluesselwert an. Ausserdem wird ueberprueft, ob der String
       * bereits als entschluesselter Text vorliegt. Ist dies der Fall, so
       * bleibt dieser unveraendert. Somit kann keine doppelte Entschluesse-
       * lung realisiert werden.
       */
       void decode(int key)
       {
        if(code_status==ENCODED)
        {
          int ASCII[255];
          int newASCII;
          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Array mit ASCII-Werten der Zeichen füllen
              ASCII[recentLetter-1]=(int)phrase[recentLetter-1];
          }
          for (int recentLetter=1; recentLetter<=length; recentLetter++)
          {
              // Wenn es sich um einen Buchstaben handelt, wird er verschluesselt
              if((ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123)
                 ||(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91))
              newASCII = ASCII[recentLetter-1]-key;
              // Ansonsten wird nichts veraendert
              else newASCII = ASCII[recentLetter-1];
              // Fängt ASCII-Werte kleiner als A/a ab und beginnt
              // wieder bei Z/z
              // Wenn es sich um Kleinbuchstaben handelt, ist 96 der Grenzwert
              if(ASCII[recentLetter-1]>96
                 &&ASCII[recentLetter-1]<123
                 &&newASCII<96)
                               newASCII=newASCII+26;
              // Wenn es sich um Kleinbuchstaben handelt, ist 64 der Grenzwert
              if(ASCII[recentLetter-1]>64
                 &&ASCII[recentLetter-1]<91
                 &&newASCII<64)
                               newASCII=newASCII+26;
              // ASCII-Wert wird wieder in Char umgewandelt
              phrase[recentLetter-1]=(char)newASCII;
          }
          code_status = DECODED;
        }
       }
};