Classes
class	pmt_exception
class	pmt_wrong_type
class	pmt_out_of_range
class	pmt_notimplemented
class	pmt_comperator
	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...
class	pmt_base
class	pmt_bool
class	pmt_symbol
class	pmt_integer
class	pmt_uint64
class	pmt_real
class	pmt_complex
class	pmt_null
class	pmt_pair
class	pmt_vector
class	pmt_tuple
class	pmt_any
class	pmt_uniform_vector
class	pmt_u8vector
class	pmt_s8vector
class	pmt_u16vector
class	pmt_s16vector
class	pmt_u32vector
class	pmt_s32vector
class	pmt_u64vector
class	pmt_s64vector
class	pmt_f32vector
class	pmt_f64vector
class	pmt_c32vector
class	pmt_c64vector
Typedefs
typedef boost::intrusive_ptr < pmt_base >	pmt_t
	typedef for shared pointer (transparent reference counting). See http://www.boost.org/libs/smart_ptr/smart_ptr.htm
Functions
GRUEL_API void	intrusive_ptr_add_ref (pmt_base *)
GRUEL_API void	intrusive_ptr_release (pmt_base *)
GRUEL_API bool	pmt_is_bool (pmt_t obj)
	Return true if obj is #t or #f, else return false.
GRUEL_API bool	pmt_is_true (pmt_t obj)
	Return false if obj is #f, else return true.
GRUEL_API bool	pmt_is_false (pmt_t obj)
	Return true if obj is #f, else return true.
GRUEL_API pmt_t	pmt_from_bool (bool val)
	Return #f is val is false, else return #t.
GRUEL_API bool	pmt_to_bool (pmt_t val)
	Return true if val is PMT_T, return false when val is PMT_F,.
GRUEL_API bool	pmt_is_symbol (const pmt_t &obj)
	Return true if obj is a symbol, else false.
GRUEL_API pmt_t	pmt_string_to_symbol (const std::string &s)
	Return the symbol whose name is `s`.
GRUEL_API pmt_t	pmt_intern (const std::string &s)
	Alias for pmt_string_to_symbol.
GRUEL_API const std::string	pmt_symbol_to_string (const pmt_t &sym)
GRUEL_API bool	pmt_is_number (pmt_t obj)
	Return true if obj is any kind of number, else false.
GRUEL_API bool	pmt_is_integer (pmt_t x)
	Return true if `x` is an integer number, else false.
GRUEL_API pmt_t	pmt_from_long (long x)
	Return the pmt value that represents the integer `x`.
GRUEL_API long	pmt_to_long (pmt_t x)
	Convert pmt to long if possible.
GRUEL_API bool	pmt_is_uint64 (pmt_t x)
	Return true if `x` is an uint64 number, else false.
GRUEL_API pmt_t	pmt_from_uint64 (uint64_t x)
	Return the pmt value that represents the uint64 `x`.
GRUEL_API uint64_t	pmt_to_uint64 (pmt_t x)
	Convert pmt to uint64 if possible.
GRUEL_API bool	pmt_is_real (pmt_t obj)
GRUEL_API pmt_t	pmt_from_double (double x)
	Return the pmt value that represents double `x`.
GRUEL_API double	pmt_to_double (pmt_t x)
	Convert pmt to double if possible.
GRUEL_API bool	pmt_is_complex (pmt_t obj)
	return true if `obj` is a complex number, false otherwise.
GRUEL_API pmt_t	pmt_make_rectangular (double re, double im)
	Return a complex number constructed of the given real and imaginary parts.
GRUEL_API pmt_t	pmt_from_complex (double re, double im)
	Return a complex number constructed of the given real and imaginary parts.
GRUEL_API pmt_t	pmt_from_complex (const std::complex< double > &z)
	Return a complex number constructed of the given a complex number.
GRUEL_API std::complex< double >	pmt_to_complex (pmt_t z)
GRUEL_API bool	pmt_is_null (const pmt_t &x)
	Return true if `x` is the empty list, otherwise return false.
GRUEL_API bool	pmt_is_pair (const pmt_t &obj)
	Return true if `obj` is a pair, else false.
