Loading...
Searching...
No Matches
pmt Namespace Reference

## Classes

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

## Typedefs

typedef std::shared_ptr< pmt_base > | pmt_t
| typedef for shared pointer (transparent reference counting).

## 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.
PMT_API bool | is_true (pmt_t obj)
| Return false if obj is #f, else return true.
PMT_API bool | is_false (pmt_t obj)
| Return true if obj is #f, else return true.
PMT_API pmt_t | from_bool (bool val)
| Return #f is val is false, else return #t.
PMT_API bool | to_bool (pmt_t val)
| Return true if val is pmt::True, return false when val is pmt::PMT_F,.
PMT_API bool | is_symbol (const pmt_t &obj)
| Return true if obj is a symbol, else false.
PMT_API pmt_t | string_to_symbol (const std::string &s)
| Return the symbol whose name is `s`.
PMT_API pmt_t | intern (const std::string &s)
| Alias for pmt_string_to_symbol.
PMT_API const 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.
PMT_API bool | is_integer (pmt_t x)
| Return true if `x` is an integer number, else false.
PMT_API pmt_t | from_long (long x)
| Return the pmt value that represents the integer `x`.
PMT_API long | to_long (pmt_t x)
| Convert pmt to long if possible.
PMT_API bool | is_uint64 (pmt_t x)
| Return true if `x` is an uint64 number, else false.
PMT_API pmt_t | from_uint64 (uint64_t x)
| Return the pmt value that represents the uint64 `x`.
PMT_API uint64_t | to_uint64 (pmt_t x)
| Convert pmt to uint64 if possible.
PMT_API bool | is_real (pmt_t obj)
PMT_API pmt_t | from_double (double x)
| Return the pmt value that represents double `x`.
PMT_API pmt_t | from_float (float x)
PMT_API double | to_double (pmt_t x)
| Convert pmt to double if possible.
PMT_API float | to_float (pmt_t x)
| Convert pmt to float if possible.
PMT_API bool | is_complex (pmt_t obj)
| return true if `obj` is a complex number, false otherwise.
PMT_API pmt_t | make_rectangular (double re, double im)
| Return a complex number constructed of the given real and imaginary parts.
PMT_API pmt_t | from_complex (double re, double im)
| Return a complex number constructed of the given real and imaginary parts.
PMT_API pmt_t | from_complex (const std::complex< double > &z)
| Return a complex number constructed of the given a complex number.
PMT_API pmt_t | pmt_from_complex (double re, double im)
| Return a complex number constructed of the given real and imaginary parts.
PMT_API pmt_t | pmt_from_complex (const std::complex< double > &z)
| Return a complex number constructed of the given a complex number.
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.
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).
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`.
PMT_API pmt_t | car (const pmt_t &pair)
| If `pair` is a pair, return the car of the `pair`, otherwise raise wrong_type.
PMT_API pmt_t | cdr (const pmt_t &pair)
| If `pair` is a pair, return the cdr of the `pair`, otherwise raise wrong_type.
PMT_API void | set_car (pmt_t pair, pmt_t value)
| Stores `value` in the car field of `pair`.
PMT_API void | set_cdr (pmt_t pair, pmt_t value)
| Stores `value` in the cdr field of `pair`.
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.
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.
PMT_API pmt_t | make_vector (size_t k, pmt_t fill)
| Make a vector of length `k`, with initial values set to `fill`.
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`.
PMT_API void | vector_fill (pmt_t vector, pmt_t fill)
| Store `fill` in every position of `vector`.
PMT_API bool | is_blob (pmt_t x)
| Return true if `x` is a blob, otherwise false.
PMT_API pmt_t | make_blob (const void *buf, size_t len)
| Make a blob given a pointer and length in bytes.
PMT_API const void * | blob_data (pmt_t blob)
| Return a pointer to the blob's data.
PMT_API size_t | blob_length (pmt_t blob)
| Return the blob's length in bytes.
PMT_API bool | is_uniform_vector (pmt_t x)
| true if `x` is any kind of uniform numeric vector
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
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)
PMT_API const void * | uniform_vector_elements (pmt_t v, size_t &len)
PMT_API const uint8_t * | u8vector_elements (pmt_t v, size_t &len)
PMT_API const int8_t * | s8vector_elements (pmt_t v, size_t &len)
PMT_API const uint16_t * | u16vector_elements (pmt_t v, size_t &len)
PMT_API const int16_t * | s16vector_elements (pmt_t v, size_t &len)
PMT_API const uint32_t * | u32vector_elements (pmt_t v, size_t &len)
PMT_API const int32_t * | s32vector_elements (pmt_t v, size_t &len)
PMT_API const uint64_t * | u64vector_elements (pmt_t v, size_t &len)
PMT_API const int64_t * | s64vector_elements (pmt_t v, size_t &len)
PMT_API const float * | f32vector_elements (pmt_t v, size_t &len)
PMT_API const double * | f64vector_elements (pmt_t v, size_t &len)
PMT_API const std::complex< float > * | c32vector_elements (pmt_t v, size_t &len)
PMT_API const std::complex< double > * | c64vector_elements (pmt_t v, size_t &len)
PMT_API const std::vector< uint8_t > | u8vector_elements (pmt_t v)
PMT_API const std::vector< int8_t > | s8vector_elements (pmt_t v)
PMT_API const std::vector< uint16_t > | u16vector_elements (pmt_t v)
PMT_API const std::vector< int16_t > | s16vector_elements (pmt_t v)
PMT_API const std::vector< uint32_t > | u32vector_elements (pmt_t v)
PMT_API const std::vector< int32_t > | s32vector_elements (pmt_t v)
PMT_API const std::vector< uint64_t > | u64vector_elements (pmt_t v)
PMT_API const std::vector< int64_t > | s64vector_elements (pmt_t v)
PMT_API const std::vector< float > | f32vector_elements (pmt_t v)
PMT_API const std::vector< double > | f64vector_elements (pmt_t v)
PMT_API const std::vector< std::complex< float > > | c32vector_elements (pmt_t v)
PMT_API const 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.
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`.
PMT_API pmt_t | make_dict ()
| Make an empty dictionary.
template<typename map_t>
pmt_t | dict_from_mapping (const map_t &prototype)
| Make a dictionary from an existing mapping type. The constraint for this to work is the ability for the map_t to iterate over [key, value] pairs, that is, to be able to be used in a.
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`.
PMT_API pmt_t | dict_delete (const pmt_t &dict, const pmt_t &key)
| Return a new dictionary with `key` removed.
PMT_API bool | dict_has_key (const pmt_t &dict, const pmt_t &key)
| Return true if `key` exists in `dict`.
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`.
PMT_API pmt_t | dict_items (pmt_t dict)
| Return list of (key . value) pairs.
PMT_API pmt_t | dict_keys (pmt_t dict)
| Return list of keys.
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.
PMT_API pmt_t | dict_values (pmt_t dict)
| Return list of values.
PMT_API bool | is_any (pmt_t obj)
| Return true if `obj` is an any.
PMT_API pmt_t | make_any (const boost::any &any)
| make an any
PMT_API boost::any | any_ref (pmt_t obj)
| Return underlying boost::any.
PMT_API void | any_set (pmt_t obj, const boost::any &any)
| Store `any` in `obj`.
PMT_API bool | is_msg_accepter (const pmt_t &obj)
| Return true if `obj` is a msg_accepter.
PMT_API pmt_t | make_msg_accepter (std::shared_ptr< gr::messages::msg_accepter > ma)
| make a msg_accepter
PMT_API std::shared_ptr< gr::messages::msg_accepter > | msg_accepter_ref (const pmt_t &obj)
| Return underlying msg_accepter.
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.
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.
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.
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.
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.
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.
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.
PMT_API pmt_t | reverse (pmt_t list)
| reverse `list`.
PMT_API pmt_t | reverse_x (pmt_t list)
| destructively reverse `list`.
static pmt_t | acons (pmt_t x, pmt_t y, pmt_t a)
| (acons x y a) == (cons (cons x y) a)
PMT_API pmt_t | nth (size_t n, pmt_t list)
| locates `nth` element of list where the car is the 'zeroth' element.
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.
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`.
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`.
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`.
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.
PMT_API pmt_t | list1 (const pmt_t &x1)
| Return a list of length 1 containing `x1`, that is cons(x1, NIL) Note that PMT lists are nested pairs. Use pmt::make_tuple to generate a list in the common sense.
PMT_API pmt_t | list2 (const pmt_t &x1, const pmt_t &x2)
| Return a list of length 2 containing `x1`, `x2`, that is cons(x1, cons(x2, NIL)) Note that PMT lists are nested pairs. Use pmt::make_tuple to generate a list in the common sense.
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`, that is cons(x1, cons(x2, cons(x3, NIL))) Note that PMT lists are nested pairs. Use pmt::make_tuple to generate a list in the common sense.
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`, that is cons(x1, cons(x2, cons(x3, cons(x4, NIL)))) Note that PMT lists are nested pairs. Use pmt::make_tuple to generate a list in the common sense.
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`, that is cons(x1, cons(x2, cons(x3, cons(x4, cons(x5, NIL))))) Note that PMT lists are nested pairs. Use pmt::make_tuple to generate a list in the common sense.
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`, that is cons(x1, cons(x2, cons(x3, cons(x4, cons(x5, cons(x6, NIL)))))) Note that PMT lists are nested pairs. Use pmt::make_tuple to generate a list in the common sense.
PMT_API pmt_t | list_add (pmt_t list, const pmt_t &item)
| Return `list` with `item` added to it. Note that PMT lists are nested pairs, e.g. cons(x1, cons(x2, cons(x3, NIL))) Use pmt::make_tuple to generate a list in the common sense.
PMT_API pmt_t | list_rm (pmt_t list, const pmt_t &item)
| Return `list` with `item` removed from it.
PMT_API bool | list_has (pmt_t list, const pmt_t &item)
| Return bool of `list` contains `item`.
PMT_API bool | is_eof_object (pmt_t obj)
| return true if obj is the EOF object, otherwise return false.
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.
PMT_API bool | serialize (pmt_t obj, std::streambuf &sink)
| Write portable byte-serial representation of `obj` to `sink`.
PMT_API pmt_t | deserialize (std::streambuf &source)
| Create obj from portable byte-serial representation.
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.
PMT_API pmt_t | deserialize_str (std::string str)
| Provide a simple string generating interface to pmt's deserialize function.
static pmt_t | mp (const std::string &s)
| Make pmt symbol.
static pmt_t | mp (const char *s)
| Make pmt symbol.
static pmt_t | mp (long x)
| Make pmt long.
static pmt_t | mp (long unsigned x)
| Make pmt uint64.
static pmt_t | mp (long long unsigned x)
| Make pmt uint64.
static pmt_t | mp (int x)
| Make pmt long.
static pmt_t | mp (double x)
| Make pmt double.
static pmt_t | mp (std::complex< double > z)
| Make pmt complex.
static pmt_t | mp (std::complex< float > z)
| Make pmt complex.
static pmt_t | mp (std::shared_ptr< gr::messages::msg_accepter > ma)
| Make pmt msg_accepter.
static pmt_t | mp (const void *data, size_t len_in_bytes)
| Make pmt Binary Large Object (BLOB).
static pmt_t | mp (const pmt_t &e0)
| Make tuple.
static pmt_t | mp (const pmt_t &e0, const pmt_t &e1)
| Make tuple.
static pmt_t | mp (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2)
| Make tuple.
static pmt_t | mp (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3)
| Make tuple.
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.
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.
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.
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.
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.
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.

