IAnyAccessor

IAccessor
└── IAnyAccessor
    └── IAnyAccessor<Container>
        └── IAnyAccessor<Container, Content>

IAnyAccessor describes writers that access a containers that can hold any type.

/// <summary>Any accessor</summary>
public interface IAnyAccessor : IAccessor, IDefaultConstructorAccessor, IConstructorAccessor, IDeconstructorAccessor, IContainerAccessor, IContentAccessor { }

IAnyAccessor<Container> describes accessor for container type Container.

/// <summary>Any accessor of <typeparamref name="Container"/>.</summary>
public interface IAnyAccessor<Container> : IAnyAccessorT, IAccessor<Container>, IDefaultConstructorAccessor<Container>, IConstructorAccessor<Container>, IDeconstructorAccessor<Container>, IContainerAccessor<Container>, IContentAccessor<Container> where Container : notnull { }
/// <summary>Any accessor of <typeparamref name="Container"/>.</summary>
public interface IAnyAccessor<Container, Content> : IAnyAccessor<Container>, IAnyAccessorOf<Content>, IContentAccessor<Container, Content>, IConstructorAccessor<Container, (Content content, object target)>, IDeconstructorAccessor<Container, (Content content, object target)> where Container : notnull { }

IAnyVisitor and IAnyVisitorT are visitor interfaces for IAccessorBase.Accept(IAccessorVisitor).

/// <summary>Base interface for one of visitor</summary>
public interface IAnyVisitor : IAccessorVisitor
{
    /// <summary>Try visit <paramref name="anyAccessor"/>.</summary>
    /// <returns>true to continue visitation</returns>
    bool VisitAnyAccessor(IAnyAccessor anyAccessor);
}

/// <summary>Base interface for one of visitor</summary>
public interface IAnyVisitorT : IAccessorVisitor
{
    /// <summary>Try visit <paramref name="AnyAccessor"/>.</summary>
    /// <returns>true to continue visitation</returns>
    bool VisitAnyAccessor<Container, Content>(IAnyAccessor<Container, Content> anyAccessor) where Container : notnull;
}

AnyAccessor

AccessorBase
└── AnyAccessor
    └── AnyAccessor<Container>
        └── AnyAccessor<Container, Content>

AnyAccessor<Container> is the default implementation.

IAnyAccessor accessor = new AnyAccessor()
{
    DefaultConstructor = null!,
    Constructor = null!,
    Deconstructor = null!,
    IsAssigned = null!,
    Unassign = null!
}.SetReadOnly();

AnyAccessor<Container, Content> is implementation for accessor with specific Content type.

IAnyAccessor<object, object> accessor = new AnyAccessor<object, object>()
{
    DefaultConstructor = null!,
    Constructor = null!,
    Deconstructor = null!,
    IsAssigned = null!,
    Unassign = null!
}.SetReadOnly();

AnyAccessor.Create(containerType) constructs IAnyAccessor<Container> with run-time types. There are extension method a setters for each field.

IAnyAccessor accessor =
    AnyAccessor.Create(typeof(object))
    .SetConstructor(null!)
    .SetDeconstructor(null!)
    .SetDefaultConstructor(null!)
    .SetIsAssigned(null!)
    .SetUnassign(null!)
    .SetReadOnly();

AnyAccessor.Create(containerType, contentType) constructs IAnyAccessor<Container, Content>.

IAnyAccessor accessor =
    AnyAccessor.Create(typeof(object), typeof(object))
    .SetConstructor(null!)
    .SetDeconstructor(null!)
    .SetDefaultConstructor(null!)
    .SetIsAssigned(null!)
    .SetUnassign(null!)
    .SetReadOnly();

Query

AccessorRequest(target) requests for IAccessor depending on type target.