GRUEL_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`.
GRUEL_API pmt_t	pmt_car (const pmt_t &pair)
	If `pair` is a pair, return the car of the `pair`, otherwise raise wrong_type.
GRUEL_API pmt_t	pmt_cdr (const pmt_t &pair)
	If `pair` is a pair, return the cdr of the `pair`, otherwise raise wrong_type.
GRUEL_API void	pmt_set_car (pmt_t pair, pmt_t value)
	Stores `value` in the car field of `pair`.
GRUEL_API void	pmt_set_cdr (pmt_t pair, pmt_t value)
	Stores `value` in the cdr field of `pair`.
GRUEL_API pmt_t	pmt_caar (pmt_t pair)
GRUEL_API pmt_t	pmt_cadr (pmt_t pair)
GRUEL_API pmt_t	pmt_cdar (pmt_t pair)
GRUEL_API pmt_t	pmt_cddr (pmt_t pair)
GRUEL_API pmt_t	pmt_caddr (pmt_t pair)
GRUEL_API pmt_t	pmt_cadddr (pmt_t pair)
GRUEL_API bool	pmt_is_tuple (pmt_t x)
	Return true if `x` is a tuple, othewise false.
GRUEL_API pmt_t	pmt_make_tuple ()
GRUEL_API pmt_t	pmt_make_tuple (const pmt_t &e0)
GRUEL_API pmt_t	pmt_make_tuple (const pmt_t &e0, const pmt_t &e1)
GRUEL_API pmt_t	pmt_make_tuple (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2)
GRUEL_API pmt_t	pmt_make_tuple (const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3)
GRUEL_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)
GRUEL_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)
GRUEL_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)
GRUEL_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)
GRUEL_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)
GRUEL_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)
GRUEL_API pmt_t	pmt_to_tuple (const pmt_t &x)
GRUEL_API pmt_t	pmt_tuple_ref (const pmt_t &tuple, size_t k)
GRUEL_API bool	pmt_is_vector (pmt_t x)
	Return true if `x` is a vector, othewise false.
GRUEL_API pmt_t	pmt_make_vector (size_t k, pmt_t fill)
	Make a vector of length `k`, with initial values set to `fill`.
GRUEL_API pmt_t	pmt_vector_ref (pmt_t vector, size_t k)
GRUEL_API void	pmt_vector_set (pmt_t vector, size_t k, pmt_t obj)
	Store `obj` in position `k`.
GRUEL_API void	pmt_vector_fill (pmt_t vector, pmt_t fill)
	Store `fill` in every position of `vector`.
GRUEL_API bool	pmt_is_blob (pmt_t x)
	Return true if `x` is a blob, othewise false.
GRUEL_API pmt_t	pmt_make_blob (const void *buf, size_t len)
	Make a blob given a pointer and length in bytes.
GRUEL_API const void *	pmt_blob_data (pmt_t blob)
	Return a pointer to the blob's data.
GRUEL_API size_t	pmt_blob_length (pmt_t blob)
	Return the blob's length in bytes.
GRUEL_API bool	pmt_is_uniform_vector (pmt_t x)
	true if `x` is any kind of uniform numeric vector
GRUEL_API bool	pmt_is_u8vector (pmt_t x)
GRUEL_API bool	pmt_is_s8vector (pmt_t x)
GRUEL_API bool	pmt_is_u16vector (pmt_t x)
GRUEL_API bool	pmt_is_s16vector (pmt_t x)
GRUEL_API bool	pmt_is_u32vector (pmt_t x)
GRUEL_API bool	pmt_is_s32vector (pmt_t x)
GRUEL_API bool	pmt_is_u64vector (pmt_t x)
GRUEL_API bool	pmt_is_s64vector (pmt_t x)
GRUEL_API bool	pmt_is_f32vector (pmt_t x)
GRUEL_API bool	pmt_is_f64vector (pmt_t x)
GRUEL_API bool	pmt_is_c32vector (pmt_t x)
GRUEL_API bool	pmt_is_c64vector (pmt_t x)
GRUEL_API pmt_t	pmt_make_u8vector (size_t k, uint8_t fill)
GRUEL_API pmt_t	pmt_make_s8vector (size_t k, int8_t fill)
GRUEL_API pmt_t	pmt_make_u16vector (size_t k, uint16_t fill)
GRUEL_API pmt_t	pmt_make_s16vector (size_t k, int16_t fill)
GRUEL_API pmt_t	pmt_make_u32vector (size_t k, uint32_t fill)
GRUEL_API pmt_t	pmt_make_s32vector (size_t k, int32_t fill)
GRUEL_API pmt_t	pmt_make_u64vector (size_t k, uint64_t fill)
GRUEL_API pmt_t	pmt_make_s64vector (size_t k, int64_t fill)
GRUEL_API pmt_t	pmt_make_f32vector (size_t k, float fill)
GRUEL_API pmt_t	pmt_make_f64vector (size_t k, double fill)
GRUEL_API pmt_t	pmt_make_c32vector (size_t k, std::complex< float > fill)
GRUEL_API pmt_t	pmt_make_c64vector (size_t k, std::complex< double > fill)
GRUEL_API pmt_t	pmt_init_u8vector (size_t k, const uint8_t *data)
GRUEL_API pmt_t	pmt_init_u8vector (size_t k, const std::vector< uint8_t > &data)
GRUEL_API pmt_t	pmt_init_s8vector (size_t k, const int8_t *data)
GRUEL_API pmt_t	pmt_init_s8vector (size_t k, const std::vector< int8_t > &data)
GRUEL_API pmt_t	pmt_init_u16vector (size_t k, const uint16_t *data)
GRUEL_API pmt_t	pmt_init_u16vector (size_t k, const std::vector< uint16_t > &data)
GRUEL_API pmt_t	pmt_init_s16vector (size_t k, const int16_t *data)
GRUEL_API pmt_t	pmt_init_s16vector (size_t k, const std::vector< int16_t > &data)
GRUEL_API pmt_t	pmt_init_u32vector (size_t k, const uint32_t *data)
GRUEL_API pmt_t	pmt_init_u32vector (size_t k, const std::vector< uint32_t > &data)
GRUEL_API pmt_t	pmt_init_s32vector (size_t k, const int32_t *data)
GRUEL_API pmt_t	pmt_init_s32vector (size_t k, const std::vector< int32_t > &data)
GRUEL_API pmt_t	pmt_init_u64vector (size_t k, const uint64_t *data)
GRUEL_API pmt_t	pmt_init_u64vector (size_t k, const std::vector< uint64_t > &data)
GRUEL_API pmt_t	pmt_init_s64vector (size_t k, const int64_t *data)
GRUEL_API pmt_t	pmt_init_s64vector (size_t k, const std::vector< int64_t > &data)
GRUEL_API pmt_t	pmt_init_f32vector (size_t k, const float *data)
GRUEL_API pmt_t	pmt_init_f32vector (size_t k, const std::vector< float > &data)
GRUEL_API pmt_t	pmt_init_f64vector (size_t k, const double *data)
GRUEL_API pmt_t	pmt_init_f64vector (size_t k, const std::vector< double > &data)
GRUEL_API pmt_t	pmt_init_c32vector (size_t k, const std::complex< float > *data)
GRUEL_API pmt_t	pmt_init_c32vector (size_t k, const std::vector< std::complex< float > > &data)
GRUEL_API pmt_t	pmt_init_c64vector (size_t k, const std::complex< double > *data)
GRUEL_API pmt_t	pmt_init_c64vector (size_t k, const std::vector< std::complex< double > > &data)
GRUEL_API uint8_t	pmt_u8vector_ref (pmt_t v, size_t k)
GRUEL_API int8_t	pmt_s8vector_ref (pmt_t v, size_t k)
GRUEL_API uint16_t	pmt_u16vector_ref (pmt_t v, size_t k)
GRUEL_API int16_t	pmt_s16vector_ref (pmt_t v, size_t k)
GRUEL_API uint32_t	pmt_u32vector_ref (pmt_t v, size_t k)
GRUEL_API int32_t	pmt_s32vector_ref (pmt_t v, size_t k)
GRUEL_API uint64_t	pmt_u64vector_ref (pmt_t v, size_t k)
GRUEL_API int64_t	pmt_s64vector_ref (pmt_t v, size_t k)
GRUEL_API float	pmt_f32vector_ref (pmt_t v, size_t k)
GRUEL_API double	pmt_f64vector_ref (pmt_t v, size_t k)
GRUEL_API std::complex< float >	pmt_c32vector_ref (pmt_t v, size_t k)
GRUEL_API std::complex< double >	pmt_c64vector_ref (pmt_t v, size_t k)
GRUEL_API void	pmt_u8vector_set (pmt_t v, size_t k, uint8_t x)
GRUEL_API void	pmt_s8vector_set (pmt_t v, size_t k, int8_t x)
GRUEL_API void	pmt_u16vector_set (pmt_t v, size_t k, uint16_t x)
GRUEL_API void	pmt_s16vector_set (pmt_t v, size_t k, int16_t x)
GRUEL_API void	pmt_u32vector_set (pmt_t v, size_t k, uint32_t x)
GRUEL_API void	pmt_s32vector_set (pmt_t v, size_t k, int32_t x)
GRUEL_API void	pmt_u64vector_set (pmt_t v, size_t k, uint64_t x)
GRUEL_API void	pmt_s64vector_set (pmt_t v, size_t k, int64_t x)
GRUEL_API void	pmt_f32vector_set (pmt_t v, size_t k, float x)
GRUEL_API void	pmt_f64vector_set (pmt_t v, size_t k, double x)
GRUEL_API void	pmt_c32vector_set (pmt_t v, size_t k, std::complex< float > x)
GRUEL_API void	pmt_c64vector_set (pmt_t v, size_t k, std::complex< double > x)
GRUEL_API const void *	pmt_uniform_vector_elements (pmt_t v, size_t &len)
GRUEL_API const uint8_t *	pmt_u8vector_elements (pmt_t v, size_t &len)
GRUEL_API const int8_t *	pmt_s8vector_elements (pmt_t v, size_t &len)
GRUEL_API const uint16_t *	pmt_u16vector_elements (pmt_t v, size_t &len)
GRUEL_API const int16_t *	pmt_s16vector_elements (pmt_t v, size_t &len)
GRUEL_API const uint32_t *	pmt_u32vector_elements (pmt_t v, size_t &len)
GRUEL_API const int32_t *	pmt_s32vector_elements (pmt_t v, size_t &len)
GRUEL_API const uint64_t *	pmt_u64vector_elements (pmt_t v, size_t &len)
GRUEL_API const int64_t *	pmt_s64vector_elements (pmt_t v, size_t &len)
GRUEL_API const float *	pmt_f32vector_elements (pmt_t v, size_t &len)
GRUEL_API const double *	pmt_f64vector_elements (pmt_t v, size_t &len)
GRUEL_API const std::complex < float > *	pmt_c32vector_elements (pmt_t v, size_t &len)
GRUEL_API const std::complex < double > *	pmt_c64vector_elements (pmt_t v, size_t &len)
GRUEL_API const std::vector < uint8_t >	pmt_u8vector_elements (pmt_t v)
GRUEL_API const std::vector < int8_t >	pmt_s8vector_elements (pmt_t v)
GRUEL_API const std::vector < uint16_t >	pmt_u16vector_elements (pmt_t v)
GRUEL_API const std::vector < int16_t >	pmt_s16vector_elements (pmt_t v)
GRUEL_API const std::vector < uint32_t >	pmt_u32vector_elements (pmt_t v)
GRUEL_API const std::vector < int32_t >	pmt_s32vector_elements (pmt_t v)
GRUEL_API const std::vector < uint64_t >	pmt_u64vector_elements (pmt_t v)
GRUEL_API const std::vector < int64_t >	pmt_s64vector_elements (pmt_t v)
GRUEL_API const std::vector < float >	pmt_f32vector_elements (pmt_t v)
GRUEL_API const std::vector < double >	pmt_f64vector_elements (pmt_t v)
GRUEL_API const std::vector < std::complex< float > >	pmt_c32vector_elements (pmt_t v)
GRUEL_API const std::vector < std::complex< double > >	pmt_c64vector_elements (pmt_t v)
GRUEL_API void *	pmt_uniform_vector_writable_elements (pmt_t v, size_t &len)
GRUEL_API uint8_t *	pmt_u8vector_writable_elements (pmt_t v, size_t &len)
GRUEL_API int8_t *	pmt_s8vector_writable_elements (pmt_t v, size_t &len)
GRUEL_API uint16_t *	pmt_u16vector_writable_elements (pmt_t v, size_t &len)
GRUEL_API int16_t *	pmt_s16vector_writable_elements (pmt_t v, size_t &len)
GRUEL_API uint32_t *	pmt_u32vector_writable_elements (pmt_t v, size_t &len)
GRUEL_API int32_t *	pmt_s32vector_writable_elements (pmt_t v, size_t &len)
GRUEL_API uint64_t *	pmt_u64vector_writable_elements (pmt_t v, size_t &len)
GRUEL_API int64_t *	pmt_s64vector_writable_elements (pmt_t v, size_t &len)
GRUEL_API float *	pmt_f32vector_writable_elements (pmt_t v, size_t &len)
GRUEL_API double *	pmt_f64vector_writable_elements (pmt_t v, size_t &len)
GRUEL_API std::complex< float > *	pmt_c32vector_writable_elements (pmt_t v, size_t &len)
GRUEL_API std::complex< double > *	pmt_c64vector_writable_elements (pmt_t v, size_t &len)
GRUEL_API bool	pmt_is_dict (const pmt_t &obj)
	Return true if `obj` is a dictionary.
GRUEL_API pmt_t	pmt_make_dict ()
	Make an empty dictionary.
GRUEL_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`.
GRUEL_API pmt_t	pmt_dict_delete (const pmt_t &dict, const pmt_t &key)
	Return a new dictionary with `key` removed.