## 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()

pmt_t pmt::acons | ( | pmt_t | x,
|  | pmt_t | y,
|  | pmt_t | a )

inline static

(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.

References PMT_API.

## any_set()

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

Store `any` in `obj`.

References PMT_API.

## 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`.

References PMT_API.

## 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`.

References PMT_API.

## 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`.

References PMT_API.

## blob_data()

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

Return a pointer to the blob's data.

References PMT_API.

## blob_length()

PMT_API size_t pmt::blob_length | ( | pmt_t | blob | ) |

Return the blob's length in bytes.

References PMT_API.

## c32vector_elements() [1/2]

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

References PMT_API.

## c32vector_elements() [2/2]

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

References PMT_API.

## c32vector_ref()

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

References PMT_API.

## c32vector_set()

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

References PMT_API.

## c32vector_writable_elements()

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

References PMT_API.

## c64vector_elements() [1/2]

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

References PMT_API.

## c64vector_elements() [2/2]

PMT_API const 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 )

References PMT_API.

## c64vector_set()

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

References PMT_API.

## 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 | ) |

References PMT_API.

## cadddr()

PMT_API pmt_t pmt::cadddr | ( | pmt_t | pair | ) |

References PMT_API.

## caddr()

PMT_API pmt_t pmt::caddr | ( | pmt_t | pair | ) |

