dx::usb::stream::device< desc_t > Class Template Reference

#include <dx_usb_stream_device.h>

Inheritance diagram for dx::usb::stream::device< desc_t >:

Collaboration diagram for dx::usb::stream::device< desc_t >:

Public Types
typedef desc_t	desc
enum class	speed : uint8_t {   low = ::kUSBDeviceSpeedLow , full = ::kUSBDeviceSpeedFull , high = ::kUSBDeviceSpeedHigh , super = ::kUSBDeviceSpeedSuper ,   superplus = ::kUSBDeviceSpeedSuperPlus , superplus2 = ::kUSBDeviceSpeedSuperPlusBy2 , usb1 = full , usb2 = high ,   usb3 = super , usb31 = super , usb32 = superplus , usb32x2 = superplus2 ,   low = ::UsbLowSpeed , full = ::UsbFullSpeed , high = ::UsbHighSpeed , super = ::UsbSuperSpeed ,   superplus = 4 , superplus2 = 5 , usb1 = full , usb2 = high ,   usb3 = super , usb31 = super , usb32 = superplus , usb32x2 = superplus2 }
	USB speed. More...
enum class	speed : uint8_t {   low = ::kUSBDeviceSpeedLow , full = ::kUSBDeviceSpeedFull , high = ::kUSBDeviceSpeedHigh , super = ::kUSBDeviceSpeedSuper ,   superplus = ::kUSBDeviceSpeedSuperPlus , superplus2 = ::kUSBDeviceSpeedSuperPlusBy2 , usb1 = full , usb2 = high ,   usb3 = super , usb31 = super , usb32 = superplus , usb32x2 = superplus2 ,   low = ::UsbLowSpeed , full = ::UsbFullSpeed , high = ::UsbHighSpeed , super = ::UsbSuperSpeed ,   superplus = 4 , superplus2 = 5 , usb1 = full , usb2 = high ,   usb3 = super , usb31 = super , usb32 = superplus , usb32x2 = superplus2 }

Public Member Functions
virtual uint32_t	clocksource ()
virtual uint32_t	clocksource (uint32_t clocksource) try
device &	close () noexcept
device &	close (bool force=false) noexcept
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.
void	conclude () noexcept override
	conclude notifacation: device will be removed from tree
uint8_t	configurations () const
auto	count () const noexcept
void	ctl (uint32_t ioctl) const
void	ctl (unsigned int ioctl) const
	device (decltype(super::driver)&driver, decltype(super::id)&id, const desc_t &desc={})
	dx_catchall_rethrow () device &open()
	for macOS compatibility only
	dx_catchall_rethrow () uint32_t samplerate() const override
	dx_catchall_rethrow () virtual void configure()
	dx_catchall_rethrow (, "iosize: %d (current: %d)", iosize, hw.iosize) virtual int32_t iosize() const try
	dx_catchall_rethrow (, "name: %s, access rights: %x, sharing options:%x", name, access, share)
	dx_catchall_rethrow (if(autoclear) try {const_cast< device * >(this) ->clear();} dx_catchall(), "handle: %p size: %lld request: %x idx: %x value: %x length: %x", winusb.handle, sizeof(request), request.control::request, request.index, request.value, request.length) template< typename data_t
	dx_catchall_rethrow (try {if(exception.error==stalled) const_cast< device * >(this) ->reset();} dx_catchall_handler(this,), "request type:%x [recipient:%d type:%x direction:%x] request:%x value:%x index:%x length:%d", reinterpret_cast< const uint8_t & >(request), request.recipient, request.type, request.direction, request.control::request, request.value, request.index, request.length) template< typename data_t >data_t submit(const control &control) const
	device control request