// Create service
IService service = Services.Create(NetAccessorHandlers.Instance);
// Create container target
IContainerTarget target = new NetAny(typeof(object));
// Create request
IRequestFor<IAccessor> request = new AccessorRequest(target);
// Issue request
IAnyAccessor<object> accessor = service.GetRequired<IRequest, IAnyAccessor<object>>(request);

AnyAccessorRequest(target) requests for IAnyAccessor<Any>.

// Create service
IService service = Services.Create(NetAccessorHandlers.Instance);
// Create container target
IContainerTarget target = new NetAny(typeof(object));
// Create request
IRequestFor<IAnyAccessor> request = new AnyAccessorRequest(target);
// Issue request
IAnyAccessor<object> accessor = service.GetRequired<IRequest, IAnyAccessor<object>>(request);

AnyAccessorRequest(target) can also request for IAnyAccessor<Any, Element>.

// Create service
IService service = Services.Create(NetAccessorHandlers.Instance);
// Create container target
IContainerTarget target = new NetAny(typeof(object), typeof(object));
// Create request
IRequestFor<IAnyAccessor> request = new AnyAccessorRequest(target);
// Issue request
IAnyAccessor<object, object> accessor = service.GetRequired<IRequest, IAnyAccessor<object, object>>(request);

AnyAccessorRequest is specifically a request for specific writers. Each can be assigned with explicit customization.

// Create service
IService service = Services.Create(NetAccessorHandlers.Instance);
// Create container target
IContainerTarget target = new NetAny(typeof(object));
// Create request
IRequestFor<IAnyAccessor> request = new AnyAccessorRequest
{
    Constructor = new ConstructorRequest(target),
    Deconstructor = new DeconstructorRequest(target),
    DefaultConstructor = new DefaultConstructorRequest(target),
    Reader = new ReaderRequest(target),
    Writer = new WriterRequest(target),
    Referer = new RefererRequest(target),
    IsAssigned = new IsAssignedRequest(target),
    Unassign = new UnassignRequest(target),
    ContainerType = new ContainerTypeRequest(target),
    ContentType = new ContentTypeRequest(target),
};
// Issue request
IAnyAccessor<object> accessor = service.GetRequired<IRequest, IAnyAccessor<object>>(request);

Usage

.DefaultConstructor creates a any with default value.

object any = accessor.DefaultConstructor.Read();

.Constructor creates an any from tuple of value and binding.

object any = accessor.Constructor.Read(("Hello", null!));

.Deconstructor reads value and binding as an tuple.

object any = "Hello";
(object content, object binding) = accessor.Deconstructor.Read(any);

.Reader reads content value.

object any = "Hello";
object value = accessor.Reader.Read(any);

.Writer writes content.

object any = "Hello";
accessor.Writer.Write(11, ref any);

.IsAssigned tests whether a any is assigned in container.

object any = "Hello";
bool nonNull = accessor.IsAssigned.Read(any);

.Unassign removes any at container.

object any = "Hello";
accessor.Unassign.Write(default, ref any);

Full Example

Full example

using Avalanche.Accessor;
using Avalanche.DataType;
using Avalanche.Service;
using Avalanche.Utilities;
using Avalanche.Writer;
using Microsoft.Extensions.DependencyInjection;

