public IFormatReader Get(IFormatReader parameter)
                {
                    var typeInfo = _classification.Get(parameter);
                    var fullName = typeInfo.FullName;
                    var version  = parameter.IsSatisfiedBy(_property) ? _property.Get(parameter) : 0;

                    var length = _migrations.Length;

                    if (version > length)
                    {
                        throw new XmlException($"Unknown varsion number {version} for type {typeInfo}.");
                    }

                    if (_migrations == null)
                    {
                        throw new XmlException($"Migrations for type {fullName} is null.");
                    }

                    var element = XElement.Load(parameter.Get().AsValid <System.Xml.XmlReader>());

                    for (var i = version; i < length; i++)
                    {
                        var index     = (int)i;
                        var migration = _migrations.ElementAtOrDefault(index);
                        if (migration == null)
                        {
                            throw new XmlException(
                                      $"Migrations for type {fullName} contains invalid migration at index {i}.");
                        }
                        _migrations[index].Invoke(element);
                    }
                    var result = _factory.Get(element.CreateReader());

                    return(result);
                }
Exemple #2
0
 public object Get(T parameter)
 {
     using (var content = _readers.Get(parameter))
     {
         var classification = _classification.GetClassification(content);
         var result         = _serializers.Get(classification)
                              .Get(content);
         return(result);
     }
 }
                public IFormatReader Get(IFormatReader parameter)
                {
                    var typeInfo = _classification.Get(parameter) ?? _type;
                    var fullName = typeInfo.FullName;
                    var version  = parameter.IsSatisfiedBy(_property) ? _property.Get(parameter) : 0;

                    if (version > _version)
                    {
                        throw new XmlException($"Unknown varsion number {version} for type {typeInfo}.");
                    }

                    var reader  = parameter.Get().AsValid <System.Xml.XmlReader>();
                    var element = XElement.Load(reader.ReadSubtree());

                    for (var i = version; i < _version; i++)
                    {
                        var index     = (int)i;
                        var migration = _migrations.ElementAtOrDefault(index);
                        if (migration == null)
                        {
                            throw new XmlException(
                                      $"Migrations for type {fullName} contains invalid migration at index {i}.");
                        }
                        _migrations[index]
                        .Invoke(element);
                    }

                    var xmlReader = element.CreateReader();

                    XmlParserContexts.Default.Assign(xmlReader.NameTable,
                                                     XmlParserContexts.Default.Get(reader.NameTable));
                    var result = _factory.Get(xmlReader);

                    AssociatedReaders.Default.Assign(result, parameter);
                    return(result);
                }
                // ReSharper disable once CognitiveComplexity
                // ReSharper disable once ExcessiveIndentation
                public IFormatReader Get(IFormatReader parameter)
                {
                    var typeInfo = _classification.Get(parameter) ?? _type;
                    var fullName = typeInfo.FullName;
                    var version  = parameter.IsSatisfiedBy(_property) ? _property.Get(parameter) : 0;

                    if (version > _version)
                    {
                        throw new XmlException($"Unknown version number {version} for type {typeInfo}.");
                    }

                    parameter.Set();

                    var reader  = parameter.Get().AsValid <System.Xml.XmlReader>();
                    var element = XElement.Load(reader.ReadSubtree());

                    for (var i = version; i < _version; i++)
                    {
                        var index     = (int)i;
                        var migration = _migrations.ElementAtOrDefault(index);
                        if (migration == null)
                        {
                            throw new XmlException(
                                      $"Migrations for type {fullName} contains invalid migration at index {i}.");
                        }
                        _migrations[index](element);
                    }

                    var attributes = element.Descendants()
                                     .Attributes()
                                     .Where(a => a.IsNamespaceDeclaration)
                                     .Distinct()
                                     .ToArray();

                    foreach (var attribute in attributes)
                    {
                        if (element.Attribute(attribute.Name) == null)
                        {
                            element.Add(attribute);
                        }
                    }

                    var native  = element.CreateReader(ReaderOptions.OmitDuplicateNamespaces);
                    var context = XmlParserContexts.Default.Get(reader.NameTable);

                    if (reader.NameTable != null)
                    {
                        var manager = context.NamespaceManager;

                        foreach (var attribute in attributes)
                        {
                            var prefix = attribute.Name.LocalName;
                            if (manager.LookupNamespace(prefix) == null)
                            {
                                var @namespace = element.GetNamespaceOfPrefix(prefix);
                                if (@namespace != null)
                                {
                                    manager.AddNamespace(prefix, @namespace.NamespaceName);
                                }
                            }
                        }
                    }

                    XmlParserContexts.Default.Assign(native.NameTable, context);
                    var result = _factory.Get(native);

                    AssociatedReaders.Default.Assign(result, parameter);
                    return(result);
                }
 public IFormatReader Get(T reader) => new DeferredReferencesReader(_factory.Get(reader));