public override IEnumerable <string> Serialize(ConfigSerializer serializer, FieldInfo fieldInfo, SerializationInfo serializationInfo, int currentIndentation, int currentObjectDepth,
EFormatOption keyFormatOption, EFormatOption valueFormatOption)
{
return(Enumerable.Repeat("", emptyLinesAbove)
.Concat(comments.Select(comment => new string('\t', currentIndentation + indentation)
+ SpecialCharacters.multiLineComment + " " + comment + " " + SpecialCharacters.multiLineCommentEnd)));
}
private IEnumerable <string> Serialize(SerializationInfo info, int currentIndentation, int currentObjectDepth,
EFormatOption keyFormatOption, EFormatOption valueFormatOption)
{
return(info.eDataType.IsSingleValueType()
? new[] { SerializeSingleValueType(info, valueFormatOption) }
: SerializeMultiValueType(info, currentIndentation, currentObjectDepth, keyFormatOption, valueFormatOption));
}
private IEnumerable <string> SerializeNonGenericClass(SerializationInfo serializationInfo, int currentIndentation, int currentObjectDepth,
EFormatOption keyFormatOption, EFormatOption valueFormatOption)
{
List <ConfigTypeInfo> typeFieldInfo;
if (!typeCache.ContainsKey(serializationInfo.dataType))
{
typeFieldInfo = ConfigTypeInfo.GatherTypeInfo(serializationInfo.dataType, options).ToList();
typeCache[serializationInfo.dataType] = typeFieldInfo;
}
else
{
typeFieldInfo = typeCache[serializationInfo.dataType];
}
List <string> result = new List <string>();
foreach (IEnumerable <string> serializeResult in
from configInfo in typeFieldInfo
let fieldValue = configInfo.fieldInfo.GetValue(serializationInfo.dataInstance)
let fieldType = configInfo.fieldInfo.FieldType
let info = new SerializationInfo(fieldValue, fieldType, EDataTypes_Extensions.GetDataType(fieldType))
select configInfo.fieldSerializer.Serialize(this, configInfo.fieldInfo, info, currentIndentation, currentObjectDepth, keyFormatOption, valueFormatOption))
{
result.AddRange(serializeResult);
}
return(result);
}
private IEnumerable <string> SerializeListValue(SerializationInfo info, int currentIndentation, int currentObjectDepth,
EFormatOption keyFormatOption, EFormatOption valueFormatOption)
{
return(info.eDataType.IsSingleValueType()
? new[] { new string('\t', currentIndentation) + new string(SpecialCharacters.objectDepth, currentObjectDepth) + " " + SerializeSingleValueType(info, valueFormatOption) }
: new[] { new string('\t', currentIndentation) + new string(SpecialCharacters.objectDepth, currentObjectDepth) + " " + SpecialCharacters.objectAssignment }
.Concat(SerializeMultiValueType(info, currentIndentation, currentObjectDepth + 1, keyFormatOption, valueFormatOption)));
}
internal IEnumerable <string> SerializeMultiValueType(SerializationInfo serializationInfo, int currentIndentation, int currentObjectDepth,
EFormatOption keyFormatOption, EFormatOption valueFormatOption)
{
if (serializationInfo.dataInstance == null)
{
return(new string[] { });
}
if (!serializationInfo.eDataType.IsMultiValueType())
{
throw new ArgumentOutOfRangeException("eDataType: " + serializationInfo.eDataType + " is not a multi-value Type!");
}
switch (serializationInfo.eDataType)
{
case EDataType.GenericList: {
IList list = (IList)serializationInfo.dataInstance;
Type valueType = serializationInfo.dataType.GetGenericArguments()[0];
EDataType valueEDataType = EDataTypes_Extensions.GetDataType(valueType);
return((
from object value in list
select new SerializationInfo(value, valueType, valueEDataType)
into valueSerializationInfo
select SerializeListValue(valueSerializationInfo, currentIndentation, currentObjectDepth, keyFormatOption, valueFormatOption)
).SelectMany(sList => sList));
}
case EDataType.GenericDictionary: {
IDictionary dictionary = (IDictionary)serializationInfo.dataInstance;
Type keyType = serializationInfo.dataType.GetGenericArguments()[0];
EDataType eKeyType = EDataTypes_Extensions.GetDataType(keyType);
Type valueType = serializationInfo.dataType.GetGenericArguments()[1];
EDataType eValueType = EDataTypes_Extensions.GetDataType(valueType);
if (!eKeyType.IsSingleValueType())
{
throw new InvalidDataException("Key of Config Dictionary must be Single-Value Type!");
}
List <string> result = new List <string>();
foreach (DictionaryEntry entry in dictionary)
{
SerializationInfo keyInfo = new SerializationInfo(entry.Key, keyType, eKeyType);
SerializationInfo valueInfo = new SerializationInfo(entry.Value, valueType, eValueType);
result.AddRange(SerializeDictionaryEntry(keyInfo, valueInfo, currentIndentation, currentObjectDepth, keyFormatOption, valueFormatOption));
}
return(result);
}
case EDataType.NonGenericClass:
return(SerializeNonGenericClass(serializationInfo, currentIndentation, currentObjectDepth, keyFormatOption, valueFormatOption));
case EDataType.TypeConvertibleClass:
case EDataType.Enum:
case EDataType.Primitive:
case EDataType.String:
default:
throw new ArgumentOutOfRangeException();
}
}
public ConfigValueAttribute([CallerLineNumber] int order = 0,
string name = null, int indentation = 0, int emptyLinesAbove = 0,
EFormatOption keyFormatOption = EFormatOption.UseDefault, EFormatOption valueFormatOption = EFormatOption.UseDefault,
params string[] comments) : base(order)
{
this.name = name;
this.indentation = indentation;
this.emptyLinesAbove = emptyLinesAbove;
_keyFormatOption = keyFormatOption;
_valueFormatOption = valueFormatOption;
this.comments = comments ?? new string[] { };
}
public IEnumerable <string> Serialize(ConfigSerializer serializer, FieldInfo fieldInfo, SerializationInfo serializationInfo, int currentIndentation, int currentObjectDepth,
EFormatOption keyFormatOption, EFormatOption valueFormatOption)
{
if (serializationInfo.eDataType.IsSingleValueType())
{
string assignmentString = ConfigSerializer.SerializeValueAssignmentDeclaration(fieldInfo.Name, currentIndentation, currentObjectDepth, keyFormatOption);
string dataString = ConfigSerializer.SerializeSingleValueType(serializationInfo, valueFormatOption);
return(new[] { assignmentString + dataString });
}
string declarationString = ConfigSerializer.SerializeObjectAssignmentDeclaration(fieldInfo.Name, currentIndentation, currentObjectDepth, keyFormatOption);
return(new[] { declarationString }
.Concat(serializer.SerializeMultiValueType(serializationInfo, currentIndentation, currentObjectDepth + 1, keyFormatOption, valueFormatOption)));
}
private IEnumerable <string> SerializeDictionaryEntry(SerializationInfo keyInfo, SerializationInfo valueInfo, int currentIndentation, int currentObjectDepth,
EFormatOption keyFormatOption, EFormatOption valueFormatOption)
{
string keyString = new string('\t', currentIndentation) + new string(SpecialCharacters.objectDepth, currentObjectDepth) + " " + SerializeSingleValueType(keyInfo, keyFormatOption);
if (valueInfo.eDataType.IsSingleValueType())
{
// can write entries as single line
return(new[] { keyString + $" {SpecialCharacters.valueAssignment} " + SerializeSingleValueType(valueInfo, valueFormatOption) });
}
// need to write entries as declaration : \n value
return(new[] { keyString + " " + SpecialCharacters.objectAssignment }
.Concat(SerializeMultiValueType(valueInfo, currentIndentation, currentObjectDepth + 1, keyFormatOption, valueFormatOption)));
}
public override IEnumerable <string> Serialize(ConfigSerializer serializer, FieldInfo fieldInfo, SerializationInfo serializationInfo, int currentIndentation, int currentObjectDepth,
EFormatOption keyFormatOption, EFormatOption valueFormatOption)
{
IEnumerable <string> dataLines;
keyFormatOption = GetKeyFormatOption(keyFormatOption);
valueFormatOption = GetValueFormatOption(valueFormatOption);
if (serializationInfo.eDataType.IsSingleValueType())
{
string declarationString = ConfigSerializer.SerializeValueAssignmentDeclaration(name ?? fieldInfo.Name, currentIndentation + indentation, currentObjectDepth, keyFormatOption);
string dataString = ConfigSerializer.SerializeSingleValueType(serializationInfo, valueFormatOption);
dataLines = new[] { declarationString + dataString };
}
else
{
string declarationString = ConfigSerializer.SerializeObjectAssignmentDeclaration(name ?? fieldInfo.Name, currentIndentation + indentation, currentObjectDepth, keyFormatOption);
dataLines = new[] { declarationString }
.Concat(serializer.SerializeMultiValueType(serializationInfo, currentIndentation + indentation, currentObjectDepth + 1, keyFormatOption, valueFormatOption));
}
return(Enumerable.Repeat("", emptyLinesAbove)
.Concat(comments.Select(comment => new string('\t', currentIndentation + indentation) + SpecialCharacters.singleLineComment + " " + comment))
.Concat(dataLines));
}
public abstract IEnumerable <string> Serialize(ConfigSerializer serializer, FieldInfo fieldInfo, SerializationInfo serializationInfo, int currentIndentation, int currentObjectDepth,
EFormatOption keyFormatOption, EFormatOption valueFormatOption);
private EFormatOption GetValueFormatOption(EFormatOption fallback)
{
return(_valueFormatOption == EFormatOption.UseDefault ? fallback : _valueFormatOption);
}
private EFormatOption GetKeyFormatOption(EFormatOption fallback)
{
return(_keyFormatOption == EFormatOption.UseDefault ? fallback : _keyFormatOption);
}
public static string FormatStringValue([CanBeNull] string value, EFormatOption option)
{
if (value == null)
{
return("~");
}
bool containsWhiteSpace = ContainsWhiteSpace(value);
bool containsSpecialChar = ContainsSpecialChar(value);
if (option != EFormatOption.AlwaysQuote && !containsWhiteSpace && !containsSpecialChar)
{
return(value);
}
switch (option)
{
case EFormatOption.Escape:
value = value.EscapeCharacter(escapeChar.ToString());
if (containsWhiteSpace)
{
char[] whiteSpaceEscapedChars = value.ToCharArray().SelectMany(c => char.IsWhiteSpace(c) ? new[] { escapeChar, c } : new[] { c }).ToArray();
value = new string(whiteSpaceEscapedChars);
}
if (containsSpecialChar)
{
value = value.EscapeCharacter(objectDepth.ToString())
.EscapeCharacter(valueAssignment.ToString())
.EscapeCharacter(objectAssignment.ToString())
.EscapeCharacter(nullChar.ToString())
.EscapeCharacter(stringChar.ToString())
.EscapeCharacter(singleLineComment)
.EscapeCharacter(multiLineComment);
}
return(value);
case EFormatOption.QuoteCharacter:
value = value.EscapeCharacter(escapeChar.ToString())
.EscapeCharacter(stringChar.ToString());
if (containsWhiteSpace)
{
char[] whiteSpaceQuotedChars = value.ToCharArray().SelectMany(c => char.IsWhiteSpace(c) ? new[] { stringChar, c, stringChar } : new[] { c }).ToArray();
value = new string(whiteSpaceQuotedChars);
}
if (containsSpecialChar)
{
value = value.QuoteCharacter(objectDepth.ToString())
.QuoteCharacter(valueAssignment.ToString())
.QuoteCharacter(objectAssignment.ToString())
.QuoteCharacter(nullChar.ToString())
.QuoteCharacter(singleLineComment)
.QuoteCharacter(multiLineComment);
}
return(value);
case EFormatOption.AlwaysQuote:
case EFormatOption.UseDefault:
case EFormatOption.QuoteValue:
return(stringChar
+ value.EscapeCharacter(escapeChar.ToString())
.EscapeCharacter(stringChar.ToString())
+ stringChar);
default:
throw new ArgumentOutOfRangeException(nameof(option), option, null);
}
}
internal static string SerializeValueAssignmentDeclaration(string keyString, int indentation, int objectDepth, EFormatOption keyFormatOption)
{
return(new string('\t', indentation)
+ new string(SpecialCharacters.objectDepth, objectDepth) + " "
+ SpecialCharacters.FormatStringValue(keyString, keyFormatOption)
+ $" {SpecialCharacters.valueAssignment} ");
}
internal static string SerializeSingleValueType(SerializationInfo serializationInfo, EFormatOption valueFormatOption)
{
if (serializationInfo.dataInstance == null)
{
return(SpecialCharacters.FormatStringValue(null, valueFormatOption));
}
if (!serializationInfo.eDataType.IsSingleValueType())
{
throw new ArgumentOutOfRangeException("eDataType: " + serializationInfo.eDataType + " is not a single-value Type!");
}
string result = TypeDescriptor.GetConverter(serializationInfo.dataType).ConvertToInvariantString(serializationInfo.dataInstance);
return(SpecialCharacters.FormatStringValue(result, valueFormatOption));
}
private IEnumerable <string> Serialize(object data, int currentIndentation, int currentObjectDepth, EFormatOption keyFormatOption, EFormatOption valueFormatOption)
{
if (data == null)
{
return(new string[] { });
}
Type dataType = data.GetType();
EDataType eDataType = EDataTypes_Extensions.GetDataType(dataType);
SerializationInfo serializationInfo = new SerializationInfo(data, dataType, eDataType);
return(Serialize(serializationInfo, currentIndentation, currentObjectDepth, keyFormatOption, valueFormatOption));
}
