/// <summary>Creates new instance of the X2O config, adding the default elements processors and type resolvers</summary>
public static X2OConfig DefaultConfig()
{
var cfg = new X2OConfig(GetDefaultElementsProcessors());
cfg.m_TypeResolvers.AddRange(cfg.GetDefaultTypeResolvers());
return(cfg);
}
/// <summary>
/// Will read the XML file and returns instance of the read object completely initialized with values from XML file.
/// The Type generic argument is used as the declared type of the root node.
/// </summary>
/// <param name="_filename">The filename of the XML file to read into the object</param>
/// <returns>The instance of the object according to the type read from XML file</returns>
public static T ReadFromFile <T>(string _filename)
{
var cfg = X2OConfig.DefaultConfig().UsingExternalConfigSearchPath(new System.IO.FileInfo(_filename).DirectoryName);
var result = ReadFromFile <T>(_filename, cfg);
return((T)result);
}
/// <summary>Creates new instance of the X2O config, with adding the default type resolvers</summary>
public static X2OConfig WithDefaultTypeResolvers()
{
var cfg = new X2OConfig(null);
cfg.m_TypeResolvers.AddRange(cfg.GetDefaultTypeResolvers());
return(cfg);
}
/// <summary>
/// Will analyse the passed element (which is root) and returns the type which can be used as _declared_type
/// when calling the ProcessElements function for the root node of Xml.
/// </summary>
public virtual Type GetTypeOfRoot(XmlElement _element, X2OConfig _config)
{
var type_attr = _element.Attributes["type"];
Type tgt_type = null;
if (type_attr != null)
{
tgt_type = GetTypeByName(type_attr.Value, _config);
}
if (tgt_type == null)
{
tgt_type = GetTypeByName(_element.Name, _config);
}
return tgt_type;
}
/// <summary>
/// This function based on the name of type returns the type.
/// This helps to consider the type even with type shortcuts (e.g. not using namespaces and so on).
/// It goes through the full list of types in all loaded assemblies and tries to find the best match - only single is allowed.
/// </summary>
/// <exception cref="InvalidOperationException">In case, there is more than one suitable type.</exception>
public virtual Type GetTypeByName(string _type_name, X2OConfig _config)
{
// first try by type attribute
var tgt_types = from a in AppDomain.CurrentDomain.GetAssemblies()
from t in a.GetTypes()
where t.FullName == _type_name || t.Name == _type_name || t.AssemblyQualifiedName == _type_name
select t;
if (tgt_types.Count() == 1)
return tgt_types.First();
if (tgt_types.Count() > 1)
throw new InvalidOperationException($"Multiple types has been found for resolving the type name \"{_type_name}\"");
// no type found, so look within type resolvers
foreach(var type_resolver in _config.TypeResolvers)
{
var resolved_type = type_resolver(_type_name);
if (resolved_type != null)
return resolved_type;
}
// no type found
return null;
}
/// <summary>
/// Will process elements under the _parent element by finding the best suitable
/// elements processor (the one which returns non-null value)
/// </summary>
/// <returns>
/// The object which has evolved as the result of elements processor run,
/// or null, if the current element with its child nodes could not be read by any elements processor.
/// </returns>
public virtual object ProcessElements(XmlElement _parent_element, Type _declared_type, X2OConfig _config)
{
Type tgt_type = _declared_type;
// consider target type
// firstly we will look for the type atribute
var type_attr = _parent_element.Attributes["type"];
if (type_attr != null)
{
tgt_type = GetTypeByName(type_attr.Value, _config);
if (tgt_type == null)
throw new ArgumentException($"Type name specified in type attribute ({type_attr.Value}) couldn't been resolved.");
if (!_declared_type.IsAssignableFrom(tgt_type))
throw new ArgumentException($"Type name specified in type attribute ({type_attr.Value}, resolved as {tgt_type.FullName}) cannot be converted into declared type ({_declared_type.FullName}).");
}
foreach(var processor in ElementsProcessors.Reverse())
{
var result = processor.ProcessElements(_parent_element, tgt_type, _config);
if (result != null)
return result;
}
return null;
}
/// <summary>Creates new instance of the X2O config with adding the default elements processors</summary>
public static X2OConfig WithDefaultElementsProcessors()
{
var cfg = new X2OConfig(GetDefaultElementsProcessors());
return(cfg);
}
/// <summary>Create new instance of the X2O config without any custom settings made</summary>
public static X2OConfig EmptyConfig()
{
var cfg = new X2OConfig();
return(cfg);
}
/// <summary>
/// Will read the XML file and returns instance of the read object completely initialized with values from XML file.
/// </summary>
/// <param name="_element">Usually the root node of the XML document to be deserialized and returned as object instance.</param>
/// <param name="_target_type">The type which is the suppossed the be the result (or convertible into this type)</param>
/// <param name="_config">Configurtion object of X2OReader</param>
/// <returns>The instance of the object according to the type read from XML file</returns>
public static object ReadFromXmlElement(XmlElement _element, Type _target_type, X2OConfig _config)
{
var result = _config.Processor.ProcessElements(_element, _target_type, _config);
return(result);
}
/// <summary>
/// Will read the XML file and returns instance of the read object completely initialized with values from XML file.
/// The Type generic argument is used as the declared type of the root node.
/// </summary>
/// <param name="_filename">The filename of the XML file to read into the object</param>
/// <param name="_config">The configuration of X2O reader</param>
/// <returns>The instance of the object according to the type read from XML file</returns>
public static T ReadFromFile <T>(string _filename, X2OConfig _config)
{
var root_node = GetXmlRootElementFromFile(_filename);
var root_type = typeof(T);
var result = ReadFromXmlElement(root_node, root_type, _config);
return((T)result);
}
/// <summary>Will read the XML file and returns instance of the read object completely initialized with values from XML file</summary>
/// <param name="_filename">The filename of the XML file to read into the object</param>
/// <param name="_config">The configuration of X2O reader</param>
/// <returns>The instance of the object according to the type read from XML file</returns>
public static object ReadFromFile(string _filename, X2OConfig _config)
{
var root_node = GetXmlRootElementFromFile(_filename);
var root_type = _config.Processor.GetTypeOfRoot(root_node, _config);
var result = ReadFromXmlElement(root_node, root_type, _config);
return(result);
}
