dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t > Class Template Reference

#include <dx_proxy_stream_device.h>

Inheritance diagram for dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >:

Collaboration diagram for dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >:

Classes
class	chain
	drives one of the device's own promoted values through an IOCTL More...
class	monitor
	the driver's clock monitor, mapped on demand and handed back at the end of the scope; a driver that does not keep one answers not_implemented and the monitor stays empty More...
class	promoted
	dx::proxy::stream::device::promoted with device::preference More...

Public Types
typedef desc_t	desc_t
typedef shared::event	event_t
	the driver signals this client through it: the engine's clock and every stream's data events
typedef std::set< std::string >	keys
typedef promoted< uint32_t >::template preference< decltype(dx::proxy::device< preference_t >::preference)>	source_t
typedef stream_t	stream_t
enum class	type : ::DWORD {   undefined = REG_NONE , uint32 = REG_DWORD , uint64 = REG_QWORD , string = REG_SZ ,   vendor = REG_BINARY }
	the value types this store keeps - a scalar rides as REG_DWORD/REG_QWORD rather than as a byte copy, so a value written here reads like any other in the registry editor More...

Public Member Functions
	_device (decltype(super::driver)&driver, decltype(super::id)&id, const std::pair< std::string, std::string > &identity={})
void	attach (channel_t **io[dx::stream::direction::directions][2], const std::vector< bool >(&channel_map)[2])
	catch (...)
	catch (...)
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. Called only through try_conclude() - never call this directly from outside the class hierarchy.
unsigned char	configuration () const
unsigned char	configuration (unsigned char configuration)
unsigned char	configurations () const
auto	count () const noexcept
void	ctl (uint32_t ioctl) const
void	ctl (unsigned int ioctl) const
registry &	erase (const char *subkey=nullptr) noexcept
void	exception (const dx::exception &exception, bool filtered=false) const noexcept override
	notification exception handler
void	exception (const dx::exception &exception, bool filtered=false) const noexcept override
	notification exception handler
virtual uint64_t	frame () const
virtual void	free () noexcept
template<typename value_t>
value_t	get () const
template<typename value_t>
bool	get (value_t &value) const
template<typename value_t, typename = cf::enable_if_convertible<value_t>>
value_t	get (::CFStringRef key) const
::CFTypeRef	get (::CFStringRef key) const
template<typename value_t, typename = cf::enable_if_convertible<value_t>>
value_t	get (::CFStringRef key, ::CFTypeRef dflt) const noexcept
::CFTypeRef	get (::CFStringRef key, ::CFTypeRef dflt) const noexcept
template<typename value_t, typename = cf::enable_if_convertible<value_t>>
value_t	get (::CFStringRef key, value_t dflt) const noexcept
template<typename key_t, typename value_t, typename = cf::enable_if_convertible<key_t>, typename = cf::enable_if_convertible<value_t>>
value_t	get (key_t key) const
template<typename key_t, typename = cf::enable_if_convertible<key_t>>
::CFTypeRef	get (key_t key) const
void	grouped (typename super::group_t &group) override
void	hw_clock (abstract::event *hw_clock, uint32_t iosize) override
	registers this client's buffer switch event with the driver's clock domain
virtual bool	hw_clock () const noexcept
template<typename rx_t>
enable_if_ptr< rx_t >	ictl (uint32_t ioctl) const
template<typename rx_t>
enable_if_scalar< rx_t >	ictl (uint32_t ioctl) const
template<typename rx_t>
hide_if_scalar_or_ptr< rx_t >	ictl (uint32_t ioctl) const
	member ioctl
template<typename rx_t>
size_t	ictl (uint32_t ioctl, rx_t &rx) const
template<typename rx_t>
rx_t	ictl (unsigned int ioctl) const
	Windows: member ioctl.
template<typename rx_t>
size_t	ictl (unsigned int ioctl, rx_t &rx) const
void	info (std::ostream &os) noexcept override
	log object class information
void	initialize (const char *name, ::DWORD access=GENERIC_READ|GENERIC_WRITE, ::DWORD share=FILE_SHARE_READ|FILE_SHARE_WRITE)
	(re-)initialization the underlaying windows API is CreateFile(). for detailed information see http://msdn.microsoft.com/en-us/library/aa363858(VS.85).aspx
registry &	initialize (::HKEY root, ::REGSAM rights=KEY_ALL_ACCESS)
registry &	initialize (::REGSAM rights=KEY_ALL_ACCESS, ::HKEY root=HKEY_CURRENT_USER)
registry &	initialize (const std::string &key, ::HKEY root=HKEY_CURRENT_USER, ::REGSAM rights=KEY_ALL_ACCESS)
template<typename rx_t, typename tx_t>
rx_t	ioctl (uint32_t ioctl, const tx_t &tx) const
template<typename rx_t, typename tx_t>
size_t	ioctl (uint32_t ioctl, const tx_t &tx, rx_t &rx) const
size_t	ioctl (uint32_t ioctl, const void *tx=nullptr, size_t tx_size=0, void *rx=nullptr, size_t rx_size=0) const
template<typename rx_t, typename tx_t>
rx_t	ioctl (unsigned int ioctl, const tx_t &tx) const
template<typename tx_t, typename rx_t>
size_t	ioctl (unsigned int ioctl, const tx_t &tx, rx_t &rx) const
void	launch () override
	launch notification: object mounted and ready to use. Called only through try_launch() - never call this directly from outside the class hierarchy.