registry &	erase (const char *key=nullptr)
uint64_t	frame () const
uint64_t	frame () const try
::CFTypeRef	get (::CFStringRef key) const
template<typename value_t , typename = cf::enable_if_convertible<value_t>>
value_t	get (::CFStringRef key) const
::CFTypeRef	get (::CFStringRef key, ::CFTypeRef dflt) const noexcept
template<typename value_t , typename = cf::enable_if_convertible<value_t>>
value_t	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 = cf::enable_if_convertible<key_t>>
::CFTypeRef	get (key_t key) const
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 rx_t >
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	initialize (const char *name, ::DWORD access=GENERIC_READ|GENERIC_WRITE, ::DWORD share=FILE_SHARE_READ|FILE_SHARE_WRITE) try
	(re-)initialization the underlaying windows API is CreateFile(). for detailed information see http://msdn.microsoft.com/en-us/library/aa363858(VS.85).aspx
void	initialize (const char *path, ::HKEY root, ::REGSAM rights=KEY_READ, const char *key=nullptr)
void	initialize (const char *path, ::REGSAM rights=KEY_READ, ::HKEY root=HKEY_CURRENT_USER, const char *key=nullptr)
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
virtual int32_t	iosize (uint32_t iosize, dx::event< user > &hw_clock) try
void	launch () override
	launch notification: object mounted and ready to use
virtual bool	monitor () noexcept
monitor_t *	monitor (bool force=false)
template<typename tx_t >
void	octl (uint32_t ioctl, const tx_t &tx) const
template<typename tx_t >
void	octl (unsigned int ioctl, const tx_t &tx) const
device &	open ()
	opens the USB device for exclusice access
	operator const io_registry_entry_t & () const noexcept
	auto converter into const 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 std::string () const
	operator uint64_t () const
template<typename value_t >
	operator value_t () const
template<typename value_t >
value_t	operator() (value_t dflt) const
	operator::CFMutableDictionaryRef () const
	operator::CFStringRef () const
	operator::HKEY () const noexcept
bool	operator== (io_registry_entry_t io_object) const noexcept
::CFTypeRef	operator[] (::CFStringRef key) const
registry	operator[] (const char *key) const
template<typename key_t , typename = cf::enable_if_convertible<key_t>>
::CFTypeRef	operator[] (key_t key) const
device &	reenumerate ()
virtual device &	reset ()
reference &	retain ()
template<typename observer_t = uint32_t>
observer_t *	samplerate () const
uint32_t	samplerate (uint32_t samplerate) override try
registry &	set (::CFStringRef key, ::CFTypeRef value) noexcept
template<typename value_t , typename = cf::enable_if_convertible<value_t>>
registry &	set (::CFStringRef key, value_t value)
registry &	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>>
registry &	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>>
registry &	set (key_t key, value_t value)
virtual void	start ()
virtual void	stop (bool=false)
device &	submit (const control &control) const
template<typename data_t >
device &	submit (const request< data_t > &request) const try
	standard device request
template<typename data_t >
device &	submit (const request< data_t > &request, bool autoclear=true) const try

Public Attributes
union {
struct {
struct {
struct {
uint8_t   id
}   selector
struct {
uint8_t   id
}   source
}   clock
}   v2
}	adc
uint16_t	bcdADC = 0
bool	composite = false
	indicate WinUSB matched against single interface of composit device;
std::atomic< size_t >	counter
dx::driver< decltype(id)> &	driver
dx::driver< decltype(id)> &	driver
struct {
dx::event< user > *   clock
std::atomic< size_t >   counter
uint32_t   iosize
}	hw
std::weak_ptr< dx::circular >	implicit_feedback
uint32_t	iosize
bool	launched {}
bool	launched {}
std::map< uint8_t, std::weak_ptr< usb::pipe< device > > >	pipes
sc::preference	preference
registry	preference
std::string	puid
	persistent UID (i.e. serial number)
std::string	puuid
	persistent universal UID
shared::memory< dx::stream::clock::monitor >	shared_monitor
enum dx::usb::platform::device::speed	speed
std::map< uint8_t, std::weak_ptr< dx::stream::stream< device > > >	streams
uint32_t	version
uint32_t	version

