Projekt

Obecné

Profil

Stáhnout (26.7 KB) Statistiky
| Větev: | Revize:
1
package data;
2

    
3
import java.time.DayOfWeek;
4
import java.time.LocalDate;
5
import java.time.Month;
6
import java.time.temporal.ChronoUnit;
7
import java.time.temporal.WeekFields;
8
import java.util.Arrays;
9
import java.util.Locale;
10

    
11
/**
12
 *
13
 * Trida uchovavajici informace a umoznujici praci s bitmapou
14
 *
15
 * @author  Daniel Stus, Marek Sobota, Lukas Scurko, Jan Jirman
16
 * @version 1.0
17
 *
18
 */
19
public class Bitmap {
20

    
21
    //-------------- Atributy --------------/
22

    
23
    /** Atribut -  Datum zacatku obdobi */
24
    private LocalDate dateFrom;
25

    
26
    /** Atribut -  Datum konce obdobi */
27
    private LocalDate dateTo;
28

    
29
    /** Atribut s cislem linky pro kterou je generovana bitmapa */
30
    private String lineNumber;
31

    
32
    /** Atribut s cislem spoje pro kterou je generovana bitmapa */
33
    private String joinNumber;
34

    
35
    /** Atribut s verzi linky */
36
    private String lineVersion;
37

    
38
    /** Atribut s casovym kodem */
39
    private String timeCode;
40

    
41
    /** List uchovavajici seznam pevnych kodu pro spoj */
42
    private String hardCodes;
43

    
44
    /** Pole uchovavajici bitmapu */
45
    private int[] bitmap;
46

    
47
    /** Aktualni dny velikonocnich svatku */
48
    private LocalDate goodFriday, easterMonday;
49

    
50

    
51

    
52
    //-------------- Konstruktor -------------/
53

    
54
    /**
55
     * Konstruktor incializuje a nastavuje důležité parametry tridy (@code Bitmap)
56
     *
57
     * @param dateFrom Datum zacatku obdobi
58
     * @param dateTo Datum konce obdobi
59
     * @param lineNumber Cislo linky
60
     * @param joinNumber Cislo spoje
61
     * @param timeCode Casovy kod bitmapy
62
     * @param hardCodes Retezec s pevnymi kody bitmapy
63
     * @param lineVersion Verze linky
64
     */
65
    public Bitmap(LocalDate dateFrom, LocalDate dateTo, String lineNumber, String joinNumber, String timeCode, String hardCodes, String lineVersion) {
66
        this.dateFrom = dateFrom;
67
        this.dateTo = dateTo;
68
        this.lineNumber = lineNumber;
69
        this.joinNumber = joinNumber;
70
        this.timeCode = timeCode;
71
        this.hardCodes = hardCodes;
72
        this.lineVersion = lineVersion;
73
        this.bitmap = new int[(int) getDateRange()];
74
        getEasterHolidays(dateFrom.getYear());
75
    }
76

    
77

    
78
    //----------------- Metody ----------------/
79

    
80
    /**
81
     * Metoda vraci pocet dni uzivatelem zvoleneho obdobi
82
     *
83
     * @return Pocet dni v uzivatelem zvolenem obdobi (rozmezi)
84
     */
85
    public long getDateRange() {
86
        LocalDate from = this.dateFrom;
87
        LocalDate to = this.dateTo;
88

    
89
        long noOfDaysBetween = ChronoUnit.DAYS.between(from, to);
90
        return noOfDaysBetween+1;
91
    }
92

    
93
    /**
94
     * Metoda vraci pozici dne v bitmape
95
     *
96
     * @param date Den pro ktery pozadujeme vratit pozici
97
     * @return Pozice zadaneho dne v bitmape
98
     */
99
    public long getDatePosition(LocalDate date) {
100
        LocalDate from = this.dateFrom;
101

    
102
        //Re #7443
103
        return ChronoUnit.DAYS.between(from, date);
104
    }
105

    
106

    
107
    /**
108
     * Metoda nastavy pracovni dny bitmapy na hodnotu parametru {@code value}
109
     *
110
     * @param value hodnota na kterou se maji dny v bitmape nastavit
111
     */
112
    public void setWorkdays(int value) {
113
        value = validateValue(value);
114
        LocalDate currentDay = this.dateFrom;
115

    
116
        for (int i = 0; i < this.bitmap.length; i++) {
117
            if (currentDay.getDayOfWeek() != DayOfWeek.SATURDAY && currentDay.getDayOfWeek() != DayOfWeek.SUNDAY && !isBankHoliday(currentDay)) {
118
                this.bitmap[i] = value;
119
            }
120

    
121
           currentDay = currentDay.plusDays(1);
122
        }
123
    }
124

    
125

    
126
    /**
127
     * Metoda nastavy pracovni dny bitmapy v zvolenem obdobi na hodnotu parametru {@code value}
128
     *
129
     * @param from Pocatecni den obdobi
130
     * @param to Konecny den obdobi
131
     * @param value hodnota na kterou se maji dny v bitmape nastavit
132
     */
133
    public void setWorkdaysInRange(LocalDate from, LocalDate to, int value) {
134
        value = validateValue(value);
135
        LocalDate currentDay = this.dateFrom;
136

    
137
        for (int i = 0; i < this.bitmap.length; i++) {
138
            if (!currentDay.isBefore(from) && !currentDay.isAfter(to) && !isBankHoliday(currentDay)) {
139
                if (currentDay.getDayOfWeek() != DayOfWeek.SATURDAY && currentDay.getDayOfWeek() != DayOfWeek.SUNDAY) {
140
                    this.bitmap[i] = value;
141
                }
142
            }
143

    
144
            currentDay = currentDay.plusDays(1);
145
        }
146

    
147
    }
148

    
149
    /**
150
     * Metoda nastavy vsechny dny (krome soboty) bitmapy na hodnotu parametru {@code value}
151
     *
152
     * @param value hodnota na kterou se maji dny v bitmape nastavit
153
     */
154
    public void setSundaysAndHolidays(int value) {
155
        value = validateValue(value);
156
        LocalDate currentDay = this.dateFrom;
157

    
158
        for (int i = 0; i < this.bitmap.length; i++) {
159
            if (currentDay.getDayOfWeek() != DayOfWeek.SATURDAY) {
160
                this.bitmap[i] = value;
161
            }
162

    
163
            currentDay = currentDay.plusDays(1);
164
        }
165
    }
166

    
167
    /**
168
     * Metoda nastavi vsechny dny (krome soboty) bitmapy ve zvolenem obdobi na hodnotu parametru {@code value}
169
     *
170
     * @param from Pocatecni den obdobi
171
     * @param to Konecny den obdobi
172
     * @param value hodnota na kterou se maji dny v bitmape nastavit
173
     */
174
    public void setSundaysAndHolidays(LocalDate from, LocalDate to, int value) {
175
        value = validateValue(value);
176
        LocalDate currentDay = this.dateFrom;
177

    
178
        for (int i = 0; i < this.bitmap.length; i++) {
179
            if (!currentDay.isBefore(from) && !currentDay.isAfter(to) && !isBankHoliday(currentDay)) {
180
                if (currentDay.getDayOfWeek() != DayOfWeek.SATURDAY) {
181
                    this.bitmap[i] = value;
182
                }
183
            }
184

    
185
            currentDay = currentDay.plusDays(1);
186
        }
187
    }
188

    
189
    /**
190
     * Nastavi den v bitmape na prislusnou hodnotu predanou parametrem {@code value}
191
     *
192
     * @param day Den, pro ktery se ma hodnota v bitmape nastavit
193
     * @param value Hodnota na kterou se ma bitmapa nastavit
194
     */
195
    public void setDay(LocalDate day, int value) {
196
        value = validateValue(value);
197
        int dayPosition = (int) getDatePosition(day);
198

    
199
        bitmap[dayPosition] = value;
200
    }
201

    
202

    
203
    /**
204
     * Nastavi pouze jeden den v bitmapě na hodnotu 1 - jede
205
     * vsechny ostatni dny nastavi na 0
206
     *
207
     * @param day Den, pro který se má hodnota v bitmapě nastavit
208
     */
209
    public void setOneDayOnly(LocalDate day) {
210
        fillWithZeros();
211
        int dayPosition = (int) getDatePosition(day);
212

    
213
        bitmap[dayPosition] = 1;
214
    }
215

    
216

    
217
    /**
218
     * Nastavi dny (vsechny krome svatku) ve zvolenem obdobi na hodnotu {@code value}
219
     *
220
     * @param from Pocatecni den obdobi
221
     * @param to Konecny den obdobi
222
     * @param value hodnota na kterou se maji dny v bitmape nastavit
223
     */
224
    public void setDaysInRange(LocalDate from, LocalDate to, int value) {
225
        value = validateValue(value);
226
        LocalDate currentDay = this.dateFrom;
227

    
228
        for (int i = 0; i < this.bitmap.length; i++) {
229
            if (!currentDay.isBefore(from) && !currentDay.isAfter(to) && !isBankHoliday(currentDay)) {
230
                this.bitmap[i] = value;
231
            }
232

    
233
            currentDay = currentDay.plusDays(1);
234
        }
235

    
236
    }
237

    
238

    
239
    /**
240
     * Nastavi vsechny dny ve zvolenem obdobi na hodnotu 0
241
     *
242
     * @param from Pocatecni den obdobi
243
     * @param to Konecny den obdobi
244
     */
245
    public void unsetDaysInRange(LocalDate from, LocalDate to) {
246
        LocalDate currentDay = this.dateFrom;
247

    
248
        for (int i = 0; i < this.bitmap.length; i++) {
249
            if (!currentDay.isBefore(from) && !currentDay.isAfter(to)) {
250
                this.bitmap[i] = 0;
251
            }
252

    
253
            currentDay = currentDay.plusDays(1);
254
        }
255

    
256
    }
257

    
258

    
259
    /**
260
     * Nastavi vsechny zvolene dny v tydny parametrem {@code dayOfWeek} na hodnotu {@code value}
261
     *
262
     * @param dayOfWeek Den v tydnu (po - ne) pro ktery se maji hodnoty nastavit
263
     * @param value hodnota na kterou se maji dny v bitmape nastavit
264
     */
265
    public void setDaysInWeek(DayOfWeek dayOfWeek, int value) {
266
        value = validateValue(value);
267
        LocalDate currentDay = this.dateFrom;
268

    
269
        for (int i = 0; i < this.bitmap.length; i++) {
270
            if (currentDay.getDayOfWeek() == dayOfWeek) {
271
                this.bitmap[i] = value;
272
            }
273

    
274
            currentDay = currentDay.plusDays(1);
275
        }
276
    }
277

    
278
    /**
279
     * Nastavi vsechny zvolene dny v tydny parametrem {@code dayOfWeek} ve zvolenem obdobi na hodnotu {@code value}
280
     *
281
     * @param from Pocatecni den obdobi
282
     * @param to Konecny den obdobi
283
     * @param dayOfWeek Den v tydnu (po - ne) pro ktery se maji hodnoty nastavit
284
     * @param value hodnota na kterou se maji dny v bitmape nastavit
285
     */
286
    public void setDaysInWeek(LocalDate from, LocalDate to, DayOfWeek dayOfWeek, int value) {
287
        value = validateValue(value);
288
        LocalDate currentDay = this.dateFrom;
289

    
290
        for (int i = 0; i < this.bitmap.length; i++) {
291
            if (!currentDay.isBefore(from) && !currentDay.isAfter(to) && !isBankHoliday(currentDay))
292
                if (currentDay.getDayOfWeek() == dayOfWeek) {
293
                    this.bitmap[i] = value;
294
                }
295
            currentDay = currentDay.plusDays(1);
296
         }
297
        }
298

    
299

    
300
    /**
301
     * Nastavi vsechny sude/liche tydny v bitmape na hodnotu {@code value}
302
     *
303
     * @param value hodnota na kterou se maji dny v bitmape nastavit
304
     * @param remainder urcuje sude/liche tydny (zbytek po deleni 2); 1 -> liche tydny; 0 -> sude tydny
305
     */
306
    public void setWeeks(int value, int remainder) {
307
        value = validateValue(value);
308
        LocalDate currentDay = this.dateFrom;
309
        WeekFields weekFields = WeekFields.of(Locale.getDefault());
310

    
311
        for (int i = 0; i < this.bitmap.length; i++) {
312
            if ((currentDay.get(weekFields.weekOfWeekBasedYear())%2)==remainder) {
313
                this.bitmap[i] = value;
314
            }
315

    
316
            currentDay = currentDay.plusDays(1);
317

    
318
        }
319
    }
320

    
321

    
322
    /**
323
     * Nastavi vsechny sude/liche tydny v bitmape ve zvolenem obdobi na hodnotu {@code value}
324
     *
325
     * @param from Pocatecni den obdobi
326
     * @param to Konecny den obdobi
327
     * @param value hodnota na kterou se maji dny v bitmape nastavit
328
     * @param remainder urcuje sude/liche tydny (zbytek po deleni 2); 1 -> liche tydny; 0 -> sude tydny
329
     */
330
    public void setWeeksInRange(LocalDate from, LocalDate to, int value, int remainder) {
331

    
332
        value = validateValue(value);
333
        LocalDate currentDay = this.dateFrom;
334
        WeekFields weekFields = WeekFields.of(Locale.getDefault());
335

    
336
        for (int i = 0; i < this.bitmap.length; i++) {
337
            if (!currentDay.isBefore(from) && !currentDay.isAfter(to)) {
338
                if ((currentDay.get(weekFields.weekOfWeekBasedYear())%2)==remainder) {
339
                    this.bitmap[i] = value;
340
                }
341
            }
342

    
343
            currentDay = currentDay.plusDays(1);
344
        }
345

    
346
    }
347

    
348

    
349
    /**
350
     * Nastavi vsechny dny svatku v bitmape na hodnotu {@code value}
351
     *
352
     * @param value hodnota na kterou se maji dny v bitmape nastavit
353
     */
354
    public void setHolidays(int value) {
355
        value = validateValue(value);
356
        LocalDate currentDay = this.dateFrom;
357

    
358
        for (int i = 0; i < this.bitmap.length; i++) {
359
            if (isBankHoliday(currentDay)) {
360
                this.bitmap[i] = value;
361
            }
362

    
363
            currentDay = currentDay.plusDays(1);
364
        }
365
    }
366

    
367

    
368
    /**
369
     * Nastavy vsechny dny odpovidajici pevnym kodum ve zvolenem obdobi na hodnotu {@code value}
370
     *
371
     * @param from Pocatecni den obdobi
372
     * @param to Konecny den obdobi
373
     * @param value hodnota na kterou se maji dny v bitmape nastavit
374
     */
375
    public void setHardCodeDays(LocalDate from, LocalDate to, int value) {
376

    
377
        value = validateValue(value);
378
        char[] hardCodesChar = hardCodes.toCharArray();
379

    
380
        for (int i = 0; i < hardCodesChar.length; i++) {
381
            LocalDate currentDay = this.dateFrom;
382
            for (int j = 0; j < this.bitmap.length; j++) {
383
                if (isHardCodeDay(currentDay, hardCodesChar[i]) && !currentDay.isBefore(from) && !currentDay.isAfter(to)) {
384
                    this.bitmap[j] = value;
385
                }
386

    
387
                currentDay = currentDay.plusDays(1);
388
            }
389
        }
390

    
391
    }
392

    
393
    /**
394
     * Nastavy vsechny dny odpovidajici pevnym kodum v sudych/lichych tydnech na hodnotu {@code value}
395
     *
396
     * @param value hodnota na kterou se maji dny v bitmape nastavit
397
     * @param remainder urcuje sude/liche tydny (zbytek po deleni 2); 1 -> liche tydny; 0 -> sude tydny
398
     */
399
    public void setHardCodeWeeks(int value, int remainder) {
400

    
401
        value = validateValue(value);
402
        WeekFields weekFields = WeekFields.of(Locale.getDefault());
403
        char[] hardCodesChar = hardCodes.toCharArray();
404

    
405
        for (int i = 0; i < hardCodesChar.length; i++) {
406
            LocalDate currentDay = this.dateFrom;
407
            for (int j = 0; j < this.bitmap.length; j++) {
408
                    if ((currentDay.get(weekFields.weekOfWeekBasedYear()) % 2) == remainder && isHardCodeDay(currentDay, hardCodesChar[i])) {
409
                        this.bitmap[j] = value;
410
                }
411

    
412
                currentDay = currentDay.plusDays(1);
413
            }
414
        }
415

    
416
    }
417

    
418
    /**
419
     * Nastavy vsechny dny odpovidajici pevnym kodum v sudych/lichych tydnech ve zvolenem obdobi na hodnotu {@code value}
420
     *
421
     * @param from Pocatecni den obdobi
422
     * @param to Konecny den obdobi
423
     * @param value hodnota na kterou se maji dny v bitmape nastavit
424
     * @param remainder urcuje sude/liche tydny (zbytek po deleni 2); 1 -> liche tydny; 0 -> sude tydny
425
     */
426
    public void setHardCodeWeeksInRange(LocalDate from, LocalDate to, int value, int remainder) {
427

    
428
        value = validateValue(value);
429
        WeekFields weekFields = WeekFields.of(Locale.getDefault());
430
        char[] hardCodesChar = hardCodes.toCharArray();
431

    
432
        for (int i = 0; i < hardCodesChar.length; i++) {
433
            LocalDate currentDay = this.dateFrom;
434
            for (int j = 0; j < this.bitmap.length; j++) {
435
                if (!currentDay.isBefore(from) && !currentDay.isAfter(to)) {
436
                    if ((currentDay.get(weekFields.weekOfWeekBasedYear()) % 2) == remainder && isHardCodeDay(currentDay, hardCodesChar[i])) {
437
                        this.bitmap[j] = value;
438
                    }
439
                }
440

    
441
                currentDay = currentDay.plusDays(1);
442
            }
443
        }
444

    
445
    }
446

    
447
    /**
448
     * Metoda overi jestli predany den je soucasti jednoho z pevnych kodu
449
     *
450
     * @param day den pro overeni pevnych kodu
451
     * @param hardCode pevny kod pro overeni
452
     * @return Vrati {@code true} pokud den spada do nektereho z pevnych kodu, v opacnem pripade vraci {@code false}
453
     */
454
    public boolean isHardCodeDay(LocalDate day, char hardCode) {
455

    
456
            switch (hardCode) {
457
                case 'X': if(day.getDayOfWeek() != DayOfWeek.SATURDAY && day.getDayOfWeek() != DayOfWeek.SUNDAY && !isBankHoliday(day)) return true ; break;
458
                case '+': if (day.getDayOfWeek() != DayOfWeek.SATURDAY) return true; break;
459
                case '1': if (day.getDayOfWeek() == DayOfWeek.MONDAY) return true; break;
460
                case '2': if (day.getDayOfWeek() == DayOfWeek.TUESDAY) return true; break;
461
                case '3': if (day.getDayOfWeek() == DayOfWeek.WEDNESDAY) return true; break;
462
                case '4': if (day.getDayOfWeek() == DayOfWeek.THURSDAY) return true; break;
463
                case '5': if (day.getDayOfWeek() == DayOfWeek.FRIDAY) return true; break;
464
                case '6': if (day.getDayOfWeek() == DayOfWeek.SATURDAY) return true; break;
465
                case '7': if (day.getDayOfWeek() == DayOfWeek.SUNDAY) return true; break;
466
                default: return false;
467
            }
468

    
469
        return false;
470
    }
471

    
472

    
473
    /**
474
     * Metoda naplní (přemaže) bitmapu nulami
475
     */
476
    public void fillWithZeros() {
477
        Arrays.fill(this.bitmap, 0);
478
    }
479

    
480
    /**
481
     * Metoda naplní bitmapu (všechny dny) jedničkami
482
     */
483
    public void fillWithOnes() {
484
        Arrays.fill(this.bitmap, 1);
485
    }
486

    
487

    
488
    /**
489
     * Metoda overuje spravnost zadane hodnoty
490
     * - do bitmapy lze zadat pouze 1 nebo 0
491
     * - v pripade ze uzivatel zada cislo vetsi nez jedna metoda vrati jednotku
492
     * - v pripade ze uzivatel zada cislo mensi nez nula metoda vrati nulu
493
     *
494
     * @param value Uzivatelem zadana hodnota
495
     * @return Nova (spravna hodnota) ukladajici se do bitmapy
496
     */
497
    public static int validateValue(int value) {
498
        if (value < 0) value = 0;
499
        else if (value > 0) value = 1;
500
        else return value;
501
        return value;
502
    }
503

    
504
    /**
505
     * Metoda overi zda je zadany den statnim svatkem
506
     *
507
     * @param date den pro overeni statniho svatku
508
     * @return {@code true} pokud je v zadany den statni svatek, {@code false} pokud neni v zadany den statni svatek
509
     */
510
    public boolean isBankHoliday(LocalDate date) {
511

    
512
        Month month = date.getMonth();
513
        int dayOfMonth = date.getDayOfMonth();
514

    
515
        if (date.getDayOfYear() == 1) getEasterHolidays(date.getYear());
516

    
517
        // 1. ledna - Den obnovy samostatného českého státu | Nový rok
518
        if(month == Month.JANUARY && dayOfMonth == 1) {
519
            return true;
520
        }
521

    
522
        // Velikonoční pondělí
523
        if(month == easterMonday.getMonth() && dayOfMonth == easterMonday.getDayOfMonth()){
524
            return true;
525
        }
526

    
527
        // Velký pátek
528
        if(month == goodFriday.getMonth() && dayOfMonth == goodFriday.getDayOfMonth()){
529
            return true;
530
        }
531

    
532
        // 1. května - Svátek práce
533
        if(month == Month.MAY && dayOfMonth == 1) {
534
            return true;
535
        }
536

    
537
        // 8. května - Den vítězství
538
        if(month == Month.MAY && dayOfMonth == 8) {
539
            return true;
540
        }
541

    
542
        // 5. července - Den slovanských věrozvěstů Cyrila a Metoděje
543
        if(month == Month.JULY && dayOfMonth == 5) {
544
            return true;
545
        }
546

    
547
        // 6. července - Den upálení mistra Jana Husa
548
        if(month == Month.JULY && dayOfMonth == 6) {
549
            return true;
550
        }
551

    
552
        // 28. září – Den české státnosti
553
        if(month == Month.SEPTEMBER && dayOfMonth == 28) {
554
            return true;
555
        }
556

    
557
        // 28. října – Den vzniku samostatného československého státu
558
        if(month == Month.OCTOBER && dayOfMonth == 28) {
559
            return true;
560
        }
561

    
562
        // 17. listopadu – Den boje za svobodu a demokracii
563
        if(month == Month.NOVEMBER && dayOfMonth == 17) {
564
            return true;
565
        }
566

    
567
        // 24. prosince – Štědrý den
568
        if(month == Month.DECEMBER && dayOfMonth == 24) {
569
            return true;
570
        }
571

    
572
        // 25. prosince – 1. svátek vánoční
573
        if(month == Month.DECEMBER && dayOfMonth == 25) {
574
            return true;
575
        }
576

    
577
        // 26. prosince – 2. svátek vánoční
578
        if(month == Month.DECEMBER && dayOfMonth == 26) {
579
            return true;
580
        }
581

    
582
        // Není svátek
583
        return false;
584

    
585
    }
586

    
587
    /**
588
     * Metoda vypocita a nastavi bitmape na zaklade roku aktualni dny velikonocnich svatku
589
     *
590
     * @param year Rok pro vypocet velikonocnich svatku
591
     */
592
    public void getEasterHolidays(int year) {
593
        int Y = year;
594
        int a = Y % 19;
595
        int b = Y / 100;
596
        int c = Y % 100;
597
        int d = b / 4;
598
        int e = b % 4;
599
        int f = (b + 8) / 25;
600
        int g = (b - f + 1) / 3;
601
        int h = (19 * a + b - d - g + 15) % 30;
602
        int i = c / 4;
603
        int k = c % 4;
604
        int L = (32 + 2 * e + 2 * i - h - k) % 7;
605
        int m = (a + 11 * h + 22 * L) / 451;
606
        int n = h + L - 7 * m + 114;
607
        int month = n / 31;
608
        int day = (n % 31) + 1;
609

    
610
        //Velikonoční pondělí --> Velikonoční neděle + 1
611
        LocalDate easterMonday = LocalDate.of(year, month, day);
612
        easterMonday = easterMonday.plusDays(1);
613
        //Velký pátek --> Velikonoční neděle - 2
614
        LocalDate goodFriday = LocalDate.of(year, month, day);
615
        goodFriday = goodFriday.minusDays(2);
616

    
617
        this.easterMonday = easterMonday;
618
        this.goodFriday = goodFriday;
619
    }
620

    
621
    /**
622
     * Vrati bitmapu ve formatu retezce
623
     *
624
     * @return bitmapa ve formatu retezce
625
     */
626
    public String getBitmapString() {
627
        return Arrays.toString(this.bitmap).replaceAll("\\[|\\]|,|\\s", "");
628
    }
629

    
630
    /**
631
     * Vrati pocatecni den obdobi bitmapy
632
     *
633
     * @return pocatecni den obdobi bitmapy
634
     */
635
    public LocalDate getDateFrom() {
636
        return dateFrom;
637
    }
638

    
639
    /**
640
     * Nastavi pocatecni den obdobi na hodnotu {@code dateFrom}
641
     *
642
     * @param dateFrom pocatecni den obdobi bitmapy
643
     */
644
    public void setDateFrom(LocalDate dateFrom) {
645
        this.dateFrom = dateFrom;
646
    }
647

    
648

    
649
    /**
650
     * Vrati koncovy den obdobi bitmapy
651
     *
652
     * @return koncovy den obdobi bitmapy
653
     */
654
    public LocalDate getDateTo() {
655
        return dateTo;
656
    }
657

    
658

    
659
    /**
660
     * Nastavi koncovy den obdobi na hodnotu {@code dateFrom}
661
     *
662
     * @param dateTo koncovy den obdobi bitmapy
663
     */
664
    public void setDateTo(LocalDate dateTo) {
665
        this.dateTo = dateTo;
666
    }
667

    
668
    /**
669
     * Vrati retezec s cislem linky generovane bitmapy
670
     *
671
     * @return retezec s cislem linky generovane bitmapy
672
     */
673
    public String getLineNumber() {
674
        return lineNumber;
675
    }
676

    
677
    /**
678
     * Nastavi hodnotu atributu retezece s cislem linky generovane bitmapy na {@code lineNumber}
679
     *
680
     * @param lineNumber retezece s cislem linky pro nastaveni bitmapy
681
     */
682
    public void setLineNumber(String lineNumber) {
683
        this.lineNumber = lineNumber;
684
    }
685

    
686
    /**
687
     * Vrati pole bitovych map
688
     *
689
     * @return pole bitovych map
690
     */
691
    public int[] getBitmap() {
692
        return bitmap;
693
    }
694

    
695
    /**
696
     * Nastavi pole bitovych map na hodnotu {@code bitmap}
697
     *
698
     * @param bitmap pole bitovych map pro nastaveni bitmapy
699
     */
700
    public void setBitmap(int[] bitmap) {
701
        this.bitmap = bitmap;
702
    }
703

    
704
    /**
705
     * Vrati retezec s cislem spoje generovane bitmapy
706
     *
707
     * @return retezec s cislem spoje generovane bitmapy
708
     */
709
    public String getJoinNumber() {
710
        return joinNumber;
711
    }
712

    
713
    /**
714
     * Nastavi hodnotu atributu retezece s cislem spoje generovane bitmapy na {@code joinNumber}
715
     *
716
     * @param joinNumber retezece s cislem spoje pro nastaveni bitmapy
717
     */
718
    public void setJoinNumber(String joinNumber) {
719
        this.joinNumber = joinNumber;
720
    }
721

    
722
    /**
723
     * Vrati retezec s cislem verze linky generovane bitmapy
724
     *
725
     * @return retezec s cislem verze linky generovane bitmapy
726
     */
727
    public String getLineVersion() {
728
        return lineVersion;
729
    }
730

    
731
    /**
732
     * Nastavi hodnotu atributu retezece s verzi linky kodu generovane bitmapy na {@code lineVersion}
733
     *
734
     * @param lineVersion retezece s cislem verze linky pro nastaveni bitmapy
735
     */
736
    public void setLineVersion(String lineVersion) {
737
        this.lineVersion = lineVersion;
738
    }
739

    
740
    /**
741
     * Vrati retezec s cislem ceasoveho kodu generovane bitmapy
742
     *
743
     * @return etezece s cislem casoveho kodu generovane bitmapy
744
     */
745
    public String getTimeCode() {
746
        return timeCode;
747
    }
748

    
749
    /**
750
     * Nastavi hodnotu atributu retezece s cislem casoveho kodu generovane bitmapy na {@code timeCode}
751
     *
752
     * @param timeCode retezece s cislem casoveho kodu pro nastaveni bitmapy
753
     */
754
    public void setTimeCode(String timeCode) {
755
        this.timeCode = timeCode;
756
    }
757

    
758
    /**
759
     * Nastavi hodnotu atributu tridy s pevnymi kody
760
     *
761
     * @return retezec s pevnymi kody
762
     */
763
    public String getHardCodes() {
764
        return hardCodes;
765
    }
766

    
767
    /**
768
     * Nastavi hodnotu atributu tridy s pevnymi kody na {@code hardCodes}
769
     *
770
     * @param hardCodes retezec s pevnymi kody bitmapy
771
     */
772
    public void setHardCodes(String hardCodes) {
773
        this.hardCodes = hardCodes;
774
    }
775

    
776
    /**
777
     * Vrati retezec bitmapy ve formatu [XXXXXXXXXXX]
778
     *
779
     * @return bitmapa jako retezec ve formatu [XXXXXXXXXXX]
780
     */
781
    public String bitmapToString() { return Arrays.toString(this.bitmap); }
782

    
783

    
784
    /**
785
     * Vrati retezec s udajemi atributu tridy ve format pro vypis
786
     * format: cisloLinkyVerzeLinky-CasovyKod-PevneKody;;Bitovamapa
787
     *
788
     * @return retezec s udajemi atributu tridy
789
     */
790
    @Override
791
    public String toString() {
792
        return lineNumber+lineVersion+"-"+timeCode+"-"+hardCodes+";;"+getBitmapString();
793
    }
794

    
795

    
796
    /**
797
     *
798
     * hlavni metoda pro ozkouseni funkcnosti {@code Bitmap}
799
     *-issue #7374
800
     *
801
     * @param args parametry programu
802
     */
803
    public static void main(String[] args) {
804

    
805
        LocalDate dateFrom = LocalDate.of(2019, 5, 1);
806
        LocalDate dateTo = LocalDate.of(2019, 5, 31);
807

    
808

    
809

    
810
        Bitmap bitmap = new Bitmap(dateFrom, dateTo, "143440","1","34", "5", "1");
811

    
812

    
813
        // ------------- KONTROLNÍ VÝPISY -----------------
814
        System.out.println("------------- KONTROLNÍ VÝPISY -----------------");
815
        System.out.println("Linka: "+ bitmap.getLineNumber());
816
        System.out.println("Datum: od: " + bitmap.getDateFrom() + " | do: " + bitmap.getDateTo());
817
        System.out.println("První den je: "+bitmap.getDateFrom().getDayOfWeek());
818
        System.out.println("Počet dní v rozmezí: " + bitmap.getDateRange());
819
        System.out.println(bitmap.bitmapToString());
820

    
821
        //Jede pouze v pracovní dny
822
        bitmap.setWorkdays(1);
823
        System.out.println("\nJede v pracovní dny:");
824
        System.out.println(bitmap.bitmapToString());
825
        
826
        bitmap.fillWithZeros();
827
        
828
        bitmap.setSundaysAndHolidays(1);
829
        System.out.println(bitmap.bitmapToString());
830

    
831
        // Kontrola přemazání
832
        System.out.println("\nKontrola přemazání:");
833
        bitmap.fillWithZeros();
834
        System.out.println(bitmap.bitmapToString());
835

    
836
        //Nastavit pouze Pondělky - atribut 2
837
        System.out.println("\nJede každé pondělí:");
838
        bitmap.setDaysInWeek(DayOfWeek.MONDAY, 1);
839
        System.out.println(bitmap.bitmapToString());
840

    
841
        //přemazání
842
        bitmap.fillWithZeros();
843

    
844
        System.out.println("\nJede liché týdny od 1. 5. - 13. 5. :");
845
        LocalDate dateTo2 = LocalDate.of(2019, 5, 13);
846
        bitmap.setWeeksInRange(dateFrom, dateTo2, 1, 1);
847
        System.out.println(bitmap.bitmapToString());
848

    
849
        //Nastavit liché týdny (zbytek(remainder) 1 - liché)
850
        System.out.println("\nLiché týdny:");
851
        bitmap.setWeeks(1, 1);
852
        System.out.println(bitmap.bitmapToString());
853

    
854
        //přemazání
855
        bitmap.fillWithZeros();
856

    
857
        //Nastavit podle časového kódu
858
        System.out.println("\nNastavení podle pevných kódů:");
859
        bitmap.setHardCodeDays(dateFrom, dateTo2, 1);
860
        System.out.println(bitmap.bitmapToString());
861

    
862
        //Velikonoce pro svátky
863
        System.out.println("\nVelikonoční pondělí: " + bitmap.easterMonday);
864
        System.out.println("Velký pátek: " + bitmap.goodFriday);
865

    
866

    
867

    
868

    
869

    
870
    }
871

    
872

    
873
}
(1-1/8)