API tools faq
paste
Advertisement
miki_brill

Untitled

miki_brill
Dec 19th, 2014
180
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.67 KB | None | 0 0
raw download clone embed print report
  1. #include "tinder.h"
  2.  
  3. struct Tinder_t{
  4. Map users;
  5. Map hobbies;
  6. FILE *output;
  7. };
  8.  
  9. #define INITIAL_CHECKS(tinder)\
  10. if(!tinder || !tinder->users || !tinder->hobbies){\
  11. return TINDER_INVALID_PARAMETERS;}
  12.  
  13. #define CHECK_TINDER_IF_NULL_RETURN_INVALID if(tinder==NULL){\
  14. return TINDER_INVALID_PARAMETERS;}
  15.  
  16. static TinderResult checkHobbyResult(HobbyResult result){
  17. TinderResult tResult;
  18. switch (result) {
  19. case HOBBY_ALREADY_EXISTS:
  20. tResult = TINDER_HOBBY_ALREADY_EXISTS;
  21. break;
  22. case HOBBY_OUT_OF_MEMORY:
  23. tResult = TINDER_OUT_OF_MEMORY;
  24. break;
  25. case HOBBY_DOESNT_EXIST:
  26. tResult = TINDER_HOBBY_DOES_NOT_EXIST;
  27. break;
  28. case HOBBY_USER_DOESNT_EXISTS:
  29. tResult = TINDER_USER_DOES_NOT_EXIST;
  30. break;
  31. case HOBBY_USER_ALREADY_EXISTS:
  32. tResult = TINDER_USER_ALREADY_EXISTS;
  33. break;
  34. case HOBBY_NULL_ARGUMENT:
  35. tResult = TINDER_INVALID_PARAMETERS;
  36. break;
  37. case HOBBY_INVALID_PARAMETERS:
  38. tResult = TINDER_INVALID_PARAMETERS;
  39. break;
  40. case HOBBY_NO_HOBBIES:
  41. tResult = TINDER_NO_HOBBIES;
  42. break;
  43. case HOBBY_NO_USERS:
  44. tResult = TINDER_NO_USERS;
  45. break;
  46. case HOBBY_USER_DOESNT_PARTICIPATE_HOBBY:
  47. tResult = TINDER_USER_DOESNT_PARTICIPATE_HOBBY;
  48. break;
  49. case HOBBY_USER_ALREADY_PARTICIPATES_HOBBY:
  50. tResult = TINDER_USER_ALREADY_PARTICIPATES_HOBBY;
  51. break;
  52. default:
  53. tResult = TINDER_SUCCESS;
  54. break;
  55. }
  56. return tResult;
  57. }
  58.  
  59. static TinderResult checkUserResult(UserResult result) {
  60. TinderResult tResult = TINDER_SUCCESS;
  61. switch (result) {
  62. case USER_FAILED:
  63. tResult = TINDER_OUT_OF_MEMORY;
  64. break;
  65. case USER_NULL_ARGUMENT:
  66. tResult = TINDER_INVALID_PARAMETERS;
  67. break;
  68. case USER_NOT_FRIENDS:
  69. tResult = TINDER_USER_NOT_FRIEND;
  70. break;
  71. case USER_DOESNT_EXIST:
  72. tResult = TINDER_USER_DOES_NOT_EXIST;
  73. break;
  74. case USER_ALREADY_EXISTS:
  75. tResult = TINDER_USER_ALREADY_EXISTS;
  76. break;
  77. case USER_NO_USERS:
  78. tResult = TINDER_NO_USERS;
  79. break;
  80. case USER_INVALID_PARAMETERS:
  81. tResult = TINDER_INVALID_PARAMETERS;
  82. break;
  83. case USER_NO_USER_REQUEST:
  84. tResult = TINDER_NO_USER_REQUEST;
  85. break;
  86. case USER_ALREADY_FRIENDS:
  87. tResult = TINDER_USER_ALREADY_FRIEND;
  88. break;
  89. default:
  90. tResult = TINDER_SUCCESS;
  91. break;
  92. }
  93. return tResult;
  94. }
  95.  
  96. ///////////////////////////Module functions/////////////////////////////////////
  97.  
  98. Tinder createTinder(FILE* output){
  99. assert(output != NULL);
  100. Tinder tinder = malloc(sizeof(*tinder));
  101. if(!tinder){
  102. return NULL;
  103. }
  104. tinder->output = output;
  105. tinder->users = mapCreate(copyDataUser,copyID,freeDataUser,freeID,compareVoidID);
  106. if(!tinder->users){
  107. free(tinder);
  108. return NULL;
  109. }
  110. tinder->hobbies = mapCreate(copyHobbyData, copyHobbyKey, freeHobbyData,
  111. freeHobbyKey,compareMapKeys);
  112. if(!tinder->hobbies){
  113. mapDestroy(tinder->users);
  114. free(tinder);
  115. return NULL;
  116. }
  117. return tinder;
  118. }
  119.  
  120. void tinderDestroy(Tinder tinder){
  121. if(tinder!= NULL){
  122. mapDestroy(tinder->users);
  123. mapDestroy(tinder->hobbies);
  124. free(tinder);
  125. }
  126. }
  127.  
  128. TinderResult tinderHobbyAdd(Tinder tinder, char* name){
  129. INITIAL_CHECKS(tinder);
  130. HobbyResult result = hobbyAdd(tinder->hobbies, name);
  131. return checkHobbyResult(result);
  132. }
  133.  
  134. TinderResult tinderHobbyRemove(Tinder tinder, char* name){
  135. INITIAL_CHECKS(tinder);
  136. HobbyResult result = hobbyRemove(tinder->hobbies, name);
  137. return checkHobbyResult(result);
  138. }
  139.  
  140. TinderResult tinderHobbyJoin(Tinder tinder, char* name ,int id){
  141. INITIAL_CHECKS(tinder);
  142. HobbyResult result = hobbyJoin(tinder->hobbies,tinder->users, name, id);
  143. return checkHobbyResult(result);
  144. }
  145.  
  146. TinderResult tinderHobbyLeave(Tinder tinder, char* name ,int id){
  147. INITIAL_CHECKS(tinder);
  148. HobbyResult result = hobbyLeave(tinder->hobbies,tinder->users, name, id);
  149. return checkHobbyResult(result);
  150. }
  151.  
  152. TinderResult tinderHobbyReport(Tinder tinder, int count){
  153. INITIAL_CHECKS(tinder);
  154. HobbyResult result = hobbyReport(tinder->hobbies,count, tinder->output);
  155. return checkHobbyResult(result);
  156. }
  157.  
  158. TinderResult tinderHobbyReportByAge(Tinder tinder){
  159. INITIAL_CHECKS(tinder);
  160. HobbyResult result = hobbyReportByAge(tinder->hobbies, tinder->users,
  161. tinder->output);
  162. return checkHobbyResult(result);
  163. }
  164.  
  165. TinderResult tinderUserAdd(int id, char* name, int year, Gender gender,
  166. Gender pref, Tinder tinder) {
  167. CHECK_TINDER_IF_NULL_RETURN_INVALID
  168. UserResult result = userAdd(id, name, year, gender, pref,
  169. tinder->users);
  170. return checkUserResult(result);
  171.  
  172. }
  173.  
  174. TinderResult tinderUserRemove(Tinder tinder, int id) {
  175. CHECK_TINDER_IF_NULL_RETURN_INVALID
  176. UserResult result = userRemove(tinder->users, tinder->hobbies, id);
  177. return checkUserResult(result);
  178. }
  179.  
  180. TinderResult tinderUserReport(Tinder tinder) {
  181. CHECK_TINDER_IF_NULL_RETURN_INVALID
  182. UserResult result = userReport(tinder->users, tinder->output);
  183. return checkUserResult(result);
  184. }
  185.  
  186. TinderResult tinderUserFriendRequest(Tinder tinder, int idIng, int idEd) {
  187. CHECK_TINDER_IF_NULL_RETURN_INVALID
  188. UserResult result = userFriendRequest(tinder->users, idIng, idEd);
  189. return checkUserResult(result);
  190. }
  191.  
  192. TinderResult tinderUserHandleRequest(Tinder tinder, int idIng, int idEd,
  193. char* choice) {
  194. CHECK_TINDER_IF_NULL_RETURN_INVALID
  195. UserResult result = userHandleRequest(tinder->users, idIng, idEd,
  196. choice);
  197. return checkUserResult(result);
  198. }
  199.  
  200. TinderResult tinderUserUnfriend(Tinder tinder, int idIng, int idEd) {
  201. CHECK_TINDER_IF_NULL_RETURN_INVALID
  202. UserResult result = userUnfriend(tinder->users, idIng, idEd);
  203. return checkUserResult(result);
  204. }
  205.  
  206. TinderResult tinderUserWhoCanIDate(Tinder tinder, int id1, int count) {
  207. CHECK_TINDER_IF_NULL_RETURN_INVALID
  208. UserResult result = userWhoCanIDate(tinder->users, id1, count,
  209. tinder->output);
  210. return checkUserResult(result);
  211. }
  212.  
  213. ///////////////////////////Testing functions////////////////////////////////////
  214.  
  215. int* getTinderUserId(Tinder tinder){
  216. assert(tinder!=NULL);
  217. MapKeyElement key = mapGetFirst(tinder->users);
  218. return (int*)key;
  219. }
  220.  
  221. int getTindetUsersSize(Tinder tinder){
  222. assert(tinder!=NULL);
  223. return mapGetSize(tinder->users);
  224. }
  225.  
  226. char* getTinderUserName(Tinder tinder, int id){
  227. int* key = createMapKey(id);
  228. MapDataElement data = mapGet(tinder->users,key);
  229. freeID(key);
  230. return getUserName(data);
  231. }
  232.  
  233. int getTinderUserBirthYear(Tinder tinder, int id){
  234. int* key = createMapKey(id);
  235. MapDataElement data = mapGet(tinder->users,key);
  236. freeID(key);
  237. return getUserBirthYear(data);
  238. }
  239.  
  240. Gender getTinderUserGender(Tinder tinder, int id){
  241. int* key = createMapKey(id);
  242. MapDataElement data = mapGet(tinder->users,key);
  243. freeID(key);
  244. return getUserGender(data);
  245. }
  246.  
  247. Gender getTinderUserPref(Tinder tinder, int id){
  248. int* key = createMapKey(id);
  249. MapDataElement data = mapGet(tinder->users,key);
  250. freeID(key);
  251. return getUserPref(data);
  252. }
  253.  
  254. Map getTinderUsers(Tinder tinder){
  255. assert(tinder!=NULL);
  256. return tinder->users;
  257. }
  258.  
  259. char* getHobby(Tinder tinder){
  260. return (char*)mapGetFirst(tinder->hobbies);
  261. }
  262.  
  263. bool hobbyExists(Tinder tinder, char* hobby){
  264. return mapContains(tinder->hobbies,hobby);
  265. }
  266.  
  267. bool userParticipatesHobby(Tinder tinder, char* name, MapKeyElement idKey){
  268. return setIsIn(getPplLikeHobby((HobbyData)mapGet(tinder->hobbies, name)),
  269. idKey);
  270. }
  271.  
  272. bool hobbyExistsInUsersHobbies(Tinder tinder, char* name, MapKeyElement idKey){
  273. return setIsIn(getHobbiesOfUser((UserData)mapGet(tinder->users,idKey)),
  274. name);
  275. }
  276.  
  277. int getHobbyPplSetSize(Tinder tinder, char* name){
  278. return getNumPplLikeHobby((HobbyData)mapGet(tinder->hobbies, name));
  279. }
  280.  
  281. bool checkContainIdInUsers(Tinder tinder, int id){
  282. assert(tinder!=NULL);
  283. int* key = createMapKey(id);
  284. if(key==NULL){
  285. return false;
  286. }
  287. bool answer = mapContains(tinder->users,key);
  288. freeID(key);
  289. return answer;
  290. }
  291.  
  292. bool checkInFriendsSet(Tinder tinder, int id1, int id2){
  293. if(tinder==NULL){
  294. return false;
  295. }
  296. int* key1 = createMapKey(id1);
  297. if(key1==NULL){
  298. return false;
  299. }
  300. int* key2 = createMapKey(id2);
  301. if(key2==NULL){
  302. freeID(key1);
  303. return false;
  304. }
  305. bool answer = checkIfInFriendSet(tinder->users,key1,key2);
  306. freeID(key1);
  307. freeID(key2);
  308. return answer;
  309. }
  310.  
  311. bool checkInFriendsRequests(Tinder tinder, int id1, int id2){
  312. if(tinder==NULL){
  313. return false;
  314. }
  315. int* key1 = createMapKey(id1);
  316. if(key1==NULL){
  317. return false;
  318. }
  319. int* key2 = createMapKey(id2);
  320. if(key2==NULL){
  321. freeID(key1);
  322. return false;
  323. }
  324. bool answer = checkIfInFriendRequests(tinder->users,key1,key2);
  325. freeID(key1);
  326. freeID(key2);
  327. return answer;
  328. }
  329.  
  330. int getTinderFriendsSetSize(Tinder tinder, int id){
  331. if(tinder==NULL){
  332. return -1;
  333. }
  334. MapKeyElement key1 = createMapKey(id);
  335. if(key1==NULL){
  336. return -1;
  337. }
  338. int size = getSizeSetFriends(tinder->users,key1);
  339. freeID(key1);
  340. return size;
  341. }
  342.  
  343. int getTinderRequestsSetSize(Tinder tinder, int id){
  344. if(tinder==NULL){
  345. return -1;
  346. }
  347. MapKeyElement key1 = createMapKey(id);
  348. if(key1==NULL){
  349. return -1;
  350. }
  351. int size = getSizeSetFriendRequests(tinder->users,key1);
  352. freeID(key1);
  353. return size;
  354. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!