Protected Member Functions
void	initialize (::IOCFPlugInInterface **cf_interface, ::CFUUIDRef uuid)
void	initialize (io_object_t io_object, ::CFUUIDRef type, ::CFUUIDRef uuid)
::IOUSBDeviceInterface650 *	operator-> () const
	operator::IOUSBDeviceInterface650 ** () const

Protected Attributes
bool	connected = false
struct {
cf::type< const char * >   bundle_id
cf::type< const char * >   class_name
}	kernel
std::atomic< int >	opened {}
io::port	port
struct {
::WINUSB_INTERFACE_HANDLE   handle
}	winusb

Member Typedef Documentation

desc

typedef desc_t dx::stream::device< usb::device , desc_t >::desc

inherited

Member Enumeration Documentation

speed [1/2]

enum class enum dx::usb::platform::device::speed dx::usb::platform::device::speed

stronginherited

USB speed.

Enumerator
low
full
high
super	SuperSpeed (Gen 1) 5Gbps device.
superplus	SuperSpeed Plus (Gen 2) 10Gbps device.
superplus2	SuperSpeed Plus (Gen 2 X 2) 20Gbps device
usb1
usb2
usb3
usb31
usb32
usb32x2
low
full
high
super
superplus
superplus2
usb1
usb2
usb3
usb31
usb32
usb32x2

speed [2/2]

enum class dx::usb::platform::device::speed : uint8_t

stronginherited

Enumerator
low
full
high
super	SuperSpeed (Gen 1) 5Gbps device.
superplus	SuperSpeed Plus (Gen 2) 10Gbps device.
superplus2	SuperSpeed Plus (Gen 2 X 2) 20Gbps device
usb1
usb2
usb3
usb31
usb32
usb32x2
low
full
high
super
superplus
superplus2
usb1
usb2
usb3
usb31
usb32
usb32x2

Constructor & Destructor Documentation

device()

template<typename desc_t >

dx::usb::stream::device< desc_t >::device ( decltype(super::driver)& driver, decltype(super::id)& id, const desc_t & desc = {} )

inline

Member Function Documentation

clocksource() [1/2]

virtual uint32_t dx::stream::device< usb::device , desc_t >::clocksource ( )

inlinevirtualinherited

clocksource() [2/2]

virtual uint32_t dx::stream::device< usb::device , desc_t >::clocksource ( uint32_t clocksource )

inlinevirtualinherited

close() [1/2]

device & dx::usb::platform::device::close ( )

inlinenoexceptinherited

close() [2/2]

device & dx::usb::platform::device::close ( bool force = false )

inlinenoexceptinherited

conclude() [1/2]

void dx::proxy::device::conclude ( )

inlineoverridevirtualnoexceptinherited

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::object.

Here is the call graph for this function:

Here is the caller graph for this function:

conclude() [2/2]

void dx::proxy::device::conclude ( )

inlineoverridevirtualnoexceptinherited

conclude notifacation: device will be removed from tree

Reimplemented from dx::object.

configurations()

uint8_t dx::usb::platform::device::configurations ( ) const

inlineinherited

count()

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

inlinenoexceptinherited

ctl() [1/2]

void dx::proxy::device::ctl ( uint32_t ioctl ) const

inlineinherited

ctl() [2/2]

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

inlineinherited

dx_catchall_rethrow() [1/7]

dx::usb::platform::device::dx_catchall_rethrow ( ) &

inlineinherited

for macOS compatibility only

dx_catchall_rethrow() [2/7]

template<typename desc_t >

dx::usb::stream::device< desc_t >::dx_catchall_rethrow ( ) const

inlineoverride

dx_catchall_rethrow() [3/7]

template<typename desc_t >

dx::usb::stream::device< desc_t >::dx_catchall_rethrow ( )

inline

Todo

usb::stream::device::configure(): support odd sample rate ranges