template<typename tx_t, typename = hide_if_ptr<tx_t>>
device &	octl (uint32_t ioctl, const tx_t &tx)
template<typename tx_t, typename = enable_if_ptr<tx_t>>
device &	octl (uint32_t ioctl, const tx_t tx)
template<typename tx_t>
void	octl (unsigned int ioctl, const tx_t &tx) const
std::shared_ptr< stream_t >	open (const typename desc_t::stream::desc &desc)
	the desc's stream: the registered one, else created, registered and launched
	operator const ::io_registry_entry_t & () const noexcept
	auto converter into const io_object
	operator const ::io_registry_entry_t & () const noexcept
	auto converter into const io_object
	operator const os_event () const noexcept
	operator const std::string & () const noexcept
	identifying device string, mirroring macOS' io::registry conversion
	operator os_event () noexcept
	operator uint64_t () const
	operator::CFMutableDictionaryRef () const
	operator::CFStringRef () const
	operator::HANDLE () const noexcept
	operator::HKEY () const noexcept
	operator::io_registry_entry_t & () noexcept
	auto converter into io_object
	operator::io_registry_entry_t & () noexcept
	auto converter into io_object
	operator::io_registry_entry_t * () noexcept
	auto converter into io_object pointer
	operator::io_registry_entry_t * () noexcept
	auto converter into io_object pointer
virtual void	operator= (const desc_t &desc)
bool	operator== (::io_registry_entry_t io_object) const noexcept
virtual device &	operator>> (std::ostream &) const
	the device's own diagnostics, beyond dx::object::info
virtual device &	operator>> (std::ostream &) const
	the device's own diagnostics, beyond dx::object::info
group_t &	operator[] (const typename desc_t::stream::desc &stream)
	the stream's group, created on first use
::CFTypeRef	operator[] (::CFStringRef key) const
template<typename key_t, typename = cf::enable_if_convertible<key_t>>
::CFTypeRef	operator[] (key_t key) const
registry	parent () const
_device &	reset ()
reference &	retain ()
registry &	run ()
device &	set (::CFStringRef key, ::CFTypeRef value) noexcept
template<typename value_t, typename = cf::enable_if_convertible<value_t>>
device &	set (::CFStringRef key, value_t value)
device &	set (::CFTypeRef properties)
	Setting properties in a registry entry is not generally supported, it is more common to support setting of properties of the connection based property setting of dx::device.
template<typename key_t, typename = cf::enable_if_convertible<key_t>>
device &	set (key_t key, ::CFTypeRef value)
template<typename key_t, typename value_t, typename = cf::enable_if_convertible<key_t>, typename = cf::enable_if_convertible<value_t>>
device &	set (key_t key, value_t value)
registry &	set (::DWORD type, const void *value, size_t size)
size_t	size () const noexcept
virtual void	sleep ()
	notify system will sleep stub
virtual void	sleep ()
	notify system will sleep stub
virtual std::pair< source_t &, bool >	source (const struct desc_t::stream &stream)
	the stream's source selector, created on first use: the preference by stream target, the value an index into the stream's sources
virtual std::string	string (uint8_t) const
bool	try_conclude () noexcept
	atomically conclude()s if currently launched; returns whether this call did it
bool	try_conclude () noexcept
	atomically conclude()s if currently launched; returns whether this call did it
bool	try_launch ()
	atomically launch()es if not already launched; returns whether this call did it
bool	try_launch ()
	atomically launch()es if not already launched; returns whether this call did it
type	type () const noexcept
void	wake () override
	~_device () override

Static Public Member Functions
template<typename value_t, typename self_t>
static void	assign (const self_t &self, const value_t &value)
template<typename self_t>
static registry	at (const self_t &self)
template<typename container_t, typename self_t>
static container_t	children (const self_t &self) noexcept
template<typename desc_t>
static void	create (const char *product_id, const ::GUID &guid, const std::string &id, const desc_t &desc)
	persisted software device: PnP keeps it enumerated after the creating handle closes
static void	destroy (const char *product_id, const ::GUID &guid, const std::string &id)
	re-acquires the persisted device and binds it to the closing handle; PnP keeps the removed device's node as a phantom, uninstalled here
template<typename value_t, typename self_t>
static bool	fetch (const self_t &self, value_t &value)
template<typename self_t>
static bool	nested (const self_t &self) noexcept
template<typename self_t>
static void	purge (const self_t &self) noexcept
template<typename self_t>
static size_t	size (const self_t &self) noexcept

Public Attributes
promoted< typename super::client_map, typename super::client_map::value_t >	clients {*this, ioctl::stream::clients}
dx::shared::lockfree::list< registration >	clock
	the tick walks it without a lock
promoted< uint32_t >::preference< decltype(super::preference)>	clocksource
dx::stream::clock::consumer	consumer
promoted< desc_t, typename desc_t::value_t >	desc {*this, ioctl::stream::desc}
dx::driver< decltype(id), preference_t > &	driver
dx::driver< decltype(id), preference_t > &	driver
abstract::event *	event
std::map< decltype(desc_t::stream::group), group_t >	group
	streaming groups by desc::stream::group id: every stream of this device is registered with its group - behind the settings its groups listen to, so they go first
struct {
struct registration {
dx::stream::clock::consumer   consumer
abstract::event *   event
volatile bool   reset {}
}
dx::shared::lockfree::list< registration >   clock
	the tick walks it without a lock More...
uint32_t   iosize
	staging value for registration paths without their own iosize argument (macOS CF property bridge) More...
std::mutex   mutex
	the registrations' writers More...
std::map< abstract::event *, std::unique_ptr< registration > >   registrations
}	hw
promoted< std::string >	icon {*this, ioctl::device::icon}
const std::string	id
const ::io_service_t	id
promoted< uint32_t >::preference< decltype(super::preference)>	iosize
uint32_t	iosize
	staging value for registration paths without their own iosize argument (macOS CF property bridge)
chain< uint32_t >	iosize_server {*this, super::iosize, ioctl::stream::clock::iosize}
std::string	key
std::atomic< bool >	launched
std::atomic< bool >	launched
std::deque< std::function< void()> >	listen
dx::stream::device::monitor	monitor
std::mutex	mutex
	the registrations' writers
preference_t	preference
preference_t	preference
std::string	puid
	persistent UID - system unique - could change with location
std::string	puid
	persistent UID - system unique - could change with location
std::string	puuid
	persistent universal UID - universally unique ID (i.e. serial number)
