SLList.cpp

#include "SLList.h"
#include <iostream>
#include <regex>
#include <sstream>
#include <filesystem>
#include <fstream>

namespace SLList {
	using namespace std;

	template<typename T>
	class SinglyLinkedList
	{
	public:
		SinglyLinkedList();
		SinglyLinkedList(const SinglyLinkedList& other);
		~SinglyLinkedList();
		void push_back(T data);
		void push_front(T data);
		void pop_front();
		void clear();
		void build_empty(size_t sizeOfList);
		void insert(T data, int index);
		void removeAt(int index);
		void pop_back();
		int getSize() { return size; }
		T operator[] (const int index);
	private:
		template<typename T>
		class Node
		{
		public:
			Node* pNext;
			T data;
			Node(T data = T(), Node* pNext = nullptr)
			{
				this->data = data;
				this->pNext = pNext;
			}
		};
		Node<T>* head;
		size_t size;
	};

	template<typename T>
	SinglyLinkedList<T>::SinglyLinkedList()
	{
		size = 0;
		head = nullptr;
	}

	template<typename T>
	SinglyLinkedList<T>::SinglyLinkedList(const SinglyLinkedList& other) : SinglyLinkedList()
	{
		Node<T>* current = other.head;
		while (current != nullptr)
		{
			push_back(current->data);
			current = current->pNext;
		}
	}

	template<typename T>
	SinglyLinkedList<T>::~SinglyLinkedList()
	{
		clear();
	}

	template<typename T>
	void SinglyLinkedList<T>::push_back(T data)
	{
		if (head == nullptr)
		{
			head = new Node<T>(data);
		}
		else
		{
			Node<T>* current = this->head;
			while (current->pNext != nullptr)
			{
				current = current->pNext;
			}
			current->pNext = new Node<T>(data);
		}
		size++;
	}

	template<typename T>
	void SinglyLinkedList<T>::pop_front()
	{
		Node<T>* temp = head;
		head = head->pNext;
		delete temp;
		size--;
	}

	template<typename T>
	T SinglyLinkedList<T>::operator[](const int index)
	{
		size_t counter = 0;
		Node<T>* current = this->head;
		while (current != nullptr)
		{
			if (counter == index)
			{
				return current->data;
			}
			++counter;
			current = current->pNext;
		}
	}

	template<typename T>
	void SinglyLinkedList<T>::clear()
	{
		while (size)
		{
			pop_front();
		}
	}

	template<typename T>
	void SinglyLinkedList<T>::build_empty(size_t sizeOfList)
	{
		for (size_t i = 0; i < sizeOfList; ++i)
		{
			push_back(T());
		}
	}

	template<typename T>
	void SinglyLinkedList<T>::push_front(T data)
	{
		head = new Node<T>(data, head);
		size++;
	}

	template<typename T>
	void SinglyLinkedList<T>::insert(T data, int index)
	{
		if (index == 0)
		{
			push_front(data);
		}
		else
		{
			Node<T>* previous = this->head;
			for (size_t i = 0; i < index - 1; ++i)
			{
				previous = previous->pNext;
			}
			Node<T>* newNode = new Node<T>(data, previous->pNext);
			previous->pNext = newNode;
			++size;
		}
	}

	template<typename T>
	void SinglyLinkedList<T>::removeAt(int index)
	{
		if (index == 0)
		{
			pop_front();
		}
		else
		{
			Node<T>* previous = this->head;
			for (size_t i = 0; i < index - 1; ++i)
			{
				previous = previous->pNext;
			}
			Node<T>* temp = previous->pNext;
			previous->pNext = temp->pNext;
			delete temp;
			size--;
		}
	}

	template<typename T>
	void SinglyLinkedList<T>::pop_back()
	{
		removeAt(size - 1);
	}

	template<typename T>
	void print(SinglyLinkedList<T> list)
	{
		cout << endl << "№\t" << "элемент" << endl;
		for (size_t i = 0; i < list.getSize(); ++i)
		{
			cout << i + 1 << "\t" << list[i] << endl;
		}
		cout << endl;
	}

	template<typename T>
	unsigned short allEntryOfElement(T element, SinglyLinkedList<T> list)
	{
		unsigned short counter = 0;
		for (size_t i = 0; i < list.getSize(); ++i)
		{
			if (element == list[i])
				counter++;
		}
		return counter;
	}

	bool isFileCorrect(string path)
	{
		string inputline;
		regex regular("^(\\d+\\s*)+$");
		fstream fin(path, ios_base::in);
		bool isCorrect = true;
		while (!fin.eof() && isCorrect)
		{
			getline(fin, inputline);
			if (!(regex_match(inputline.c_str(), regular)))
				isCorrect = false;
		}
		fin.close();
		return isCorrect;
	}

	string readFilePath(bool flag)
	{
		string path;
		bool isIncorrect;
		do
		{
			isIncorrect = false;
			cout << "Введите абсолютный путь к файлу: " << endl;
			cin >> path;
			if (!filesystem::exists(path))
			{
				cout << "Файл не найден. Проверьте введённый путь." << endl;
				isIncorrect = true;
			}
			else
			{
				if (flag && !isFileCorrect(path))
				{
					cout << "Ошибка при чтении файла! Проверьте данные и попробуйте ещё раз!" << endl;
					isIncorrect = true;
				}
			}

		} while (isIncorrect);
		return path;
	}

