GNU Radio Manual and C++ API Reference  3.9.4.0
The Free & Open Software Radio Ecosystem
pmt Namespace Reference

Classes

class  comparator
 Provide a comparator function object to allow pmt use in stl types. More...
 
class  exception
 
class  notimplemented
 
class  out_of_range
 
class  pmt_base
 base class of all pmt types More...
 
class  pmt_pool
 very simple thread-safe fixed-size allocation pool More...
 
class  wrong_type
 

Typedefs

typedef std::shared_ptr< pmt_basepmt_t
 typedef for shared pointer (transparent reference counting). More...
 

Functions

PMT_API pmt_t get_PMT_NIL ()
 
PMT_API pmt_t get_PMT_T ()
 
PMT_API pmt_t get_PMT_F ()
 
PMT_API pmt_t get_PMT_EOF ()
 
PMT_API bool is_bool (pmt_t obj)
 Return true if obj is #t or #f, else return false. More...
 
PMT_API bool is_true (pmt_t obj)
 Return false if obj is #f, else return true. More...
 
PMT_API bool is_false (pmt_t obj)
 Return true if obj is #f, else return true. More...
 
PMT_API pmt_t from_bool (bool val)
 Return #f is val is false, else return #t. More...
 
PMT_API bool to_bool (pmt_t val)
 Return true if val is pmt::True, return false when val is pmt::PMT_F,. More...
 
PMT_API bool is_symbol (const pmt_t &obj)
 Return true if obj is a symbol, else false. More...
 
PMT_API pmt_t string_to_symbol (const std::string &s)
 Return the symbol whose name is s. More...
 
PMT_API pmt_t intern (const std::string &s)
 Alias for pmt_string_to_symbol. More...
 
const PMT_API std::string symbol_to_string (const pmt_t &sym)
 
PMT_API bool is_number (pmt_t obj)
 Return true if obj is any kind of number, else false. More...
 
PMT_API bool is_integer (pmt_t x)
 Return true if x is an integer number, else false. More...
 
PMT_API pmt_t from_long (long x)
 Return the pmt value that represents the integer x. More...
 
PMT_API long to_long (pmt_t x)
 Convert pmt to long if possible. More...
 
PMT_API bool is_uint64 (pmt_t x)
 Return true if x is an uint64 number, else false. More...
 
PMT_API pmt_t from_uint64 (uint64_t x)
 Return the pmt value that represents the uint64 x. More...
 
PMT_API uint64_t to_uint64 (pmt_t x)
 Convert pmt to uint64 if possible. More...
 
PMT_API bool is_real (pmt_t obj)
 
PMT_API pmt_t from_double (double x)
 Return the pmt value that represents double x. More...
 
PMT_API pmt_t from_float (float x)
 
PMT_API double to_double (pmt_t x)
 Convert pmt to double if possible. More...
 
PMT_API float to_float (pmt_t x)
 Convert pmt to float if possible. More...
 
PMT_API bool is_complex (pmt_t obj)
 return true if obj is a complex number, false otherwise. More...
 
PMT_API pmt_t make_rectangular (double re, double im)
 Return a complex number constructed of the given real and imaginary parts. More...
 
PMT_API pmt_t from_complex (double re, double im)
 Return a complex number constructed of the given real and imaginary parts. More...
 
PMT_API pmt_t from_complex (const std::complex< double > &z)
 Return a complex number constructed of the given a complex number. More...
 
PMT_API pmt_t pmt_from_complex (double re, double im)
 Return a complex number constructed of the given real and imaginary parts. More...
 
PMT_API pmt_t pmt_from_complex (const std::complex< double > &z)
 Return a complex number constructed of the given a complex number. More...
 
PMT_API std::complex< double > to_complex (pmt_t z)
 
PMT_API bool is_null (const pmt_t &x)
 Return true if x is the empty list, otherwise return false. More...
 
PMT_API bool is_pair (const pmt_t &obj)
 Return true if obj is a pair, else false (warning: also returns true for a dict) More...
 
PMT_API pmt_t cons (const pmt_t &x, const pmt_t &y)
 Return a newly allocated pair whose car is x and whose cdr is y. More...
 
PMT_API pmt_t car (const pmt_t &pair)
 If pair is a pair, return the car of the pair, otherwise raise wrong_type. More...
 
PMT_API pmt_t cdr (const pmt_t &pair)
 If pair is a pair, return the cdr of the pair, otherwise raise wrong_type. More...
 
PMT_API void set_car (pmt_t pair, pmt_t value)
 Stores value in the car field of pair. More...
 
PMT_API void set_cdr (pmt_t pair, pmt_t value)
 Stores value in the cdr field of pair. More...
 
PMT_API pmt_t caar (pmt_t pair)
 
PMT_API pmt_t cadr (pmt_t pair)
 
PMT_API pmt_t cdar (pmt_t pair)
 
PMT_API pmt_t cddr (pmt_t pair)
 
PMT_API pmt_t caddr (pmt_t pair)
 
PMT_API pmt_t cadddr (pmt_t pair)
 
PMT_API bool is_tuple (pmt_t x)
 Return true if x is a tuple, otherwise false. More...
 
PMT_API pmt_t make_tuple ()
 
PMT_API pmt_t make_tuple (const pmt_t &e0)
 
PMT_API pmt_t make_tuple (const pmt_t &e0, const pmt_t &e1)
 
PMT_API pmt_t make_tuple (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2)
 
PMT_API pmt_t make_tuple (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3)
 
PMT_API pmt_t make_tuple (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4)
 
PMT_API pmt_t make_tuple (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5)
 
PMT_API pmt_t make_tuple (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6)
 
PMT_API pmt_t make_tuple (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7)
 
PMT_API pmt_t make_tuple (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8)
 
PMT_API pmt_t make_tuple (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8, const pmt_t &e9)
 
PMT_API pmt_t to_tuple (const pmt_t &x)
 
PMT_API pmt_t tuple_ref (const pmt_t &tuple, size_t k)
 
PMT_API bool is_vector (pmt_t x)
 Return true if x is a vector, otherwise false. More...
 
PMT_API pmt_t make_vector (size_t k, pmt_t fill)
 Make a vector of length k, with initial values set to fill. More...
 
PMT_API pmt_t vector_ref (pmt_t vector, size_t k)
 
PMT_API void vector_set (pmt_t vector, size_t k, pmt_t obj)
 Store obj in position k. More...
 
PMT_API void vector_fill (pmt_t vector, pmt_t fill)
 Store fill in every position of vector. More...
 
PMT_API bool is_blob (pmt_t x)
 Return true if x is a blob, otherwise false. More...
 
PMT_API pmt_t make_blob (const void *buf, size_t len)
 Make a blob given a pointer and length in bytes. More...
 
const PMT_API void * blob_data (pmt_t blob)
 Return a pointer to the blob's data. More...
 
PMT_API size_t blob_length (pmt_t blob)
 Return the blob's length in bytes. More...
 
PMT_API bool is_uniform_vector (pmt_t x)
 true if x is any kind of uniform numeric vector More...
 
PMT_API bool is_u8vector (pmt_t x)
 
PMT_API bool is_s8vector (pmt_t x)
 
PMT_API bool is_u16vector (pmt_t x)
 
PMT_API bool is_s16vector (pmt_t x)
 
PMT_API bool is_u32vector (pmt_t x)
 
PMT_API bool is_s32vector (pmt_t x)
 
PMT_API bool is_u64vector (pmt_t x)
 
PMT_API bool is_s64vector (pmt_t x)
 
PMT_API bool is_f32vector (pmt_t x)
 
PMT_API bool is_f64vector (pmt_t x)
 
PMT_API bool is_c32vector (pmt_t x)
 
PMT_API bool is_c64vector (pmt_t x)
 
PMT_API size_t uniform_vector_itemsize (pmt_t x)
 item size in bytes if x is any kind of uniform numeric vector More...
 
PMT_API pmt_t make_u8vector (size_t k, uint8_t fill)
 
PMT_API pmt_t make_s8vector (size_t k, int8_t fill)
 
PMT_API pmt_t make_u16vector (size_t k, uint16_t fill)
 
PMT_API pmt_t make_s16vector (size_t k, int16_t fill)
 
PMT_API pmt_t make_u32vector (size_t k, uint32_t fill)
 
PMT_API pmt_t make_s32vector (size_t k, int32_t fill)
 
PMT_API pmt_t make_u64vector (size_t k, uint64_t fill)
 