References PMT_API.

## cadr()

PMT_API pmt_t pmt::cadr | ( | pmt_t | pair | ) |

References PMT_API.

## 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.

References PMT_API.

## cdar()

PMT_API pmt_t pmt::cdar | ( | pmt_t | pair | ) |

References PMT_API.

## cddr()

PMT_API pmt_t pmt::cddr | ( | pmt_t | pair | ) |

References PMT_API.

## 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.

References PMT_API.

## 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`.

References PMT_API.

Referenced by acons().

## 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`.

References PMT_API.

Referenced by acons().

## deserialize()

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

Create obj from portable byte-serial representation.

References PMT_API.

## deserialize_str()

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

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

References PMT_API.

## 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`.

References PMT_API.

Referenced by dict_from_mapping().

## dict_delete()

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

Return a new dictionary with `key` removed.

References PMT_API.

## dict_from_mapping()

template<typename map_t>

pmt_t pmt::dict_from_mapping | ( | const map_t & | prototype | ) |

Make a dictionary from an existing mapping type. The constraint for this to work is the ability for the map_t to iterate over [key, value] pairs, that is, to be able to be used in a.

    for(const auto& [key, val] : prototype)

loop.

References dict_add(), and make_dict().

## 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`.

References PMT_API.

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.

References PMT_API.

