ArchiveExtensions.cs

Go to the documentation of this file.

using System;
using System.Linq;
using IDSImaging.Peak.Common.Exceptions;
 
namespace IDSImaging.Peak.Common.Serialization;
 
 
public static class ArchiveExtensions
{
    public static void SetValue(this IArchive archive, string key, object value)
    {
        if (archive is null)
        {
            throw new CommonInvalidParameterException($"The parameter {nameof(archive) } is null!");
        }
 
        if (value is null)
        {
            throw new CommonInvalidParameterException($"The parameter {nameof(value) } is null!");
        }
 
        switch (value)
        {
            case bool b:
                archive.SetBool(key, b);
                break;
 
            case int i:
                archive.SetInt64(key, i);
                break;
 
            case long l:
                archive.SetInt64(key, l);
                break;
 
            case float f:
                archive.SetDouble(key, f);
                break;
 
            case double d:
                archive.SetDouble(key, d);
                break;
 
            case string s:
                archive.SetString(key, s);
                break;
 
            case IArchive a:
                archive.SetArchive(key, a);
                break;
 
            case bool[] ba:
                archive.SetBoolArray(key, ba);
                break;
 
            case long[] la:
                archive.SetInt64Array(key, la);
                break;
 
            case int[] ia:
                archive.SetInt64Array(key, Array.ConvertAll(ia, x => (long)x));
                break;
 
            case double[] da:
                archive.SetDoubleArray(key, da);
                break;
 
            case float[] fa:
                archive.SetDoubleArray(key, Array.ConvertAll(fa, x => (double)x));
                break;
 
            case string[] sa:
                archive.SetStringArray(key, sa);
                break;
 
            default:
                throw new CommonNotSupportedException(
                    $"Value type '{value.GetType().FullName}' is not supported."
                );
        }
    }
 
    public static T GetValue<T>(this IArchive archive, string key)
    {
        if (archive is null)
        {
            throw new CommonInvalidParameterException($"The parameter {nameof(archive) } is null!");
        }
 
        Type t = typeof(T);
 
        if (t == typeof(bool))
        {
            return (T)(object)archive.GetBool(key);
        }
 
        // TODO: Discuss if we want to allow these (e.g. casting with overflow checks)
        if (t == typeof(int))
        {
            return (T)(object)checked((int)archive.GetInt64(key));
        }
 
        if (t == typeof(long))
        {
            return (T)(object)archive.GetInt64(key);
        }
 
        if (t == typeof(float))
        {
            return (T)(object)checked((float)archive.GetDouble(key));
        }
 
        if (t == typeof(double))
        {
            return (T)(object)archive.GetDouble(key);
        }
 
        if (t == typeof(string))
        {
            return (T)(object)archive.GetString(key);
        }
 
        if (t == typeof(IArchive))
        {
            return (T)(object)archive.GetArchive(key);
        }
 
        if (t == typeof(bool[]))
        {
            return (T)(object)archive.GetBoolArray(key).ToArray();
        }
 
        if (t == typeof(long[]))
        {
            return (T)(object)archive.GetInt64Array(key).ToArray();
        }
 
        if (t == typeof(double[]))
        {
            return (T)(object)archive.GetDoubleArray(key).ToArray();
        }
 
        if (t == typeof(string[]))
        {
            return (T)(object)archive.GetStringArray(key).ToArray();
        }
 
        throw new CommonNotSupportedException(
            $"Type '{t.FullName}' is not supported."
        );
    }
}