karateka.h

#ifndef TOURNAMENT_RUNNER_KARATEKA_H_
#define TOURNAMENT_RUNNER_KARATEKA_H_

#include <string>
#include <cstdint>
#include <vector>
#include <array>

#include <boost/serialization/access.hpp>
#include <boost/serialization/array.hpp>
#include <boost/serialization/nvp.hpp>

#include "tournament_runner/date.h"
#include "tournament_runner/kata_performer_interface.h"
#include "tournament_runner/kataround_scores.h"

using boost::array;
using boost::serialization::make_nvp;

namespace TournamentRunner
{

constexpr auto max_number_of_kata_rounds = 3;

class Karateka :
    public IKataPerformer
{
public:

 //   Karateka() = default;

    Karateka& with_name (const std::string& karateka_name);
    Karateka& with_name (std::string&& karateka_name) noexcept;
    Karateka& with_surname (const std::string& karateka_surname);
    Karateka& with_surname (std::string&& karateka_surname) noexcept;
    Karateka& with_birthdate (const Date& birthdate);
    Karateka& with_birthdate (Date&& birthdate) noexcept;
    Karateka& with_birthdate (const std::string& birthdate_as_string);
    Karateka& from_dojo (const std::string& dojo_name);
    Karateka& from_dojo (std::string&& dojo_name) noexcept;
    Karateka& with_grade (const std::string& grade_as_string);
    Karateka& with_grade (std::string&& grade_as_string) noexcept;


    void set_startnumber (size_t start_number);

    size_t get_startnumber() const;

    void add_kata_score (float score) final;

    void add_deduction (float deduction) final;

    uint8_t next_round () final;

    float get_maximum_score_of_round (uint8_t round) const final;

    float get_minimum_score_of_round (uint8_t round) const final;

    float get_overall_score_of_round (uint8_t round) const final;

    float get_maximum_score_of_current_round () const final;

    float get_minimum_score_of_current_round () const final;

    float get_overall_score_of_current_round () const final;


    KataRoundScores::ScoreVectorType get_scores (uint8_t round) const;

    float get_deduction (uint8_t round) const;

    std::string name () const;
    std::string surname () const;

    std::string date_of_birth_as_string () const;

    Date date_of_birth () const;

    std::string dojo () const;
    std::string grade () const;

private:

    friend class boost::serialization::access;

    template<class Archive>
    void serialize (Archive& archive, const unsigned int version);

    std::string name_{};
    std::string surname_{};
    Date date_of_birth_{};
    std::string dojo_{};
    std::string grade_{};
    array<KataRoundScores, max_number_of_kata_rounds> kata_scores_;
    size_t start_number_{};
    uint8_t current_kata_round_{};
};

bool kata_score_sort_greater(const IKataPerformer& lhs,
                             const IKataPerformer& rhs);

bool kata_score_is_equal(const IKataPerformer& lhs,
                         const IKataPerformer& rhs);

inline void Karateka::set_startnumber (size_t start_number)
{
    start_number_ = start_number;
}

inline size_t Karateka::get_startnumber () const
{
    return start_number_;
}

inline std::string Karateka::name () const
{
    return name_;
}

inline std::string Karateka::surname () const
{
    return surname_;
}

inline std::string Karateka::date_of_birth_as_string () const
{
    return date_of_birth_.to_iso_extended_string();
}

inline Date Karateka::date_of_birth() const
{
    return date_of_birth_;
}

inline std::string Karateka::dojo () const
{
    return dojo_;
}

inline std::string Karateka::grade () const
{
    return grade_;
}

template<class Archive>
void Karateka::serialize (Archive& archive,
                          const unsigned int)
{
    archive & make_nvp("Name", name_);
    archive & make_nvp("Surname", surname_);
    archive & make_nvp("DateOfBirth", date_of_birth_);
    archive & make_nvp("Dojo", dojo_);
    archive & make_nvp("Grade", grade_);
    archive & make_nvp("Scores", kata_scores_);
    archive & make_nvp("Startnumber", start_number_);
    archive & make_nvp("CurrentKataRound", current_kata_round_);
}

} //namespace TournamentRunner

#endif // TOURNAMENT_RUNNER_KARATEKA_H_