std::string	puuid
	persistent universal UID - universally unique ID (i.e. serial number)
std::map< abstract::event *, std::unique_ptr< registration > >	registrations
std::list< promoted< uint32_t > >	safety_offset_server
	per group: the kernel keeps the client margins of its streams
dx::promoted< uint32_t >	samplerate
bool	schedule_erase {}
std::map< decltype(desc_t::stream::target.idx()), source_t >	sources
promoted< structdesc_t::stream * >::template preference< decltype(super::preference), uint32_t >	sync_reference
class dx::proxy::stream::_device::monitor *	this
dx::stream::device::monitor	version

Static Public Attributes
static constexpr bool	hosted
	the transport's settings belong to another process' device: a hosted device mirrors them through its chains, it keeps no store of them

Protected Types
typedef service::request< service::stream::data< typename super_device_t::desc_t > >	request
typedef pipe< request >::template server< user_client, std::weak_ptr< device > >	server
	pipe::server connecting user_clients The pipe holds a std::weak_ptr<device> as a temporary by the pipe::server::args variadic tuple to create shared device references for the user_client. At time of device construction there is not yet a std::shared_ptr<device>, therefore the pipe::server::args weak_ptr assignment happens at service::device::launch().

Protected Member Functions
std::string	canonical (const std::string &name) const
void	grouped (typename super::group_t &group) override
virtual void	grouped (group_t &)
	operator[](): a group just came into existence, a host wires its per-group transports here
registry &	initialize (const std::string &key, ::REGSAM rights, ::HKEY root, const char *path=nullptr)
virtual void	launch ()
	launch notification: object mounted and ready to use. Called only through try_launch() - never call this directly from outside the class hierarchy.

Protected Attributes
bool	connected = false
std::list< promoted >	group_server
	per-group chains, wired as each group comes into existence (grouped())
::HANDLE	handle {invalid_t}
struct {
cf::string   bundle_id
cf::string   class_name
}	kernel
class dx::service::device::promoted	pipe
server	pipe
io::port	port
::HANDLE	process {::GetCurrentProcess()}

Friends
template<typename>
class	dx::proxy::stream::group
	the app wraps this bus's own group, so friendship has to name it, not just the device's group_t

Member Typedef Documentation

desc_t

typedef desc_t dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::desc_t

inherited

event_t

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

typedef shared::event dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::event_t

the driver signals this client through it: the engine's clock and every stream's data events

keys

typedef std::set<std::string> dx::registry::keys

inherited

request

template<typename preference_t>

typedef service::request<service::stream::data<typename super_device_t::desc_t> > dx::service::device< preference_t >::request

protectedinherited

server

template<typename preference_t>

typedef pipe<request>::template server<user_client, std::weak_ptr<device> > dx::service::device< preference_t >::server

protectedinherited

pipe::server connecting user_clients The pipe holds a std::weak_ptr<device> as a temporary by the pipe::server::args variadic tuple to create shared device references for the user_client. At time of device construction there is not yet a std::shared_ptr<device>, therefore the pipe::server::args weak_ptr assignment happens at service::device::launch().

source_t

typedef promoted<uint32_t>::template preference<decltype(dx::proxy::device< preference_t >::preference)> dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::source_t

inherited

stream_t

typedef stream_t dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::stream_t

inherited

Member Enumeration Documentation

type

enum class dx::registry::type : ::DWORD

stronginherited

the value types this store keeps - a scalar rides as REG_DWORD/REG_QWORD rather than as a byte copy, so a value written here reads like any other in the registry editor

Enumerator
undefined
uint32
uint64
string
vendor

Constructor & Destructor Documentation

_device()

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::_device ( decltype(super::driver)& driver, decltype(super::id)& id, const std::pair< std::string, std::string > & identity = {} )

inline

the driver's log mask follows the host's: –log-level reaches the kernel

Here is the caller graph for this function:

~_device()

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::~_device ( )

inlineoverride

Member Function Documentation

assign()

template<typename value_t, typename self_t>

void dx::registry::assign ( const self_t & self, const value_t & value )

inlinestaticinherited

Here is the call graph for this function:

Here is the caller graph for this function:

at()

template<typename self_t>

registry dx::registry::at ( const self_t & self )

inlinestaticinherited

dx::key_value_tree<registry> contract: resolves self's parent chain into one real key/value position, then delegates below - the only place a registry[k1][k2]..[kN] chain becomes real subkeys/values.

Here is the call graph for this function:

Here is the caller graph for this function:

attach()

void dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::attach ( channel_t ** io[dx::stream::direction::directions][2], const std::vector< bool >(&) channel_map[2] )

inlineinherited

canonical()

std::string dx::registry::canonical ( const std::string & name ) const

inlineprotectedinherited

Here is the caller graph for this function:

catch() [1/2]

dx::registry::catch ( ... )

inlineinherited

catch() [2/2]

dx::registry::catch ( ... )

inlineinherited

children()

template<typename container_t, typename self_t>

container_t dx::registry::children ( const self_t & self )

inlinestaticnoexceptinherited

self's own child names as any string container, yielding an empty one when the key is absent or inaccessible. Stays a static, not a dx::key_value_tree-style operator container_t(): registry is a dependent base of key_value_tree<registry> (inherited via the tree_t template parameter), and key_value_tree's own operator value_t() becomes entirely unreachable once a dependent base declares a same-shaped operator container_t() template of its own.

Here is the call graph for this function:

conclude()

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

void dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_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. Called only through try_conclude() - never call this directly from outside the class hierarchy.

Reimplemented from dx::proxy::device< preference_t >.

configuration() [1/2]

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

unsigned char dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::configuration ( ) const

inline

configuration() [2/2]

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

unsigned char dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::configuration ( unsigned char configuration )

inline

configurations()

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

unsigned char dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::configurations ( ) const

inline

count()

auto io::reference< ::io_registry_entry_t >::count ( ) const

inlinenoexceptinherited