## dict_keys()

PMT_API pmt_t pmt::dict_keys | ( | pmt_t | dict | ) |

Return list of keys.

References PMT_API.

## 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`.

References PMT_API.

## 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.

References PMT_API.

## dict_values()

PMT_API pmt_t pmt::dict_values | ( | pmt_t | dict | ) |

Return list of values.

References PMT_API.

## dump_sizeof()

PMT_API void pmt::dump_sizeof | ( |  | ) |

References PMT_API.

## 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.

References PMT_API.

## 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.

References PMT_API.

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.

References PMT_API.

Referenced by gr::msg_queue_comparator::operator()(), and pmt::comparator::operator()().

## f32vector_elements() [1/2]

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

References PMT_API.

## f32vector_elements() [2/2]

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

References PMT_API.

## f32vector_ref()

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

References PMT_API.

## f32vector_set()

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

References PMT_API.

## f32vector_writable_elements()

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

References PMT_API.

## f64vector_elements() [1/2]

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

References PMT_API.

## f64vector_elements() [2/2]

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

References PMT_API.

## f64vector_ref()

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

References PMT_API.

## f64vector_set()

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

References PMT_API.

## f64vector_writable_elements()

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

References PMT_API.

## from_bool()

PMT_API pmt_t pmt::from_bool | ( | bool | val | ) |

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

References PMT_API.

## 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.

References PMT_API.

## 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.

References PMT_API.

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

## from_double()

PMT_API pmt_t pmt::from_double | ( | double | x | ) |

Return the pmt value that represents double `x`.

References PMT_API.

Referenced by mp().

## from_float()

PMT_API pmt_t pmt::from_float | ( | float | x | ) |

References PMT_API.

## from_long()

PMT_API pmt_t pmt::from_long | ( | long | x | ) |

Return the pmt value that represents the integer `x`.

References PMT_API.

Referenced by mp(), and mp().

## from_uint64()

PMT_API pmt_t pmt::from_uint64 | ( | uint64_t | x | ) |

Return the pmt value that represents the uint64 `x`.

References PMT_API.

Referenced by mp(), mp(), and rpcbasic_inserter< T, uint64_t >::retrieve().

## get_PMT_EOF()

PMT_API pmt_t pmt::get_PMT_EOF | ( |  | ) |

References PMT_API.

## get_PMT_F()

PMT_API pmt_t pmt::get_PMT_F | ( |  | ) |

References PMT_API.

## get_PMT_NIL()

PMT_API pmt_t pmt::get_PMT_NIL | ( |  | ) |

References PMT_API.

## get_PMT_T()

PMT_API pmt_t pmt::get_PMT_T | ( |  | ) |

References PMT_API.

## init_c32vector() [1/2]

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

References PMT_API.

Referenced by pmt_assist< myType >::make(), and rpcbasic_inserter< T, std::vector< std::complex< float > > >::retrieve().

## init_c32vector() [2/2]

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

References PMT_API.

## init_c64vector() [1/2]

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

References PMT_API.

## init_c64vector() [2/2]

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

References PMT_API.

## init_f32vector() [1/2]

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

References PMT_API.

Referenced by pmt_assist< myType >::make(), and rpcbasic_inserter< T, std::vector< float > >::retrieve().

## init_f32vector() [2/2]

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

References PMT_API.

## init_f64vector() [1/2]

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

References PMT_API.

## init_f64vector() [2/2]

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

References PMT_API.

## init_s16vector() [1/2]

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

References PMT_API.