GRUEL_API bool	pmt_dict_has_key (const pmt_t &dict, const pmt_t &key)
	Return true if `key` exists in `dict`.
GRUEL_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`.
GRUEL_API pmt_t	pmt_dict_items (pmt_t dict)
	Return list of (key . value) pairs.
GRUEL_API pmt_t	pmt_dict_keys (pmt_t dict)
	Return list of keys.
GRUEL_API pmt_t	pmt_dict_values (pmt_t dict)
	Return list of values.
GRUEL_API bool	pmt_is_any (pmt_t obj)
	Return true if `obj` is an any.
GRUEL_API pmt_t	pmt_make_any (const boost::any &any)
	make an any
GRUEL_API boost::any	pmt_any_ref (pmt_t obj)
	Return underlying boost::any.
GRUEL_API void	pmt_any_set (pmt_t obj, const boost::any &any)
	Store `any` in `obj`.
GRUEL_API bool	pmt_is_msg_accepter (const pmt_t &obj)
	Return true if `obj` is a msg_accepter.
GRUEL_API pmt_t	pmt_make_msg_accepter (boost::shared_ptr< gruel::msg_accepter > ma)
	make a msg_accepter
GRUEL_API boost::shared_ptr < gruel::msg_accepter >	pmt_msg_accepter_ref (const pmt_t &obj)
	Return underlying msg_accepter.
GRUEL_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.
GRUEL_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.
GRUEL_API bool	pmt_equal (const pmt_t &x, const pmt_t &y)
GRUEL_API size_t	pmt_length (const pmt_t &v)
	Return the number of elements in v.
GRUEL_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.
GRUEL_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.
GRUEL_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.
GRUEL_API pmt_t	pmt_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.
GRUEL_API pmt_t	pmt_reverse (pmt_t list)
	reverse `list`.
GRUEL_API pmt_t	pmt_reverse_x (pmt_t list)
	destructively reverse `list`.
static pmt_t	pmt_acons (pmt_t x, pmt_t y, pmt_t a)
	(acons x y a) == (cons (cons x y) a)
GRUEL_API pmt_t	pmt_nth (size_t n, pmt_t list)
	locates `nth` element of list where the car is the 'zeroth' element.
GRUEL_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.
GRUEL_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`.
GRUEL_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`.
GRUEL_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`.
GRUEL_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.
GRUEL_API pmt_t	pmt_list1 (const pmt_t &x1)
	Return a list of length 1 containing `x1`.