Here is the caller graph for this function:

create()

template<typename preference_t>

template<typename desc_t>

void dx::proxy::device< preference_t >::create ( const char * product_id, const ::GUID & guid, const std::string & id, const desc_t & desc )

inlinestaticinherited

persisted software device: PnP keeps it enumerated after the creating handle closes

Here is the call graph for this function:

ctl() [1/2]

template<typename preference_t>

void dx::proxy::device< preference_t >::ctl ( uint32_t ioctl ) const

inlineinherited

Here is the call graph for this function:

ctl() [2/2]

template<typename preference_t>

void dx::proxy::device< preference_t >::ctl ( unsigned int ioctl ) const

inlineinherited

Here is the call graph for this function:

destroy()

template<typename preference_t>

void dx::proxy::device< preference_t >::destroy ( const char * product_id, const ::GUID & guid, const std::string & id )

inlinestaticinherited

re-acquires the persisted device and binds it to the closing handle; PnP keeps the removed device's node as a phantom, uninstalled here

Here is the call graph for this function:

erase()

registry & dx::registry::erase ( const char * subkey = nullptr )

inlinenoexceptinherited

Here is the call graph for this function:

Here is the caller graph for this function:

exception() [1/2]

template<typename preference_t>

void dx::proxy::device< preference_t >::exception ( const dx::exception & exception, bool filtered = false ) const

inlineoverridevirtualnoexceptinherited

notification exception handler

Reimplemented from dx::device<::io_service_t, preference_t >.

Reimplemented in dx::usb::device< preference_t >, dx::usb::device< dx::preference >, dx::usb::platform::device< preference_t >, dx::usb::platform::device< preference_t >, dx::usb::platform::device< dx::preference >, dx::usb::platform::device< preference_t >, and dx::usb::platform::device< preference_t >.

Here is the call graph for this function:

Here is the caller graph for this function:

exception() [2/2]

template<typename preference_t>

void dx::proxy::device< preference_t >::exception ( const dx::exception & exception, bool filtered = false ) const

inlineoverridevirtualnoexceptinherited

notification exception handler

Reimplemented from dx::device<::io_service_t, preference_t >.

Reimplemented in dx::usb::platform::device< preference_t >, and dx::usb::platform::device< preference_t >.

Here is the call graph for this function:

fetch()

template<typename value_t, typename self_t>

bool dx::registry::fetch ( const self_t & self, value_t & value )

inlinestaticinherited

a value that serializes itself into a tree node recurses through its own named children; only what has no such serialization reaches the flat position below, where a struct would become one opaque REG_BINARY of its layout

Here is the call graph for this function:

frame()

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

virtual uint64_t dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::frame ( ) const

inlinevirtual

free()

template<::HANDLE invalid_t = INVALID_HANDLE_VALUE>

virtual void dx::resource< invalid_t >::free ( )

inlinevirtualnoexceptinherited

Reimplemented in dx::coreaudio::pod::stream< device_t, circular_t >, dx::pipe< rcv_t >, dx::pipe< dx::service::request< service::stream::data< desc > > >, dx::pipe< dx::service::request< service::stream::data< desc_t > > >, dx::pipe< dx::service::request< service::stream::data< typename device_t::desc_t > > >, dx::pipe< request >, dx::pipe< request_t >, dx::service::manager::promoted, dx::shared::memory< buffer_t >, dx::shared::memory< buffer_t >, dx::shared::memory< circular_t >, dx::shared::memory< circular_t >, dx::shared::memory< dx::circular >, dx::shared::memory< dx::stream::clock::monitor >, dx::shared::memory< dx::stream::clock::monitor >, dx::stream::shared::stream< device_t, circular_t, super_stream_t, event_t >, dx::stream::shared::stream< device_t, circular_t >, dx::stream::shared::stream< device_t, circular_t, super_stream_t, event_t >, dx::stream::shared::stream< device_t, dx::circular >, dx::stream::stream< device_t, dx::circular, usb::pipe< device_t > >, dx::template server< request >, dx::template server< user_client, std::weak_ptr< device > >, and dx::usb::stream::pipe< device_t, circular_t, stream_t >.

Here is the caller graph for this function:

get() [1/9]

template<typename value_t>

value_t dx::registry::get ( ) const

inlineinherited

stays a named method: base and derived conversion function templates are simultaneous overload candidates, so an operator value_t() here would compete with dx::key_value_tree's own.

Here is the call graph for this function:

Here is the caller graph for this function:

get() [2/9]

template<typename value_t>

bool dx::registry::get ( value_t & value ) const

inlineinherited

like get<value_t>() but returns false for ERROR_FILE_NOT_FOUND, from either RegQueryValueExA or value_of() itself; any other failure throws.

Here is the call graph for this function:

get() [3/9]

template<typename value_t, typename = cf::enable_if_convertible<value_t>>

value_t io::registry::get ( ::CFStringRef key ) const

inlineinherited

Here is the call graph for this function:

get() [4/9]

::CFTypeRef io::registry::get ( ::CFStringRef key ) const

inlineinherited

Here is the call graph for this function:

Here is the caller graph for this function:

get() [5/9]

template<typename value_t, typename = cf::enable_if_convertible<value_t>>

value_t io::registry::get ( ::CFStringRef key, ::CFTypeRef dflt ) const

inlinenoexceptinherited

Here is the call graph for this function:

get() [6/9]

::CFTypeRef io::registry::get ( ::CFStringRef key, ::CFTypeRef dflt ) const

inlinenoexceptinherited

Here is the call graph for this function:

get() [7/9]

template<typename value_t, typename = cf::enable_if_convertible<value_t>>

value_t io::registry::get ( ::CFStringRef key, value_t dflt ) const

inlinenoexceptinherited

Here is the call graph for this function:

get() [8/9]

template<typename key_t, typename value_t, typename = cf::enable_if_convertible<key_t>, typename = cf::enable_if_convertible<value_t>>

