db.h

Go to the documentation of this file.

#ifndef CORE_DB_H
#define CORE_DB_H 1

#include <dmn/dmn.h>
#include <dmn/module.h>
#include <dmn/core.h>
#include <dmn/tournament.h>
#include <dmn/match.h>
#include <dmn/game.h>
#include <dmn/hand.h>
#include <dmn/player.h>
#include <dmn/display.h>
#include <dmn/sound.h>

namespace dmn
{
  class Team: public Module
  {
  };

  class Couple: public Module
  {
  };


  class DBTournament
  {
  private:
    Tournament* module_;

    std::list<ID> matches_;
    std::list<ID> teams_;
    std::list<ID> displays_;

  public:
    DBTournament(Tournament* module);

    Tournament* module() const;
    void matches(std::list<ID>* matches) const;
    void teams(std::list<ID>* teams) const;
    void displays(std::list<ID>* displays) const;
    bool insert_match(ID match);
    bool insert_team(ID team);
    bool insert_display(ID display);
    bool delete_match(ID match);
    bool delete_team(ID team);
    bool delete_display(ID display);
  };

  class DBMatch
  {
  private:
    Match* module_;
    ID tournament_;

    std::list<ID> games_;
    std::list<ID> couples_;
    std::list<ID> displays_;

  public:
    DBMatch(Match* module, ID tournament);

    Match* module() const;
    ID tournament() const;
    void games(std::list<ID>* games) const;
    void couples(std::list<ID>* couples) const;
    void displays(std::list<ID>* couples) const;
    bool insert_game(ID game);
    bool insert_couple(ID couple);
    bool insert_display(ID display);
    bool delete_game(ID game);
    bool delete_couple(ID couple);
    bool delete_display(ID display);
  };

  class DBGame
  {
  private:
    Game* module_;
    ID match_;

    std::list<ID> hands_;
    std::list<ID> couples_;
    std::list<ID> displays_;

  public:
    DBGame(Game* module, ID match);

    Game* module() const;
    ID match() const;
    void hands(std::list<ID>* hands) const;
    void couples(std::list<ID>* couples) const;
    void displays(std::list<ID>* displays) const;
    bool insert_hand(ID hand);
    bool insert_couple(ID couple);
    bool insert_display(ID display);
    bool delete_hand(ID hand);
    bool delete_couple(ID couple);
    bool delete_display(ID display);
  };

  class DBHand
  {
  private:
    Hand* module_;
    ID game_;

    std::list<ID> players_;
    std::list<ID> displays_;
    std::list<ID> sounds_;

  public:
    DBHand(Hand* module, ID game);

    Hand* module() const;
    ID game() const;
    void players(std::list<ID>* players) const;
    void displays(std::list<ID>* displays) const;
    void sounds(std::list<ID>* sounds) const;
    bool insert_player(ID player);
    bool insert_display(ID display);
    bool insert_sound(ID sound);
    bool delete_player(ID player);
    bool delete_display(ID display);
    bool delete_sound(ID sound);
  };

  class DBTeam
  {
  private:
    Team* module_;

    ID tournament_;
    std::list<ID> couples_;

  public:
    DBTeam(Team* module);

    Team* module() const;
    ID tournament() const;
    void set_tournament(ID tournament);
    void couples(std::list<ID>* couples) const;
    bool insert_couple(ID couple);
    bool delete_couple(ID couple);
  };

  class DBCouple
  {
  private:
    Couple* module_;
    ID team_;

    ID match_;
    ID game_;
    std::list<ID> players_;

  public:
    DBCouple(Couple* module, ID team);

    Couple* module() const;
    ID team() const;
    ID match() const;
    void set_match(ID match);
    ID game() const;
    void set_game(ID game);
    void players(std::list<ID>* players) const;
    bool insert_player(ID player);
    bool delete_player(ID player);
  };

  class DBPlayer
  {
  private:
    Player* module_;
    ID couple_;

    ID hand_;

  public:
    DBPlayer(Player* module, ID couple);

    Player* module() const;
    ID couple() const;
    ID hand() const;
    void set_hand(ID hand);
  };

  class DBDisplay
  {
  private:
    Display* module_;

    ID tournament_;
    ID match_;
    ID game_;
    ID hand_;

  public:
    DBDisplay(Display* module);

    Display* module() const;
    ID tournament() const;
    void set_tournament(ID tournament);
    ID match() const;
    void set_match(ID match);
    ID game() const;
    void set_game(ID game);
    ID hand() const;
    void set_hand(ID hand);
  };

  class DBSound
  {
  private:
    Sound* module_;

    ID hand_;

  public:
    DBSound(Sound* module);

    Sound* module() const;
    ID hand() const;
    void set_hand(ID hand);
  };

