How we keep track of the readers of a gr::buffer.  
 More...
#include <gnuradio/buffer_reader.h>
|  | 
|  | buffer_reader (buffer_sptr buffer, unsigned int read_index, block_sptr link) | 
|  | constructor is private. Use gr::buffer::add_reader to create instances 
 | 
How we keep track of the readers of a gr::buffer. 
◆ ~buffer_reader()
  
  | 
        
          | virtual gr::buffer_reader::~buffer_reader | ( |  | ) |  |  | virtual | 
 
 
◆ buffer_reader()
  
  | 
        
          | gr::buffer_reader::buffer_reader | ( | buffer_sptr | buffer, |  
          |  |  | unsigned int | read_index, |  
          |  |  | block_sptr | link ) |  | protected | 
 
constructor is private. Use gr::buffer::add_reader to create instances 
References buffer, and link().
 
 
◆ buffer()
  
  | 
        
          | buffer_sptr gr::buffer_reader::buffer | ( |  | ) | const |  | inline | 
 
Return buffer this reader reads from. 
References d_buffer.
 
 
◆ declare_sample_delay()
      
        
          | void gr::buffer_reader::declare_sample_delay | ( | unsigned | delay | ) |  | 
      
 
 
◆ done()
  
  | 
        
          | bool gr::buffer_reader::done | ( |  | ) | const |  | inline | 
 
 
◆ get_abs_read_offset()
  
  | 
        
          | uint64_t gr::buffer_reader::get_abs_read_offset | ( |  | ) | const |  | inline | 
 
 
◆ get_read_index()
  
  | 
        
          | unsigned int gr::buffer_reader::get_read_index | ( |  | ) | const |  | inline | 
 
 
◆ get_sizeof_item()
  
  | 
        
          | size_t gr::buffer_reader::get_sizeof_item | ( |  | ) |  |  | inline | 
 
 
◆ get_tags_in_range()
      
        
          | void gr::buffer_reader::get_tags_in_range | ( | std::vector< tag_t > & | v, | 
        
          |  |  | uint64_t | abs_start, | 
        
          |  |  | uint64_t | abs_end, | 
        
          |  |  | long | id ) | 
      
 
Given a [start,end), returns a vector all tags in the range. 
Get a vector of tags in given range. Range of counts is from start to end-1.
Tags are tuples of: (item count, source id, key, value)
- Parameters
- 
  
    | v | a vector reference to return tags into |  | abs_start | a uint64 count of the start of the range of interest |  | abs_end | a uint64 count of the end of the range of interest |  | id | the unique ID of the block to make sure already deleted tags are not returned |  
 
 
 
◆ input_blkd_cb_ready()
  
  | 
        
          | virtual bool gr::buffer_reader::input_blkd_cb_ready | ( | int | items_required | ) | const |  | inlinevirtual | 
 
Returns true when the current thread is ready to call the callback, false otherwise. Delegate calls to buffer class's input_blkd_cb_ready(). Note if input_blocked_callback is overridden then this function should also be overridden. 
Reimplemented in gr::buffer_reader_sm.
 
 
◆ input_blocked_callback()
  
  | 
        
          | virtual bool gr::buffer_reader::input_blocked_callback | ( | int | items_required, |  
          |  |  | int | items_avail ) |  | inlinevirtual | 
 
Callback function that the scheduler will call when it determines that the input is blocked. Delegate calls to buffer class's input_blocked_callback(). Override this function if needed. 
Reimplemented in gr::buffer_reader_sm.
 
 
◆ items_available()
  
  | 
        
          | virtual int gr::buffer_reader::items_available | ( |  | ) | const |  | virtual | 
 
 
◆ link()
  
  | 
        
          | block_sptr gr::buffer_reader::link | ( |  | ) | const |  | inline | 
 
 
◆ max_possible_items_available()
  
  | 
        
          | int gr::buffer_reader::max_possible_items_available | ( |  | ) | const |  | inline | 
 
Return maximum number of items that could ever be available for reading. This is used as a sanity check in the scheduler to avoid looping forever. 
References d_buffer.
 
 
◆ mutex()
◆ nitems_read()
  
  | 
        
          | uint64_t gr::buffer_reader::nitems_read | ( |  | ) | const |  | inline | 
 
 
◆ read_pointer()
      
        
          | const void * gr::buffer_reader::read_pointer | ( |  | ) |  | 
      
 
return pointer to read buffer. 
The return value points to items_available() number of items 
 
 
◆ reset_nitem_counter()
  
  | 
        
          | void gr::buffer_reader::reset_nitem_counter | ( |  | ) |  |  | inline | 
 
 
◆ sample_delay()
      
        
          | unsigned gr::buffer_reader::sample_delay | ( |  | ) | const | 
      
 
 
◆ set_done()
  
  | 
        
          | void gr::buffer_reader::set_done | ( | bool | done | ) |  |  | inline | 
 
 
◆ update_read_pointer()
      
        
          | void gr::buffer_reader::update_read_pointer | ( | int | nitems | ) |  | 
      
 
 
◆ buffer
◆ buffer_add_reader
  
  | 
        
          | GR_RUNTIME_API buffer_reader_sptr buffer_add_reader | ( | buffer_sptr | buf, |  
          |  |  | int | nzero_preload, |  
          |  |  | block_sptr | link = block_sptr(), |  
          |  |  | int | delay = 0 ) |  | friend | 
 
Create a new gr::buffer_reader and attach it to buffer buf. 
- Parameters
- 
  
    | buf | is the buffer the gr::buffer_readerreads from. |  | nzero_preload | – number of zero items to "preload" into buffer. |  | link | is the block that reads from the buffer using this gr::buffer_reader. |  | delay | Optional setting to declare the buffer's sample delay. |  
 
References GR_RUNTIME_API, and link().
 
 
◆ buffer_double_mapped
◆ buffer_reader_sm
◆ buffer_single_mapped
◆ d_abs_read_offset
  
  | 
        
          | uint64_t gr::buffer_reader::d_abs_read_offset |  | protected | 
 
 
◆ d_attr_delay
  
  | 
        
          | unsigned gr::buffer_reader::d_attr_delay |  | protected | 
 
 
◆ d_buffer
  
  | 
        
          | buffer_sptr gr::buffer_reader::d_buffer |  | protected | 
 
 
◆ d_link
  
  | 
        
          | std::weak_ptr<block> gr::buffer_reader::d_link |  | protected | 
 
 
◆ d_read_index
  
  | 
        
          | unsigned int gr::buffer_reader::d_read_index |  | protected | 
 
 
The documentation for this class was generated from the following file: