Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123456789]

Ncf	Corefoundation namespace
C__string	RAII CFString class
Cless
C_preference	Persistant storarage base class - do not use directly! use cf::preference
Cproperty
Carray
Carray<::CFArrayRef, cf_object_t >
Carray<::CFMutableArrayRef >
Cbundle
Cdata
Citerator
Cdictionary	Key value pair store
Cdictionary<::CFDictionaryRef, cf_object_t >
Cdictionary<::CFMutableDictionaryRef >
Cerror
Cinterface
Cinterface<::IOCFPlugInInterface >
Creference
Crunloop
Cpause
Csource
Cstream
Ctree	Dx::key_value_tree<derived_t> contract (dxd/interface/dx_key_value_tree.h), implemented once for every CF-backed preference store (cf::_preference, sc::_preference, dx::coreaudio::server::_preference) - inherit from this (CRTP: class _preference: public cf::tree<_preference>) instead of reimplementing it
Ctype
Ctype< bool >
Ctype< char * >
Ctype< const char * >
Ctype< double >
Ctype< float >
Ctype< std::string >
Ctype< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==1 > >
Ctype< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==2 > >
Ctype< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==4 > >
Ctype< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==8 > >
Ctype<::CFTypeRef >	Opaque type serves as type::factory
Curl
Cuuid
Ndx	Dynax driver framework user mode interface namespace
Nabstract
Cevent
Nasio	ASIO namespace
Nclient
C_device	ASIO client streaming device interface class
Casio
Ccallbacks
Cdevice
Cdriver
Cproperty
Cstream
Ctarget
Nservice	Service interface namespace
Cdevice
Cdriver
Cdriver
Cpause
Cproperty
Ncoreaudio	Coreaudio - dynax coreaudio namespace
Npod
Cdevice	CoreAudio stream client device
Cstream
Npromoted
Cproperty	Coreaudio::promoted::property
Nserver
C_preference	Persistant CoreAudio storarage base class - do not use directly! use coreaudio::server::preference
Ccontrol
Cproperty
Cclock
Cspdif
Cdevice	CoreAudio server streaming device
Chost
Cpin
Cplugin	CoreAudio server plugin
Nstream
Cdevice	CoreAudio stream client device
Cstream
C__target
C_device	CoreAudio client device
Cclocksource
Cicon
Cdevice	CoreAudio client device
Cdriver
Cproperty
Cproperty	Coreaudio::property
Cdevice
Clisten	Coreaudio::property::listen
Cplugin
Cpod
Cdevice
Cstream
Cqualifier
Cvirtuel
Cdevice
Ctarget
Cdx_packed
Cdx_packed
Cdx_packed
Ncoremidi	Coremidi - dynax coremidi interface namespace
Npromoted
Cproperty	Coremidi::promoted::property
Nserver	Server - dynax coremidi::server interface namespace
Cdevice	CoreMIDI device
Cpin
Cplugin	CoreMIDI plugin
C_device	CoreMIDI client device
Cdevice	CoreMIDI client device
Cdriver
Cproperty	Coremidi::property
Clisten	Coremidi::property::listen
Cstream
Ctarget
Ngui
Caggregate
Cbar	Dx::gui::bar A row of independently toggling buttons, reporting (id, state) on change
Cbox	Dx::gui::box A read-only dropdown of (label, value) pairs, reporting the selected value
Clabel	Box::label Corrects JUCE awkward positioning and size of the juce::ComboBox editor. This is attached by the cpl::looknfeel class
Cbutton
Ccheckbox
Ccomponent_size_pair
Ccpl	Dx::gui::cpl wxWidgets counterpart of the juce dx::gui::cpl application shell: a resizable window holding a tree of the driver's devices (with "+"/"-" buttons to create/destroy pod devices), a File/Debug/Help menu bar mirroring the juce interface's New/Open/Import/Save/Save As/Recent/Exit, Logging and About, and the exception hierarchy dialog above for uncaught exceptions
Cdevice	Dx::gui::device Mixes an outline presence into a device_t, mirroring the juce interface's nesting one-for-one: device::stream::pin, device::clock::samplerate, device::iosize and device::clients are nested dx::gui::item subclasses here too, each row showing its own controls inline, exactly like the juce TreeView design - the one deviation forced by wx is that every wxWindow needs its parent at construction time, so (unlike juce, which lazily makes a Component once a TreeViewItem becomes visible) device_t's own outline row cannot be built inside its constructor: the generic driver/map machinery constructs device_t itself, before any wx parent window exists. attach() below is therefore called once by the driver, once a wx parent is available, and builds the outline from that point on exactly as juce's device::update() does
Cclients	Dx::gui::device::clients Detail row listing the processes currently holding this device open. Closed by default, matching juce, and kept live via device.clients.listen
Cclock	Dx::gui::device::clock Detail row of a clock domain: current samplerate, nested (closed by default, matching juce) beneath the set of rates it is allowed to run at
Ciosize	Dx::gui::device::iosize Detail row of the device's streaming I/O block size, bounded by the primary clock's supported range and quantised to its tick interval. Closed by default, matching juce
Cstream	Dx::gui::device::stream Detail row of a stream: bidirectional/in/out, channel count, sync-reference eligibility and pin count; rebuilds its dx::gui::device::stream::pin child rows when the pin count changes
Cpin	Dx::gui::device::stream::pin Detail row of a single stream pin: name, direction/channels/index, sample format (audio/MIDI, resolution, scalar/float, byte size, endian, alignment), latency and encoder role - grouped into the same dense rows juce uses
Cdirection
Cexception_dialog	Dx::gui::exception_dialog wxWidgets counterpart of the juce interface's exception hierarchy dialog: shows a dx::exception and its chain of causes (frame, comment, what()+error code, file:line, function) as a navigable tree, instead of collapsing it into a single message string
Cfile	Given vendor/product-relative path, in the platform's standard app data location
Cimage
Citem	Dx::gui::item wx counterpart of the juce interface's dx::gui::item<component_t>: one row of a single, continuously expandable outline. Every device and every one of its stream/pin/clock/... rows is an item, nested directly inside its parent item and indented beneath it, showing its own controls inline via content - mirroring juce's TreeView design, where wx has no equivalent of an arbitrary Component hosted per tree row (wxTreeCtrl cannot host child controls), so the outline is built here from plain wxPanel rows in nested box sizers instead
Clabel
Clooknfeel	Dx::gui::looknfeel Approximates the juce interface's dark/light colour scheme on the containers wx lets us recolour (frame/panel/splitter backgrounds, the tree, and - via colour inheritance - future field labels) without fighting native control rendering. Buttons, combo boxes, checkboxes and text fields are deliberately left to render as the platform normally would: recolouring native controls fights macOS's own dark-mode appearance, whereas juce draws every control itself and so can commit to one look on every platform
Cpower2
Ctext	Dx::gui::text An editable single line text field, committing on Enter or on losing focus
Nmap
Cdriver
Nmidi
Ccircular
Npower
Cac
Cacdc
Cdc
Cdisable_c3
Cscheme
Nprocess	Process
Cmmcss	Mmcss | thread priority/process priority class
Nproxy	OS proxy interface class
Nstream	Stream interface
C_device
Cpromoted	Dx::proxy::stream::device::promoted with device::preference
Cdevice
Cstream
Cdevice	OS proxy device interface class
Csoftware	Software Device API instance
Cdriver
Cnotification
Cdevice
Cproperty
Csetup
Nredirect	Redirect std IO
Ccerr
Cclog
Ccout
Ceventlog
Cfile	Redirect stdout to file
Cindent
Cdflt
Cstreambuf	Indented streambuf
Clog	Redirect stdout to unified logging
Csyslog	Redirect stdout to syslog
Nservice	Service interface namespace
Nclient
C_device	Service client streaming device interface class
Cchain
Cdevice
Cdriver
Cproperty
Cstream
Csync
Ctarget
Caccept
Cto
Capp	Service::app - Windows Service Windows services are essentially just a type of container for which startup conditions can be defined. The service interface does not support any additional communication. Communication between client and service are usually be implemented using Windows named pipes
Cdevice	Device - hosts a per-device pipe::server, keyed by puuid, separate from the driver-level control pipe Each connected client is represented by a user_client instance holding a std::shared_ptr<device>, so the device stays alive for as long as any client stays connected to it. conclude() stops that pipe before calling super::conclude(); since pipe::server::stop() unconditionally joins every instance - connected or not - this releases every user_client's device reference synchronously, within the same call. A caller holding the last other std::shared_ptr<device> (e.g. map::driver::remove()) is therefore guaranteed to reach a zero refcount, and run the device's destructor, before conclude() returns - independent of any further pipe activity. This is what lets a deferred cleanup step tied to the device's own destruction (e.g. the Windows registry preference's schedule_erase, dx_registry.h) complete within the same remove() call instead of depending on a future connection
Cpromoted	Service::device::chain handle request to/from device::promoted and pipe
Cuser_client	User client connection The each user_client holds a shared device reference
Cdriver
Cproperty
Cmanager
Cenumerate
Cpromoted
Cstatus
Cparser
Crequest
Cstart_type
Cfrom
Cto
Cstate
Cto
Nshared
Cevent	MacOS user space shared event
Cguard	Synchronize write/shared read access/destruction
Cmemory	MacOS user space shared memory
Creference	Cross-process, crash-safe named reference count
Nstream	Generic stream interface
Nchannel	Generic stream::channel interface
Ccontrol
Copen	Generic stream open request
Copened	Generic streaming channel buffer description
Nshared	Shared stream namespace
Cstream
Cclock	Select/get stream sample rate/iosize
Cmonitor	Performance monitor shared memory
Cclock_value
Ccontrol
Cpause
Cdesc	Device streaming interface descriptor
Cclock
Cdefaults
Ciosize
Csync
Ccycle
Csetting
Cexternal
Cname_id
Cstream	Dx::desc::stream interface descriptor
Cconfig	Dx::desc::stream::config interface descriptor
Cclock
Csync
Coptions
Cspdif
Ctransaction
Cpin
Cdevice
Cmonitor
Cproperty
Csync
Ccycle
Cdriver
Cencoder
Cindex
Cengine	Generic streaming engine
Cformat
Ciosize
Cobject
Copen	Generic stream open request
Copened	Generic shared streaming buffer description
Cpin
Cstart	RAII object start/stop balancer
Cstream
Ntest
Nmidi
Cdevice
Cdriver
Nservice
Cdriver
Nsurprise
Casynchronous	Concurrently drives synchronous conclude()/launch() cycles (device tree arrival/removal) against whatever else is using the driver, on its own thread
Csynchronous	Single, synchronous mid-operation conclude()/launch() cycle, resuming streaming (if it was active) at its prior sample rate once the device is back
Nusb
Cdriver
Nvirtuel
Cdriver
Cdevice
Chas_license
Chas_license< type_t, decltype((void) type_t::license, void())>
Cdriver
Cmatch_helper
Cmatch_helper< std::set< std::string > >
Cparameter
Cgenerator
Cmask
Nthread	Thread
Cprio	Thread::prio
Crealtime	Thread::prio::realtime
Cworkgroup
Cinterval
Cjoin
Ntrace
Nindent
Creceipt
Creceipt
Nusb	USB user mode interface namespace
N__
Cendpoint
Cinterface
Naudio	Generic USB audio 1.0
Cdescriptor	USB audio class descriptors
Cendpoint
Cmidi
Cgeneral
Cstreaming
Cgeneral
Csubtype
Chead
Cinterface	USB audio class interface descriptors
Ccontrol	USB audio class control interface descriptors
Cclock_multiplier
Cclock_selector
Cclock_source
Ceffect_unit
Cextension_unit
Cfeature_unit
Chead
Cheader
Cinput_terminal
Chead
Cv1
Cv2
Cmixer_unit
Chead
Cv1
Cv2
Coutput_terminal
Chead
Cv1
Cv2
Cprocessing_unit
Csamplerate_converter
Cselector_unit
Csubtype
Cv1
Cclock_selector
Cclock_selector1
Ceffect_unit
Ceffect_unit1
Cextension_unit
Cextension_unit1
Cfeature_unit
Cfeature_unit1
Cmixer_unit
Cmixer_unit1
Cprocessing_unit
Cprocessing_unit1
Cselector_unit
Cselector_unit1
Cv2
Cclock_selector
Cclock_selector1
Ceffect_unit
Ceffect_unit1
Cextension_unit
Cextension_unit1
Cfeature_unit
Cfeature_unit1
Cmixer_unit
Cmixer_unit1
Cprocessing_unit
Cprocessing_unit1
Cselector_unit
Cselector_unit1
Chead
Cmidi
Celement
Chead
Cheader
Cjack
Chead
Cin
Cout
Csubtype
Cstreaming	USB audio class streaming interface descriptors
Cencoder
Cformat
Cex
Ctype1
Ctype2
Ctype3
Chead
Ctype1
Cv1
Cv2
Ctype2
Cv1
Cv2
Ctype4
Cv1
Cv2
Cex
Cgeneral
Cv1
Cv2
Chead
Csubtype
Cv1
Cv2
Ctype
Cisoc
Ccycle
Ctick
Crange
Csubclass
Nisoc
Cframe
Nplatform	Platform dependend namespace
Cdevice
Cinterface
Cpipe
Cisoc
Cbuffer
Nstream	USB user mode streaming interface namespace
C_device
Cdevice
Cpipe
Ccache
Cencoder
Cisoc
C__request_type	Standard USB control request definitions
Ccontrol
Cdescriptor
Ctype
Cdevice
Cendpoint	USB specific errors
Cattributes
Cinterface
Cmidi	USB MIDI packetizer
Cmsg	USB MIDI endpoint element types: defining the element size for a single USB MIDI pipe request
Cpipe
Crequest
Crequest< data_t >
Nvirtuel
Nstream
C_device	Virtual streaming device interface class
Cdevice
Ctarget
Cdriver
Cproperty
Nwasapi	WASAPI namespace
Nclient
C_device	WASAPI client streaming device interface class
Cdevice
Cdriver	WASAPI client driver interface class
Cproperty
Ctarget
Ccom	COM apartment of the constructing thread, balanced only if this instance entered it
Creference	COM interface reference
Ctask_memory	CoTaskMemAlloc'd out parameter
C__scalar
Ccast
Caggregate
Cansi
Ccircular	Kernel/user space shared circular buffer
Cchannel	Copy/mix channel converters
Cchannel< dst_t, src_t >
Cfence	RAII acquire/release fence bracketing the tx/rx handshake below: acquire on construction, release on destruction, payload access in between. tx/rx stay plain volatile (not std::atomic<>) because this struct is shared byte-for-byte across the app/kernel boundary; the fences give the missing ordering guarantee on weakly-ordered CPUs (Apple Silicon, Windows ARM64) without changing the struct layout
Cclock
Cdevice	Abstract commom base device interface class
Cclient_map
Cdriver	Abstract base driver interface class This is the abstract base interface to a driver
Cdisconnect
Cevent
Cevent< kernel >	Kernel triggerable user space event
Cevent< user >
Cexception
Cfile
Cguid
Ciobridge	Ioctl bridge for 32/64bit user mode/kernel space big/little endian interface
Cis_dx_iterator
Cis_dx_iterator< type_t, std::void_t< typename type_t::dx_iterator_tag > >
Cis_initializer_list
Cis_initializer_list< std::initializer_list< type_t > >
Cis_smart_pointer
Cis_smart_pointer< std::shared_ptr< type_t > >
Cis_smart_pointer< std::unique_ptr< type_t, deleter_t > >
Cis_smart_pointer< std::weak_ptr< type_t > >
Cis_string_container
Cis_string_container< type_t, false >
Cprobe
Cprobe< t, std::void_t< typename t::value_type, decltype(t(std::declval< std::set< std::string >::iterator >(), std::declval< std::set< std::string >::iterator >()))> >
Citerator	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
Ckey_value_tree	Hierarchical key/value navigation over a flat persistent store
Citerator
Ckey_value_tree_enabled
Ckey_value_tree_enabled< tree_t, value_t, std::void_t< decltype(tree_t::template enabled< value_t >())> >
Claunch	RAII object launcher
Clicense
Ctypes
Clisten	Guarded listerners map used from the server side to manage listeners
Clistener	Balanced listener client into servers listeners map used from the client side to manage its subscription into the server listeners map
Clisteners	Internal helper to map single listener into listerners map
Clog
Cfrom
Cmodule
Cfrom
Cto
Cscope
Cfrom
Cto
Cto
Cobject
Copen	RAII manage balanced object open/(close)
Cos_event	Kernel/user space shared event representation
Coverlapped
Cparser	Cmd line parser
Cdispatch
Cpci	Physical PCI stream descriptor
Cdma	Physical DMA stream descriptor
Cpipe	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
Caccess
Cserver	Server - accepts multiple concurrent pipe client connections Each accepted connection is served by its own pipe::server::instance, running on a dedicated read thread. run() keeps exactly one instance listening for the next client at all times: once ConnectNamedPipe() accepts a connection, that instance's own thread calls server::run() again - reaping already-concluded instances and spawning the next listener - before servicing its own connection. A concluded instance (client disconnected) therefore joins only at the start of the next run(), on a different thread: a std::jthread cannot join itself, so reaping cannot happen from within the concluding instance's own read thread. An otherwise idle server thus keeps its most recently used instance around until either the next connection or stop(), which unconditionally joins every instance - connected or not - synchronously before returning
Caccess
Cinstance
Cstatus
Cprocess
Cpromoted	Promoted value
Cchain
Cpreference
Cpromoting	Promoted::preference with default and optional alignment function
Cpromoting< preference_t, std::void_t< decltype(preference_t::listen)> >
Creference	RAII manage balanced object open/(close)
Cregistry	Flat, non-hierarchical Windows registry access to one real key
Cresource	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.)
Cselect	Select from aggregated drivers
Cserial	Serial interface
Cstring
Ctty
Cvoid_struct
Cwindow
Ndxd	Dynax driver framework kernel namespace
Nabstract
Cevent	Abstract::event: base clase to event<dx::user> and event<dx::kernel> to allow mixed user/kernel broadcast signalization
Ndmus	Dmus namespace
Cminiport	Dmus::miniport
Cstream	Dmus::stream
Ndoubly
Nlinked
Nabstract
Cevent	Semi lock free doubly linked event list
Cevent	Semi lock free doubly linked event item
Citem	Semi lock free doubly linked list item
Clist	Partially lock free doubly linked list
Nlinked
Nabstract
Cevent	Lock free linked event list item
Cevent	Lock free linked event
Citem	Singly linked list item
Clink
Clist	Lock free singly linked list
Nmultichannel
Cstream	Generic kernel multichannel stream
Cclock
Cmonitor	Clock::monitor buffer to be shared with user client mappings to measure jitter and latencies at various levels (IRQ, DPC, ASIO)
Cin	Kernel stream mapped client reference counted in channel buffers
Cumap	Stream user mapping
Cchannel
Nportcls	Portcls namespace
Cdevice	Adapter device streaming a lower device stack
Cminiport	Portcls::miniport
Cpin
Cstream	Portcls::stream base class
Cwave	Wave filter description shared by the wave port models
Nrange	Range namespace
Caudio	KSDATARANGE_AUDIO constructor
Nwavert	WaveRT namespace
Cminiport	Wavert::miniport
Cstream	Wavert::stream: cyclic WaveRT buffer with client notifications
Nwdm	WDM++ - windows helper classes
Cdevice_interface	Enabled device interface: registered and enabled by initialize(), disabled on destruction
Cfile	File class
Cirp	IRP class
Cregistry
Cunicode	WDM unicode string helper
Cworkitem	WDM workitem helper
C__atomic_pointer	Atomic pointer operations
C__atomic_pointer< type_t * >
C__atomic_scalar
C__atomic_scalar< 4, type_t >	32bit atomic operations
C__atomic_scalar< 8, type_t >	64bit atomic operations
Cadapter	PortCls adapter driver
Cclient	User client: one per control open, mirrors dxd::client
Cdevice	Per-FDO adapter device: miniport subdevices are created in start()
Cadjust
Cadjust< host >
Cadjust< swap >
Carray
Catomic	Atomic operations
Catomic< type_t * >	Explicitely specify pointer template argument:
Cbroadcast	Broadcast signalization of participating linked event items
Cbuffer	Kernel memory buffer w/o alignment and boundary requirements
Cbus	WDM BUS class
Cdesc	Device description for bus class
Cclient	User client
Cclock	Kernel-mode periodic software clock, mirroring dx::clock's tick()/run()/halt() shape
Cdecay	No array/function decay - not needed here
Cdevice
Cdriver_creator	Dummy WDF interface class
Cevent	Kernel event
Cevent< dx::kernel >
Cevent< dx::user >	Kernel representation of shared user space event
Cfourchar_string
Cfw	WDK: FireWire device
Caddress	IOKit: FireWire address space
Cphy	IOKit: FireWire physical address space
Cguid
Clock
Cmap	WDK memory mapping
Cmap< dx::kernel, vm_t >	WDK: kernel space memory mapping
Cmap< dx::user, vm_t >	WDK: user space memory mapping
Cmemory	Virtual kernel memory description
Cmutex	Mutex
Copen
Cpci
Cresources
Cmemory
Cscatter_gather
Cport	Miniport creation helper
Creference
Cppc	PPC device
Cprocess	IOKit process thread
Cpromoted	Kernel-mode promoted value, mirroring dx::promoted's server/commit/notify shape
Creference	Reference holder for object based reference counter
Creferenced	Reference counting base class
Cremove_reference
Cremove_reference< type_t & >
Cremove_reference< type_t && >
Cscoped
Cscoped<::URB >
Cspinlock	WDK spinlock
Cstream	Generic kernel stream
Copened	Generic streaming interface description
Cumap	Stream user mapping
Cusb_device
Cpipe	IOKit: USB pipe class
Cisoc_frame
Cusb_stream_client	Generic USB user client class
Cusb_stream_device	Generic USB device
Cclock
Cstream	USB stream
Cwstring
Nio	Io - IOKit namespace
Citerator	Internally used service iterator providing RAII for io_service references - returned when iterating
Cservice
Cport	Notification port
Cpower	System power notification receiver to get notifications: inherit and connect to runloop
Creference
Cregistry	MacOS IORegistry access
Nsc	Sc - system configuration namespace
C_preference	Persistant system configuration storarage base class - do not use directly! use sc::preference
Nsec	Sec - security namespace
C__code
Ccertificate	Persistant system configuration storarage base class - do not use directly! use sc::preference
Ccode
Ccode<::SecCodeRef >
Ccode<::SecStaticCodeRef >
Citem
Ctrust