Esempio n. 1
0
        public override Task PostFieldLoad(ObjectGeneration obj, TypeGeneration field, XElement node)
        {
            var data = field.CustomData.GetOrAdd(Constants.DataKey, () => new MutagenFieldData(field)) as MutagenFieldData;

            if (node.TryGetAttribute("recordType", out string recordAttr))
            {
                data.RecordType = new RecordType(recordAttr);
            }
            else if (node.TryGetAttribute("recordTypeHex", out string recordAttrInt))
            {
                data.RecordType = new RecordType(Convert.ToInt32(recordAttrInt, 16));
            }
            if (node.TryGetAttribute("overflowRecordType", out var overflow))
            {
                data.OverflowRecordType = new RecordType(overflow.Value);
            }
            var markerAttr = node.GetAttribute("markerType");

            if (markerAttr != null)
            {
                data.MarkerType = new RecordType(markerAttr);
            }
            if (obj.IsTopLevelGroup() && (field.Name?.Equals("Items") ?? false))
            {
                DictType  dict  = field as DictType;
                LoquiType loqui = dict.ValueTypeGen as LoquiType;
                data.TriggeringRecordAccessors.Add($"Group<T>.T_RecordType");
            }
            return(base.PostFieldLoad(obj, field, node));
        }
Esempio n. 2
0
        public override async Task GenerateWrapperFields(
            FileGeneration fg,
            ObjectGeneration objGen,
            TypeGeneration typeGen,
            Accessor dataAccessor,
            int?passedLength,
            string passedLengthAccessor,
            DataType data = null)
        {
            DictType dict = typeGen as DictType;

            if (GetDictType(dict) != DictBinaryType.EnumMap)
            {
                // Special case for Groups
                return;
            }

            if (!this.Module.TryGetTypeGeneration(dict.ValueTypeGen.GetType(), out var subTransl))
            {
                throw new ArgumentException("Unsupported type generator: " + dict.ValueTypeGen);
            }

            var posStr = data == null ? passedLengthAccessor : $"_{typeGen.Name}Location";

            if (data != null)
            {
                DataBinaryTranslationGeneration.GenerateWrapperExtraMembers(fg, data, objGen, typeGen, passedLengthAccessor);
            }

            using (var args = new ArgsWrapper(fg,
                                              $"public IReadOnlyDictionary<{dict.KeyTypeGen.TypeName(getter: true)}, {dict.ValueTypeGen.TypeName(getter: true)}> {typeGen.Name} => DictBinaryTranslation<{dict.ValueTypeGen.TypeName(getter: false)}>.Instance.Parse<{dict.KeyTypeGen.TypeName(false)}>"))
            {
                args.Add($"new {nameof(MutagenFrame)}(new {nameof(MutagenMemoryReadStream)}({dataAccessor}{(posStr == null ? null : $".Slice({posStr})")}, _package.{nameof(BinaryOverlayFactoryPackage.MetaData)}))");
        private DictBinaryType GetDictType(DictType dict)
        {
            var data    = dict.GetFieldData();
            var subData = dict.ValueTypeGen.GetFieldData();

            if (subData.HasTrigger)
            {
                return(DictBinaryType.SubTrigger);
            }
            else if (data.RecordType.HasValue)
            {
                return(DictBinaryType.Trigger);
            }
            else if (dict.Mode == DictMode.KeyValue &&
                     dict.KeyTypeGen is EnumType)
            {
                return(DictBinaryType.EnumMap);
            }
            else
            {
                throw new NotImplementedException();
            }
        }