PMT_API pmt_t make_s64vector (size_t k, int64_t fill)
 
PMT_API pmt_t make_f32vector (size_t k, float fill)
 
PMT_API pmt_t make_f64vector (size_t k, double fill)
 
PMT_API pmt_t make_c32vector (size_t k, std::complex< float > fill)
 
PMT_API pmt_t make_c64vector (size_t k, std::complex< double > fill)
 
PMT_API pmt_t init_u8vector (size_t k, const uint8_t *data)
 
PMT_API pmt_t init_u8vector (size_t k, const std::vector< uint8_t > &data)
 
PMT_API pmt_t init_s8vector (size_t k, const int8_t *data)
 
PMT_API pmt_t init_s8vector (size_t k, const std::vector< int8_t > &data)
 
PMT_API pmt_t init_u16vector (size_t k, const uint16_t *data)
 
PMT_API pmt_t init_u16vector (size_t k, const std::vector< uint16_t > &data)
 
PMT_API pmt_t init_s16vector (size_t k, const int16_t *data)
 
PMT_API pmt_t init_s16vector (size_t k, const std::vector< int16_t > &data)
 
PMT_API pmt_t init_u32vector (size_t k, const uint32_t *data)
 
PMT_API pmt_t init_u32vector (size_t k, const std::vector< uint32_t > &data)
 
PMT_API pmt_t init_s32vector (size_t k, const int32_t *data)
 
PMT_API pmt_t init_s32vector (size_t k, const std::vector< int32_t > &data)
 
PMT_API pmt_t init_u64vector (size_t k, const uint64_t *data)
 
PMT_API pmt_t init_u64vector (size_t k, const std::vector< uint64_t > &data)
 
PMT_API pmt_t init_s64vector (size_t k, const int64_t *data)
 
PMT_API pmt_t init_s64vector (size_t k, const std::vector< int64_t > &data)
 
PMT_API pmt_t init_f32vector (size_t k, const float *data)
 
PMT_API pmt_t init_f32vector (size_t k, const std::vector< float > &data)
 
PMT_API pmt_t init_f64vector (size_t k, const double *data)
 
PMT_API pmt_t init_f64vector (size_t k, const std::vector< double > &data)
 
PMT_API pmt_t init_c32vector (size_t k, const std::complex< float > *data)
 
PMT_API pmt_t init_c32vector (size_t k, const std::vector< std::complex< float >> &data)
 
PMT_API pmt_t init_c64vector (size_t k, const std::complex< double > *data)
 
PMT_API pmt_t init_c64vector (size_t k, const std::vector< std::complex< double >> &data)
 
PMT_API uint8_t u8vector_ref (pmt_t v, size_t k)
 
PMT_API int8_t s8vector_ref (pmt_t v, size_t k)
 
PMT_API uint16_t u16vector_ref (pmt_t v, size_t k)
 
PMT_API int16_t s16vector_ref (pmt_t v, size_t k)
 
PMT_API uint32_t u32vector_ref (pmt_t v, size_t k)
 
PMT_API int32_t s32vector_ref (pmt_t v, size_t k)
 
PMT_API uint64_t u64vector_ref (pmt_t v, size_t k)
 
PMT_API int64_t s64vector_ref (pmt_t v, size_t k)
 
PMT_API float f32vector_ref (pmt_t v, size_t k)
 
PMT_API double f64vector_ref (pmt_t v, size_t k)
 
PMT_API std::complex< float > c32vector_ref (pmt_t v, size_t k)
 
PMT_API std::complex< double > c64vector_ref (pmt_t v, size_t k)
 
PMT_API void u8vector_set (pmt_t v, size_t k, uint8_t x)
 
PMT_API void s8vector_set (pmt_t v, size_t k, int8_t x)
 
PMT_API void u16vector_set (pmt_t v, size_t k, uint16_t x)
 
PMT_API void s16vector_set (pmt_t v, size_t k, int16_t x)
 
PMT_API void u32vector_set (pmt_t v, size_t k, uint32_t x)
 
PMT_API void s32vector_set (pmt_t v, size_t k, int32_t x)
 
PMT_API void u64vector_set (pmt_t v, size_t k, uint64_t x)
 
PMT_API void s64vector_set (pmt_t v, size_t k, int64_t x)
 
PMT_API void f32vector_set (pmt_t v, size_t k, float x)
 
PMT_API void f64vector_set (pmt_t v, size_t k, double x)
 
PMT_API void c32vector_set (pmt_t v, size_t k, std::complex< float > x)
 
PMT_API void c64vector_set (pmt_t v, size_t k, std::complex< double > x)
 
const PMT_API void * uniform_vector_elements (pmt_t v, size_t &len)
 
const PMT_API uint8_t * u8vector_elements (pmt_t v, size_t &len)
 
const PMT_API int8_t * s8vector_elements (pmt_t v, size_t &len)
 
const PMT_API uint16_t * u16vector_elements (pmt_t v, size_t &len)
 
const PMT_API int16_t * s16vector_elements (pmt_t v, size_t &len)
 
const PMT_API uint32_t * u32vector_elements (pmt_t v, size_t &len)
 
const PMT_API int32_t * s32vector_elements (pmt_t v, size_t &len)
 
const PMT_API uint64_t * u64vector_elements (pmt_t v, size_t &len)
 
const PMT_API int64_t * s64vector_elements (pmt_t v, size_t &len)
 
const PMT_API float * f32vector_elements (pmt_t v, size_t &len)
 
const PMT_API double * f64vector_elements (pmt_t v, size_t &len)
 
const PMT_API std::complex< float > * c32vector_elements (pmt_t v, size_t &len)
 
const PMT_API std::complex< double > * c64vector_elements (pmt_t v, size_t &len)
 
const PMT_API std::vector< uint8_t > u8vector_elements (pmt_t v)
 
const PMT_API std::vector< int8_t > s8vector_elements (pmt_t v)
 
const PMT_API std::vector< uint16_t > u16vector_elements (pmt_t v)
 
const PMT_API std::vector< int16_t > s16vector_elements (pmt_t v)
 
const PMT_API std::vector< uint32_t > u32vector_elements (pmt_t v)
 
const PMT_API std::vector< int32_t > s32vector_elements (pmt_t v)
 
const PMT_API std::vector< uint64_t > u64vector_elements (pmt_t v)
 
const PMT_API std::vector< int64_t > s64vector_elements (pmt_t v)
 
const PMT_API std::vector< float > f32vector_elements (pmt_t v)
 
const PMT_API std::vector< double > f64vector_elements (pmt_t v)
 
const PMT_API std::vector< std::complex< float > > c32vector_elements (pmt_t v)
 
const PMT_API std::vector< std::complex< double > > c64vector_elements (pmt_t v)
 
PMT_API void * uniform_vector_writable_elements (pmt_t v, size_t &len)
 
PMT_API uint8_t * u8vector_writable_elements (pmt_t v, size_t &len)
 
PMT_API int8_t * s8vector_writable_elements (pmt_t v, size_t &len)
 
PMT_API uint16_t * u16vector_writable_elements (pmt_t v, size_t &len)
 
PMT_API int16_t * s16vector_writable_elements (pmt_t v, size_t &len)
 
PMT_API uint32_t * u32vector_writable_elements (pmt_t v, size_t &len)
 
PMT_API int32_t * s32vector_writable_elements (pmt_t v, size_t &len)
 
PMT_API uint64_t * u64vector_writable_elements (pmt_t v, size_t &len)
 
PMT_API int64_t * s64vector_writable_elements (pmt_t v, size_t &len)
 
PMT_API float * f32vector_writable_elements (pmt_t v, size_t &len)
 
PMT_API double * f64vector_writable_elements (pmt_t v, size_t &len)
 
PMT_API std::complex< float > * c32vector_writable_elements (pmt_t v, size_t &len)
 
PMT_API std::complex< double > * c64vector_writable_elements (pmt_t v, size_t &len)
 
PMT_API bool is_dict (const pmt_t &obj)
 Return true if obj is a dictionary. More...
 
PMT_API pmt_t dcons (const pmt_t &x, const pmt_t &y)
 Return a newly allocated dict whose car is a key-value pair x and whose cdr is a dict y. More...
 
PMT_API pmt_t make_dict ()
 Make an empty dictionary. More...
 
PMT_API pmt_t dict_add (const pmt_t &dict, const pmt_t &key, const pmt_t &value)
 Return a new dictionary with key associated with value. More...
 