GRUEL_API pmt_t	pmt_list2 (const pmt_t &x1, const pmt_t &x2)
	Return a list of length 2 containing `x1`, `x2`.
GRUEL_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`.
GRUEL_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`.
GRUEL_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`.
GRUEL_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`.
GRUEL_API pmt_t	pmt_list_add (pmt_t list, const pmt_t &item)
	Return `list` with `item` added to it.
GRUEL_API pmt_t	pmt_list_rm (pmt_t list, const pmt_t &item)
	Return `list` with `item` removed from it.
GRUEL_API bool	pmt_list_has (pmt_t list, const pmt_t &item)
	Return bool of `list` contains `item`.
GRUEL_API bool	pmt_is_eof_object (pmt_t obj)
	return true if obj is the EOF object, otherwise return false.
GRUEL_API pmt_t	pmt_read (std::istream &port)
GRUEL_API void	pmt_write (pmt_t obj, std::ostream &port)
GRUEL_API std::string	pmt_write_string (pmt_t obj)
GRUEL_API std::ostream &	operator<< (std::ostream &os, pmt_t obj)
GRUEL_API void	pmt_print (pmt_t v)
	Write pmt string representation to stdout.
GRUEL_API bool	pmt_serialize (pmt_t obj, std::streambuf &sink)
	Write portable byte-serial representation of `obj` to `sink`.
GRUEL_API pmt_t	pmt_deserialize (std::streambuf &source)
	Create obj from portable byte-serial representation.
GRUEL_API void	pmt_dump_sizeof ()
GRUEL_API std::string	pmt_serialize_str (pmt_t obj)
	Provide a simple string generating interface to pmt's serialize function.
