private static ImmutableArray <(string Name, TypeInfo Type)> GetRequiredColumns()
{
var recordType = typeof(TRecord).GetTypeInfo();
var(cons, _, _) = recordType.ReadRecordType();
return(ImmutableArray.CreateRange(cons.GetParameters().Select(p => (Utils.NonNull(p.Name), p.ParameterType.GetTypeInfo()))));
}
/// <summary>
/// Enumerate members which will be serialized for the given type.
///
/// Note that these members are generated ahead of time with a source gneerator,
/// and cannot be changed at runtime.
/// </summary>
public IEnumerable <SerializableMember> EnumerateMembersToSerialize(TypeInfo forType)
{
var paired = GetPairedType(forType, SERIALIZER_KIND);
if (paired == null)
{
return(Enumerable.Empty <SerializableMember>());
}
var colNamesField = paired.GetFieldNonNull("ColumnNames", PublicStatic);
var colNames = (ImmutableArray <string>)colNamesField.GetValueNonNull(null);
var ret = ImmutableArray.CreateBuilder <SerializableMember>(colNames.Length);
for (var i = 0; i < colNames.Length; i++)
{
var name = colNames[i];
var colWriterName = $"__Column_{i}";
var colWriterMtd = paired.GetMethodNonNull(colWriterName, PublicStatic);
#pragma warning disable CS0618 // This is obsolete to prevent clients from using them, but they are fine for us.
var emitsDefaultValue = colWriterMtd.GetCustomAttribute <DoesNotEmitDefaultValueAttribute>() == null;
#pragma warning restore CS0618
var shouldSerializeName = $"__Column_{i}_ShouldSerialize";
var shouldSerializeMtd = paired.GetMethod(shouldSerializeName, PublicStatic);
var shouldSerialize = (ShouldSerialize?)shouldSerializeMtd;
var getterName = $"__Column_{i}_Getter";
var getterMtd = paired.GetMethodNonNull(getterName, PublicStatic);
var getter = Getter.ForMethod(getterMtd);
var formatterName = $"__Column_{i}_Formatter";
var formatterMtd = paired.GetMethod(formatterName, PublicStatic);
Formatter formatter;
if (formatterMtd == null)
{
// if a method isn't provided, it must be using the default
formatter = Utils.NonNull(Formatter.GetDefault(getter.Returns));
}
else
{
formatter = Formatter.ForMethod(formatterMtd);
}
ret.Add(SerializableMember.ForGeneratedMethod(name, colWriterMtd, getter, formatter, shouldSerialize, emitsDefaultValue));
}
return(ret.ToImmutable());
}
internal DynamicRowEnumerableNonGeneric(object row)
{
if (row is DynamicRow dynRow)
{
Row = dynRow;
DependsOn = dynRow;
Offset = Length = null;
}
else
{
var dynRowRange = Utils.NonNull(row as DynamicRowRange);
Row = dynRowRange.Parent;
DependsOn = dynRowRange;
Offset = dynRowRange.Offset;
Length = dynRowRange.Length;
}
}
internal Options(OptionsBuilder copy)
{
ValueSeparator = copy.ValueSeparator;
EscapedValueStartAndEnd = copy.EscapedValueStartAndEnd;
EscapedValueEscapeCharacter = copy.EscapedValueEscapeCharacter;
ReadRowEnding = copy.ReadRowEnding;
WriteRowEnding = copy.WriteRowEnding;
ReadHeader = copy.ReadHeader;
WriteHeader = copy.WriteHeader;
TypeDescriber = Utils.NonNull(copy.TypeDescriber);
WriteTrailingRowEnding = copy.WriteTrailingRowEnding;
MemoryPoolProvider = Utils.NonNull(copy.MemoryPoolProvider);
CommentCharacter = copy.CommentCharacter;
WriteBufferSizeHint = copy.WriteBufferSizeHint;
ReadBufferSizeHint = copy.ReadBufferSizeHint;
DynamicRowDisposal = copy.DynamicRowDisposal;
WhitespaceTreatment = copy.WhitespaceTreatment;
ExtraColumnTreatment = copy.ExtraColumnTreatment;
}
internal PassthroughRowEnumerable(object row)
{
if (row is DynamicRow dynRow)
{
Row = dynRow;
DependsOn = dynRow;
Offset = Length = null;
}
else
{
var dynRowRange = Utils.NonNull(row as DynamicRowRange);
Row = dynRowRange.Parent;
DependsOn = dynRowRange;
Offset = dynRowRange.Offset;
Length = dynRowRange.Length;
}
Generation = Row.Generation;
}
private static ulong[] CreateValues()
{
var enumType = typeof(T).GetTypeInfo();
if (enumType.IsFlagsEnum())
{
// only need the actual values if we're in Flags mode
var values = Enum.GetValues(enumType);
var ret = new ulong[values.Length];
for (var i = 0; i < values.Length; i++)
{
var obj = values.GetValue(i);
var asT = (T)Utils.NonNull(obj);
ret[i] = Utils.EnumToULong(asT);
}
return(ret);
}
return(Array.Empty <ulong>());
}
private static ulong[] CreateULongValues()
{
var enumType = typeof(T).GetTypeInfo();
// note that this is different from CreateValues()
// which means these don't match like they do in formatting
if (!enumType.IsFlagsEnum())
{
// only need ULongValues for [Flags] enums
return(Array.Empty <ulong>());
}
var values = Enum.GetValues(enumType);
var ret = new ulong[values.Length];
for (var i = 0; i < values.Length; i++)
{
var obj = values.GetValue(i);
obj = Utils.NonNull(obj);
ret[i] = Utils.EnumToULong((T)obj);
}
return(ret);
}
private static ImmutableArray <(string Name, TypeInfo Type, Delegate Setter)> GetOptionalColumns()
{
var recordType = typeof(TRecord).GetTypeInfo();
var(_, propsSetByCons, _) = recordType.ReadRecordType();
var propsWithSetters = recordType.GetProperties().Where(p => p.SetMethod != null).Except(propsSetByCons);
var ret = ImmutableArray.CreateBuilder <(string Name, TypeInfo Type, Delegate Setter)>();
foreach (var prop in propsWithSetters)
{
var name = prop.Name;
var type = prop.PropertyType.GetTypeInfo();
var setMtd = Utils.NonNull(prop.SetMethod);
var delType = Types.Action2.MakeGenericType(typeof(TRecord), type);
var del = Delegate.CreateDelegate(delType, setMtd);
ret.Add((name, type, del));
}
return(ret.ToImmutable());
}
/// <summary>
/// Enumerate members which will be deserialized for the given type.
///
/// Note that these members are generated ahead of time with a source gneerator,
/// and cannot be changed at runtime.
/// </summary>
public IEnumerable <DeserializableMember> EnumerateMembersToDeserialize(TypeInfo forType)
{
var paired = GetPairedType(forType, DESERIALIZER_KIND);
if (paired == null)
{
return(Enumerable.Empty <DeserializableMember>());
}
var colNamesProp = paired.GetPropertyNonNull("__ColumnNames", PublicStatic);
var colNames = (ImmutableArray <string>)colNamesProp.GetValueNonNull(null);
var ret = ImmutableArray.CreateBuilder <DeserializableMember>(colNames.Length);
ParameterInfo[]? consPs = null;
for (var i = 0; i < colNames.Length; i++)
{
var name = colNames[i];
var colReaderName = $"__Column_{i}";
var colReaderMtd = paired.GetMethodNonNull(colReaderName, PublicInstance);
#pragma warning disable CS0618 // These are obsolete to prevent clients from using them, but they are fine for us.
var isRequired = colReaderMtd.GetCustomAttribute <IsRequiredAttribute>() != null;
var setterBackedByParameter = colReaderMtd.GetCustomAttribute <SetterBackedByConstructorParameterAttribute>();
var setterIsInitOnly = colReaderMtd.GetCustomAttribute <SetterBackedByInitOnlyPropertyAttribute>();
#pragma warning restore CS0618
Setter setter;
if (setterBackedByParameter == null && setterIsInitOnly == null)
{
// directly a method
var setterName = $"__Column_{i}_Setter";
var setterMtd = paired.GetMethodNonNull(setterName, PublicStatic);
setter = Setter.ForMethod(setterMtd);
}
else if (setterBackedByParameter != null)
{
// parameter to constructor
if (consPs == null)
{
var ip = GetInstanceProvider(forType);
ip = Utils.NonNull(ip);
var cons = ip.Constructor.Value;
consPs = cons.GetParameters();
}
var consParameterIndex = setterBackedByParameter.Index;
if (consParameterIndex < 0 || consParameterIndex >= consPs.Length)
{
Throw.ImpossibleException($"Setter for column {i} claims to be backed by constructor parameter, but its position is out of bounds (index={consParameterIndex})");
}
var p = consPs[setterBackedByParameter.Index];
setter = Setter.ForConstructorParameter(p);
}
else
{
// init only property
var initOnly = Utils.NonNull(setterIsInitOnly);
var prop = forType.GetProperty(initOnly.PropertyName, initOnly.BindingFlags);
if (prop == null)
{
Throw.ImpossibleException($"Setter for column {i} claims to be backed by init-only property {initOnly.PropertyName} with bindings ({initOnly.BindingFlags}), but it could not be found");
}
setter = Setter.ForProperty(prop);
}
var resetMethodName = $"__Column_{i}_Reset";
var resetMtd = paired.GetMethod(resetMethodName, PublicStatic);
var reset = (Reset?)resetMtd;
var parserMethodName = $"__Column_{i}_Parser";
var parserMtd = paired.GetMethod(parserMethodName, PublicStatic);
Parser?parser;
if (parserMtd != null)
{
parser = Parser.ForMethod(parserMtd);
}
else
{
parser = Utils.NonNull(Parser.GetDefault(setter.Takes));
}
ret.Add(DeserializableMember.CreateInner(forType, name, setter, parser, isRequired ? MemberRequired.Yes : MemberRequired.No, reset, paired));
}
return(ret.ToImmutable());
}
