BasicsOfComputerSoftwareEngineering/大作业/Record.cpp

#include "Record.hpp"
#include "Tools.hpp"
#include <iomanip>
#include <iostream>

unsigned BaseRecord::nextRecordID = 1;

std::string BaseRecord::cutToLength(std::string str, int length) const {
    if (str.length() <= length) {
        return str;
    }
    else {
        return str.substr(0, length) + "+";
    }
}

BaseRecord::BaseRecord(const time_t _date, const std::string _courseName,
                       const int _studentNumber, const std::string _studentName)
    : recordID(nextRecordID++), date(_date), courseName(_courseName),
      studentNumber(_studentNumber), studentName(_studentName){};

BaseRecord::BaseRecord(const unsigned _recordID, const time_t _date,
                       const std::string _courseName, const int _studentNumber,
                       const std::string _studentName)
    : recordID(_recordID), date(_date), courseName(_courseName),
      studentNumber(_studentNumber), studentName(_studentName){};

const unsigned BaseRecord::getRecordID() const {
    return this->recordID;
}

const Date &BaseRecord::getDate() const {
    return this->date;
}

const std::string BaseRecord::getCourseName() const {
    return this->courseName;
}

const int BaseRecord::getStudentNumber() const {
    return this->studentNumber;
}

const std::string BaseRecord::getStudentName() const {
    return this->studentName;
}

void BaseRecord::promptForNewDate(bool showOriginal) {
    time_t originTime = this->date.getTime();
    tm *curDate = localtime(&originTime);
    int tempInput;
    if (showOriginal) {
        char buffer[20];
        strftime(buffer, 20, "%F", curDate);
        std::cout << setoutputcolor(green) << "Current date: " << buffer
                  << ". Enter 0 to retain original value." << resetOutputColor
                  << std::endl;
        std::cout << setoutputcolor(blue) << "Year: " << resetOutputColor
                  << std::flush;
        std::cin >> tempInput;
        curDate->tm_year =
            (tempInput == 0 ? curDate->tm_year : tempInput - 1900);
        std::cout << setoutputcolor(blue) << "Month: " << resetOutputColor
                  << std::flush;
        std::cin >> tempInput;
        curDate->tm_mon = (tempInput == 0 ? curDate->tm_mon : tempInput - 1);
        std::cout << setoutputcolor(blue) << "Day: " << resetOutputColor
                  << std::flush;
        std::cin >> tempInput;
        curDate->tm_mday = (tempInput == 0 ? curDate->tm_mday : tempInput);
    }
    else {
        std::cout << setoutputcolor(blue) << "Year: " << resetOutputColor
                  << std::flush;
        std::cin >> tempInput;
        curDate->tm_year = tempInput - 1900;
        std::cout << setoutputcolor(blue) << "Month: " << resetOutputColor
                  << std::flush;
        std::cin >> tempInput;
        curDate->tm_mon = tempInput - 1;
        std::cout << setoutputcolor(blue) << "Day: " << resetOutputColor
                  << std::flush;
        std::cin >> tempInput;
        curDate->tm_mday = tempInput;
    }
    this->date = mktime(curDate);
}

void BaseRecord::promptForNewCourseName(bool showOriginal) {
    if (showOriginal) {
        std::cout << setoutputcolor(green)
                  << "Original course name: " << resetOutputColor
                  << this->courseName << "\n"
                  << setoutputcolor(green)
                  << "Enter 0 to retain original value." << std::endl;
    }
    std::cout << "Course name: " << std::flush;
    std::cin >> this->courseName;
}

