internal override void ReadField(uint type, IFieldReader reader)
        {
            var size = reader.Size;

            switch ((FieldType)type)
            {
            case FieldType.EDID:
            {
                this.MarkField(0);
                this._EditorId = reader.ReadString(size);
                break;
            }

            case FieldType.FULL:
            {
                this.MarkField(1);
                this._FullName = reader.ReadLocalizedString();
                break;
            }

            case FieldType.DESC:
            {
                this.MarkField(2);
                this._Description = reader.ReadLocalizedString();
                break;
            }

            case FieldType.MODL:
            {
                this.MarkField(3);
                break;
            }

            case FieldType.MODT:
            {
                this.MarkField(4);
                break;
            }

            case FieldType.DATA:
            {
                this.MarkField(5);
                this._Data = reader.ReadObject <ObjectMod.Data>();
                break;
            }

            case FieldType.MNAM:
            {
                this.MarkField(6);
                Debug.Assert(size > 0 && (size % 4) == 0);
                var keywordIds = new uint[size / 4];
                for (int i = 0; i < keywordIds.Length; i++)
                {
                    keywordIds[i] = reader.ReadValueU32();
                }
                this._KeywordIds.Clear();
                this._KeywordIds.AddRange(keywordIds);
                break;
            }

            case FieldType.LNAM:
            {
                this.MarkField(7);
                Debug.Assert(size == 4);
                this._LNAM = reader.ReadValueU32();
                break;
            }

            case FieldType.NAM1:
            {
                this.MarkField(8);
                break;
            }

            case FieldType.FLTR:
            {
                this.MarkField(9);
                this._EditorFilter = reader.ReadString(260);
                break;
            }

            case FieldType.FNAM:
            {
                this.MarkField(10);
                break;
            }

            case FieldType.MODS:
            {
                this.MarkField(11);
                break;
            }

            default:
            {
                throw new NotSupportedException();
            }
            }
        }
        internal override void ReadField(uint type, IFieldReader reader)
        {
            var size = reader.Size;

            switch ((Fields)type)
            {
            case Fields.HEDR:
            {
                this.MarkField(0);
                Debug.Assert(size == 12);
                this._Header = reader.ReadObject <PluginHeader>();
                break;
            }

            case Fields.CNAM:
            {
                this.MarkField(1);
                this._Creator = reader.ReadString(size);
                break;
            }

            case Fields.SNAM:
            {
                this.MarkField(2);
                this._Summary = reader.ReadString(size);
                break;
            }

            case Fields.MAST:
            {
                this._Masters.Add(reader.ReadString(size));
                break;
            }

            case Fields.DATA:
            {
                break;
            }

            case Fields.TNAM:
            {
                break;
            }

            case Fields.INTV:
            {
                this.MarkField(6);
                Debug.Assert(size == 4);
                break;
            }

            case Fields.INCC:
            {
                this.MarkField(7);
                Debug.Assert(size == 4);
                break;
            }

            default:
            {
                throw new NotSupportedException();
            }
            }
        }