poved/src/data/Bitmap.java @ a353614c

package data;

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.Month;
import java.time.temporal.ChronoUnit;
import java.time.temporal.WeekFields;
import java.util.Arrays;
import java.util.Locale;
import java.util.Objects;

/**
 *
 * Trida uchovavajici informace a umoznujici praci s bitmapou
 *
 * @author  Daniel Stus, Marek Sobota, Lukas Scurko, Jan Jirman
 * @version 1.0
 *
 */
public class Bitmap implements Comparable<Bitmap>{

    //-------------- Atributy --------------/

    /** Atribut -  Datum zacatku obdobi */
    private LocalDate dateFrom;

    /** Atribut -  Datum konce obdobi */
    private LocalDate dateTo;

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

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

    /** Atribut s verzi linky */
    private String lineVersion;

    /** Atribut s casovym kodem */
    private String timeCode;

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

    /** Pole uchovavajici bitmapu */
    private int[] bitmap;

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



    //-------------- Konstruktor -------------/

    /**
     * Konstruktor incializuje a nastavuje důležité parametry tridy (@code Bitmap)
     *
     * @param dateFrom Datum zacatku obdobi
     * @param dateTo Datum konce obdobi
     * @param lineNumber Cislo linky
     * @param joinNumber Cislo spoje
     * @param timeCode Casovy kod bitmapy
     * @param hardCodes Retezec s pevnymi kody bitmapy
     * @param lineVersion Verze linky
     */
    public Bitmap(LocalDate dateFrom, LocalDate dateTo, String lineNumber, String joinNumber, String timeCode, String hardCodes, String lineVersion) {
        this.dateFrom = dateFrom;
        this.dateTo = dateTo;
        this.lineNumber = lineNumber;
        this.joinNumber = joinNumber;
        this.timeCode = timeCode;
        this.hardCodes = hardCodes;
        this.lineVersion = lineVersion;
        this.bitmap = new int[(int) getDateRange()];
        getEasterHolidays(dateFrom.getYear());
    }


    //----------------- Metody ----------------/

    /**
     * Metoda vraci pocet dni uzivatelem zvoleneho obdobi
     *
     * @return Pocet dni v uzivatelem zvolenem obdobi (rozmezi)
     */
    public long getDateRange() {
        LocalDate from = this.dateFrom;
        LocalDate to = this.dateTo;

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

    /**
     * Metoda vraci pozici dne v bitmape
     *
     * @param date Den pro ktery pozadujeme vratit pozici
     * @return Pozice zadaneho dne v bitmape
     */
    public long getDatePosition(LocalDate date) {
        LocalDate from = this.dateFrom;

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


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

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

           currentDay = currentDay.plusDays(1);
        }
    }


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

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

            currentDay = currentDay.plusDays(1);
        }

    }

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

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

            currentDay = currentDay.plusDays(1);
        }
    }

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

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

            currentDay = currentDay.plusDays(1);
        }
    }

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

        bitmap[dayPosition] = value;
    }


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

        bitmap[dayPosition] = 1;
    }


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

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

            currentDay = currentDay.plusDays(1);
        }

    }


    /**
     * Nastavi vsechny dny ve zvolenem obdobi na hodnotu 0
     *
     * @param from Pocatecni den obdobi
     * @param to Konecny den obdobi
     */
    public void unsetDaysInRange(LocalDate from, LocalDate to) {
        LocalDate currentDay = this.dateFrom;

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

            currentDay = currentDay.plusDays(1);
        }

    }


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

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

            currentDay = currentDay.plusDays(1);
        }
    }

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

        for (int i = 0; i < this.bitmap.length; i++) {
            if (!currentDay.isBefore(from) && !currentDay.isAfter(to) && !isBankHoliday(currentDay))
                if (currentDay.getDayOfWeek() == dayOfWeek) {
                    this.bitmap[i] = value;
                }
            currentDay = currentDay.plusDays(1);
         }
        }


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

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

            currentDay = currentDay.plusDays(1);

        }
    }


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

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

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

            currentDay = currentDay.plusDays(1);
        }

    }


    /**
     * Nastavi vsechny dny svatku v bitmape na hodnotu {@code value}
     *
     * @param value hodnota na kterou se maji dny v bitmape nastavit
     */
    public void setHolidays(int value) {
        value = validateValue(value);
        LocalDate currentDay = this.dateFrom;

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

            currentDay = currentDay.plusDays(1);
        }
    }


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

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

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

                currentDay = currentDay.plusDays(1);
            }
        }

    }

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

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

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

                currentDay = currentDay.plusDays(1);
            }
        }

    }

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

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

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

                currentDay = currentDay.plusDays(1);
            }
        }

    }

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

            switch (hardCode) {
                case 'X': if(day.getDayOfWeek() != DayOfWeek.SATURDAY && day.getDayOfWeek() != DayOfWeek.SUNDAY && !isBankHoliday(day)) return true ; break;
                case '+': if (day.getDayOfWeek() != DayOfWeek.SATURDAY) return true; break;
                case '1': if (day.getDayOfWeek() == DayOfWeek.MONDAY) return true;  break;
                case '2': if (day.getDayOfWeek() == DayOfWeek.TUESDAY) return true; break;
                case '3': if (day.getDayOfWeek() == DayOfWeek.WEDNESDAY) return true; break;
                case '4': if (day.getDayOfWeek() == DayOfWeek.THURSDAY) return true; break;
                case '5': if (day.getDayOfWeek() == DayOfWeek.FRIDAY) return true; break;
                case '6': if (day.getDayOfWeek() == DayOfWeek.SATURDAY) return true; break;
                case '7': if (day.getDayOfWeek() == DayOfWeek.SUNDAY) return true; break;
                default: return false;
            }

        return false;
    }


    /**
     * Metoda naplní (přemaže) bitmapu nulami
     */
    public void fillWithZeros() {
        Arrays.fill(this.bitmap, 0);
    }

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


    /**
     * Metoda overuje spravnost zadane hodnoty
     * - do bitmapy lze zadat pouze 1 nebo 0
     * - v pripade ze uzivatel zada cislo vetsi nez jedna metoda vrati jednotku
     * - v pripade ze uzivatel zada cislo mensi nez nula metoda vrati nulu
     *
     * @param value Uzivatelem zadana hodnota
     * @return Nova (spravna hodnota) ukladajici se do bitmapy
     */
    public static int validateValue(int value) {
        if (value < 0) value = 0;
        else if (value > 0) value = 1;
        else return value;
        return value;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        // Není svátek
        return false;

    }

    /**
     * Metoda vypocita a nastavi bitmape na zaklade roku aktualni dny velikonocnich svatku
     *
     * @param year Rok pro vypocet velikonocnich svatku
     */
    public void getEasterHolidays(int year) {
        int a = year % 19;
        int b = year / 100;
        int c = year % 100;
        int d = b / 4;
        int e = b % 4;
        int f = (b + 8) / 25;
        int g = (b - f + 1) / 3;
        int h = (19 * a + b - d - g + 15) % 30;
        int i = c / 4;
        int k = c % 4;
        int L = (32 + 2 * e + 2 * i - h - k) % 7;
        int m = (a + 11 * h + 22 * L) / 451;
        int n = h + L - 7 * m + 114;
        int month = n / 31;
        int day = (n % 31) + 1;

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

        this.easterMonday = easterMonday;
        this.goodFriday = goodFriday;
    }

    /**
     * Vrati bitmapu ve formatu retezce
     *
     * @return bitmapa ve formatu retezce
     */
    public String getBitmapString() {
        return Arrays.toString(this.bitmap).replaceAll("\\[|\\]|,|\\s", "");
    }

    /**
     * Vrati pocatecni den obdobi bitmapy
     *
     * @return pocatecni den obdobi bitmapy
     */
    public LocalDate getDateFrom() {
        return dateFrom;
    }

    /**
     * Nastavi pocatecni den obdobi na hodnotu {@code dateFrom}
     *
     * @param dateFrom pocatecni den obdobi bitmapy
     */
    public void setDateFrom(LocalDate dateFrom) {
        this.dateFrom = dateFrom;
    }


    /**
     * Vrati koncovy den obdobi bitmapy
     *
     * @return koncovy den obdobi bitmapy
     */
    public LocalDate getDateTo() {
        return dateTo;
    }


    /**
     * Nastavi koncovy den obdobi na hodnotu {@code dateFrom}
     *
     * @param dateTo koncovy den obdobi bitmapy
     */
    public void setDateTo(LocalDate dateTo) {
        this.dateTo = dateTo;
    }

    /**
     * Vrati retezec s cislem linky generovane bitmapy
     *
     * @return retezec s cislem linky generovane bitmapy
     */
    public String getLineNumber() {
        return lineNumber;
    }

    /**
     * Nastavi hodnotu atributu retezece s cislem linky generovane bitmapy na {@code lineNumber}
     *
     * @param lineNumber retezece s cislem linky pro nastaveni bitmapy
     */
    public void setLineNumber(String lineNumber) {
        this.lineNumber = lineNumber;
    }

    /**
     * Vrati pole bitovych map
     *
     * @return pole bitovych map
     */
    public int[] getBitmap() {
        return bitmap;
    }

    /**
     * Nastavi pole bitovych map na hodnotu {@code bitmap}
     *
     * @param bitmap pole bitovych map pro nastaveni bitmapy
     */
    public void setBitmap(int[] bitmap) {
        this.bitmap = bitmap;
    }

    /**
     * Vrati retezec s cislem spoje generovane bitmapy
     *
     * @return retezec s cislem spoje generovane bitmapy
     */
    public String getJoinNumber() {
        return joinNumber;
    }

    /**
     * Nastavi hodnotu atributu retezece s cislem spoje generovane bitmapy na {@code joinNumber}
     *
     * @param joinNumber retezece s cislem spoje pro nastaveni bitmapy
     */
    public void setJoinNumber(String joinNumber) {
        this.joinNumber = joinNumber;
    }

    /**
     * Vrati retezec s cislem verze linky generovane bitmapy
     *
     * @return retezec s cislem verze linky generovane bitmapy
     */
    public String getLineVersion() {
        return lineVersion;
    }

    /**
     * Nastavi hodnotu atributu retezece s verzi linky kodu generovane bitmapy na {@code lineVersion}
     *
     * @param lineVersion retezece s cislem verze linky pro nastaveni bitmapy
     */
    public void setLineVersion(String lineVersion) {
        this.lineVersion = lineVersion;
    }

    /**
     * Vrati retezec s cislem ceasoveho kodu generovane bitmapy
     *
     * @return etezece s cislem casoveho kodu generovane bitmapy
     */
    public String getTimeCode() {
        return timeCode;
    }

    /**
     * Nastavi hodnotu atributu retezece s cislem casoveho kodu generovane bitmapy na {@code timeCode}
     *
     * @param timeCode retezece s cislem casoveho kodu pro nastaveni bitmapy
     */
    public void setTimeCode(String timeCode) {
        this.timeCode = timeCode;
    }

    /**
     * Nastavi hodnotu atributu tridy s pevnymi kody
     *
     * @return retezec s pevnymi kody
     */
    public String getHardCodes() {
        return hardCodes;
    }

    /**
     * Nastavi hodnotu atributu tridy s pevnymi kody na {@code hardCodes}
     *
     * @param hardCodes retezec s pevnymi kody bitmapy
     */
    public void setHardCodes(String hardCodes) {
        this.hardCodes = hardCodes;
    }

    /**
     * Vrati retezec bitmapy ve formatu [XXXXXXXXXXX]
     *
     * @return bitmapa jako retezec ve formatu [XXXXXXXXXXX]
     */
    public String bitmapToString() { return Arrays.toString(this.bitmap); }


    /**
     * Vrati retezec s udajemi atributu tridy ve format pro vypis
     * format: cisloLinkyVerzeLinky-CasovyKod-PevneKody;;Bitovamapa
     *
     * @return retezec s udajemi atributu tridy
     */
    @Override
    public String toString() {
        return lineNumber+lineVersion+"-"+timeCode+"-"+hardCodes+";;"+getBitmapString();
    }


    /**
     *
     * hlavni metoda pro ozkouseni funkcnosti {@code Bitmap}
     *-issue #7374
     *
     * @param args parametry programu
     */
    public static void main(String[] args) {

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



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


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

        //Jede pouze v pracovní dny
        bitmap.setWorkdays(1);
        System.out.println("\nJede v pracovní dny:");
        System.out.println(bitmap.bitmapToString());
        
        bitmap.fillWithZeros();
        
        bitmap.setSundaysAndHolidays(1);
        System.out.println(bitmap.bitmapToString());

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

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

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

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

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

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

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

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





    }


    /**
     * Porovnava bitmapy podle jejich atributu pro serazeni podle hodnot
     * @param o bitmapa k porovnani se stavajici
     * @return 0 - kdyz jsou bitmapy stejne
     *         1 - kdyz je bitmapa "vetsi"
     *        -1 - kdyz je bitmapa "mensi"
     */
    @Override
    public int compareTo(Bitmap o) {

        if (this.lineNumber.equals(o.lineNumber)) {
                if(this.lineVersion.equals(o.lineVersion)) {
                    if (this.timeCode.equals(o.timeCode)) {
                        if (this.hardCodes.equals(o.hardCodes)) {
                            if(Arrays.equals(this.bitmap, o.bitmap)) return 0;
                            else return -1;
                        }
                        else if (this.hardCodes.equals("") && !o.hardCodes.equals(""))
                            return -Integer.parseInt(o.hardCodes);
                        else if (!this.hardCodes.equals("") && o.hardCodes.equals(""))
                            return Integer.parseInt(this.hardCodes);
                        else return Integer.parseInt(this.hardCodes) - Integer.parseInt(o.hardCodes);
                    }
                    else if (this.timeCode.equals("") && !o.timeCode.equals(""))
                        return -Integer.parseInt(o.timeCode);
                    else if (!this.timeCode.equals("") && o.timeCode.equals(""))
                        return Integer.parseInt(this.timeCode);
                    else return Integer.parseInt(this.timeCode) - Integer.parseInt(o.timeCode);
                }
                else return Integer.parseInt(this.lineVersion) - Integer.parseInt(o.lineVersion);
        }
        else return Integer.parseInt(this.lineNumber) - Integer.parseInt(o.lineNumber);
    }

    /**
     * Porovna objekt s bitmapou a rozhodne zda se jedna o stejnou ci ne
     * @param obj objekt k porovnani s bitmapou
     * @return true - kdyz je cela bitmapa stejna
     *         false - v opacnem pripade
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null) return false;
        if(getClass() != obj.getClass()) return false;
        Bitmap o = (Bitmap) obj;
        return Objects.equals(lineNumber, o.lineNumber) && Objects.equals(lineVersion, o.lineVersion) &&
                Objects.equals(timeCode, o.timeCode) && Objects.equals(hardCodes, o.hardCodes) &&
                Objects.equals(bitmap, o.bitmap);
    }


}