dx_catchall_rethrow() [4/7]

dx::stream::device< usb::device , desc_t >::dx_catchall_rethrow ( "iosize: %d (current: %d)" , iosize , hw. iosize ) const

inlineinherited

<

Todo

stream::device calculate default iosize from desc

dx_catchall_rethrow() [5/7]

dx::file::dx_catchall_rethrow ( "name: % s, access rights:% x, sharing options:%x" , name , access , share  )

inherited

dx_catchall_rethrow() [6/7]

dx::usb::platform::device::dx_catchall_rethrow ( if(autoclear) try {const_cast< device * >(this) ->clear();} dx_catchall() , "handle: %p size: %lld request: %x idx: %x value: %x length: %x" , winusb. handle, sizeof(request) , request.control::request , request. index, request. value, request. length )

inherited

dx_catchall_rethrow() [7/7]

dx::usb::platform::device::dx_catchall_rethrow ( try { ifexception.error==stalled) const_cast< device * >(this) ->reset();} dx_catchall_handler(this,, "request type:%x request:%x value:%x index:%x length:%d" [recipient:%d type:%x direction:%x], reinterpret_cast< const uint8_t & > request, request. recipient, request. type, request. direction, request.control::request , request. value, request. index, request. length ) const &

inlineinherited

device control request

erase()

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

inlineinherited

Todo

registry::erase(): investigate why it's not working

frame() [1/2]

uint64_t dx::usb::platform::device::frame ( ) const

inlineinherited

Here is the call graph for this function:

Here is the caller graph for this function:

frame() [2/2]

uint64_t dx::usb::platform::device::frame ( ) const

inlineinherited

Here is the call graph for this function:

get() [1/7]

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

inlineinherited

Here is the caller graph for this function:

get() [2/7]

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

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

inlineinherited

Here is the call graph for this function:

get() [3/7]

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

inlinenoexceptinherited

get() [4/7]

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

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

inlinenoexceptinherited

Here is the call graph for this function:

get() [5/7]

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

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

inlinenoexceptinherited

Here is the call graph for this function:

get() [6/7]

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

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

inlineinherited

Here is the call graph for this function:

Here is the caller graph for this function:

get() [7/7]

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

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

inlineinherited

Here is the call graph for this function:

ictl() [1/4]

template<typename rx_t >

rx_t dx::proxy::device::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.

ictl() [2/4]

template<typename rx_t >

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

inlineinherited

ictl() [3/4]

template<typename rx_t >

rx_t dx::proxy::device::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

ictl() [4/4]

template<typename rx_t >

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

inlineinherited

initialize() [1/5]

void cf::interface< ::IOUSBDeviceInterface650 >::initialize ( ::IOCFPlugInInterface ** cf_interface, ::CFUUIDRef uuid )

inlineprotectedinherited