PMT_API pmt_t dict_delete (const pmt_t &dict, const pmt_t &key)
 Return a new dictionary with key removed. More...
 
PMT_API bool dict_has_key (const pmt_t &dict, const pmt_t &key)
 Return true if key exists in dict. More...
 
PMT_API pmt_t dict_ref (const pmt_t &dict, const pmt_t &key, const pmt_t &not_found)
 If key exists in dict, return associated value; otherwise return not_found. More...
 
PMT_API pmt_t dict_items (pmt_t dict)
 Return list of (key . value) pairs. More...
 
PMT_API pmt_t dict_keys (pmt_t dict)
 Return list of keys. More...
 
PMT_API pmt_t dict_update (const pmt_t &dict1, const pmt_t &dict2)
 Return a new dictionary dict1 with k=>v pairs from dict2 added. More...
 
PMT_API pmt_t dict_values (pmt_t dict)
 Return list of values. More...
 
PMT_API bool is_any (pmt_t obj)
 Return true if obj is an any. More...
 
PMT_API pmt_t make_any (const boost::any &any)
 make an any More...
 
PMT_API boost::any any_ref (pmt_t obj)
 Return underlying boost::any. More...
 
PMT_API void any_set (pmt_t obj, const boost::any &any)
 Store any in obj. More...
 
PMT_API bool is_msg_accepter (const pmt_t &obj)
 Return true if obj is a msg_accepter. More...
 
PMT_API pmt_t make_msg_accepter (std::shared_ptr< gr::messages::msg_accepter > ma)
 make a msg_accepter More...
 
PMT_API std::shared_ptr< gr::messages::msg_acceptermsg_accepter_ref (const pmt_t &obj)
 Return underlying msg_accepter. More...
 
PMT_API bool is_pdu (const pmt_t &obj)
 
PMT_API bool eq (const pmt_t &x, const pmt_t &y)
 Return true if x and y are the same object; otherwise return false. More...
 
PMT_API bool eqv (const pmt_t &x, const pmt_t &y)
 Return true if x and y should normally be regarded as the same object, else false. More...
 
PMT_API bool equal (const pmt_t &x, const pmt_t &y)
 
PMT_API size_t length (const pmt_t &v)
 Return the number of elements in v. More...
 
PMT_API pmt_t assq (pmt_t obj, pmt_t alist)
 Find the first pair in alist whose car field is obj and return that pair. More...
 
PMT_API pmt_t assv (pmt_t obj, pmt_t alist)
 Find the first pair in alist whose car field is obj and return that pair. More...
 
PMT_API pmt_t assoc (pmt_t obj, pmt_t alist)
 Find the first pair in alist whose car field is obj and return that pair. More...
 
PMT_API pmt_t map (pmt_t proc(const pmt_t &), pmt_t list)
 Apply proc element-wise to the elements of list and returns a list of the results, in order. More...
 
PMT_API pmt_t reverse (pmt_t list)
 reverse list. More...
 
PMT_API pmt_t reverse_x (pmt_t list)
 destructively reverse list. More...
 
static pmt_t acons (pmt_t x, pmt_t y, pmt_t a)
 (acons x y a) == (cons (cons x y) a) More...
 
PMT_API pmt_t nth (size_t n, pmt_t list)
 locates nth element of
list where the car is the 'zeroth' element. More...
 
PMT_API pmt_t nthcdr (size_t n, pmt_t list)
 returns the tail of list that would be obtained by calling cdr n times in succession. More...
 
PMT_API pmt_t memq (pmt_t obj, pmt_t list)
 Return the first sublist of list whose car is obj. If obj does not occur in list, then #f is returned. pmt::memq use pmt::eq to compare obj with the elements of list. More...
 
PMT_API pmt_t memv (pmt_t obj, pmt_t list)
 Return the first sublist of list whose car is obj. If obj does not occur in list, then #f is returned. pmt::memv use pmt::eqv to compare obj with the elements of list. More...
 
PMT_API pmt_t member (pmt_t obj, pmt_t list)
 Return the first sublist of list whose car is obj. If obj does not occur in list, then #f is returned. pmt::member use pmt::equal to compare obj with the elements of list. More...
 
PMT_API bool subsetp (pmt_t list1, pmt_t list2)
 Return true if every element of list1 appears in list2, and false otherwise. Comparisons are done with pmt::eqv. More...
 
PMT_API pmt_t list1 (const pmt_t &x1)
 Return a list of length 1 containing x1. More...
 
PMT_API pmt_t list2 (const pmt_t &x1, const pmt_t &x2)
 Return a list of length 2 containing x1, x2. More...
 
PMT_API pmt_t list3 (const pmt_t &x1, const pmt_t &x2, const pmt_t &x3)
 Return a list of length 3 containing x1, x2, x3. More...
 
PMT_API pmt_t list4 (const pmt_t &x1, const pmt_t &x2, const pmt_t &x3, const pmt_t &x4)
 Return a list of length 4 containing x1, x2, x3, x4. More...
 
PMT_API pmt_t list5 (const pmt_t &x1, const pmt_t &x2, const pmt_t &x3, const pmt_t &x4, const pmt_t &x5)
 Return a list of length 5 containing x1, x2, x3, x4, x5. More...
 
PMT_API pmt_t list6 (const pmt_t &x1, const pmt_t &x2, const pmt_t &x3, const pmt_t &x4, const pmt_t &x5, const pmt_t &x6)
 Return a list of length 6 containing x1, x2, x3, x4, x5, x6. More...
 
PMT_API pmt_t list_add (pmt_t list, const pmt_t &item)
 Return list with item added to it. More...
 
PMT_API pmt_t list_rm (pmt_t list, const pmt_t &item)
 Return list with item removed from it. More...
 
PMT_API bool list_has (pmt_t list, const pmt_t &item)
 Return bool of list contains item. More...
 
PMT_API bool is_eof_object (pmt_t obj)
 return true if obj is the EOF object, otherwise return false. More...
 
PMT_API pmt_t read (std::istream &port)
 
PMT_API void write (pmt_t obj, std::ostream &port)
 
PMT_API std::string write_string (pmt_t obj)
 
PMT_API std::ostream & operator<< (std::ostream &os, pmt_t obj)
 
PMT_API void print (pmt_t v)
 Write pmt string representation to stdout. More...
 
PMT_API bool serialize (pmt_t obj, std::streambuf &sink)
 Write portable byte-serial representation of obj to sink. More...
 
PMT_API pmt_t deserialize (std::streambuf &source)
 Create obj from portable byte-serial representation. More...
 
PMT_API void dump_sizeof ()
 
PMT_API std::string serialize_str (pmt_t obj)
 Provide a simple string generating interface to pmt's serialize function. More...
 
PMT_API pmt_t deserialize_str (std::string str)
 Provide a simple string generating interface to pmt's deserialize function. More...
 
static pmt_t mp (const std::string &s)
 Make pmt symbol. More...
 
static pmt_t mp (const char *s)
 Make pmt symbol. More...
 
static pmt_t mp (long x)
 Make pmt long. More...
 
static pmt_t mp (long unsigned x)
 Make pmt uint64. More...
 
static pmt_t mp (long long unsigned x)
 Make pmt uint64. More...
 
static pmt_t mp (int x)
 Make pmt long. More...
 
static pmt_t mp (double x)
 Make pmt double. More...
 
static pmt_t mp (std::complex< double > z)
 Make pmt complex. More...
 
static pmt_t mp (std::complex< float > z)
 Make pmt complex. More...
 
static pmt_t mp (std::shared_ptr< gr::messages::msg_accepter > ma)
 Make pmt msg_accepter. More...
 
static pmt_t mp (const void *data, size_t len_in_bytes)
 Make pmt Binary Large Object (BLOB) More...
 
static pmt_t mp (const pmt_t &e0)
 Make tuple. More...
 
static pmt_t mp (const pmt_t &e0, const pmt_t &e1)
 Make tuple. More...
 
static pmt_t mp (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2)
 Make tuple. More...
 
static pmt_t mp (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3)
 Make tuple. More...
 
static pmt_t mp (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4)
 Make tuple. More...
 
static pmt_t mp (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5)
 Make tuple. More...
 
static pmt_t mp (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6)
 Make tuple. More...
 
static pmt_t mp (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7)
 Make tuple. More...
 
static pmt_t mp (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8)
 Make tuple. More...
 
static pmt_t mp (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8, const pmt_t &e9)
 Make tuple. More...
 

Detailed Description

This file defines a polymorphic type and the operations on it.

