#include <dx_virtual_driver.h>
 | 
| void  | add (const device_id_t &device_id) override try | 
|   | adds a new device to the device list  
  | 
|   | 
| virtual void  | arrived () | 
|   | notify device arrivals completed stub  
  | 
|   | 
| virtual void  | arrived (device_t &) | 
|   | notify specific device arrival stub  
  | 
|   | 
|   | catch (...) | 
|   | 
|   | catch (const dx::exception &__dx_exception) | 
|   | 
|   | catch (const std::exception &__std_exception) | 
|   | 
| void  | clear () noexcept try | 
|   | replaces std::map::clear to call virtual notification methods  
  | 
|   | 
| void  | conclude () noexcept override try | 
|   | 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.  
  | 
|   | 
|   | dx_catchall_handler (this,) virtual void operator<<(std | 
|   | restores device settings  
  | 
|   | 
| virtual void  | operator>> (std::ostream &ostream) const | 
|   | saves device tree  
  | 
|   | 
| void  | remove (const device_id_t &device_id) override try | 
|   | finds and removes a device from the device list  
  | 
|   | 
| virtual void  | removed () noexcept | 
|   | notify device removals completed stub  
  | 
|   | 
| virtual void  | removed (device_t &) noexcept | 
|   | notify specific device removal stub  
  | 
|   | 
| virtual void  | scan () try | 
|   | 
◆ device_id_t
template<typename device_t > 
 
 
◆ match
template<
class device_t > 
 
      
 
 
◆ driver()
template<
class device_t > 
 
 
the virtual driver interface class constructor 
- Parameters
 - 
  
    | matching_ids | the matching virtual driver IDs identifying the driver interface   | 
    | id | virtual driver ID   | 
    | log | log settings  | 
  
   
 
 
◆ add() [1/2]
template<
class device_t > 
 
  
  | 
      
   | 
  
inlineoverrideprotectedvirtual   | 
  
 
 
◆ add() [2/2]
template<
class device_t > 
 
  
  
      
        
          | void dx::virtuel::driver< device_t >::add  | 
          ( | 
          const std::string & |           device_id,  | 
         
        
           | 
           | 
          const typename device_t::desc_t & |           desc ) | 
         
       
   | 
  
inline   | 
  
 
 
◆ arrived() [1/2]
template<typename device_t > 
  
  | 
      
   | 
  
inlineprotectedvirtualinherited   | 
  
 
notify device arrivals completed stub 
Reimplemented from dx::driver< decltype(device_t::id), decltype(device_t::preference)>.
Reimplemented in dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >, dx::stream::engine< device< super_device_t >, audio_pin_t, dx::proxy::driver< device< super_device_t > >, int32_t >, dx::stream::engine< dx::test::device< super_device_t >, audio_pin_t, dx::proxy::driver< dx::test::device< super_device_t > >, int32_t >, dx::stream::engine< dx::test::device< super_device_t >, audio_pin_t, dx::virtuel::driver< dx::test::device< super_device_t > >, int32_t >, and dx::stream::engine< dx::test::midi::device< super_device_t >, audio_pin_t, dx::proxy::driver< dx::test::midi::device< super_device_t > >, int32_t >.
 
 
◆ arrived() [2/2]
template<typename device_t > 
  
  | 
      
   | 
  
inlineprotectedvirtualinherited   | 
  
 
 
◆ boot()
  
  
      
        
          | virtual bool dx::driver< decltype(device_t::id) , decltype(device_t::preference)  >::boot  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inlinevirtualinherited   | 
  
 
 
◆ catch() [1/12]
template<
class device_t > 
 
 
 
◆ catch() [2/12]
template<
class device_t > 
 
 
 
◆ catch() [3/12]
template<
class device_t > 
 
 
 
◆ catch() [4/12]
template<
class device_t > 
 
 
 
◆ catch() [5/12]
template<
class device_t > 
 
 
 
◆ catch() [6/12]
template<
class device_t > 
 
 
 
◆ catch() [7/12]
template<
class device_t > 
 
 
 
◆ catch() [8/12]
template<
class device_t > 
 
 
 
◆ catch() [9/12]
template<
class device_t > 
 
 
 
◆ catch() [10/12]
template<
class device_t > 
 
 
 
◆ catch() [11/12]
template<
class device_t > 
 
 
 
◆ catch() [12/12]
template<
class device_t > 
 
 
 
◆ clear()
template<typename device_t > 
  
  | 
      
   | 
  
inlineprotectednoexceptinherited   | 
  
 
replaces std::map::clear to call virtual notification methods 
 
 
◆ conclude()
template<typename device_t > 
  
  | 
      
   | 
  
inlineoverrideprotectedvirtualnoexceptinherited   | 
  
 
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.
 
 
◆ dx_catchall_handler()
template<typename device_t > 
 
 
◆ exception() [1/2]
  
  
      
        
          | void dx::driver< decltype(device_t::id) , decltype(device_t::preference)  >::exception  | 
          ( | 
          const class exception & |           exception,  | 
         
        
           | 
           | 
          bool |           filtered = false ) | 
         
       
   | 
  
inlineoverridenoexceptinherited   | 
  
 
notification exception handler 
 
 
◆ exception() [2/2]
  
  
      
        
          | virtual void dx::object::exception  | 
          ( | 
          const exception & |           exception,  | 
         
        
           | 
           | 
          bool |           filtered = false ) | 
         
       
   | 
  
pure virtualnoexceptinherited   | 
  
 
notification exception handler 
Implemented in dx::device< dx::guid, dx::preference >, dx::device< dx::guid, preference_t >, dx::device< std::string, dx::preference >, dx::device< std::string, preference_t >, dx::device<::AudioObjectID, cf::preference >, dx::device<::AudioObjectID, preference_t >, dx::device<::io_service_t, dx::preference >, dx::device<::io_service_t, preference_t >, dx::device<::MIDIDeviceRef, cf::preference >, dx::device<::MIDIDeviceRef, preference_t >, dx::device< id_t, preference_t >, dx::stream::pin< device_t, _circular_t >, dx::virtuel::stream::_device< desc_t, preference_t, stream_t >, dx::usb::platform::device< preference_t >, dx::asio::client::_device< desc_t, preference_t, stream_t >, dx::proxy::device< dx::preference >, dx::proxy::device<>, and dx::proxy::device< preference_t >.
 
 
◆ info()
template<
class device_t > 
 
  
  | 
      
   | 
  
inlineoverridevirtualnoexcept   | 
  
 
 
◆ launch()
template<
class device_t > 
 
 
launch notification: object mounted and ready to use 
- Todo
 - virtual::driver::launch(): fix preference[] and remove ":" test hack 
 
Reimplemented from dx::map::driver< device_t >.
 
 
◆ operator>>()
template<typename device_t > 
  
  
      
        
          | virtual void dx::map::driver< device_t >::operator>>  | 
          ( | 
          std::ostream & |           ostream | ) | 
           const | 
         
       
   | 
  
inlineprotectedvirtualinherited   | 
  
 
 
◆ remove() [1/2]
template<typename device_t > 
  
  | 
      
   | 
  
inlineoverrideprotectedvirtualinherited   | 
  
 
 
◆ remove() [2/2]
template<
class device_t > 
 
 
non-virtual remove hides super::remove() to be used to permamently eliminate a virtual device 
 
 
◆ removed() [1/2]
template<typename device_t > 
  
  | 
      
   | 
  
inlineprotectedvirtualnoexceptinherited   | 
  
 
 
◆ removed() [2/2]
template<typename device_t > 
  
  | 
      
   | 
  
inlineprotectedvirtualnoexceptinherited   | 
  
 
 
◆ scan()
template<
class device_t > 
 
 
 
◆ shutdown()
  
  
      
        
          | virtual bool dx::driver< decltype(device_t::id) , decltype(device_t::preference)  >::shutdown  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inlinevirtualinherited   | 
  
 
 
◆ connection_id
template<
class device_t > 
 
 
 
◆ elements
  
  
      
        
          | T std::map< K, T >::elements | 
         
       
   | 
  
inherited   | 
  
 
 
◆ keys
◆ launched
  
  
      
        
          | bool dx::object::launched {} | 
         
       
   | 
  
inherited   | 
  
 
 
◆ log
  
  
      
        
          | log dx::driver< decltype(device_t::id) , decltype(device_t::preference)  >::log | 
         
       
   | 
  
inherited   | 
  
 
 
◆ matching_ids
template<
class device_t > 
 
 
 
◆ preference
  
  
      
        
          | decltype(device_t::preference)  dx::driver< decltype(device_t::id) , decltype(device_t::preference)  >::preference | 
         
       
   | 
  
inherited   | 
  
 
 
◆ product_id
  
  
      
        
          | const char* dx::driver< decltype(device_t::id) , decltype(device_t::preference)  >::product_id | 
         
       
   | 
  
inherited   | 
  
 
 
◆ version
The documentation for this class was generated from the following file: