public SecondGenCacheFile(IReader reader, BuildInformation buildInfo, string buildString)
{
_buildInfo = buildInfo;
_segmenter = new FileSegmenter(buildInfo.SegmentAlignment);
Allocator = new MetaAllocator(this, 0x10000);
Load(reader, buildInfo, buildString);
}
/// <summary>
/// Writes data to a reflexive, reallocating the original.
/// </summary>
/// <param name="entries">The entries to write.</param>
/// <param name="oldCount">The old count.</param>
/// <param name="oldAddress">The old address.</param>
/// <param name="newCount">The number of entries to write.</param>
/// <param name="layout">The layout of the data to write.</param>
/// <param name="metaArea">The meta area of the cache file.</param>
/// <param name="allocator">The cache file's meta allocator.</param>
/// <param name="stream">The stream to manipulate.</param>
/// <returns>The address of the new reflexive, or 0 if the entry list is empty and the reflexive was freed.</returns>
public static uint WriteReflexive(IEnumerable<StructureValueCollection> entries, int oldCount, uint oldAddress,
int newCount, StructureLayout layout, FileSegmentGroup metaArea, MetaAllocator allocator, IStream stream)
{
if (newCount == 0)
{
// Free the old reflexive and return
if (oldCount > 0 && oldAddress != 0)
allocator.Free(oldAddress, oldCount*layout.Size);
return 0;
}
uint newAddress = oldAddress;
if (newCount != oldCount)
{
// Reallocate the reflexive
int oldSize = oldCount*layout.Size;
int newSize = newCount*layout.Size;
if (oldCount > 0 && oldAddress != 0)
newAddress = allocator.Reallocate(oldAddress, oldSize, newSize, stream);
else
newAddress = allocator.Allocate(newSize, stream);
}
// Write the new values
WriteReflexive(entries.Take(newCount), newAddress, layout, metaArea, stream);
return newAddress;
}
public FourthGenCacheFile(IReader map_reader, IReader tag_reader, IReader string_reader, IReader tagnames_reader, EngineDescription buildInfo, string buildString)
{
_buildInfo = buildInfo;
_segmenter = new FileSegmenter(buildInfo.SegmentAlignment);
Allocator = new MetaAllocator(this, 0x10000);
Load(map_reader, tag_reader, string_reader, tagnames_reader, buildString);
}
public ThirdGenCacheFile(IReader reader, EngineDescription buildInfo, string buildString)
{
_buildInfo = buildInfo;
_segmenter = new FileSegmenter(buildInfo.SegmentAlignment);
Allocator = new MetaAllocator(this, 0x10000);
Load(reader, buildString);
}
public static void Free(StructureValueCollection values, MetaAllocator allocator)
{
FreeBitArray(values, "number of raw pool bitfields", "raw pool bitfield table address", allocator);
FreeBitArray(values, "number of raw pool 2 bitfields", "raw pool 2 bitfield table address", allocator);
FreeBitArray(values, "number of raw pool 3 bitfields", "raw pool 3 bitfield table address", allocator);
FreeBitArray(values, "number of tag bitfields", "tag bitfield table address", allocator);
FreeBitArray(values, "number of tag 2 bitfields", "tag 2 bitfield table address", allocator);
}
public FourthGenResourceLayoutTable(ITag playTag, FileSegmentGroup metaArea, MetaAllocator allocator,
EngineDescription buildInfo)
{
_tag = playTag;
_metaArea = metaArea;
_allocator = allocator;
_buildInfo = buildInfo;
}
public FourthGenZoneSetTable(FourthGenResourceGestalt gestalt, IReader reader, FileSegmentGroup metaArea,
MetaAllocator allocator, EngineDescription buildInfo)
{
_gestalt = gestalt;
_metaArea = metaArea;
_allocator = allocator;
_buildInfo = buildInfo;
Load(reader);
}
public FourthGenTagTable(IReader reader, MetaAllocator allocator, EngineDescription buildInfo)
{
//_indexHeaderLocation = indexHeaderLocation;
//_metaArea = metaArea;
_allocator = allocator;
_buildInfo = buildInfo;
Load(reader);
}
/// <summary>
/// Initializes a new instance of the <see cref="ThirdGenResourceManager" /> class.
/// </summary>
/// <param name="gestalt">The cache file's resource gestalt.</param>
/// <param name="layoutTable">The cache file's resource layout table.</param>
/// <param name="tags">The cache file's tag table.</param>
/// <param name="metaArea">The cache file's meta area.</param>
/// <param name="allocator">The cache file's tag data allocator.</param>
/// <param name="buildInfo">The cache file's build information.</param>
public ThirdGenResourceManager(ThirdGenResourceGestalt gestalt, ThirdGenResourceLayoutTable layoutTable, TagTable tags,
FileSegmentGroup metaArea, MetaAllocator allocator, EngineDescription buildInfo)
{
_gestalt = gestalt;
_layoutTable = layoutTable;
_tags = tags;
_metaArea = metaArea;
_allocator = allocator;
_buildInfo = buildInfo;
}
public ThirdGenResourceGestalt(IReader reader, ITag zoneTag, FileSegmentGroup metaArea, MetaAllocator allocator,
StringIDSource stringIDs, EngineDescription buildInfo)
{
_tag = zoneTag;
_metaArea = metaArea;
_allocator = allocator;
_buildInfo = buildInfo;
Load(reader, stringIDs);
}
public FourthGenSimulationDefinitionTable(ITag scenario, TagTable tags, IReader reader, FileSegmentGroup metaArea, MetaAllocator allocator, EngineDescription buildInfo)
{
_scenario = scenario;
_tags = tags;
_metaArea = metaArea;
_allocator = allocator;
_buildInfo = buildInfo;
Load(reader);
}
public ThirdGenTagTable(IReader reader, SegmentPointer indexHeaderLocation, FileSegmentGroup metaArea,
MetaAllocator allocator, EngineDescription buildInfo)
{
_indexHeaderLocation = indexHeaderLocation;
_metaArea = metaArea;
_allocator = allocator;
_buildInfo = buildInfo;
Load(reader);
}
/// <summary>
/// Writes data to a reflexive, reallocating the original.
/// </summary>
/// <param name="entries">The entries to write.</param>
/// <param name="oldCount">The old count.</param>
/// <param name="oldAddress">The old address.</param>
/// <param name="layout">The layout of the data to write.</param>
/// <param name="metaArea">The meta area of the cache file.</param>
/// <param name="allocator">The cache file's meta allocator.</param>
/// <param name="stream">The stream to manipulate.</param>
/// <returns>The address of the new reflexive, or 0 if the entry list is empty and the reflexive was freed.</returns>
public static uint WriteReflexive(ICollection <StructureValueCollection> entries, int oldCount, uint oldAddress,
StructureLayout layout, FileSegmentGroup metaArea, MetaAllocator allocator, IStream stream)
{
return(WriteReflexive(entries, oldCount, oldAddress, entries.Count, layout, metaArea, allocator, stream));
}
private static void FreeBitArray(StructureValueCollection values, string countName, string addressName, MetaAllocator allocator)
{
if (!values.HasInteger(countName) || !values.HasInteger(addressName))
return;
var oldCount = (int)values.GetInteger(countName);
uint oldAddress = values.GetInteger(addressName);
if (oldCount > 0 && oldAddress > 0)
allocator.Free(oldAddress, oldCount*4);
}
private void SaveBitArray(BitArray bits, string countName, string addressName, MetaAllocator allocator, IStream stream, ReflexiveCache<int> cache, StructureValueCollection values)
{
if (bits.Length == 0)
{
values.SetInteger(countName, 0);
values.SetInteger(addressName, 0);
return;
}
var ints = new int[((bits.Length + 31) & ~31)/32];
bits.CopyTo(ints, 0);
// If the address isn't cached, then allocate space and write a new array
uint newAddress;
if (!cache.TryGetAddress(ints, out newAddress))
{
newAddress = allocator.Allocate(ints.Length*4, stream);
stream.SeekTo(_metaArea.PointerToOffset(newAddress));
foreach (int i in ints)
stream.WriteInt32(i);
cache.Add(newAddress, ints);
}
values.SetInteger(countName, (uint)ints.Length);
values.SetInteger(addressName, newAddress);
}
public StructureValueCollection Serialize(IStream stream, MetaAllocator allocator, ReflexiveCache<int> cache)
{
var result = new StructureValueCollection();
SaveBitArray(_activeResources, "number of raw pool bitfields", "raw pool bitfield table address", allocator, stream, cache, result);
SaveBitArray(_unknownResources, "number of raw pool 2 bitfields", "raw pool 2 bitfield table address", allocator, stream, cache, result);
SaveBitArray(_unknownResources2, "number of raw pool 3 bitfields", "raw pool 3 bitfield table address", allocator, stream, cache, result);
SaveBitArray(_activeTags, "number of tag bitfields", "tag bitfield table address", allocator, stream, cache, result);
SaveBitArray(_unknownTags, "number of tag 2 bitfields", "tag 2 bitfield table address", allocator, stream, cache, result);
return result;
}
/// <summary>
/// Writes data to a block, reallocating the original.
/// </summary>
/// <param name="elements">The entries to write.</param>
/// <param name="oldCount">The old count.</param>
/// <param name="oldAddress">The old address.</param>
/// <param name="newCount">The number of entries to write.</param>
/// <param name="layout">The layout of the data to write.</param>
/// <param name="metaArea">The meta area of the cache file.</param>
/// <param name="allocator">The cache file's meta allocator.</param>
/// <param name="stream">The stream to manipulate.</param>
/// <returns>The address of the new tag block, or 0 if the entry list is empty and the tag block was freed.</returns>
public static long WriteTagBlock(IEnumerable <StructureValueCollection> elements, int oldCount, long oldAddress,
int newCount, StructureLayout layout, FileSegmentGroup metaArea, MetaAllocator allocator, IStream stream)
{
if (newCount == 0)
{
// Free the old block and return
if (oldCount > 0 && oldAddress != 0)
{
allocator.Free(oldAddress, oldCount * layout.Size);
}
return(0);
}
long newAddress = oldAddress;
if (newCount != oldCount)
{
// Reallocate the block
int oldSize = oldCount * layout.Size;
int newSize = newCount * layout.Size;
if (oldCount > 0 && oldAddress != 0)
{
newAddress = allocator.Reallocate(oldAddress, oldSize, newSize, stream);
}
else
{
newAddress = allocator.Allocate(newSize, stream);
}
}
// Write the new values
WriteTagBlock(elements.Take(newCount), newAddress, layout, metaArea, stream);
return(newAddress);
}
/// <summary>
/// Writes data to a block, reallocating the original.
/// </summary>
/// <param name="elements">The entries to write.</param>
/// <param name="oldCount">The old count.</param>
/// <param name="oldAddress">The old address.</param>
/// <param name="layout">The layout of the data to write.</param>
/// <param name="metaArea">The meta area of the cache file.</param>
/// <param name="allocator">The cache file's meta allocator.</param>
/// <param name="stream">The stream to manipulate.</param>
/// <returns>The address of the new tag block, or 0 if the entry list is empty and the tag block was freed.</returns>
public static long WriteTagBlock(ICollection <StructureValueCollection> elements, int oldCount, long oldAddress,
StructureLayout layout, FileSegmentGroup metaArea, MetaAllocator allocator, IStream stream)
{
return(WriteTagBlock(elements, oldCount, oldAddress, elements.Count, layout, metaArea, allocator, stream));
}
/// <summary>
/// Writes data to a reflexive, reallocating the original.
/// </summary>
/// <param name="entries">The entries to write.</param>
/// <param name="oldCount">The old count.</param>
/// <param name="oldAddress">The old address.</param>
/// <param name="newCount">The number of entries to write.</param>
/// <param name="layout">The layout of the data to write.</param>
/// <param name="metaArea">The meta area of the cache file.</param>
/// <param name="allocator">The cache file's meta allocator.</param>
/// <param name="stream">The stream to manipulate.</param>
/// <returns>The address of the new reflexive, or 0 if the entry list is empty and the reflexive was freed.</returns>
public static uint WriteReflexive(IEnumerable <StructureValueCollection> entries, int oldCount, uint oldAddress,
int newCount, StructureLayout layout, FileSegmentGroup metaArea, MetaAllocator allocator, IStream stream)
{
if (newCount == 0)
{
// Free the old reflexive and return
if (oldCount > 0 && oldAddress != 0)
{
allocator.Free(oldAddress, oldCount * layout.Size);
}
return(0);
}
uint newAddress = oldAddress;
if (newCount != oldCount)
{
// Reallocate the reflexive
int oldSize = oldCount * layout.Size;
int newSize = newCount * layout.Size;
if (oldCount > 0 && oldAddress != 0)
{
newAddress = allocator.Reallocate(oldAddress, oldSize, newSize, stream);
}
else
{
newAddress = allocator.Allocate(newSize, stream);
}
}
// Write the new values
WriteReflexive(entries.Take(newCount), newAddress, layout, metaArea, stream);
return(newAddress);
}
/// <summary>
/// Allocates a new reflexive and writes data to it.
/// </summary>
/// <param name="entries">The entries to write.</param>
/// <param name="layout">The layout of the data to write.</param>
/// <param name="metaArea">The meta area of the cache file.</param>
/// <param name="allocator">The cache file's meta allocator.</param>
/// <param name="stream">The stream to manipulate.</param>
/// <returns>The address of the new reflexive, or 0 if the entry list is empty.</returns>
public static long WriteReflexive(ICollection <StructureValueCollection> entries, StructureLayout layout,
FileSegmentGroup metaArea, MetaAllocator allocator, IStream stream)
{
return(WriteReflexive(entries, 0, 0, layout, metaArea, allocator, stream));
}
/// <summary>
/// Writes data to a reflexive, reallocating the original.
/// </summary>
/// <param name="entries">The entries to write.</param>
/// <param name="oldCount">The old count.</param>
/// <param name="oldAddress">The old address.</param>
/// <param name="layout">The layout of the data to write.</param>
/// <param name="metaArea">The meta area of the cache file.</param>
/// <param name="allocator">The cache file's meta allocator.</param>
/// <param name="stream">The stream to manipulate.</param>
/// <returns>The address of the new reflexive, or 0 if the entry list is empty and the reflexive was freed.</returns>
public static uint WriteReflexive(ICollection<StructureValueCollection> entries, int oldCount, uint oldAddress,
StructureLayout layout, FileSegmentGroup metaArea, MetaAllocator allocator, IStream stream)
{
return WriteReflexive(entries, oldCount, oldAddress, entries.Count, layout, metaArea, allocator, stream);
}