Can someone impliment the toReverse() function as well as the ++operator?

On the foundation of the previous Text ADT homework, add thefollowing methods to the Text class: 1. Implement the functiontoReverse() to reverse recursively the order of letters of thegiven Text object. Test your implementation by activatingLAB2_TEST1. (15 pts) Function prototype: Text toReverse(Text obj,int position) const; 2. Implement the operators +=. Test it byactivating LAB2_TEST2. (15 pts) Function prototype: Text operator+= (const Text &input2);

textio.cpp

//——————————————————————–

//

// Laboratory 1, In-lab Exercise 1 textio.cpp

//

// String input/output operations

//

//——————————————————————–

#include <iostream>

#include <iomanip>

#include “Text.h”

//——————————————————————–

istream & operator >> ( istream &input, Text&inputText )

// Text input function. Extracts a string from istream inputand

// returns it in inputText. Returns the state of the inputstream.

{

const int textBufferSize = 256; // Large (but finite)

char textBuffer [textBufferSize]; // text buffer

// Read a string into textBuffer, setw is used to preventbuffer

// overflow.

input >> setw(textBufferSize) >> textBuffer;

// Apply the Text(char*) constructor to convert textBufferto

// a string. Assign the resulting string to inputText usingthe

// assignment operator.

inputText = textBuffer;

// Return the state of the input stream.

return input;

}

//——————————————————————–

ostream & operator << ( ostream &output, constText &outputText )

// Text output function. Inserts outputText in ostreamoutput.

// Returns the state of the output stream.

{

   output << outputText.buffer;

   return output;

}

***************************************************************

text.h

//——————————————————————–

//

// Laboratory 1 Text.h

// **Instructor’s Solution**

// Class declaration for the array implementation of the TextADT

//

//——————————————————————–

#ifndef TEXT_H

#define TEXT_H

#include <stdexcept>

#include <iostream>

using namespace std;

class Text

{

public:

// Constructors and operator=

Text ( const char *charSeq = “” ); // Initialize using char*

Text ( const Text &other ); // Copy constructor

void operator = ( const Text &other ); // Assignment

// Destructor

~Text ();

// **** Lab 2 ****

Text operator += (const Text &input2);

char toReverse(Text t1, int t) const;

// ***************

// Text operations

int getLength () const; // # characters

char operator [] ( int n ) const; // Subscript

void clear (); // Clear string

// Output the string structure — used in testing/debugging

void showStructure () const;

//——————————————————————–

// In-lab operations

// toUpper/toLower operations (Programming Exercise 2)

Text toUpper( ) const; // Create upper-case copy

Text toLower( ) const; // Create lower-case copy

// Relational operations (Programming Exercise 3)

bool operator == ( const Text& other ) const;

bool operator < ( const Text& other ) const;

bool operator > ( const Text& other ) const;

private:

// Data members

int bufferSize; // Size of the string buffer

char *buffer; // Text buffer containing a null-terminatedsequence of characters

// Friends

// Text input/output operations (In-lab Exercise 1)

friend istream & operator >> ( istream& input,Text& inputText );

friend ostream & operator << ( ostream& output,const Text& outputText );

};

#endif

**********************************************************************

test1.cpp

//——————————————————————–

//

// Laboratory 1 test1.cpp

//

// Test program for the operations in the Text ADT

//

//——————————————————————–

#include <iostream>

#include “Text.h”

#include “config.h”

//——————————————————————–

//

// Function prototype

void copyTester ( Text copyText ); // copyText is passed byvalue

void print_help ( );

//——————————————————————–

int main()

