cc_int32 ccs_list_iterator_clone (ccs_list_iterator_t  in_list_iterator,
                                  ccs_list_iterator_t *out_list_iterator)
{
    cc_int32 err = ccNoError;
    ccs_list_iterator_t list_iterator = NULL;
    
    if (!in_list_iterator ) { err = cci_check_error (ccErrBadParam); }
    if (!out_list_iterator) { err = cci_check_error (ccErrBadParam); }
    
    if (!err) {
        err = ccs_list_iterator_new (&list_iterator, 
                                     in_list_iterator->list, 
                                     in_list_iterator->client_pipe);
    }
    
    if (!err) {
        list_iterator->current = in_list_iterator->current;

        *out_list_iterator = list_iterator;
        list_iterator = NULL;
    }
    
    ccs_list_iterator_release (list_iterator);
    
    return cci_check_error (err);    
}
Example #2
0
static cc_int32 print_list (ccs_list_t in_list)
{
    cc_int32 err = ccNoError;
    ccs_list_iterator_t iterator = NULL;
    
    if (!in_list) { err = ccErrBadParam; }
    
    if (!err) {
        err = ccs_list_new_iterator (in_list, &iterator);
    }
    
    if (!err) {
        int i = 0;
        printf ("List:\n");
        
        while (!err) {
            ccs_object_t object = NULL;
            
            err = ccs_list_iterator_next (iterator, &object);
            
            if (!err) {
                test_object_t tobj = (test_object_t) object;
                printf ("\t%d: \"%s\"\n", i++, tobj->string);
            }
        }
        if (err == ccIteratorEnd) { 
            printf ("\n");
            err = ccNoError; 
        }
    }
    
    ccs_list_iterator_release (iterator);
    
    return err;
}
static cc_int32 ccs_list_iterator_new (ccs_list_iterator_t *out_list_iterator,
                                       ccs_list_t           io_list,
                                       ccs_pipe_t           in_client_pipe)
{
    cc_int32 err = ccNoError;
    ccs_list_iterator_t list_iterator = NULL;
    
    if (!out_list_iterator) { err = cci_check_error (ccErrBadParam); }
    if (!io_list          ) { err = cci_check_error (ccErrBadParam); }
    /* client_pipe may be NULL if the iterator exists for internal server use */
    
    if (!err) {
        list_iterator = malloc (sizeof (*list_iterator));
        if (list_iterator) { 
            *list_iterator = ccs_list_iterator_initializer;
        } else {
            err = cci_check_error (ccErrNoMem); 
        }
    }
    
    if (!err) {
        err = ccs_server_new_identifier (&list_iterator->identifier);
    }

    if (!err) {
        list_iterator->list = io_list;
        list_iterator->current = 0;
        
        err = cci_array_insert (io_list->iterators, 
                                (cci_array_object_t) list_iterator, 
				cci_array_count (io_list->iterators));
    }
    
    if (!err && ccs_pipe_valid (in_client_pipe)) {
        ccs_client_t client = NULL;
        
        err = ccs_pipe_copy (&list_iterator->client_pipe, in_client_pipe);
        
        if (!err) {
            err = ccs_server_client_for_pipe (in_client_pipe, &client);
        }
        
        if (!err) {
            err = ccs_client_add_iterator (client, list_iterator);
        }
    }

    if (!err) {
        *out_list_iterator = list_iterator;
        list_iterator = NULL;
    }
    
    ccs_list_iterator_release (list_iterator);
    
    return cci_check_error (err);    
}
Example #4
0
cc_int32 ccs_list_release_iterator (ccs_list_t       io_list,
                                    cci_identifier_t in_identifier)
{
    cc_int32 err = ccNoError;
    ccs_list_iterator_t iterator = NULL;
    
    if (!io_list      ) { err = cci_check_error (ccErrBadParam); }
    if (!in_identifier) { err = cci_check_error (ccErrBadParam); }
    
    if (!err) {
        err = ccs_list_find_iterator (io_list, in_identifier, &iterator);
    }
    
    if (!err) {
        err = ccs_list_iterator_release (iterator);
    }
    
    return cci_check_error (err);    
}
Example #5
0
cc_int32 ccs_list_release (ccs_list_t io_list)
{
    cc_int32 err = ccNoError;
    
    if (!io_list) { err = ccErrBadParam; }
    
    if (!err) {
        cc_uint64 i;
        
        for (i = 0; i < cci_array_count (io_list->iterators); i++) {
            ccs_list_iterator_release (cci_array_object_at_index (io_list->iterators, i));
        }
        free (io_list->iterators);
        cci_array_release (io_list->objects);
        free (io_list);
    }
    
    return err;        
}
cc_int32 ccs_list_iterator_invalidate (ccs_list_iterator_t io_list_iterator)
{
    cc_int32 err = ccNoError;
    ccs_list_iterator_t list_iterator = (ccs_list_iterator_t) io_list_iterator;
    
    if (!io_list_iterator) { err = ccErrBadParam; }
    
    if (!err) {
        /* Client owner died.  Remove client reference and then the iterator. */
        if (ccs_pipe_valid (list_iterator->client_pipe)) { 
            ccs_pipe_release (list_iterator->client_pipe);
            list_iterator->client_pipe = CCS_PIPE_NULL;
        }
        
        err = ccs_list_iterator_release (io_list_iterator);
    }
    
    return err;        
}
Example #7
0
static cc_int32 ccs_list_iterator_new (ccs_list_iterator_t *out_list_iterator,
                                       ccs_list_t           io_list)
{
    cc_int32 err = ccNoError;
    ccs_list_iterator_t list_iterator = NULL;
    
    if (!out_list_iterator) { err = cci_check_error (ccErrBadParam); }
    if (!io_list          ) { err = cci_check_error (ccErrBadParam); }
    
    if (!err) {
        list_iterator = malloc (sizeof (*list_iterator));
        if (list_iterator) { 
            *list_iterator = ccs_list_iterator_initializer;
        } else {
            err = cci_check_error (ccErrNoMem); 
        }
    }
    
    if (!err) {
        err = ccs_server_new_identifier (&list_iterator->identifier);
    }

    if (!err) {
        list_iterator->list = io_list;
        list_iterator->current = 0;
        
        err = cci_array_insert (io_list->iterators, 
                                list_iterator, cci_array_count (io_list->iterators));
    }

    if (!err) {
        *out_list_iterator = list_iterator;
        list_iterator = NULL;
    }
    
    ccs_list_iterator_release (list_iterator);
    
    return cci_check_error (err);    
}