Referenced by rpcbasic_inserter< T, std::vector< short > >::retrieve().

## init_s16vector() [2/2]

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

References PMT_API.

## init_s32vector() [1/2]

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

References PMT_API.

Referenced by rpcbasic_inserter< T, std::vector< int > >::retrieve().

## init_s32vector() [2/2]

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

References PMT_API.

## init_s64vector() [1/2]

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

References PMT_API.

Referenced by rpcbasic_inserter< T, std::vector< int64_t > >::retrieve().

## init_s64vector() [2/2]

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

References PMT_API.

## init_s8vector() [1/2]

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

References PMT_API.

Referenced by rpcbasic_inserter< T, std::vector< signed char > >::retrieve().

## init_s8vector() [2/2]

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

References PMT_API.

## init_u16vector() [1/2]

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

References PMT_API.

## init_u16vector() [2/2]

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

References PMT_API.

## init_u32vector() [1/2]

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

References PMT_API.

## init_u32vector() [2/2]

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

References PMT_API.

## init_u64vector() [1/2]

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

References PMT_API.

## init_u64vector() [2/2]

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

References PMT_API.

## init_u8vector() [1/2]

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

References PMT_API.

## init_u8vector() [2/2]

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

References PMT_API.

Referenced by rpcbasic_inserter< T, std::vector< uint8_t > >::retrieve().

## intern()

PMT_API pmt_t pmt::intern | ( | const std::string & | s | ) |

Alias for pmt_string_to_symbol.

References PMT_API.

Referenced by gr::basic_block::alias_pmt(), gr::blocks::tags_strobe::make(), rpcbasic_register_get< T, Tfrom >::rpcbasic_register_get(), rpcbasic_register_get< T, Tfrom >::rpcbasic_register_get(), rpcbasic_register_handler< T >::rpcbasic_register_handler(), rpcbasic_register_set< T, Tto >::rpcbasic_register_set(), and rpcbasic_register_trigger< T >::rpcbasic_register_trigger().

## is_any()

PMT_API bool pmt::is_any | ( | pmt_t | obj | ) |

Return true if `obj` is an any.

References PMT_API.

## is_blob()

PMT_API bool pmt::is_blob | ( | pmt_t | x | ) |

Return true if `x` is a blob, otherwise false.

References PMT_API.

## is_bool()

PMT_API bool pmt::is_bool | ( | pmt_t | obj | ) |

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

References PMT_API.

## is_c32vector()

PMT_API bool pmt::is_c32vector | ( | pmt_t | x | ) |

References PMT_API.

## is_c64vector()

PMT_API bool pmt::is_c64vector | ( | pmt_t | x | ) |

References PMT_API.

## is_complex()

PMT_API bool pmt::is_complex | ( | pmt_t | obj | ) |

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

References PMT_API.

## is_dict()

PMT_API bool pmt::is_dict | ( | const pmt_t & | obj | ) |

Return true if `obj` is a dictionary.

References PMT_API.

## is_eof_object()

PMT_API bool pmt::is_eof_object | ( | pmt_t | obj | ) |

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

References PMT_API.

## is_f32vector()

PMT_API bool pmt::is_f32vector | ( | pmt_t | x | ) |

References PMT_API.

## is_f64vector()

PMT_API bool pmt::is_f64vector | ( | pmt_t | x | ) |

References PMT_API.

## is_false()

PMT_API bool pmt::is_false | ( | pmt_t | obj | ) |

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

References PMT_API.

## is_integer()

PMT_API bool pmt::is_integer | ( | pmt_t | x | ) |

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

References PMT_API.

## is_msg_accepter()

PMT_API bool pmt::is_msg_accepter | ( | const pmt_t & | obj | ) |

Return true if `obj` is a msg_accepter.

References PMT_API.

## is_null()

PMT_API bool pmt::is_null | ( | const pmt_t & | x | ) |

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

References PMT_API.

## is_number()

PMT_API bool pmt::is_number | ( | pmt_t | obj | ) |

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

References PMT_API.

## 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).

References PMT_API.

## 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

References PMT_API.

## is_real()

PMT_API bool pmt::is_real | ( | pmt_t | obj | ) |

References PMT_API.

## is_s16vector()

PMT_API bool pmt::is_s16vector | ( | pmt_t | x | ) |

References PMT_API.

## is_s32vector()

PMT_API bool pmt::is_s32vector | ( | pmt_t | x | ) |

References PMT_API.

## is_s64vector()

PMT_API bool pmt::is_s64vector | ( | pmt_t | x | ) |

