|
| namespace | abstract |
| namespace | asio |
| | ASIO namespace.
|
| namespace | color |
| | the SGR sequences, by their effect; dx::themed picks between two of them
|
| namespace | coreaudio |
| | CoreAudio, both sides of it: dx::coreaudio is the HAL client - a device the system published, whoever drives it - and dx::coreaudio::server is the plugin that publishes one. Settings are HAL properties here, promoted over dx::coreaudio::promoted::property.
|
| namespace | coremidi |
| | the MIDI client over CoreMIDI, which speaks Universal MIDI Packets since macOS 11 - so this bus's rings carry UMP, and a MIDITimeStamp is dx::timestamp itself, converted nowhere
|
| namespace | crypto |
| | cryptographic primitives a signature check takes, kernel and user mode alike: no allocation, no exception, no platform
|
| namespace | daemon |
| namespace | der |
| | ASN.1 DER, walked in place: what a certificate's fields and a license's private extensions take.
|
| namespace | dll |
| | the registry names a COM server is registered under - what the ASIO driver's own registration writes
|
| namespace | erase |
| namespace | fourchar |
| | the four character codes of the OS audio APIs: to::string prints the printable bytes and the numeric value of the others, from::string packs four bytes back into the word
|
| namespace | gui |
| | the control panel's widgets over JUCE: each one takes the value it edits and a listener, writes the device's desc back on a change and follows the desc when something else changes it - so a panel is composed of these, never of event handling of its own
|
| namespace | install |
| | driver package installation namespace
|
| namespace | ioctl |
| | IOCTLs namespace.
|
| namespace | licensing |
| | a license: an X.509 certificate the product's root signed, its attributes private extensions
|
| namespace | map |
| namespace | midi |
| namespace | platform |
| | the machine's identity a license may be bound to (dx_common.cpp)
|
| namespace | power |
| namespace | process |
| | process
|
| namespace | proxy |
| | OS proxy interface class.
|
| namespace | redirect |
| | redirect std IO: a stream's distributor (dx::redirect::indent::streambuf) hands every write to the sinks joined to it - any std::streambuf: the stream's own, a file's, a line sink's (dx::redirect::line) - which join and leave in any order, each for its object's life (dx::redirect::join)
|
| namespace | service |
| | a device that is an IOService of the registry, without a driver connection of its own - what a proxy device derives its identity and its properties from
|
| namespace | shared |
| namespace | smbios |
| | the SMBIOS tables as the firmware interface hands them out (RawSMBIOSData: GetSystemFirmwareTable 'RSMB', WMI MSSmBios_RawSMBiosTables - one layout), walked in place
|
| namespace | stream |
| | generic stream interface
|
| namespace | test |
| | the manual exerciser: one dx::test::driver per client bus, each a dx::parser of its own, handed to dx::select. It prints rather than asserts - the output is the verdict
|
| namespace | thread |
| | thread
|
| namespace | trace |
| namespace | usb |
| | USB user mode interface namespace.
|
| namespace | virtuel |
| | the in-process bus: devices exist in the preference store alone, no OS registration of any kind. It exercises the shared stream machinery - device, pins, groups, engine - without a plugin, a service or a kernel driver, and its desc types are the generic default other buses fall back to
|
| namespace | wasapi |
| | WASAPI namespace.
|
| namespace | x509 |
| | the fields of an X.509 certificate a license check reads, off its DER: kernel and user mode alike
|
| namespace | xpc |
|
| struct | __scalar |
| | an integer of a width the language has none for - dx::int24/dx::uint24, packed into its own bytes because a bit field of a packed struct still costs four bytes here More...
|
| struct | aggregate |
| | forwards a braced argument list into a type with no matching constructor - the conversion builds it from the stored tuple, so an aggregate can be returned or passed where its own members would not deduce More...
|
| struct | ansi |
| | an SGR/OSC control sequence, written only where it is read: every sink below drops it unless stderr is a terminal More...
|
| class | apartment |
| | the COM apartment of one object - a device or a whole driver: its thread creates the object, runs its steps and releases it More...
|
| struct | circular |
| | kernel/user space shared circular buffer More...
|
| class | clock |
| | realtime tick mechanism: one thread per clock - run/halt lifecycle and tick dispatch; the source_t base owns objective and wait More...
|
| class | device |
| | abstract commom base device interface class More...
|
| class | driver |
| struct | driver_settings |
| | abstract base driver interface class This is the abstract base interface to a driver. More...
|
| class | event |
| class | event< kernel > |
| | kernel triggerable user space event More...
|
| class | event< user > |
| | the process local event over a condition variable; dx::event<kernel> is the platform's own, waitable together with an OS handle More...
|
| class | exception |
| | a throw's whole diagnostic: the OS result, where it was raised (frame, file, line), the thread and the moment, a formatted comment and the exception it grew out of. Each frame on the way out wraps the one below into a new exception of its own - dx_catchall and friends do nothing else - so previous is the chain down to the origin, deep copied and owned by the wrapper; dx::trace::unfold prints it. The constructor overloads below are one signature per combination of the optional leading arguments (previous, function, error, what) ahead of the mandatory frame/file/line, with and without the printf-style comment. More...
|
| struct | fence |
| | the memory ordering plain shared state needs on weakly ordered CPUs, in user mode and the kernel alike More...
|
| class | file |
| | an open handle to a device interface - what every ioctl of a proxy device goes through More...
|
| class | free_run |
| | free running timer source: condition variable timer at system timer resolution; duration zero degenerates to the event driven base More...
|
| class | guid |
| | a ::GUID with the arithmetic Windows leaves out: constructed from its parts or its string, ordered so it can be a map key, printed as its string More...
|
| struct | int24be |
| | a packed 24 bit integer stored big endian: converts from and to the native int on every access, so the ring converters take it like int24 More...
|
| struct | iobridge |
| | ioctl bridge for 32/64bit user mode/kernel space big/little endian interface More...
|
| struct | is_dx_iterator |
| struct | is_dx_iterator< type_t, std::void_t< typename type_t::dx_iterator_tag > > |
| struct | is_initializer_list |
| struct | is_initializer_list< std::initializer_list< type_t > > |
| struct | is_smart_pointer |
| struct | is_smart_pointer< std::shared_ptr< type_t > > |
| struct | is_smart_pointer< std::unique_ptr< type_t, deleter_t > > |
| struct | is_smart_pointer< std::weak_ptr< type_t > > |
| struct | is_string_container |
| struct | is_string_container< type_t, false > |
| class | iterator |
| | range-for support shared by every dxd type whose elements aren't already kept in an STL container of their own (dx::key_value_tree, cf::data, cf::dictionary, cf::array): a derived_t populates container_t however it needs to - a single existing conversion, or an explicit per-element loop - in its own constructor, then calls seed() once population is complete; operator++()/operator!=() forward to container_t's own iterator from then on. operator*() stays derived_t's own: what it should return (a plain element, const or not) differs per user, from cf::data's read-only bytes to dx::key_value_tree's mutable, further-navigable child node. More...
|
| class | key_value_tree |
| | hierarchical key/value navigation over a flat persistent store More...
|
| struct | key_value_tree_enabled |
| struct | key_value_tree_enabled< tree_t, value_t, std::void_t< decltype(tree_t::template enabled< value_t >())> > |
| class | launch |
| | RAII object launcher. More...
|
| class | license |
| | the first certificate of the platform's store naming the product that the root signed, whose constraints this machine and device satisfy and that, unless perpetual, has not expired; kernel and user mode alike over the platform part (dx_platform_license.h: the store's candidates and their DER, the time, the machine's serial number and ethernet addresses, what to keep and the missing/forged hooks) More...
|
| class | listen |
| | guarded listerners map used from the server side to manage listeners More...
|
| class | listener |
| | balanced listener client into servers listeners map used from the client side to manage its subscription into the server listeners map More...
|
| class | listeners |
| | internal helper to map single listener into listerners map More...
|
| union | log |
| | the whole log setting in one 32 bit word: a dx::log::level per dx::log::scope per dx::log::module, four bits each. The word is what a driver, a kernel and a host exchange and compare; the named members are the same bits, and to/from name them for a preference, a command line or a property. The serialization macros hand the member list to the tree and CF sinks of dx_serialize.h, so the store holds the log resolved rather than the word. More...
|
| class | object |
| | the framework's object lifecycle: launch() once mounted, conclude() before removal, both reached through the try_ pair alone, which elects the single caller that runs them. Neither is a constructor's or destructor's job: an object is constructed long before its resources exist (a device ahead of its bus arrival) and outlives their release. The destructor's try_conclude() is the backstop for an object never concluded by its owner. More...
|
| class | open |
| | RAII manage balanced object open/(close). More...
|
| struct | os_event |
| | kernel/user space shared event representation More...
|
| class | overlapped |
| | an overlapped operation with the event it completes on, and the wait for its result More...
|
| class | parser |
| | cmd line parser More...
|
| struct | pci |
| | physical PCI stream descriptor More...
|
| class | pipe |
| | pipe - Windows named pipes A dx::pipe is a bidirection, multi-client, multi-threaded communication channel between a pipe client and a pipe server. Both pipe sides feature a dedicated read thread to receive data from the opposite side notifiying installable listener std::functions. On the service side, a pipe server is instantiated for each pipe client connection. Until a new client connects, the pipe::server::instance remains waiting in pipe::server::instance::connect within its dedicated pipe read thread. If a client disconnects the pipe::server::instance terminates its read thread and is joined and released by the next pipe::server::run() or pipe::server::stop(). The pipe::server::instance super class can be template-parameterized to allow mimicking user client behaviour. Windows arbitrarily serializes operations on synchronous pipe handles, limiting it's named pipe concurrent synchronous operation capabilities to exactly one synchronous pipe per process (i.e. exactly one per process), effectively forcing both the pipe::server and the pipe client to be implemented using asynchronous OVERLAPPED I/O — introducing a whole host of unnecessary pitfalls and awkward behaviors. However, the MSDN documentation here apparently describes a different piece of software. Though dx::pipes can be used for any communication between user space software its purpose is to allow Windows service communication. A service itself runs with elevated privileges, whereas the clients typically run in the normal user context. Therefore, the pipe servers have defined their default ACLs for non-privileged access. More...
|
| class | process |
| | a child process with its handles, started and waited for; mmcss inside it is what a streaming thread of this process registers with the multimedia scheduler as More...
|
| class | promoted |
| | promoted value More...
|
| struct | promoting |
| | promoted::preference with default and optional alignment function More...
|
| struct | promoting< preference_t, std::void_t< decltype(preference_t::listen)> > |
| class | reference |
| | RAII manage balanced object open/(close). More...
|
| class | registry |
| | flat, non-hierarchical Windows registry access to one real key More...
|
| class | resource |
| | Windows handle class bill wasn't sure wether an invalid handle is a nullptr or -1. Hence the invalid_t template parameter. (Usually its -1, but i.e. for file mappings its nullptr, etc.). More...
|
| class | security |
| | Windows security descriptor: allows non-privileged access. More...
|
| class | select |
| | select from aggregated drivers More...
|
| class | serial |
| | serial interface More...
|
| class | source |
| | clock source base: the only thing that may signal a tick - itself the event driven source (hw clock fan-out) More...
|
| struct | spin |
| class | string |
| | a fixed size name that crosses a process or kernel boundary by value, where a std::string cannot: the platform's file name length, always terminated, converting to and from std::string More...
|
| struct | themed |
| class | timebase |
| class | timer |
| | high resolution timer source: an OS timer wait toward the objective, optionally handing over to yield/spin polling covering the last lead; self pacing by duration like free_run, or paced by an override's sync() More...
|
| struct | tty |
| | the terminal behind a file descriptor: its presence, its raw mode and its background colour More...
|
| struct | void_struct |
| | the empty stand-in where a template needs a type but nothing is carried - it streams nothing More...
|
| class | window |
| | a message only window on a thread of its own: WM_DEVICECHANGE and WM_POWERBROADCAST are what Windows delivers device arrival, removal and sleep through, and there is no window less way to take them More...
|
| struct | yield |
| | stateless polling wait strategies: trade a core for the last microseconds toward an objective More...
|
|
| enum | : ::DWORD {
ok = kIOReturnSuccess
, unknown = kIOReturnInvalid
, not_implemented = kIOReturnUnsupported
, invalid = kIOReturnBadArgument
,
device_error = kIOReturnDeviceError
, no_resources = kIOReturnNoResources
, invalid_data = kIOReturnNoSpace
, not_initialized = kIOReturnNotReady
,
no_device = kIOReturnNoDevice
, version_mismatch = err_system(0x37)| err_sub(2)| 0x14
, invalid_priority = ERROR_INVALID_PRIORITY
, timeout = kIOReturnTimeout
,
internal_error = kIOReturnInternalError
, exclusive = kIOReturnExclusiveAccess
, aborted = kIOReturnAborted
, busy = kIOReturnBusy
,
not_permitted = kIOReturnNotPermitted
, overflow = kIOReturnOverrun
, not_found = ERROR_FILE_NOT_FOUND
, driver_not_installed = kIOReturnNotAttached
,
driver_not_connected = kIOReturnNotOpen
, driver_not_running = kIOReturnOffline
} |
| enum | : ::mach_error_t {
ok = kIOReturnSuccess
, not_initialized = kIOReturnNotReady
, not_implemented = kIOReturnUnsupported
, invalid = kIOReturnBadArgument
,
no_device = kIOReturnNoDevice
, device_error = kIOReturnDeviceError
, no_resources = kIOReturnNoResources
, invalid_data = kIOReturnNoSpace
,
version_mismatch = err_system(0x37)| err_sub(2)| 0x14
, timeout = kIOReturnTimeout
, unknown = kIOReturnInvalid
, overflow = kIOReturnOverrun
,
driver_not_installed = kIOReturnNotAttached
, driver_not_connected = kIOReturnNotOpen
, driver_not_running = kIOReturnOffline
, internal_error = kIOReturnInternalError
,
not_permitted = kIOReturnNotPermitted
, exclusive = kIOReturnExclusiveAccess
, aborted = kIOReturnAborted
, busy = kIOReturnBusy
} |
| enum | scale : int64_t {
nsec = 1ll
, usec = 1000ll
, msec = usec* 1000ll
, sec = msec* 1000ll
,
sec = msec* 1000ll
, msec = usec* 1000ll
, usec = 1000ll
, nsec = 1ll
} |
| | the factors a dx::timestamp is scaled by - timestamp(value, msec), duration(ticks, usec) More...
|
| enum | scale : int64_t {
nsec = 1ll
, usec = 1000ll
, msec = usec* 1000ll
, sec = msec* 1000ll
,
sec = msec* 1000ll
, msec = usec* 1000ll
, usec = 1000ll
, nsec = 1ll
} |
| | Windows: timestamp to Windows time converter. More...
|
| enum | scope { kernel
, user
, kernel
, user
} |
| | template parameter defining origin of kernel object or destination of mapping More...
|
| enum | scope { kernel
, user
, kernel
, user
} |
| | template parameter defining origin of kernel object or destination of mapping More...
|
|
| template<typename type_t, int resolution> |
| class | __attribute__ ((__packed__)) __scalar |
| | an integer of a width the language has none for - dx::int24/dx::uint24, three bytes in the machine's own order, converting to and from the native type on every access
|
| os_result | _assert (os_result error, const char *expression, const char *frame, const char *file, unsigned int line) |
| | the failing expression, its frame and dx::describe of the result to stderr, then dx::halt; a zero result passes through. Only a debug build calls it: release drops the diagnostics and keeps (dx_assert_along) or drops (dx_assert_discard) the expression itself
|
| template<typename ... arg_t> |
| os_result | _assert (os_result error, const char *expression, const char *frame, const char *file, unsigned int line, arg_t... args) |
| template<typename... types> |
| | aggregate (types &&...) -> aggregate< types &&... > |
| std::string | canonical (const std::string &name, size_t length=DX_FILENAME_LENGTH) |
| | remove invalid characters from file name or return a hex hash if name is too long
|
| std::string | describe (os_result result) noexcept |
| int64_t | duration (int64_t timestamp, scale scale) |
| | macOS: timestamp duration (clock ticks) to time converter
|
| void | halt () |
| | the breakpoint a dx_pass/dx_assert failure runs into - a debugger's stop is one uncommented line away
|
| template<typename ... next_t> |
| os_result | map_os_result (os_result result, os_result desired, next_t... next) |
| | map list of os_results to a desired value This helper allows to ignore a list of os_results and if matched return the desired result instead.
|
| std::ostream & | operator<< (std::ostream &os, const exception &exception) noexcept |
| std::ostream & | operator<< (std::ostream &os, const log &log) |
| std::ostream & | operator<< (std::ostream &os, const log::level &level) |
| std::ostream & | operator<< (std::ostream &os, const log::scope &scope) |
| std::ostream & | operator<< (std::ostream &os, const void_struct &) |
| bool | os_error (os_result result) noexcept |
| inline ::CFStringRef | os_string (const char *string) noexcept |
| uint32_t | priority () |
| inline ::LARGE_INTEGER | qpc (int64_t timestamp) |
| | Windows: timestamp to performance counter reading converter.
|
| void | report_uncaught () |
| | prints an uncaught exception's actual diagnostic to stderr before the runtime terminates the process. Call once at startup - std::terminate() (an uncaught throw reaching main(), or escaping any std::thread's entry function) otherwise calls abort() with no diagnostic output at all.
|
| template<typename type_t, typename... types_t> |
| type_t & | static_try (const types_t &... args) |
| | a function local static whose constructor may throw: the throw is reported and a default constructed object takes its place, so the caller always gets one and the construction is attempted once
|
| template<typename type_t, typename... types_t> |
| type_t & | static_try (types_t &... args) |
| int64_t | time (int64_t timestamp, scale scale=nsec) |
| | macOS: timestamp (clock ticks) to time converter
|
| int64_t | timestamp () |
| | macOS: high precision timestamp (clock ticks) Returns current value of a clock that increments monotonically in tick units (starting at an arbitrary point), this clock does not increment while the system is asleep.
|
| int64_t | timestamp (const ::LARGE_INTEGER &qpc) |
| | Windows: performance counter reading to timestamp converter.
|
| int64_t | timestamp (int64_t time, scale scale=nsec) |
| | macOS: time to timestamp (clock ticks) converter
|
| int64_t | timestamp_offset (int64_t time, scale scale=nsec) |
| | macOS: duration to timestamp (clock ticks) converter
|
| const std::string & | to_string (const std::string &string) |
| std::string | version (const std::string &package) |
| | installation package version
|
| std::string | version (uint32_t v32) |
| | a DX_VERSION32 word as it is read: major.minor.sub with the deployment letter and the build number behind it
|
dynax driver framework interface namespace
intended use
dx - dynax driver framework user mode interface namespace
dx - dynax driver framework interface namespace
dynax driver framework user mode interface namespace
the interface headers shared with user mode spell the status as dx:: does
