UELib.Core.UObject.Record C# (CSharp) Метод

        internal void Record( string varName, object varObject = null )
        {
            var size = _Buffer.Position - _Buffer.LastPosition;
            if( size <= 0 )
                return;

            BinaryMetaData.AddField( varName, varObject, _Buffer.LastPosition, size );
            #if LOG_RECORDS
            if( varObject == null )
            {
                Console.WriteLine( varName );
                return;
            }

            var propertyType = varObject.GetType();
            Console.WriteLine(
                "0x" + _Buffer.LastPosition.ToString("x8").ToUpper()
                + " : ".PadLeft( 2, ' ' )
                + varName.PadRight( 32, ' ' ) + ":" + propertyType.Name.PadRight( 32, ' ' )
                + " => " + varObject
            );
            #endif
        }

        public bool Deserialize()
        {
            _BeginOffset = _Buffer.Position;

            Name = _Buffer.ReadNameReference();
            _Container.Record("Name", Name);
            if (Name.IsNone())
            {
                return(false);
            }

            // Unreal Engine 1 and 2
            if (_Buffer.Version < V3)
            {
                const byte typeMask = 0x0F;
                const byte sizeMask = 0x70;

                // Packed byte
                var info = _Buffer.ReadByte();
                _Container.Record(String.Format(
                                      "Info(Type={0},SizeMask=0x{1:X2},ArrayIndexMask=0x{2:X2})",
                                      (PropertyType)(byte)(info & typeMask),
                                      (byte)(info & sizeMask),
                                      (info & ArrayIndexMask)
                                      ), info
                                  );

                Type = (PropertyType)(byte)(info & typeMask);
                if (Type == PropertyType.StructProperty)
                {
                    ItemName = _Buffer.ReadNameReference();
                    _Container.Record("ItemName", ItemName);
                }

                Size = DeserializeSize((byte)(info & sizeMask));
                if (Size >= 0x50)
                {
                    _Container.Record("Size", Size);
                }

                switch (Type)
                {
                case PropertyType.BoolProperty:
                    _BoolValue = (info & ArrayIndexMask) != 0;
                    break;

                default:
                    if ((info & ArrayIndexMask) != 0)
                    {
                        ArrayIndex = DeserializeArrayIndex();
                        _Container.Record("ArrayIndex", ArrayIndex);
                    }
                    break;
                }
            }
            // Unreal Engine 3
            else
            {
                string typeName = _Buffer.ReadName();
                _Container.Record("typeName", typeName);
                Type = (PropertyType)Enum.Parse(typeof(PropertyType), typeName);

                Size = _Buffer.ReadInt32();
                _Container.Record("Size", Size);
                ArrayIndex = _Buffer.ReadInt32();
                _Container.Record("ArrayIndex", ArrayIndex);

                switch (Type)
                {
                case PropertyType.StructProperty:
                    ItemName = _Buffer.ReadNameReference();
                    _Container.Record("ItemName", ItemName);
                    break;

                case PropertyType.ByteProperty:
                    if (_Buffer.Version >= VEnumName)
                    {
                        EnumName = _Buffer.ReadNameReference();
                        _Container.Record("EnumName", EnumName);
                    }
                    break;

                case PropertyType.BoolProperty:
                    _BoolValue = _Buffer.Version >= VBoolSizeToOne?_Buffer.ReadByte() > 0 : _Buffer.ReadInt32() > 0;

                    _Container.Record("_BoolValue", _BoolValue);
                    break;
                }
            }

            _ValueOffset = _Buffer.Position;
            try
            {
                DeserializeValue();
            }
            finally
            {
                // Even if something goes wrong, we can still skip everything and safely deserialize the next property if any!
                _Buffer.Position = _EndOffset;
            }
            return(true);
        }