Ejemplo n.º 1
0
/*
 * tldlist_add adds the TLD contained in `hostname' to the tldlist if
 * `d' falls in the begin and end dates associated with the list;
 * returns 1 if the entry was counted, 0 if not
 */
int tldlist_add(TLDList *tld, char *hostname, Date *d) {
    // check if it's within the tld dates
    if (date_compare(tld->begin, d) > 0 ||date_compare(tld->end, d) < 0)
        return 0;
    int i , counter=0;
    int len = strlen(hostname);
    for(i=len;i>0;i--){
        if(hostname[i] == '.'){
            counter=i;
            break;
        }
    }
    char *tempTLDnode = hostname+counter+1;
    int hostlen = strlen(tempTLDnode);
    char *tldstr = (char *)malloc((hostlen + 1));

    tldstr[hostlen] = '\0'; // make sure there is a null end

    for(i=0;i<hostlen;i++){
        tldstr[i] = tempTLDnode[i];
    }

    tld->root = addnode(tld, tldstr, tld->root);
    tld->count++;
    return 1;
}
Ejemplo n.º 2
0
int tldlist_add(TLDList *tld, char *hostname, Date *d){
	//create node with 'hostname' to the tldlist when 'd' falls in the begin and end date

	if ((date_compare(tld->beg, d)<=0)&&(date_compare(tld->end, d)>=0)){
		//char *tldToken=strtok(strrchr(hostname, '.'), ".");
		int i;
		int len = strlen(hostname);
		i = len;
		int dotCount;
		while(i > 0){
			if(hostname[i] == '.'){
				dotCount = i;
				break;
			}
			i--;
		}
		char *tempChar = hostname+dotCount+1;
		int charLen = strlen(tempChar);
		char *tldname=(char *)malloc(charLen+1);
		if(tldname == NULL){
			free(tldname);
			return NULL;
		}
		tldname[charLen]='\0';
		for(i=0;i<charLen;i++){
			tldname[i] = tempChar[i];
		}
		tld->root =insert_node(tld, tld->root, tldname);
		tld->numOfNodes++;
		return 1;
	}
	return 0;
}
/*
 * tldlist_add adds the TLD contained in `hostname' to the tldlist if
 * `d' falls in the begin and end dates associated with the list;
 * returns 1 if the entry was counted, 0 if not
 */