It draws heavily on the idea of scheme and lisp data types. The interface parallels that in Guile 1.8, with the notable exception that these objects are transparently reference counted.

This file is included by pmt.h and contains pseudo-constructor shorthand for making pmt objects

Typedef Documentation

◆ pmt_t

typedef std::shared_ptr<pmt_base> pmt::pmt_t

typedef for shared pointer (transparent reference counting).

Function Documentation

◆ acons()

static pmt_t pmt::acons ( pmt_t  x,
pmt_t  y,
pmt_t  a 
)
inlinestatic

(acons x y a) == (cons (cons x y) a)

References cons(), and dcons().

◆ any_ref()

PMT_API boost::any pmt::any_ref ( pmt_t  obj)

Return underlying boost::any.

◆ any_set()

PMT_API void pmt::any_set ( pmt_t  obj,
const boost::any &  any 
)

Store any in obj.

◆ assoc()

PMT_API pmt_t pmt::assoc ( pmt_t  obj,
pmt_t  alist 
)

Find the first pair in alist whose car field is obj and return that pair.

alist (for "association list") must be a list of pairs. If no pair in alist has obj as its car then #f is returned. Uses pmt::equal to compare obj with car fields of the pairs in alist.

◆ assq()

PMT_API pmt_t pmt::assq ( pmt_t  obj,
pmt_t  alist 
)

Find the first pair in alist whose car field is obj and return that pair.

alist (for "association list") must be a list of pairs. If no pair in alist has obj as its car then #f is returned. Uses pmt::eq to compare obj with car fields of the pairs in alist.

◆ assv()

PMT_API pmt_t pmt::assv ( pmt_t  obj,
pmt_t  alist 
)

Find the first pair in alist whose car field is obj and return that pair.

alist (for "association list") must be a list of pairs. If no pair in alist has obj as its car then #f is returned. Uses pmt::eqv to compare obj with car fields of the pairs in alist.

◆ blob_data()

const PMT_API void* pmt::blob_data ( pmt_t  blob)

Return a pointer to the blob's data.

◆ blob_length()

PMT_API size_t pmt::blob_length ( pmt_t  blob)

Return the blob's length in bytes.

◆ c32vector_elements() [1/2]

const PMT_API std::vector<std::complex<float> > pmt::c32vector_elements ( pmt_t  v)

◆ c32vector_elements() [2/2]

const PMT_API std::complex<float>* pmt::c32vector_elements ( pmt_t  v,
size_t &  len 
)

◆ c32vector_ref()

PMT_API std::complex<float> pmt::c32vector_ref ( pmt_t  v,
size_t  k 
)

◆ c32vector_set()

PMT_API void pmt::c32vector_set ( pmt_t  v,
size_t  k,
std::complex< float >  x 
)

◆ c32vector_writable_elements()

PMT_API std::complex<float>* pmt::c32vector_writable_elements ( pmt_t  v,
size_t &  len 
)

◆ c64vector_elements() [1/2]

const PMT_API std::vector<std::complex<double> > pmt::c64vector_elements ( pmt_t  v)

◆ c64vector_elements() [2/2]

const PMT_API std::complex<double>* pmt::c64vector_elements ( pmt_t  v,
size_t &  len 
)

◆ c64vector_ref()

PMT_API std::complex<double> pmt::c64vector_ref ( pmt_t  v,
size_t  k 
)

◆ c64vector_set()

PMT_API void pmt::c64vector_set ( pmt_t  v,
size_t  k,
std::complex< double >  x 
)

◆ c64vector_writable_elements()

PMT_API std::complex<double>* pmt::c64vector_writable_elements ( pmt_t  v,
size_t &  len 
)

◆ caar()

PMT_API pmt_t pmt::caar ( pmt_t  pair)

◆ cadddr()

PMT_API pmt_t pmt::cadddr ( pmt_t  pair)

◆ caddr()

PMT_API pmt_t pmt::caddr ( pmt_t  pair)

◆ cadr()

PMT_API pmt_t pmt::cadr ( pmt_t  pair)

◆ car()

PMT_API pmt_t pmt::car ( const pmt_t pair)

If pair is a pair, return the car of the pair, otherwise raise wrong_type.

◆ cdar()

PMT_API pmt_t pmt::cdar ( pmt_t  pair)

◆ cddr()

PMT_API pmt_t pmt::cddr ( pmt_t  pair)

◆ cdr()

PMT_API pmt_t pmt::cdr ( const pmt_t pair)

If pair is a pair, return the cdr of the pair, otherwise raise wrong_type.

◆ cons()

PMT_API pmt_t pmt::cons ( const pmt_t x,
const pmt_t y 
)

Return a newly allocated pair whose car is x and whose cdr is y.

Referenced by acons(), gr::digital::adaptive_algorithm_nlms::make(), gr::digital::adaptive_algorithm_lms::make(), and gr::digital::adaptive_algorithm_cma::make().

◆ dcons()

PMT_API pmt_t pmt::dcons ( const pmt_t x,
const pmt_t y 
)

Return a newly allocated dict whose car is a key-value pair x and whose cdr is a dict y.

Referenced by acons().

◆ deserialize()

PMT_API pmt_t pmt::deserialize ( std::streambuf &  source)

Create obj from portable byte-serial representation.

◆ deserialize_str()

PMT_API pmt_t pmt::deserialize_str ( std::string  str)

Provide a simple string generating interface to pmt's deserialize function.

◆ dict_add()

PMT_API pmt_t pmt::dict_add ( const pmt_t dict,
const pmt_t key,
const pmt_t value 
)

Return a new dictionary with key associated with value.

◆ dict_delete()

PMT_API pmt_t pmt::dict_delete ( const pmt_t dict,
const pmt_t key 
)

Return a new dictionary with key removed.

◆ dict_has_key()

PMT_API bool pmt::dict_has_key ( const pmt_t dict,
const pmt_t key 
)

Return true if key exists in dict.

Referenced by gr::basic_block::has_msg_port(), and gr::hier_block2::message_port_register_hier_out().

◆ dict_items()

PMT_API pmt_t pmt::dict_items ( pmt_t  dict)

Return list of (key . value) pairs.

◆ dict_keys()

PMT_API pmt_t pmt::dict_keys ( pmt_t  dict)

Return list of keys.

◆ dict_ref()

PMT_API pmt_t pmt::dict_ref ( const pmt_t dict,
const pmt_t key,
const pmt_t not_found 
)

If key exists in dict, return associated value; otherwise return not_found.

◆ dict_update()

PMT_API pmt_t pmt::dict_update ( const pmt_t dict1,
const pmt_t dict2 
)

Return a new dictionary dict1 with k=>v pairs from dict2 added.

◆ dict_values()

PMT_API pmt_t pmt::dict_values ( pmt_t  dict)

Return list of values.

◆ dump_sizeof()

PMT_API void pmt::dump_sizeof ( )

◆ eq()

PMT_API bool pmt::eq ( const pmt_t x,
const pmt_t y 
)

Return true if x and y are the same object; otherwise return false.

◆ equal()

PMT_API bool pmt::equal ( const pmt_t x,
const pmt_t y 
)

pmt::equal recursively compares the contents of pairs and vectors, applying pmt::eqv on other objects such as numbers and symbols. pmt::equal may fail to terminate if its arguments are circular data structures.

Referenced by gr::msg_endpoint::operator==().

◆ eqv()

PMT_API bool pmt::eqv ( const pmt_t x,
const pmt_t y 
)

Return true if x and y should normally be regarded as the same object, else false.

eqv returns true if:
  x and y are the same object.
  x and y are both #t or both #f.
  x and y are both symbols and their names are the same.
  x and y are both numbers, and are numerically equal.
  x and y are both the empty list (nil).
  x and y are pairs or vectors that denote same location in store.

Referenced by pmt::comparator::operator()().

◆ f32vector_elements() [1/2]

const PMT_API std::vector<float> pmt::f32vector_elements ( pmt_t  v)

◆ f32vector_elements() [2/2]

const PMT_API float* pmt::f32vector_elements ( pmt_t  v,
size_t &  len 
)

◆ f32vector_ref()

PMT_API float pmt::f32vector_ref ( pmt_t  v,
size_t  k 
)

◆ f32vector_set()

PMT_API void pmt::f32vector_set ( pmt_t  v,
size_t  k,
float  x 
)

◆ f32vector_writable_elements()

PMT_API float* pmt::f32vector_writable_elements ( pmt_t  v,
size_t &  len 
)

