/// <summary> /// Stream the field to a tag stream /// </summary> /// <param name="ts"></param> /// <exception cref="Exceptions.InvalidTagStruct"></exception> public override void Read(IO.ITagStream ts) { IO.EndianReader s = ts.GetInputStream(); base.relativeOffset = s.PositionUnsigned; // use relative offset since the 'fieldset header' is really...well the header NeedsUpgrading = false; try { if (DefinitionState.FieldSetRequiresVersioningHeader(ts)) { IFieldSetVersioning fs = kState.FieldSetReadVersion(ts, FieldType.Struct, base.relativeOffset, 1); if (NeedsUpgrading = fs.NeedsUpgrading) { int index, size_of; fs.GetUpgradeParameters(out index, out size_of); // It is ASSUMED that the group tag won't ever be needed for version construction if (!fs.UseImplicitUpgrading) { Value = (T)kState.NewInstance(this, index, size_of); } else { Value.VersionImplicitUpgradeBegin(size_of, ts); } } } } catch (Debug.ExceptionLog del) { throw del; } catch (Exception ex) { throw new Exceptions.InvalidTagStruct(ex, base.relativeOffset, this.owner, ts); } }
/// <summary> /// Read the tag from the supplied I\O stream /// </summary> public void Read() { if (InputStream == null) { Debug.Assert.If(false, "Tried to read a tag that we didn't open. {0}:{1}", engine, this.Path); } if (engine == BlamVersion.Unknown) { CalculateVersion(); } ReadPreprocess(); bool needs_upgrading = false; // Read past the tag field set header of the tag group if (DefinitionState.FieldSetRequiresVersioningHeader(this)) { IFieldSetVersioning fs = tagDefinition.State.FieldSetReadVersion(this, FieldType.Tag, InputStream.PositionUnsigned); if (needs_upgrading = fs.NeedsUpgrading) { int index, size_of; fs.GetUpgradeParameters(out index, out size_of); if (!fs.UseImplicitUpgrading) { tagDefinition = tagDefinition.NewInstance((tagDefinition as IStructureOwner).OwnerObject, index, size_of); flags.Add(IO.ITagStreamFlags.DefinitionWasUpgraded); } else { tagDefinition.VersionImplicitUpgradeBegin(size_of, this); } } } tagDefinition.Read(this); if (needs_upgrading) { if (tagDefinition.VersionImplicitUpgradeIsActive) { tagDefinition.VersionImplicitUpgradeEnd(); } else { #if DEBUG if (!tagDefinition.Upgrade()) { Debug.Assert.If(false, "Failed to upgrade tag group. {0} {1}", tagDefinition.GetType().Name, tagDefinition.ToVersionString()); } #else tagDefinition.Upgrade(); #endif } } }
/// <summary> /// Process the block data from a tag stream /// </summary> /// <param name="ts"></param> /// <exception cref="Exceptions.InvalidTagBlock"></exception> public override void Read(IO.ITagStream ts) { NeedsUpgrading = false; bool resizeImplicitUpgradeIsActive = false; if (this.elements.Count != 0) { IO.EndianReader s = ts.GetInputStream(); if (!ts.Flags.Test(IO.ITagStreamFlags.UseStreamPositions)) { relativeOffset = s.PositionUnsigned; // nifty for debugging } else { s.PositionUnsigned = relativeOffset; } try { if (DefinitionState.FieldSetRequiresVersioningHeader(ts)) { IFieldSetVersioning fs = kState.FieldSetReadVersion(ts, FieldType.Block, relativeOffset, Count); if (NeedsUpgrading = fs.NeedsUpgrading) { int index, size_of; fs.GetUpgradeParameters(out index, out size_of); if (!(resizeImplicitUpgradeIsActive = fs.UseImplicitUpgrading)) { Resize(Count, index, size_of); } else { ResizeImplicitUpgradeBegin(size_of, ts); } } } elements.Read(ts); } catch (Debug.ExceptionLog del) { throw del; } catch (Exception ex) { throw new Exceptions.InvalidTagBlock(ex, base.headerOffset, base.relativeOffset, this.owner, ts); } if (NeedsUpgrading) { if (resizeImplicitUpgradeIsActive) { ResizeImplicitUpgradeEnd(); } else { elements.Upgrade(); } } } }