blob: 8630615fbf9cae7779620f20ce2374923ec599f5 (
plain)
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
package de.ostfalia.algo.ws18.s1;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Optional;
import java.util.function.Predicate;
import de.ostfalia.algo.ws18.base.Gender;
import de.ostfalia.algo.ws18.base.IManagement;
import de.ostfalia.algo.ws18.base.IMember;
import de.ostfalia.algo.ws18.base.KindOfSport;
public class Management implements IManagement {
private int numberOfOperations = 0;
private Optional<LinkedListNode<IMember>> head = Optional.empty();
private int size = 0;
boolean reversed = false;
public Management() {
}
public Management(String[] membersCsv) {
for (String memberCsv : membersCsv) {
this.insert(new Member(memberCsv));
}
}
public Management(String filename) {
this.importFromFile(filename);
}
private void importFromFile(String filename) {
File file = new File(filename);
try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) {
bufferedReader.lines().forEach(line -> insert(new Member(line)));
} catch (IOException exception) {
throw new IllegalArgumentException(exception);
}
}
@Override
public int size() {
return this.size;
}
@Override
public boolean insert(IMember value) {
this.numberOfOperations++;
LinkedListNode<IMember> newHead = new LinkedListNode<IMember>(value);
if (this.head.isPresent()) {
newHead.setNext(this.head.get());
}
this.head = Optional.of(newHead);
this.size++;
return true; // TODO?
}
private Management filter(Predicate<IMember> criteria, boolean breakAfterFirstMatch) {
Management result = new Management();
if (!this.head.isPresent()) {
return result;
}
// searches from head, inserts at head -> result is reversed
result.reverse();
LinkedListNode<IMember> currentNode = this.head.get();
do {
this.numberOfOperations++;
IMember currentValue = currentNode.getValue();
if (criteria.test(currentValue)) {
result.insert(currentValue);
if (breakAfterFirstMatch) {
break;
}
}
} while ((currentNode = currentNode.getNext()) != null);
return result;
}
private Optional<IMember> search(Predicate<IMember> criteria) {
return this.filter(criteria, true).head.map(head -> head.getValue());
}
private long size(Predicate<IMember> criteria) {
return this.filter(criteria, false).size;
}
public void reverse() {
this.reversed = !this.reversed;
}
@Override
public IMember search(long key) {
return this.search(member -> member.getKey() == key).orElse(null);
}
@Override
public IMember search(String name, String firstName) {
return this.search(member -> member.getName().equals(name)
&& member.getFirstName().equals(firstName)).orElse(null);
}
@Override
public int size(KindOfSport kindOfSport) {
return (int) this.size(member -> member.getKindOfSport().equals(kindOfSport));
}
@Override
public IMember[] discipline(KindOfSport kindOfSport) {
return this.filter(member -> member.getKindOfSport().equals(kindOfSport), false)
.toArray();
}
@Override
public IMember[] toArray() {
IMember[] array = new IMember[this.size];
if (!this.head.isPresent()) {
return array;
}
LinkedListNode<IMember> currentNode = this.head.get();
for (int index = 0; index < this.size; index++) {
if (reversed) {
array[this.size - index - 1] = currentNode.getValue();
} else {
array[index] = currentNode.getValue();
}
currentNode = currentNode.getNext();
}
return array;
}
@Override
public int numberOfOperations() {
int numberOfOperations = this.numberOfOperations;
this.numberOfOperations = 0;
return numberOfOperations;
}
}
|
