README

mokomoking2501/lockwire/driver does not have a README file

#
LinkDriverKind

pub(all) enum LinkDriverKind {
RawEthernetSocket
UdpDatagramSocket
PacketCaptureWriter
InterfaceListing
HighResolutionClock
ZeroCopyFramePool
} derive(Eq,
Debug
)

#
LinkDriverKind::label

fn LinkDriverKind::label(self : LinkDriverKind) -> String

#
LinkDriverMergeReport

pub(all) struct LinkDriverMergeReport {
catalog_count : Int
raw_ethernet_count : Int
udp_datagram_count : Int
pcap_count : Int
zero_copy_count : Int
native_gate_count : Int
protocol_import_free : Bool
live_adapter_evidence : Bool
provider_master_harness_count : Int
lockwire_builtin_master_harness_count : Int
lockwire_protocol_semantics_owned : Bool
trace_event_count : Int
replay_count : Int
same_seed_stable : Bool
digest :
SimDigest

} derive(Eq,
Debug
)

#
LinkDriverMergeReport::passes

fn LinkDriverMergeReport::passes(self : LinkDriverMergeReport) -> Bool

#
LinkDriverRuntime

pub(all) enum LinkDriverRuntime {
WindowsNpcap
LinuxRawSocket
WinsockUdp
BsdUdpSocket
PcapFileWriter
MoonEcatFramePool
NativeClock
} derive(Eq,
Debug
)

#
LinkDriverRuntime::label

fn LinkDriverRuntime::label(self : LinkDriverRuntime) -> String

#
LinkDriverSource

pub(all) enum LinkDriverSource {
MoonEcatHalNative
ProfinetRawNet
ProfinetUdpNet
ProfinetPcapDump
} derive(Eq,
Debug
)

#
LinkDriverSource::label

fn LinkDriverSource::label(self : LinkDriverSource) -> String

#
LinkDriverSpec

pub(all) struct LinkDriverSpec {
id : String
source : LinkDriverSource
kind : LinkDriverKind
runtime : LinkDriverRuntime
reference_path : String
operations : Array[String]
requires_native : Bool
requires_runtime : Bool
has_non_native_fallback : Bool
zero_copy : Bool
live_validation_locked : Bool
protocol_import_free : Bool
} derive(Eq,
Debug
)

#
LinkDriverSpec::catalog_label

fn LinkDriverSpec::catalog_label(self : LinkDriverSpec) -> String

#
LinkDriverSpec::has_operation

fn LinkDriverSpec::has_operation(self : LinkDriverSpec, operation : String) -> Bool

#
LinkDriverSpec::is_native_gate

fn LinkDriverSpec::is_native_gate(self : LinkDriverSpec) -> Bool

#
LinkDriverSpec::operation_count

fn LinkDriverSpec::operation_count(self : LinkDriverSpec) -> Int

#
LinkMasterHarnessDescriptor

pub(all) struct LinkMasterHarnessDescriptor {
id : String
provider_id : String
stack_id : String
stack_family : String
descriptor_path : String
protocol_stack_path : String
master_control_path : String
driver_ids : Array[String]
supports_scan : Bool
supports_cyclic_io : Bool
supports_recording : Bool
minimal_master_candidate : Bool
live_validation_locked : Bool
provider_owned_delivery : Bool
lockwire_owns_protocol_semantics : Bool
} derive(Eq,
Debug
)

#
LinkMasterHarnessDescriptor::driver_count

#
LinkMasterHarnessDescriptor::passes_against

#
LinkMasterHarnessDescriptor::references_catalog

fn LinkMasterHarnessDescriptor::references_catalog(self : LinkMasterHarnessDescriptor, catalog : ArrayView[LinkDriverSpec]) -> Bool

#
LinkMasterHarnessDescriptor::uses_driver

fn LinkMasterHarnessDescriptor::uses_driver(self : LinkMasterHarnessDescriptor, driver_id : String) -> Bool

#
LinkMasterHarnessValidationReport