GRUEL_API pmt_t	pmt_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 long unsigned x)
	Make pmt long.
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 (boost::shared_ptr< gruel::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.
Variables
GRUEL_API const pmt_t	PMT_T
GRUEL_API const pmt_t	PMT_F
GRUEL_API const pmt_t	PMT_NIL
GRUEL_API const pmt_t	PMT_EOF

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

typedef boost::intrusive_ptr<pmt_base> pmt::pmt_t

typedef for shared pointer (transparent reference counting). See http://www.boost.org/libs/smart_ptr/smart_ptr.htm

Function Documentation

GRUEL_API void pmt::intrusive_ptr_add_ref ( pmt_base * )

GRUEL_API void pmt::intrusive_ptr_release ( pmt_base * )

static pmt_t pmt::mp ( const std::string & s ) [inline, static]

Make pmt symbol.

References pmt_string_to_symbol().

static pmt_t pmt::mp ( const char * s ) [inline, static]

Make pmt symbol.

References pmt_string_to_symbol().

static pmt_t pmt::mp ( long x ) [inline, static]

Make pmt long.

References pmt_from_long().

static pmt_t pmt::mp ( long long unsigned x ) [inline, static]

Make pmt long.

References pmt_from_long().

static pmt_t pmt::mp ( int x ) [inline, static]

Make pmt long.

References pmt_from_long().

static pmt_t pmt::mp ( double x ) [inline, static]

Make pmt double.

References pmt_from_double().

static pmt_t pmt::mp	(	const pmt_t &	e0,
		const pmt_t &	e1,
		const pmt_t &	e2
	)		`[inline, static]`

Make tuple.

References pmt_make_tuple().

static pmt_t pmt::mp ( std::complex< double > z ) [inline, static]

Make pmt complex.

References pmt_make_rectangular().

static pmt_t pmt::mp ( std::complex< float > z ) [inline, static]

Make pmt complex.

References pmt_make_rectangular().

static pmt_t pmt::mp ( boost::shared_ptr< gruel::msg_accepter > ma ) [inline, static]

Make pmt msg_accepter.

References pmt_make_msg_accepter().

static pmt_t pmt::mp	(	const void *	data,
		size_t	len_in_bytes
	)		`[inline, static]`

Make pmt Binary Large Object (BLOB)

References pmt_make_blob().

static pmt_t pmt::mp ( const pmt_t & e0 ) [inline, static]

Make tuple.

References pmt_make_tuple().

static pmt_t pmt::mp	(	const pmt_t &	e0,
		const pmt_t &	e1
	)		`[inline, static]`

Make tuple.

References pmt_make_tuple().

static 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 pmt_make_tuple().

static pmt_t pmt::mp	(	const pmt_t &	e0,
		const pmt_t &	e1,
		const pmt_t &	e2,
		const pmt_t &	e3,
		const pmt_t &	e4
	)		`[inline, static]`

Make tuple.

References pmt_make_tuple().

static pmt_t pmt::mp	(	const pmt_t &	e0,
		const pmt_t &	e1,
		const pmt_t &	e2,
		const pmt_t &	e3,
		const pmt_t &	e4,
		const pmt_t &	e5
	)		`[inline, static]`

Make tuple.

References pmt_make_tuple().

static pmt_t pmt::mp	(	const pmt_t &	e0,
		const pmt_t &	e1,
		const pmt_t &	e2,
		const pmt_t &	e3,
		const pmt_t &	e4,
		const pmt_t &	e5,
		const pmt_t &	e6
	)		`[inline, static]`

Make tuple.

References pmt_make_tuple().

static pmt_t pmt::mp	(	const pmt_t &	e0,
		const pmt_t &	e1,
		const pmt_t &	e2,
		const pmt_t &	e3,
		const pmt_t &	e4,
		const pmt_t &	e5,
		const pmt_t &	e6,
		const pmt_t &	e7
	)		`[inline, static]`

Make tuple.

References pmt_make_tuple().

static pmt_t pmt::mp	(	const pmt_t &	e0,
		const pmt_t &	e1,
		const pmt_t &	e2,
		const pmt_t &	e3,
		const pmt_t &	e4,
		const pmt_t &	e5,
		const pmt_t &	e6,
		const pmt_t &	e7,
		const pmt_t &	e8
	)		`[inline, static]`

Make tuple.

References pmt_make_tuple().

static pmt_t pmt::mp	(	const pmt_t &	e0,
		const pmt_t &	e1,
		const pmt_t &	e2,
		const pmt_t &	e3,
		const pmt_t &	e4,
		const pmt_t &	e5,
		const pmt_t &	e6,
		const pmt_t &	e7,
		const pmt_t &	e8,
		const pmt_t &	e9
	)		`[inline, static]`

Make tuple.

References pmt_make_tuple().

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

static pmt_t pmt::pmt_acons	(	pmt_t	x,
		pmt_t	y,
		pmt_t	a
	)		`[inline, static]`

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

References pmt_cons().

GRUEL_API boost::any pmt::pmt_any_ref ( pmt_t obj )

Return underlying boost::any.

GRUEL_API void pmt::pmt_any_set	(	pmt_t	obj,
		const boost::any &	any
	)

Store any in obj.

GRUEL_API pmt_t pmt::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.

GRUEL_API pmt_t pmt::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.

GRUEL_API pmt_t pmt::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.

GRUEL_API const void* pmt::pmt_blob_data ( pmt_t blob )

Return a pointer to the blob's data.

GRUEL_API size_t pmt::pmt_blob_length ( pmt_t blob )

Return the blob's length in bytes.

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

GRUEL_API const std::vector<std::complex<float> > pmt::pmt_c32vector_elements ( pmt_t v )

GRUEL_API std::complex<float> pmt::pmt_c32vector_ref	(	pmt_t	v,
		size_t	k
	)

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

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

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

GRUEL_API const std::vector<std::complex<double> > pmt::pmt_c64vector_elements ( pmt_t v )

GRUEL_API std::complex<double> pmt::pmt_c64vector_ref	(	pmt_t	v,
		size_t	k
	)

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

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

GRUEL_API pmt_t pmt::pmt_caar ( pmt_t pair )

GRUEL_API pmt_t pmt::pmt_cadddr ( pmt_t pair )

GRUEL_API pmt_t pmt::pmt_caddr ( pmt_t pair )

GRUEL_API pmt_t pmt::pmt_cadr ( pmt_t pair )

GRUEL_API pmt_t pmt::pmt_car ( const pmt_t & pair )

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

GRUEL_API pmt_t pmt::pmt_cdar ( pmt_t pair )

GRUEL_API pmt_t pmt::pmt_cddr ( pmt_t pair )

GRUEL_API pmt_t pmt::pmt_cdr ( const pmt_t & pair )

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

GRUEL_API pmt_t pmt::pmt_cons	(	const pmt_t &	x,
		const pmt_t &	y
	)

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

Referenced by pmt_acons().

GRUEL_API pmt_t pmt::pmt_deserialize ( std::streambuf & source )

Create obj from portable byte-serial representation.

GRUEL_API pmt_t pmt::pmt_deserialize_str ( std::string str )

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

GRUEL_API pmt_t pmt::pmt_dict_add	(	const pmt_t &	dict,
		const pmt_t &	key,
		const pmt_t &	value
	)

Return a new dictionary with key associated with value.

GRUEL_API pmt_t pmt::pmt_dict_delete	(	const pmt_t &	dict,
		const pmt_t &	key
	)

Return a new dictionary with key removed.

GRUEL_API bool pmt::pmt_dict_has_key	(	const pmt_t &	dict,
		const pmt_t &	key
	)

Return true if key exists in dict.

Referenced by gr_basic_block::has_msg_port(), and gr_hier_block2::message_port_register_hier_out().

GRUEL_API pmt_t pmt::pmt_dict_items ( pmt_t dict )

Return list of (key . value) pairs.

GRUEL_API pmt_t pmt::pmt_dict_keys ( pmt_t dict )

Return list of keys.

GRUEL_API pmt_t pmt::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.

GRUEL_API pmt_t pmt::pmt_dict_values ( pmt_t dict )

Return list of values.

GRUEL_API void pmt::pmt_dump_sizeof ( )

GRUEL_API bool pmt::pmt_eq	(	const pmt_t &	x,
		const pmt_t &	y
	)

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

GRUEL_API bool pmt::pmt_equal	(	const pmt_t &	x,
		const pmt_t &	y
	)

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

Referenced by gr_msg_endpoint::operator==().

GRUEL_API bool pmt::pmt_eqv	(	const pmt_t &	x,
		const pmt_t &	y
	)

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

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

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

GRUEL_API const float* pmt::pmt_f32vector_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const std::vector<float> pmt::pmt_f32vector_elements ( pmt_t v )

GRUEL_API float pmt::pmt_f32vector_ref	(	pmt_t	v,
		size_t	k
	)

GRUEL_API void pmt::pmt_f32vector_set	(	pmt_t	v,
		size_t	k,
		float	x
	)

GRUEL_API float* pmt::pmt_f32vector_writable_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const double* pmt::pmt_f64vector_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const std::vector<double> pmt::pmt_f64vector_elements ( pmt_t v )

GRUEL_API double pmt::pmt_f64vector_ref	(	pmt_t	v,
		size_t	k
	)

GRUEL_API void pmt::pmt_f64vector_set	(	pmt_t	v,
		size_t	k,
		double	x
	)

GRUEL_API double* pmt::pmt_f64vector_writable_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API pmt_t pmt::pmt_from_bool ( bool val )

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

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

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

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

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

GRUEL_API pmt_t pmt::pmt_from_double ( double x )

Return the pmt value that represents double x.

Referenced by tag_source_demo::make_time_tag(), and mp().

GRUEL_API pmt_t pmt::pmt_from_long ( long x )

Return the pmt value that represents the integer x.

Referenced by mp().

GRUEL_API pmt_t pmt::pmt_from_uint64 ( uint64_t x )

Return the pmt value that represents the uint64 x.

Referenced by tag_source_demo::make_time_tag().

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

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

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

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

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

GRUEL_API pmt_t pmt::pmt_init_f32vector	(	size_t	k,
		const float *	data
	)

GRUEL_API pmt_t pmt::pmt_init_f64vector	(	size_t	k,
		const double *	data
	)

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

GRUEL_API pmt_t pmt::pmt_init_s16vector	(	size_t	k,
		const int16_t *	data
	)

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

GRUEL_API pmt_t pmt::pmt_init_s32vector	(	size_t	k,
		const int32_t *	data
	)

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

GRUEL_API pmt_t pmt::pmt_init_s64vector	(	size_t	k,
		const int64_t *	data
	)

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

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

GRUEL_API pmt_t pmt::pmt_init_s8vector	(	size_t	k,
		const int8_t *	data
	)

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

GRUEL_API pmt_t pmt::pmt_init_u16vector	(	size_t	k,
		const uint16_t *	data
	)

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

GRUEL_API pmt_t pmt::pmt_init_u32vector	(	size_t	k,
		const uint32_t *	data
	)

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

GRUEL_API pmt_t pmt::pmt_init_u64vector	(	size_t	k,
		const uint64_t *	data
	)

GRUEL_API pmt_t pmt::pmt_init_u8vector	(	size_t	k,
		const uint8_t *	data
	)

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

GRUEL_API pmt_t pmt::pmt_intern ( const std::string & s )

Alias for pmt_string_to_symbol.

Referenced by gr_basic_block::alias_pmt().

GRUEL_API bool pmt::pmt_is_any ( pmt_t obj )

Return true if obj is an any.

GRUEL_API bool pmt::pmt_is_blob ( pmt_t x )

Return true if x is a blob, othewise false.

GRUEL_API bool pmt::pmt_is_bool ( pmt_t obj )

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

GRUEL_API bool pmt::pmt_is_c32vector ( pmt_t x )

GRUEL_API bool pmt::pmt_is_c64vector ( pmt_t x )

GRUEL_API bool pmt::pmt_is_complex ( pmt_t obj )

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

GRUEL_API bool pmt::pmt_is_dict ( const pmt_t & obj )

Return true if obj is a dictionary.

GRUEL_API bool pmt::pmt_is_eof_object ( pmt_t obj )

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

GRUEL_API bool pmt::pmt_is_f32vector ( pmt_t x )

GRUEL_API bool pmt::pmt_is_f64vector ( pmt_t x )

GRUEL_API bool pmt::pmt_is_false ( pmt_t obj )

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

GRUEL_API bool pmt::pmt_is_integer ( pmt_t x )

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

GRUEL_API bool pmt::pmt_is_msg_accepter ( const pmt_t & obj )

Return true if obj is a msg_accepter.

GRUEL_API bool pmt::pmt_is_null ( const pmt_t & x )

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

GRUEL_API bool pmt::pmt_is_number ( pmt_t obj )

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

GRUEL_API bool pmt::pmt_is_pair ( const pmt_t & obj )

Return true if obj is a pair, else false.

GRUEL_API bool pmt::pmt_is_real ( pmt_t obj )

GRUEL_API bool pmt::pmt_is_s16vector ( pmt_t x )

GRUEL_API bool pmt::pmt_is_s32vector ( pmt_t x )

GRUEL_API bool pmt::pmt_is_s64vector ( pmt_t x )

GRUEL_API bool pmt::pmt_is_s8vector ( pmt_t x )

GRUEL_API bool pmt::pmt_is_symbol ( const pmt_t & obj )

Return true if obj is a symbol, else false.

GRUEL_API bool pmt::pmt_is_true ( pmt_t obj )

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

GRUEL_API bool pmt::pmt_is_tuple ( pmt_t x )

Return true if x is a tuple, othewise false.

GRUEL_API bool pmt::pmt_is_u16vector ( pmt_t x )

GRUEL_API bool pmt::pmt_is_u32vector ( pmt_t x )

GRUEL_API bool pmt::pmt_is_u64vector ( pmt_t x )

GRUEL_API bool pmt::pmt_is_u8vector ( pmt_t x )

GRUEL_API bool pmt::pmt_is_uint64 ( pmt_t x )

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

GRUEL_API bool pmt::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>
 ------------------------------------------------------------------------

GRUEL_API bool pmt::pmt_is_vector ( pmt_t x )

Return true if x is a vector, othewise false.

GRUEL_API size_t pmt::pmt_length ( const pmt_t & v )

Return the number of elements in v.

Referenced by tcp_connection::send().

GRUEL_API pmt_t pmt::pmt_list1 ( const pmt_t & x1 )

Return a list of length 1 containing x1.

GRUEL_API pmt_t pmt::pmt_list2	(	const pmt_t &	x1,
		const pmt_t &	x2
	)

Return a list of length 2 containing x1, x2.

GRUEL_API pmt_t pmt::pmt_list3	(	const pmt_t &	x1,
		const pmt_t &	x2,
		const pmt_t &	x3
	)

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

GRUEL_API pmt_t pmt::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.

GRUEL_API pmt_t pmt::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.

GRUEL_API pmt_t pmt::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.

GRUEL_API pmt_t pmt::pmt_list_add	(	pmt_t	list,
		const pmt_t &	item
	)

Return list with item added to it.

Referenced by gr_hier_block2::message_port_register_hier_in(), and gr_hier_block2::message_port_register_hier_out().

GRUEL_API bool pmt::pmt_list_has	(	pmt_t	list,
		const pmt_t &	item
	)

Return bool of list contains item.

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

GRUEL_API pmt_t pmt::pmt_list_rm	(	pmt_t	list,
		const pmt_t &	item
	)

Return list with item removed from it.

GRUEL_API pmt_t pmt::pmt_make_any ( const boost::any & any )

make an any

GRUEL_API pmt_t pmt::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.

Referenced by mp().

GRUEL_API pmt_t pmt::pmt_make_c32vector	(	size_t	k,
		std::complex< float >	fill
	)

GRUEL_API pmt_t pmt::pmt_make_c64vector	(	size_t	k,
		std::complex< double >	fill
	)

GRUEL_API pmt_t pmt::pmt_make_dict ( )

Make an empty dictionary.

GRUEL_API pmt_t pmt::pmt_make_f32vector	(	size_t	k,
		float	fill
	)

GRUEL_API pmt_t pmt::pmt_make_f64vector	(	size_t	k,
		double	fill
	)

GRUEL_API pmt_t pmt::pmt_make_msg_accepter ( boost::shared_ptr< gruel::msg_accepter > ma )

make a msg_accepter

Referenced by mp().

GRUEL_API pmt_t pmt::pmt_make_rectangular	(	double	re,
		double	im
	)

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

Referenced by mp().

GRUEL_API pmt_t pmt::pmt_make_s16vector	(	size_t	k,
		int16_t	fill
	)

GRUEL_API pmt_t pmt::pmt_make_s32vector	(	size_t	k,
		int32_t	fill
	)

GRUEL_API pmt_t pmt::pmt_make_s64vector	(	size_t	k,
		int64_t	fill
	)

GRUEL_API pmt_t pmt::pmt_make_s8vector	(	size_t	k,
		int8_t	fill
	)

GRUEL_API pmt_t pmt::pmt_make_tuple	(	const pmt_t &	e0,
		const pmt_t &	e1,
		const pmt_t &	e2,
		const pmt_t &	e3,
		const pmt_t &	e4
	)

GRUEL_API pmt_t pmt::pmt_make_tuple	(	const pmt_t &	e0,
		const pmt_t &	e1,
		const pmt_t &	e2,
		const pmt_t &	e3
	)

GRUEL_API pmt_t pmt::pmt_make_tuple ( )

Referenced by tag_source_demo::make_time_tag(), and mp().

GRUEL_API pmt_t pmt::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
	)