◆ f64vector_elements() [1/2]

const PMT_API std::vector<double> pmt::f64vector_elements ( pmt_t  v)

◆ f64vector_elements() [2/2]

const PMT_API double* pmt::f64vector_elements ( pmt_t  v,
size_t &  len 
)

◆ f64vector_ref()

PMT_API double pmt::f64vector_ref ( pmt_t  v,
size_t  k 
)

◆ f64vector_set()

PMT_API void pmt::f64vector_set ( pmt_t  v,
size_t  k,
double  x 
)

◆ f64vector_writable_elements()

PMT_API double* pmt::f64vector_writable_elements ( pmt_t  v,
size_t &  len 
)

◆ from_bool()

PMT_API pmt_t pmt::from_bool ( bool  val)

Return #f is val is false, else return #t.

◆ from_complex() [1/2]

PMT_API pmt_t pmt::from_complex ( const std::complex< double > &  z)

Return a complex number constructed of the given a complex number.

◆ from_complex() [2/2]

PMT_API pmt_t pmt::from_complex ( double  re,
double  im 
)

Return a complex number constructed of the given real and imaginary parts.

Referenced by rpcbasic_inserter< T, std::complex< float > >::retrieve(), and rpcbasic_inserter< T, std::complex< double > >::retrieve().

◆ from_double()

PMT_API pmt_t pmt::from_double ( double  x)

Return the pmt value that represents double x.

Referenced by mp().

◆ from_float()

PMT_API pmt_t pmt::from_float ( float  x)

◆ from_long()

PMT_API pmt_t pmt::from_long ( long  x)

Return the pmt value that represents the integer x.

Referenced by mp().

◆ from_uint64()

PMT_API pmt_t pmt::from_uint64 ( uint64_t  x)

Return the pmt value that represents the uint64 x.

Referenced by mp().

◆ get_PMT_EOF()

PMT_API pmt_t pmt::get_PMT_EOF ( )

◆ get_PMT_F()

PMT_API pmt_t pmt::get_PMT_F ( )

◆ get_PMT_NIL()

PMT_API pmt_t pmt::get_PMT_NIL ( )

◆ get_PMT_T()

PMT_API pmt_t pmt::get_PMT_T ( )

◆ init_c32vector() [1/2]

PMT_API pmt_t pmt::init_c32vector ( size_t  k,
const std::complex< float > *  data 
)

◆ init_c32vector() [2/2]

PMT_API pmt_t pmt::init_c32vector ( size_t  k,
const std::vector< std::complex< float >> &  data 
)

◆ init_c64vector() [1/2]

PMT_API pmt_t pmt::init_c64vector ( size_t  k,
const std::complex< double > *  data 
)

◆ init_c64vector() [2/2]

PMT_API pmt_t pmt::init_c64vector ( size_t  k,
const std::vector< std::complex< double >> &  data 
)

◆ init_f32vector() [1/2]

PMT_API pmt_t pmt::init_f32vector ( size_t  k,
const float *  data 
)

◆ init_f32vector() [2/2]

PMT_API pmt_t pmt::init_f32vector ( size_t  k,
const std::vector< float > &  data 
)

◆ init_f64vector() [1/2]

PMT_API pmt_t pmt::init_f64vector ( size_t  k,
const double *  data 
)

◆ init_f64vector() [2/2]

PMT_API pmt_t pmt::init_f64vector ( size_t  k,
const std::vector< double > &  data 
)

◆ init_s16vector() [1/2]

PMT_API pmt_t pmt::init_s16vector ( size_t  k,
const int16_t *  data 
)

◆ init_s16vector() [2/2]

PMT_API pmt_t pmt::init_s16vector ( size_t  k,
const std::vector< int16_t > &  data 
)

◆ init_s32vector() [1/2]

PMT_API pmt_t pmt::init_s32vector ( size_t  k,
const int32_t *  data 
)

◆ init_s32vector() [2/2]

PMT_API pmt_t pmt::init_s32vector ( size_t  k,
const std::vector< int32_t > &  data 
)

◆ init_s64vector() [1/2]

PMT_API pmt_t pmt::init_s64vector ( size_t  k,
const int64_t *  data 
)

◆ init_s64vector() [2/2]

PMT_API pmt_t pmt::init_s64vector ( size_t  k,
const std::vector< int64_t > &  data 
)

◆ init_s8vector() [1/2]

PMT_API pmt_t pmt::init_s8vector ( size_t  k,
const int8_t *  data 
)

◆ init_s8vector() [2/2]

PMT_API pmt_t pmt::init_s8vector ( size_t  k,
const std::vector< int8_t > &  data 
)

◆ init_u16vector() [1/2]

PMT_API pmt_t pmt::init_u16vector ( size_t  k,
const std::vector< uint16_t > &  data 
)

◆ init_u16vector() [2/2]

PMT_API pmt_t pmt::init_u16vector ( size_t  k,
const uint16_t *  data 
)

◆ init_u32vector() [1/2]

PMT_API pmt_t pmt::init_u32vector ( size_t  k,
const std::vector< uint32_t > &  data 
)

◆ init_u32vector() [2/2]

PMT_API pmt_t pmt::init_u32vector ( size_t  k,
const uint32_t *  data 
)

◆ init_u64vector() [1/2]

PMT_API pmt_t pmt::init_u64vector ( size_t  k,
const std::vector< uint64_t > &  data 
)

◆ init_u64vector() [2/2]

PMT_API pmt_t pmt::init_u64vector ( size_t  k,
const uint64_t *  data 
)

◆ init_u8vector() [1/2]

PMT_API pmt_t pmt::init_u8vector ( size_t  k,
const std::vector< uint8_t > &  data 
)

◆ init_u8vector() [2/2]

PMT_API pmt_t pmt::init_u8vector ( size_t  k,
const uint8_t *  data 
)

◆ intern()

◆ is_any()

PMT_API bool pmt::is_any ( pmt_t  obj)

Return true if obj is an any.

◆ is_blob()

PMT_API bool pmt::is_blob ( pmt_t  x)

Return true if x is a blob, otherwise false.

◆ is_bool()

PMT_API bool pmt::is_bool ( pmt_t  obj)

Return true if obj is #t or #f, else return false.

◆ is_c32vector()

PMT_API bool pmt::is_c32vector ( pmt_t  x)

◆ is_c64vector()

PMT_API bool pmt::is_c64vector ( pmt_t  x)

◆ is_complex()

PMT_API bool pmt::is_complex ( pmt_t  obj)

return true if obj is a complex number, false otherwise.

◆ is_dict()

PMT_API bool pmt::is_dict ( const pmt_t obj)

Return true if obj is a dictionary.

◆ is_eof_object()

PMT_API bool pmt::is_eof_object ( pmt_t  obj)

return true if obj is the EOF object, otherwise return false.

◆ is_f32vector()

PMT_API bool pmt::is_f32vector ( pmt_t  x)

◆ is_f64vector()

PMT_API bool pmt::is_f64vector ( pmt_t  x)

◆ is_false()

PMT_API bool pmt::is_false ( pmt_t  obj)

Return true if obj is #f, else return true.

◆ is_integer()

PMT_API bool pmt::is_integer ( pmt_t  x)

Return true if x is an integer number, else false.

◆ is_msg_accepter()

PMT_API bool pmt::is_msg_accepter ( const pmt_t obj)

Return true if obj is a msg_accepter.

◆ is_null()

PMT_API bool pmt::is_null ( const pmt_t x)

Return true if x is the empty list, otherwise return false.

◆ is_number()

PMT_API bool pmt::is_number ( pmt_t  obj)

Return true if obj is any kind of number, else false.

◆ is_pair()

PMT_API bool pmt::is_pair ( const pmt_t obj)

Return true if obj is a pair, else false (warning: also returns true for a dict)

◆ is_pdu()

PMT_API bool pmt::is_pdu ( const pmt_t obj)

Returns true if the object is a PDU meaning: the object is a pair the car is a dictionary type object (including an empty dict) the cdr is a uniform vector of any type

◆ is_real()

PMT_API bool pmt::is_real ( pmt_t  obj)

◆ is_s16vector()

PMT_API bool pmt::is_s16vector ( pmt_t  x)

◆ is_s32vector()

PMT_API bool pmt::is_s32vector ( pmt_t  x)

◆ is_s64vector()

PMT_API bool pmt::is_s64vector ( pmt_t  x)

◆ is_s8vector()

PMT_API bool pmt::is_s8vector ( pmt_t  x)