value_t io::registry::get ( key_t key ) const

inlineinherited

Here is the call graph for this function:

get() [9/9]

template<typename key_t, typename = cf::enable_if_convertible<key_t>>

::CFTypeRef io::registry::get ( key_t key ) const

inlineinherited

Here is the call graph for this function:

Here is the caller graph for this function:

grouped() [1/3]

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

void dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::grouped ( typename super::group_t & group )

inlineoverride

grouped() [2/3]

template<typename preference_t>

void dx::service::device< preference_t >::grouped ( typename super::group_t & group )

inlineoverrideprotectedinherited

grouped() [3/3]

virtual void dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::grouped ( group_t & )

inlineprotectedvirtualinherited

operator[](): a group just came into existence, a host wires its per-group transports here

Here is the call graph for this function:

Here is the caller graph for this function:

hw_clock() [1/2]

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

void dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::hw_clock ( abstract::event * hw_clock, uint32_t iosize )

inlineoverridevirtual

registers this client's buffer switch event with the driver's clock domain

The driver owns the clock: it signals every registered client at that client's own iosize, so the engine's event has to be one the driver can signal. A device whose driver does not take the registration falls back to the engine's own software clock through not_implemented.

Reimplemented from dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >.

hw_clock() [2/2]

virtual bool dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::hw_clock ( ) const

inlinevirtualnoexceptinherited

ictl() [1/6]

template<typename preference_t>

template<typename rx_t>

enable_if_ptr< rx_t > dx::proxy::device< preference_t >::ictl ( uint32_t ioctl ) const

inlineinherited

Here is the call graph for this function:

ictl() [2/6]

template<typename preference_t>

template<typename rx_t>

enable_if_scalar< rx_t > dx::proxy::device< preference_t >::ictl ( uint32_t ioctl ) const

inlineinherited

Here is the call graph for this function:

ictl() [3/6]

template<typename preference_t>

template<typename rx_t>

hide_if_scalar_or_ptr< rx_t > dx::proxy::device< preference_t >::ictl ( uint32_t ioctl ) const

inlineinherited

member ioctl

this member retreives data from the device by providing an IOCTL code. the template argument defines the type of data to be retreived. this member is intended as a convinient way to retreive only small amounts of data since there is an intermediate stack copy involved in returning the data.

Here is the call graph for this function:

Here is the caller graph for this function:

ictl() [4/6]

template<typename preference_t>

template<typename rx_t>

size_t dx::proxy::device< preference_t >::ictl ( uint32_t ioctl, rx_t & rx ) const

inlineinherited

Here is the call graph for this function:

ictl() [5/6]

template<typename preference_t>

template<typename rx_t>

rx_t dx::proxy::device< preference_t >::ictl ( unsigned int ioctl ) const

inlineinherited

Windows: member ioctl.

this member retreives data from the device by providing an IOCTL code. the template argument defines the type of data to be retreived. this member is intended as a convinient way to retreive only small amounts of data since there is an intermediate stack copy involved in returning the data.

the underlaying windows API is DeviceIoControl(). for detailed information see http://msdn.microsoft.com/en-us/library/aa363216(VS.85).aspx

Exceptions

n/a	microsoft does not give information about what possible errors values are provided by its OS other than
ERROR_INSUFFICIENT_BUFFER	if the output buffer is too small to receive any data

Template Parameters

rx_t	type of rx_t needs to be explicitly specified as it can't be deduced

Here is the call graph for this function:

ictl() [6/6]

template<typename preference_t>

template<typename rx_t>

size_t dx::proxy::device< preference_t >::ictl ( unsigned int ioctl, rx_t & rx ) const

inlineinherited

Here is the call graph for this function:

info()

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

void dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::info ( std::ostream & os )

inlineoverridevirtualnoexcept

log object class information

Reimplemented from dx::proxy::device< preference_t >.

initialize() [1/5]

void dx::file::initialize ( const char * name, ::DWORD access = GENERIC_READ| GENERIC_WRITE, ::DWORD share = FILE_SHARE_READ| FILE_SHARE_WRITE )

inlineinherited

(re-)initialization the underlaying windows API is CreateFile(). for detailed information see http://msdn.microsoft.com/en-us/library/aa363858(VS.85).aspx

Exceptions

n/a	microsoft does not give information about what possible errors values are provided by its OS

Here is the call graph for this function:

Here is the caller graph for this function:

initialize() [2/5]

registry & dx::registry::initialize ( ::HKEY root, ::REGSAM rights = KEY_ALL_ACCESS )

inlineinherited

Here is the call graph for this function:

initialize() [3/5]

registry & dx::registry::initialize ( ::REGSAM rights = KEY_ALL_ACCESS, ::HKEY root = HKEY_CURRENT_USER )

inlineinherited

Here is the call graph for this function:

initialize() [4/5]

registry & dx::registry::initialize ( const std::string & key, ::HKEY root = HKEY_CURRENT_USER, ::REGSAM rights = KEY_ALL_ACCESS )

inlineinherited

Here is the call graph for this function:

initialize() [5/5]

registry & dx::registry::initialize ( const std::string & key, ::REGSAM rights, ::HKEY root, const char * path = nullptr )

inlineprotectedinherited

Here is the call graph for this function:

Here is the caller graph for this function:

ioctl() [1/5]

template<typename preference_t>

template<typename rx_t, typename tx_t>

rx_t dx::proxy::device< preference_t >::ioctl ( uint32_t ioctl, const tx_t & tx ) const

inlineinherited

Here is the call graph for this function:

ioctl() [2/5]

template<typename preference_t>

template<typename rx_t, typename tx_t>

size_t dx::proxy::device< preference_t >::ioctl ( uint32_t ioctl, const tx_t & tx, rx_t & rx ) const

inlineinherited

Here is the call graph for this function:

Here is the caller graph for this function:

ioctl() [3/5]

template<typename preference_t>

