### NetSim Demo Parameter Example - Shell

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/api.rst.txt

An example shell command demonstrating how to start the Network Simulator demo executable, specifying the participant configuration file and the desired participant name as command-line arguments.

```shell
# Start the Network Simulator Demo with the given configuration file and participant name
|DemoDir|/SilKitDemoNetSim ./SilKit-Demos/NetworkSimulator/DemoNetSim.silkit.silkit.yaml NetworkSimulator
```

--------------------------------

### Executing SIL Kit Simulation from Command Line

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/for-developers/developers.rst.txt

This command-line sequence shows how to start a SIL Kit simulation involving the sample application. It requires launching the `sil-kit-registry` for participant discovery and the `sil-kit-system-controller` to orchestrate the simulation and wait for the specified participants before starting.

```bash
# Start the Middleware Registry
./sil-kit-registry.exe

# Start the System Controller and tell it to wait for PublisherParticipant and SubscriberParticipant
./sil-kit-system-controller.exe PublisherParticipant SubscriberParticipant

# Start the application running the two participants
# Make sure that the SilKit.dll and simple.yaml are available 
./SampleSilKit.exe
```

--------------------------------

### Installing Pipenv

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/development/build.rst.txt

Installs the pipenv tool, which is mentioned as a requirement for documentation generation alongside the standard Python requirements.

```shell
pip3 install pipenv
```

--------------------------------

### Installing Documentation Python Requirements

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/development/build.rst.txt

Installs the necessary Python packages required for building the SIL Kit documentation. These dependencies are listed in the specified requirements file.

```shell
pip3 install -r SilKit/ci/docker/docs_requirements.txt
```

--------------------------------

### Building the Doxygen Documentation Target

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/development/build.rst.txt

Executes the CMake build command to compile and generate the Doxygen documentation for the project. This requires the build system to be configured with `SILKIT_BUILD_DOCS=ON`.

```shell
cmake --build . --target Doxygen
```

--------------------------------

### Simple Can Demo System Example (Notes Context) - Shell

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/api.rst.txt

Provides a basic shell command example for running the Simple Can demo participants (CanReader and CanWriter) alongside the SIL Kit registry and a system controller. This example appears in the Network Simulator section notes, potentially as a baseline or comparison.

```shell
# Registry (if not already running):
|Registry|

# Can Reader:
|DemoDir|/SilKitDemoSimpleCan CanReader

# Can Writer:
|DemoDir|/SilKitDemoSimpleCan CanWriter

# System Controller:
|SystemController| CanReader CanWriter
```

--------------------------------

### Configuring CMake with Options

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/development/build.rst.txt

Configures the CMake build system for SIL Kit from a build directory one level below the source. It enables building tests and documentation by setting the respective options to ON.

```shell
cmake .. -D SILKIT_BUILD_TESTS=ON -D SILKIT_BUILD_DOCS=ON
```

--------------------------------

### Launching Docker Containers with Docker Compose

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/development/docker/docker.rst.txt

This command uses Docker Compose to build, create, and start the services defined in the specified YAML file (`docker-compose-linux.yaml`). It brings up the `registry` and `canreader` containers required for the SIL Kit setup based on the configuration.

```shell
docker-compose -f docker-compose-linux.yaml up
```

--------------------------------

### Starting SIL Kit Registry on WSL - Shell

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/troubleshooting/connection-guides.rst.txt