  class DB: public Core
  {
  private:
    std::list<DBTournament> Tournaments_; // Std::List of DBTournament
    std::list<DBMatch> Matches_;  // Std::List of DBMatch
    std::list<DBGame> Games_;   // Std::List of DBGame
    std::list<DBHand> Hands_;   // Std::List of DBHand
    std::list<DBTeam> Teams_;   // Std::List of DBTeam
    std::list<DBCouple> Couples_; // Std::List of DBCouple
    std::list<DBPlayer> Players_; // Std::List of DBPlayer
    std::list<DBDisplay> Displays_; // Std::List of DBDisplay
    std::list<DBSound> Sounds_; // Std::List of DBSound

    DBTournament* search_tournament(ID tournament);
    DBMatch* search_match(ID match);
    DBGame* search_game(ID game);
    DBHand* search_hand(ID hand);
    DBTeam* search_team(ID team);
    DBCouple* search_couple(ID couple);
    DBPlayer* search_player(ID player);
    DBDisplay* search_display(ID display);
    DBSound* search_sound(ID sound);

  protected:
    Tournament* tournament(ID tournament);
    Match* match(ID match);
    Game* game(ID game);
    Hand* hand(ID hand);
    Player* player(ID player);
    Display* display(ID display);
    Sound* sound(ID sound);

    bool new_tournament(Tournament* module);
    bool new_match(Match* module, ID tournament);
    bool new_game(Game* module, ID match);
    bool new_hand(Hand* module, ID game);
    bool new_team(Team* module);
    bool new_couple(Couple* module, ID team);
    bool new_player(Player* module, ID couple);
    bool new_display(Display* module);
    bool new_sound(Sound* module);

    bool delete_tournament(ID tournament);
    bool delete_match(ID match);
    bool delete_game(ID game);
    bool delete_hand(ID hand);
    bool delete_team(ID team);
    bool delete_couple(ID couple);
    bool delete_player(ID player);
    bool delete_display(ID display);
    bool delete_sound(ID sound);

    bool insert_team_in_tournament(ID team, ID tournament);
    bool insert_display_in_tournament(ID display, ID tournament);
    bool insert_couple_in_match(ID couple, ID match);
    bool insert_display_in_match(ID display, ID match);
    bool insert_couple_in_game(ID couple, ID game);
    bool insert_display_in_game(ID display, ID game);
    bool insert_player_in_hand(ID player, ID hand);
    bool insert_display_in_hand(ID display, ID hand);
    bool insert_sound_in_hand(ID sound, ID hand);

    bool delete_team_from_tournament(ID team, ID tournament);
    bool delete_display_from_tournament(ID display, ID tournament);
    bool delete_couple_from_match(ID couple, ID match);
    bool delete_display_from_match(ID display, ID match);
    bool delete_couple_from_game(ID couple, ID game);
    bool delete_display_from_game(ID display, ID game);
    bool delete_player_from_hand(ID player, ID hand);
    bool delete_display_from_hand(ID display, ID hand);
    bool delete_sound_from_hand(ID sound, ID hand);

    bool teams(std::list<ID>* teams);

  public:
    bool tournaments(std::list<ID>* tournaments);
    bool matches_in_tournament(ID tournament, std::list<ID>* matches);
    ID tournament_of_match(ID match);
    bool teams_in_tournament(ID tournament, std::list<ID>* teams);
    ID tournament_of_team(ID team);
    bool displays_in_tournament(ID tournament, std::list<ID>* displays);
    ID tournament_of_display(ID display);
    bool games_in_match(ID match, std::list<ID>* games);
    ID match_of_game(ID game);
    bool couples_in_match(ID match, std::list<ID>* couples);
    ID match_of_couple(ID couple);
    bool displays_in_match(ID match, std::list<ID>* displays);
    ID match_of_display(ID display);
    bool hands_in_game(ID game, std::list<ID>* hands);
    ID game_of_hand(ID hand);
    bool couples_in_game(ID game, std::list<ID>* couples);
    ID game_of_couple(ID couple);
    bool displays_in_game(ID game, std::list<ID>* displays);
    ID game_of_display(ID display);
    bool players_in_hand(ID hand, std::list<ID>* players);
    ID hand_of_player(ID player);
    bool displays_in_hand(ID hand, std::list<ID>* displays);
    ID hand_of_display(ID display);
    bool sounds_in_hand(ID hand, std::list<ID>* sound);
    ID hand_of_sound(ID sound);
    bool couples_in_team(ID team, std::list<ID>* couples);
    ID team_of_couple(ID couple);
    bool players_in_couple(ID couple, std::list<ID>* players);
    ID couple_of_player(ID player);
  };
};

#endif        // CORE_DB_H

---