References PMT_API.

## is_s8vector()

PMT_API bool pmt::is_s8vector | ( | pmt_t | x | ) |

References PMT_API.

## is_symbol()

PMT_API bool pmt::is_symbol | ( | const pmt_t & | obj | ) |

Return true if obj is a symbol, else false.

References PMT_API.

## is_true()

PMT_API bool pmt::is_true | ( | pmt_t | obj | ) |

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

References PMT_API.

## is_tuple()

PMT_API bool pmt::is_tuple | ( | pmt_t | x | ) |

Return true if `x` is a tuple, otherwise false.

References PMT_API.

## is_u16vector()

PMT_API bool pmt::is_u16vector | ( | pmt_t | x | ) |

References PMT_API.

## is_u32vector()

PMT_API bool pmt::is_u32vector | ( | pmt_t | x | ) |

References PMT_API.

## is_u64vector()

PMT_API bool pmt::is_u64vector | ( | pmt_t | x | ) |

References PMT_API.

## is_u8vector()

PMT_API bool pmt::is_u8vector | ( | pmt_t | x | ) |

References PMT_API.

## is_uint64()

PMT_API bool pmt::is_uint64 | ( | pmt_t | x | ) |

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

References PMT_API.

## 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>

References PMT_API.

## is_vector()

PMT_API bool pmt::is_vector | ( | pmt_t | x | ) |

Return true if `x` is a vector, otherwise false.

References PMT_API.

## length()

PMT_API size_t pmt::length | ( | const pmt_t & | v | ) |

Return the number of elements in v.

References PMT_API.

## list1()

PMT_API pmt_t pmt::list1 | ( | const pmt_t & | x1 | ) |

Return a list of length 1 containing `x1`, that is cons(x1, NIL) Note that PMT lists are nested pairs. Use pmt::make_tuple to generate a list in the common sense.

References PMT_API.

Referenced by subsetp().

## list2()

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

Return a list of length 2 containing `x1`, `x2`, that is cons(x1, cons(x2, NIL)) Note that PMT lists are nested pairs. Use pmt::make_tuple to generate a list in the common sense.

References PMT_API.

Referenced by subsetp().

## 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`, that is cons(x1, cons(x2, cons(x3, NIL))) Note that PMT lists are nested pairs. Use pmt::make_tuple to generate a list in the common sense.

References PMT_API.

## 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`, that is cons(x1, cons(x2, cons(x3, cons(x4, NIL)))) Note that PMT lists are nested pairs. Use pmt::make_tuple to generate a list in the common sense.

References PMT_API.

## 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`, that is cons(x1, cons(x2, cons(x3, cons(x4, cons(x5, NIL))))) Note that PMT lists are nested pairs. Use pmt::make_tuple to generate a list in the common sense.

References PMT_API.

## 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`, that is cons(x1, cons(x2, cons(x3, cons(x4, cons(x5, cons(x6, NIL)))))) Note that PMT lists are nested pairs. Use pmt::make_tuple to generate a list in the common sense.

References PMT_API.

## list_add()

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

Return `list` with `item` added to it. Note that PMT lists are nested pairs, e.g. cons(x1, cons(x2, cons(x3, NIL))) Use pmt::make_tuple to generate a list in the common sense.

References PMT_API.

Referenced by gr::hier_block2::message_port_register_hier_in(), and gr::hier_block2::message_port_register_hier_out().

## list_has()

PMT_API bool pmt::list_has | ( | pmt_t | list,
|  | const pmt_t & | item )

Return bool of `list` contains `item`.

References PMT_API.

Referenced by gr::hier_block2::message_port_is_hier_in(), gr::hier_block2::message_port_is_hier_out(), gr::hier_block2::message_port_register_hier_in(), and gr::hier_block2::message_port_register_hier_out().

## list_rm()

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

Return `list` with `item` removed from it.

References PMT_API.

## make_any()

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

make an any

References PMT_API.

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

  buf | is the pointer to data to use to create blob
  len | is the size of the data in bytes.

The data is copied into the blob.

References PMT_API.

Referenced by mp().

## make_c32vector()

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

References PMT_API.

## make_c64vector()

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

References PMT_API.

## make_dict()

PMT_API pmt_t pmt::make_dict | ( |  | ) |

Make an empty dictionary.

References PMT_API.

Referenced by dict_from_mapping(), and gr::blocks::file_meta_sink::make().

## make_f32vector()

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

References PMT_API.

## make_f64vector()

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