◆ is_symbol()

PMT_API bool pmt::is_symbol ( const pmt_t obj)

Return true if obj is a symbol, else false.

◆ is_true()

PMT_API bool pmt::is_true ( pmt_t  obj)

Return false if obj is #f, else return true.

◆ is_tuple()

PMT_API bool pmt::is_tuple ( pmt_t  x)

Return true if x is a tuple, otherwise false.

◆ is_u16vector()

PMT_API bool pmt::is_u16vector ( pmt_t  x)

◆ is_u32vector()

PMT_API bool pmt::is_u32vector ( pmt_t  x)

◆ is_u64vector()

PMT_API bool pmt::is_u64vector ( pmt_t  x)

◆ is_u8vector()

PMT_API bool pmt::is_u8vector ( pmt_t  x)

◆ is_uint64()

PMT_API bool pmt::is_uint64 ( pmt_t  x)

Return true if x is an uint64 number, else false.

◆ is_uniform_vector()

PMT_API bool pmt::is_uniform_vector ( pmt_t  x)

true if x is any kind of uniform numeric vector

               Uniform Numeric Vectors
A uniform numeric vector is a vector whose elements are all of single
numeric type.  pmt offers uniform numeric vectors for signed and
unsigned 8-bit, 16-bit, 32-bit, and 64-bit integers, two sizes of
floating point values, and complex floating-point numbers of these
two sizes.  Indexing is zero based.
The names of the functions include these tags in their names:
   u8  unsigned 8-bit integers
   s8  signed 8-bit integers
  u16  unsigned 16-bit integers
  s16  signed 16-bit integers
  u32  unsigned 32-bit integers
  s32  signed 32-bit integers
  u64  unsigned 64-bit integers
  s64  signed 64-bit integers
  f32  the C++ type float
  f64  the C++ type double
  c32  the C++ type complex<float>
  c64  the C++ type complex<double>

◆ is_vector()

PMT_API bool pmt::is_vector ( pmt_t  x)

Return true if x is a vector, otherwise false.

◆ length()

PMT_API size_t pmt::length ( const pmt_t v)

Return the number of elements in v.

◆ list1()

PMT_API pmt_t pmt::list1 ( const pmt_t x1)

Return a list of length 1 containing x1.

◆ list2()

PMT_API pmt_t pmt::list2 ( const pmt_t x1,
const pmt_t x2 
)

Return a list of length 2 containing x1, x2.

◆ list3()

PMT_API pmt_t pmt::list3 ( const pmt_t x1,
const pmt_t x2,
const pmt_t x3 
)

Return a list of length 3 containing x1, x2, x3.

◆ list4()

PMT_API pmt_t pmt::list4 ( const pmt_t x1,
const pmt_t x2,
const pmt_t x3,
const pmt_t x4 
)

Return a list of length 4 containing x1, x2, x3, x4.

◆ list5()

PMT_API pmt_t pmt::list5 ( const pmt_t x1,
const pmt_t x2,
const pmt_t x3,
const pmt_t x4,
const pmt_t x5 
)

Return a list of length 5 containing x1, x2, x3, x4, x5.

◆ list6()

PMT_API pmt_t pmt::list6 ( const pmt_t x1,
const pmt_t x2,
const pmt_t x3,
const pmt_t x4,
const pmt_t x5,
const pmt_t x6 
)

Return a list of length 6 containing x1, x2, x3, x4, x5, x6.

◆ list_add()

PMT_API pmt_t pmt::list_add ( pmt_t  list,
const pmt_t item 
)

◆ list_has()

◆ list_rm()

PMT_API pmt_t pmt::list_rm ( pmt_t  list,
const pmt_t item 
)

Return list with item removed from it.

◆ make_any()

PMT_API pmt_t pmt::make_any ( const boost::any &  any)

make an any

Referenced by gr::digital::constellation::as_pmt().

◆ make_blob()

PMT_API pmt_t pmt::make_blob ( const void *  buf,
size_t  len 
)

Make a blob given a pointer and length in bytes.

Parameters
bufis the pointer to data to use to create blob
lenis the size of the data in bytes.

The data is copied into the blob.

Referenced by mp().

◆ make_c32vector()

PMT_API pmt_t pmt::make_c32vector ( size_t  k,
std::complex< float >  fill 
)

◆ make_c64vector()

PMT_API pmt_t pmt::make_c64vector ( size_t  k,
std::complex< double >  fill 
)

◆ make_dict()

PMT_API pmt_t pmt::make_dict ( )

Make an empty dictionary.

◆ make_f32vector()

PMT_API pmt_t pmt::make_f32vector ( size_t  k,
float  fill 
)

◆ make_f64vector()

PMT_API pmt_t pmt::make_f64vector ( size_t  k,
double  fill 
)

◆ make_msg_accepter()

PMT_API pmt_t pmt::make_msg_accepter ( std::shared_ptr< gr::messages::msg_accepter ma)

make a msg_accepter

Referenced by mp().

◆ make_rectangular()

PMT_API pmt_t pmt::make_rectangular ( double  re,
double  im 
)

Return a complex number constructed of the given real and imaginary parts.

Referenced by mp().

◆ make_s16vector()

PMT_API pmt_t pmt::make_s16vector ( size_t  k,
int16_t  fill 
)

◆ make_s32vector()

PMT_API pmt_t pmt::make_s32vector ( size_t  k,
int32_t  fill 
)

◆ make_s64vector()

PMT_API pmt_t pmt::make_s64vector ( size_t  k,
int64_t  fill 
)

◆ make_s8vector()

PMT_API pmt_t pmt::make_s8vector ( size_t  k,
int8_t  fill 
)

◆ make_tuple() [1/11]

PMT_API pmt_t pmt::make_tuple ( )

Referenced by mp().

◆ make_tuple() [2/11]

PMT_API pmt_t pmt::make_tuple ( const pmt_t e0)

◆ make_tuple() [3/11]

PMT_API pmt_t pmt::make_tuple ( const pmt_t e0,
const pmt_t e1 
)

◆ make_tuple() [4/11]

PMT_API pmt_t pmt::make_tuple ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2 
)

◆ make_tuple() [5/11]

PMT_API pmt_t pmt::make_tuple ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2,
const pmt_t e3 
)

◆ make_tuple() [6/11]

PMT_API pmt_t pmt::make_tuple ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2,
const pmt_t e3,
const pmt_t e4 
)

◆ make_tuple() [7/11]

PMT_API pmt_t pmt::make_tuple ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2,
const pmt_t e3,
const pmt_t e4,
const pmt_t e5 
)

◆ make_tuple() [8/11]

PMT_API pmt_t pmt::make_tuple ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2,
const pmt_t e3,
const pmt_t e4,
const pmt_t e5,
const pmt_t e6 
)

◆ make_tuple() [9/11]

PMT_API pmt_t pmt::make_tuple ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2,
const pmt_t e3,
const pmt_t e4,
const pmt_t e5,
const pmt_t e6,
const pmt_t e7 
)

◆ make_tuple() [10/11]

PMT_API pmt_t pmt::make_tuple ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2,
const pmt_t e3,
const pmt_t e4,
const pmt_t e5,
const pmt_t e6,
const pmt_t e7,
const pmt_t e8 
)

◆ make_tuple() [11/11]

PMT_API pmt_t pmt::make_tuple ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2,
const pmt_t e3,
const pmt_t e4,
const pmt_t e5,
const pmt_t e6,
const pmt_t e7,
const pmt_t e8,
const pmt_t e9 
)

◆ make_u16vector()

PMT_API pmt_t pmt::make_u16vector ( size_t  k,
uint16_t  fill 
)

◆ make_u32vector()

PMT_API pmt_t pmt::make_u32vector ( size_t  k,
uint32_t  fill 
)

◆ make_u64vector()

PMT_API pmt_t pmt::make_u64vector ( size_t  k,
uint64_t  fill 
)

◆ make_u8vector()

PMT_API pmt_t pmt::make_u8vector ( size_t  k,
uint8_t  fill 
)

◆ make_vector()

PMT_API pmt_t pmt::make_vector ( size_t  k,
pmt_t  fill 
)

Make a vector of length k, with initial values set to fill.

◆ map()

PMT_API pmt_t pmt::map ( pmt_t   procconst pmt_t &,
pmt_t  list 
)

Apply proc element-wise to the elements of list and returns a list of the results, in order.

list must be a list. The dynamic order in which proc is applied to the elements of list is unspecified.

◆ member()