void BaseRecord::promptForNewStudentInfo(bool showOriginal) {
    if (showOriginal) {
        int tempStuID;
        std::string tempStuName;
        std::cout << setoutputcolor(green) << "Current student info: \n"
                  << setoutputcolor(blue) << "Student ID: " << resetOutputColor
                  << this->studentNumber << "\n"
                  << setoutputcolor(blue)
                  << "Student Name: " << resetOutputColor << this->studentName
                  << "\n"
                  << setoutputcolor(green)
                  << "Enter 0 to retain original value." << std::endl;
        std::cout << setoutputcolor(blue) << "Student ID: " << resetOutputColor
                  << std::flush;
        std::cin >> tempStuID;
        this->studentNumber =
            (tempStuID == 0 ? this->studentNumber : tempStuID);
        std::cout << setoutputcolor(blue)
                  << "Studnet Name: " << resetOutputColor << std::flush;
        std::cin >> tempStuName;
        this->studentName =
            (tempStuName == "0" ? this->studentName : tempStuName);
    }
    else {
        std::cout << setoutputcolor(blue) << "Student ID: " << resetOutputColor
                  << std::flush;
        std::cin >> this->studentNumber;
        std::cout << setoutputcolor(blue)
                  << "Studnet Name: " << resetOutputColor << std::flush;
        std::cin >> this->studentName;
    }
}

void BaseRecord::display() const {
    std::cout << std::setfill('0') << std::setw(8) << this->recordID;
    std::cout << " | ";
    std::cout << std::setfill(' ') << std::setw(12)
              << this->cutToLength(this->date.toString(), 12);
    std::cout << " | ";
    std::cout << std::setfill(' ') << std::setw(15)
              << this->cutToLength(this->courseName, 15);
    std::cout << " | ";
    std::cout << std::setfill(' ') << std::setw(10) << this->studentNumber;
    std::cout << " | ";
    std::cout << std::setfill(' ') << std::setw(15)
              << this->cutToLength(this->studentName, 15);
    std::cout << " | ";
    std::cout << std::setfill(' ') << std::setw(10) << this->getRecordType();
    std::cout << std::endl;
}

LateRecord::LateRecord(const time_t _date, const std::string _courseName,
                       const int _studentNumber, const std::string _studentName)
    : BaseRecord(_date, _courseName, _studentNumber, _studentName){};

LateRecord::LateRecord(const unsigned _recordID, const time_t _date,
                       const std::string _courseName, const int _studentNumber,
                       const std::string _studentName)
    : BaseRecord(_recordID, _date, _courseName, _studentNumber, _studentName){};

std::string LateRecord::getRecordType() const {
    return "Late";
}

AbsentRecord::AbsentRecord(const time_t _date, const std::string _courseName,
                           const int _studentNumber,
                           const std::string _studentName)
    : BaseRecord(_date, _courseName, _studentNumber, _studentName){};

AbsentRecord::AbsentRecord(const unsigned _recordID, const time_t _date,
                           const std::string _courseName,
                           const int _studentNumber,
                           const std::string _studentName)
    : BaseRecord(_recordID, _date, _courseName, _studentNumber, _studentName){};

std::string AbsentRecord::getRecordType() const {
    return "Absent";
}

PersonalLeaveRecord::PersonalLeaveRecord(const time_t _date,
                                         const std::string _courseName,
                                         const int _studentNumber,
                                         const std::string _studentName)
    : BaseRecord(_date, _courseName, _studentNumber, _studentName){};

PersonalLeaveRecord::PersonalLeaveRecord(const unsigned _recordID,
                                         const time_t _date,
                                         const std::string _courseName,
                                         const int _studentNumber,
                                         const std::string _studentName)
    : BaseRecord(_recordID, _date, _courseName, _studentNumber, _studentName){};

std::string PersonalLeaveRecord::getRecordType() const {
    return "Personal";
}

SaveRecord::SaveRecord(const unsigned _recordID, const time_t _date,
                       const std::string &courseName, const int _studentNumber,
                       const std::string &studentName, RecordType _recordType)
    : recordID(_recordID), date(_date), courseNameLength(courseName.length()),
      studentNumber(_studentNumber), studentNameLength(studentName.length()),
      recordType(_recordType){};

BaseRecord *SaveRecord::convertToRecord(const char *_courseName,
                                        const char *_name) const {
    switch (this->recordType) {
    case Late:
        return new LateRecord(this->recordID, this->date,
                              std::string(_courseName), this->studentNumber,
                              std::string(_name));
    case Absent:
        return new AbsentRecord(this->recordID, this->date,
                                std::string(_courseName), this->studentNumber,
                                std::string(_name));
    case PersonalLeave:
        return new PersonalLeaveRecord(this->recordID, this->date,
                                       std::string(_courseName),
                                       this->studentNumber, std::string(_name));
    }
}