Bachelorarbeit/ClientSimulation/DataModel.cpp

#include "DataModel.h"
#include "instreamOperator.h"
#include <fstream>
#include <filesystem>
#include <charconv>
#include <ranges>
#include <mutex> 


//Initialization of static member
std::unique_ptr<DataModel> DataModel::instance = nullptr;

//Read file locker
std::timed_mutex accessFilesMTX;

inline void DataModel::Create() {
	
	instance = std::make_unique<DataModel>();
}

std::unique_ptr<DataModel>& DataModel::Instance() {
	if (!instance)
		Create();
	return instance;
}

inline void DataModel::Destroy() {
	if (instance)
		instance.reset();
}

std::ostream& operator<<(std::ostream& os, const PublisherType type) {
	switch (type) {
	case PublisherType::RCMS_BENDER:
		os << "Bender RCMS";
		break;
	case PublisherType::POWERCENTER:
		os << "Siemens Powercenter";
		break;
	default:
		os << "<Unknown Publisher Type>";
		break;
	}
	return os;
}


void DataModel::savePublishedData(PublisherData data)
{
	auto iter = savedPublishedData.find(data.getID());
	if (iter != savedPublishedData.end()) {
		iter->second.push_back(data);
	}
	else {
		std::vector<PublisherData> test{ data };
		savedPublishedData.emplace(data.getID(), test);
	}
}

std::istream& operator>>(std::istream& is, char const* pat);

//Deserialize dataModel object
std::istream& operator>>(std::istream& is, DataModel& dataModel) {
	
	char a;

	//Prase header
	unsigned long long startTime;
	unsigned int interval;
	is >> startTime >> "," >> interval;
	//remove return
	is.get();

	//Parse Body
	while (( a = is.peek()) != EOF) {
		unsigned int id;
		is >> id >> ":";
		try {
			std::vector<PublisherData> values;
			while (is.peek() != '\n') {
				PublisherData data;
				is >> data;
				data.setID(id);
				values.push_back(data);
			}
			is.get();
			
			auto iter = dataModel.savedPublishedData.find(id);
			if (iter == dataModel.savedPublishedData.end()) {
				dataModel.savedPublishedData.emplace(id, values);
			}
			else {
				for (auto& v : values)
				{
					iter->second.push_back(v);
				}
			}
		}
		catch (std::exception& e) { std::cout << e.what(); }
	}
	
	return is;
}