int main(int argc, char* argv[])
{
deque_t* pdeq_coll = NULL;
person_t t_person;
type_register(person_t, NULL, NULL, NULL, NULL);
pdeq_coll = create_deque(person_t);
if(pdeq_coll == NULL)
{
return -1;
}
deque_init(pdeq_coll);
memset(t_person.s_firstname, '\0', 21);
memset(t_person.s_lastname, '\0', 21);
strcpy(t_person.s_firstname, "Jonh");
strcpy(t_person.s_lastname, "right");
deque_push_back(pdeq_coll, &t_person);
memset(t_person.s_firstname, '\0', 21);
memset(t_person.s_lastname, '\0', 21);
strcpy(t_person.s_firstname, "Bill");
strcpy(t_person.s_lastname, "killer");
deque_push_back(pdeq_coll, &t_person);
memset(t_person.s_firstname, '\0', 21);
memset(t_person.s_lastname, '\0', 21);
strcpy(t_person.s_firstname, "Jonh");
strcpy(t_person.s_lastname, "sound");
deque_push_back(pdeq_coll, &t_person);
memset(t_person.s_firstname, '\0', 21);
memset(t_person.s_lastname, '\0', 21);
strcpy(t_person.s_firstname, "Bin");
strcpy(t_person.s_lastname, "lee");
deque_push_back(pdeq_coll, &t_person);
memset(t_person.s_firstname, '\0', 21);
memset(t_person.s_lastname, '\0', 21);
strcpy(t_person.s_firstname, "Lee");
strcpy(t_person.s_lastname, "bird");
deque_push_back(pdeq_coll, &t_person);
algo_for_each(deque_begin(pdeq_coll), deque_end(pdeq_coll), _print);
printf("\n");
algo_sort_if(deque_begin(pdeq_coll), deque_end(pdeq_coll), _person_sort_criterion);
algo_for_each(deque_begin(pdeq_coll), deque_end(pdeq_coll), _print);
printf("\n");
deque_destroy(pdeq_coll);
return 0;
}
void push_back_counting(size_t item_size, deque_t* d, int num)
{
int i;
assert(item_size == 4);
for( i = 0; i < num; i++ ) {
deque_push_back(4, d, &i);
}
}
int main(void)
{
deque_t *deque;
int errcode,integer,integer_;
size_t counter = 0;
deque = deque_initialize(sizeof(int),DEFAULT_RELEASE_FUNCTION);
if(!deque){
fputs("Error!\n",stderr);
return -1;
}
while(counter != 64){
integer = counter;
errcode = deque_push_front(deque,&integer);
if(errcode){
deque_release(deque);
fputs("Error!\n",stderr);
return -1;
}
integer = counter+10;
errcode = deque_push_back(deque,&integer);
if(errcode){
deque_release(deque);
fputs("Error!\n",stderr);
return -1;
}
counter++;
}
counter = 0;
while(counter != deque_size(deque)){
errcode = deque_refer_from_front(deque,counter,&integer);
if(errcode){
deque_release(deque);
fputs("Error!\n",stderr);
return -1;
}
errcode = deque_refer_from_back(deque,counter,&integer_);
if(errcode){
deque_release(deque);
fputs("Error!\n",stderr);
return -1;
}
fprintf(stdout,"%03d : %03d,%03d\n",counter,integer,integer_);
counter++;
}
deque_release(deque);
return 0;
}
static VALUE deque_init(int argc, VALUE *argv, VALUE self)
{
int len, i;
VALUE ary;
if(argc == 0) {
return self;
}
else if(argc > 1) {
rb_raise(rb_eArgError, "wrong number of arguments");
}
else {
ary = rb_check_array_type(argv[0]);
if(!NIL_P(ary)) {
len = RARRAY_LEN(ary);
for (i = 0; i < len; i++) {
deque_push_back(self, RARRAY_PTR(ary)[i]);
}
}
}
return self;
}
int main()
{
const char *output[] = {"EsaY", "YasE", "aYsE", "asYE"};
const char *input = "EasY";
const char *pinput; /* point to input */
const char *poutput; /* point to output */
size_t i;
for (i = 0; i < SIZE(output); i++) {
pinput = input;
poutput = output[i];
printf("for pattern %s:\n", poutput);
for (; *poutput != '\0';) {
if (!deque_empty() && deque_front() == *poutput) {
printf("+\t%c\n", deque_pop_front());
poutput++;
} else if (!deque_empty() && deque_back() == *poutput) {
printf("*\t%c\n", deque_pop_back());
poutput++;
} else { /* the deque is empty or not the first or last */
if (islower(*pinput)) {
deque_push_back(*pinput++);
} else if (isupper(*pinput)) {
deque_push_front(*pinput++);
} else if (*pinput == '\0') {
printf("unable to generate such pattern\n");
break;
}
}
}
putchar('\n');
}
return 0;
}
qioerr qbuffer_append(qbuffer_t* buf, qbytes_t* bytes, int64_t skip_bytes, int64_t len_bytes)
{
qbuffer_part_t part;
int64_t new_end;
qioerr err;
new_end = buf->offset_end + len_bytes;
// init part retains the bytes.
err = qbuffer_init_part(&part, bytes, skip_bytes, len_bytes, new_end);
if( err ) return err;
err = deque_push_back(sizeof(qbuffer_part_t), &buf->deque, &part);
if( err ) {
qbytes_release(bytes); // release the bytes.
return err;
}
buf->offset_end = new_end;
// invalidate cached entries.
qbuffer_clear_cached(buf);
return 0;
}
void simple_test( void){
deque dq;
double a;
int i, status;
fprintf( stdout, "Testing deque_allocate: " );
dq = deque_alloc();
if( dq != NULL ){
fprintf( stdout, "success!\n");
}else{
fprintf( stdout, "failed!\n");
}
fprintf( stdout, "Testing deque_empty: ");
if( deque_empty( dq) ){
fprintf( stdout, "success!\n");
}else{
fprintf( stdout, "failed!\n");
}
a = 2.5;
fprintf( stdout, "Testing deque_push_back, value=%1.2g: ", a);
if( deque_push_back( dq, a ) == DEQUE_SUCCESS ){
fprintf( stdout, "success!\n");
}else{
fprintf( stdout, "failed!\n");
}
a = 3.14159;
fprintf( stdout, "Testing deque_peek_back: ");
if( deque_peek_back( dq, &a) == DEQUE_SUCCESS ){
fprintf( stdout, "success!, value=%1.2g\n", a);
}else{
fprintf( stdout, "failed, value=%1.2g\n", a);
}
fprintf( stdout, "Testing deque_size: ");
fprintf( stdout, "size=%d\n", deque_size( dq));
fprintf( stdout, "Testing deque_pop_back: ");
a = 3.14159;
if( deque_pop_back( dq, &a) == DEQUE_SUCCESS ){
fprintf( stdout, "success!, value=%1.2g\n", a);
}else{
fprintf( stdout, "failed!, value=%1.2g\n", a);
}
a = 3.14159;
fprintf( stdout, "Testing deque_pop_back on empty deque: ");
if( deque_pop_back( dq, &a) != DEQUE_EMPTY ){
fprintf( stdout, "failed!, value=%1.2g\n", a);
}else{
fprintf( stdout, "success!,\n");
fprintf( stdout, " caught empty deque, value=%1.2g\n", a);
}
a = 2.5;
fprintf( stdout, "Testing deque_push_front, value=%1.2g: ", a);
if( deque_push_front( dq, a ) == DEQUE_SUCCESS ){
fprintf( stdout, "success!\n");
}else{
fprintf( stdout, "failed!\n");
}
a = 3.14159;
fprintf( stdout, "Testing deque_peek_front: ");
if( deque_peek_front( dq, &a) == DEQUE_SUCCESS ){
fprintf( stdout, "success!, value=%1.2g\n", a);
}else{
fprintf( stdout, "failed, value=%1.2g\n", a);
}
fprintf( stdout, "Testing deque_size: ");
fprintf( stdout, "size=%d\n", deque_size( dq));
fprintf( stdout, "Testing deque_pop_front: ");
a = 3.14159;
if( deque_pop_front( dq, &a) == DEQUE_SUCCESS ){
fprintf( stdout, "success!, value=%1.2g\n", a);
}else{
fprintf( stdout, "failed!, value=%1.2g\n", a);
}
a = 3.14159;
fprintf( stdout, "Testing deque_pop_front on empty deque: ");
if( deque_pop_front( dq, &a) != DEQUE_EMPTY ){
fprintf( stdout, "failed!, value=%1.2g\n", a);
}else{
fprintf( stdout, "success!,\n");
fprintf( stdout, " caught empty deque, value=%1.2g\n", a);
}
fprintf( stdout, "Testing deque_get_item: ");
for( i=0; i<5; i++ ){
a = (double) i + 0.545;
if( deque_push_back( dq, a) != DEQUE_SUCCESS ){
fprintf( stderr, "deque push back failed!\n" );
deque_free( dq);
return;
}
a = (-1. - (double) i) + 0.545;
if( deque_push_front( dq, a) != DEQUE_SUCCESS ){
fprintf( stderr, "deque push front failed!\n" );
deque_free( dq);
return;
}
}
for( i=0; i<10; i++){
status = deque_get_item( dq, i, &a);
if( status != DEQUE_SUCCESS || a != (-5. + (double) i) + 0.545 ){
fprintf( stderr, "deque get_item failed!\n" );
deque_free( dq);
return;
}
}
a = 3.14159;
status = deque_get_item( dq, 11, &a);
if( status != DEQUE_OUT_OF_BOUNDS || a != 3.14159 ){
fprintf( stderr, "deque get_item out of bounds failed!\n");
deque_free( dq);
}
fprintf( stdout, "success!\n");
deque_free( dq);
}
void big_test( int num){
int center, front, back, i, sw, status, fsize;
double *vals, *pvals, tmp;
clock_t start, stop, diff;
int msecs;
deque dq;
dq = deque_alloc();
vals = (double *) malloc( 2*num*sizeof(double));
pvals = (double *) malloc( 2*num*sizeof(double));
for( i=0; i<2*num; i++){
vals[i] = (double) rand() / (double) RAND_MAX;
}
front = 0;
back = 0;
center = num;
fprintf( stdout, "Testing deque_push_back and front %d times\n", num/2);
start = clock();
for( i=0; i<num/2; i++){
if( rand() % 2 == 0 ){
deque_push_back( dq, vals[center+back] );
back++;
}else{
front--;
deque_push_front( dq, vals[center+front] );
}
}
stop = clock();
diff = stop-start;
msecs = (int) diff * 1000 / CLOCKS_PER_SEC;
fprintf( stdout, " succeeded in %u ms\n", msecs);
fprintf( stdout,
"Testing deque_push(pop)_back(front) %d times\n", num);
start = clock();
for( i=0; i<num; i++){
sw = rand() % 4;
switch( sw ){
case 0:
status = deque_push_back( dq, vals[center+back]);
back++;
break;
case 1:
front--;
status = deque_push_front( dq, vals[center+front]);
break;
case 2:
back--;
status = deque_pop_back( dq, &tmp);
break;
case 3:
status = deque_pop_front( dq, &tmp);
front++;
break;
default:
status = 1;
tmp = 1;
}
if( status != DEQUE_SUCCESS ){
fprintf( stderr, " error at op i=%d\n", i);
free( pvals);
free( vals);
deque_free( dq);
return;
}
}
stop = clock();
diff = stop-start;
msecs = (int) diff * 1000 / CLOCKS_PER_SEC;
fprintf( stdout, " succeeded in %u ms\n", msecs);
fsize = deque_size( dq);
fprintf( stdout,
"Testing deque_get_item %d times\n", fsize);
start = clock();
for( i=0; i<fsize; i++){
deque_get_item( dq, i, &(pvals[i]));
}
stop = clock();
for( i=0; i<fsize; i++){
if( pvals[i] != vals[center+front+i] ){
fprintf( stderr, " obtained value error! at item %d\n", i);
free( pvals);
free( vals);
deque_free( dq);
return;
}
}
diff = stop-start;
msecs = (int) diff * 1000 / CLOCKS_PER_SEC;
fprintf( stdout, " succeeded in %u ms\n", msecs);
fprintf( stdout,
"Testing deque_pop_front %d times\n", fsize);
start = clock();
for( i=0; i<fsize; i++){
deque_pop_front( dq, &(pvals[i]));
}
stop = clock();
for( i=0; i<fsize; i++){
if( pvals[i] != vals[center+front+i] ){
fprintf( stderr, " obtained value error! at item %d\n", i);
free( pvals);
free( vals);
deque_free( dq);
return;
}
}
diff = stop-start;
msecs = (int) diff * 1000 / CLOCKS_PER_SEC;
fprintf( stdout, " succeeded in %u ms\n", msecs);
free( pvals);
free( vals);
deque_free( dq);
}
int main()
{
{
deque_t d = new_deque();
SPAN(tuple_ix_t) span = deque_as_span(&d);
assert(span.ptr == NULL);
assert(span.sz == 0);
deque_free(&d);
}
{
deque_t d = new_deque();
deque_push_back(&d, 1234);
SPAN(tuple_ix_t) span = deque_as_span(&d);
assert(span.ptr != NULL);
assert(span.sz == 1);
assert(span.ptr[0] == 1234);
deque_free(&d);
free(span.ptr);
}
{
deque_t d = new_deque();
enum {NREP = 40000};
size_t ix = 0;
for (ix = 0; ix < NREP; ++ix)
{
deque_push_back(&d, ix + 1234);
}
SPAN(tuple_ix_t) span = deque_as_span(&d);
assert(span.ptr != NULL);
assert(span.sz == NREP);
for (ix = 0; ix < NREP; ++ix)
{
assert(span.ptr[ix] == (ix + 1234));
}
deque_free(&d);
free(span.ptr);
}
{
deque_t d = new_deque();
enum {NREP = 40000000};
size_t ix = 0;
for (ix = 0; ix < NREP; ++ix)
{
deque_push_back(&d, ix + 1234);
}
SPAN(tuple_ix_t) span = deque_as_span(&d);
assert(span.ptr != NULL);
assert(span.sz == NREP);
for (ix = 0; ix < NREP; ++ix)
{
assert(span.ptr[ix] == (ix + 1234));
}
deque_free(&d);
free(span.ptr);
}
return 0;
}
/**
* Recursive iteration for file finding
*
* @param __dir - directory to search file in
* @param __rel_dir - relative director name to search file in
* @param __options - finding options
* @param __res_wnd - window with results
* @return zero on success, non-zero otherwise
*/
static int
find_iteration (const wchar_t *__dir, const wchar_t *__rel_dir,
const action_find_options_t *__options,
action_find_res_wnd_t *__res_wnd)
{
int i, j, count;
vfs_dirent_t **eps = NULL;
size_t fn_len;
wchar_t *format, *full_name;
vfs_stat_t stat;
vfs_stat_proc stat_proc;
deque_t *dirs;
wchar_t **dir_data;
__res_wnd->dir_opened = FALSE;
/* Get listing of directory */
/*
* TODO: Add separately displaying of directories and files
*/
count = vfs_scandir (__dir, &eps, 0, vfs_alphasort);
if (count < 0)
{
/* Error getting listing */
return ACTION_ERR;
}
if (TEST_FLAG(__options->flags, AFF_FIND_RECURSIVELY))
{
dirs = deque_create ();
}
/* Get function for stat'ing */
if (TEST_FLAG(__options->flags, AFF_FOLLOW_SYMLINKS))
{
stat_proc = vfs_stat;
}
else
{
stat_proc = vfs_lstat;
}
/* Allocate memory for full file name */
fn_len = wcslen (__dir) + MAX_FILENAME_LEN + 1;
full_name = malloc ((fn_len + 1) * sizeof (wchar_t));
/* Get format mask for correct directory drilling */
if (__dir[wcslen (__dir) - 1] == '/')
{
format = L"%ls%ls";
}
else
{
format = L"%ls/%ls";
}
for (i = 0; i < count; ++i)
{
if (IS_PSEUDODIR (eps[i]->name))
{
vfs_free_dirent (eps[i]);
continue;
}
set_searching_status (__res_wnd, L"Searching in", __rel_dir);
/* Get full file name */
swprintf (full_name, fn_len, format, __dir, eps[i]->name);
/* Stat current node of FS */
if (!stat_proc (full_name, &stat) == VFS_OK)
{
/* Error getting status of file */
vfs_free_dirent (eps[i]);
continue;
}
if (S_ISREG (stat.st_mode))
{
if (check_regular_file (eps[i]->name, full_name,
__options, __res_wnd))
{
append_result (__rel_dir, eps[i]->name, stat, __res_wnd);
++__res_wnd->found_files;
}
}
else if (S_ISDIR (stat.st_mode))
{
/* Of user wants directories to be found... */
if (TEST_FLAG(__options->flags, AFF_FIND_DIRECTORIES))
{
if (check_directory (eps[i]->name, full_name,
__options, __res_wnd))
{
append_result (__rel_dir, eps[i]->name, stat, __res_wnd);
++__res_wnd->found_dirs;
}
}
if (TEST_FLAG(__options->flags, AFF_FIND_RECURSIVELY))
{
dir_data = malloc (2 * sizeof (wchar_t));
dir_data[0] = wcsdup (eps[i]->name);
dir_data[1] = wcsdup (full_name);
deque_push_back (dirs, (void*)dir_data);
}
}
else
{
if (check_special_file (eps[i]->name, full_name,
__options, __res_wnd))
{
append_result (__rel_dir, eps[i]->name, stat, __res_wnd);
++__res_wnd->found_files;
}
}
vfs_free_dirent (eps[i]);
hook_call (L"switch-task-hook", NULL);
if (ACTION_PERFORMED (__res_wnd))
{
/* Free remain dirents */
for (j = i + 1; j < count; ++j)
{
vfs_free_dirent (eps[j]);
}
break;
}
}
SAFE_FREE (eps);
free (full_name);
if (TEST_FLAG(__options->flags, AFF_FIND_RECURSIVELY) &&
!ACTION_PERFORMED (__res_wnd))
{
void *data;
wchar_t *rel_name;
if (__rel_dir[wcslen (__rel_dir) - 1] == '/')
{
format = L"%ls%ls";
}
else
{
format = L"%ls/%ls";
}
fn_len = wcslen (__dir) + MAX_FILENAME_LEN + 1;
rel_name = malloc ((fn_len + 1) * sizeof (wchar_t));
deque_foreach (dirs, data);
/* Drill relative file name */
dir_data = data;
if (!ACTION_PERFORMED (__res_wnd))
{
swprintf (rel_name, fn_len, format, __rel_dir, dir_data[0]);
find_iteration (dir_data[1], rel_name, __options, __res_wnd);
}
free (dir_data);
deque_foreach_done
}
