generic streaming engine More...

#include <dx_stream_engine.h>

Inheritance diagram for dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >:

Collaboration diagram for dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >:

Public Types
typedef device_t::desc_t	desc
typedef decltype(matching_ids)	match
typedef decltype(matching_ids)	match

Public Member Functions
virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END bool	boot () try
void	conclude () noexcept override
	conclude notification: object will be removed. If you overwrite conclude() you also need to overwrite destructor and check if its needed to be called from there.
template<typename desc_t>
void	create (const std::string &, const desc_t &)
virtual void	detach () noexcept
	dx_catchall_rethrow () uint32_t samplerate() const try
	dx_catchall_rethrow () virtual void free() noexcept
	dx_catchall_rethrow () void halt() noexcept override
	stop streaming engine
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	exception (const class exception &exception, bool filtered=false) const noexcept override try
	notification exception handler
virtual void	exception (const exception &exception, bool filtered=false) const noexcept=0
	notification exception handler
void	initialize (uint32_t iosize, const std::vector< bool >(&channel_map)[2]) try
void	launch () override try
	launch notification: object mounted and ready to use
virtual void	launch () try
	launch notification: object mounted and ready to use
void	run () override try
	start streaming engine
void	samplerate (uint32_t samplerate) try
virtual bool	shutdown () try
	client driver::shutdown/boot(): override to shutdown/boot host driver

Public Attributes
cf::string	connection_id = ::IOObjectCopyBundleIdentifierForClass(cf::string{this->product_id}.retain())
T	elements
	STL member.
dx::promoted< dx::log >	host
	host logging control
K	keys
	STL member.
bool	launched
log	log
decltype(device<>::preference)	preference
const char *	product_id
io::registry	registry
std::deque< setup >	setup
uint32_t	version

Static Public Attributes
static constexpr auto	connection_id = class_name

Protected Types
typedef dx::clock< typename device_t::event_t >	clock
typedef decltype(device_t::id)	device_id_t
typedef device<>	device_t

Protected Member Functions
virtual void	add (const decltype(device<>::id) &)=0
	adds a new device to the device list
virtual void	add (const decltype(device<>::id) &)=0
	adds a new device to the device list
void	add (const device_id_t &device_id) override try
	adds a new device to the device list