GRUEL_API pmt_t pmt::pmt_make_tuple	(	const pmt_t &	e0,
		const pmt_t &	e1,
		const pmt_t &	e2
	)

GRUEL_API pmt_t pmt::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
	)

GRUEL_API pmt_t pmt::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
	)

GRUEL_API pmt_t pmt::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
	)

GRUEL_API pmt_t pmt::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
	)

GRUEL_API pmt_t pmt::pmt_make_tuple ( const pmt_t & e0 )

GRUEL_API pmt_t pmt::pmt_make_tuple	(	const pmt_t &	e0,
		const pmt_t &	e1
	)

GRUEL_API pmt_t pmt::pmt_make_u16vector	(	size_t	k,
		uint16_t	fill
	)

GRUEL_API pmt_t pmt::pmt_make_u32vector	(	size_t	k,
		uint32_t	fill
	)

GRUEL_API pmt_t pmt::pmt_make_u64vector	(	size_t	k,
		uint64_t	fill
	)

GRUEL_API pmt_t pmt::pmt_make_u8vector	(	size_t	k,
		uint8_t	fill
	)

GRUEL_API pmt_t pmt::pmt_make_vector	(	size_t	k,
		pmt_t	fill
	)

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

GRUEL_API pmt_t pmt::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.

GRUEL_API pmt_t pmt::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.