public class anyaccessor
{
    public static void Run()
    {
        {
            // <01>
            IAnyAccessor accessor = new AnyAccessor()
            {
                DefaultConstructor = null!,
                Constructor = null!,
                Deconstructor = null!,
                IsAssigned = null!,
                Unassign = null!
            }.SetReadOnly();
            // </01>
        }
        {
            // <02>
            IAnyAccessor<object, object> accessor = new AnyAccessor<object, object>()
            {
                DefaultConstructor = null!,
                Constructor = null!,
                Deconstructor = null!,
                IsAssigned = null!,
                Unassign = null!
            }.SetReadOnly();
            // </02>
        }
        {
            // <03>
            IAnyAccessor accessor =
                AnyAccessor.Create(typeof(object))
                .SetConstructor(null!)
                .SetDeconstructor(null!)
                .SetDefaultConstructor(null!)
                .SetIsAssigned(null!)
                .SetUnassign(null!)
                .SetReadOnly();
            // </03>
        }
        {
            // <04>
            IAnyAccessor accessor =
                AnyAccessor.Create(typeof(object), typeof(object))
                .SetConstructor(null!)
                .SetDeconstructor(null!)
                .SetDefaultConstructor(null!)
                .SetIsAssigned(null!)
                .SetUnassign(null!)
                .SetReadOnly();
            // </04>
        }
        {
            // <10>
            // Create service
            IService service = Services.Create(NetAccessorHandlers.Instance);
            // Create container target
            IContainerTarget target = new NetAny(typeof(object));
            // Create request
            IRequestFor<IAccessor> request = new AccessorRequest(target);
            // Issue request
            IAnyAccessor<object> accessor = service.GetRequired<IRequest, IAnyAccessor<object>>(request);
            // </10>
        }
        {
            // <11>
            // Create service
            IService service = Services.Create(NetAccessorHandlers.Instance);
            // Create container target
            IContainerTarget target = new NetAny(typeof(object));
            // Create request
            IRequestFor<IAnyAccessor> request = new AnyAccessorRequest(target);
            // Issue request
            IAnyAccessor<object> accessor = service.GetRequired<IRequest, IAnyAccessor<object>>(request);
            // </11>
        }
        {
            // <11B>
            // Create service
            IService service = Services.Create(NetAccessorHandlers.Instance);
            // Create container target
            IContainerTarget target = new NetAny(typeof(object), typeof(object));
            // Create request
            IRequestFor<IAnyAccessor> request = new AnyAccessorRequest(target);
            // Issue request
            IAnyAccessor<object, object> accessor = service.GetRequired<IRequest, IAnyAccessor<object, object>>(request);
            // </11B>
        }
        {
            // <12>
            // Create service
            IService service = Services.Create(NetAccessorHandlers.Instance);
            // Create container target
            IContainerTarget target = new NetAny(typeof(object));
            // Create request
            IRequestFor<IAnyAccessor> request = new AnyAccessorRequest
            {
                Constructor = new ConstructorRequest(target),
                Deconstructor = new DeconstructorRequest(target),
                DefaultConstructor = new DefaultConstructorRequest(target),
                Reader = new ReaderRequest(target),
                Writer = new WriterRequest(target),
                Referer = new RefererRequest(target),
                IsAssigned = new IsAssignedRequest(target),
                Unassign = new UnassignRequest(target),
                ContainerType = new ContainerTypeRequest(target),
                ContentType = new ContentTypeRequest(target),
            };
            // Issue request
            IAnyAccessor<object> accessor = service.GetRequired<IRequest, IAnyAccessor<object>>(request);
            // </12>
        }

        {
            IAnyAccessor<object, object> accessor = Services.Create(NetAccessorHandlers.Instance).GetRequiredService<IAnyAccessor<object, object>>();
            {
                // <51>
                object any = accessor.DefaultConstructor.Read();
                // </51>
            }
            {
                // <52>
                object any = accessor.Constructor.Read(("Hello", null!));
                // </52>
            }
            {
                // <53>
                object any = "Hello";
                (object content, object binding) = accessor.Deconstructor.Read(any);
                // </53>
            }
            {
                // <54>
                object any = "Hello";
                object value = accessor.Reader.Read(any);
                // </54>
            }
            {
                // <55>
                object any = "Hello";
                accessor.Writer.Write(11, ref any);
                // </55>
            }
            {
                // <62>
                object any = "Hello";
                bool nonNull = accessor.IsAssigned.Read(any);
                // </62>
            }
            {
                // <63>
                object any = "Hello";
                accessor.Unassign.Write(default, ref any);
                // </63>
            }
        }
    }
}