size_t dx::proxy::device< preference_t >::ioctl ( uint32_t ioctl, const void * tx = nullptr, size_t tx_size = 0, void * rx = nullptr, size_t rx_size = 0 ) const

inlineinherited

Here is the call graph for this function:

ioctl() [4/5]

template<typename preference_t>

template<typename rx_t, typename tx_t>

rx_t dx::proxy::device< preference_t >::ioctl ( unsigned int ioctl, const tx_t & tx ) const

inlineinherited

Here is the call graph for this function:

ioctl() [5/5]

template<typename preference_t>

template<typename tx_t, typename rx_t>

size_t dx::proxy::device< preference_t >::ioctl ( unsigned int ioctl, const tx_t & tx, rx_t & rx ) const

inlineinherited

Here is the call graph for this function:

launch() [1/2]

virtual void dx::object::launch ( )

inlineprotectedvirtualinherited

launch notification: object mounted and ready to use. Called only through try_launch() - never call this directly from outside the class hierarchy.

launch() [2/2]

template<typename preference_t>

void dx::service::device< preference_t >::launch ( )

inlineoverridevirtualinherited

launch notification: object mounted and ready to use. Called only through try_launch() - never call this directly from outside the class hierarchy.

Reimplemented from dx::object.

Reimplemented in dx::usb::stream::_device< desc_t, preference_t, stream_t, group_t >, dx::usb::stream::_device< desc_t, dx::preference, pipe< device< desc_t, dx::preference, pipe, group > >, group< device< desc_t, dx::preference, pipe, group > > >, and dx::usb::stream::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t, group_t > >, group_t< device< desc_t, preference_t, stream_t, group_t > > >.

nested()

template<typename self_t>

bool dx::registry::nested ( const self_t & self )

inlinestaticnoexceptinherited

Here is the call graph for this function:

octl() [1/3]

template<typename preference_t>

template<typename tx_t, typename = hide_if_ptr<tx_t>>

device & dx::proxy::device< preference_t >::octl ( uint32_t ioctl, const tx_t & tx )

inlineinherited

Here is the call graph for this function:

Here is the caller graph for this function:

octl() [2/3]

template<typename preference_t>

template<typename tx_t, typename = enable_if_ptr<tx_t>>

device & dx::proxy::device< preference_t >::octl ( uint32_t ioctl, const tx_t tx )

inlineinherited

Here is the call graph for this function:

octl() [3/3]

template<typename preference_t>

template<typename tx_t>

void dx::proxy::device< preference_t >::octl ( unsigned int ioctl, const tx_t & tx ) const

inlineinherited

Here is the call graph for this function:

open()

std::shared_ptr< stream_t > dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::open ( const typename desc_t::stream::desc & desc )

inlineinherited

the desc's stream: the registered one, else created, registered and launched

operator const ::io_registry_entry_t &() [1/2]

io::reference< ::io_registry_entry_t >::operator const ::io_registry_entry_t & ( ) const

inlinenoexceptinherited

auto converter into const io_object

operator const ::io_registry_entry_t &() [2/2]

io::reference< ::io_registry_entry_t >::operator const ::io_registry_entry_t & ( ) const

inlinenoexceptinherited

auto converter into const io_object

operator const os_event()

template<::HANDLE invalid_t = INVALID_HANDLE_VALUE>

dx::resource< invalid_t >::operator const os_event ( ) const

inlinenoexceptinherited

operator const std::string &()

template<typename preference_t>

dx::proxy::device< preference_t >::operator const std::string & ( ) const

inlinenoexceptinherited

identifying device string, mirroring macOS' io::registry conversion

operator os_event()

template<::HANDLE invalid_t = INVALID_HANDLE_VALUE>

dx::resource< invalid_t >::operator os_event ( )

inlinenoexceptinherited

operator uint64_t()

io::registry::operator uint64_t ( ) const

inlineexplicitinherited

operator::CFMutableDictionaryRef()

io::registry::operator::CFMutableDictionaryRef ( ) const

inlineexplicitinherited

Here is the call graph for this function:

Here is the caller graph for this function:

operator::CFStringRef()

io::registry::operator::CFStringRef ( ) const

inlineexplicitinherited

Here is the caller graph for this function:

operator::HANDLE()

template<::HANDLE invalid_t = INVALID_HANDLE_VALUE>

dx::resource< invalid_t >::operator::HANDLE ( ) const

inlinenoexceptinherited

Here is the caller graph for this function:

operator::HKEY()

dx::registry::operator::HKEY ( ) const

inlinenoexceptinherited

Here is the call graph for this function:

Here is the caller graph for this function:

operator::io_registry_entry_t &() [1/2]

io::reference< ::io_registry_entry_t >::operator ::io_registry_entry_t & ( )

inlinenoexceptinherited

auto converter into io_object

operator::io_registry_entry_t &() [2/2]

io::reference< ::io_registry_entry_t >::operator ::io_registry_entry_t & ( )

inlinenoexceptinherited

auto converter into io_object

operator::io_registry_entry_t *() [1/2]

io::reference< ::io_registry_entry_t >::operator ::io_registry_entry_t * ( )

inlinenoexceptinherited

auto converter into io_object pointer

operator::io_registry_entry_t *() [2/2]

io::reference< ::io_registry_entry_t >::operator ::io_registry_entry_t * ( )

inlinenoexceptinherited

auto converter into io_object pointer

operator=()

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

virtual void dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::operator= ( const desc_t & desc )

inlinevirtual

operator==()

bool io::reference< ::io_registry_entry_t >::operator== ( ::io_registry_entry_t io_object ) const

inlinenoexceptinherited

operator>>() [1/2]

virtual device & dx::device< std::string, preference_t >::operator>> ( std::ostream & ) const

inlinevirtualinherited

the device's own diagnostics, beyond dx::object::info

operator>>() [2/2]

virtual device & dx::device< ::io_service_t, preference_t >::operator>> ( std::ostream & ) const

inlinevirtualinherited

the device's own diagnostics, beyond dx::object::info

