Question

First, create a class object named SequenceMap that has as private data members the following two:

string recognition_sequence_ ;

vector enzyme_acronyms_;

Other than the big-five (note that you can use the defaults for all of them), you have to add the following:

a) A constructor SequenceMap(const string &a_rec_seq, const string &an_enz_acro),that constructs a SequenceMap from two strings (note that now the vector enzyme_acronyms_ will contain just one element, the an_enz_acro).

b) bool operator<(const SequenceMap &rhs) const, that operates based on the regular string comparison between the recognition_sequence_ strings (this will be a one line function).

c) Overload the operator<< for SequenceMap.

d) void Merge(const SequenceMap &other_sequence). This function assumes that the object’s recognition_sequence_ and other_sequence.recognition_sequence_ are equal to each other. The function Merge() merges the other_sequence.enzyme_acronym_ with the object’s enzyme_acronym_. The other_sequence object will not be affected.

Please test it with your own test functions to make sure that it operates correctly.

Please also show the test functions that you utilize so I can also implement it.

thank you.

Answer 1

SequenceMap.cpp

#include "SequenceMap.h"

int main() {
   string recSequence = "SEQUENCE";
   string recSequence_ = "SEQUENCE_";
   string enzymeOne = "enzymeOne";
   string thingS = "THINGS";
   string enzymeThree = "enzymeThree";
   SequenceMap mySM(recSequence, enzymeOne);
   SequenceMap anotherSM(recSequence, enzymeThree);
   SequenceMap diffSM(thingS, thingS);
   if (mySM < diffSM) {
       cout << "it is true" << endl;
   }
   else {
       cout << "it is false" << endl;
   }
   //cout << mySM;
   mySM.Merge(diffSM);
   mySM.Merge(anotherSM);

   cout << "###############" << endl;
   cout << mySM;
   //*/
   return 0;
}

SequenceMap.h

#ifndef SEQUENCEMAP_H
#define SEQUENCEMAP_H

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class SequenceMap {
public:
   // Zero-parameter constructor.
    SequenceMap() = default;
    // Copy-constructor.
    SequenceMap(const SequenceMap &rhs) = default;
    // Copy-assignment.
    SequenceMap& operator=(const SequenceMap &rhs) = default;
    // Move-constructor.
   SequenceMap(SequenceMap &&rhs) = default;
   // Move-assignment.
   SequenceMap& operator=(SequenceMap &&rhs) = default;
   // Destructor.
   ~SequenceMap() = default;

   // Start of Part 1

   // Constructor for recognition sequence and enzyme acronym
   SequenceMap(const string &a_rec_seq, const string &an_enz_acro) {
       recognition_sequence_ = a_rec_seq;
       enzyme_acronyms_.push_back(an_enz_acro);
   }

   // Constructor for recognition sequence only
   SequenceMap(const string &a_rec_seq) {
       recognition_sequence_ = a_rec_seq;
       enzyme_acronyms_.push_back("");
   }

   // Overload the < operator
   bool operator<(const SequenceMap &rhs) const {
       return (recognition_sequence_ < rhs.recognition_sequence_);
   }

   // Overload the << operator to print the recognition sequence with enzyme acronyms
   friend std::ostream &operator<<(std::ostream &out, const SequenceMap &a_SequenceMap) {
       out << a_SequenceMap.recognition_sequence_ << "   ";
       for (int i = 0; i < a_SequenceMap.enzyme_acronyms_.size(); ++i) {
           out << a_SequenceMap.enzyme_acronyms_[i] << " ";
       }
       return out;
   }

   // Merge two SequenceMap objects
   void Merge(const SequenceMap &other_sequence) {
       for (int i = 0; i < other_sequence.enzyme_acronyms_.size(); ++i) {
           enzyme_acronyms_.push_back(other_sequence.enzyme_acronyms_[i]);  
       }
   }

   // Print the recognition sequence
   string getRecognitionSequence() const {
       return recognition_sequence_;
   }

   // Print enzyme acronym
   void printAllEnzAcroOfRecSeq() const {
       for (int i = 0; i < enzyme_acronyms_.size() ; ++i) {
           cout << enzyme_acronyms_[i] << "   ";  
       }
       cout << endl;
   }

private:
   string recognition_sequence_ ;
   vector<string> enzyme_acronyms_;
};

#endif