Method: createMitErlaubten(String)

1: package auftraege.auftragsBildungsParameter;
2:
3: import auftraege.auftragsBildungsParameter.abstraction.AusschliessenderParameter;
4: import auftraege.auftragsBildungsParameter.abstraction.AusschliessenderParameterVisitor;
5: import auftraege.auftragsBildungsParameter.abstraction.DokumentenklassenVariable;
6: import auftraege.auftragsBildungsParameter.abstraction.DokumentenklassenVariablenVisitor;
7: import auftraege.auftragsBildungsParameter.dokumentenKlassenVariablen.Beilagenart;
8: import auftraege.auftragsBildungsParameter.states.BeilagenArtenErlaubt;
9: import auftraege.auftragsBildungsParameter.states.BeilagenArtenState;
10: import auftraege.auftragsBildungsParameter.states.BeilagenArtenVerboten;
11: import util.exceptions.BeilagenAnzahlOutOfBoundsException;
12:
13: import java.util.Arrays;
14: import java.util.Collections;
15: import java.util.HashSet;
16: import java.util.List;
17: import java.util.Map;
18: import java.util.Set;
19: import java.util.stream.Collectors;
20:
21: /**
22: * repräsentiert effektiv eine Liste von {@linkplain Beilagenart}en, kann jedoch auch invers gesehen werden. Siehe die Operationen {@link
23: * BeilagenArten#createMitErlaubten(String)} sowie {@link BeilagenArten#createMitVerbotenen(Set)}
24: */
25: public final class BeilagenArten implements AusschliessenderParameter, DokumentenklassenVariable {
26:         /**
27:          * quasi ein billiges SingletonLeeresBeilagenArten, doch obacht! Diesem leeren BeilagenartenObject dürfen keine Beilagen hinzugefügt werden, denn dann wäre es ja
28:          * nicht mehr leer, was entgegen der Intuition einiger Testfälle gehen würde.
29:          */
30:         public static final BeilagenArten EMPTY = BeilagenArten.createMitErlaubten(Collections.unmodifiableSet(new HashSet<>()));
31:         private final BeilagenArtenState state;
32:
33:         private BeilagenArten(final BeilagenArtenState state) {
34:                 this.state = state;
35:         }
36:
37:         /**
38:          * @param beilagenarten
39:          *                 verbotene Beilagenarten
40:          *
41:          * @return verbietet sämtliche {@link Beilagenart}en, die angegeben werden.
42:          * @see BeilagenArten#contains(Beilagenart)
43:          */
44:         public static BeilagenArten createMitVerbotenen(final Set<Beilagenart> beilagenarten) {
45:                 return new BeilagenArten(new BeilagenArtenVerboten(beilagenarten));
46:         }
47:
48:         /**
49:          * @param beilagenarten
50:          *                 verbotene Beilagenarten
51:          *
52:          * @return erlaubt sämtliche {@link Beilagenart}en, die angegeben werden.
53:          * @see BeilagenArten#contains(Beilagenart)
54:          */
55:         public static BeilagenArten createMitErlaubten(final Set<Beilagenart> beilagenarten) {
56:                 return new BeilagenArten(new BeilagenArtenErlaubt(beilagenarten));
57:         }
58:
59:         /**
60:          * @return leeres BeilagenArtenObject.
61:          */
62:         public static BeilagenArten createEmpty() {
63:                 return BeilagenArten.createMitErlaubten(new HashSet<>());
64:         }
65:
66:         /**
67:          * @param s
68:          *                 verbotene Beilagenarten, welche aus dem String geparsed werden.
69:          *
70:          * @return verbietet sämtliche {@link Beilagenart}en, die angegeben werden.
71:          * @see BeilagenArten#createMitErlaubten(String)
72:          */
73:         public static BeilagenArten createMitErlaubten(final String s) {
74:                 return BeilagenArten.createMitErlaubten(
75:                                 Arrays.stream(s.split(","))
76:                                                 .map(String::trim)
77:                                                 .map(Beilagenart::new)
78:                                                 .collect(Collectors.toSet()));
79:         }
80:
81:         @Override
82:         public <T> T accept(final AusschliessenderParameterVisitor<T> v) {
83:                 return v.handle(this);
84:
85:         }
86:
87:         /**
88:          * @param beilagenart
89:          *                 zu prüfende {@link Beilagenart}
90:          *
91:          * @return true, falls die Beilagenart entweder nicht verboten oder explizit erlaubt wurde. Sonst false.
92:          */
93:         public Boolean contains(final Beilagenart beilagenart) {
94:                 return this.state.contains(beilagenart);
95:         }
96:
97:         @Override
98:         public <T> T accept(final DokumentenklassenVariablenVisitor<T> v) {
99:                 return v.handle(this);
100:         }
101:
102:         @Override
103:         public boolean equals(final Object o) {
104:                 if (this == o) {
105:                         return true;
106:                 }
107:                 if (!(o instanceof BeilagenArten)) {
108:                         return false;
109:                 }
110:
111:                 final BeilagenArten that = (BeilagenArten) o;
112:
113:                 return this.state.beilagenarten.equals(that.state.beilagenarten) && this.state.getClass().equals(that.state.getClass());
114:         }
115:
116:         @Override
117:         public int hashCode() {
118:                 return this.state.beilagenarten.hashCode();
119:         }
120:
121:         /**
122:          * @return alle Beilagenarten, falls man sich um {@link BeilagenArten} im {@link BeilagenArtenState} {@link BeilagenArtenErlaubt} befindet. Falls man sich im State
123:          *                 {@link BeilagenArtenVerboten} befindet, wird eine {@link util.exceptions.VariableDoesNotExistException} geworfen.
124:          */
125:         public Set<Beilagenart> getBeilagenarten() {
126:                 return this.state.getBeilagenarten();
127:         }
128:
129:         /**
130:          * @param beilagenarten
131:          *                 zu prüfende {@link Beilagenart}en
132:          *
133:          * @return prüft auf {@link BeilagenArten#contains(Beilagenart)} für sämtliche übergebenen {@link Beilagenart}en
134:          */
135:         public boolean containsAll(final Set<Beilagenart> beilagenarten) {
136:                 for (final Beilagenart current : beilagenarten) {
137:                         if (!this.contains(current)) {
138:                                 return false;
139:                         }
140:                 }
141:                 return true;
142:         }
143:
144:         /**
145:          * Diese Operation funktioniert nur, wenn das {@link BeilagenArten}-Objekt im {@link BeilagenArtenErlaubt}-State ist.
146:          * <p>
147:          * In diesem Fall werden die Beilagenarten, die via Parameter übergeben werden, der Menge an Beilagen hinzugefügt.
148:          * <p>
149:          * Anderenfalls löst die Operation {@link BeilagenArten#getBeilagenarten()} eine Exception aus.
150:          *
151:          * @param beilagenarten
152:          *                 Beilagenarten, welche der Menge an Beilagen hinzugefügt werden sollen.
153:          *
154:          * @return sich selbst.
155:          * @throws UnsupportedOperationException
156:          *                 Wenn der statischen {@link BeilagenArten#EMPTY} versucht wurde ein Element hinzuzufügen.
157:          */
158:         public BeilagenArten addBeilagenarten(final Set<Beilagenart> beilagenarten) throws UnsupportedOperationException {
159:                 try {
160:                         this.getBeilagenarten().addAll(beilagenarten);
161:                 } catch (final UnsupportedOperationException e) {
162:                         throw new UnsupportedOperationException("Der statischen BeilagenArten.EMPTY darf kein Element hinzugefügt werden!", e);
163:                 }
164:                 return this;
165:         }
166:
167:         /**
168:          * Berechnet die Anzahl der UmbauArbeiten einer Beilagenkonfiguration zu einer anderen unter der Berücksichtigung einer Begrenzung.
169:          *
170:          * @param that
171:          *                 zu vergleichende BeilagenArten
172:          * @param begrenzung
173:          *                 einzuhaltende Begrenzung beim Umbau.
174:          *
175:          * @return Anzahl der Umrüstvorgänge (aus this zu entfernende Beilagen + Anzahl der aus that hinzuzufügenden Beilagen)
176:          */
177:         public int calculateUmruestvorgaengeZuNeuerBeilagenArt(final BeilagenArten that, final int begrenzung) {
178:                 final Set<Beilagenart> thatsBeilagenarten = that.getBeilagenarten();
179:                 final Map<Boolean, List<Beilagenart>> bereitsVorhandeneElementeInAuftrag = thatsBeilagenarten.stream().collect(Collectors.partitioningBy(this
180:                                 .getBeilagenarten()::contains));
181:
182:                 final int idk = (bereitsVorhandeneElementeInAuftrag.get(false).size() + this.getBeilagenarten().size()) - begrenzung;
183:                 final int elementsNoetigZuEntfernen = idk < 0 ? 0 : idk;
184:
185:                 if ((this.getBeilagenarten().size() + bereitsVorhandeneElementeInAuftrag.get(false).size()) - elementsNoetigZuEntfernen > begrenzung) {
186:                         throw new BeilagenAnzahlOutOfBoundsException("Der Beilagenumbau ist nicht unterhalb der Begrenzung zu realisieren.");
187:                 }
188:                 return elementsNoetigZuEntfernen + bereitsVorhandeneElementeInAuftrag.get(false).size();
189:         }
190:
191:         /**
192:          * Diese Operation funktioniert nur, wenn das {@link BeilagenArten}-Objekt im {@link BeilagenArtenErlaubt}-State ist.
193:          * <p>
194:          * Anderenfalls löst die Operation {@link BeilagenArten#getBeilagenarten()} eine Exception aus.
195:          *
196:          * @return Anzahl der verschiedenen Beilagenarten.
197:          */
198:         public int getAnzahl() {
199:                 return this.getBeilagenarten().size();
200:         }
201: }