/// <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();
}
}
}
}