Here is the call graph for this function:

operator[]() [1/3]

group_t & dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::operator[] ( const typename desc_t::stream::desc & stream )

inlineinherited

the stream's group, created on first use

Here is the call graph for this function:

operator[]() [2/3]

::CFTypeRef io::registry::operator[] ( ::CFStringRef key ) const

inlineinherited

Here is the call graph for this function:

operator[]() [3/3]

template<typename key_t, typename = cf::enable_if_convertible<key_t>>

::CFTypeRef io::registry::operator[] ( key_t key ) const

inlineinherited

Here is the call graph for this function:

parent()

registry io::registry::parent ( ) const

inlineinherited

Here is the call graph for this function:

Here is the caller graph for this function:

purge()

template<typename self_t>

void dx::registry::purge ( const self_t & self )

inlinestaticnoexceptinherited

Here is the call graph for this function:

Here is the caller graph for this function:

reset()

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

_device & dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::reset ( )

inline

retain()

reference & io::reference< ::io_registry_entry_t >::retain ( )

inlineinherited

Here is the caller graph for this function:

run()

registry & dx::registry::run ( )

inlineinherited

Here is the call graph for this function:

set() [1/6]

template<typename preference_t>

device & dx::proxy::device< preference_t >::set ( ::CFStringRef key, ::CFTypeRef value )

inlinenoexceptinherited

Here is the call graph for this function:

set() [2/6]

template<typename preference_t>

template<typename value_t, typename = cf::enable_if_convertible<value_t>>

device & dx::proxy::device< preference_t >::set ( ::CFStringRef key, value_t value )

inlineinherited

Here is the call graph for this function:

set() [3/6]

template<typename preference_t>

device & dx::proxy::device< preference_t >::set ( ::CFTypeRef properties )

inlineinherited

Setting properties in a registry entry is not generally supported, it is more common to support setting of properties of the connection based property setting of dx::device.

Here is the call graph for this function:

Here is the caller graph for this function:

set() [4/6]

template<typename preference_t>

template<typename key_t, typename = cf::enable_if_convertible<key_t>>

device & dx::proxy::device< preference_t >::set ( key_t key, ::CFTypeRef value )

inlineinherited

Here is the call graph for this function:

set() [5/6]

template<typename preference_t>

template<typename key_t, typename value_t, typename = cf::enable_if_convertible<key_t>, typename = cf::enable_if_convertible<value_t>>

device & dx::proxy::device< preference_t >::set ( key_t key, value_t value )

inlineinherited

Here is the call graph for this function:

set() [6/6]

registry & dx::registry::set ( ::DWORD type, const void * value, size_t size )

inlineinherited

a sibling thread/process may delete the containing key between value_of()'s create and the set - retry recreates the whole chain in that case

Here is the call graph for this function:

Here is the caller graph for this function:

size() [1/2]

size_t dx::registry::size ( ) const

inlinenoexceptinherited

subkey+value count, 0 if the key doesn't exist (key_of()'s non-throwing overload - an ordinary, expected outcome here, not a genuine error).

Here is the call graph for this function:

Here is the caller graph for this function:

size() [2/2]

template<typename self_t>

size_t dx::registry::size ( const self_t & self )

inlinestaticnoexceptinherited

Here is the call graph for this function:

sleep() [1/2]

virtual void dx::device< std::string, preference_t >::sleep ( )

inlinevirtualinherited

notify system will sleep stub

sleep() [2/2]

virtual void dx::device< ::io_service_t, preference_t >::sleep ( )

inlinevirtualinherited

notify system will sleep stub

source()

virtual std::pair< source_t &, bool > dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::source ( const struct desc_t::stream & stream )

inlinevirtualinherited

the stream's source selector, created on first use: the preference by stream target, the value an index into the stream's sources

Here is the call graph for this function:

Here is the caller graph for this function:

string()

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

virtual std::string dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::string ( uint8_t ) const

inlinevirtual

try_conclude() [1/2]

bool dx::object::try_conclude ( )

inlinenoexceptinherited

atomically conclude()s if currently launched; returns whether this call did it

try_conclude() [2/2]

bool dx::object::try_conclude ( )

inlinenoexceptinherited

atomically conclude()s if currently launched; returns whether this call did it

try_launch() [1/2]

bool dx::object::try_launch ( )

inlineinherited

atomically launch()es if not already launched; returns whether this call did it

try_launch() [2/2]

bool dx::object::try_launch ( )

inlineinherited

atomically launch()es if not already launched; returns whether this call did it

type()

type dx::registry::type ( ) const

inlinenoexceptinherited

wake()

void dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::wake ( )

inlineoverridevirtualinherited

Reimplemented from dx::device<::io_service_t, preference_t >.

Here is the call graph for this function:

Friends And Related Symbol Documentation

dx::proxy::stream::group

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

template<typename>

friend class dx::proxy::stream::group

friend

the app wraps this bus's own group, so friendship has to name it, not just the device's group_t

Member Data Documentation

bundle_id

template<typename preference_t>

cf::string dx::service::device< preference_t >::bundle_id

inherited

clients

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

promoted<typename super::client_map, typename super::client_map::value_t> dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::clients {*this, ioctl::stream::clients}

clock

dx::shared::lockfree::list<registration> dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::clock

inherited

the tick walks it without a lock

clocksource

promoted<uint32_t>::preference<decltype(super::preference)> dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::clocksource

inherited

connected

template<typename preference_t>

bool dx::proxy::device< preference_t >::connected = false

protectedinherited

consumer

dx::stream::clock::consumer dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::consumer

inherited

desc

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

promoted<desc_t, typename desc_t::value_t> dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::desc {*this, ioctl::stream::desc}

driver [1/2]

dx::driver<decltype(id), preference_t>& dx::device< std::string, preference_t >::driver

inherited

driver [2/2]

dx::driver<decltype(id), preference_t>& dx::device< ::io_service_t, preference_t >::driver

inherited