pub(all) struct LinkMasterHarnessValidationReport {
descriptor_count : Int
passing_descriptor_count : Int
provider_owned_descriptor_count : Int
lockwire_protocol_semantics_owned : Bool
trace_event_count : Int
replay_count : Int
same_seed_stable : Bool
digest :
SimDigest

} derive(Eq,
Debug
)

#
LinkMasterHarnessValidationReport::passes

#
LinkReadinessMatrixReport

pub(all) struct LinkReadinessMatrixReport {
target_count : Int
windows_target_count : Int
linux_target_count : Int
stm32_threadx_target_count : Int
host_native_target_count : Int
embedded_target_count : Int
raw_frame_target_count : Int
udp_target_count : Int
pcap_artifact_target_count : Int
frame_pool_target_count : Int
live_locked_count : Int
no_live_plan_ready_count : Int
embedded_driver_gap_count : Int
driver_reference_failure_count : Int
hal_reference_failure_count : Int
os_reference_failure_count : Int
reactor_reference_failure_count : Int
live_evidence_present : Bool
trace_event_count : Int
replay_count : Int
same_seed_stable : Bool
digest :
SimDigest

} derive(Eq,
Debug
)

#
LinkReadinessMatrixReport::passes

#
LinkReadinessMatrixReport::to_text

#
LinkReadinessTarget

pub(all) struct LinkReadinessTarget {
id : String
kind : LinkReadinessTargetKind
profile :
CapabilityProfile

reactor_id : String
os_capability_ids : Array[String]
hal_capability_ids : Array[String]
driver_ids : Array[String]
host_os : String
board_family : String
supports_raw_frame : Bool
supports_udp : Bool
supports_pcap_artifact : Bool
supports_frame_pool : Bool
requires_threadx : Bool
requires_bsp : Bool
requires_hardware : Bool
live_validation_locked : Bool
no_live_plan_ready : Bool
live_evidence_present : Bool
} derive(Eq,
Debug
)

#
LinkReadinessTarget::driver_count

fn LinkReadinessTarget::driver_count(self : LinkReadinessTarget) -> Int

#
LinkReadinessTarget::hal_count

fn LinkReadinessTarget::hal_count(self : LinkReadinessTarget) -> Int

#
LinkReadinessTarget::is_embedded

fn LinkReadinessTarget::is_embedded(self : LinkReadinessTarget) -> Bool

#
LinkReadinessTarget::references_drivers

fn LinkReadinessTarget::references_drivers(self : LinkReadinessTarget, catalog : ArrayView[LinkDriverSpec]) -> Bool

#
LinkReadinessTarget::references_hal

#
LinkReadinessTarget::references_os

#
LinkReadinessTarget::references_reactor

#
LinkReadinessTargetKind

pub(all) enum LinkReadinessTargetKind {
LinkTargetWindowsNpcap
LinkTargetLinuxRaw
LinkTargetStm32Threadx
} derive(Eq,
Debug
)

#
LinkReadinessTargetKind::label

fn link_readiness_matrix_report(seed? : Int) -> LinkReadinessMatrixReport

fn link_readiness_matrix_trace_fixture(seed? : Int) ->
TraceLog

fn link_readiness_targets() -> Array[LinkReadinessTarget]

fn moonecat_link_driver_specs() -> Array[LinkDriverSpec]

fn native_link_driver_catalog() -> Array[LinkDriverSpec]

fn native_link_driver_merge_report(seed? : Int) -> LinkDriverMergeReport

fn native_link_driver_trace_fixture(seed? : Int) ->
TraceLog

#
package_id

fn package_id() -> String

fn profinet_link_driver_specs() -> Array[LinkDriverSpec]

#
provider_master_harness_trace_fixture

fn provider_master_harness_trace_fixture(harnesses : ArrayView[LinkMasterHarnessDescriptor], seed? : Int) ->
TraceLog

#
validate_master_harness_descriptors

fn validate_master_harness_descriptors(harnesses : ArrayView[LinkMasterHarnessDescriptor], seed? : Int) -> LinkMasterHarnessValidationReport

Source Files