Esempio n. 1
0
        public override void Read(BinaryReader br)
        {
            _maxCount   = br.ReadInt16();
            _validCount = br.ReadInt16();
            _dataSize   = br.ReadInt16();
            br.ReadInt16();

            ConstructorInfo mi = _itemType.GetConstructor(Type.EmptyTypes);

            for (int i = 0; i < _maxCount; i++)
            {
                if (_align > 0)
                {
                    if (br.BaseStream.Position % _align != 0)
                    {
                        br.BaseStream.Position += _align - (br.BaseStream.Position % _align);
                    }
                }

                VLTDataItem item = mi.Invoke(null) as VLTDataItem;

                if (item is VLTDataItems.Unknown)
                {
                    (item as VLTDataItems.Unknown).SetLength(_dataSize);
                }

                item.Offset     = (uint)br.BaseStream.Position;
                item.InlineData = false;
                item.TypeHash   = _type;
                item.DataRow    = this.DataRow;
                item.ArrayIndex = i;

                item.Read(br);

                _items.Add(item);
            }
        }
Esempio n. 2
0
            public void Add(VLTDataCollectionLoad collLoad, VLTFile vltFile)
            {
                BinaryReader br;

                BinaryReader brR = new BinaryReader(vltFile.RawStream);
                BinaryReader brV = new BinaryReader(vltFile.VltStream);

                VLTDataRow  dataRow  = new VLTDataRow(_vltClass.FieldCount);
                VLTPointers pointers = vltFile.GetChunk(VLTChunkId.Pointers) as VLTPointers;

                int offset = 0;

#if CARBON
                if (pointers[collLoad.Pointer] == null)
                {
                    /*
                     * Debug.WriteLine(string.Format("Skipped Exp.. class='{0}', name='{1}', num1={2}, exp_ptr={3:x}, ptr_ptr={4:x}",
                     *      HashResolver.Resolve(collLoad.ClassNameHash), HashResolver.Resolve(collLoad.NameHash),
                     *      collLoad.Num1, collLoad.Address, collLoad.Pointer));
                     */
                }
                else
                {
                    offset = pointers[collLoad.Pointer].OffsetDest;
                }
#else
                offset = pointers[collLoad.Pointer].OffsetDest;
#endif

                dataRow.VLTFile        = vltFile;
                dataRow.VLTClass       = _vltClass;
                dataRow.CollectionLoad = collLoad;

                for (int i = 0; i < _vltClass.FieldCount; i++)
                {
#if CARBON
                    bool runtimeLink = false;
#endif
                    ClassField field = _vltClass[i];

                    if (field.IsOptional)
                    {
                        br = null;
                        for (int j = 0; j < collLoad.CountOptional; j++)
                        {
                            if (collLoad[j].NameHash == field.NameHash)
                            {
                                if (collLoad[j].IsDataEmbedded)
                                {
                                    br = brV;
                                    br.BaseStream.Seek(collLoad[j].Pointer, SeekOrigin.Begin);
                                }
                                else
                                {
                                    VLTPointerBlock block = pointers[collLoad[j].Pointer];
#if CARBON
                                    if (block != null)
#endif
                                    {
                                        int localOffset = block.OffsetDest;
                                        br = brR;
                                        br.BaseStream.Seek(localOffset, SeekOrigin.Begin);
                                    }
#if CARBON
                                    else
                                    {
                                        /*
                                         * System.Diagnostics.Debug.WriteLine(
                                         *      string.Format("Runtime Linkage '{0}', name '{1}', field '{2}', req ptr '{3:x}'",
                                         *              HashResolver.Resolve(_vltClass.ClassHash), HashResolver.Resolve(collLoad.NameHash),
                                         *              HashResolver.Resolve(field.NameHash), collLoad[j].Pointer));
                                         */
                                        runtimeLink = true;
                                        br          = brR;
                                    }
#endif
                                }
                            }
                        }
                        if (br == null)
                        {
                            // data is not defined
                            continue;
                        }
                    }
                    else
                    {
                        br = brR;
                        br.BaseStream.Seek(offset + field.Offset, SeekOrigin.Begin);
                    }

/*
 #if !CARBON
 *                                      if (!field.IsArray && field.Alignment > 0)
 *                                      {
 *                                              int align = field.Alignment;
 *                                              if (br.BaseStream.Position % align != 0)
 *                                                      br.BaseStream.Position += align - (br.BaseStream.Position % align);
 *                                      }
 #endif
 */

                    Type type = VLTTypeResolver.Resolver.Resolve(field.TypeHash);

                    if (type == null)
                    {
                        type = typeof(VLTDataItems.Unknown);
                    }

                    VLTDataItem dataItem;
                    if (field.IsArray)
                    {
                        dataItem = VLTDataItemArray.Instantiate(field, type);
                    }
                    else
                    {
                        dataItem = VLTDataItem.Instantiate(type);
                        if (dataItem is VLTDataItems.Unknown)
                        {
                            (dataItem as VLTDataItems.Unknown).SetLength(field.Length);
                        }
                    }

                    dataItem.Offset     = 0;
                    dataItem.InlineData = (br == brV);
                    dataItem.TypeHash   = field.TypeHash;
                    dataItem.NameHash   = field.NameHash;
                    dataItem.DataRow    = dataRow;

                    if (offset != 0 && !runtimeLink)
                    {
                        dataItem.Offset = (uint)br.BaseStream.Position;
                        dataItem.Read(br);
                    }

                    dataRow[i] = dataItem;
                }

                _collection.Add(dataRow);
            }