{

Text a(“a”), // Predefined test text objects

   alp(“alp”),

   alpha(“alpha”),

   epsilon(“epsilon”),

   empty,

   assignText, // Destination for assignment

   inputText, // Input text object

   inputText2;

int n; // Input subscript

char ch, // Character specified by subscript

   selection; // Input test selection

// Get user test selection.

print_help();

// Execute the selected test.

cin >> selection;

cout << endl;

switch ( selection )

{

case ‘1’ :

   // Test 1 : Tests the constructors.

   cout << “Structure of various text objects: “<< endl;

   cout << “text object: alpha” <<endl;

   alpha.showStructure();

   cout << “text object: epsilon” <<endl;

   epsilon.showStructure();

   cout << “text object: a” << endl;

   a.showStructure();

   cout << “empty text object” <<endl;

   empty.showStructure();

   break;

case ‘2’ :

   // Test 2 : Tests the length operation.

   cout << “Lengths of various text object:”<< endl;

   cout << ” alpha : ” <<alpha.getLength() << endl;

   cout << ” epsilon : ” <<epsilon.getLength() << endl;

   cout << ” a : ” << a.getLength()<< endl;

   cout << ” empty : ” <<empty.getLength() << endl;

   break;

case ‘3’ :

   // Test 3 : Tests the subscript operation.

   cout << “Enter a subscript : “;

   cin >> n;

   ch = alpha[n];

   cout << ” alpha[” << n << “] :”;

   if ( ch == ‘ ‘ )

cout << “” << endl;

   else

cout << ch << endl;

   break;

case ‘4’ :

   // Test 4 : Tests the assignment and clearoperations.

   cout << “Assignments:” << endl;

   cout << “assignText = alpha” <<endl;

   assignText = alpha;

   assignText.showStructure();

   cout << “assignText = a” << endl;

   assignText = a;

   assignText.showStructure();

   cout << “assignText = empty” <<endl;

   assignText = empty;

   assignText.showStructure();

   cout << “assignText = epsilon” <<endl;

   assignText = epsilon;

   assignText.showStructure();

   cout << “assignText = assignText” <<endl;

   assignText = assignText;

   assignText.showStructure();

   cout << “assignText = alpha” <<endl;

   assignText = alpha;

   assignText.showStructure();

   cout << “Clear assignText” << endl;

   assignText.clear();

   assignText.showStructure();

   cout << “Confirm that alpha has not beencleared” << endl;

   alpha.showStructure();

   break;

case ‘5’ :

   // Test 5 : Tests the copy constructor andoperator= operations.

   cout << “Calls by value:” << endl;

   cout << “alpha before call” <<endl;

   alpha.showStructure();

   copyTester(alpha);

   cout << “alpha after call” << endl;

   alpha.showStructure();

   cout << “a before call” << endl;

   a.showStructure();

   a = epsilon;

   cout << “a after call” << endl;

   a.showStructure();

   cout << “epsilon after call” <<endl;

   epsilon.showStructure();

   break;

#if LAB1_TEST1

case ‘6’ : // In-lab Exercise 2

   // Test 6 : Tests toUpper and toLower

   cout << “Testing toUpper and toLower.”

<< “Enter a mixed case string: ” << endl;

   cin >> inputText;

   cout << “Input string:” << endl;

   inputText.showStructure();

   cout << “Upper case copy: ” <<endl;

   inputText.toUpper().showStructure();

   cout << “Lower case copy: ” <<endl;

   inputText.toLower().showStructure();

   break;

#endif // LAB1_TEST1

#if LAB1_TEST2

case ‘7’ : // In-lab Exercise 3

   // Test 7 : Tests the relational operations.

   cout << ” left right < == > ” <<endl;

   cout << “——————————–“<< endl;

   cout << ” alpha epsilon ” <<(alpha<epsilon)

<< ” ” << (alpha==epsilon) << ” “

<< (alpha>epsilon) << endl;

   cout << ” epsilon alpha ” <<(epsilon<alpha)

<< ” ” << (epsilon==alpha) << ” “

<< (epsilon>alpha) << endl;

   cout << ” alpha alpha ” <<(alpha<alpha) << ” “

<< (alpha==alpha) << ” ” << (alpha>alpha)<< endl;

   cout << ” alp alpha ” << (alp<alpha)<< ” “

<< (alp==alpha) << ” ” << (alp>alpha)<< endl;

   cout << ” alpha alp ” << (alpha<alp)<< ” “

<< (alpha==alp) << ” ” << (alpha>alp)<< endl;

   cout << ” a alpha ” << (a<alpha)<< ” “

<< (a==alpha) << ” ” << (a>alpha) <<endl;

   cout << ” alpha a ” << (alpha<a)<< ” “

<< (alpha==a) << ” ” << (alpha>a) <<endl;

   cout << ” empty alpha ” <<(empty<alpha) << ” “

<< (empty==alpha) << ” ” << (empty>alpha)<< endl;

   cout << ” alpha empty ” <<(alpha<empty) << ” “

<< (alpha==empty) << ” ” << (alpha>empty)<< endl;

   cout << ” empty empty ” <<(empty<empty) << ” “

<< (empty==empty) << ” ” << (empty>empty)<< endl;

   break;

#endif // LAB1_TEST2

#if LAB2_TEST1

case ‘8’ :

cout << “Input text to be reversed: “;

cin >> inputText;

inputText.toReverse(inputText, 0);

//inputText.showStructure();

break;

#endif // LAB2_TEST1

#if LAB2_TEST2

case ‘9’:

cout << “Input text1 to be reversed: “;

cin >> inputText;

cout << “Input text2 to be reversed: “;

cin >> inputText2;

inputText += inputText2;

inputText.toReverse(inputText, 0);

break;

#endif // LAB2_TEST2

default :

   cout << “‘” << selection << “‘specifies an inactive or invalid test” << endl;

}

   system(“PAUSE”);

return 0;

}