event

abstract::event* dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::event

inherited

group

std::map<decltype(desc_t::stream::group), group_t> dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::group

inherited

streaming groups by desc::stream::group id: every stream of this device is registered with its group - behind the settings its groups listen to, so they go first

group_server

template<typename preference_t>

std::list<promoted> dx::service::device< preference_t >::group_server

protectedinherited

per-group chains, wired as each group comes into existence (grouped())

handle

template<::HANDLE invalid_t = INVALID_HANDLE_VALUE>

::HANDLE dx::resource< invalid_t >::handle {invalid_t}

protectedinherited

hosted

bool dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::hosted

staticconstexprinherited

the transport's settings belong to another process' device: a hosted device mirrors them through its chains, it keeps no store of them

[struct]

struct { ... } dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::hw

Todo

migrate hw clock generation/distribution into a dedicated clock class

icon

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

promoted<std::string> dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::icon {*this, ioctl::device::icon}

id [1/2]

const std::string dx::device< std::string, preference_t >::id

inherited

id [2/2]

const ::io_service_t dx::device< ::io_service_t, preference_t >::id

inherited

iosize [1/2]

promoted<uint32_t>::preference<decltype(super::preference)> dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::iosize

inherited

iosize [2/2]

uint32_t dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::iosize

inherited

staging value for registration paths without their own iosize argument (macOS CF property bridge)

iosize_server

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

chain<uint32_t> dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::iosize_server {*this, super::iosize, ioctl::stream::clock::iosize}

[struct]

struct { ... } dx::service::device< preference_t >::kernel

key

std::string dx::registry::key

inherited

launched [1/2]

std::atomic<bool> dx::object::launched

inherited

launched [2/2]

std::atomic<bool> dx::object::launched

inherited

listen

std::deque<std::function<void()> > dx::registry::listen

inherited

monitor

dx::stream::device::monitor dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::monitor

inherited

mutex

std::mutex dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::mutex

inherited

the registrations' writers

pipe [1/2]

template<typename preference_t>

class dx::service::device::promoted dx::service::device< preference_t >::pipe

protectedinherited

pipe [2/2]

template<typename preference_t>

class dx::service::device::promoted dx::service::device< preference_t >::pipe

protectedinherited

Initial value:

{
        std::string{this->driver.product_id}+ "/"+ this->puuid,
        {[this](class server::instance& instance, const request& request){
            {
                if(this->driver.log.bus.setup>= dx::log::level::debug){
                    std::lock_guard lock{io_mutex};
                    std::clog<< class_name<< "<"<< this->puuid<< ">::pipe::listen: "<< request<< std::endl;
                }
                switch(request.id){
                case request::id::desc:
                    if constexpr(requires{std::declval<device>().desc;})
                        if(request.data){
                            this->desc= std::get<super::desc_t>(*request.data);
                            break;
                        }
                    instance<< device::request{.id= request.id, .data= static_cast<typename super::desc_t>(*this)};
                    break;
                }
            }
 
 
  }},{}}

port

template<typename preference_t>

io::port dx::proxy::device< preference_t >::port

protectedinherited

preference [1/2]

preference_t dx::device< std::string, preference_t >::preference

inherited

preference [2/2]

preference_t dx::device< ::io_service_t, preference_t >::preference

inherited

process

template<::HANDLE invalid_t = INVALID_HANDLE_VALUE>

::HANDLE dx::resource< invalid_t >::process {::GetCurrentProcess()}

protectedinherited

puid [1/2]

std::string dx::device< std::string, preference_t >::puid

inherited

persistent UID - system unique - could change with location

puid [2/2]

std::string dx::device< ::io_service_t, preference_t >::puid

inherited

persistent UID - system unique - could change with location

puuid [1/2]

std::string dx::device< std::string, preference_t >::puuid

inherited

persistent universal UID - universally unique ID (i.e. serial number)

puuid [2/2]

std::string dx::device< ::io_service_t, preference_t >::puuid

inherited

persistent universal UID - universally unique ID (i.e. serial number)

registrations

std::map<abstract::event*, std::unique_ptr<registration> > dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::registrations

inherited

safety_offset_server

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

std::list<promoted<uint32_t> > dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::safety_offset_server

per group: the kernel keeps the client margins of its streams

samplerate

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

dx::promoted<uint32_t> dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::samplerate

Initial value:

{
        {[this](dx::promoted<uint32_t>::lock_t&& lock, uint32_t value, uint32_t){
            dx::promoted<uint32_t>::lock_t tmp(std::move(lock));
            if(!samplerate.initialized){    
                if(this->persistence){
                    samplerate.commit(std::move(tmp), this->template ictl<uint32_t>(ioctl::stream::clock::samplerate));
                    return;
                }
                value= super::samplerate;
            }else if(this->clock[0].settings){
                uint32_t clocksource{this->clocksource};
                dx_pass(this->clock[0].setting[clocksource].external.locked?
                    not_permitted: ok, "clocksource:%d", clocksource);
            }
            samplerate.commit(std::move(tmp),
                this->template ioctl<uint32_t, dx::stream::clock_value>(
                    ioctl::stream::clock::samplerate,{
                        this->stream[0].config[0].clock.domain,
                        this->clock[0].align(value)}));
        }},
        {[this](const uint32_t& value){if(!this->persistence) super::samplerate= value;}}}

schedule_erase

bool dx::registry::schedule_erase {}

inherited

sources

std::map<decltype(desc_t::stream::target.idx()), source_t> dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::sources

inherited

source selectors by stream target: a stream with sources gets its own on first use

sync_reference

promoted<structdesc_t::stream*>::template preference<decltype(super::preference), uint32_t> dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::sync_reference

inherited

this

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

class dx::proxy::stream::_device::monitor* dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >::this

version

dx::stream::device::monitor dx::stream::device< dx::proxy::device< preference_t >, desc_t, stream_t, group_t >::version

inherited

---

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

• dx_proxy_stream_device.h