Advertisement
Guest User

Untitled

a guest
Mar 30th, 2016
104
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 6.51 KB | None | 0 0
  1. #ifndef DBADAPTER_H
  2. #define DBADAPTER_H
  3.  
  4. #include <vector>
  5. #include <set>
  6. #include <mutex>
  7. using namespace std;
  8.  
  9. struct Message {
  10.     int32_t user_id;
  11.     int32_t room_id;
  12.     char *text;
  13.     int64_t time;
  14.     char *theme;
  15.     bool read;
  16. };
  17.  
  18. struct User {
  19.     int32_t id;
  20.     char *login;
  21.     char *password;
  22.     set<int32_t> rooms;
  23. };
  24.  
  25. struct Room {
  26.     int32_t id;
  27.     char *name;
  28.     set<int32_t> users;
  29.     vector<Message*> messages;
  30. };
  31.  
  32. class DBAdapter {
  33.    
  34.     vector<User> users;
  35.     vector<Room> rooms;
  36.     recursive_mutex lock;
  37.     set<int32_t> *empty_set;
  38.    
  39. public:
  40.    
  41.     DBAdapter() {
  42.         empty_set = new set<int32_t>;
  43.     }
  44.    
  45.     ~DBAdapter() {
  46.         delete empty_set;
  47.     }
  48.    
  49.     bool open();
  50.     void close();
  51.    
  52.     bool is_user_exist(int32_t user_id);
  53.     bool is_user_exist(char *login);
  54.     bool is_room_exist(int32_t room_id);
  55.    
  56.     int32_t register_user(char *login, char *password);
  57.     int32_t register_room(char *name);
  58.     int32_t register_message(Message *message);
  59.     //int32_t register_image(Image *image);
  60.    
  61.     void change_user_password(int32_t user_id, char *new_password);
  62.     void change_room_name(int32_t room_id, char *new_name);
  63.    
  64.     char* get_user_login(int32_t user_id);
  65.     int32_t get_user_id(char *login);
  66.    
  67.     char* get_room_name(int32_t room_id);
  68.    
  69.     bool check_user(char *login, char *password);
  70.    
  71.     set<int32_t>* get_user_rooms(int32_t user_id);
  72.     set<int32_t>* get_users_in_room(int32_t room_id);
  73.     bool is_user_in_room(int32_t user_id, int32_t room_id);
  74.     void add_user_to_room(int32_t user_id, int32_t room_id);
  75.    
  76.     int32_t get_messages_in_room(int32_t room_id/*, ??filter??*/);
  77.     Message* get_message(int32_t room_id, int32_t message_id);
  78.    
  79.     //int32_t get_image_room(int32_t image_id);
  80.    
  81.     void mark_message(int32_t room_id, int32_t message_id);
  82. };
  83.  
  84. #endif //DBADAPTER_H
  85.  
  86.  
  87. bool DBAdapter::is_user_exist(int32_t user_id) {
  88.     bool b;
  89.     lock.lock();
  90.     b = users.size() < user_id;
  91.     lock.unlock();
  92.     return b;
  93. }
  94.  
  95. bool DBAdapter::is_user_exist(char *login) {
  96.     bool b;
  97.     lock.lock();
  98.     b = get_user_id(login) != -1;
  99.     lock.unlock();
  100.     return b;
  101. }
  102.  
  103. bool DBAdapter::is_room_exist(int32_t room_id) {
  104.     bool b;
  105.     lock.lock();
  106.     b = rooms.size() < room_id;
  107.     lock.unlock();
  108.     return b;
  109. }
  110.  
  111.  
  112. int32_t DBAdapter::register_user(char *login, char *password) {
  113.     int32_t user_id = -1;
  114.     lock.lock();
  115.     if (!is_user_exist(login)) {
  116.         user_id = (int32_t)users.size();
  117.         User user = {user_id, login, password};
  118.         users.push_back(user);
  119.     }
  120.     lock.unlock();
  121.     return user_id;
  122. }
  123. int32_t DBAdapter::register_room(char *name) {
  124.     lock.lock();
  125.     int32_t room_id = (int32_t)rooms.size();
  126.     Room room = {room_id, name};
  127.     rooms.push_back(room);
  128.     lock.unlock();
  129.     return room_id;
  130. }
  131.  
  132. int32_t DBAdapter::register_message(Message *message) {
  133.     int32_t id = -1;
  134.     lock.lock();
  135.     if (is_user_exist(message->user_id) && is_room_exist(message->room_id)) {
  136.         id = (int32_t)rooms[message->room_id].messages.size();
  137.         rooms[message->room_id].messages.push_back(message);
  138.     }
  139.     lock.unlock();
  140.     return id;
  141. }
  142.  
  143.  
  144. void DBAdapter::change_user_password(int32_t user_id, char *new_password) {
  145.     lock.lock();
  146.     if (is_user_exist(user_id)) {
  147.         delete[] users[user_id].password;
  148.         users[user_id].password = new_password;
  149.     }
  150.     lock.unlock();
  151. }
  152.  
  153. void DBAdapter::change_room_name(int32_t room_id, char *new_name) {
  154.     lock.lock();
  155.     if (is_room_exist(room_id)) {
  156.         delete[] rooms[room_id].name;
  157.         rooms[room_id].name = new_name;
  158.     }
  159.     lock.unlock();
  160. }
  161.  
  162. char* DBAdapter::get_user_login(int32_t user_id) {
  163.     char *login = NULL;
  164.     lock.lock();
  165.     if (is_user_exist(user_id)) {
  166.         login = users[user_id].login;
  167.     }
  168.     lock.unlock();
  169.     return login;
  170. }
  171.  
  172. int32_t DBAdapter::get_user_id(char *login) {
  173.     int32_t id = -1;
  174.     lock.lock();
  175.     for (auto i = users.begin(); i != users.end(); i++) {
  176.         if (strcmp(i->login, login) == 0) {
  177.             id = i->id;
  178.             break;
  179.         }
  180.     }
  181.     lock.unlock();
  182.     return id;
  183. }
  184.  
  185. char* DBAdapter::get_room_name(int32_t room_id) {
  186.     char *name = NULL;
  187.     lock.lock();
  188.     if (is_room_exist(room_id)) {
  189.         name = rooms[room_id].name;
  190.     }
  191.     lock.unlock();
  192.     return name;
  193. }
  194.  
  195. bool DBAdapter::check_user(char *login, char *password) {
  196.     bool b;
  197.     lock.lock();
  198.     b = is_user_exist(login) && strcmp(users[get_user_id(login)].password, password) == 0;
  199.     lock.unlock();
  200.     return b;
  201. }
  202.  
  203. set<int32_t>* DBAdapter::get_user_rooms(int32_t user_id) {
  204.     set<int32_t> *result = empty_set;
  205.     lock.lock();
  206.     if (is_user_exist(user_id)) {
  207.         result = &users[user_id].rooms;
  208.     }
  209.     lock.unlock();
  210.     return result;
  211. }
  212.  
  213. set<int32_t>* DBAdapter::get_users_in_room(int32_t room_id) {
  214.     set<int32_t> *result = empty_set;
  215.     lock.lock();
  216.     if (is_room_exist(room_id)) {
  217.         result = &rooms[room_id].users;
  218.     }
  219.     lock.unlock();
  220.     return result;
  221. }
  222.  
  223. bool DBAdapter::is_user_in_room(int32_t user_id, int32_t room_id) {
  224.     bool b = false;
  225.     lock.lock();
  226.     if (is_user_exist(user_id) && is_room_exist(room_id)) {
  227.         auto u = rooms[room_id].users;
  228.         auto r = users[user_id].rooms;
  229.         b = r.size() < u.size() ? r.find(room_id) != r.end() : u.find(user_id) != u.end();
  230.     }
  231.     lock.unlock();
  232.     return b;
  233. }
  234.  
  235. void DBAdapter::add_user_to_room(int32_t user_id, int32_t room_id) {
  236.     lock.lock();
  237.     if (is_user_exist(user_id) && is_room_exist(room_id)) {
  238.         rooms[room_id].users.insert(user_id);
  239.         users[user_id].rooms.insert(room_id);
  240.     }
  241.     lock.unlock();
  242. }
  243.  
  244. int32_t DBAdapter::get_messages_in_room(int32_t room_id/*, ??filter??*/) {
  245.     int32_t result = 0;
  246.     lock.lock();
  247.     if (is_room_exist(room_id)) {
  248.         result = (int32_t)rooms[room_id].messages.size();
  249.     }
  250.     lock.unlock();
  251.     return result;
  252. }
  253.  
  254. Message* DBAdapter::get_message(int32_t room_id, int32_t message_id) {
  255.     Message *result = NULL;
  256.     lock.lock();
  257.     result = rooms[room_id].messages[message_id];
  258.     lock.unlock();
  259.     return result;
  260. }
  261.  
  262. void DBAdapter::mark_message(int32_t room_id, int32_t message_id) {
  263.     lock.lock();
  264.     if (is_room_exist(room_id) && get_messages_in_room(room_id) > message_id) {
  265.         rooms[room_id].messages[message_id]->read = true;
  266.     }
  267.     lock.unlock();
  268. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement