DelegateWriter

DelegateWriter.Func() adapts two argument Func<From, To> to IWriterToRef<From, To>.

IWriterToRef<int, int> writer =
    DelegateWriter.Func(
        (int x) => x * x
    );

DelegateWriter.Action() adapts two argument Action<From, To> to IWriter<From, To>

IWriter<MyClass, string> writer =
    DelegateWriter.Action(
        (MyClass myClass, string value) => myClass.Print(value)
    );

DelegateWriter.Invoke() adapts one argument Action<T>.

IWriter<Avalanche.Void, MyClass> writer =
    DelegateWriter.Invoke(
        (MyClass myClass) => Console.WriteLine(myClass)
    );

DelegateWriter.Reader() adapts delegate to IWriterToRef<From, To>.

IWriterToRef<(string, int), MyClass> writer =
    DelegateWriter.Reader(
        ((string, int) args) => new MyClass(args.Item1, args.Item2)
    );

ref From can be used to adapt to IWriterFromRefToRef<From, To>.

IWriterFromRefToRef<(string, int), MyClass> writer =
    DelegateWriter.Reader(
        (ref (string, int) args) => new MyClass(args.Item1, args.Item2)
    );

IServiceProvider can be used as argument.

IWriterToRef<(string, int), MyClass> writer =
    DelegateWriter.Reader(
        ((string, int) args, IServiceProvider ctx) => new MyClass(args.Item1, args.Item2)
    );

DelegateWriter.Writer() also delegate to IWriter<From, To>, IWriterFromRef<From, To>, IWriterToRef<From, To> and IWriterFromRefToRef<From, To>.

IWriterToRef<(string, int), MyClass> writer =
    DelegateWriter.Writer(
        ((string, int) args, ref MyClass to) => { to = new MyClass(args.Item1, args.Item2); }
    );

The delegate can return bool if writer cannot be applied to arguments.

IWriterToRef<(string, int), MyClass> writer =
    DelegateWriter.Writer(
        ((string, int) args, ref MyClass to) =>
        {
            // Assert not null
            if (args.Item1 == null) return false;
            // Assign value
            to = new MyClass(args.Item1, args.Item2);
            // Ok
            return true;
        }
    );

IWriterFromRefToRef<(string, int), MyClass> writer =
    DelegateWriter.Writer(
        (ref (string, int) args, ref MyClass to) =>
        {
            // Assert not null
            if (args.Item1 == null) return false;
            // Assign value
            to = new MyClass(args.Item1, args.Item2);
            // Ok
            return true;
        }
    );

IServiceProvider can be used in the delegate for acquiring contextual arguments.

IWriterToRef<(string, int), MyClass> writer =
    DelegateWriter.Writer(
        ((string, int) args, ref MyClass to, IServiceProvider context) =>
        {
            // Assert not null
            if (args.Item1 == null) return false;
            // Assign value
            to = new MyClass(args.Item1, args.Item2);
            // Ok
            return true;
        }
    );

DelegateReferer

DelegateWriter.Refer() adapts delegate to IReferer<From, To> when reading from a class.

IReferer<MyClass, string> referer =
    DelegateWriter.Refer(
        (MyClass myClass) => ref myClass.label
    );

DelegateWriter.Refer() adapts delegate to IRefererFromRef<From, To> when reading from a struct.

IRefererFromRef<MyStruct, string> referer =
    DelegateWriter.Refer(
        (ref MyStruct myStruct) => ref myStruct.label
    );

Full Example

Full example

using System;
using Avalanche.Writer;

class delegatewriter
{
    public static void Run()
    {
        {
            // <01>
            IWriterToRef<(string, int), MyClass> writer =
                DelegateWriter.Reader(
                    ((string, int) args) => new MyClass(args.Item1, args.Item2)
                );
            // </01>
        }
        {
            // <01B>
            IWriterFromRefToRef<(string, int), MyClass> writer =
                DelegateWriter.Reader(
                    (ref (string, int) args) => new MyClass(args.Item1, args.Item2)
                );
            // </01B>
        }
        {
            // <01C>
            IWriterToRef<(string, int), MyClass> writer =
                DelegateWriter.Reader(
                    ((string, int) args, IServiceProvider ctx) => new MyClass(args.Item1, args.Item2)
                );
            // </01C>
        }
        {
            // <02>
            IWriterToRef<(string, int), MyClass> writer =
                DelegateWriter.Writer(
                    ((string, int) args, ref MyClass to) => { to = new MyClass(args.Item1, args.Item2); }
                );
            // </02>
        }
        {
            // <03>
            IWriterToRef<(string, int), MyClass> writer =
                DelegateWriter.Writer(
                    ((string, int) args, ref MyClass to) =>
                    {
                        // Assert not null
                        if (args.Item1 == null) return false;
                        // Assign value
                        to = new MyClass(args.Item1, args.Item2);
                        // Ok
                        return true;
                    }
                );
            // </03>
        }
        {
            // <05>
            IWriterFromRefToRef<(string, int), MyClass> writer =
                DelegateWriter.Writer(
                    (ref (string, int) args, ref MyClass to) =>
                    {
                        // Assert not null
                        if (args.Item1 == null) return false;
                        // Assign value
                        to = new MyClass(args.Item1, args.Item2);
                        // Ok
                        return true;
                    }
                );
            // </05>
        }
        {
            // <04>
            IWriterToRef<(string, int), MyClass> writer =
                DelegateWriter.Writer(
                    ((string, int) args, ref MyClass to, IServiceProvider context) =>
                    {
                        // Assert not null
                        if (args.Item1 == null) return false;
                        // Assign value
                        to = new MyClass(args.Item1, args.Item2);
                        // Ok
                        return true;
                    }
                );
            // </04>
        }
        {
            // <10>
            IWriter<Avalanche.Void, MyClass> writer =
                DelegateWriter.Invoke(
                    (MyClass myClass) => Console.WriteLine(myClass)
                );
            // </10>
            MyClass myClass = new MyClass("A", 1);
            writer.Write(default, myClass);
        }
        {
            // <11>
            IWriterToRef<int, int> writer =
                DelegateWriter.Func(
                    (int x) => x * x
                );
            // </11>
        }
        {
            // <12>
            IWriter<MyClass, string> writer =
                DelegateWriter.Action(
                    (MyClass myClass, string value) => myClass.Print(value)
                );
            // </12>
        }
        {
            // <13>
            IReferer<MyClass, string> referer =
                DelegateWriter.Refer(
                    (MyClass myClass) => ref myClass.label
                );
            // </13>
            MyClass myClass = new MyClass("A", 1);
            ref string label = ref referer.GetReference(myClass);

            object box = myClass;
            IReferer<object, string> refererFromObject = (IReferer<object, string>)referer;
            ref string label2 = ref refererFromObject.GetReference(box);
        }
        { 
            // <14>
            IRefererFromRef<MyStruct, string> referer =
                DelegateWriter.Refer(
                    (ref MyStruct myStruct) => ref myStruct.label
                );
            // </14>
            MyStruct myStruct = new MyStruct("A", 1);
            ref string label = ref referer.GetReference(ref myStruct);

            object box = myStruct;
            IReferer<object, string> refererFromObject = (IReferer<object, string>)referer;
            ref string label2 = ref refererFromObject.GetReference(box);
        }
    }

    public record MyClass
    {
        public string label;
        public int id;

        public MyClass(string label, int id) { this.label = label; this.id = id; }

        public void Print(string value) { }
    }
    public record struct MyStruct
    {
        public string label;
        public int id;

        public MyStruct(string label, int id) { this.label = label; this.id = id; }

        public void Print(string value) { }
    }
}