initialize() [2/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 caller graph for this function:

initialize() [3/5]

void dx::registry::initialize ( const char * path, ::HKEY root, ::REGSAM rights = KEY_READ, const char * key = nullptr )

inlineinherited

Here is the caller graph for this function:

initialize() [4/5]

void dx::registry::initialize ( const char * path, ::REGSAM rights = KEY_READ, ::HKEY root = HKEY_CURRENT_USER, const char * key = nullptr )

inlineinherited

initialize() [5/5]

void cf::interface< ::IOUSBDeviceInterface650 >::initialize ( io_object_t io_object, ::CFUUIDRef type, ::CFUUIDRef uuid )

protectedinherited

ioctl() [1/5]

template<typename rx_t , typename tx_t >

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

inlineinherited

ioctl() [2/5]

template<typename rx_t , typename tx_t >

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

inlineinherited

ioctl() [3/5]

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

inlineinherited

ioctl() [4/5]

template<typename rx_t , typename tx_t >

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

inlineinherited

ioctl() [5/5]

template<typename tx_t , typename rx_t >

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

inlineinherited

iosize()

virtual int32_t dx::stream::device< usb::device , desc_t >::iosize ( uint32_t iosize, dx::event< user > & hw_clock )

inlinevirtualinherited

launch()

template<typename desc_t >

void dx::usb::stream::device< desc_t >::launch ( )

inlineoverridevirtual

launch notification: object mounted and ready to use

Reimplemented from dx::object.

monitor() [1/2]

virtual bool dx::stream::device< usb::device , desc_t >::monitor ( )

inlinevirtualnoexceptinherited

monitor() [2/2]

monitor_t * dx::stream::device< usb::device , desc_t >::monitor ( bool force = false )

inlineinherited

octl() [1/2]

template<typename tx_t >

void dx::proxy::device::octl ( uint32_t ioctl, const tx_t & tx ) const

inlineinherited

octl() [2/2]

template<typename tx_t >

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

inlineinherited

open()

device & dx::usb::platform::device::open ( )

inlineinherited

opens the USB device for exclusice access

Here is the caller graph for this function:

operator const io_registry_entry_t &()

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

inlinenoexceptinherited

auto converter into const io_object

operator io_registry_entry_t &()

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

inlinenoexceptinherited

auto converter into io_object

operator io_registry_entry_t *()

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

inlinenoexceptinherited

auto converter into io_object pointer

operator std::string()

dx::registry::operator std::string ( ) const

inlineinherited

operator uint64_t()

dx::io::registry::operator uint64_t ( ) const

inlineexplicitinherited

operator value_t()

template<typename value_t >

dx::registry::operator value_t ( ) const

inlineinherited

operator()()

template<typename value_t >

value_t dx::registry::operator() ( value_t dflt ) const

inlineinherited

operator->()

::IOUSBDeviceInterface650 * cf::interface< ::IOUSBDeviceInterface650 >::operator-> ( ) const

inlineinherited

operator::CFMutableDictionaryRef()

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

inlineexplicitinherited

Here is the call graph for this function:

Here is the caller graph for this function:

operator::CFStringRef()

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

inlineexplicitinherited

operator::HKEY()

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

inlinenoexceptinherited

operator::IOUSBDeviceInterface650 **()

cf::interface< ::IOUSBDeviceInterface650 >::operator ::IOUSBDeviceInterface650 ** ( ) const

inlineinherited

operator==()

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

inlinenoexceptinherited

operator[]() [1/3]

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

inlineinherited

Here is the call graph for this function:

operator[]() [2/3]

registry dx::registry::operator[] ( const char * key ) const

inlineinherited

operator[]() [3/3]

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

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

inlineinherited

Here is the call graph for this function:

reenumerate()

device & dx::usb::platform::device::reenumerate ( )

inlineinherited

Here is the call graph for this function:

reset()

virtual device & dx::stream::device< usb::device , desc_t >::reset ( )

inlinevirtualinherited

retain()

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

inlineinherited

samplerate() [1/2]

template<typename desc_t >

template<typename observer_t = uint32_t>

observer_t * dx::usb::stream::device< desc_t >::samplerate ( ) const

inlinevirtual

Todo

dedicated stream::device::clock class

Reimplemented from dx::stream::device< usb::device, desc_t >.

samplerate() [2/2]

template<typename desc_t >

uint32_t dx::usb::stream::device< desc_t >::samplerate ( uint32_t samplerate )

inlineoverridevirtual

Todo

dedicated usb::stream::device::clock class

Reimplemented from dx::stream::device< usb::device, desc_t >.

set() [1/5]

registry & dx::proxy::device::set ( ::CFStringRef key, ::CFTypeRef value )

inlinenoexceptinherited

set() [2/5]

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

registry & dx::proxy::device::set ( ::CFStringRef key, value_t value )

inlineinherited

set() [3/5]

registry & dx::proxy::device::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.

set() [4/5]

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

registry & dx::proxy::device::set ( key_t key, ::CFTypeRef value )

inlineinherited

set() [5/5]

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

registry & dx::proxy::device::set ( key_t key, value_t value )

inlineinherited

start()

virtual void dx::stream::device< usb::device , desc_t >::start ( )

inlinevirtualinherited

stop()

virtual void dx::stream::device< usb::device , desc_t >::stop ( bool = false )

inlinevirtualinherited

submit() [1/3]

device & dx::usb::platform::device::submit ( const control & control ) const

inlineinherited

Here is the call graph for this function:

submit() [2/3]

template<typename data_t >

device & dx::usb::platform::device::submit ( const request< data_t > & request ) const

inlineinherited

standard device request

Here is the caller graph for this function:

submit() [3/3]

template<typename data_t >

device & dx::usb::platform::device::submit ( const request< data_t > & request, bool autoclear = true ) const

inlineinherited

Member Data Documentation

[union]

union { ... } dx::usb::stream::device< desc_t >::adc

bcdADC

template<typename desc_t >

uint16_t dx::usb::stream::device< desc_t >::bcdADC = 0

bundle_id

cf::type<const char*> dx::proxy::device::bundle_id

inherited

[struct]

struct { ... } dx::usb::stream::device< desc_t >::clock

composite

bool dx::usb::platform::device::composite = false

inherited

indicate WinUSB matched against single interface of composit device;

connected

bool dx::proxy::device::connected = false

protectedinherited

counter

std::atomic<size_t> dx::stream::device< usb::device , desc_t >::counter

inherited

driver [1/2]

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

inherited

driver [2/2]

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

inherited

handle

::WINUSB_INTERFACE_HANDLE dx::usb::platform::device::handle

inherited

[struct]

struct { ... } dx::stream::device< usb::device , desc_t >::hw

id

template<typename desc_t >

uint8_t dx::usb::stream::device< desc_t >::id

implicit_feedback

template<typename desc_t >

std::weak_ptr<dx::circular> dx::usb::stream::device< desc_t >::implicit_feedback

iosize

uint32_t dx::stream::device< usb::device , desc_t >::iosize

inherited

[struct]

struct { ... } dx::proxy::device::kernel

launched [1/2]

bool dx::object::launched {}

inherited

launched [2/2]

bool dx::object::launched {}

inherited

opened

std::atomic< int > dx::usb::platform::device::opened {}

protectedinherited

Todo

add runloop ////////////////////////////////////////////////////////////////////////////

pipes

template<typename desc_t >

std::map<uint8_t,std::weak_ptr<usb::pipe<device> > > dx::usb::stream::device< desc_t >::pipes

port

io::port dx::proxy::device::port

protectedinherited

preference [1/2]

sc::preference dx::proxy::device::preference

inherited

preference [2/2]

registry dx::proxy::device::preference

inherited

puid

std::string dx::stream::device< usb::device , desc_t >::puid

inherited

persistent UID (i.e. serial number)

puuid

std::string dx::stream::device< usb::device , desc_t >::puuid

inherited

persistent universal UID

[struct]

struct { ... } dx::usb::stream::device< desc_t >::selector

shared_monitor

shared::memory<dx::stream::clock::monitor> dx::stream::device< usb::device , desc_t >::shared_monitor

inherited

[struct]

struct { ... } dx::usb::stream::device< desc_t >::source

speed

enum dx::usb::platform::device::speed dx::usb::platform::device::speed

inherited

streams

std::map<uint8_t, std::weak_ptr<dx::stream::stream<device> > > dx::stream::device< usb::device , desc_t >::streams

inherited

[struct]

struct { ... } dx::usb::stream::device< desc_t >::v2

version [1/2]

uint32_t dx::device< ::io_service_t >::version

inherited

version [2/2]

uint32_t dx::device< std::string >::version

inherited

[struct]

struct { ... } dx::usb::platform::device::winusb

---

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

• dx_usb_stream_device.h