//——————————————————————–

void copyTester ( Text copyText )

// Dummy routine that is passed a text object using call byvalue. Outputs

// copyText and clears it.

{

cout << “Copy of text object” << endl;

copyText.showStructure();

cout << “Clear copy” << endl;

copyText.clear();

copyText.showStructure();

}

//——————————————————————–

void print_help()

{

cout << endl << “Tests:” << endl;

cout << ” 1 Tests the constructors” << endl;

cout << ” 2 Tests the length operation” << endl;

cout << ” 3 Tests the subscript operation” <<endl;

cout << ” 4 Tests the assignment and clear operations”<< endl;

cout << ” 5 Tests the copy constructor and operator=operations” << endl;

cout << ” 6 Tests the toUpper and toLower operations “

#if   LAB1_TEST1

   << “(Active : “

#else

   << “(Inactive : “

#endif   // LAB1_TEST1

   << “In-lab Exercise 2)” << endl;

cout << ” 7 Tests the relational operations “

#if   LAB1_TEST2

   << ” (Active : “

#else

   << ” (Inactive : “

#endif   // LAB1_TEST2

   << “In-lab Exercise 3)” << endl;

cout << ” 8 Tests the reverse operations” <<endl;

cout << ” 9 Tests the reverse and operator+= operations”<< endl;

cout << “Select the test to run : “;

}

***********************************************************************

config.h

/**

* Text class (Lab 1) configuration file.

* Activate test ‘N’ by defining the corresponding LAB1_TESTN tohave the value 1.

*/

#define LAB1_TEST1   0      // Programming exercise 2: toUpper and toLower

#define LAB1_TEST2   0      // Programming exercise 3: ==, <, and >

#define LAB2_TEST1    1      // Programming recursion

#define LAB2_TEST2    1      // Programming operation + and recursion

***************************************************************

text.cpp

#include <iostream>

#include <iomanip>

#include <cassert>

#include <cstring>

#include “Text.h”

Text::Text ( const char *charSeq )

{

bufferSize=strlen(charSeq)+1;

buffer=new char[bufferSize];

strcpy(buffer,charSeq);

}

Text::Text ( const Text &other )

{

bufferSize=other.bufferSize;

buffer=new char[bufferChar];

strncpy(buffer,other.buffer,bufferSize);

}

void Text::operator = ( const Text &other )

{

clear();

bufferSize=other.bufferSize;

buffer=new char[bufferSize];

strncpy(buffer,other.buffer,bufferSize);

}

Text::~Text ()

{

clear();

}

int Text::getLength () const

{

if(buffersize==0)

   return -1;

return strlen(buffer);

}

char Text::operator [] ( int n ) const

{

if(n<getLength())

return buffer[n];

else

   return 0;

}

void Text::clear ()

{

if(bufferSize>0)

{

delete[]buffer;

buffer=0;

}

bufferSize=0;

}

void Text::showStructure() const

void Text::showStructure () const

{

cout << “bufferSize: ” << bufferSize << “,buffer: [ “;

int i;

for(i = 0; i < getLength(); i++)

cout << buffer[i] << ” “;

for(; i < bufferSize; i++)

cout << “_ “;

cout << “]n”;

}

Text Text::toUpper( ) const

{

Text upper(*this);

for(int i = 0; i < upper.getLength(); i++)

{

if(islower(upper[i]))

{

upper.buffer[i] = toupper(upper[i]);

}

}

return upper;

}

Text Text::toLower( ) const

{

Text lower(*this);

for(int i = 0; i < lower.getLength(); i++)

{

if(isupper(lower[i]))

{

lower.buffer[i] = tolower(lower[i]);

}

}

return lower;

}

char Text::toReverse(Text obj, int position) const

{

if(position < getLength())

{

toReverse(obj, position + 1);

cout << buffer[position];

}

return buffer[position];

}

// ********** Lab 2 *************

Text Text::operator += (const Text &input2)

{

int spaceReqd = getLength() + input2.getLength() + 1;

if(bufferSize >= spaceReqd)

{

strcat(buffer, input2.buffer);

}

else

{

char *buff = new char[spaceReqd];

strcpy(buff, buffer);

strcat(buff, input2.buffer);

clear();

buffer = buff;

bufferSize = spaceReqd;

}

}

istream & operator >> ( istream& input, Text&inputText )

{

char buff[1000];

input >> buff;

inputText.clear();

inputText.bufferSize = strlen(buff) + 1;

inputText.buffer = new char[inputText.bufferSize];

strcpy(inputText.buffer, buff);

return input;

}

ostream & operator << ( ostream& output, constText& outputText )

{

if(outputText.getLength())

output << outputText.buffer;

return output;

}

// *******************************