Class: SizedQueue (Ruby 2.3.4)

    In Files

    • thread_sync.c

    Class/Module Index [+]

    Quicksearch

    SizedQueue

    This class represents queues of specified size capacity. The push operation may be blocked if the capacity is full.

    See Queue for an example of how a SizedQueue works.

    Public Class Methods

    new(max) click to toggle source

    Creates a fixed-length queue with a maximum size of max.

     
                   static VALUE
    rb_szqueue_initialize(VALUE self, VALUE vmax)
    {
        long max;
    
        max = NUM2LONG(vmax);
        if (max <= 0) {
            rb_raise(rb_eArgError, "queue size must be positive");
        }
    
        RSTRUCT_SET(self, QUEUE_QUE, ary_buf_new());
        RSTRUCT_SET(self, QUEUE_WAITERS, ary_buf_new());
        RSTRUCT_SET(self, SZQUEUE_WAITERS, ary_buf_new());
        RSTRUCT_SET(self, SZQUEUE_MAX, vmax);
    
        return self;
    }
                

    Public Instance Methods

    <<(*args) click to toggle source

    Alias for push.

    Alias for: push
    clear() click to toggle source

    Removes all objects from the queue.

     
                   static VALUE
    rb_szqueue_clear(VALUE self)
    {
        rb_ary_clear(GET_QUEUE_QUE(self));
        wakeup_all_threads(GET_SZQUEUE_WAITERS(self));
        return self;
    }
                
    close(exception=false) click to toggle source

    Similar to Queue#close.

    The difference is behavior with waiting enqueuing threads.

    If there are waiting enqueuing threads, they are interrupted by raising ClosedQueueError('queue closed').

     
                   static VALUE
    rb_szqueue_close(VALUE self)
    {
        return queue_do_close(self, TRUE);
    }
                
    deq(*args) click to toggle source

    Alias for push.

    Alias for: pop
    enq(*args) click to toggle source
    Alias for: push
    max() click to toggle source

    Returns the maximum size of the queue.

     
                   static VALUE
    rb_szqueue_max_get(VALUE self)
    {
        return GET_SZQUEUE_MAX(self);
    }
                
    max=(number) click to toggle source

    Sets the maximum size of the queue to the given number.

     
                   static VALUE
    rb_szqueue_max_set(VALUE self, VALUE vmax)
    {
        long max = NUM2LONG(vmax), diff = 0;
        VALUE t;
    
        if (max <= 0) {
            rb_raise(rb_eArgError, "queue size must be positive");
        }
        if ((unsigned long)max > GET_SZQUEUE_ULONGMAX(self)) {
            diff = max - GET_SZQUEUE_ULONGMAX(self);
        }
        RSTRUCT_SET(self, SZQUEUE_MAX, vmax);
        while (diff-- > 0 && !NIL_P(t = rb_ary_shift(GET_SZQUEUE_WAITERS(self)))) {
            rb_thread_wakeup_alive(t);
        }
        return vmax;
    }
                
    num_waiting() click to toggle source

    Returns the number of threads waiting on the queue.

     
                   static VALUE
    rb_szqueue_num_waiting(VALUE self)
    {
        long len = queue_num_waiting(self) + szqueue_num_waiting_producer(self);
        return ULONG2NUM(len);
    }
                
    pop(non_block=false) click to toggle source
    deq(non_block=false)
    shift(non_block=false)

    Retrieves data from the queue.

    If the queue is empty, the calling thread is suspended until data is pushed onto the queue. If non_block is true, the thread isn't suspended, and an exception is raised.

     
                   static VALUE
    rb_szqueue_pop(int argc, VALUE *argv, VALUE self)
    {
        int should_block = queue_pop_should_block(argc, argv);
        return szqueue_do_pop(self, should_block);
    }
                
    Also aliased as: deq, shift
    push(object, non_block=false) click to toggle source
    enq(object, non_block=false)
    <<(object)

    Pushes object to the queue.

    If there is no space left in the queue, waits until space becomes available, unless non_block is true. If non_block is true, the thread isn't suspended, and an exception is raised.

     
                   static VALUE
    rb_szqueue_push(int argc, VALUE *argv, VALUE self)
    {
        struct waiting_delete args;
        int should_block = szqueue_push_should_block(argc, argv);
        args.waiting = GET_SZQUEUE_WAITERS(self);
        args.th      = rb_thread_current();
    
        while (queue_length(self) >= GET_SZQUEUE_ULONGMAX(self)) {
            if (!should_block) {
                rb_raise(rb_eThreadError, "queue full");
            }
            else if (queue_closed_p(self)) {
                goto closed;
            }
            else {
                rb_ary_push(args.waiting, args.th);
                rb_ensure((VALUE (*)())rb_thread_sleep_deadly, (VALUE)0, queue_delete_from_waiting, (VALUE)&args);
            }
        }
    
        if (queue_closed_p(self)) {
          closed:
            raise_closed_queue_error(self);
        }
    
        return queue_do_push(self, argv[0]);
    }
                
    Also aliased as: enq, <<
    shift(*args) click to toggle source

    Alias for pop.

    Alias for: pop