#include <iostream>
#include <fstream>
#include <cstring>
#include <unistd.h>
#include <chrono>
#include <sstream>
#include <string>
#include <bits/stdc++.h>

using namespace std;

struct process_detail {
	//cpu_burst_times[0] is arrival time
	int pid;
	vector<int> burst_times;
	int in_cpu;
	int ptr;
};

struct clock{
	int push_signal; //boolean
	int timer;

};

//// operator overloading
//struct CompareHeight {
//    bool operator()(struct process_detail p1, struct process_detail p2)
//    {
//        // return "true" if "p1" is ordered
//        // before "p2", for example:
//        return p1.height < p2.height;
//    }
//};


vector<struct process_detail> processes;
vector<struct process_detail> ready_queue;
queue<struct process_detail*> ready_queue_fifo;
vector<struct process_detail*> waiting;
struct process_detail* CPU = NULL;

void fifo() {

	//clock initialized to 0
	struct clock time;
	memset(&time, 0, sizeof(struct clock));
	int process_count = processes.size();

	//ready queue initialized as process 1 will arrive at time 0
	ready_queue_fifo.push(&processes[0]);
	processes[0].ptr++;

	int brk = 0;

	while(true){
		for(int i = 0; i < process_count; ++i) {
			if(processes[i].burst_times[processes[i].ptr] == -1) {
				brk = 1;
			}
			else brk = 0;
		}
		if(brk) break;

		//managing arrival times
		for(int i = 1; i < process_count; ++i) {
			//if process not in cpu
			if(processes[i].in_cpu != 1) {
				if(time.timer == processes[i].burst_times[0]) {
					ready_queue_fifo.push(&processes[i]);
					processes[i].ptr++;
				}
			}
		}

		//THE FIFO RULE
		if(CPU == NULL) {
			CPU = ready_queue_fifo.front();
			CPU->in_cpu = 1;
			ready_queue_fifo.pop();
		}
		else {
			//check cpu_burst complete
			for(int i = 0; i < process_count; ++i) {
				if(processes[i].in_cpu == 1) {
					if(time.push_signal + CPU->burst_times[processes[i].ptr] == time.timer){
						waiting.push_back(CPU); // process added to waiting queue
						CPU->in_cpu = 0;
						CPU = ready_queue_fifo.front(); // process added to CPU
						CPU->in_cpu = 1;
						ready_queue_fifo.pop();
						time.push_signal = time.push_signal + CPU->burst_times[processes[i].ptr] ;
					}
				}
			}

			// removing form waiting list

			for(int j = 0; j < waiting.size(); ++j) {
				if(waiting[j] != NULL) {
					if(waiting[j]->burst_times[waiting[j]->ptr] == 0) {
						ready_queue_fifo.push(waiting[j]);
						waiting[j]->ptr++;
						waiting[j] = NULL;
					}
					else waiting[j]->burst_times[waiting[j]->ptr]--; // reducing the io burst till it reaches 0
				}

			}
		}
		time.timer++;
	}

	cout << "fifo" << endl;
	return;
}

int main(int argc, char **argv) {

    if(argc != 3)
	{
		cout <<"usage: ./scheduler.out <path-to-workload-file> <scheduler_algorithm>\nprovided arguments:\n";
		for(int i = 0; i < argc; i++)
			cout << argv[i] << "\n";
		return -1;
	}

    char *file_to_search_in = argv[1];
	char *scheduler_algorithm = argv[2];

    ifstream file(file_to_search_in, ios::binary);
    string buffer;
    int pid = 0;

    while(getline(file, buffer)) {
		if(buffer[0] == '<'){
			continue;
		}
		istringstream iss(buffer);
		string word;
		struct process_detail pd;
		memset(&pd,0,sizeof(struct process_detail));
		pd.pid = pid++;
		pd.ptr = 0;

		while(iss>>word){
//			if(i == 0){
//				pd.cpu_burst_times.push_back(stoi(word));
//			}
//			else if(i % 2 == 0){
//				pd.io_burst_times.push_back(stoi(word));
//			}
//			else if(i % 2 == 1){
//			}
			pd.burst_times.push_back(stoi(word));
//			i++;
//			cout << stoi(word) << endl;
		}
		processes.push_back(pd);
    }

	map<string, int> temp;
	temp["fifo"] = 1;
	string temp1 = scheduler_algorithm;


	switch(temp[temp1]){
		case 1:
			fifo();
			break;
		default:
			cout << "enter fifo" << endl;
	}

	cout << processes[0].in_cpu << endl;
	cout << processes[0].ptr << endl;

	cout << processes[1].in_cpu << endl;
	cout << processes[1].ptr << endl;
    return 0;
}






I am writing the above code to as an answer for the following question:
Process Scheduling
Laboratory 3
Duration: 3 weeks
This assignment will help us learn different process scheduling algorithms and their relative pros
and cons.
To do this task, you will need to develop a simulator of a scheduler in C / C++. The simulator
must take in the following command line arguments: <scheduling-algorithm>
<path-to-workload-description-file>. The simulator must produce as output the following metrics:
Makespan, Completion Time (average and maximum), and Waiting Time (average and
maximum), Run Time of your simulator (not counting I/O). Also, report the schedule itself
(choose a nice format which will also help you debug).
For all the studies, we will use the workload description files given here. Each row in the file
refers to one process. The row format is as follows:
<process-arrival-time> <cpu-burst-1-duration> <io-burst-1-duration> <cpu-burst-2-duration>
<io-burst-2-duration> … -1
For example:
0 100 2 200 3 25 -1 indicates arrival time = 0; CPU burst 1 duration = 100; I/O burst 1 duration =
2; CPU burst 2 duration = 200; I/O burst 2 duration = 3; CPU burst 3 duration = 25; end of
process.
Assume that every line ends with -1. A process may have any number of CPU / I/O burst
cycles terminated with a -1. There will be any number of processes, terminated by an end of file.
The arrival times are in nondecreasing order.
Part I
Implement the following algorithms:
A. First In First Out


Also here is the input file:
<html>
<body>
<pre>
0 100 2 -1
2 80 2 -1
</pre></body></html>


Help me write the appropriate code