GRUEL_API pmt_t pmt::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.

GRUEL_API pmt_t pmt::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.

GRUEL_API boost::shared_ptr<gruel::msg_accepter> pmt::pmt_msg_accepter_ref ( const pmt_t & obj )

Return underlying msg_accepter.

Referenced by gruel::send().

GRUEL_API pmt_t pmt::pmt_nth	(	size_t	n,
		pmt_t	list
	)

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

GRUEL_API pmt_t pmt::pmt_nthcdr	(	size_t	n,
		pmt_t	list
	)

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

GRUEL_API void pmt::pmt_print ( pmt_t v )

Write pmt string representation to stdout.

GRUEL_API pmt_t pmt::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.

GRUEL_API pmt_t pmt::pmt_reverse ( pmt_t list )

reverse list.

list must be a proper list.

GRUEL_API pmt_t pmt::pmt_reverse_x ( pmt_t list )

destructively reverse list.

list must be a proper list.

GRUEL_API const int16_t* pmt::pmt_s16vector_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const std::vector<int16_t> pmt::pmt_s16vector_elements ( pmt_t v )

GRUEL_API int16_t pmt::pmt_s16vector_ref	(	pmt_t	v,
		size_t	k
	)

GRUEL_API void pmt::pmt_s16vector_set	(	pmt_t	v,
		size_t	k,
		int16_t	x
	)

GRUEL_API int16_t* pmt::pmt_s16vector_writable_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const std::vector<int32_t> pmt::pmt_s32vector_elements ( pmt_t v )

