OutWit.Engine.Data 1.1.1

OutWit.Engine.Data

Data models, base classes, and utilities for WitEngine controllers and activities.

Overview

This package provides the foundational data structures and base classes for building WitEngine controllers. It includes activity base classes, variable implementations, serialization support, and common utilities.

Installation

dotnet add package OutWit.Engine.Data

Key Components

Activity Base Classes

Activity Adapter Base Classes

Variable Classes

Job Classes

Parameter Types

Status Classes

Processing Classes

Attributes

Usage Examples

Creating a Custom Activity

[Activity("MyActivity")]
[MemoryPackable]
public partial class MyActivity : WitActivityFunction
{
    public IWitParameter? InputValue { get; init; }
    
    public override bool Is(ModelBase modelBase, double tolerance = 1E-07)
    {
        if (modelBase is not MyActivity other)
            return false;
        return base.Is(other, tolerance) 
            && InputValue.Check(other.InputValue);
    }

    protected override MyActivity InnerClone()
    {
        return new MyActivity { InputValue = InputValue?.Clone() as IWitParameter };
    }
}

Creating an Activity Adapter

internal class MyActivityAdapter : WitActivityAdapterFunction<MyActivity>
{
    public MyActivityAdapter(
        IWitControllerManager controllerManager,
        IWitProcessingManager processingManager,
        ILogger logger)
        : base(controllerManager, processingManager, logger)
    {
    }

    protected override async Task<object?> ProcessInner(
        MyActivity activity,
        IWitVariablesCollection pool,
        IWitActivityStatus? activityStatus,
        WitProcessingStatus status)
    {
        if (!pool.TryGetValue(activity.InputValue, out int input))
            throw new InvalidOperationException("Failed to get input");

        return input * 2;
    }

    protected override MyActivity CreateActivity(IWitParameter[] parameters)
    {
        if (parameters.Length != 1)
            throw new ArgumentException("Expected 1 parameter");

        return new MyActivity { InputValue = parameters[0] };
    }
}

Creating a Custom Variable

[Variable("MyType")]
[MemoryPackable]
public partial class MyVariable : WitVariable<MyData>
{
    public MyVariable() : base() { }
    public MyVariable(string name) : base(name) { }
    public MyVariable(string name, MyData value) : base(name, value) { }
}

Registering in a Controller Module

public override void Initialize(IServiceCollection services)
{
    services.AddVariable<MyVariable>();
    services.AddActivityAdapter<MyActivity, MyActivityAdapter>();
}

Serialization

All data types use MemoryPack for high-performance binary serialization. Mark your classes with [MemoryPackable] and make them partial:

[MemoryPackable]
public partial class MyActivity : WitActivityFunction
{
    // ...
}

Project Structure

OutWit.Engine.Data/
  Activities/          - Activity base classes
  ActivityAdapters/    - Adapter base classes
  Variables/           - Variable implementations
  Jobs/                - WitJob implementation
  Constants/           - Literal value types
  References/          - Variable reference types
  Conditions/          - Conditional operators
  Arrays/              - Array parameter type
  Status/              - Processing status classes
  Tasks/               - Processing task implementation
  Processing/          - Processing options
  Attributes/          - Activity/Variable attributes
  Exceptions/          - Engine exceptions
  Serialization/       - MemoryPack registration
  Utils/               - Extension methods and utilities

Dependencies

• OutWit.Engine.Interfaces
• OutWit.Common.Aspects
• OutWit.Common.MemoryPack

License

This software is licensed under the Non-Commercial License (NCL).

• Free for personal, educational, and research purposes
• Commercial use requires a separate license agreement
• Contact licensing@ratner.io for commercial licensing inquiries

See the full LICENSE file for details.