void fprint(text_t * text)
{
FILE * file = fopen("output.txt", "w");
if(NULL == file)
return 1;
int i, j, count = 1;
for (count = 0; count < 15; count++)
{
for(i = 0; i < list_getSize(text->sentences); i++)
{
sentence_t * sentence = list_get(text->sentences, i);
for(j = 0; j < list_getSize(sentence->words); j++)
{
word_t * word = list_get(sentence->words, j);
if (strlen(word->letters) == count && isupper(abs(word->letters[0])))
{
printf("%s", word->letters);
fprintf(file, "%s", word->letters);
fprintf(file, "\n");
printf("\n");
}
}
}
}
fclose(file);
}
cons_t * fprint(text_t * text)
{
int vowels = 0;
int consonants = 0;
cons_t * cons = cons_t_new();
int i, j, k;
for(i = 0; i < list_getSize(text->sentences); i++)
{
sentence_t * sentence = list_get(text->sentences, i);
for(j = 0; j < list_getSize(sentence->words); j++)
{
word_t * word = list_get(sentence->words, j);
for (k = 0; k < strlen (word->letters); k++)
{
if (word->letters[k]>= 'A' && word->letters[k]<= 'Z')
word->letters[k] = word->letters[k] + 'a' - 'A';
if (word->letters[k] >= 'a' && word->letters[k] <= 'z')
if (word->letters[k] == 'a' || word->letters[k] == 'e' || word->letters[k] == 'i' || word->letters[k] == 'o' || word->letters[k] == 'u')
vowels++;
else consonants++;
}
}
}
cons->vowels = vowels;
cons->consonants = consonants;
printf ("Vowels %i\n", vowels);
printf ("Consonants %i\n", consonants);
puts (cons);
return cons;
}
int __getNumberTotalClients(clinic_t * self) {
int number = 0;
for (int i = 0; i < list_getSize(self->flats); i++) {
flat_t * flat = list_get(self->flats, i);
number += list_getSize(flat->patiens);
}
return number;
}
void flat_addPatient (clinic_t * clinic, flat_t * self, patient_t * pat)
{
patient_t * pat = malloc (sizeof (patient_t));
if (list_getSize (self->patients < MAX_PATIENTS))
{
pat->seat = list_getSize (self->patients);
list_push_back(self->patients, patient);
list_push_back (clinic->flats, self);
}
else self->type = 0;
}
list_t * get_last_messages(chat_t * chat, int count){
if(count > list_getSize(chat->messages))
return NULL;
else{
list_t * tmp = list_new();
for(int i = list_getSize(chat->messages) - 1; i >= list_getSize(chat->messages) - count; i--){
list_push_back(tmp, (void*) list_get(chat->messages, i));
}
return tmp;
}
}
int main(void){
chat_t * chat = chat_new("First Chat");
printf("1st task(Chat name is) : %s\n", get_chat_name(chat));//1st task
user_t * firstUser = user_new("Dima", "Diachenko", 18);
chat_add_user(chat, firstUser);
user_t * secondUser = user_new("Gleb", "Davidov", 18);
chat_add_user(chat, secondUser); //6th task
list_t * users_list = list_new();
users_list = chat_get_list_of_users(chat);
printf("4th task (and 6th task)(Users in list) : %i\n", list_getSize(users_list));//4th task
printf("2d task : List of users:\n"); // 2d task
for(int i = 0; i < list_getSize(users_list); i++){
user_t * tmp = (user_t*) list_get(users_list, i);
printf("%s %s %i\n", user_get_name(tmp), user_get_surname(tmp), user_get_age(tmp));
}
printf("7th task : %s - this user was removed!\n", user_get_surname(chat_remove_user_by_surname(chat, "Davidov")));//7th task
users_list = chat_get_list_of_users(chat);
printf("2d task : List of users:\n"); // 2d task
for(int i = 0; i < list_getSize(users_list); i++){
user_t * tmp = (user_t*) list_get(users_list, i);
printf("%s %s %i\n", user_get_name(tmp), user_get_surname(tmp), user_get_age(tmp));
}
message_t * msg1 = message_new("Hello!", firstUser);
chat_add_message(chat, msg1);//8th task
printf("8th task: added message to chat:\n%s:\t%s\n", user_get_surname(get_owner(msg1)), get_message_text(msg1));
list_t * msgs_list = list_new();
msgs_list = get_list_of_messages_of_one_user(chat, firstUser);//5th task
printf("5th task : Messages of user %s\n", user_get_surname(firstUser));
for(int i = 0; i < list_getSize(msgs_list); i++){
message_t * tmpmsg = list_get(msgs_list, i);
printf("%s\n", get_message_text(tmpmsg));
}
msgs_list = get_last_messages(chat, 1);
printf("3d task : List of last messages(1):\n");
for(int i = 0; i < list_getSize(msgs_list); i++){
message_t * tmpmsg = list_get(msgs_list, i);
printf("%s\n", get_message_text(tmpmsg));
}
return 0;
}
void sentence_free(sentence_t * sentence)
{
for (int i = 0; i < list_getSize(sentence->words); i++)
word_free(list_get(sentence->words, i));
list_free(sentence->words);
free(sentence);
}
list_t * list_new_copy(list_t * original) {
list_t * self = list_new();
for (int i = 0; i < list_getSize(original); i++) {
list_push_back(self, list_get(original, i));
}
return self;
}
void server_dB(socket_t * client, db_t * db, list_t * lt)
{
int cntPens = db_countPensioner(db);
for(int i = 0; i < cntPens; i++)
{
list_push_back(lt, db_getPensionerById(db, i));
}
cJSON * arr = cJSON_CreateArray();
for(int i = 1; i < list_getSize(lt); i++)
{
cJSON * pens = cJSON_CreateObject();
pensioner_t * ps = list_get(lt, i);
cJSON_AddItemToObject(pens, "name", cJSON_CreateString(pensioner_getName(ps)));
cJSON_AddItemToObject(pens, "surname", cJSON_CreateString(pensioner_getSurname(ps)));
cJSON_AddItemToObject(pens, "year", cJSON_CreateNumber(pensioner_getAge(ps)));
cJSON_AddItemToObject(pens, "experience", cJSON_CreateNumber(pensioner_getExperience(ps)));
cJSON_AddItemToObject(pens, "pension", cJSON_CreateNumber(pensioner_getPension(ps)));
cJSON_AddItemToObject(pens, "surname", cJSON_CreateString(pensioner_getYear(ps)));
cJSON_AddItemToArray(arr, pens);
}
char * Jtext = cJSON_Print(arr);
server_sent(client, Jtext);
free(Jtext);
}
char* data_manager_getAsString (data_manager_t self, char buffer[], int id)
{
xmlDoc* doc = NULL;
xmlNode* root_element = NULL;
doc = xmlNewDoc ("1.0");
root_element = xmlNewNode (NULL, "directors");
xmlDocSetRootElement (doc, root_element);
int qDirs = list_getSize(self->directors);
for (int i = 0; i < qDirs; i++)
{
if (id == i || id == -1)
director_toXmlNode (list_get (self->directors, i, NULL), doc, root_element);
}
xmlChar* pMem = NULL;
int size = 0;
xmlDocDumpMemory(doc, &pMem, &size);
strcpy(buffer, pMem);
free(pMem);
xmlFreeDoc (doc);
return buffer;
}
void text_free(text_t * text)
{
for (int i = 0; i < list_getSize(text->sentences); i++)
sentence_free(list_get(text->sentences, i));
list_free(text->sentences);
free(text);
}
cJSON * pupil_listToJson(list_t * pupils){
cJSON * arr = cJSON_CreateArray();
for(int i=0; i< list_getSize(pupils); i++){
cJSON *jPupil = pupil_pupilToJson(list_get(pupils,i));
cJSON_AddItemToArray(arr,jPupil);
}
return arr;
}
int check_foo(list_t * list)
{
register int i;
int sum = 0;
for(i = 0; i<list_getSize(list); i++)
sum+=list_getData(list, i);
return sum;
}
void player_unsubscribeStart(audioplayer_t * self, void * listener, change_fn callback) {
for (int i = 0; i < list_getSize(self->subscribers); i++) {
subscriber_t * subs = (subscriber_t *)list_get(self->subscribers, i);
if ((subs->listener == listener) && (subs->callback == callback)) {
list_remove(self->subscribers, i);
break;
}
}
}
void word_add (sentence_t * sentence, word_t * word)
{
for(int i = 0; i < list_getSize(sentence->words); i++)
{
word_t * wrd = list_get(sentence->words, i);
if(!strcmp(word->letters, wrd->letters))
return 0;
}
list_push_back(sentence->words, word);
}
user_t * chat_remove_user_by_surname(chat_t * chat, const char * Surname)
{
for(int i = 0; i < list_getSize(chat->users); i++){
user_t * tmp = list_get(chat->users, i);
if(strcmp(user_get_surname(tmp), Surname) == 0){
return list_remove(chat->users, i);
}
}
return NULL;
}
void chat_add_message(chat_t * chat, message_t * msg){
list_t * tmp = list_new();
tmp = chat_get_list_of_users(chat);
for(int i = 0; i < list_getSize(tmp); i++){ // if new user print a message
user_t * tmpUser = (user_t*) list_get(tmp, i);
if(strcmp(user_get_name(tmpUser), user_get_name(msg->owner)) != 0 ||
strcmp(user_get_surname(tmpUser), user_get_surname(msg->owner)) != 0 ||
user_get_age(tmpUser) != user_get_age(msg->owner))
{
if( i == (list_getSize(tmp) - 1)){
list_push_back(chat, (void *) user_new(user_get_name(msg->owner),
user_get_surname(msg->owner),user_get_age(msg->owner)));
break;
}
continue;
}
else {
break;
}
}
list_push_back(chat->messages, (void*) msg);
}
list_t * get_list_of_messages_of_one_user(chat_t * chat, user_t * user){
list_t * msgList = list_new();
for(int i = 0; i < list_getSize(chat->messages); i++){
message_t * tmp = list_get(chat->messages, i);
if(strcmp(user_get_surname(tmp->owner), user_get_surname(user)) == 0 &&
strcmp(user_get_name(tmp->owner), user_get_name(user)) == 0 &&
user_get_age(tmp->owner) == user_get_age(user))
{
list_push_back(msgList, (void*) tmp);
}
else continue;
}
return msgList;
}
void server_sendListAsHtml(socket_t * client,list_t * pupils,db_t * self){
char html[5000]= "<html>"
"<head>"
"<title>My lab 5, my hell, my love</title>"
"<body>"
"<ul>";
for(int i=0; i< list_getSize(pupils); i++){
char pupil[400];
pupil_t * p = list_get(pupils,i);
sprintf(pupil,"<li><a href= http://127.0.0.1:5000/pupils/%d>%s %s : id - %d</a></li>",pupil_getId(p),pupil_getName(p),pupil_getSurname(p),pupil_getId(p));
strcat(html,pupil);
}
strcat(html,"</ul></body></head></html>");
server_sendHtml(client,html);
}
/* =============================================================================
* hashtable_getSize
* -- Returns number of elements in hash table
* =============================================================================
*/
long
hashtable_getSize (hashtable_t* hashtablePtr)
{
#ifdef HASHTABLE_SIZE_FIELD
return hashtablePtr->size;
#else
long i;
long size = 0;
for (i = 0; i < hashtablePtr->numBucket; i++) {
size += list_getSize(hashtablePtr->buckets[i]);
}
return size;
#endif
}
patient_t * clinic_removePatient(clinic_t * cl, patient_t * p)
{
int index = -1;
for(int i = 0; i < list_getSize(cl->patients); i++)
{
patient_t * pat = list_get(cl->patients, i);
if (strcmp(p->name, pat->name)== 0)
{
index = i;
break;
}
}
if (index == -1)
{
return NULL;
}
else
return list_remove(cl->patients,index);
}
void data_manager_save (data_manager_t self)
{
xmlDoc* doc = NULL;
xmlNode* root_element = NULL;
doc = xmlNewDoc ("1.0");
root_element = xmlNewNode (NULL, "directors");
xmlDocSetRootElement (doc, root_element);
int qDirs = list_getSize(self->directors);
for (int i = 0; i < qDirs; i++)
{
director_toXmlNode (list_get (self->directors, i, NULL), doc, root_element);
}
xmlSaveFormatFileEnc (szSourcePath, doc, "UTF-8", 1);
xmlFreeDoc (doc);
}
/* =============================================================================
* data_generate
* -- Binary variables of random PDFs
* -- If seed is <0, do not reseed
* -- Returns random network
* =============================================================================
*/
net_t*
data_generate (data_t* dataPtr, long seed, long maxNumParent, long percentParent)
{
random_t* randomPtr = dataPtr->randomPtr;
if (seed >= 0) {
random_seed(randomPtr, seed);
}
/*
* Generate random Bayesian network
*/
long numVar = dataPtr->numVar;
net_t* netPtr = net_alloc(numVar);
assert(netPtr);
net_generateRandomEdges(netPtr, maxNumParent, percentParent, randomPtr);
/*
* Create a threshold for each of the possible permutation of variable
* value instances
*/
long** thresholdsTable = (long**)SEQ_MALLOC(numVar * sizeof(long*));
assert(thresholdsTable);
long v;
for (v = 0; v < numVar; v++) {
list_t* parentIdListPtr = net_getParentIdListPtr(netPtr, v);
long numThreshold = 1 << list_getSize(parentIdListPtr);
long* thresholds = (long*)SEQ_MALLOC(numThreshold * sizeof(long));
assert(thresholds);
long t;
for (t = 0; t < numThreshold; t++) {
long threshold = random_generate(randomPtr) % (DATA_PRECISION + 1);
thresholds[t] = threshold;
}
thresholdsTable[v] = thresholds;
}
/*
* Create variable dependency ordering for record generation
*/
long* order = (long*)SEQ_MALLOC(numVar * sizeof(long));
assert(order);
long numOrder = 0;
queue_t* workQueuePtr = queue_alloc(-1);
assert(workQueuePtr);
vector_t* dependencyVectorPtr = vector_alloc(1);
assert(dependencyVectorPtr);
bitmap_t* orderedBitmapPtr = bitmap_alloc(numVar);
assert(orderedBitmapPtr);
bitmap_clearAll(orderedBitmapPtr);
bitmap_t* doneBitmapPtr = bitmap_alloc(numVar);
assert(doneBitmapPtr);
bitmap_clearAll(doneBitmapPtr);
v = -1;
while ((v = bitmap_findClear(doneBitmapPtr, (v + 1))) >= 0) {
list_t* childIdListPtr = net_getChildIdListPtr(netPtr, v);
long numChild = list_getSize(childIdListPtr);
if (numChild == 0) {
bool status;
/*
* Use breadth-first search to find net connected to this leaf
*/
queue_clear(workQueuePtr);
status = queue_push(workQueuePtr, (void*)v);
assert(status);
while (!queue_isEmpty(workQueuePtr)) {
long id = (long)queue_pop(workQueuePtr);
status = bitmap_set(doneBitmapPtr, id);
assert(status);
status = vector_pushBack(dependencyVectorPtr, (void*)id);
assert(status);
list_t* parentIdListPtr = net_getParentIdListPtr(netPtr, id);
list_iter_t it;
list_iter_reset(&it, parentIdListPtr);
while (list_iter_hasNext(&it, parentIdListPtr)) {
long parentId = (long)list_iter_next(&it, parentIdListPtr);
status = queue_push(workQueuePtr, (void*)parentId);
assert(status);
}
}
/*
* Create ordering
*/
long i;
long n = vector_getSize(dependencyVectorPtr);
for (i = 0; i < n; i++) {
long id = (long)vector_popBack(dependencyVectorPtr);
if (!bitmap_isSet(orderedBitmapPtr, id)) {
bitmap_set(orderedBitmapPtr, id);
order[numOrder++] = id;
}
}
}
}
assert(numOrder == numVar);
/*
* Create records
*/
char* record = dataPtr->records;
long r;
long numRecord = dataPtr->numRecord;
for (r = 0; r < numRecord; r++) {
long o;
for (o = 0; o < numOrder; o++) {
long v = order[o];
list_t* parentIdListPtr = net_getParentIdListPtr(netPtr, v);
long index = 0;
list_iter_t it;
list_iter_reset(&it, parentIdListPtr);
while (list_iter_hasNext(&it, parentIdListPtr)) {
long parentId = (long)list_iter_next(&it, parentIdListPtr);
long value = record[parentId];
assert(value != DATA_INIT);
index = (index << 1) + value;
}
long rnd = random_generate(randomPtr) % DATA_PRECISION;
long threshold = thresholdsTable[v][index];
record[v] = ((rnd < threshold) ? 1 : 0);
}
record += numVar;
assert(record <= (dataPtr->records + numRecord * numVar));
}
/*
* Clean up
*/
bitmap_free(doneBitmapPtr);
bitmap_free(orderedBitmapPtr);
vector_free(dependencyVectorPtr);
queue_free(workQueuePtr);
SEQ_FREE(order);
for (v = 0; v < numVar; v++) {
SEQ_FREE(thresholdsTable[v]);
}
SEQ_FREE(thresholdsTable);
return netPtr;
}
int room_getSize(room_t * self){
return list_getSize(self->flat);
}
/* =============================================================================
* element_addNeighbor
* =============================================================================
*/
void
element_addNeighbor (element_t* elementPtr, element_t* neighborPtr)
{
list_insert(elementPtr->neighborListPtr, (void*)neighborPtr);
assert(list_getSize(elementPtr->neighborListPtr) <= elementPtr->numEdge);
}
int text_getSentencesCount(text_t * self){
return list_getSize(self->sentencesList);
}
void list_clear( struct List* list )
{
while ( list_getSize(list) > 0 )
list_pop(list);
}
int sentence_getWordsCount(sentence_t * self){
return list_getSize(self->words);
}
/* =============================================================================
* decoder_process
* =============================================================================
*/
int_error_t
decoder_process (decoder_t* decoderPtr, char* bytes, long numByte)
{
bool_t status;
/*
* Basic error checking
*/
if (numByte < (long)PACKET_HEADER_LENGTH) {
return ERROR_SHORT;
}
packet_t* packetPtr = (packet_t*)bytes;
long flowId = packetPtr->flowId;
long fragmentId = packetPtr->fragmentId;
long numFragment = packetPtr->numFragment;
long length = packetPtr->length;
if (flowId < 0) {
return ERROR_FLOWID;
}
if ((fragmentId < 0) || (fragmentId >= numFragment)) {
return ERROR_FRAGMENTID;
}
if (length < 0) {
return ERROR_LENGTH;
}
#if 0
/*
* With the above checks, this one is redundant
*/
if (numFragment < 1) {
return ERROR_NUMFRAGMENT;
}
#endif
/*
* Add to fragmented map for reassembling
*/
if (numFragment > 1) {
MAP_T* fragmentedMapPtr = decoderPtr->fragmentedMapPtr;
list_t* fragmentListPtr =
(list_t*)MAP_FIND(fragmentedMapPtr, (void*)flowId);
if (fragmentListPtr == NULL) {
fragmentListPtr = list_alloc(&decoder_comparator);
assert(fragmentListPtr);
status = list_insert(fragmentListPtr, (void*)packetPtr);
assert(status);
status = MAP_INSERT(fragmentedMapPtr,
(void*)flowId,
(void*)fragmentListPtr);
assert(status);
} else {
list_iter_t it;
list_iter_reset(&it, fragmentListPtr);
assert(list_iter_hasNext(&it, fragmentListPtr));
packet_t* firstFragmentPtr =
(packet_t*)list_iter_next(&it, fragmentListPtr);
long expectedNumFragment = firstFragmentPtr->numFragment;
if (numFragment != expectedNumFragment) {
status = MAP_REMOVE(fragmentedMapPtr, (void*)flowId);
assert(status);
return ERROR_NUMFRAGMENT;
}
status = list_insert(fragmentListPtr, (void*)packetPtr);
assert(status);
/*
* If we have all the fragments we can reassemble them
*/
if (list_getSize(fragmentListPtr) == numFragment) {
long numByte = 0;
long i = 0;
list_iter_reset(&it, fragmentListPtr);
while (list_iter_hasNext(&it, fragmentListPtr)) {
packet_t* fragmentPtr =
(packet_t*)list_iter_next(&it, fragmentListPtr);
assert(fragmentPtr->flowId == flowId);
if (fragmentPtr->fragmentId != i) {
status = MAP_REMOVE(fragmentedMapPtr, (void*)flowId);
assert(status);
return ERROR_INCOMPLETE; /* should be sequential */
}
numByte += fragmentPtr->length;
i++;
}
char* data = (char*)SEQ_MALLOC(numByte + 1);
assert(data);
data[numByte] = '\0';
char* dst = data;
list_iter_reset(&it, fragmentListPtr);
while (list_iter_hasNext(&it, fragmentListPtr)) {
packet_t* fragmentPtr =
(packet_t*)list_iter_next(&it, fragmentListPtr);
memcpy(dst, (void*)fragmentPtr->data, fragmentPtr->length);
dst += fragmentPtr->length;
}
assert(dst == data + numByte);
decoded_t* decodedPtr = (decoded_t*)SEQ_MALLOC(sizeof(decoded_t));
assert(decodedPtr);
decodedPtr->flowId = flowId;
decodedPtr->data = data;
queue_t* decodedQueuePtr = decoderPtr->decodedQueuePtr;
status = queue_push(decodedQueuePtr, (void*)decodedPtr);
assert(status);
list_free(fragmentListPtr);
status = MAP_REMOVE(fragmentedMapPtr, (void*)flowId);
assert(status);
}
}
} else {
/*
* This is the only fragment, so it is ready
*/
if (fragmentId != 0) {
return ERROR_FRAGMENTID;
}
char* data = (char*)SEQ_MALLOC(length + 1);
assert(data);
data[length] = '\0';
memcpy(data, (void*)packetPtr->data, length);
decoded_t* decodedPtr = (decoded_t*)SEQ_MALLOC(sizeof(decoded_t));
assert(decodedPtr);
decodedPtr->flowId = flowId;
decodedPtr->data = data;
queue_t* decodedQueuePtr = decoderPtr->decodedQueuePtr;
status = queue_push(decodedQueuePtr, (void*)decodedPtr);
assert(status);
}
return ERROR_NONE;
}
int data_manager_getSize (data_manager_t self)
{
return list_getSize( self->directors );
}