References PMT_API.

## make_msg_accepter()

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

make a msg_accepter

References PMT_API.

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.

References PMT_API.

Referenced by mp(), and mp().

## make_s16vector()

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

References PMT_API.

## make_s32vector()

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

References PMT_API.

## make_s64vector()

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

References PMT_API.

## make_s8vector()

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

References PMT_API.

## make_tuple() [1/11]

PMT_API pmt_t pmt::make_tuple | ( |  | ) |

References PMT_API.

Referenced by mp(), mp(), mp(), mp(), mp(), mp(), mp(), mp(), mp(), and mp().

## make_tuple() [2/11]

PMT_API pmt_t pmt::make_tuple | ( | const pmt_t & | e0 | ) |

References PMT_API.

## make_tuple() [3/11]

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

References PMT_API.

## make_tuple() [4/11]

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

References PMT_API.

## 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 )

References PMT_API.

## 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 )

References PMT_API.

## 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 )

References PMT_API.

## 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 )

References PMT_API.

## 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 )

References PMT_API.

## 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 )

References PMT_API.

## 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 )

References PMT_API.

## make_u16vector()

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

References PMT_API.

## make_u32vector()

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

References PMT_API.

## make_u64vector()

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

References PMT_API.

## make_u8vector()

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

References PMT_API.

## 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`.

References PMT_API.

## 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.

References PMT_API.

## 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`.

References PMT_API.

## 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`.

References PMT_API.

## 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`.

References PMT_API.

## mp() [1/21]

pmt_t pmt::mp | ( | const char * | s | ) |

inline static

Make pmt symbol.

References string_to_symbol().

## mp() [2/21]

pmt_t pmt::mp | ( | const pmt_t & | e0 | ) |

inline static

Make tuple.

References make_tuple().

## mp() [3/21]

pmt_t pmt::mp | ( | const pmt_t & | e0,
|  | const pmt_t & | e1 )

inline static

Make tuple.

References make_tuple().

## mp() [4/21]

pmt_t pmt::mp | ( | const pmt_t & | e0,
|  | const pmt_t & | e1,
|  | const pmt_t & | e2 )

inline static

Make tuple.

References make_tuple().

## mp() [5/21]

pmt_t pmt::mp | ( | const pmt_t & | e0,
|  | const pmt_t & | e1,
|  | const pmt_t & | e2,
|  | const pmt_t & | e3 )

inline static

Make tuple.

References make_tuple().

## mp() [6/21]

pmt_t pmt::mp | ( | const pmt_t & | e0,
|  | const pmt_t & | e1,
|  | const pmt_t & | e2,
|  | const pmt_t & | e3,
|  | const pmt_t & | e4 )

inline static

Make tuple.

References make_tuple().

## mp() [7/21]

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 )

inline static

Make tuple.

References make_tuple().

## mp() [8/21]

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 )

inline static

Make tuple.

References make_tuple().

## mp() [9/21]

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 )

inline static

Make tuple.

References make_tuple().

## mp() [10/21]

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 )

inline static

Make tuple.

References make_tuple().

## mp() [11/21]

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 )

inline static

Make tuple.

References make_tuple().

## mp() [12/21]

pmt_t pmt::mp | ( | const std::string & | s | ) |

inline static

Make pmt symbol.

References string_to_symbol().

Referenced by pmt_assist< myType >::make(), and rpcbasic_inserter< T, Tfrom >::retrieve().

## mp() [13/21]

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

inline static

Make pmt Binary Large Object (BLOB).

References make_blob().

## mp() [14/21]

pmt_t pmt::mp | ( | double | x | ) |

inline static

Make pmt double.

References from_double().

## mp() [15/21]

pmt_t pmt::mp | ( | int | x | ) |

inline static

Make pmt long.

References from_long().

## mp() [16/21]

pmt_t pmt::mp | ( | long long unsigned | x | ) |

inline static

Make pmt uint64.

References from_uint64().

## mp() [17/21]

pmt_t pmt::mp | ( | long unsigned | x | ) |

inline static

Make pmt uint64.

References from_uint64().

## mp() [18/21]

pmt_t pmt::mp | ( | long | x | ) |

inline static

Make pmt long.

References from_long().

## mp() [19/21]

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

inline static

Make pmt complex.

References make_rectangular().

## mp() [20/21]

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

inline static

Make pmt complex.

References make_rectangular().

## mp() [21/21]

pmt_t pmt::mp | ( | std::shared_ptr< gr::messages::msg_accepter > | ma | ) |

