internal static object GetNodeData(Node node, Type type)
{
if (node.Value == Utilities.NullIndicator)
{
return(null);
}
// Ensures that the type's static constructor has been run before we try to load it.
// A convenient place to add base type rules is in the type's static constructor, so
// this ensures the base type rules are registered before they are needed.
System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(type.TypeHandle);
if (type == typeof(string) && node.Value == MultiLineStringNode.Terminator && node.ChildNodeType == NodeChildrenType.multiLineString && node.ChildLines.Count > 0)
{
return(MultiLineStringSpecialCaseHandler.ParseSpecialStringCase(node));
}
if (BaseTypesManager.IsBaseType(type))
{
return(RetrieveDataWithErrorChecking(() => RetrieveBaseTypeNode(node, type)));
}
if (CollectionTypesManager.IsSupportedType(type))
{
return(RetrieveDataWithErrorChecking(() => CollectionTypesManager.RetrieveCollection(node, type)));
}
if (!node.Value.IsNullOrEmpty())
{
return(RetrieveDataWithErrorChecking(() => ComplexTypeShortcuts.GetFromShortcut(node.Value, type)));
}
return(RetrieveDataWithErrorChecking(() => ComplexTypes.RetrieveComplexType(node, type)));
object RetrieveDataWithErrorChecking(Func <object> retrieveDataFunction)
{
try
{
return(retrieveDataFunction.Invoke());
}
catch (CannotRetrieveDataFromNodeException deeperException)
{
// If there's a parsing error deeper in the tree, we want to throw *that* error, so the user gets a line
// number appropriate to the actual error.
throw deeperException;
}
catch
{
throw new CannotRetrieveDataFromNodeException(node, type);
}
}
}
internal static void SetNodeData(Node node, object data, Type type, FileStyle style)
{
if (data == null)
{
node.ClearChildren();
node.Value = Utilities.NullIndicator;
return;
}
else if (node.Value == Utilities.NullIndicator)
{
node.Value = String.Empty;
}
// ensure the type is initialized. This is especially important if it's added as
// a base type in the type's static constructor.
System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(type.TypeHandle);
// If we try to save a single-line string and find it is currently saved as a multi-line string, we do NOT remove the mutli-line formatting.
// The reason for this is that there might be comments on the """s, and we want to preserve those comments.
// Also, this happens in only two cases:
// 1. A string that is usually single-line is manually switched to multi-line formatting by a user
// 2. A string is saved as multi-line, then later saved as single-line
// In case 1, we don't want to piss off the user; keep it how they like it.
// In case 2, the string is probably going to be saved again later with multiple lines. It doesn't seem necessary to disrupt the structure
// of the file for something temporary.
string dataAsString = data as string;
if (type == typeof(string) && (dataAsString.ContainsNewLine() || node.ChildNodes.Count > 0))
{
BaseTypes.SetStringSpecialCase(node, dataAsString, style);
}
else if (BaseTypes.IsBaseType(type))
{
BaseTypes.SetBaseTypeNode(node, data, type, style);
}
else if (CollectionTypes.TrySetCollection(node, data, type, style))
{
return;
}
else
{
ComplexTypes.SetComplexNode(node, data, type, style);
}
}
private static object RetrieveBaseTypeNode(Node node, Type type)
{
// Base types are unique in that they CAN be serialized as a single line, and indeed that is how SUCC will always save them.
// However, you CAN manually write a file that uses complex type rules for a base type, and thanks to the logic in this method,
// it will still work.
// See https://github.com/JimmyCushnie/SUCC/issues/26
if (node.ChildNodeType == NodeChildrenType.key && node.ChildNodes.Count > 0)
{
return(ComplexTypes.RetrieveComplexType(node, type));
}
if (BaseTypesManager.TryParseBaseType(node.Value, type, out var result))
{
return(result);
}
return(ComplexTypeShortcuts.GetFromShortcut(node.Value, type));
}
internal static object GetNodeData(Node node, Type type)
{
if (node.Value == Utilities.NullIndicator)
{
return(null);
}
System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(type.TypeHandle);
try
{
if (type == typeof(string) && node.Value == MultiLineStringNode.Terminator && node.ChildLines.Count > 0)
{
return(BaseTypes.ParseSpecialStringCase(node));
}
if (BaseTypes.IsBaseType(type))
{
return(BaseTypes.ParseBaseType(node.Value, type));
}
var collection = CollectionTypes.TryGetCollection(node, type);
if (collection != null)
{
return(collection);
}
if (!String.IsNullOrEmpty(node.Value))
{
return(ComplexTypeShortcuts.GetFromShortcut(node.Value, type));
}
return(ComplexTypes.RetrieveComplexType(node, type));
}
catch (Exception e)
{
throw new Exception($"Error getting data of type {type} from node: {e.InnerException}");
}
}