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_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`.
PMT_API pmt_t	list2 (const pmt_t &x1, const pmt_t &x2)
	Return a list of length 2 containing `x1`, `x2`.
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`.
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`.
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`.
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`.
PMT_API pmt_t	list_add (pmt_t list, const pmt_t &item)
	Return `list` with `item` added to it.
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 )

inlinestatic

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

References acons(), cons(), and dcons().

Referenced by acons().

◆ any_ref()

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

Return underlying boost::any.

References any_ref(), and PMT_API.

Referenced by any_ref().

◆ any_set()

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

Store any in obj.

References any_set(), and PMT_API.

Referenced by any_set().

◆ 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 assoc(), and PMT_API.

Referenced by assoc().

◆ 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 assq(), and PMT_API.

Referenced by assq().

◆ 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 assv(), and PMT_API.

Referenced by assv().

◆ blob_data()

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

Return a pointer to the blob's data.

References blob_data(), and PMT_API.

Referenced by blob_data().

◆ blob_length()

PMT_API size_t pmt::blob_length ( pmt_t blob )

Return the blob's length in bytes.

References blob_length(), and PMT_API.

Referenced by blob_length().

◆ c32vector_elements() [1/2]

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

References c32vector_elements(), and PMT_API.

◆ c32vector_elements() [2/2]

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

References c32vector_elements(), and PMT_API.

Referenced by c32vector_elements(), and c32vector_elements().

◆ c32vector_ref()

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

References c32vector_ref(), and PMT_API.

Referenced by c32vector_ref().

◆ c32vector_set()

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

References c32vector_set(), and PMT_API.

Referenced by c32vector_set().

◆ c32vector_writable_elements()

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

References c32vector_writable_elements(), and PMT_API.

Referenced by c32vector_writable_elements().

◆ c64vector_elements() [1/2]

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

References c64vector_elements(), and PMT_API.

◆ c64vector_elements() [2/2]

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

References c64vector_elements().

Referenced by c64vector_elements(), and c64vector_elements().

◆ c64vector_ref()

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

References c64vector_ref(), and PMT_API.

Referenced by c64vector_ref().

◆ c64vector_set()

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

References c64vector_set(), and PMT_API.

Referenced by c64vector_set().

◆ c64vector_writable_elements()

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

References c64vector_writable_elements().

Referenced by c64vector_writable_elements().

◆ caar()

PMT_API pmt_t pmt::caar ( pmt_t pair )

References caar(), and PMT_API.

Referenced by caar().

◆ cadddr()

PMT_API pmt_t pmt::cadddr ( pmt_t pair )

References cadddr(), and PMT_API.

Referenced by cadddr().

◆ caddr()

PMT_API pmt_t pmt::caddr ( pmt_t pair )

References caddr(), and PMT_API.

Referenced by caddr().

◆ cadr()

PMT_API pmt_t pmt::cadr ( pmt_t pair )

References cadr(), and PMT_API.

Referenced by cadr().

◆ 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 car(), and PMT_API.

Referenced by car().

◆ cdar()

PMT_API pmt_t pmt::cdar ( pmt_t pair )

References cdar(), and PMT_API.

Referenced by cdar().

◆ cddr()

PMT_API pmt_t pmt::cddr ( pmt_t pair )

References cddr(), and PMT_API.

Referenced by cddr().

◆ 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 cdr(), and PMT_API.

Referenced by cdr().

◆ 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 cons(), and PMT_API.

Referenced by acons(), and cons().

◆ 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 dcons(), and PMT_API.

Referenced by acons(), and dcons().

◆ deserialize()

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

Create obj from portable byte-serial representation.

References deserialize(), and PMT_API.

Referenced by deserialize().

◆ deserialize_str()

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

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

References deserialize_str(), and PMT_API.

Referenced by deserialize_str().

◆ 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 dict_add(), and PMT_API.

Referenced by dict_add(), and 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 dict_delete(), and PMT_API.

Referenced by dict_delete().

◆ 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(), dict_from_mapping(), and make_dict().

Referenced by dict_from_mapping().

◆ 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 dict_has_key(), and PMT_API.

Referenced by dict_has_key(), 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 dict_items(), and PMT_API.

Referenced by dict_items().

◆ dict_keys()

PMT_API pmt_t pmt::dict_keys ( pmt_t dict )

Return list of keys.

References dict_keys(), and PMT_API.

Referenced by dict_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.

References dict_ref(), and PMT_API.

Referenced by dict_ref().

◆ 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 dict_update(), and PMT_API.

Referenced by dict_update().

◆ dict_values()

PMT_API pmt_t pmt::dict_values ( pmt_t dict )

Return list of values.

References dict_values(), and PMT_API.

Referenced by dict_values().

◆ dump_sizeof()

PMT_API void pmt::dump_sizeof ( )

References dump_sizeof(), and PMT_API.

Referenced by 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.

References eq(), and PMT_API.

Referenced by eq().

◆ 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 equal(), and PMT_API.

Referenced by equal(), and 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 eqv(), and PMT_API.

Referenced by eqv(), 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 f32vector_elements(), and PMT_API.

◆ f32vector_elements() [2/2]

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

References f32vector_elements(), and PMT_API.

Referenced by f32vector_elements(), and f32vector_elements().

◆ f32vector_ref()

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

References f32vector_ref(), and PMT_API.

Referenced by f32vector_ref().

◆ f32vector_set()

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

References f32vector_set(), and PMT_API.

Referenced by f32vector_set().

◆ f32vector_writable_elements()

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

References f32vector_writable_elements(), and PMT_API.

Referenced by f32vector_writable_elements().

◆ f64vector_elements() [1/2]

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

References f64vector_elements(), and PMT_API.

◆ f64vector_elements() [2/2]

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

References f64vector_elements(), and PMT_API.

Referenced by f64vector_elements(), and f64vector_elements().

◆ f64vector_ref()

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

References f64vector_ref(), and PMT_API.

Referenced by f64vector_ref().

◆ f64vector_set()

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

References f64vector_set(), and PMT_API.

Referenced by f64vector_set().

◆ f64vector_writable_elements()

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

References f64vector_writable_elements(), and PMT_API.

Referenced by f64vector_writable_elements().

◆ from_bool()

PMT_API pmt_t pmt::from_bool ( bool val )

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

References from_bool(), and PMT_API.

Referenced by from_bool().

◆ 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 from_complex(), and 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 from_complex(), and PMT_API.

Referenced by from_complex(), from_complex(), 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 from_double(), and PMT_API.

Referenced by from_double(), and mp().

◆ from_float()

PMT_API pmt_t pmt::from_float ( float x )

References from_float(), and PMT_API.

Referenced by from_float().

◆ from_long()

PMT_API pmt_t pmt::from_long ( long x )

Return the pmt value that represents the integer x.

References from_long(), and PMT_API.

Referenced by from_long(), 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 from_uint64(), and PMT_API.

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

◆ get_PMT_EOF()

PMT_API pmt_t pmt::get_PMT_EOF ( )

References get_PMT_EOF(), and PMT_API.

Referenced by get_PMT_EOF().

◆ get_PMT_F()

PMT_API pmt_t pmt::get_PMT_F ( )

References get_PMT_F(), and PMT_API.

Referenced by get_PMT_F().

◆ get_PMT_NIL()

PMT_API pmt_t pmt::get_PMT_NIL ( )

References get_PMT_NIL(), and PMT_API.

Referenced by get_PMT_NIL().

◆ get_PMT_T()

PMT_API pmt_t pmt::get_PMT_T ( )

References get_PMT_T(), and PMT_API.

Referenced by get_PMT_T().

◆ init_c32vector() [1/2]

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

References init_c32vector(), and PMT_API.

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

◆ init_c64vector() [1/2]

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

References init_c64vector(), and PMT_API.

Referenced by init_c64vector(), and init_c64vector().

◆ init_c64vector() [2/2]

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

References init_c64vector(), and PMT_API.

◆ init_f32vector() [1/2]

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

References init_f32vector(), and PMT_API.

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

◆ init_f64vector() [1/2]

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

References init_f64vector(), and PMT_API.

Referenced by init_f64vector(), and init_f64vector().

◆ init_f64vector() [2/2]

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

References init_f64vector(), and PMT_API.

◆ init_s16vector() [1/2]

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

References init_s16vector(), and PMT_API.

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

◆ init_s32vector() [1/2]

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

References init_s32vector(), and PMT_API.

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

◆ init_s64vector() [1/2]

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

References init_s64vector(), and PMT_API.

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

◆ init_s8vector() [1/2]

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

References init_s8vector(), and PMT_API.

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

◆ init_u16vector() [1/2]

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

References init_u16vector(), and PMT_API.

◆ init_u16vector() [2/2]

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

References init_u16vector(), and PMT_API.

Referenced by init_u16vector(), and init_u16vector().

◆ init_u32vector() [1/2]

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

References init_u32vector(), and PMT_API.

◆ init_u32vector() [2/2]

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

References init_u32vector(), and PMT_API.

Referenced by init_u32vector(), and init_u32vector().

◆ init_u64vector() [1/2]

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

References init_u64vector(), and PMT_API.

◆ init_u64vector() [2/2]

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

References init_u64vector(), and PMT_API.

Referenced by init_u64vector(), and init_u64vector().

◆ init_u8vector() [1/2]

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

References init_u8vector(), and PMT_API.

◆ init_u8vector() [2/2]

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

References init_u8vector(), and PMT_API.

Referenced by init_u8vector(), init_u8vector(), and 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 intern(), and PMT_API.

Referenced by gr::basic_block::alias_pmt(), intern(), 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 is_any(), and PMT_API.

Referenced by is_any().

◆ is_blob()

PMT_API bool pmt::is_blob ( pmt_t x )

Return true if x is a blob, otherwise false.

References is_blob(), and PMT_API.

Referenced by is_blob().

◆ is_bool()

PMT_API bool pmt::is_bool ( pmt_t obj )

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

References is_bool(), and PMT_API.

Referenced by is_bool().

◆ is_c32vector()

PMT_API bool pmt::is_c32vector ( pmt_t x )

References is_c32vector(), and PMT_API.

Referenced by is_c32vector().

◆ is_c64vector()

PMT_API bool pmt::is_c64vector ( pmt_t x )

References is_c64vector(), and PMT_API.

Referenced by is_c64vector().

◆ is_complex()

PMT_API bool pmt::is_complex ( pmt_t obj )

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

References is_complex(), and PMT_API.

Referenced by is_complex().

◆ is_dict()

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

Return true if obj is a dictionary.

References is_dict(), and PMT_API.

Referenced by is_dict().

◆ 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 is_eof_object(), and PMT_API.

Referenced by is_eof_object().

◆ is_f32vector()

PMT_API bool pmt::is_f32vector ( pmt_t x )

References is_f32vector(), and PMT_API.

Referenced by is_f32vector().

◆ is_f64vector()

PMT_API bool pmt::is_f64vector ( pmt_t x )

References is_f64vector(), and PMT_API.

Referenced by is_f64vector().

◆ is_false()

PMT_API bool pmt::is_false ( pmt_t obj )

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

References is_false(), and PMT_API.

Referenced by is_false().

◆ is_integer()

PMT_API bool pmt::is_integer ( pmt_t x )

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

References is_integer(), and PMT_API.

Referenced by is_integer().

◆ is_msg_accepter()

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

Return true if obj is a msg_accepter.

References is_msg_accepter(), and PMT_API.

Referenced by is_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.

References is_null(), and PMT_API.

Referenced by is_null().

◆ is_number()

PMT_API bool pmt::is_number ( pmt_t obj )

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

References is_number(), and PMT_API.

Referenced by is_number().

◆ 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 is_pair(), and PMT_API.

Referenced by is_pair().

◆ 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 is_pdu(), and PMT_API.

Referenced by is_pdu().

◆ is_real()

PMT_API bool pmt::is_real ( pmt_t obj )

References is_real(), and PMT_API.

Referenced by is_real().

◆ is_s16vector()

PMT_API bool pmt::is_s16vector ( pmt_t x )

References is_s16vector(), and PMT_API.

Referenced by is_s16vector().

◆ is_s32vector()

PMT_API bool pmt::is_s32vector ( pmt_t x )

References is_s32vector(), and PMT_API.

Referenced by is_s32vector().

◆ is_s64vector()

PMT_API bool pmt::is_s64vector ( pmt_t x )

References is_s64vector(), and PMT_API.

Referenced by is_s64vector().

◆ is_s8vector()

PMT_API bool pmt::is_s8vector ( pmt_t x )

References is_s8vector(), and PMT_API.

Referenced by is_s8vector().

◆ is_symbol()

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

Return true if obj is a symbol, else false.

References is_symbol(), and PMT_API.

Referenced by is_symbol().

◆ is_true()

PMT_API bool pmt::is_true ( pmt_t obj )

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

References is_true(), and PMT_API.

Referenced by is_true().

◆ is_tuple()

PMT_API bool pmt::is_tuple ( pmt_t x )

Return true if x is a tuple, otherwise false.

References is_tuple(), and PMT_API.

Referenced by is_tuple().

◆ is_u16vector()

PMT_API bool pmt::is_u16vector ( pmt_t x )

References is_u16vector(), and PMT_API.

Referenced by is_u16vector().

◆ is_u32vector()

PMT_API bool pmt::is_u32vector ( pmt_t x )

References is_u32vector(), and PMT_API.

Referenced by is_u32vector().

◆ is_u64vector()

PMT_API bool pmt::is_u64vector ( pmt_t x )

References is_u64vector(), and PMT_API.

Referenced by is_u64vector().

◆ is_u8vector()

PMT_API bool pmt::is_u8vector ( pmt_t x )

References is_u8vector(), and PMT_API.

Referenced by is_u8vector().

◆ is_uint64()

PMT_API bool pmt::is_uint64 ( pmt_t x )

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

References is_uint64(), and PMT_API.

Referenced by is_uint64().

◆ 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 is_uniform_vector(), and PMT_API.

Referenced by is_uniform_vector().

◆ is_vector()

PMT_API bool pmt::is_vector ( pmt_t x )

Return true if x is a vector, otherwise false.

References is_vector(), and PMT_API.

Referenced by is_vector().

◆ length()

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

Return the number of elements in v.

References length(), and PMT_API.

Referenced by length().

◆ list1()

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

Return a list of length 1 containing x1.

References list1(), and PMT_API.

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

References list2(), and PMT_API.

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

References list3(), and PMT_API.

Referenced by list3().

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

References list4(), and PMT_API.

Referenced by list4().

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

References list5(), and PMT_API.

Referenced by list5().

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

References list6(), and PMT_API.

Referenced by list6().

◆ list_add()

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

Return list with item added to it.

References list_add(), and PMT_API.

Referenced by list_add(), 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 list_has(), and PMT_API.

Referenced by list_has(), 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 list_rm(), and PMT_API.

Referenced by list_rm().

◆ make_any()

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

make an any

References make_any(), and PMT_API.

Referenced by gr::digital::constellation::as_pmt(), and make_any().

◆ 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 make_blob(), and PMT_API.

Referenced by make_blob(), and mp().

◆ make_c32vector()

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

References make_c32vector(), and PMT_API.

Referenced by make_c32vector().

◆ make_c64vector()

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

References make_c64vector(), and PMT_API.

Referenced by make_c64vector().

◆ make_dict()

PMT_API pmt_t pmt::make_dict ( )

Make an empty dictionary.

References make_dict(), and PMT_API.

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

◆ make_f32vector()

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

References make_f32vector(), and PMT_API.

Referenced by make_f32vector().

◆ make_f64vector()

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

References make_f64vector(), and PMT_API.

Referenced by make_f64vector().

◆ make_msg_accepter()

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

make a msg_accepter

References make_msg_accepter(), and PMT_API.

Referenced by make_msg_accepter(), and 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 make_rectangular(), and PMT_API.

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

◆ make_s16vector()

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

References make_s16vector(), and PMT_API.

Referenced by make_s16vector().

◆ make_s32vector()

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

References make_s32vector(), and PMT_API.

Referenced by make_s32vector().

◆ make_s64vector()

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

References make_s64vector(), and PMT_API.

Referenced by make_s64vector().

◆ make_s8vector()

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

References make_s8vector(), and PMT_API.

Referenced by make_s8vector().

◆ make_tuple() [1/11]

PMT_API pmt_t pmt::make_tuple ( )

References make_tuple(), and PMT_API.

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

◆ make_tuple() [3/11]

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

References make_tuple(), and 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 make_tuple(), and 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 make_tuple(), and 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 make_tuple(), and 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 make_tuple(), and 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 make_tuple(), and 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 make_tuple(), and 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 make_tuple(), and 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 make_tuple(), and PMT_API.

◆ make_u16vector()

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

References make_u16vector(), and PMT_API.

Referenced by make_u16vector().

◆ make_u32vector()

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

References make_u32vector(), and PMT_API.

Referenced by make_u32vector().

◆ make_u64vector()

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

References make_u64vector(), and PMT_API.

Referenced by make_u64vector().

◆ make_u8vector()

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

References make_u8vector(), and PMT_API.

Referenced by make_u8vector().

◆ 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 make_vector(), and PMT_API.

Referenced by make_vector().

◆ 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 map(), and PMT_API.

Referenced by map().

◆ 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 member(), and PMT_API.

Referenced by member().

◆ 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 memq(), and PMT_API.

Referenced by memq().

◆ 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 memv(), and PMT_API.

Referenced by memv().

◆ mp() [1/21]

pmt_t pmt::mp ( const char * s )

inlinestatic

Make pmt symbol.

References mp(), and string_to_symbol().

◆ mp() [2/21]

pmt_t pmt::mp ( const pmt_t & e0 )

inlinestatic

Make tuple.

References make_tuple(), and mp().

◆ mp() [3/21]

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

inlinestatic

Make tuple.

References make_tuple(), and mp().

◆ mp() [4/21]

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

inlinestatic

Make tuple.

References make_tuple(), and mp().

◆ mp() [5/21]

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

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

inlinestatic

Make tuple.

References make_tuple(), and mp().

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

inlinestatic

Make tuple.

References make_tuple(), and mp().

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

inlinestatic

Make tuple.

References make_tuple(), and mp().

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

inlinestatic

Make tuple.

References make_tuple(), and mp().

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

inlinestatic

Make tuple.

References make_tuple(), and mp().

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

inlinestatic

Make tuple.

References make_tuple(), and mp().

◆ mp() [12/21]

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

inlinestatic

Make pmt symbol.

References mp(), and string_to_symbol().

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

◆ mp() [13/21]

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

inlinestatic

Make pmt Binary Large Object (BLOB).

References make_blob(), and mp().

◆ mp() [14/21]

pmt_t pmt::mp ( double x )

inlinestatic

Make pmt double.

References from_double(), and mp().

◆ mp() [15/21]

pmt_t pmt::mp ( int x )

inlinestatic

Make pmt long.

References from_long(), and mp().

◆ mp() [16/21]

pmt_t pmt::mp ( long long unsigned x )

inlinestatic

Make pmt uint64.

References from_uint64(), and mp().

◆ mp() [17/21]

pmt_t pmt::mp ( long unsigned x )

inlinestatic

Make pmt uint64.

References from_uint64(), and mp().

◆ mp() [18/21]

pmt_t pmt::mp ( long x )

inlinestatic

Make pmt long.

References from_long(), and mp().

◆ mp() [19/21]

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

inlinestatic

Make pmt complex.

References make_rectangular(), and mp().

◆ mp() [20/21]

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

inlinestatic

Make pmt complex.

References make_rectangular(), and mp().

◆ mp() [21/21]

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

inlinestatic

Make pmt msg_accepter.

References make_msg_accepter(), and mp().

◆ 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 msg_accepter_ref(), and PMT_API.

Referenced by msg_accepter_ref(), and 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 nth(), and PMT_API.

Referenced by nth().

◆ 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 nthcdr(), and PMT_API.

Referenced by nthcdr().

◆ operator<<()

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

References operator<<(), and PMT_API.

Referenced by operator<<().

◆ 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, and pmt_from_complex().

◆ 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, and pmt_from_complex().

Referenced by pmt_from_complex(), and pmt_from_complex().

◆ print()

PMT_API void pmt::print ( pmt_t v )

Write pmt string representation to stdout.

References PMT_API, and print().

Referenced by print().

◆ 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, and read().

Referenced by read().

◆ reverse()

PMT_API pmt_t pmt::reverse ( pmt_t list )

reverse list.

list must be a proper list.

References PMT_API, and reverse().

Referenced by reverse().

◆ reverse_x()

PMT_API pmt_t pmt::reverse_x ( pmt_t list )

destructively reverse list.

list must be a proper list.

References PMT_API, and reverse_x().

Referenced by reverse_x().

◆ s16vector_elements() [1/2]

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

References PMT_API, and s16vector_elements().

◆ s16vector_elements() [2/2]

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

References PMT_API, and s16vector_elements().

Referenced by s16vector_elements(), and s16vector_elements().

◆ s16vector_ref()

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

References PMT_API, and s16vector_ref().

Referenced by s16vector_ref().

◆ s16vector_set()

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

References PMT_API, and s16vector_set().

Referenced by s16vector_set().

◆ s16vector_writable_elements()

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

References PMT_API, and s16vector_writable_elements().

Referenced by s16vector_writable_elements().

◆ s32vector_elements() [1/2]

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

References PMT_API, and s32vector_elements().

◆ s32vector_elements() [2/2]

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

References PMT_API, and s32vector_elements().

Referenced by s32vector_elements(), and s32vector_elements().

◆ s32vector_ref()

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

References PMT_API, and s32vector_ref().

Referenced by s32vector_ref().

◆ s32vector_set()

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

References PMT_API, and s32vector_set().

Referenced by s32vector_set().

◆ s32vector_writable_elements()

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

References PMT_API, and s32vector_writable_elements().

Referenced by s32vector_writable_elements().

◆ s64vector_elements() [1/2]

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

References PMT_API, and s64vector_elements().

◆ s64vector_elements() [2/2]

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

References PMT_API, and s64vector_elements().

Referenced by s64vector_elements(), and s64vector_elements().

◆ s64vector_ref()

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

References PMT_API, and s64vector_ref().

Referenced by s64vector_ref().

◆ s64vector_set()

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

References PMT_API, and s64vector_set().

Referenced by s64vector_set().

◆ s64vector_writable_elements()

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

References PMT_API, and s64vector_writable_elements().

Referenced by s64vector_writable_elements().

◆ s8vector_elements() [1/2]

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

References PMT_API, and s8vector_elements().

◆ s8vector_elements() [2/2]

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

References PMT_API, and s8vector_elements().

Referenced by s8vector_elements(), and s8vector_elements().

◆ s8vector_ref()

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

References PMT_API, and s8vector_ref().

Referenced by s8vector_ref().

◆ s8vector_set()

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

References PMT_API, and s8vector_set().

Referenced by s8vector_set().

◆ s8vector_writable_elements()

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

References PMT_API, and s8vector_writable_elements().

Referenced by s8vector_writable_elements().

◆ serialize()

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

Write portable byte-serial representation of obj to sink.

References PMT_API, and serialize().

Referenced by serialize().

◆ 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, and serialize_str().

Referenced by serialize_str().

◆ 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, and set_car().

Referenced by set_car().

◆ 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, and set_cdr().

Referenced by set_cdr().

◆ 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, and string_to_symbol().

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

◆ 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(), PMT_API, and subsetp().

Referenced by subsetp().

◆ 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, and symbol_to_string().

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

◆ 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, and to_bool().

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

◆ 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, and to_complex().

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

◆ 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, and to_double().

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

◆ 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, and to_float().

Referenced by to_float().

◆ 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, and to_long().

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

◆ 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, and to_tuple().

Referenced by to_tuple().

◆ 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, and to_uint64().

Referenced by to_uint64().