inline static

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.

References PMT_API.

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.

References PMT_API.

## 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.

References PMT_API.

## operator<<()

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

References PMT_API.

## 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.

References PMT_API.

## 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.

References PMT_API.

## print()

PMT_API void pmt::print | ( | pmt_t | v | ) |

Write pmt string representation to stdout.

References PMT_API.

## 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.

References PMT_API.

## reverse()

PMT_API pmt_t pmt::reverse | ( | pmt_t | list | ) |

reverse `list`.

`list` must be a proper list.

References PMT_API.

## reverse_x()

PMT_API pmt_t pmt::reverse_x | ( | pmt_t | list | ) |

destructively reverse `list`.

`list` must be a proper list.

References PMT_API.

## s16vector_elements() [1/2]

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

References PMT_API.

## s16vector_elements() [2/2]

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

References PMT_API.

## s16vector_ref()

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

References PMT_API.

## s16vector_set()

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

References PMT_API.

## s16vector_writable_elements()

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

References PMT_API.

## s32vector_elements() [1/2]

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

References PMT_API.

## s32vector_elements() [2/2]

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

References PMT_API.

## s32vector_ref()

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

References PMT_API.

## s32vector_set()

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

References PMT_API.

## s32vector_writable_elements()

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

References PMT_API.

## s64vector_elements() [1/2]

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

References PMT_API.

## s64vector_elements() [2/2]

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

References PMT_API.

## s64vector_ref()

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

References PMT_API.

## s64vector_set()

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

References PMT_API.

## s64vector_writable_elements()

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

References PMT_API.

## s8vector_elements() [1/2]

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

References PMT_API.

## s8vector_elements() [2/2]

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

References PMT_API.

## s8vector_ref()

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

References PMT_API.

## s8vector_set()

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

References PMT_API.

## s8vector_writable_elements()

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

References PMT_API.

## serialize()

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

Write portable byte-serial representation of `obj` to `sink`.

References PMT_API.

## serialize_str()

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

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

References PMT_API.

## set_car()

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

Stores `value` in the car field of `pair`.

References PMT_API.

## set_cdr()

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

Stores `value` in the cdr field of `pair`.

References PMT_API.

## string_to_symbol()

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

Return the symbol whose name is `s`.

References PMT_API.

Referenced by mp(), and 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.

References list1(), list2(), and PMT_API.

## symbol_to_string()

PMT_API const 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.

References PMT_API.

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,.

References PMT_API.

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.

References PMT_API.

Referenced by rpcbasic_extractor< T, std::complex< double > >::post(), and rpcbasic_extractor< T, std::complex< float > >::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.

References PMT_API.

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.

References PMT_API.

## 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.

References PMT_API.

Referenced by rpcbasic_extractor< T, char >::post(), rpcbasic_extractor< T, int >::post(), rpcbasic_extractor< T, long >::post(), and rpcbasic_extractor< T, short >::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

References PMT_API.

## 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.

References PMT_API.

## 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`.

References PMT_API.

## u16vector_elements() [1/2]

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

References PMT_API.

## u16vector_elements() [2/2]

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

References PMT_API.

## u16vector_ref()

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

References PMT_API.

## u16vector_set()

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

References PMT_API.

## u16vector_writable_elements()

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

References PMT_API.

## u32vector_elements() [1/2]

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

References PMT_API.

## u32vector_elements() [2/2]

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

References PMT_API.

## u32vector_ref()

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

References PMT_API.

## u32vector_set()

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

References PMT_API.

## u32vector_writable_elements()

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

References PMT_API.

## u64vector_elements() [1/2]

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

References PMT_API.

## u64vector_elements() [2/2]

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

References PMT_API.

## u64vector_ref()

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

References PMT_API.

## u64vector_set()

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

References PMT_API.

## u64vector_writable_elements()

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

References PMT_API.

## u8vector_elements() [1/2]

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

References PMT_API.

## u8vector_elements() [2/2]

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

References PMT_API.

## u8vector_ref()

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

References PMT_API.

## u8vector_set()

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

References PMT_API.

## u8vector_writable_elements()

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

References PMT_API.

## uniform_vector_elements()

PMT_API const 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

References PMT_API.

## 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`.

References PMT_API.

## 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`.

References PMT_API.

## vector_set()

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

Store `obj` in position `k`.

References PMT_API.

## write()

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

Write a written representation of `obj` to the given `port`.

References PMT_API.

## 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.

References PMT_API.