Assembly_Line_ex/LineManager.cpp at main · vdalbani/Assembly_Line_ex · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
//Author Name:				Victor A.

#include <iostream>
#include <fstream>
#include <vector>
#include "Task.h"
#include "LineManager.h"
#include "Utilities.h"

namespace std
{
	LineManager::LineManager(const std::string& str, std::vector<Task*>& v_tasks, std::vector<CustomerOrder>& customerOrd) :
		m_cntCustomerOrder(0)
	{
		Utilities utl;
		size_t nextPos = 0;
		auto more = true;
		auto taskOne = true;

		std::string token;
		std::string next;
		std::ifstream file(str);

		while (!file.eof())
		{
			std::getline(file, token);

			auto tempTask = utl.extractToken(token, nextPos, more);

			if (more)
				next = utl.extractToken(token, nextPos, more);


			for (size_t i = 0; i < v_tasks.size(); ++i)
			{
				if (v_tasks[i]->getName() == tempTask)
				{
					if (taskOne)
					{
						first_task = i;
						taskOne = !taskOne;
					}

					if (next.empty())
					{
						last_task = i;
					}
					else
					{
						for (size_t j = 0; j < v_tasks.size(); ++j)
							if (v_tasks[j]->getName() == next)
							{
								v_tasks[i]->setNextTask(*v_tasks[j]);
								break;
							}
					}

					break;
				}
			}

			nextPos = 0;
			more = true;
			tempTask.clear();
			next.clear();
		}

		for (auto& co : customerOrd)
			ToBeFilled.push_front(std::move(co));

		customerOrd.erase(customerOrd.begin(), customerOrd.end());
		AssemblyLine = v_tasks;
	}

	bool LineManager::run(std::ostream& out)
	{
		auto isRun = true;

		if (!ToBeFilled.empty())
		{
			*AssemblyLine[first_task] += std::move(ToBeFilled.back());
			ToBeFilled.pop_back();

		}

		for (auto& i : AssemblyLine)
			i->runProcess(out);

		CustomerOrder buffer;

		if (AssemblyLine[last_task]->getCompleted(buffer))
			Completed.push_back(std::move(buffer));

		for (auto& i : AssemblyLine)
			if (i->moveTask())
				isRun = false;

		return isRun;
	}

	void LineManager::displayCompleted(std::ostream& out) const
	{
		if (!Completed.empty())
			for (const auto& i : Completed)
				i.display(out);
	}

	void LineManager::validateTasks() const
	{
		if (!AssemblyLine.empty())
			for (auto i : AssemblyLine)
				i->validate(std::cout);
	}
}