GRUEL_API const int32_t* pmt::pmt_s32vector_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API int32_t pmt::pmt_s32vector_ref	(	pmt_t	v,
		size_t	k
	)

GRUEL_API void pmt::pmt_s32vector_set	(	pmt_t	v,
		size_t	k,
		int32_t	x
	)

GRUEL_API int32_t* pmt::pmt_s32vector_writable_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const int64_t* pmt::pmt_s64vector_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const std::vector<int64_t> pmt::pmt_s64vector_elements ( pmt_t v )

GRUEL_API int64_t pmt::pmt_s64vector_ref	(	pmt_t	v,
		size_t	k
	)

GRUEL_API void pmt::pmt_s64vector_set	(	pmt_t	v,
		size_t	k,
		int64_t	x
	)

GRUEL_API int64_t* pmt::pmt_s64vector_writable_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const int8_t* pmt::pmt_s8vector_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const std::vector<int8_t> pmt::pmt_s8vector_elements ( pmt_t v )

GRUEL_API int8_t pmt::pmt_s8vector_ref	(	pmt_t	v,
		size_t	k
	)

GRUEL_API void pmt::pmt_s8vector_set	(	pmt_t	v,
		size_t	k,
		int8_t	x
	)

GRUEL_API int8_t* pmt::pmt_s8vector_writable_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API bool pmt::pmt_serialize	(	pmt_t	obj,
		std::streambuf &	sink
	)

Write portable byte-serial representation of obj to sink.

GRUEL_API std::string pmt::pmt_serialize_str ( pmt_t obj )

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

GRUEL_API void pmt::pmt_set_car	(	pmt_t	pair,
		pmt_t	value
	)

Stores value in the car field of pair.

GRUEL_API void pmt::pmt_set_cdr	(	pmt_t	pair,
		pmt_t	value
	)

Stores value in the cdr field of pair.

GRUEL_API pmt_t pmt::pmt_string_to_symbol ( const std::string & s )

Return the symbol whose name is s.

Referenced by tag_source_demo::make_eob_tag(), tag_source_demo::make_sob_tag(), tag_source_demo::make_time_tag(), mp(), and tag_sink_demo::work().

GRUEL_API bool pmt::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.

GRUEL_API const std::string pmt::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.

GRUEL_API bool pmt::pmt_to_bool ( pmt_t val )

Return true if val is PMT_T, return false when val is PMT_F,.

GRUEL_API std::complex<double> pmt::pmt_to_complex ( pmt_t z )

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

GRUEL_API double pmt::pmt_to_double ( pmt_t x )

Convert pmt to double if possible.

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

Referenced by tag_sink_demo::work().

GRUEL_API long pmt::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.

GRUEL_API pmt_t pmt::pmt_to_tuple ( const pmt_t & x )

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

GRUEL_API uint64_t pmt::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.

Referenced by tag_sink_demo::work().

GRUEL_API pmt_t pmt::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.

Referenced by tag_sink_demo::work().

GRUEL_API const std::vector<uint16_t> pmt::pmt_u16vector_elements ( pmt_t v )

GRUEL_API const uint16_t* pmt::pmt_u16vector_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API uint16_t pmt::pmt_u16vector_ref	(	pmt_t	v,
		size_t	k
	)

GRUEL_API void pmt::pmt_u16vector_set	(	pmt_t	v,
		size_t	k,
		uint16_t	x
	)

GRUEL_API uint16_t* pmt::pmt_u16vector_writable_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const uint32_t* pmt::pmt_u32vector_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const std::vector<uint32_t> pmt::pmt_u32vector_elements ( pmt_t v )

GRUEL_API uint32_t pmt::pmt_u32vector_ref	(	pmt_t	v,
		size_t	k
	)

GRUEL_API void pmt::pmt_u32vector_set	(	pmt_t	v,
		size_t	k,
		uint32_t	x
	)

GRUEL_API uint32_t* pmt::pmt_u32vector_writable_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const uint64_t* pmt::pmt_u64vector_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const std::vector<uint64_t> pmt::pmt_u64vector_elements ( pmt_t v )

GRUEL_API uint64_t pmt::pmt_u64vector_ref	(	pmt_t	v,
		size_t	k
	)

GRUEL_API void pmt::pmt_u64vector_set	(	pmt_t	v,
		size_t	k,
		uint64_t	x
	)

GRUEL_API uint64_t* pmt::pmt_u64vector_writable_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const uint8_t* pmt::pmt_u8vector_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const std::vector<uint8_t> pmt::pmt_u8vector_elements ( pmt_t v )

GRUEL_API uint8_t pmt::pmt_u8vector_ref	(	pmt_t	v,
		size_t	k
	)

GRUEL_API void pmt::pmt_u8vector_set	(	pmt_t	v,
		size_t	k,
		uint8_t	x
	)

GRUEL_API uint8_t* pmt::pmt_u8vector_writable_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API const void* pmt::pmt_uniform_vector_elements	(	pmt_t	v,
		size_t &	len
	)

Referenced by tcp_connection::send().

GRUEL_API void* pmt::pmt_uniform_vector_writable_elements	(	pmt_t	v,
		size_t &	len
	)

GRUEL_API void pmt::pmt_vector_fill	(	pmt_t	vector,
		pmt_t	fill
	)

Store fill in every position of vector.

GRUEL_API pmt_t pmt::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.

GRUEL_API void pmt::pmt_vector_set	(	pmt_t	vector,
		size_t	k,
		pmt_t	obj
	)

Store obj in position k.

GRUEL_API void pmt::pmt_write	(	pmt_t	obj,
		std::ostream &	port
	)

Write a written representation of obj to the given port.

GRUEL_API std::string pmt::pmt_write_string ( pmt_t obj )

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

Variable Documentation

GRUEL_API const pmt_t pmt::PMT_EOF

GRUEL_API const pmt_t pmt::PMT_F

GRUEL_API const pmt_t pmt::PMT_NIL

GRUEL_API const pmt_t pmt::PMT_T

Referenced by tag_source_demo::make_eob_tag(), and tag_source_demo::make_sob_tag().

pmt Namespace Reference

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

Function Documentation

Variable Documentation