API tools faq
paste
Advertisement
miki_brill

Untitled

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