dx_catchall_handler(this,) using super void	arrived () override try
	notify device arrivals completed stub
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void	clear () noexcept try
	replaces std::map::clear to call virtual notification methods
	dx_catchall_handler (this,) virtual driver &operator<<(std
	restores device settings
	dx_catchall_rethrow () virtual void process(int64_t timestamp) noexcept=0
	dx_catchall_rethrow () void tick() override try
	engine (const typename super::match &matching_ids, const char *product_id, const decltype(super::preference)&preference, dx::log log={})
virtual void	halt () noexcept
	stop and remove clock thread
void	info (std::ostream &os) noexcept override
	log object class information
realtime &	initialize (const std::chrono::high_resolution_clock::duration &resolution)
void	initialize (const typename std::chrono::high_resolution_clock::duration &duration)
realtime &	initialize (const std::chrono::high_resolution_clock::duration &resolution)
virtual void	notify () noexcept
	notify change from device requiring streaming reset
virtual void	notify (uint32_t) noexcept
	notify sample rate change from device
	operator event_t & () noexcept
	operator event_t * () noexcept
virtual driver &	operator<< (const char *file)
virtual driver &	operator>> (std::ostream &ostream) const
	saves device tree
virtual void	overload () noexcept
virtual void	remove (const decltype(device<>::id) &)=0
	finds and removes a device from the device list
virtual void	remove (const decltype(device<>::id) &)=0
	finds and removes a device from the device list
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	remove (const device_id_t &device_id) override try
	finds and removes a device from the device list
dx_catchall_rethrow() using super void	removed (device_t &device) noexcept override
void	sleep () override
	< notify system will sleep
virtual void	sync (const typename std::chrono::high_resolution_clock::time_point &now)
void	sync (const std::chrono::high_resolution_clock::time_point &now) override try
virtual void	tick ()=0
void	update () noexcept try
virtual clock &	wait (bool reset=false) try
void	wake () override
	~engine () override

Protected Attributes
struct {
circular_t * circular [direction::directions]
force_read force_read
force_write force_write
struct {
struct {
uint32_t interval
	clock resolution: HW stream frame size in samples More...
uint32_t linesize
uint32_t safety_offset
} io [direction::directions]
direction::direction reference
uint32_t samplerate
int64_t trigger
	resync condition More...
} sync
}	cache
std::shared_ptr< device_t >	device
std::chrono::high_resolution_clock::duration	duration
event_t	event
dx_catchall_rethrow() std uint64_t	frame = 0
bool	hw_clock = false
io_t **	io [direction::directions][2] {}
uint32_t	iosize = 0
bool	kernel_streaming = false
std::set< dx::guid >	matching_ids
dx::stream::clock::monitor *	monitor = nullptr
	io[directions][double buffer][channel][sample]
std::mutex	mutex
struct dx::proxy::driver::notification	notification
std::chrono::high_resolution_clock::time_point	objective
std::atomic< bool >	running
os_result	status

Detailed Description

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
class dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >

generic streaming engine

Exceptions

in	case of an error returned by the underlaying API the device class throws a dx::exception.

Member Typedef Documentation

◆ clock

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

typedef dx::clock<typename device_t::event_t> dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::clock

protected

◆ desc

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

typedef device_t::desc_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::desc

◆ device_id_t

typedef decltype(device_t::id) dx::map::driver< device<> >::device_id_t

protectedinherited

◆ device_t

typedef device<> dx::map::driver< device<> >::device_t

protectedinherited

◆ match [1/2]

template<typename device_t = device<>>

typedef decltype(matching_ids) dx::proxy::driver< device_t >::match

inherited

◆ match [2/2]

template<typename device_t = device<>>

typedef decltype(matching_ids) dx::proxy::driver< device_t >::match

inherited

Todo: proxy::driver::connection_id: reflect driver presence

Constructor & Destructor Documentation

◆ engine()

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::engine	(	const typename super::match &	matching_ids,
		const char *	product_id,
		const decltype(super::preference)&	preference,
		dx::log	log = {} )

inlineprotected

◆ ~engine()

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::~engine ( )

inlineoverrideprotected

Member Function Documentation

◆ add() [1/3]

virtual void dx::driver< decltype(device<>::id), decltype(device<>::preference) >::add ( const decltype(device<>::id) & )

protectedpure virtualinherited

adds a new device to the device list

Exceptions

dx::exception

◆ add() [2/3]

virtual void dx::driver< decltype(device<>::id), decltype(device<>::preference) >::add ( const decltype(device<>::id) & )

protectedpure virtualinherited

adds a new device to the device list

Exceptions

dx::exception

◆ add() [3/3]

void dx::map::driver< device<> >::add ( const device_id_t & device_id )

inlineoverrideprotectedinherited

adds a new device to the device list

Exceptions

dx::exception

Here is the caller graph for this function:

◆ arrived()

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

dx_catchall_handler(this,) using super void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::arrived ( )

inlineoverrideprotectedvirtual

notify device arrivals completed stub

pin creation exception caught here to allow device inspection even if streaming is not possible - most likely due to exclusive access.

Todo: forward pin creation exception to be thrown at engine::start()

Reimplemented from dx::map::driver< device<> >.

◆ boot()

virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END bool dx::driver< decltype(device<>::id), decltype(device<>::preference) >::boot ( )

inlinevirtualinherited

◆ catch()

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::map::driver< device<> >::catch ( const dx::exception & __dx_exception )

inlineprotectedinherited

◆ clear()

virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::map::driver< device<> >::clear ( )

inlineprotectedvirtualnoexceptinherited

replaces std::map::clear to call virtual notification methods

◆ conclude()

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::conclude ( )

inlineoverridevirtualnoexcept

conclude notification: object will be removed. If you overwrite conclude() you also need to overwrite destructor and check if its needed to be called from there.

Reimplemented from dx::map::driver< device<> >.

Here is the caller graph for this function:

◆ create()

template<typename device_t = device<>>

template<typename desc_t>

void dx::proxy::driver< device_t >::create	(	const std::string &	,
		const desc_t &	)

inlineinherited

Todo: proxy::driver::operator bool() check if driver is installed

◆ detach()

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

virtual void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::detach ( )

inlinevirtualnoexcept

Here is the caller graph for this function:

◆ dx_catchall_handler()

dx::map::driver< device<> >::dx_catchall_handler ( this ) &

inlineprotectedinherited

restores device settings

◆ dx_catchall_rethrow() [1/5]

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::dx_catchall_rethrow ( ) const

inline

◆ dx_catchall_rethrow() [2/5]

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::dx_catchall_rethrow ( )

inlinenoexcept

Todo: replace test for valid pin by overwise keeping track of allocated channels

◆ dx_catchall_rethrow() [3/5]

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::dx_catchall_rethrow ( )

protectedpure virtualnoexcept

Implemented in dx::asio::driver< device_t, pin_t, driver_t >.

◆ dx_catchall_rethrow() [4/5]

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::dx_catchall_rethrow ( )

inlineoverridenoexcept

stop streaming engine

◆ dx_catchall_rethrow() [5/5]

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::dx_catchall_rethrow ( )

inlineoverrideprotected

Todo: enable re-sync with correct rx/tx position dependent clock event time point

◆ exception() [1/2]

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::driver< decltype(device<>::id), decltype(device<>::preference) >::exception	(	const class exception &	exception,
		bool	filtered = false ) const

inlineoverridenoexceptinherited

notification exception handler

Here is the caller graph for this function:

◆ exception() [2/2]

virtual void dx::object::exception	(	const exception &	exception,
		bool	filtered = false ) const

pure virtualnoexceptinherited

notification exception handler

◆ halt()

virtual void dx::clock< event_t, std::chrono::high_resolution_clock >::halt ( )

inlinevirtualnoexceptinherited

stop and remove clock thread

Here is the caller graph for this function:

◆ info()

void dx::map::driver< device<> >::info ( std::ostream & os )

inlineoverrideprotectedvirtualnoexceptinherited

log object class information

Reimplemented from dx::object.

◆ initialize() [1/4]

realtime & dx::thread::prio::realtime::initialize ( const std::chrono::high_resolution_clock< device_t::event_t >::duration & resolution )

inlineinherited

Todo: dx::thread::prio: replace experimental hardcoded preemption limit with real limit obtained from machine

◆ initialize() [2/4]

void dx::clock< event_t, std::chrono::high_resolution_clock >::initialize ( const typename std::chrono::high_resolution_clock< device_t::event_t >::duration & duration )

inlineinherited

◆ initialize() [3/4]

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::initialize	(	uint32_t	iosize,
		const std::vector< bool >(&)	channel_map[2] )

inline

Todo: clock already runnning with different iosize: check if engine should be initialized with current iosize

Todo: stream::engine::initialize(): define sync reference pin

◆ initialize() [4/4]

realtime & dx::thread::prio::realtime::initialize ( const std::chrono::high_resolution_clock::duration & resolution )

inlineinherited

Todo: dx::thread::prio: replace experimental hardcoded preemption limit with real limit obtained from machine

Here is the call graph for this function:

◆ launch() [1/2]

template<typename device_t = device<>>

void dx::proxy::driver< device_t >::launch ( )

inlineoverridevirtualinherited

launch notification: object mounted and ready to use

Reimplemented from dx::map::driver< device<> >.

Here is the call graph for this function:

◆ launch() [2/2]

template<typename device_t = device<>>

virtual void dx::proxy::driver< device_t >::launch ( )

inlinevirtualinherited

launch notification: object mounted and ready to use

Reimplemented from dx::map::driver< device<> >.

Here is the call graph for this function:

◆ notify() [1/2]

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

virtual void dx::clock< event_t, std::chrono::high_resolution_clock >::notify ( )

inlineprotectedvirtualnoexcept

notify change from device requiring streaming reset

Reimplemented from dx::clock< device_t::event_t >.

Here is the caller graph for this function:

◆ notify() [2/2]

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

virtual void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::notify ( uint32_t )

inlineprotectedvirtualnoexcept

notify sample rate change from device

Reimplemented in dx::asio::driver< device_t, pin_t, driver_t >.

◆ operator event_t &()

dx::clock< event_t, std::chrono::high_resolution_clock >::operator event_t & ( )

inlinenoexceptinherited

◆ operator event_t *()

dx::clock< event_t, std::chrono::high_resolution_clock >::operator event_t * ( )

inlinenoexceptinherited

◆ operator<<()

virtual driver & dx::map::driver< device<> >::operator<< ( const char * file )

inlineprotectedvirtualinherited

◆ operator>>()

virtual driver & dx::map::driver< device<> >::operator>> ( std::ostream & ostream ) const

inlineprotectedvirtualinherited

saves device tree

◆ overload()

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

virtual void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::overload ( )

inlineprotectedvirtualnoexcept

Reimplemented in dx::asio::driver< device_t, pin_t, driver_t >.

◆ remove() [1/3]

virtual void dx::driver< decltype(device<>::id), decltype(device<>::preference) >::remove ( const decltype(device<>::id) & )

protectedpure virtualinherited

finds and removes a device from the device list

◆ remove() [2/3]

virtual void dx::driver< decltype(device<>::id), decltype(device<>::preference) >::remove ( const decltype(device<>::id) & )

protectedpure virtualinherited

finds and removes a device from the device list

◆ remove() [3/3]

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::map::driver< device<> >::remove ( const device_id_t & device_id )

inlineoverrideprotectedinherited

finds and removes a device from the device list

Exceptions

dx::exception

◆ removed()

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

dx_catchall_rethrow() using super void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::removed ( device_t & device )

inlineoverrideprotectednoexcept

◆ run()

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::run ( )

inlineoverridevirtual

start streaming engine

Reimplemented from dx::clock< device_t::event_t >.

◆ samplerate()

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::samplerate ( uint32_t samplerate )

inline

◆ shutdown()

virtual bool dx::driver< decltype(device<>::id), decltype(device<>::preference) >::shutdown ( )

inlinevirtualinherited

client driver::shutdown/boot(): override to shutdown/boot host driver

◆ sleep()

void dx::map::driver< device<> >::sleep ( )

inlineoverrideprotectedinherited

< notify system will sleep

notify system wake completed stub

◆ sync() [1/2]

virtual void dx::clock< event_t, std::chrono::high_resolution_clock >::sync ( const typename std::chrono::high_resolution_clock< device_t::event_t >::time_point & now )

inlineprotectedvirtualinherited

◆ sync() [2/2]

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::sync ( const std::chrono::high_resolution_clock::time_point & now )

inlineoverrideprotected

◆ tick()

virtual void dx::clock< event_t, std::chrono::high_resolution_clock >::tick ( )

protectedpure virtualinherited

◆ update()

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::update ( )

inlineprotectednoexcept

Here is the caller graph for this function:

◆ wait()

virtual clock & dx::clock< event_t, std::chrono::high_resolution_clock >::wait ( bool reset = false )

inlinevirtualinherited

◆ wake()

void dx::map::driver< device<> >::wake ( )

inlineoverrideprotectedinherited

Member Data Documentation

◆ [struct]

struct { ... } dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::cache

◆ circular

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

circular_t* dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::circular[direction::directions]

◆ connection_id [1/2]

template<typename device_t = device<>>

cf::string dx::proxy::driver< device_t >::connection_id = ::IOObjectCopyBundleIdentifierForClass(cf::string{this->product_id}.retain())

inherited

◆ connection_id [2/2]

template<typename device_t = device<>>

auto dx::proxy::driver< device_t >::connection_id = class_name

staticconstexprinherited

◆ device

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

std::shared_ptr<device_t> dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::device

protected

◆ duration

std::chrono::high_resolution_clock::duration dx::clock< event_t, std::chrono::high_resolution_clock >::duration

protectedinherited

Todo: evaluate clock::status replacement (exception?)

◆ elements

T std::map< K, T >::elements

inherited

STL member.

◆ event

event_t dx::clock< event_t, std::chrono::high_resolution_clock >::event

protectedinherited

◆ force_read

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

force_read dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::force_read

◆ force_write

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

force_write dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::force_write

◆ frame

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

dx_catchall_rethrow () std uint64_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::frame = 0

protected

◆ host

dx::promoted<dx::log> dx::driver< decltype(device<>::id), decltype(device<>::preference) >::host

inherited

host logging control

◆ hw_clock

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

bool dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::hw_clock = false

protected

◆ interval

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

uint32_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::interval

clock resolution: HW stream frame size in samples

◆ [struct] [1/2]

struct { ... } dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::io[direction::directions]

◆ io [2/2]

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

io_t** dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::io[direction::directions][2] {}

protected

◆ iosize

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

uint32_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::iosize = 0

protected

◆ kernel_streaming

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

bool dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::kernel_streaming = false

protected

◆ keys

K std::map< K, T >::keys

inherited

STL member.

◆ launched

bool dx::object::launched

inherited

◆ linesize

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

uint32_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::linesize

◆ log

log dx::driver< decltype(device<>::id), decltype(device<>::preference) >::log

inherited

◆ matching_ids

template<typename device_t = device<>>

std::set<dx::guid> dx::proxy::driver< device_t >::matching_ids

protectedinherited

◆ monitor

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

dx::stream::clock::monitor* dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::monitor = nullptr

protected

io[directions][double buffer][channel][sample]

◆ mutex

std::mutex dx::clock< event_t, std::chrono::high_resolution_clock >::mutex

protectedinherited

◆ notification

template<typename device_t = device<>>

struct dx::proxy::driver::notification dx::proxy::driver< device_t >::notification

protectedinherited

◆ objective

std::chrono::high_resolution_clock::time_point dx::clock< event_t, std::chrono::high_resolution_clock >::objective

protectedinherited

◆ preference

decltype(device<>::preference) dx::driver< decltype(device<>::id), decltype(device<>::preference) >::preference

inherited

◆ product_id

const char* dx::driver< decltype(device<>::id), decltype(device<>::preference) >::product_id

inherited

◆ reference

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

direction::direction dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::reference

◆ registry

template<typename device_t = device<>>

io::registry dx::proxy::driver< device_t >::registry

inherited

◆ running

std::atomic<bool> dx::clock< event_t, std::chrono::high_resolution_clock >::running

protectedinherited

◆ safety_offset

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

uint32_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::safety_offset {}

◆ samplerate

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

uint32_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::samplerate

◆ setup

template<typename device_t = device<>>

std::deque<setup> dx::proxy::driver< device_t >::setup

inherited

◆ status

os_result dx::clock< event_t, std::chrono::high_resolution_clock >::status

protectedinherited

◆ [struct]

struct { ... } dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::sync

◆ trigger

template<typename device_t, typename pin_t, typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

int64_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::trigger

resync condition

◆ version

uint32_t dx::driver< decltype(device<>::id), decltype(device<>::preference) >::version

inherited

The documentation for this class was generated from the following file:

dx_stream_engine.h

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ clock

◆ desc

◆ device_id_t

◆ device_t

◆ match [1/2]

◆ match [2/2]

Constructor & Destructor Documentation

◆ engine()

◆ ~engine()

Member Function Documentation

◆ add() [1/3]

◆ add() [2/3]

◆ add() [3/3]

◆ arrived()

◆ boot()

◆ catch()

◆ clear()

◆ conclude()

◆ create()

◆ detach()

◆ dx_catchall_handler()

◆ dx_catchall_rethrow() [1/5]

◆ dx_catchall_rethrow() [2/5]

◆ dx_catchall_rethrow() [3/5]

◆ dx_catchall_rethrow() [4/5]

◆ dx_catchall_rethrow() [5/5]

◆ exception() [1/2]

◆ exception() [2/2]

◆ halt()

◆ info()

◆ initialize() [1/4]

◆ initialize() [2/4]

◆ initialize() [3/4]

◆ initialize() [4/4]

◆ launch() [1/2]

◆ launch() [2/2]

◆ notify() [1/2]

◆ notify() [2/2]

◆ operator event_t &()

◆ operator event_t *()

◆ operator<<()

◆ operator>>()

◆ overload()

◆ remove() [1/3]

◆ remove() [2/3]

◆ remove() [3/3]

◆ removed()

◆ run()

◆ samplerate()

◆ shutdown()

◆ sleep()

◆ sync() [1/2]

◆ sync() [2/2]

◆ tick()

◆ update()

◆ wait()

◆ wake()

Member Data Documentation

◆ [struct]

◆ circular

◆ connection_id [1/2]

◆ connection_id [2/2]

◆ device

◆ duration

◆ elements

◆ event

◆ force_read

◆ force_write

◆ frame

◆ host

◆ hw_clock