Metadata.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using IDSImaging.Peak.Common.Exceptions;
using IDSImaging.Peak.Common.Types.Geometry;
 
namespace IDSImaging.Peak.Common.Types;
 
 
public abstract class MetadataKey
{
    protected MetadataKey(string name, Type valueType)
    {
        Name = name;
        ValueType = valueType;
    }
 
    public string Name { get; }
 
    public Type ValueType { get; }
}
 
public sealed class MetadataKeyT<T> : MetadataKey
{
    internal MetadataKeyT(string name)
        : base(name, typeof(T))
    {
    }
}
 
 
public static class MetadataKeys
{
 
    public static readonly MetadataKeyT<ulong> DeviceTimestamp = new("DeviceTimestamp");
 
 
    public static readonly MetadataKeyT<ulong> DeviceFrameID = new("DeviceFrameID");
 
 
    public static readonly MetadataKeyT<uint> BinningHorizontal = new("BinningHorizontal");
 
 
    public static readonly MetadataKeyT<uint> BinningVertical = new("BinningVertical");
 
 
    public static readonly MetadataKeyT<RectangleU> Roi = new("Roi");
 
 
    public static readonly MetadataKeyT<double> DeviceExposureTime = new("DeviceExposureTime");
 
 
    public static readonly MetadataKeyT<ulong> SystemTimestamp = new("SystemTimestamp");
 
 
    public static readonly MetadataKeyT<List<double>> DeviceExposureTimeSequence = new("DeviceExposureTimeSequence");
 
 
    public static readonly MetadataKeyT<double> DeviceGain = new("DeviceGain");
 
 
    public static readonly MetadataKeyT<List<double>> DeviceGainSequence = new("DeviceGainSequence");
}
 
 
public sealed class Metadata
{
    private readonly Dictionary<string, object> _data = new();
 
    public object GetValueByKey(MetadataKey key)
    {
        return !_data.TryGetValue(key.Name, out var value)
            ? throw new CommonOutOfRangeException($"There is no value named {key.Name}")
            : value;
    }
 
    public T GetValueByKey<T>(MetadataKeyT<T> key)
    {
        var value = GetValueByKey((MetadataKey) key);
        try
        {
            return (T) value;
        }
        catch (InvalidCastException ex)
        {
            throw new CommonInvalidCastException(
                $"Metadata entry '{key.Name}' is not of type {typeof(T).FullName}", ex);
        }
    }
 
    public object GetValueByName(string name)
    {
        try
        {
            return _data[name];
        }
        catch (KeyNotFoundException ex)
        {
            throw new CommonOutOfRangeException($"There is no value named {name}", ex);
        }
    }
 
    public bool TryGetValueByKey(MetadataKey key, out object? value)
    {
        return _data.TryGetValue(key.Name, out value);
    }
 
    public bool TryGetValueByKey<T>(MetadataKeyT<T> key, out T? value)
    {
        if (_data.TryGetValue(key.Name, out var objValue) && objValue is T typedValue)
        {
            value = typedValue;
            return true;
        }
 
        value = default;
        return false;
    }
 
    public bool TryGetValueByName(string name, out object? value)
    {
        return _data.TryGetValue(name, out value);
    }
 
    public IReadOnlyCollection<string> Keys => _data.Keys;
 
    public void SetValueByKey(MetadataKey key, object value)
    {
        if (_data.ContainsKey(key.Name) && _data[key.Name].Equals(value))
        {
            return;
        }
 
        if (!key.ValueType.IsInstanceOfType(value))
        {
            throw new CommonInvalidCastException(
                $"Value for '{key.Name}' must be assignable to {key.ValueType.FullName} (was {value.GetType().FullName})");
        }
 
        _data[key.Name] = value;
        OnChanged();
    }
 
    public void SetValueByName(string key, object value)
    {
        if (_data.ContainsKey(key) && _data[key].Equals(value))
        {
            return;
        }
 
        _data[key] = value;
        OnChanged();
    }
 
    public bool HasEntryByKey(MetadataKey key)
    {
        return _data.ContainsKey(key.Name);
    }
 
    public bool HasEntryByName(string key)
    {
        return _data.ContainsKey(key);
    }
 
    public override string ToString()
    {
        var result = string.Join(", ", _data.Select(item => $"{item.Key} = {item.Value}"));
        return $"{nameof(Metadata)}{{ {result} }}";
    }
 
    public Metadata Clone()
    {
        var copy = new Metadata();
        foreach (var kvp in Keys)
        {
            copy.SetValueByName(kvp, GetValueByName(kvp));
        }
 
        return copy;
    }
 
    public event EventHandler? Changed;
 
    private void OnChanged()
    {
        Changed?.Invoke(this, EventArgs.Empty);
    }
}