C++ Monitor

// Lab1b.cpp : Defines the entry point for the console application.
//
#define _CRT_SECURE_NO_WARNINGS

#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <thread>
#include <cstdlib>
#include <omp.h>
#include <mutex>

using namespace std;
mutex mtx;

const int FAK_COUNT = 5;
const int MAX_STUD_FAKULTETE = 10;
const int MAX_LAUKU = 50;

struct Studentas {
	int eilesNr = 0;
	string vardas;
	int kursas;
	double vidurkis;
};

struct Fakultetas {
	int studCount;
	string pavadinimas;
	Studentas studentai[MAX_LAUKU];
};

// rikiavimo laukas
struct Laukas {
	int laukas;
	int kiekis = 0;
};

// lauku konteineris
struct Laukai {
	int laukuCount;
	Laukas laukai[MAX_STUD_FAKULTETE];
};

struct Monitor {
	Laukai B;

	void insert(Laukas l, int masyvoNr) {
		mtx.lock();

		int laukoKiekis = -1;
		if (B.laukuCount == 0) {
			B.laukai[0].laukas = l.laukas;
			B.laukai[0].kiekis = l.kiekis;
			B.laukuCount++;
			laukoKiekis = l.kiekis;
		}
		else {
			bool isNew = true;
			for (int i = 0; i < B.laukuCount; i++)
			{
				if (B.laukai[i].laukas == l.laukas) {
					B.laukai[i].kiekis += l.kiekis;
					laukoKiekis = B.laukai[i].kiekis;
					isNew = false;
				}
			}
			if (isNew) {
				int index = findIndexToInsert(l.laukas);
				B.laukai[index].laukas = l.laukas;
				B.laukai[index].kiekis = l.kiekis;
				laukoKiekis = l.kiekis;
			}
		}

		cout << "P" << masyvoNr << " prideda " << l.laukas << " lauka. tokiu lauku kiekis: " << laukoKiekis << endl;

		mtx.unlock();
	}

	int findIndexToInsert(int reiksme) {
		for (int i = 0; i < B.laukuCount; i++)
		{
			if (reiksme > B.laukai[i].laukas) {
				for (int j = B.laukuCount - 1; j >= i; j--)
					B.laukai[j + 1] = B.laukai[j];

				B.laukuCount++;
				return i;
			}
		}
		B.laukuCount++;
		return B.laukuCount - 1;
	}

	//grazina false - nerado arba pasalino visus elementus
	//grazina true - rado, pasalino kieki ir dar liko elementu
	bool remove(Laukas l, int masyvoNr) {
		mtx.lock();
		int arRado = false;
		for (int i = 0; i < B.laukuCount; i++)
		{
			if (B.laukai[i].laukas == l.laukas) {
				arRado = true;

				if (B.laukai[i].kiekis <= l.kiekis) {
					for (int j = i; j < B.laukuCount; j++)
						B.laukai[j] = B.laukai[j + 1];

					B.laukai[B.laukuCount - 1].laukas = 0;
					B.laukai[B.laukuCount - 1].kiekis = 0;
					B.laukuCount--;
					break;
				}

				B.laukai[i].kiekis -= l.kiekis;
				break;
			}
		}

		cout << "V" << masyvoNr << " atima " << l.laukas << " lauka. atimamas kiekis: " << arRado << endl;

		mtx.unlock();
		return arRado;
	}

};

Monitor B;
bool BaigeDetiIB = false;

void readData(Fakultetas(&fakultetai)[FAK_COUNT], Laukai(&laukaiGrazinami)[FAK_COUNT]);
void printData(Fakultetas(&fakultetai)[FAK_COUNT], Laukai(&laukai)[FAK_COUNT]);
void startThreads(Fakultetas(&fakultetai)[FAK_COUNT], Laukai(&laukai)[FAK_COUNT]);
void executeP(int i, Studentas studentai[], int studCount);
void executeV(int i, Laukas laukai[], int laukuCount);
void printResults();

int main()
{
	Fakultetas fakultetai[FAK_COUNT];
	Laukai laukai[FAK_COUNT];

	readData(fakultetai, laukai);
	printData(fakultetai, laukai);
	startThreads(fakultetai, laukai);
	printResults();

	getchar();
	return 0;
}

void readData(Fakultetas(&fakultetai)[FAK_COUNT], Laukai(&laukaiGrazinami)[FAK_COUNT])
{
	ifstream file;
	file.open("IFF57_RainysJ_Lab2a_dat_2.txt");

	string stringLaukas;
	string intLaukas;
	string doubleLaukas;

	for (int i = 0; i < FAK_COUNT; i++)
	{
		file >> fakultetai[i].pavadinimas >> fakultetai[i].studCount;

		for (int j = 0; j < fakultetai[i].studCount; j++)
		{
			file >> stringLaukas >> intLaukas >> doubleLaukas;

			fakultetai[i].studentai[j].kursas = stoi(intLaukas);
			fakultetai[i].studentai[j].vidurkis = stod(doubleLaukas);
			fakultetai[i].studentai[j].vardas = stringLaukas;
		}
	}

	int V_COUNT;
	file >> V_COUNT;
	for (int i = 0; i < V_COUNT; i++)
	{
		file >> laukaiGrazinami[i].laukuCount;

		for (int j = 0; j < laukaiGrazinami[i].laukuCount; j++)
		{
			file >> laukaiGrazinami[i].laukai[j].laukas >> laukaiGrazinami[i].laukai[j].kiekis;
		}
	}

	file.close();
}