int tldlist_add(TLDList *tld, char *hostname, Date *d) {
	
	long i;

	// check if the date is whithin the limit
	if (date_compare(d,tld->begin) >= 0 && date_compare(tld->end, d) >= 0) {
		#ifdef DEBUG
		printf("[ADD] Valid hostname, will be added\n");
		#endif

		// extract the last dot location
		for (i=strlen(hostname); i>0 && hostname[i] != '.'; i--);

		// check if it is the first element of the tree
		if (tld->root == NULL) {
			// create a new node and set it as the first root
			tld->root = tldnode_new(hostname+i+1);
		} else {
			tldnode_add(tld, hostname+i+1, tld->root);
		}

		tld->host_count++;
		return 1;
	}
	#ifdef DEBUG
	printf("[ADD] Invalid host, date outside the limit\n");
	#endif

	return 0;

}
Ejemplo n.º 4
0
list getBetweenDate(struct tm start, struct tm end, struct error* err) {
    err->error = NO_ERROR;

    if(!db) {
        if(!initializeConnection(NULL)) {
            exit(1);
        }
    }

    sqlite3_stmt* statement;
    const char* sql = "select * from tasks";
    const char* unused;

    
    int rc = sqlite3_prepare(db, sql, -1, &statement, &unused);
    if(rc != SQLITE_OK) {
        err->error = DATABASE_SELECT;
        err->description = sqlite3_errmsg(db);
        return NULL;
    }

    list l = l_new();
    while(sqlite3_step(statement) == SQLITE_ROW) {
        struct tm s;
        struct tm e;

        
        strptime((char*)sqlite3_column_text(statement, 2), "%a %b %d %H:%M:%S %Y%n", &s);
        strptime((char*)sqlite3_column_text(statement, 3), "%a %b %d %H:%M:%S %Y%n", &e);

        if(date_compare(start, s) > 0 || date_compare(end, e) < 0) {
            continue ;
        }

        char* title;
        char* description;
        
        int title_length = strlen((char*)sqlite3_column_text(statement, 0)) + 1;
        int descr_length = strlen((char*)sqlite3_column_text(statement, 1)) + 1;

        title       = (char*)malloc(title_length*sizeof(char));
        description = (char*)malloc(descr_length*sizeof(char));

        strcpy(title,(char*)sqlite3_column_text(statement, 0));
        strcpy(description, (char*)sqlite3_column_text(statement, 1));
    
        Task t          = (Task)malloc(sizeof(struct task));
        t->title        = title;
        t->description  = description;
        t->startDay     = s;
        t->dueDay       = e;
        l_push(l, t);
    } 

    sqlite3_finalize(statement);
    return l;

}
Ejemplo n.º 5
0
Archivo: main.c Proyecto: picrin/AP3
int main(){
  Date* date_year1 = date_create("11/10/1991");
  Date* date_year2 = date_create("11/10/1992");
  Date* date_month1 = date_create("11/10/1991");
  Date* date_month2 = date_create("11/11/1991");
  Date* date_day1 = date_create("11/10/1991");
  Date* date_day2 = date_create("12/10/1991");
  Date* date_same1 = date_create("10/10/1991");
  Date* date_same2 = date_create("10/10/1991");
  int comp1;
  int comp2;
  int comp3;
  int comp4;
  int comp5;
  int comp6;
  int comp7;
  int comp8;
  
  comp1 = date_compare(date_year1, date_year2);
  comp2 = date_compare(date_month1, date_month2);
  comp3 = date_compare(date_day1, date_day2);
  comp4 = date_compare(date_same1, date_same2);
  comp5 = date_compare(date_month2, date_month1);
  comp6 = date_compare(date_year2, date_year1);
  comp7 = date_compare(date_day2, date_day1);
  comp8 = date_compare(date_same2, date_same1);
  
  
  
  printf("%i, %i, %i, %i, %i, %i, %i, %i", comp1, comp2, comp3, comp4, comp5, comp6, comp7, comp8);
  //printf("%i\n", all_chars(&validate_slash, 4, 8, '/', '/', '/'));
  return 0;
}
Ejemplo n.º 6
0
int tldlist_add(TLDList *tld, char *hostname, Date *d)
{
    if (date_compare(tld->begin, d) > 0 || date_compare(tld->end, d) < 0 )
        return 0;
    char *tldStr, *cur;
    cur = hostname;
    while ( *cur != '\0')
    {
        if ( *cur == '.')
        {
            tldStr = cur;
        }
        cur++;
    }
    tldStr++;
    char *tldValue = (char *)malloc(sizeof(char)*4);
    strcpy(tldValue, tldStr);
    if (isEmpty(tld))
    {
        tld->root = tldnode_create(NULL, tldValue, 1);
        if (tld->root != NULL)
        {
            tld->size++;
            tld->totalTLDs++;
            return 1;
        }
        else
            return 0;
    }
    else
    {
        int result = tldlist_insert(tldValue, tld->root, tld);
        if ( result != 0 )
        {
            if (result != 2) // if tld already exists, you don't need to increment the size of the tree.
                tld->size++;
            tld->totalTLDs++;
            return 1;
        }
        else
            return 0;
    }
    return 0;
}
Ejemplo n.º 7
0
tDDAPRecord *db_search_birth_date( tDateTime birthDate )
{
    uint32_t i;

    for ( i = 0; i < g_recordCount; i++ )
    {
        if ( date_compare( g_ddapDatabase[i].birthDate, birthDate ) == 0 )
            return (&g_ddapDatabase[i]);
    }

    return (NULL);
}
Ejemplo n.º 8
0
void do_date_search( eParserSymbol comparison_symbol, tDateTime dateCompare )
{
    uint32_t index;
    uint32_t record_total = db_get_record_count();
    tItemStack results;

    results.type = ITEM_TYPE_RESULT;
    results.result_list_size = 0;

    for ( index = 0; index < record_total; index++ )
    {
        tDDAPRecord *pCur = db_search_index( index );
        int32_t comparison_result = date_compare( pCur->birthDate, dateCompare );
        int32_t add_item = 0;

        switch ( comparison_symbol )
        {
        case SYM_LESS_THAN:
            if ( comparison_result == -1 )
                add_item = 1;
            break;

        case SYM_GREATER_THAN:
            if ( comparison_result == 1 )
                add_item = 1;
            break;

        case SYM_EQUAL:
            if ( comparison_result == 0 )
                add_item = 1;
            break;

        case SYM_NOT_EQUAL:
            if ( comparison_result != 0 )
                add_item = 1;
            break;

        default:
            THROW( PARSER_EXCEPTION_INVALID_TOKEN );
            break;
        }

        // Add the result to the result list
        if ( add_item )
            results.data.result_list[results.result_list_size++] = index;
    }

    // Add results
    push_parser_stack( results );
}
// THIS METHOD IS OF TIME COMPLEXITY O(ALen + BLen) . Hence this is preferred
struct transaction * sortedArraysCommonElements(struct transaction *A, int ALen, struct transaction *B, int BLen)
{
	int i = 0, j = 0, date, len = 0;
	struct transaction *result = NULL;

	if (A == NULL || B == NULL || ALen == NULL || BLen == NULL)
		return NULL;
	
	while (i < ALen && j < BLen)
	{
		date = date_compare(A[i].date, B[j].date);

		if (date == 1)
			j++;
		else if (date == 2)
			i++;
		// If transactions are high, (> 1000), we can increment i, j in steps of powers of 2.
		// Here, this is enough as there are less transactions
		else
		{
			if (A[i].amount == B[j].amount && stringcompare(A[i].description, B[j].description))
			{
				len++;
				result = (struct transaction*)realloc(result, len*sizeof(struct transaction));
				result[len - 1].amount = A[i].amount;
				string_copy(result[len - 1].date, A[i].date);
				string_copy(result[len - 1].description, A[i].description);
			}
			// For the given testcases and question , this else is not needed.(special case)
			else
			{
				len++;
				result = (struct transaction*)realloc(result, len*sizeof(struct transaction));
				result[len - 1].amount = A[i].amount;
				string_copy(result[len - 1].date, A[i].date);
				string_copy(result[len - 1].description, A[i].description);
				len++;
				result = (struct transaction*)realloc(result, len*sizeof(struct transaction));
				result[len - 1].amount = B[j].amount;
				string_copy(result[len - 1].date, B[j].date);
				string_copy(result[len - 1].description, B[j].description);
			}
			i++;
			j++;
		}
	}


	return result;
}