public new static SpellLeveled CreateFromBinary(
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
var ret = new SpellLeveled();
((SpellLeveledSetterCommon)((ISpellLeveledGetter)ret).CommonSetterInstance() !).CopyInFromBinary(
item: ret,
frame: frame,
recordTypeConverter: recordTypeConverter);
return(ret);
}
public new static AnimationSoundTagSet CreateFromBinary(
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
var ret = new AnimationSoundTagSet();
((AnimationSoundTagSetSetterCommon)((IAnimationSoundTagSetGetter)ret).CommonSetterInstance() !).CopyInFromBinary(
item: ret,
frame: frame,
recordTypeConverter: recordTypeConverter);
return(ret);
}
public new static ActorValueInformation CreateFromBinary(
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
var ret = new ActorValueInformation();
((ActorValueInformationSetterCommon)((IActorValueInformationGetter)ret).CommonSetterInstance() !).CopyInFromBinary(
item: ret,
frame: frame,
recordTypeConverter: recordTypeConverter);
return(ret);
}
public virtual void CopyInFromBinary(
IRegionLand item,
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
UtilityTranslation.SubrecordParse(
record: item,
frame: frame,
recordTypeConverter: recordTypeConverter,
fillStructs: RegionLandBinaryCreateTranslation.FillBinaryStructs,
fillTyped: RegionLandBinaryCreateTranslation.FillBinaryRecordTypes);
}
public new static RegionLand CreateFromBinary(
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
var ret = new RegionLand();
((RegionLandSetterCommon)((IRegionLandGetter)ret).CommonSetterInstance() !).CopyInFromBinary(
item: ret,
frame: frame,
recordTypeConverter: recordTypeConverter);
return(ret);
}
public bool Parse(
MutagenFrame frame,
out T item,
RecordTypeConverter?recordTypeConverter)
{
var startPos = frame.Position;
item = CREATE(
reader: frame,
recordTypeConverter: recordTypeConverter);
return(startPos != frame.Position);
}
public virtual void CopyInFromBinary(
IAttractionRuleInternal item,
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
UtilityTranslation.MajorRecordParse <IAttractionRuleInternal>(
record: item,
frame: frame,
recordTypeConverter: recordTypeConverter,
fillStructs: AttractionRuleBinaryCreateTranslation.FillBinaryStructs,
fillTyped: AttractionRuleBinaryCreateTranslation.FillBinaryRecordTypes);
}
public static bool TryCreateFromBinary(
MutagenFrame frame,
out MagicEffectLightArchetype item,
RecordTypeConverter?recordTypeConverter = null)
{
var startPos = frame.Position;
item = CreateFromBinary(
frame: frame,
recordTypeConverter: recordTypeConverter);
return(startPos != frame.Position);
}
public new static Debris CreateFromBinary(
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
var ret = new Debris();
((DebrisSetterCommon)((IDebrisGetter)ret).CommonSetterInstance() !).CopyInFromBinary(
item: ret,
frame: frame,
recordTypeConverter: recordTypeConverter);
return(ret);
}
public new static AttractionRule CreateFromBinary(
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
var ret = new AttractionRule();
((AttractionRuleSetterCommon)((IAttractionRuleGetter)ret).CommonSetterInstance() !).CopyInFromBinary(
item: ret,
frame: frame,
recordTypeConverter: recordTypeConverter);
return(ret);
}
public static bool TryCreateFromBinary(
MutagenFrame frame,
out AttractionRule item,
RecordTypeConverter?recordTypeConverter = null)
{
var startPos = frame.Position;
item = CreateFromBinary(
frame: frame,
recordTypeConverter: recordTypeConverter);
return(startPos != frame.Position);
}
public virtual void CopyInFromBinary(
IOutfitInternal item,
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
PluginUtilityTranslation.MajorRecordParse <IOutfitInternal>(
record: item,
frame: frame,
recordTypeConverter: recordTypeConverter,
fillStructs: OutfitBinaryCreateTranslation.FillBinaryStructs,
fillTyped: OutfitBinaryCreateTranslation.FillBinaryRecordTypes);
}
public new static MagicEffectGuideArchetype CreateFromBinary(
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
var ret = new MagicEffectGuideArchetype();
((MagicEffectGuideArchetypeSetterCommon)((IMagicEffectGuideArchetypeGetter)ret).CommonSetterInstance() !).CopyInFromBinary(
item: ret,
frame: frame,
recordTypeConverter: recordTypeConverter);
return(ret);
}
public new static LensFlare CreateFromBinary(
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
var ret = new LensFlare();
((LensFlareSetterCommon)((ILensFlareGetter)ret).CommonSetterInstance() !).CopyInFromBinary(
item: ret,
frame: frame,
recordTypeConverter: recordTypeConverter);
return(ret);
}
public new static Outfit CreateFromBinary(
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
var ret = new Outfit();
((OutfitSetterCommon)((IOutfitGetter)ret).CommonSetterInstance() !).CopyInFromBinary(
item: ret,
frame: frame,
recordTypeConverter: recordTypeConverter);
return(ret);
}
public new static VirtualMachineAdapter CreateFromBinary(
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
var ret = new VirtualMachineAdapter();
((VirtualMachineAdapterSetterCommon)((IVirtualMachineAdapterGetter)ret).CommonSetterInstance() !).CopyInFromBinary(
item: ret,
frame: frame,
recordTypeConverter: recordTypeConverter);
return(ret);
}
public IReadOnlyList <T> ParseRepeatedTypelessSubrecord <T>(
OverlayStream stream,
RecordType trigger,
ConverterFactory <T> factory,
RecordTypeConverter?recordTypeConverter)
{
return(ParseRepeatedTypelessSubrecord(
stream,
trigger,
(s, r, p, recConv) => factory(s, p, recConv),
recordTypeConverter));
}
public static RecordTypeConverter?Combine(this TypedParseParams?lhs, RecordTypeConverter?rhs)
{
if (lhs?.RecordTypeConverter == null)
{
return(rhs);
}
if (rhs == null)
{
return(null);
}
throw new NotImplementedException();
}
public new static MiscItem CreateFromBinary(
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
var ret = new MiscItem();
((MiscItemSetterCommon)((IMiscItemGetter)ret).CommonSetterInstance() !).CopyInFromBinary(
item: ret,
frame: frame,
recordTypeConverter: recordTypeConverter);
return(ret);
}
public new static SoundDescriptor CreateFromBinary(
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
var ret = new SoundDescriptor();
((SoundDescriptorSetterCommon)((ISoundDescriptorGetter)ret).CommonSetterInstance() !).CopyInFromBinary(
item: ret,
frame: frame,
recordTypeConverter: recordTypeConverter);
return(ret);
}
public static void WriteRecordTypes(
IGlobalGetter item,
MutagenWriter writer,
RecordTypeConverter?recordTypeConverter)
{
MajorRecordBinaryWriteTranslation.WriteRecordTypes(
item: item,
writer: writer,
recordTypeConverter: recordTypeConverter);
GlobalBinaryWriteTranslation.WriteBinaryTypeChar(
writer: writer,
item: item);
}
public BinaryOverlayRecordListByLocationArray(
ReadOnlyMemorySlice <byte> mem,
BinaryOverlayFactoryPackage package,
RecordTypeConverter?recordTypeConverter,
BinaryOverlay.SpanRecordFactory <T> getter,
int[] locs)
{
this._mem = mem;
this._getter = getter;
this._package = package;
this._recordTypeConverter = recordTypeConverter;
this._locations = locs;
}
public static IReadOnlyList <T> FactoryByCountPerItem <T>(
OverlayStream stream,
BinaryOverlayFactoryPackage package,
int countLength,
RecordType subrecordType,
RecordType countType,
RecordTypeConverter?recordTypeConverter,
BinaryOverlay.SpanRecordFactory <T> getter,
bool skipHeader = true)
{
var mem = stream.RemainingMemory;
var initialHeader = package.MetaData.Constants.SubrecordFrame(mem);
var recType = initialHeader.RecordType;
if (recType == countType)
{
var count = countLength switch
{
1 => initialHeader.Content[0],
2 => BinaryPrimitives.ReadUInt16LittleEndian(initialHeader.Content),
4 => BinaryPrimitives.ReadUInt32LittleEndian(initialHeader.Content),
_ => throw new NotImplementedException(),
};
stream.Position += initialHeader.TotalLength;
return(FactoryByArray(
mem: stream.RemainingMemory,
package: package,
recordTypeConverter: recordTypeConverter,
getter: getter,
locs: BinaryOverlay.ParseRecordLocationsByCount(
stream: stream,
count: count,
trigger: subrecordType,
constants: package.MetaData.Constants.SubConstants,
skipHeader: false)));
}
else
{
return(FactoryByArray(
mem: stream.RemainingMemory,
package: package,
recordTypeConverter: recordTypeConverter,
getter: getter,
locs: BinaryOverlay.ParseRecordLocations(
stream: stream,
constants: package.MetaData.Constants.SubConstants,
trigger: subrecordType,
skipHeader: skipHeader,
recordTypeConverter: recordTypeConverter)));
}
}
public static IReadOnlyList <T> FactoryByArray <T>(
ReadOnlyMemorySlice <byte> mem,
BinaryOverlayFactoryPackage package,
RecordTypeConverter?recordTypeConverter,
BinaryOverlay.SpanRecordFactory <T> getter,
int[] locs)
{
return(new BinaryOverlayRecordListByLocationArray <T>(
mem,
package,
recordTypeConverter,
getter,
locs));
}
public static M ModParse <M, G>(
M record,
MutagenFrame frame,
G importMask,
RecordTypeConverter?recordTypeConverter,
RecordStructFill <M> fillStructs,
ModRecordTypeFill <M, G> fillTyped)
{
var modHeader = frame.Reader.GetMod();
fillTyped(
record: record,
frame: frame,
importMask: importMask,
nextRecordType: modHeader.RecordType,
contentLength: checked ((int)modHeader.ContentLength),
recordTypeConverter: recordTypeConverter);
while (!frame.Complete)
{
var groupHeader = frame.GetGroup();
if (!groupHeader.IsGroup)
{
throw new ArgumentException("Did not see GRUP header as expected.");
}
var len = checked ((int)groupHeader.ContentLength);
var finalPos = frame.Position + groupHeader.TotalLength;
if (len == 0)
{
frame.Position = finalPos;
continue;
}
var parsed = fillTyped(
record: record,
frame: frame,
importMask: importMask,
nextRecordType: groupHeader.ContainedRecordType,
contentLength: len,
recordTypeConverter: recordTypeConverter);
if (parsed.Failed)
{
break;
}
if (frame.Position < finalPos)
{
frame.Position = finalPos;
}
}
frame.SetToFinalPosition();
return(record);
}
public bool Parse <T>(
MutagenFrame reader,
out IEDIDLinkGetter <T> item,
RecordTypeConverter?recordTypeConverter = null)
where T : class, IMajorRecordCommonGetter
{
if (!reader.TryCheckUpcomingRead(4, out var ex))
{
throw ex;
}
item = new EDIDLink <T>(HeaderTranslation.ReadNextRecordType(reader));
return(true);
}
public virtual void CopyInFromBinary(
IVirtualMachineAdapter item,
MutagenFrame frame,
RecordTypeConverter?recordTypeConverter = null)
{
frame = frame.SpawnWithFinalPosition(HeaderTranslation.ParseSubrecord(
frame.Reader,
recordTypeConverter.ConvertToCustom(RecordTypes.VMAD)));
PluginUtilityTranslation.SubrecordParse(
record: item,
frame: frame,
recordTypeConverter: recordTypeConverter,
fillStructs: VirtualMachineAdapterBinaryCreateTranslation.FillBinaryStructs);
}
public static ReadOnlyMemorySlice <T> LoquiSliceFromFixedSize <T>(
ReadOnlyMemorySlice <byte> mem,
int amount,
int length,
BinaryOverlayFactoryPackage package,
RecordTypeConverter?recordTypeConverter,
BinaryOverlay.ConverterFactory <T> getter)
{
T[] ret = new T[amount];
for (int i = 0; i < amount; i++)
{
ret[i] = getter(new OverlayStream(mem.Slice(i * length), package), package, recordTypeConverter);
}
return(ret);
}
public static GenderedItem <TItem> Parse <TItem>(
MutagenFrame frame,
BinaryMasterParseDelegate <TItem> transl,
RecordTypeConverter?recordTypeConverter = null)
{
if (!transl(frame, out var male, recordTypeConverter))
{
throw new ArgumentException();
}
if (!transl(frame, out var female, recordTypeConverter))
{
throw new ArgumentException();
}
return(new GenderedItem <TItem>(male, female));
}
public void Write(
MutagenWriter writer,
IVirtualMachineAdapterGetter item,
RecordTypeConverter?recordTypeConverter = null)
{
using (HeaderExport.Header(
writer: writer,
record: recordTypeConverter.ConvertToCustom(RecordTypes.VMAD),
type: ObjectType.Subrecord))
{
AVirtualMachineAdapterBinaryWriteTranslation.WriteEmbedded(
item: item,
writer: writer);
}
}