	template<typename T>
	void getListFromFile(SinglyLinkedList<T>& list)
	{
		bool flag = true;
		string path = readFilePath(flag);
		string inputline;
		cmatch res;
		regex reg("(\\d+)\\s*");
		fstream fin(path, std::ios_base::in);
		while (!fin.eof())
		{
			getline(fin, inputline);
			auto inputline_begin = sregex_iterator(inputline.begin(), inputline.end(), reg);
			auto inputline_end = sregex_iterator();
			for (auto i = inputline_begin; i != inputline_end; ++i)
			{
				list.push_back(stoi((*i).str()));
			}
		}
		fin.close();
	}

	int readElement(int data)
	{
		string inputLine;
		bool isIncorrect;
		do
		{
			isIncorrect = false;
			try
			{
				cin >> inputLine;
				data = stoi(inputLine);
			}
			catch (...)
			{
				isIncorrect = true;
				cout << "Введите целое число!" << endl;
			}
		} while (isIncorrect);
		return data;
	}

	void getListElementFromConsole(SinglyLinkedList<int>& list)
	{
		int data = 0;
		cout << "Введите элемент списка: \n";
		data = readElement(data);
		list.push_back(data);
	}

	int getMainMenuItem(bool item5)
	{
		bool isIncorrect;
		string inputLine;
		int item = 0;
		do
		{
			isIncorrect = false;
			try
			{
				cin >> inputLine;
				item = stoi(inputLine);
			}
			catch (...)
			{
				isIncorrect = true;
				cout << "Введите целое число!" << endl;
			}
			if (!item5 && (item != 1) && (item != 2) && (item != 3) && !isIncorrect)
			{
				cout << "Выберете один из пунктов меню!\n";
				isIncorrect = true;
			}
			if (item5 && (item != 1) && (item != 2) && (item != 3) && (item != 4) && (item != 5) && !isIncorrect)
			{
				cout << "Выберете один из пунктов меню!\n";
				isIncorrect = true;
			}
		} while (isIncorrect);
		return item;
	}

	int readSizeOfEmptyList()
	{
		bool isIncorrect;
		string inputLine;
		int size;
		do
		{
			isIncorrect = false;
			try
			{
				cin >> inputLine;
				size = stoi(inputLine);
			}
			catch (...)
			{
				isIncorrect = true;
				cout << "Введите целое число!" << endl;
			}
			if (!isIncorrect && size < 1 && size > 2000000)
			{
				cout << "Введите положительное число до 2*10^6!\n";
				isIncorrect = true;
			}
		} while (isIncorrect);
		return size;
	}

	size_t readDeletableElementIndex(size_t index, SinglyLinkedList<int>& list)
	{
		bool isIncorrect;
		string inputLine;
		do
		{
			isIncorrect = false;
			try
			{
				cin >> inputLine;
				index = stoi(inputLine);
			}
			catch (...)
			{
				isIncorrect = true;
				cout << "Введите целое число!" << endl;
			}
			if (!isIncorrect && index + 1 < list.getSize() && index + 1 > list.getSize())
			{
				cout << "Введите индекс в преедлах размера списка!\n";
				isIncorrect = true;
			}
		} while (isIncorrect);
		return index - 1;
	}

	string readFilePath()
	{
		string path;
		bool isIncorrect;
		isIncorrect = true;
		do
		{
			cout << "Введите абсолютный путь к файлу: " << endl;
			cin >> path;
			if (!std::filesystem::exists(path))
				cout << "Файл не найден. Проверьте введённый путь." << endl;
			else
				isIncorrect = false;
		} while (isIncorrect);
		return path;
	}

	void saveList(SinglyLinkedList<int>& list)
	{
		ofstream fout;
		string path = readFilePath();
		fout.open(path);
		for (size_t i = 0; i < list.getSize(); ++i)
			fout << list[i] << " ";
		fout.close();
		cout << "Список успешно сохранён в файл!" << endl;
	}

	void selectMenuItem(int menuItem, SinglyLinkedList<int>& list)
	{
		int data = 0;
		size_t index = 0;
		switch (menuItem)
		{
		case 1:
			cout << "Введите элемент списка:" << endl;
			data = readElement(data);
			list.push_back(data);
			break;
		case 2:
			cout << "Введите индекс удаляемого элемента:" << endl;
			index = readDeletableElementIndex(index, list);
			list.removeAt(index);
			break;
		case 3:
			cout << "Введите элемент:\n";
			data = readElement(data);
			cout << "Вхождений элемента " << data << " в список: " << allEntryOfElement(data, list) << endl;
			break;
		case 4:
			saveList(list);
			break;
		case 5:
			exit(0);
			break;
		}
		print(list);
	}

	void showMenu(SinglyLinkedList<int> list)
	{
		bool item5 = true;
		cout << "Выберете один из пунктов меню :" << endl;
		cout << "1. Добавить новый элемент." << endl;
		cout << "2. Удалить элемент." << endl;
		cout << "3. Подсчитать количество всех вхождений заданного элемента." << endl;
		cout << "4. Сохранить список в файл." << endl;
		cout << "5. Завершить программу." << endl;
		selectMenuItem(getMainMenuItem(item5), list);
		showMenu(list);
	}

	void selectMainMenuItem(int menuItem)
	{
		SinglyLinkedList<int> list;
		switch (menuItem)
		{
		case 1:
			getListFromFile(list);
			break;
		case 2:
			getListElementFromConsole(list);
			break;
		case 3:
			cout << "Введите размер списка\n";
			list.build_empty(readSizeOfEmptyList());
			break;
		}
		print(list);
		showMenu(list);
	}

	void showMainMenu()
	{
		bool item5 = false;
		cout << "Выберете один из пунктов меню :" << endl;
		cout << "1. Открыть список из файла." << endl;
		cout << "2. Создать новый список." << endl;
		cout << "3. Создать новый пустой список указанного размера." << endl;
		selectMainMenuItem(getMainMenuItem(item5));
	}
}