PMT_API pmt_t pmt::member ( pmt_t  obj,
pmt_t  list 
)

Return the first sublist of list whose car is obj. If obj does not occur in list, then #f is returned. pmt::member use pmt::equal to compare obj with the elements of list.

◆ memq()

PMT_API pmt_t pmt::memq ( pmt_t  obj,
pmt_t  list 
)

Return the first sublist of list whose car is obj. If obj does not occur in list, then #f is returned. pmt::memq use pmt::eq to compare obj with the elements of list.

◆ memv()

PMT_API pmt_t pmt::memv ( pmt_t  obj,
pmt_t  list 
)

Return the first sublist of list whose car is obj. If obj does not occur in list, then #f is returned. pmt::memv use pmt::eqv to compare obj with the elements of list.

◆ mp() [1/21]

static pmt_t pmt::mp ( const char *  s)
inlinestatic

Make pmt symbol.

References string_to_symbol().

◆ mp() [2/21]

static pmt_t pmt::mp ( const pmt_t e0)
inlinestatic

Make tuple.

References make_tuple().

◆ mp() [3/21]

static pmt_t pmt::mp ( const pmt_t e0,
const pmt_t e1 
)
inlinestatic

Make tuple.

References make_tuple().

◆ mp() [4/21]

static pmt_t pmt::mp ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2 
)
inlinestatic

Make tuple.

References make_tuple().

◆ mp() [5/21]

static pmt_t pmt::mp ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2,
const pmt_t e3 
)
inlinestatic

Make tuple.

References make_tuple().

◆ mp() [6/21]

static pmt_t pmt::mp ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2,
const pmt_t e3,
const pmt_t e4 
)
inlinestatic

Make tuple.

References make_tuple().

◆ mp() [7/21]

static pmt_t pmt::mp ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2,
const pmt_t e3,
const pmt_t e4,
const pmt_t e5 
)
inlinestatic

Make tuple.

References make_tuple().

◆ mp() [8/21]

static pmt_t pmt::mp ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2,
const pmt_t e3,
const pmt_t e4,
const pmt_t e5,
const pmt_t e6 
)
inlinestatic

Make tuple.

References make_tuple().

◆ mp() [9/21]

static pmt_t pmt::mp ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2,
const pmt_t e3,
const pmt_t e4,
const pmt_t e5,
const pmt_t e6,
const pmt_t e7 
)
inlinestatic

Make tuple.

References make_tuple().

◆ mp() [10/21]

static pmt_t pmt::mp ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2,
const pmt_t e3,
const pmt_t e4,
const pmt_t e5,
const pmt_t e6,
const pmt_t e7,
const pmt_t e8 
)
inlinestatic

Make tuple.

References make_tuple().

◆ mp() [11/21]

static pmt_t pmt::mp ( const pmt_t e0,
const pmt_t e1,
const pmt_t e2,
const pmt_t e3,
const pmt_t e4,
const pmt_t e5,
const pmt_t e6,
const pmt_t e7,
const pmt_t e8,
const pmt_t e9 
)
inlinestatic

Make tuple.

References make_tuple().

◆ mp() [12/21]

static pmt_t pmt::mp ( const std::string &  s)
inlinestatic

◆ mp() [13/21]

static pmt_t pmt::mp ( const void *  data,
size_t  len_in_bytes 
)
inlinestatic

Make pmt Binary Large Object (BLOB)

References make_blob().

◆ mp() [14/21]

static pmt_t pmt::mp ( double  x)
inlinestatic

Make pmt double.

References from_double().

◆ mp() [15/21]

static pmt_t pmt::mp ( int  x)
inlinestatic

Make pmt long.

References from_long().

◆ mp() [16/21]

static pmt_t pmt::mp ( long long unsigned  x)
inlinestatic

Make pmt uint64.

References from_uint64().

◆ mp() [17/21]

static pmt_t pmt::mp ( long unsigned  x)
inlinestatic

Make pmt uint64.

References from_uint64().

◆ mp() [18/21]

static pmt_t pmt::mp ( long  x)
inlinestatic

Make pmt long.

References from_long().

◆ mp() [19/21]

static pmt_t pmt::mp ( std::complex< double >  z)
inlinestatic

Make pmt complex.

References make_rectangular().

◆ mp() [20/21]

static pmt_t pmt::mp ( std::complex< float >  z)
inlinestatic

Make pmt complex.

References make_rectangular().

◆ mp() [21/21]

static pmt_t pmt::mp ( std::shared_ptr< gr::messages::msg_accepter ma)
inlinestatic

Make pmt msg_accepter.

References make_msg_accepter().

◆ msg_accepter_ref()

PMT_API std::shared_ptr<gr::messages::msg_accepter> pmt::msg_accepter_ref ( const pmt_t obj)

Return underlying msg_accepter.

Referenced by gr::messages::send().

◆ nth()

PMT_API pmt_t pmt::nth ( size_t  n,
pmt_t  list 
)

locates nth element of
list where the car is the 'zeroth' element.

◆ nthcdr()

PMT_API pmt_t pmt::nthcdr ( size_t  n,
pmt_t  list 
)

returns the tail of list that would be obtained by calling cdr n times in succession.

◆ operator<<()

PMT_API std::ostream& pmt::operator<< ( std::ostream &  os,
pmt_t  obj 
)

◆ pmt_from_complex() [1/2]

PMT_API pmt_t pmt::pmt_from_complex ( const std::complex< double > &  z)

Return a complex number constructed of the given a complex number.

◆ pmt_from_complex() [2/2]

PMT_API pmt_t pmt::pmt_from_complex ( double  re,
double  im 
)

Return a complex number constructed of the given real and imaginary parts.

◆ print()

PMT_API void pmt::print ( pmt_t  v)

Write pmt string representation to stdout.

◆ read()

PMT_API pmt_t pmt::read ( std::istream &  port)

read converts external representations of pmt objects into the objects themselves. Read returns the next object parsable from the given input port, updating port to point to the first character past the end of the external representation of the object.

If an end of file is encountered in the input before any characters are found that can begin an object, then an end of file object is returned. The port remains open, and further attempts to read will also return an end of file object. If an end of file is encountered after the beginning of an object's external representation, but the external representation is incomplete and therefore not parsable, an error is signaled.

◆ reverse()

PMT_API pmt_t pmt::reverse ( pmt_t  list)

reverse list.

list must be a proper list.

◆ reverse_x()

PMT_API pmt_t pmt::reverse_x ( pmt_t  list)

destructively reverse list.

list must be a proper list.

◆ s16vector_elements() [1/2]

const PMT_API std::vector<int16_t> pmt::s16vector_elements ( pmt_t  v)

◆ s16vector_elements() [2/2]

const PMT_API int16_t* pmt::s16vector_elements ( pmt_t  v,
size_t &  len 
)

◆ s16vector_ref()

PMT_API int16_t pmt::s16vector_ref ( pmt_t  v,
size_t  k 
)

◆ s16vector_set()

PMT_API void pmt::s16vector_set ( pmt_t  v,
size_t  k,
int16_t  x 
)

◆ s16vector_writable_elements()

PMT_API int16_t* pmt::s16vector_writable_elements ( pmt_t  v,
size_t &  len 
)

◆ s32vector_elements() [1/2]

const PMT_API std::vector<int32_t> pmt::s32vector_elements ( pmt_t  v)

◆ s32vector_elements() [2/2]

const PMT_API int32_t* pmt::s32vector_elements ( pmt_t  v,
size_t &  len 
)

◆ s32vector_ref()

PMT_API int32_t pmt::s32vector_ref ( pmt_t  v,
size_t  k 
)

◆ s32vector_set()

PMT_API void pmt::s32vector_set ( pmt_t  v,
size_t  k,
int32_t  x 
)

◆ s32vector_writable_elements()

PMT_API int32_t* pmt::s32vector_writable_elements ( pmt_t  v,
size_t &  len 
)

◆ s64vector_elements() [1/2]

const PMT_API std::vector<int64_t> pmt::s64vector_elements ( pmt_t  v)

◆ s64vector_elements() [2/2]

const PMT_API int64_t* pmt::s64vector_elements ( pmt_t  v,
size_t &  len 
)

◆ s64vector_ref()

PMT_API int64_t pmt::s64vector_ref ( pmt_t  v,
size_t  k 
)

◆ s64vector_set()

PMT_API void pmt::s64vector_set ( pmt_t  v,
size_t  k,
int64_t  x 
)

◆ s64vector_writable_elements()

