/// <summary>
/// Create a SerializableMember with an explicit type being serialized, name, getter, formatter, ShouldSerialize method, and whether to emit a default value.
/// </summary>
public static SerializableMember Create(
TypeInfo forType,
string name,
Getter getter,
Formatter formatter,
[NullableExposed("ShouldSerialize is truly optional here, it's required and validated elsewhere")]
ShouldSerialize?shouldSerialize,
EmitDefaultValue emitDefault
)
=> CreateInner(forType, name, getter, formatter, shouldSerialize, emitDefault);
protected override void InternalSerializeToXml(XmlProxy xmlRoot)
{
var xmlEmitDefaultValue = xmlRoot.AddChild("emitDefaultValue");
EmitDefaultValue.SerializeToXml(xmlEmitDefaultValue);
//xmlRoot.AddAttribute("emitDefaultValue", EmitDefaultValue);
var xmlIsRequired = xmlRoot.AddChild("isRequired");
IsRequired.SerializeToXml(xmlIsRequired);
//xmlRoot.AddAttribute("isRequired", IsRequired);
var xmlOrder = xmlRoot.AddChild("order");
Order.SerializeToXml(xmlOrder);
//xmlRoot.AddAttribute("order", Order);
}
/// <summary> /// Creates a SerializableMember for the given property, with the given name, formatter, ShouldSerialize method, and whether to emit a default value. /// </summary> public static SerializableMember ForProperty(PropertyInfo property, string name, Formatter formatter, ShouldSerialize shouldSerialize, EmitDefaultValue emitDefault) => CreateInner(property?.DeclaringType?.GetTypeInfo(), name, (Getter?)property?.GetMethod, formatter, shouldSerialize, emitDefault);
internal static SerializableMember CreateInner(TypeInfo?beingSerializedType, string?name, Getter?getter, Formatter?formatter, ShouldSerialize?shouldSerialize, EmitDefaultValue emitDefault)
{
if (beingSerializedType == null)
{
Throw.ArgumentNullException(nameof(beingSerializedType));
}
if (name == null)
{
Throw.ArgumentNullException(nameof(name));
}
if (getter == null)
{
Throw.ArgumentNullException(nameof(getter));
}
if (formatter == null)
{
Throw.ArgumentNullException(nameof(formatter));
}
bool emitDefaultValueBool;
switch (emitDefault)
{
case Cesil.EmitDefaultValue.Yes:
emitDefaultValueBool = true;
break;
case Cesil.EmitDefaultValue.No:
emitDefaultValueBool = false;
break;
default:
Throw.InvalidOperationException($"Unexpected {nameof(Cesil.EmitDefaultValue)}: {emitDefault}");
return(default);
}
var toSerializeType = getter.Returns;
if (!formatter.Takes.IsAssignableFrom(toSerializeType))
{
Throw.ArgumentException($"The first parameter to {nameof(formatter)} must accept a {toSerializeType}", nameof(formatter));
}
CheckShouldSerializeMethod(shouldSerialize, getter.RowType);
return(new SerializableMember(name, getter, formatter, shouldSerialize, emitDefaultValueBool));
}
/// <summary> /// Creates a SerializableMember for the given field, with the given name, formatter, ShouldSerialize method, and whether to emit a default value. /// </summary> public static SerializableMember ForField(FieldInfo field, string name, Formatter formatter, ShouldSerialize shouldSerialize, EmitDefaultValue emitDefault) => CreateInner(field?.DeclaringType?.GetTypeInfo(), name, (Getter?)field, formatter, shouldSerialize, emitDefault);
// internal for testing purposes
internal ManualTypeDescriberBuilder WithSerializableMember(TypeInfo?forType, Getter?getter, string?name, Formatter?formatter, ShouldSerialize?shouldSerialize, EmitDefaultValue emitDefault)
{
if (forType == null)
{
Throw.ArgumentNullException(nameof(forType));
}
if (getter == null)
{
Throw.ArgumentNullException(nameof(getter));
}
if (name == null)
{
Throw.ArgumentNullException(nameof(name));
}
if (formatter == null)
{
Throw.ArgumentNullException(nameof(name));
}
// shouldSerialize can be null
if (getter.RowType.HasValue)
{
var getterOnType = getter.RowType.Value;
var isLegal = false;
TypeInfo?cur = forType;
while (cur != null)
{
if (cur == getterOnType)
{
isLegal = true;
break;
}
cur = cur?.BaseType?.GetTypeInfo();
}
if (!isLegal)
{
Throw.InvalidOperationException($"Provided getter ({getter}) is not on {forType} or one of it's base types.");
}
}
var toAdd = SerializableMember.Create(forType, name, getter, formatter, shouldSerialize, emitDefault);
if (!Serializers.TryGetValue(forType, out var s))
{
Serializers[forType] = s = ImmutableArray.CreateBuilder <SerializableMember>();
}
s.Add(toAdd);
return(this);
}
/// <summary>
/// Add a property to serialize with the given name, formatter, ShouldSerialize method, and whether to emit a default value - for the type which declares the property.
/// </summary>
public ManualTypeDescriberBuilder WithSerializableProperty(PropertyInfo property, string name, Formatter formatter, ShouldSerialize shouldSerialize, EmitDefaultValue emitDefault)
{
Utils.CheckArgumentNull(shouldSerialize, nameof(shouldSerialize));
return(WithSerializableMember(property?.DeclaringType?.GetTypeInfo(), (Getter?)property?.GetMethod, name, formatter, shouldSerialize, emitDefault));
}
/// <summary>
/// Add a field to serialize with the given name, formatter, ShouldSerialize method, and whether to emit a default value - for the type which declares the field.
/// </summary>
public ManualTypeDescriberBuilder WithSerializableField(FieldInfo field, string name, Formatter formatter, ShouldSerialize shouldSerialize, EmitDefaultValue emitDefault)
{
Utils.CheckArgumentNull(shouldSerialize, nameof(shouldSerialize));
return(WithSerializableMember(field?.DeclaringType?.GetTypeInfo(), (Getter?)field, name, formatter, shouldSerialize, emitDefault));
}
/// <summary>
/// Add a getter for the given type, with the given name, using the given getter, formatter, ShouldSerialize method, and whether to emit a default value.
/// </summary>
public ManualTypeDescriberBuilder WithExplicitGetter(TypeInfo forType, string name, Getter getter, Formatter formatter, ShouldSerialize shouldSerialize, EmitDefaultValue emitDefault)
{
Utils.CheckArgumentNull(shouldSerialize, nameof(shouldSerialize));
return(WithSerializableMember(forType, getter, name, formatter, shouldSerialize, emitDefault));
}
