L-System-Designer/VariableSequence.cpp at master · jaxfrank/L-System-Designer · 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
115
116
117
118
119
120
121
122
123
124
125
126
127
#include "VariableSequence.h"

#include "Variable.h"
#include "VariableSequenceModel.h"

VariableSequence::VariableSequence(QString name, QObject* parent):
	QObject(parent),
	_name(name),
	_variables(),
	_model(nullptr)
{}

Variable* VariableSequence::at(int i) {
	if(i < 0 || i >= _variables.size()) return nullptr;

	return _variables.at(i);
}

bool VariableSequence::operator==(const VariableSequence& rhs) {
	if(this->length() != rhs.length()) return false;
	for(int i = 0; i < rhs.length(); i++) {
		if(_variables[i] != rhs._variables[i]) return false;
	}
	return true;
}

bool VariableSequence::operator!=(const VariableSequence& rhs) {
	return !(*this == rhs);
}

Variable*& VariableSequence::operator[](size_t pos) {
	return _variables[(int)pos];
}

const Variable* const VariableSequence::operator[](size_t pos) const {
	return _variables[(int)pos];
}

bool VariableSequence::contains(Variable* variable) const {
	return _variables.contains(variable);
}

void VariableSequence::pushFront(Variable* variable) {
	_variables.push_front(variable);
}

void VariableSequence::pushFront(const VariableSequence* sequence) {
	if(!sequence) return;

	for(int i = (int)sequence->length() - 1; i >= 0; i--) {
		_variables.push_front(sequence->_variables.at(i));
	}
}

void VariableSequence::popFront() {
	if(length() == 0) return;

	_variables.pop_front();
}

void VariableSequence::pushBack(Variable* variable) {
	_variables.push_back(variable);
}

void VariableSequence::pushBack(const VariableSequence* sequence) {
	if(!sequence) return;

	_variables << sequence->_variables;
}

void VariableSequence::popBack() {
	if(length() == 0) return;

	_variables.pop_back();
}

void VariableSequence::insert(int pos, Variable* variable) {
	if(pos < 0 || pos > _variables.size()) return;

	_variables.insert(_variables.begin() + pos, variable);
}

void VariableSequence::set(int pos, Variable* variable) {
	if(pos < 0 || pos >= _variables.size()) return;

	_variables[pos] = variable;
}

void VariableSequence::remove(int pos) {
	if(pos < 0 || pos > _variables.size()) return;
	_variables.removeAt(pos);
}

void VariableSequence::clear() {
	_variables.clear();
}

const Variable* const VariableSequence::front() const {
	return _variables.front();
}

const Variable* VariableSequence::front() {
	return _variables.front();
}

const Variable* const VariableSequence::back() const {
	return _variables.back();
}

const Variable*VariableSequence::back() {
	return _variables.back();
}

void VariableSequence::setName(QString name) {
	_name = name;
}

QString VariableSequence::getName() {
	return _name;
}

VariableSequenceModel*VariableSequence::getModel() {
	if(!_model) {
		_model = new VariableSequenceModel(this);
	}
	return _model;
}