PMT_API int64_t* pmt::s64vector_writable_elements ( pmt_t  v,
size_t &  len 
)

◆ s8vector_elements() [1/2]

const PMT_API std::vector<int8_t> pmt::s8vector_elements ( pmt_t  v)

◆ s8vector_elements() [2/2]

const PMT_API int8_t* pmt::s8vector_elements ( pmt_t  v,
size_t &  len 
)

◆ s8vector_ref()

PMT_API int8_t pmt::s8vector_ref ( pmt_t  v,
size_t  k 
)

◆ s8vector_set()

PMT_API void pmt::s8vector_set ( pmt_t  v,
size_t  k,
int8_t  x 
)

◆ s8vector_writable_elements()

PMT_API int8_t* pmt::s8vector_writable_elements ( pmt_t  v,
size_t &  len 
)

◆ serialize()

PMT_API bool pmt::serialize ( pmt_t  obj,
std::streambuf &  sink 
)

Write portable byte-serial representation of obj to sink.

◆ serialize_str()

PMT_API std::string pmt::serialize_str ( pmt_t  obj)

Provide a simple string generating interface to pmt's serialize function.

◆ set_car()

PMT_API void pmt::set_car ( pmt_t  pair,
pmt_t  value 
)

Stores value in the car field of pair.

◆ set_cdr()

PMT_API void pmt::set_cdr ( pmt_t  pair,
pmt_t  value 
)

Stores value in the cdr field of pair.

◆ string_to_symbol()

PMT_API pmt_t pmt::string_to_symbol ( const std::string &  s)

Return the symbol whose name is s.

Referenced by mp().

◆ subsetp()

PMT_API bool pmt::subsetp ( pmt_t  list1,
pmt_t  list2 
)

Return true if every element of list1 appears in list2, and false otherwise. Comparisons are done with pmt::eqv.

◆ symbol_to_string()

const PMT_API std::string pmt::symbol_to_string ( const pmt_t sym)

If is a symbol, return the name of the symbol as a string. Otherwise, raise the wrong_type exception.

Referenced by gr::msg_endpoint::identifier(), and rpcbasic_extractor< T, std::string >::post().

◆ to_bool()

PMT_API bool pmt::to_bool ( pmt_t  val)

Return true if val is pmt::True, return false when val is pmt::PMT_F,.

Referenced by rpcbasic_extractor< T, bool >::post().

◆ to_complex()

PMT_API std::complex<double> pmt::to_complex ( pmt_t  z)

If z is complex, real or integer, return the closest complex<double>. Otherwise, raise the wrong_type exception.

Referenced by rpcbasic_extractor< T, std::complex< float > >::post(), and rpcbasic_extractor< T, std::complex< double > >::post().

◆ to_double()

PMT_API double pmt::to_double ( pmt_t  x)

Convert pmt to double if possible.

Returns the number closest to val that is representable as a double. The argument val must be a real or integer, otherwise a wrong_type exception is raised.

Referenced by rpcbasic_extractor< T, double >::post(), and rpcbasic_extractor< T, float >::post().

◆ to_float()

PMT_API float pmt::to_float ( pmt_t  x)

Convert pmt to float if possible.

This basically is to_double() with a type-cast; the PMT stores the value as a double in any case. Use this when strict typing is required.

◆ to_long()

PMT_API long pmt::to_long ( pmt_t  x)

Convert pmt to long if possible.

When x represents an exact integer that fits in a long, return that integer. Else raise an exception, either wrong_type when x is not an exact integer, or out_of_range when it doesn't fit.

Referenced by rpcbasic_extractor< T, char >::post(), rpcbasic_extractor< T, short >::post(), rpcbasic_extractor< T, long >::post(), and rpcbasic_extractor< T, int >::post().

◆ to_tuple()

PMT_API pmt_t pmt::to_tuple ( const pmt_t x)

If x is a vector or proper list, return a tuple containing the elements of x

◆ to_uint64()

PMT_API uint64_t pmt::to_uint64 ( pmt_t  x)

Convert pmt to uint64 if possible.

When x represents an exact integer that fits in a uint64, return that uint64. Else raise an exception, either wrong_type when x is not an exact uint64, or out_of_range when it doesn't fit.

◆ tuple_ref()

PMT_API pmt_t pmt::tuple_ref ( const pmt_t tuple,
size_t  k 
)

Return the contents of position k of tuple. k must be a valid index of tuple.

◆ u16vector_elements() [1/2]

const PMT_API std::vector<uint16_t> pmt::u16vector_elements ( pmt_t  v)

◆ u16vector_elements() [2/2]

const PMT_API uint16_t* pmt::u16vector_elements ( pmt_t  v,
size_t &  len 
)

◆ u16vector_ref()

PMT_API uint16_t pmt::u16vector_ref ( pmt_t  v,
size_t  k 
)

◆ u16vector_set()

PMT_API void pmt::u16vector_set ( pmt_t  v,
size_t  k,
uint16_t  x 
)

◆ u16vector_writable_elements()

PMT_API uint16_t* pmt::u16vector_writable_elements ( pmt_t  v,
size_t &  len 
)

◆ u32vector_elements() [1/2]

const PMT_API std::vector<uint32_t> pmt::u32vector_elements ( pmt_t  v)

◆ u32vector_elements() [2/2]

const PMT_API uint32_t* pmt::u32vector_elements ( pmt_t  v,
size_t &  len 
)

◆ u32vector_ref()

PMT_API uint32_t pmt::u32vector_ref ( pmt_t  v,
size_t  k 
)

◆ u32vector_set()

PMT_API void pmt::u32vector_set ( pmt_t  v,
size_t  k,
uint32_t  x 
)

◆ u32vector_writable_elements()

PMT_API uint32_t* pmt::u32vector_writable_elements ( pmt_t  v,
size_t &  len 
)

◆ u64vector_elements() [1/2]

const PMT_API std::vector<uint64_t> pmt::u64vector_elements ( pmt_t  v)

◆ u64vector_elements() [2/2]

const PMT_API uint64_t* pmt::u64vector_elements ( pmt_t  v,
size_t &  len 
)

◆ u64vector_ref()

PMT_API uint64_t pmt::u64vector_ref ( pmt_t  v,
size_t  k 
)

◆ u64vector_set()

PMT_API void pmt::u64vector_set ( pmt_t  v,
size_t  k,
uint64_t  x 
)

◆ u64vector_writable_elements()

PMT_API uint64_t* pmt::u64vector_writable_elements ( pmt_t  v,
size_t &  len 
)

◆ u8vector_elements() [1/2]

const PMT_API std::vector<uint8_t> pmt::u8vector_elements ( pmt_t  v)

◆ u8vector_elements() [2/2]

const PMT_API uint8_t* pmt::u8vector_elements ( pmt_t  v,
size_t &  len 
)

◆ u8vector_ref()

PMT_API uint8_t pmt::u8vector_ref ( pmt_t  v,
size_t  k 
)

◆ u8vector_set()

PMT_API void pmt::u8vector_set ( pmt_t  v,
size_t  k,
uint8_t  x 
)

◆ u8vector_writable_elements()

PMT_API uint8_t* pmt::u8vector_writable_elements ( pmt_t  v,
size_t &  len 
)

◆ uniform_vector_elements()

const PMT_API void* pmt::uniform_vector_elements ( pmt_t  v,
size_t &  len 
)

◆ uniform_vector_itemsize()

PMT_API size_t pmt::uniform_vector_itemsize ( pmt_t  x)

item size in bytes if x is any kind of uniform numeric vector

◆ uniform_vector_writable_elements()

PMT_API void* pmt::uniform_vector_writable_elements ( pmt_t  v,
size_t &  len 
)

◆ vector_fill()

PMT_API void pmt::vector_fill ( pmt_t  vector,
pmt_t  fill 
)

Store fill in every position of vector.

◆ vector_ref()

PMT_API pmt_t pmt::vector_ref ( pmt_t  vector,
size_t  k 
)

Return the contents of position k of vector. k must be a valid index of vector.

◆ vector_set()

PMT_API void pmt::vector_set ( pmt_t  vector,
size_t  k,
pmt_t  obj 
)

Store obj in position k.

◆ write()

PMT_API void pmt::write ( pmt_t  obj,
std::ostream &  port 
)

Write a written representation of obj to the given port.

◆ write_string()

PMT_API std::string pmt::write_string ( pmt_t  obj)

Return a string representation of obj. This is the same output as would be generated by pmt::write.