This command starts the SIL Kit registry executable within the WSL environment. It configures the registry to listen for incoming participant connections on a specific IP address (the WSL instance's IP) and port using the `--listen-uri` argument, making it discoverable and accessible to participants running on the Windows host.

```Shell
./sil-kit-registry --listen-uri silkit://172.19.71.101:8500
```

--------------------------------

### Connecting SIL Kit Participant on Windows - Shell

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/troubleshooting/connection-guides.rst.txt

This command launches a SIL Kit participant executable (specifically the Monitor utility as an example) on the native Windows operating system. It uses the `--connect-uri` argument to specify the full URI of the SIL Kit registry running in WSL, enabling the participant to connect to the simulation network managed by that registry instance.

```Shell
.\sil-kit-monitor.exe --connect-uri silkit://172.19.71.101:8500
```

--------------------------------

### Running Coordinated Lifecycle Demo - Shell

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/api.rst.txt

Contains the shell commands needed to execute the Coordinated Lifecycle API demo. This setup requires starting the SIL Kit registry, two participants ('P1' and 'P2'), and a system controller to orchestrate their simulation steps and state transitions.

```shell
# Registry (if not already running):
|Registry|
    
# Participant P1:
|DemoDir|/SilKitDemoCoordinated P1

# Participant P2:
|DemoDir|/SilKitDemoCoordinated P2

# System Controller:
|SystemController| P1 P2
```

--------------------------------

### Building the CPack Package Target

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/development/build.rst.txt

Executes the CMake build command to generate the distribution package (typically a ZIP file) using CPack. This creates the ready-to-distribute archive of SIL Kit.

```shell
cmake --build . --target package
```

--------------------------------

### Implementing FlexRay Wakeup Handler (C++)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/api/services/flexray.rst.txt

Provides an example of a callback function for the FlexRay Wakeup event. Within this handler, the following cold start node responds to the wakeup signal by calling `AllowColdstart()` and `Run()` to participate in the cluster startup.

```cpp
void WakeupHandler(IFlexrayController* controller, const FlexraySymbolEvent& symbol)
{
    followingColdStartNode->AllowColdstart();
    followingColdStartNode->Run();
}
```

--------------------------------

### Starting SIL Kit Registry with Listen URI (Console)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/faq/faq.rst.txt

This console command starts the SIL Kit registry executable (`sil-kit-registry.exe`) and configures it to listen for connections on a specific URI. Using `silkit://0.0.0.0:8501` allows the registry to be accessible from any network interface on the host, making it suitable for distributed simulations where participants run on different machines and connect to this registry on port 8501. This is needed when participants are not on the same machine.

```console
./sil-kit-registry.exe --listen-uri silkit://0.0.0.0:8501
```

--------------------------------

### Configuring CMake for Documentation Build

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/development/build.rst.txt

Configures the CMake build system specifically to enable the documentation build target. The command uses a placeholder variable for the source directory path.

```shell
cmake $source_dir -D SILKIT_BUILD_DOCS=ON
```

--------------------------------

### Running Simple Can Demo - Shell

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/api.rst.txt

Provides the sequence of shell commands required to run the Simple Can API demo. It includes starting the SIL Kit registry, two participant instances ('P1' and 'P2'), and the system controller to manage their execution.

```shell
# Registry (if not already running):
|Registry|
    
# Participant P1:
|DemoDir|/SilKitDemoSimpleCan P1

# Participant P2:
|DemoDir|/SilKitDemoSimpleCan P2

# System Controller:
|SystemController| P1 P2
```

--------------------------------

### Updating Git Submodules

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/development/build.rst.txt

Initializes and updates all Git submodules recursively. This step is necessary to fetch dependencies managed as submodules for the SIL Kit project.

```shell
git submodule update --init --recursive
```

--------------------------------

### Starting SIL Kit Registry (PowerShell)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/utilities/utilities.rst.txt

This snippet shows the command-line instruction to launch the SIL Kit Registry utility using PowerShell. The Registry is essential for participant discovery in a SIL Kit simulation. It must be started before other participants connect.

```powershell
sil-kit-registry
```

--------------------------------

### Running Autonomous Lifecycle Demo - Shell

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/api.rst.txt

Shows the shell commands to start the Autonomous Lifecycle API demo. It involves starting the SIL Kit registry and two participant instances ('P1' and 'P2') that manage their simulation state independently.

```shell
# Registry (if not already running):
|Registry|
    
# Participant P1:
|DemoDir|/SilKitDemoAutonomous P1

# Participant P2:
|DemoDir|/SilKitDemoAutonomous P2
```

--------------------------------

### Running Simulation Step Handler Demo - Shell

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/api.rst.txt

Presents the shell commands to launch the Simulation Step Handler API demo. The setup includes the SIL Kit registry, two participants ('P1' and 'P2') utilizing step handlers, and the system controller for coordinated execution.

```shell
# Registry (if not already running):
|Registry|
    
# Participant P1:
|DemoDir|/SilKitDemoSimStep P1

# Participant P2:
|DemoDir|/SilKitDemoSimStep P2

# System Controller:
|SystemController| P1 P2
```

--------------------------------

### Example Includes Configuration with Search Paths and Files in SIL Kit YAML

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/configuration/includes-configuration.rst.txt

Provides a complete example of the `Includes` section in a SIL Kit participant configuration, showing how to specify both a list of search paths to help locate included files and the specific configuration files to be included.

```yaml
Includes:
   SearchPathHints:
      - ./ConfigSnippets/Generated/
   Files:
      - generated-uri.silkit.yaml
      - ../common-logging.silkit.yaml
```

--------------------------------

### Starting SIL Kit System Controller with Participants (PowerShell)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/utilities/utilities.rst.txt

This command starts the SIL Kit System Controller and instructs it to wait for two specific participants, 'Participant1' and 'Participant2', to join the simulation before allowing coordinated participants to proceed. It requires a running SIL Kit Registry to connect to.

```powershell
sil-kit-system-controller Participant1 Participant2
```

--------------------------------

### Running NetSim with Can Demos - Shell

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/api.rst.txt

Shows the shell commands to run the Network Simulator demo interacting with the Can Reader and Can Writer demos. The setup includes the SIL Kit registry, an optional monitor, the Can Reader, the Can Writer, the System Controller, and the Network Simulator participant using a configuration file.

```shell
# Registry (if not already running):
|Registry|

# Monitor (optional):
|Monitor|

# Can Reader:
|DemoDir|/SilKitDemoCanReader

# Can Writer:
|DemoDir|/SilKitDemoCanWriter

# System Controller:
|SystemController| CanReader CanWriter NetworkSimulator

# Network Simulator Demo:
|DemoDir|/SilKitDemoNetSim ./SilKit-Demos/NetworkSimulator/DemoNetSim.silkit.silkit.yaml NetworkSimulator
```

--------------------------------

### Initializing and Starting Controller - SIL Kit C++

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/api/services/can.rst.txt

This snippet demonstrates the crucial steps required to initialize and activate a CAN controller after it has been created. It involves setting the baud rates for both standard and FD CAN messages using SetBaudRate, followed by explicitly calling the Start method to enable the controller for communication.

```cpp
canController->SetBaudRate(10000, 1000000);
    canController->Start();
```

--------------------------------

### Starting SIL Kit Monitor (PowerShell)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/utilities/utilities.rst.txt

This snippet demonstrates how to launch the SIL Kit Monitor utility from the command line using PowerShell. The Monitor connects to a running SIL Kit Registry and visualizes the state of connected simulation participants, acting as a passive participant.

```powershell
sil-kit-monitor
```

--------------------------------

### Initiating FlexRay Wakeup (C++)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/api/services/flexray.rst.txt

Calls the `Wakeup()` method on the leading cold start FlexRay controller. This command is used by the designated leading cold start node to initiate the FlexRay cluster startup sequence, transitioning its state to `Wakeup`.

```cpp
leadingColdStartNode->Wakeup();
```

--------------------------------

### Running Asynchronous LIN Master/Slave Demos - SIL Kit - Console

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/communication.rst.txt

Shows the sequence of console commands needed to start the Registry and the LIN Master and Slave participants configured for asynchronous and autonomous operation in SIL Kit. This mode allows participants to start and stop independently without a System Controller. Each command should be run in a separate terminal.

```console
# Registry (if not already running):
|Registry|

# Lin Master:
|DemoDir|/SilKitDemoLinMaster --async --autonomous

# Lin Slave:
|DemoDir|/SilKitDemoLinSlave --async --autonomous
```

--------------------------------

### Running Synchronized FlexRay Node Demos - SIL Kit - Console

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/communication.rst.txt

Shows the sequence of console commands needed to start the necessary components (Registry, optional Monitor, FlexRay Node 0, FlexRay Node 1, System Controller) for running the FlexRay communication demos in a coordinated, time-synchronized manner using SIL Kit. Requires the Network Simulator. Each command should be run in a separate terminal.

```console
# Registry (if not already running):
|Registry|

# Monitor (optional):
|Monitor|

# Flexray Node 0:
|DemoDir|/SilKitDemoFlexrayNode0

# Flexray Node 1:
|DemoDir|/SilKitDemoFlexrayNode1

# System Controller:
|SystemController| FlexrayNode0 FlexrayNode1
```

--------------------------------

### Running Asynchronous Ethernet Reader/Writer Demos - SIL Kit - Console

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/communication.rst.txt

Shows the sequence of console commands needed to start the Registry and the Ethernet Reader and Writer participants configured for asynchronous and autonomous operation in SIL Kit. This mode allows participants to start and stop independently without a System Controller. Each command should be run in a separate terminal.

```console
# Registry (if not already running):
|Registry|

# Ethernet Reader:
|DemoDir|/SilKitDemoEthernetReader --async --autonomous

# Ethernet Writer:
|DemoDir|/SilKitDemoEthernetWriter --async --autonomous
```

--------------------------------

### Running Asynchronous CAN Reader/Writer Demos - SIL Kit - Console

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/communication.rst.txt

Shows the sequence of console commands needed to start the Registry and the CAN Reader and Writer participants configured for asynchronous and autonomous operation in SIL Kit. This mode allows participants to start and stop independently without a System Controller. Each command should be run in a separate terminal.

```console
# Registry (if not already running):
|Registry|

# Can Reader:
|DemoDir|/SilKitDemoCanReader --async --autonomous

# Can Writer:
|DemoDir|/SilKitDemoCanWriter --async --autonomous
```

--------------------------------

### Starting Lifecycle With Sync Time (C API)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/CHANGELOG.rst.txt

This is a C API function declaration for starting a participant's lifecycle with time synchronization. It requires the lifecycle service and a lifecycle configuration.

```c
SilKit_LifecycleService_StartLifecycleWithSyncTime(
                        SilKit_LifecycleService* lifecycleService, SilKit_LifecycleConfiguration* startConfiguration);
```

--------------------------------

### Running Synchronized LIN Master/Slave Demos - SIL Kit - Console

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/communication.rst.txt

Shows the sequence of console commands needed to start the necessary components (Registry, optional Monitor, LIN Master, LIN Slave, System Controller) for running the LIN communication demos in a coordinated, time-synchronized manner using SIL Kit. Each command should be run in a separate terminal.

```console
# Registry (if not already running):
|Registry|

# Monitor (optional):
|Monitor|

# Lin Master:
|DemoDir|/SilKitDemoLinMaster

# Lin Slave:
|DemoDir|/SilKitDemoLinSlave

# System Controller:
|SystemController| LinSlave LinMaster
```

--------------------------------

### Running IbSystemController from Command Line (New Format)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/CHANGELOG.rst.txt

This command-line snippet demonstrates the new way to start the IbSystemController. It no longer takes a JSON config file as the first argument but expects the domain ID followed by a list of all expected synchronized participant names as command-line arguments.

```sh
.\IbSystemController.exe 42 CanWriter CanReader
```

--------------------------------

### Configuring SIL Kit Participant Logging via YAML

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/for-developers/developers.rst.txt

This YAML snippet provides a configuration example for a SIL Kit participant. It configures the logging subsystem to direct messages of 'Error' severity or higher to a file named 'silkit.log', with the default console logging set to 'Info' severity.

```yaml
Logging:
  Sinks:
    - Type: File
      Level: Error
      FilePath: ./silkit.log
  Severity: Info
```

--------------------------------

### Starting Lifecycle Old C++ API

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/CHANGELOG.rst.txt

This snippet shows the old C++ API signatures in `ILifecycleService` for starting the participant's lifecycle. Separate methods were used to explicitly choose between no time synchronization (`StartLifecycleNoSyncTime`) and with time synchronization (`StartLifecycleWithSyncTime`).

```c++
virtual auto StartLifecycleNoSyncTime(LifecycleConfiguration startConfiguration) -> std::future<ParticipantState> = 0;
virtual auto StartLifecycleWithSyncTime(LifecycleConfiguration startConfiguration ) -> std::future<ParticipantState> = 0;
```

--------------------------------

### Running Synchronized Ethernet Reader/Writer Demos - SIL Kit - Console

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/communication.rst.txt

Shows the sequence of console commands needed to start the necessary components (Registry, Ethernet Reader, Ethernet Writer, System Controller) for running the Ethernet communication demos in a coordinated, time-synchronized manner using SIL Kit. Each command should be run in a separate terminal.

```console
# Registry (if not already running):
|Registry|

# Ethernet Reader:
|DemoDir|/SilKitDemoEthernetReader

# Ethernet Writer:
|DemoDir|/SilKitDemoEthernetWriter

# System Controller:
|SystemController| EthernetReader EthernetWriter
```

--------------------------------

### Running Synchronized CAN Reader/Writer Demos - SIL Kit - Console

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/communication.rst.txt

Shows the sequence of console commands needed to start the necessary components (Registry, optional Monitor, CAN Reader, CAN Writer, System Controller) for running the CAN communication demos in a coordinated, time-synchronized manner using SIL Kit. Each command should be run in a separate terminal.

```console
# Registry (if not already running):
|Registry|
    
# Monitor (optional):
|Monitor|

# Can Reader:
|DemoDir|/SilKitDemoCanReader

# Can Writer:
|DemoDir|/SilKitDemoCanWriter

# System Controller:
|SystemController| CanReader CanWriter
```

--------------------------------

### Starting Lifecycle New C++ API

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/CHANGELOG.rst.txt

This snippet shows the new C++ API signature in the `ILifecycleService` interfaces for starting the participant's lifecycle. A single `StartLifecycle` method is now used, as the synchronization behavior is determined when the lifecycle service is created.

```c++
virtual auto StartLifecycle(LifecycleConfiguration startConfiguration ) -> std::future<ParticipantState> = 0;
```

--------------------------------

### Configuring CMake to Use SIL Kit C++ Library

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/for-developers/developers.rst.txt

This CMake snippet demonstrates how to locate the installed Vector SIL Kit library using `find_package` and link it to your target executable using `target_link_libraries`. It assumes the SIL Kit library's CMake configuration is available in the system or specified via CMake options.

```cmake
find_package(SilKit CONFIG REQUIRED)
target_link_libraries(${PROJECT_NAME} PRIVATE SilKit::SilKit)
```

--------------------------------

### Initializing Time Synchronization and Starting Lifecycle in C++

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/api/services/lifecycle.rst.txt

Shows how to create the Time Synchronization Service (ITimeSyncService) using the obtained Lifecycle Service instance, and then start the participant's lifecycle. Creating the TimeSyncService is necessary for synchronized simulations. Calling CreateTimeSyncService or StartLifecycle more than once will throw an exception.

```C++
auto* timeSyncService = lifecycleService->CreateTimeSyncService();
(...)
lifecycleService->StartLifecycle();
```

--------------------------------

### Example SIL Kit Participant Configuration with Tracing Enabled (Reader)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/configuration/tracing-configuration.rst.txt

This YAML example shows a complete participant configuration for an EthernetReader, demonstrating how to enable tracing. It defines an Ethernet controller 'Eth1' and assigns a trace sink named 'Sink1' to it using 'UseTraceSinks'. The 'Sink1' is then configured in the 'Tracing' section, specifying it as a 'PcapFile' type with a defined output path for the trace data.

```yaml
Description: Tracing sample configuration for EthernetReader
EthernetControllers:
- Name: Eth1
    UseTraceSinks: [ Sink1 ]
Tracing:
    TraceSinks:
    - Name: Sink1
        Type: PcapFile
        OutputPath: EthernetReader_TraceSinkFile.pcap
```

--------------------------------

### Example SIL Kit Participant Configuration with Replay Enabled (Writer)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/configuration/tracing-configuration.rst.txt

This YAML example shows a full participant configuration for an EthernetWriter with replay enabled. It configures the Ethernet controller 'Eth1' with a 'Replay' section, referencing the trace source 'Source1' and setting the 'Direction' to 'Both'. The 'Source1' is defined in the 'Tracing' section as a 'PcapFile' type pointing to the input trace file.

```yaml
Description: Replay sample configuration for EthernetWriter
EthernetControllers:
- Name: Eth1
    Replay: 
      UseTraceSource: Source1
      Direction: Both
Tracing:
    TraceSources:
    - Name: Source1
      Type: PcapFile
      InputPath: EthernetWriter_ReplaySourceFile.pcap
```

--------------------------------

### Starting Lifecycle No Sync Time (C API)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/CHANGELOG.rst.txt

This is a C API function declaration for starting a participant's lifecycle without time synchronization. It requires the lifecycle service and a lifecycle configuration.

```c
SilKit_ReturnCode SilKit_LifecycleService_StartLifecycleNoSyncTime(
                        SilKit_LifecycleService* lifecycleService, SilKit_LifecycleConfiguration* startconfiguration);
```

--------------------------------

### Sample Network Simulator Configuration Format

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/CHANGELOG.rst.txt

This JSON snippet provides an example of the new configuration file format for the VIBE-NetworkSimulator. It includes a schema version, description, and blocks for defining network Switches and SimulatedNetworks with their respective properties like names, ports, VLAN IDs, and types.

```javascript
{
    "SchemaVersion": "1",
    "Description": "Small sample config with Link names from the VIB Demos",
    "Switches": [
        {
            "Name": "FrontSwitch",
            "Ports": [
                {
                    "Name": "Port0",
                    "VlanIds": [1],
                    "Network": "FS-Port0"
                },
                {
                    "Name": "Port1",
                    "VlanIds": [1],
                    "Network": "FS-Port1"
                }
            ]
        }
    ],
    "SimulatedNetworks": [
        {
            "Name": "CAN1",
            "Type": "CAN"
        },
        {
            "Name": "LIN1",
            "Type": "LIN"
        },
        {
            "Name": "FlexRay1",
            "Type": "FlexRay"
        },
        {
            "Name": "ETH1",
            "Type": "Ethernet"
        },
        {
            "Name": "FS-Port0",
            "Type": "Ethernet"
        },
        {
            "Name": "FS-Port1",
            "Type": "Ethernet"
        }
    ]
}
```

--------------------------------

### Example SIL Kit Participant Configuration with Tracing Enabled (Writer)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/configuration/tracing-configuration.rst.txt

Similar to the Reader example, this YAML snippet provides a complete participant configuration for an EthernetWriter with tracing enabled. It configures an Ethernet controller 'Eth1' to use the trace sink 'Sink1'. The 'Sink1' is defined separately under the 'Tracing' section as a 'PcapFile' with its specific output file path.

```yaml
Description: Tracing sample configuration for EthernetWriter
EthernetControllers:
- Name: Eth1
    UseTraceSinks: [ Sink1 ]
Tracing:
    TraceSinks:
    - Name: Sink1
        Type: PcapFile
        OutputPath: EthernetWriter_TraceSinkFile.pcap
```

--------------------------------

### Running SIL Kit System Controller (C API)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/CHANGELOG.rst.txt

This is a C API function declaration for starting the SIL Kit system controller. It executes the system controller's workflow.

```c
SilKit_ReturnCode SilKit_SystemController_Run(SilKit_SystemController* systemController);
```

--------------------------------

### Running Publisher and Subscriber in C++ Main Function

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/for-developers/developers.rst.txt

This C++ main function expands upon loading the configuration by creating separate threads for the publisher and subscriber logic. It demonstrates how to manage the lifetime of these participant threads and includes basic exception handling for robustness.

```cpp
int main(int argc, char** argv)
{
    try
    {
        auto config = SilKit::Config::ParticipantConfigurationFromFile("simple.yaml");

        std::thread publisherThread(runPublisher, "PublisherParticipant", config);
        std::thread subscriberThread(runSubscriber, "SubscriberParticipant", config);

        publisherThread.join();
        subscriberThread.join();
    }
    catch (const std::exception& e)
    {
        std::cerr << "SIL Kit error: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}
```

--------------------------------

### Launching Latency Demo Pair with Config | Shell

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/tool.rst.txt

These commands launch two instances of the SilKitDemoLatency tool using positional arguments for message count and size, similar to the basic example. Additionally, they both specify a configuration file using '--configuration' to enforce specific network settings, such as disabling domain sockets for the communication between the sender and receiver.

```shell
|DemoDir|/SilKitDemoLatency 100 1000 --configuration .\/SilKit-Demos\/Benchmark\/DemoBenchmarkDomainSocketsOff.silkit.yaml
```

```shell
|DemoDir|/SilKitDemoLatency 100 1000 --isReceiver
```

--------------------------------

### Flexray ControllerConfig C API Old Type Start

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/CHANGELOG.rst.txt

Shows the beginning of the previous definition for the ib_Flexray_ControllerConfig struct in the C-API.

```c
struct ib_Flexray_ControllerConfig
        {
```

--------------------------------

### Completing FlexRay Coldstart for Leading Node (C++)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/api/services/flexray.rst.txt

Demonstrates the conditional logic for the leading cold start node to call `AllowColdstart()` and `Run()`. This action is triggered when the controller's Process Operation Control (POC) state transitions from `Wakeup` back to `Ready` after the wakeup sequence, allowing the cluster operation to begin.

```cpp
if (oldState == FlexrayPocState::Wakeup
    && newState == FlexrayPocState::Ready)
{
    leadingColdStartNode->AllowColdstart();
    leadingColdStartNode->Run();
}
```

--------------------------------

### Accessing Singleton Services Old C++ API

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/CHANGELOG.rst.txt

This snippet shows the old C++ API signatures in `IParticipant` for accessing singleton services like Lifecycle, System Monitor, System Controller, and Logger. The methods used `Get` prefixes.

```c++
virtual auto GetLifecycleService() -> Services::Orchestration::ILifecycleService* = 0;
virtual auto GetSystemMonitor() -> Services::Orchestration::ISystemMonitor* = 0;
virtual auto GetSystemController() -> Services::Orchestration::ISystemController* = 0;
virtual auto GetLogger() -> Services::Logging::ILogger* = 0;
```

--------------------------------

### Adding StartLifecycleWithSyncTime (C++)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/CHANGELOG.rst.txt

This C++ virtual method was added to `ILifecycleService` to start the participant's lifecycle asynchronously with time synchronization via a provided `ITimeSyncService`. It corresponds to the former functionality of `IParticipantController::RunAsync`.

```cpp
virtual auto StartLifecycleWithSyncTime(ITimeSyncService* timeSyncService, bool hasCoordinatedSimulationStart,
                                                  bool hasCoordinatedSimulationStop) -> std::future<ParticipantState> = 0;
```

--------------------------------

### Running SIL Kit CanWriter on Host Linux

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/development/docker/docker.rst.txt

This sequence of commands navigates to the directory containing the SIL Kit executables and configuration, and then launches the `SilKitDemoCan` application as a `CanWriter` participant. It connects to the SIL Kit registry assumed to be running on `localhost:8500`, typically within a Docker container.

```shell
cd silkitfiles-linux
./SilKitDemoCan SilKitConfig_DemoCan.yaml CanWriter silkit://localhost:8500 --async
```

--------------------------------

### Adding StartLifecycleNoSyncTime (C++)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/CHANGELOG.rst.txt

This C++ virtual method was added to `ILifecycleService` to start the participant's lifecycle asynchronously without explicit time synchronization. It replaces part of the functionality of the removed `IParticipantController::RunAsync`.

```cpp
virtual auto StartLifecycleNoSyncTime(bool hasCoordinatedSimulationStart, bool hasCoordinatedSimulationStop)
              -> std::future<ParticipantState> = 0;
```

--------------------------------

### Implementing SIL Kit Data Publisher in C++

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/for-developers/developers.rst.txt

This C++ function `runPublisher` initializes a SIL Kit participant, creates a LifecycleService and TimeSyncService, and sets up a DataPublisher for a specific topic. It defines a simulation step handler that publishes a string message containing the current simulation time at regular intervals.

```cpp
void runPublisher(const std::string& participantName, std::shared_ptr<SilKit::Config::IParticipantConfiguration> config)
{
    auto participant = SilKit::CreateParticipant(config, participantName);
    auto* lifecycleService = participant->CreateLifecycleService();
    auto* timeSyncService = lifecycleService->CreateTimeSyncService();
    auto* pub = participant->CreateDataPublisher(participantName, DataTopic, DataType);

    timeSyncService->SetSimulationStepHandler(
        [&](auto now) {
            std::string data = "Hello from Publisher at " + std::to_string(now.count()) + " ns";
            pub->Publish(SilKit::Util::MakeSpan(data));
        },
        1ms); // Step size

    lifecycleService->StartSimulating();
}
```

--------------------------------

### Publishing Float Data Example in SIL Kit C++

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/api/services/pubsub.rst.txt

Demonstrates creating a data publisher for a specific topic and media type, serializing a float value (representing oil temperature), and publishing the serialized data buffer using the publisher instance. It includes an optional history argument `1`.

```c++
// creation of the data publisher

SilKit::Services::PubSub::PubSubSpec pubSpec{"OilTemperature", SilKit::Util::SerDes::MediaTypeData()};

auto* publisher = participant->CreateDataPublisher("OilTemperatureSensor", pubSpec, 1);

// serialization of data and publishing

float oilTemperature{model.GetOilTemperatureInCelsius()};

SilKit::Util::SerDes::Serializer serializer;
serializer.Serialize(oilTemperature);

publisher->Publish(serializer.ReleaseBuffer());
```

--------------------------------

### Implementing Custom SIL Kit Participant with ApplicationBase

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/communication.rst.txt

C++ template showing how to create a custom SIL Kit participant class by inheriting from `ApplicationBase`. Demonstrates overriding methods like `AddCommandLineArgs`, `EvaluateCommandLineArgs`, `CreateControllers`, `InitControllers`, `DoWorkSync`, and `DoWorkAsync` to handle participant setup, configuration, and execution logic.

```c++
#include "ApplicationBase.hpp"

// Inherit from ApplicationBase that provides common SIL Kit features
class MyDemoParticipant: public ApplicationBase
{
public:
    // Inherit constructors
    using ApplicationBase::ApplicationBase;

private:
    
    // Member variables like SIL Kit controller pointers, Demo state, etc
    std::string _myOption;
    bool _myFlag;

    // The following overrides are invoked in the right order by the ApplicationBase
    // This enables:
    // - General and demo specific command line arguments
    // - Setup of the SIL Kit lifecycle
    // - Controller creation and initialization
    // - SimulationStepHandler vs. thread based execution (--async)
    // - Signal handling to CTRL-C at any time
    // - Basic logging

    // Extend the command line argument list
    void AddCommandLineArgs() override
    {
        GetCommandLineParser()->Add<CommandlineParser::Option>(
            "myOption", "o", "DefaultValue", "-o, --myOption <value>",
            std::vector<std::string>{"Description Line 1.", "Description Line 2"});

        GetCommandLineParser()->Add<CommandlineParser::Flag>(
            "myFlag", "f", "-f, --myFlag",
            std::vector<std::string>{"Description Line 1.", "Description Line 2"});
    }

    // Evaluate the command line argument list
    void EvaluateCommandLineArgs() override
    {
        _myOption = GetCommandLineParser()->Get<CommandlineParser::Option>("myOption").Value();
        _myFlag = GetCommandLineParser()->Get<CommandlineParser::Flag>("myFlag").Value();
    }

    // Create all SIL Kit controllers here
    void CreateControllers() override
    {
        // All SIL Kit features can be accessed via GetParticipant()
        // _myController = GetParticipant()->CreateXYZController(...);
    }

    // Controller initialization goes here
    void InitControllers() override
    {
    }

    // Called in each simulation step when running with time synchronization
    void DoWorkSync(std::chrono::nanoseconds now) override
    {
        // _myController->Send(...)   
    }

    // Called in a worker thread when running without time synchronization
    void DoWorkAsync() override
    {
        // _myController->Send(...)   
    }
};

int main(int argc, char** argv)
{
    Arguments args;
    args.participantName = "MyDemoParticipant"; // Always specify a meaningful default participant name 

    MyDemoParticipant app{args};

    // This will trigger AddCommandLineArgs() and EvaluateCommandLineArgs()
    // Optionally, a set of excluded default command line arguments can be specified
    app.SetupCommandLineArgs(argc, argv, "Description for the command line help");

    // This will trigger CreateControllers(), InitControllers() and then cyclically DoWorkSync() or DoWorkAsync()
    return app.Run();
}
```

--------------------------------

### Loading Participant Configuration from YAML in C++

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/for-developers/developers.rst.txt

This C++ snippet demonstrates how to load a `ParticipantConfiguration` object from an external YAML file using the `ParticipantConfigurationFromFile` function. This configuration is essential for creating a SIL Kit participant and customizing its behavior.

```cpp
int main(int argc, char** argv)
{
    auto config = SilKit::Config::ParticipantConfigurationFromFile("simple.yaml");
    // TODO: Use config to create participants
}
```

--------------------------------

### Defining Docker Services with Docker Compose YAML

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/development/docker/docker.rst.txt

This YAML snippet, included via `literalinclude`, defines the services (`registry`, `canreader`) and network configuration for a SIL Kit development environment using Docker Compose. It specifies the images to use, volume mounts for accessing SIL Kit files, and potentially port mappings. This configuration is used to launch the containers.

```yaml
# Assuming content of samples/docker-compose-linux.yaml based on context:
version: '3.7'

services:
  registry:
    image: silkit/registry:latest # Example image name
    ports:
      - "8500:8500"
    volumes:
      - ./silkitfiles-linux/SilKitRegistry.yaml:/app/SilKitRegistry.yaml # Assuming a config file

  canreader:
    image: silkit/demo:latest # Example image name
    volumes:
      - ./silkitfiles-linux:/app # Mount the directory
    command: ./SilKitDemoCan SilKitConfig_DemoCan.yaml CanReader silkit://registry:8500 --async # Connect to registry service name

volumes:
  silkit-files:
    driver: local
    driver_opts:
      o: bind
      type: none
      device: ./silkitfiles-linux # Bind mount the local directory

```

--------------------------------

### Status Message: Coordinated Participant Not Required (Console)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/troubleshooting/lifecycle.rst.txt

This status message indicates that a simulation participant is configured for coordinated operation mode but has not been included in the list of 'required' participants specified for the simulation start. It suggests a potential mismatch between the participant's configuration and the system controller's setup for a coordinated start.

```Console
This participant is in OperationMode::Coordinated, but is not among the participants that are reported to the system controller as "required".
```

--------------------------------

### Implementing SIL Kit Data Subscriber in C++

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/for-developers/developers.rst.txt

This C++ function `runSubscriber` initializes a SIL Kit participant and creates a DataSubscriber for a specific topic. It registers a data message handler that prints the received data to the console, demonstrating how to process incoming publish/subscribe messages.

```cpp
void runSubscriber(const std::string& participantName, std::shared_ptr<SilKit::Config::IParticipantConfiguration> config)
{
    auto participant = SilKit::CreateParticipant(config, participantName);
    auto* lifecycleService = participant->CreateLifecycleService();
    auto* timeSyncService = lifecycleService->CreateTimeSyncService();
    auto* sub = participant->CreateDataSubscriber(participantName, DataTopic, DataType,
        [&](IDataSubscriber* /*subscriber*/, const IDataMessageEvent& dataMessageEvent) {
            std::string data(dataMessageEvent.data.begin(), dataMessageEvent.data.end());
            std::cout << "Subscriber received data: " << data << std::endl;
        });

    timeSyncService->SetSimulationStepHandler(
        [&](auto now) {
            // No simulation work here, just receive messages
        },
        1ms); // Step size

    lifecycleService->StartSimulating();
}
```

--------------------------------

### Including SIL Kit C++ Headers and Defining Constants

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/for-developers/developers.rst.txt

This C++ code snippet shows the necessary headers for using core SIL Kit functionalities, orchestration, and publish/subscribe services. It also defines common namespaces and constants used for topic names and data types in the subsequent parts of the simple application.

```cpp
#include <silkit/SilKit.hpp>
#include <silkit/services/orchestration/all.hpp>
#include <silkit/services/pubsub/all.hpp>

using namespace SilKit::Config;
using namespace SilKit::Services;
using namespace SilKit::Services::Orchestration;
using namespace SilKit::Services::PubSub;

const std::string DataTopic = "DataService";
const std::string DataType = "application/vnd.vector.testing.data";
```

--------------------------------

### Registry Configuration File Structure (YAML)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/configuration/configuration.rst.txt

This snippet outlines the structure and provides example settings for a SIL Kit Registry configuration file in YAML. It includes `SchemaVersion`, `Description`, the `ListenUri` specifying the address the registry listens on, and a `Logging` section demonstrating how to configure logging sinks (Stdout, File) and levels for the registry.

```yaml
---
SchemaVersion: 1
Description: Sample registry configuration.

ListenUri: silkit://localhost:8500

Logging:
  Sinks:
    - Type: Stdout
      Level: Trace
    - Type: File
      Level: Trace
      LogName: SampleRegistryLogFile
DashboardUri: http://localhost:8082
```

--------------------------------

### Implementing Coordinated RPC Server for Addition (C++)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/api/services/rpc.rst.txt

This comprehensive snippet demonstrates how to create a SIL Kit participant configured for coordinated orchestration, which guarantees the client and server are ready before the call. It includes necessary headers, creates a participant and lifecycle service, defines and registers an `rpcCallHandler` to perform addition upon receiving an RPC call, initializes the `IRpcServer`, and then starts the participant's lifecycle, blocking until the simulation finishes.

```C++
#include <iostream>

#include "silkit/SilKit.hpp"
#include "silkit/services/rpc/all.hpp"
#include "silkit/services/orchestration/all.hpp"
#include "silkit/util/serdes/Serialization.hpp"

using namespace SilKit::Services::Orchestration;
using namespace SilKit::Services::Rpc;

int main(int argc, char** argv)
{
    auto config = SilKit::Config::ParticipantConfigurationFromString("");
    auto participant = SilKit::CreateParticipant(config, "Server", "silkit://localhost:8500");
    auto* lifecycleService = participant->CreateLifecycleService({OperationMode::Coordinated});

    auto rpcCallHandler = [](IRpcServer* server, const RpcCallEvent& event) {
        SilKit::Util::SerDes::Deserializer deserializer{SilKit::Util::ToStdVector(event.argumentData)};
        deserializer.BeginStruct();
        const auto lhs = deserializer.Deserialize<uint32_t>(32);
        const auto rhs = deserializer.Deserialize<uint32_t>(32);
        deserializer.EndStruct();

        SilKit::Util::SerDes::Serializer serializer;
        serializer.Serialize(lhs + rhs, 32);

        std::cout << "Server function 'Add' is called with parameters: " << lhs << ", " << rhs << std::endl;
        server->SubmitResult(event.callHandle, serializer.ReleaseBuffer());
    };

    SilKit::Services::Rpc::RpcSpec rpcSpec{"Add", SilKit::Util::SerDes::MediaTypeRpc()};
    auto* server = participant->CreateRpcServer("AddServer", rpcSpec, rpcCallHandler);
    
    auto finalStateFuture = lifecycleService->StartLifecycle();
    finalStateFuture.get();

    return 0;
}
```

--------------------------------

### Adding Comments in reStructuredText

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/development/rst-help.rst.txt

Illustrates the syntax for adding comments in reStructuredText. Comments start with two dots followed by a space and the comment text, typically indented. These lines will not appear in the generated output documentation.

```reStructuredText
.. This is a comment
```

--------------------------------

### Launching Benchmark Demo with Positional Args and Config | Shell

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/tool.rst.txt

This command launches the SilKitDemoBenchmark tool using positional arguments for core settings (runs, duration, step size, service, participants, message count, message size) and also specifies a configuration file using '--configuration'. The configuration file is used to enforce specific network settings, such as disabling domain sockets.

```shell
|DemoDir|/SilKitDemoBenchmark 4 1 1 ethernet 2 1 10 --configuration .\/SilKit-Demos\/Benchmark\/DemoBenchmarkDomainSocketsOff.silkit.yaml
```

--------------------------------

### Defining Table of Contents Tree in reStructuredText

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/development/rst-help.rst.txt

Explains how to use the `toctree` directive in reStructuredText files (like `index.rst`) to build a table of contents. It shows options like `maxdepth` and how to include document links, specifying custom link names or using file paths. Prerequisites include a Sphinx project setup.

```reStructuredText
.. toctree::
   :maxdepth: 2

   intro
   Specified link name <tutorial>
   development/guidelines
   ...
```

--------------------------------

### Running SIL Kit FlexRay Demo Executables

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/communication.rst.txt

Commands to run the components of the FlexRay demo in separate terminals. Includes the Registry, Network Simulator, optional Monitor, two demo nodes (Node0 and Node1), and the System Controller to manage startup.

```shell
# Registry (if not already running):
|Registry|

# Network Simulator (assumed to be in PATH, necessary):
sil-kit-network-simulator ./SilKit-Demos/FlexRay/NetworkSimulatorConfig.yaml

# Monitor (optional):
|Monitor|

# Node 0:
|DemoDir|/SilKitDemoFlexrayNode0

# Node 1:
|DemoDir|/SilKitDemoFlexrayNode1

# System Controller:
|SystemController| Node0 Node1 NetworkSimulator
```

--------------------------------

### Building Demos from Command Line - Shell

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/build.rst.txt

Provides the standard sequence of command-line commands to configure and build the SIL Kit Demos using CMake. This process typically involves creating a dedicated build directory, changing into that directory, running CMake to configure the project based on the source files, and finally executing the build command to compile the binaries.

```Shell
mkdir build
cd build
cmake ..
cmake --build .
```

--------------------------------

### Running Synchronized SIL Kit Pub/Sub Demo

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/communication.rst.txt

Commands to execute the synchronized version of the Publish/Subscribe demo using the SIL Kit Registry, optional Monitor, the Publisher and Subscriber executables, and the System Controller for coordinated startup.

```shell
# Registry (if not already running):
|Registry|

# Monitor (optional):
|Monitor|

# Publisher:
|DemoDir|/SilKitDemoPublisher 

# Subscriber:
|DemoDir|/SilKitDemoSubscriber

# System Controller:
|SystemController| Publisher Subscriber
```

--------------------------------

### Creating SIL Kit Participant and System Controller - C++

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/api/system-utilities/systemcontroller.rst.txt

This snippet demonstrates the necessary steps to obtain an instance of the System Controller. It first creates a SIL Kit participant using configuration, name, and URI, and then uses this participant instance to create the experimental System Controller. An active participant is a prerequisite for creating the controller.

```cpp
auto participant = SilKit::CreateParticipant(configuration, participantName, connectUri);
systemController = SilKit::Experimental::Participant::CreateSystemController(participant);
```

--------------------------------

### Running Asynchronous SIL Kit Pub/Sub Demo

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/communication.rst.txt

Commands to execute the Publish/Subscribe demo without virtual time synchronization or startup coordination. Involves running the Registry, Publisher, and Subscriber executables independently with the `--async` and `--autonomous` flags.

```shell
# Registry (if not already running):
|Registry|

# Publisher:
|DemoDir|/SilKitDemoPublisher --async --autonomous

# Subscriber:
|DemoDir|/SilKitDemoSubscriber --async --autonomous
```

--------------------------------

### Creating Network Simulator Instance - SIL Kit C++

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/api/netsim.rst.txt

Demonstrates how to obtain an instance of the INetworkSimulator interface using SilKit::Experimental::Participant::CreateNetworkSimulator. This instance serves as the entry point for configuring simulated networks within a participant. It requires a valid participant object pointer and only one instance is permitted per participant.

```C++
INetworkSimulator* networkSimulator = SilKit::Experimental::Participant::CreateNetworkSimulator(participant.get());
```

--------------------------------

### IParticipant Header Changes C++ (Part 4)

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/CHANGELOG.rst.txt

Concludes the diff-like representation of changes in `IParticipant.hpp`, showing the start of the old signature for `CreateDataSubscriber`.

```c++
-    virtual auto CreateDataSubscriber(
```

--------------------------------

### Defining Subsub-heading in reStructuredText

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/development/rst-help.rst.txt

Illustrates the syntax for creating a sub-sub-heading in reStructuredText using tildes (`~`) underlined below the heading text. This represents a lower level of heading hierarchy compared to the main or sub-headings.

```reStructuredText
Sub heading
~~~~~~~~~~~
```

--------------------------------

### Defining Sub-heading in reStructuredText

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/development/rst-help.rst.txt

Shows how to create a sub-heading in reStructuredText using hyphens (`-`) underlined below the heading text. These headings are typically recognized by Sphinx and included in the document's table of contents.

```reStructuredText
This is a header
----------------
```

--------------------------------

### Running Asynchronous Sim Step Handler Demo - Shell

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/api.rst.txt

Provides the shell commands to run the Asynchronous Simulation Step Handler API demo. This configuration involves the SIL Kit registry, two participants ('P1' and 'P2') with asynchronous step handlers, and the system controller for synchronization.

```shell
# Registry (if not already running):
|Registry|
    
# Participant P1:
|DemoDir|/SilKitDemoSimStepAsync P1

# Participant P2:
|DemoDir|/SilKitDemoSimStepAsync P2

# System Controller:
|SystemController| P1 P2
```

--------------------------------

### Running Asynchronous SIL Kit RPC Demo

Source: https://github.com/vectorgrp/sil-kit-docs/blob/main/docs/_sources/demos/communication.rst.txt

Commands to execute the RPC demo without virtual time synchronization or startup coordination. Involves running the Registry, RPC Server, and Client executables independently with the `--async` and `--autonomous` flags.

```shell
# Registry (if not already running):
|Registry|

# Server:
|DemoDir|/SilKitDemoRpcServer --async --autonomous

# Client:
|DemoDir|/SilKitDemoRpcClient --async --autonomous
```