void printData(Fakultetas(&fakultetai)[FAK_COUNT], Laukai(&laukai)[FAK_COUNT])
{
	ofstream file;
	file.open("IFF57_RainysJ_Lab2a_rez.txt");

	for (int i = 0; i < FAK_COUNT; i++)
	{
		file << "Fakultetas: " << fakultetai[i].pavadinimas << endl;
		file << setw(5) << left << "nr." << setw(14) << left << "studentas" << "kursas" << "  " << setprecision(3) << "vidurkis" << endl;
		file << "-----------------------------------" << endl;

		for (int j = 0; j < fakultetai[i].studCount; j++)
		{
			string vardas = fakultetai[i].studentai[j].vardas;
			int kursas = fakultetai[i].studentai[j].kursas;
			double vidurkis = fakultetai[i].studentai[j].vidurkis;

			file << setw(5) << j + 1 << left << setw(14) << left << vardas << "|   " << kursas << "|     " << setprecision(3) << vidurkis << "|" << endl;
		}

		file << "-----------------------------------" << endl;

		for (int j = 0; j < laukai[i].laukuCount; j++)
		{
			int laukas = laukai[i].laukai[j].laukas;
			int kiekis = laukai[i].laukai[j].kiekis;

			file << "laukas: " << setw(8) << right << laukas << ", "<< "kiekis: " << setw(8) << right << kiekis <<  "|" << endl;
		}

		file << "-----------------------------------" << endl << endl;
	}

	file.close();
}

void printResults() {
	ofstream file;
	file.open("IFF57_RainysJ_Lab2a_rez.txt", ios_base::app);

	file << "B[] = " << endl;
	file << "-----------------------------------" << endl;
	for (int i = 0; i < B.B.laukuCount; i++)
	{
		file << "laukas: " << setw(8) << right << B.B.laukai[i].laukas << ", " << "kiekis: " << setw(8) << right << B.B.laukai[i].kiekis << "|" << endl;

	}
	file << "-----------------------------------" << endl;

	file.close();
}

void startThreads(Fakultetas(&fakultetai)[FAK_COUNT], Laukai(&laukai)[FAK_COUNT])
{
	int baigusiuDetiGijuCount = 0;
	B.B.laukuCount = 0;
	int threadsCount = FAK_COUNT * 2;
	//thread t[FAK_COUNT * 2];

	#pragma omp parallel num_threads(FAK_COUNT * 2)
	{
		int i = omp_get_thread_num();

		if (i < FAK_COUNT)
			executeP(i, fakultetai[i].studentai, fakultetai[i].studCount);
		else
			executeV(i - FAK_COUNT, laukai[i - FAK_COUNT].laukai, laukai[i - FAK_COUNT].laukuCount);


		if (i < FAK_COUNT - 1)
			baigusiuDetiGijuCount++;

		if(baigusiuDetiGijuCount == FAK_COUNT - 1)
			BaigeDetiIB = true;
	}

	//for (int i = 0; i < threadsCount; i++)
	//{
	//	if (i < FAK_COUNT)
	//		t[i] = thread(executeP, i, fakultetai[i].studentai, fakultetai[i].studCount);
	//	else
	//		t[i] = thread(executeV, i - FAK_COUNT, laukai[i - FAK_COUNT].laukai, laukai[i - FAK_COUNT].laukuCount);
	//}

	//for (int i = 0; i < threadsCount; i++)
	//{
	//	t[i].join();
	//	if (i < FAK_COUNT - 1)
	//		baigusiuDetiGijuCount++;
	//	else
	//		BaigeDetiIB = true;
	//}
}

void executeP(int ind, Studentas studentai[], int studCount)
{
	for (int i = 0; i < studCount; i++)
	{
		Laukas laukas;
		laukas.laukas = studentai[i].kursas;
		laukas.kiekis = 1;

		B.insert(laukas, ind);
	}
}

void executeV(int ind, Laukas laukai[], int laukuCount)
{
	bool arSuktiCikla = true;
	bool arLiko[MAX_LAUKU] = { true };
	while (arSuktiCikla || !BaigeDetiIB) {
		for (int i = 0; i < laukuCount; i++)
		{
			arLiko[i] = B.remove(laukai[i], ind);
		}

		int likusiuKiekis = 0;
		for (int i = 0; i < laukuCount; i++)
		{
			if (arLiko[i])
				likusiuKiekis++;
		}

		if (likusiuKiekis == 0)
			arSuktiCikla = false;
	}
}