Advertisement
ludaludaed

Untitled

Nov 24th, 2022 (edited)
569
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 8.20 KB | None | 0 0
  1. #include <iostream>
  2. #include <fstream>
  3. #include <string>
  4. #include <vector>
  5. #include <memory>
  6.  
  7. #define SIZE_OF_STRING 64
  8.  
  9. class WordNote {
  10. public:
  11.     friend std::istream &operator>>(std::istream &stream, WordNote &data) {
  12.         return stream >> data.word_ >> data.number_of_occurrences_;
  13.     }
  14.  
  15.     friend std::ostream &operator<<(std::ostream &stream, const WordNote &data) {
  16.         return stream << data.word_ << " " << data.number_of_occurrences_;
  17.     }
  18.  
  19. private:
  20.     char word_[SIZE_OF_STRING];
  21.     uint64_t number_of_occurrences_{0};
  22.  
  23. public:
  24.     WordNote() = default;
  25.  
  26.     WordNote(const WordNote &other) = default;
  27.  
  28.     WordNote(WordNote &&other) noexcept = default;
  29.  
  30.     WordNote &operator=(const WordNote &other) = default;
  31.  
  32.     WordNote &operator=(WordNote &&other) noexcept = default;
  33.  
  34.     WordNote(const std::string &word, uint64_t number_of_occurrences)
  35.             : number_of_occurrences_(number_of_occurrences), word_() {
  36.         std::memcpy(word_, word.data(), SIZE_OF_STRING - 1);
  37.         word_[SIZE_OF_STRING - 1] = '\0';
  38.     }
  39.  
  40.     void setWord(const std::string &word) {
  41.         std::memcpy(word_, word.data(), SIZE_OF_STRING - 1);
  42.         word_[SIZE_OF_STRING - 1] = '\0';
  43.     }
  44.  
  45.     std::string getWord() const {
  46.         return std::string(word_);
  47.     }
  48.  
  49.     uint64_t getNumberOfOccurrences() const {
  50.         return number_of_occurrences_;
  51.     }
  52.  
  53.     void setNumberOfOccurrences(uint64_t numberOfOccurrences) {
  54.         number_of_occurrences_ = numberOfOccurrences;
  55.     }
  56.  
  57.     static WordNote read(std::istream &);
  58.  
  59.     static void write(std::ostream &, const WordNote &);
  60. };
  61.  
  62. WordNote WordNote::read(std::istream &stream) {
  63.     WordNote word{};
  64.     stream.read(reinterpret_cast<char *>(&word), sizeof(word));
  65.     return word;
  66. }
  67.  
  68. void WordNote::write(std::ostream &stream, const WordNote &data) {
  69.     stream.write(reinterpret_cast<const char *>(&data), sizeof(data));
  70. }
  71.  
  72.  
  73. class FrequencyDictionary {
  74.     std::string path_;
  75.     std::fstream data_;
  76.  
  77. public:
  78.     void update(const std::string &word) {
  79.         if (!data_) {
  80.             throw std::exception("Fail of file");
  81.         }
  82.         data_.seekg(std::ios_base::beg);
  83.         auto start = data_.tellp();
  84.         data_.seekg(std::ios_base::end);
  85.         auto end = data_.tellp();
  86.  
  87.         data_.seekg(std::ios_base::beg);
  88.  
  89.         for (; start != end; start += sizeof(WordNote)) {
  90.             data_.seekg(start, std::ios_base::beg);
  91.             WordNote data = WordNote::read(data_);
  92.             if (data.getWord() == word) {
  93.                 data.setNumberOfOccurrences(data.getNumberOfOccurrences() + 1);
  94.                 data_.seekg(start, std::ios_base::beg);
  95.                 WordNote::write(data_, data);
  96.                 data_.seekg(std::ios_base::beg);
  97.                 return;
  98.             }
  99.         }
  100.         WordNote word_note(word, 1);
  101.         WordNote::write(data_, word_note);
  102.         data_.seekg(std::ios_base::beg);
  103.     }
  104.  
  105.     void erase(const std::string &word) {
  106.         if (!data_) {
  107.             throw std::exception("Fail of file");
  108.         }
  109.         data_.seekg(std::ios_base::beg);
  110.         auto start = data_.tellp();
  111.         data_.seekg(std::ios_base::end);
  112.         auto end = data_.tellp();
  113.  
  114.         data_.seekg(std::ios_base::beg);
  115.  
  116.         std::vector<WordNote> new_notes;
  117.  
  118.         for (; start != end; start += sizeof(WordNote)) {
  119.             data_.seekg(start, std::ios_base::beg);
  120.             WordNote data = WordNote::read(data_);
  121.             if (data.getWord() != word) {
  122.                 new_notes.push_back(data);
  123.             }
  124.         }
  125.  
  126.         bind(path_);
  127.         if (!data_) {
  128.             throw std::exception("Bad open!");
  129.         }
  130.         for (auto it = new_notes.begin(); it != new_notes.end(); ++it) {
  131.             WordNote::write(data_, *it);
  132.         }
  133.     }
  134.  
  135.     void bind(const std::string &file_name) {
  136.         data_.open(file_name, std::ios_base::binary);
  137.         if (!data_) {
  138.             throw std::exception("Bad open!");
  139.         }
  140.         path_ = file_name;
  141.     }
  142.  
  143.     void clear() {
  144.         data_.open(path_, std::ios_base::binary | std::ios_base::out);
  145.         data_.open(path_, std::ios_base::binary);
  146.         if (!data_) {
  147.             throw std::exception("Bad open!");
  148.         }
  149.     }
  150.  
  151.     void fill(std::istream &stream) {
  152.         if (!data_) {
  153.             throw std::exception("Bad open!");
  154.         }
  155.         clear();
  156.         std::string word;
  157.         while (stream >> word) {
  158.             update(word);
  159.         }
  160.     }
  161.  
  162.     std::string maxWord() {
  163.         if (!data_) {
  164.             throw std::exception("Bad open!");
  165.         }
  166.         WordNote max_word_note{};
  167.  
  168.         data_.seekg(std::ios_base::beg);
  169.         auto start = data_.tellp();
  170.         data_.seekg(std::ios_base::end);
  171.         auto end = data_.tellp();
  172.  
  173.         data_.seekg(std::ios_base::beg);
  174.  
  175.         for (; start != end; start += sizeof(WordNote)) {
  176.             data_.seekg(start, std::ios_base::beg);
  177.             WordNote data = WordNote::read(data_);
  178.             if (data.getNumberOfOccurrences() > max_word_note.getNumberOfOccurrences()) {
  179.                 max_word_note = data;
  180.             }
  181.         }
  182.         return max_word_note.getWord();
  183.     }
  184.  
  185.     void out(std::ostream &stream) {
  186.         if (!data_) {
  187.             throw std::exception("Bad open!");
  188.         }
  189.         data_.seekg(std::ios_base::beg);
  190.         auto start = data_.tellp();
  191.         data_.seekg(std::ios_base::end);
  192.         auto end = data_.tellp();
  193.  
  194.         data_.seekg(std::ios_base::beg);
  195.  
  196.         for (; start != end; start += sizeof(WordNote)) {
  197.             data_.seekg(start, std::ios_base::beg);
  198.             WordNote data = WordNote::read(data_);
  199.             stream << data;
  200.         }
  201.     }
  202. };
  203.  
  204. void secondTaskRun() {
  205.     FrequencyDictionary frequency_dictionary;
  206.     while (true) {
  207.         try {
  208.             std::cout << "1) Open file" << std::endl;
  209.             std::cout << "2) Update item" << std::endl;
  210.             std::cout << "3) Erase item" << std::endl;
  211.             std::cout << "4) Most frequently occurring word" << std::endl;
  212.             std::cout << "5) Out in console" << std::endl;
  213.             std::cout << "6) Out in file" << std::endl;
  214.             std::cout << "7) Fill file" << std::endl;
  215.             std::cout << "0) Exit" << std::endl;
  216.  
  217.             int num_of_operation;
  218.             std::cin >> num_of_operation;
  219.             if (num_of_operation == 1) {
  220.                 std::cout << "Enter the path:" << std::endl;
  221.                 std::string path;
  222.                 std::cin >> path;
  223.                 frequency_dictionary.bind(path);
  224.             } else if (num_of_operation == 2) {
  225.                 std::cout << "Enter the word:" << std::endl;
  226.                 std::string word;
  227.                 std::cin >> word;
  228.                 frequency_dictionary.update(word);
  229.             } else if (num_of_operation == 3) {
  230.                 std::cout << "Enter the word:" << std::endl;
  231.                 std::string word;
  232.                 std::cin >> word;
  233.                 frequency_dictionary.erase(word);
  234.             } else if (num_of_operation == 4) {
  235.                 std::cout << frequency_dictionary.maxWord();
  236.             } else if (num_of_operation == 5) {
  237.                 frequency_dictionary.out(std::cout);
  238.             } else if (num_of_operation == 6) {
  239.                 std::cout << "Enter the path:" << std::endl;
  240.                 std::string path;
  241.                 std::cin >> path;
  242.                 std::ofstream out(path);
  243.                 if (!out) {
  244.                     throw std::exception("Bad open!");
  245.                 }
  246.                 frequency_dictionary.out(out);
  247.             } else if (num_of_operation == 7) {
  248.                 std::cout << "Enter the path:" << std::endl;
  249.                 std::string path;
  250.                 std::cin >> path;
  251.                 std::ifstream in(path);
  252.                 if (!in) {
  253.                     throw std::exception("Bad open!");
  254.                 }
  255.                 frequency_dictionary.fill(in);
  256.             } else {
  257.                 return;
  258.             }
  259.         } catch (std::exception &exception) {
  260.             std::cout << exception.what() << std::endl;
  261.         }
  262.     }
  263. }
  264.  
  265. int main() {
  266.     secondTaskRun();
  267. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement