public ShaderProperties(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Reader.SeekTo(Address + 12); TemplateTagID = Reader.ReadInt32(); #region ShaderProperties Chunk Reader.SeekTo(Address + 16); int iCount = Reader.ReadInt32(); int iOffset = Reader.ReadInt32() - Cache.Magic; ShaderMaps = new List <rmsh.ShaderProperties.ShaderMap>(); for (int i = 0; i < iCount; i++) { ShaderMaps.Add(new ShaderMap(Cache, iOffset + 24 * i)); } #endregion #region Tiling Chunk Reader.SeekTo(Address + 28); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; Tilings = new List <rmsh.ShaderProperties.Tiling>(); for (int i = 0; i < iCount; i++) { Tilings.Add(new Tiling(Cache, iOffset + 16 * i)); } #endregion }
public ShaderProperties(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Reader.SeekTo(Address + 12); TemplateTagID = Reader.ReadInt32(); #region ShaderProperties Chunk Reader.SeekTo(Address + 16); int iCount = Reader.ReadInt32(); int iOffset = Reader.ReadInt32() - Cache.Magic; ShaderMaps = new List<rmsh.ShaderProperties.ShaderMap>(); for (int i = 0; i < iCount; i++) ShaderMaps.Add(new ShaderMap(Cache, iOffset + 24 * i)); #endregion #region Tiling Chunk Reader.SeekTo(Address + 28); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; Tilings = new List<rmsh.ShaderProperties.Tiling>(); for (int i = 0; i < iCount; i++) Tilings.Add(new Tiling(Cache, iOffset + 16 * i)); #endregion }
public ModelSection(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); type = Reader.ReadInt16(); Reader.ReadUInt16(); vertcount = Reader.ReadUInt16(); facecount = Reader.ReadUInt16(); Reader.SeekTo(Address + 20); bones = Reader.ReadByte(); Reader.SeekTo(Address + 56); rawOffset = Reader.ReadInt32(); rawSize = Reader.ReadInt32(); Reader.ReadUInt32(); hSize = rawSize - Reader.ReadInt32() - 4; int iCount = Reader.ReadInt32(); int iOffset = Reader.ReadInt32() - Cache.Magic; rSize = new int[iCount]; rOffset = new int[iCount]; rType = new int[iCount]; for (int i = 0; i < iCount; i++) { Reader.SeekTo(iOffset + 16 * i + 4); rType[i] = Reader.ReadInt32(); rSize[i] = Reader.ReadInt32(); rOffset[i] = Reader.ReadInt32(); } }
/// <summary> /// Checks whether the given collection key indexes are cached. /// </summary> /// <param name="collectionKeys">The list of pairs of collection entries and their indexes.</param> /// <param name="keyIndexes">The array of indexes of <paramref name="collectionKeys"/> that have to be checked.</param> /// <param name="persister">The collection persister.</param> /// <param name="batchableCache">The batchable cache.</param> /// <param name="checkCache">Whether to check the cache or just return <see langword="false" /> for all keys.</param> /// <returns>An array of booleans that contains the result for each key.</returns> private bool[] AreCached(List <KeyValuePair <KeyValuePair <CollectionEntry, IPersistentCollection>, int> > collectionKeys, int[] keyIndexes, ICollectionPersister persister, CacheBase batchableCache, bool checkCache) { var result = new bool[keyIndexes.Length]; if (!checkCache || !persister.HasCache || !context.Session.CacheMode.HasFlag(CacheMode.Get)) { return(result); } var cacheKeys = new object[keyIndexes.Length]; var i = 0; foreach (var index in keyIndexes) { var collectionKey = collectionKeys[index].Key; cacheKeys[i++] = context.Session.GenerateCacheKey( collectionKey.Key.LoadedKey, persister.KeyType, persister.Role); } var cacheResult = batchableCache.GetMany(cacheKeys); for (var j = 0; j < result.Length; j++) { result[j] = cacheResult[j] != null; } return(result); }
/// <summary> /// Checks whether the given entity key indexes are cached. /// </summary> /// <param name="entityKeys">The list of pairs of entity keys and their indexes.</param> /// <param name="keyIndexes">The array of indexes of <paramref name="entityKeys"/> that have to be checked.</param> /// <param name="persister">The entity persister.</param> /// <param name="batchableCache">The batchable cache.</param> /// <param name="checkCache">Whether to check the cache or just return <see langword="false" /> for all keys.</param> /// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param> /// <returns>An array of booleans that contains the result for each key.</returns> private async Task <bool[]> AreCachedAsync(List <KeyValuePair <EntityKey, int> > entityKeys, int[] keyIndexes, IEntityPersister persister, CacheBase batchableCache, bool checkCache, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); var result = new bool[keyIndexes.Length]; if (!checkCache || !persister.HasCache || !context.Session.CacheMode.HasFlag(CacheMode.Get)) { return(result); } var cacheKeys = new object[keyIndexes.Length]; var i = 0; foreach (var index in keyIndexes) { var entityKey = entityKeys[index].Key; cacheKeys[i++] = context.Session.GenerateCacheKey( entityKey.Identifier, persister.IdentifierType, entityKey.EntityName); } var cacheResult = await(batchableCache.GetManyAsync(cacheKeys, cancellationToken)).ConfigureAwait(false); for (var j = 0; j < result.Length; j++) { result[j] = cacheResult[j] != null; } return(result); }
public CacheIndexHeader(CacheBase Cache) { cache = Cache; var Reader = cache.Reader; #region Read Values XmlNode indexHeaderNode = cache.versionNode.ChildNodes[1]; XmlAttribute attr = indexHeaderNode.Attributes["tagClassCount"]; int offset = int.Parse(attr.Value); Reader.SeekTo(offset + cache.Header.indexOffset); tagClassCount = Reader.ReadInt32(); attr = indexHeaderNode.Attributes["tagInfoOffset"]; offset = int.Parse(attr.Value); Reader.SeekTo(offset + cache.Header.indexOffset); tagInfoOffset = Reader.ReadInt32() - cache.Header.Magic; Reader.SeekTo(cache.Header.indexOffset); cache.Header.Magic = Reader.ReadInt32() - (cache.Header.indexOffset + 32); tagClassCount = Reader.ReadInt32(); tagInfoOffset = Reader.ReadInt32() - cache.Header.Magic; Reader.SeekTo(tagInfoOffset + 8); cache.Magic = Reader.ReadInt32() - (cache.Header.indexOffset + cache.Header.tagDataAddress); Reader.SeekTo(cache.Header.indexOffset + 24); tagCount = Reader.ReadInt32(); #endregion }
/// <summary> /// Returns an array containing list of keys contained in the cache. Null if there are no /// keys or if timeout occurs. /// </summary> /// <param name="cache"></param> /// <param name="timeout"></param> /// <returns></returns> internal static object[] GetKeyset(CacheBase cache, int timeout) { int index = 0; object[] objects = null; cache.Sync.AcquireWriterLock(timeout); try { if (!cache.Sync.IsWriterLockHeld || cache.Count < 1) { return(objects); } objects = new object[cache.Count]; for (IEnumerator i = cache.GetEnumerator(); i.MoveNext() && index < objects.Length;) { objects[index++] = ((DictionaryEntry)i.Current).Key; } } finally { cache.Sync.ReleaseWriterLock(); } return(objects); }
/// <summary> /// Overloaded constructor. Takes the properties as a map. /// </summary> /// <param name="cacheSchemes">collection of cache schemes (config properties).</param> /// <param name="properties">properties collection for this cache.</param> /// <param name="listener">cache events listener</param> /// <param name="timeSched">scheduler to use for periodic tasks</param> public IndexedLocalCache(IDictionary cacheClasses, CacheBase parentCache, IDictionary properties, ICacheEventsListener listener, CacheRuntimeContext context) : base(cacheClasses, parentCache, properties, listener, context) { IDictionary props = null; if (properties.Contains("indexes")) { props = properties["indexes"] as IDictionary; } _queryIndexManager = new QueryIndexManager(props, this, _context.CacheRoot.Name); if (!_queryIndexManager.Initialize()) { _queryIndexManager = null; } //+Numan16122014 _cacheStore.ISizableQueryIndexManager = _queryIndexManager; _cacheStore.ISizableEvictionIndexManager = _evictionPolicy; _cacheStore.ISizableExpirationIndexManager = _context.ExpiryMgr; _stats.MaxCount = _cacheStore.MaxCount; _stats.MaxSize = _cacheStore.MaxSize; //+Numan16122014 if (_context.PerfStatsColl != null) { if (_queryIndexManager != null) { _context.PerfStatsColl.SetQueryIndexSize(_queryIndexManager.IndexInMemorySize); } } }
//H2X, H3B, H3R, ODST, HRB, HRR, H4R public static render_model mode(CacheBase Cache, CacheBase.IndexItem Tag) { switch (Cache.Version) { case DefinitionSet.Halo1PC: case DefinitionSet.Halo1CE: case DefinitionSet.Halo1AE: return new Halo1PC.gbxmodel(Cache, Tag.Offset); case DefinitionSet.Halo2Xbox: return new Halo2Xbox.render_model(Cache, Tag.Offset); case DefinitionSet.Halo3Beta: case DefinitionSet.Halo3Retail: return new Halo3Beta.render_model(Cache, Tag.Offset); case DefinitionSet.Halo3ODST: return new Halo3ODST.render_model(Cache, Tag.Offset); case DefinitionSet.HaloReachBeta: return new ReachBeta.render_model(Cache, Tag.Offset); case DefinitionSet.HaloReachRetail: return new ReachRetail.render_model(Cache, Tag.Offset); case DefinitionSet.Halo4Beta: return new Halo4Beta.render_model(Cache, Tag.Offset); case DefinitionSet.Halo4Retail: return new Halo4Retail.render_model(Cache, Tag.Offset); default: throw new NotSupportedException(errorMessage.Replace("----", "mode")); } }
/// <summary> /// Overloaded constructor. Takes the properties as a map. /// </summary> /// <param name="cacheSchemes">collection of cache schemes (config properties).</param> /// <param name="properties">properties collection for this cache.</param> /// <param name="listener">cache events listener</param> /// <param name="timeSched">scheduler to use for periodic tasks</param> public IndexedLocalCache(IDictionary cacheClasses, CacheBase parentCache, IDictionary properties, ICacheEventsListener listener, CacheRuntimeContext context) : base(cacheClasses, parentCache, properties, listener, context) { IDictionary props = null; if (properties.Contains("indexes")) { props = properties["indexes"] as IDictionary; } _queryIndexManager = new QueryIndexManager(props, this, _context.CacheRoot.Name); if (!_queryIndexManager.Initialize()) _queryIndexManager = null; //+Numan16122014 _cacheStore.ISizableQueryIndexManager = _queryIndexManager; _cacheStore.ISizableEvictionIndexManager = _evictionPolicy; _cacheStore.ISizableExpirationIndexManager = _context.ExpiryMgr; _stats.MaxCount = _cacheStore.MaxCount; _stats.MaxSize = _cacheStore.MaxSize; //+Numan16122014 if (_context.PerfStatsColl != null) { if (_queryIndexManager != null) _context.PerfStatsColl.SetQueryIndexSize(_queryIndexManager.IndexInMemorySize); } }
/// <summary> /// Recupera as chaves selecionadas. /// </summary> /// <param name="cache">Instancia do cache de onde os itens estão inseridos.</param> /// <param name="evictSize"></param> /// <returns></returns> internal ArrayList GetSelectedKeys(CacheBase cache, long evictSize) { EvictionIndexEntry entry = null; ArrayList list = new ArrayList(); int num = 0; bool flag = false; long next = _head; if (_head != -1) { do { entry = _index[next] as EvictionIndexEntry; foreach (string str in entry.GetAllKeys()) { int itemSize = cache.GetItemSize(str); if (((num + itemSize) >= evictSize) && (num > 0)) { if ((evictSize - num) > ((itemSize + num) - evictSize)) { list.Add(str); } flag = true; break; } list.Add(str); num += itemSize; } next = entry.Next; }while (!flag && (next != -1)); } return(list); }
public scenario_structure_bsp(CacheBase Cache, CacheBase.IndexItem Tag) { cache = Cache; int Address = Tag.Offset; EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Reader.SeekTo(Address + 68); XBounds = new Range <float>(Reader.ReadSingle(), Reader.ReadSingle()); YBounds = new Range <float>(Reader.ReadSingle(), Reader.ReadSingle()); ZBounds = new Range <float>(Reader.ReadSingle(), Reader.ReadSingle()); #region Clusters Block Reader.SeekTo(Address + 172); int iCount = Reader.ReadInt32(); int iOffset = Reader.ReadInt32() - Tag.Magic; for (int i = 0; i < iCount; i++) { ModelSections.Add(new ModelSection(Cache, Tag, iOffset + 176 * i, null) { FacesIndex = i, VertsIndex = i, NodeIndex = 255 }); Clusters.Add(new Cluster(i)); } #endregion #region Shaders Block Reader.SeekTo(Address + 180); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Tag.Magic; for (int i = 0; i < iCount; i++) { Shaders.Add(new Halo2Xbox.render_model.Shader(Cache, iOffset + 32 * i)); } #endregion #region ModelParts Block Reader.SeekTo(Address + 328); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Tag.Magic; for (int i = 0; i < iCount; i++) { ModelSections.Add(new ModelSection(Cache, Tag, iOffset + 200 * i, BoundingBoxes) { FacesIndex = i + Clusters.Count, VertsIndex = i + Clusters.Count, NodeIndex = 255 }); } #endregion #region GeometryInstances Block Reader.SeekTo(Address + 336); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Tag.Magic; for (int i = 0; i < iCount; i++) { GeomInstances.Add(new InstancedGeometry(Cache, iOffset + 88 * i, Clusters.Count)); } #endregion }
public void LoadBSPTag(CacheBase Cache, CacheBase.IndexItem Tag) { cache = Cache; tag = Tag; sbsp = DefinitionsManager.sbsp(cache, tag); sbsp.BSPName = Path.GetFileNameWithoutExtension(tag.Filename + "." + tag.ClassCode); lblName.Text = sbsp.BSPName; if (cache.Version <= DefinitionSet.Halo2Vista) sbsp.LoadRaw(); isWorking = true; tvRegions.Nodes.Clear(); TreeNode ClusterNode = new TreeNode("Clusters") { Checked = true }; foreach (var clust in sbsp.Clusters) { if (sbsp.ModelSections[clust.SectionIndex].Submeshes.Count > 0) ClusterNode.Nodes.Add(new TreeNode(sbsp.Clusters.IndexOf(clust).ToString("D3")) { Tag = clust, Checked = true }); } if (ClusterNode.Nodes.Count > 0) tvRegions.Nodes.Add(ClusterNode); TreeNode IGnode = new TreeNode("Instances") { Checked = true }; foreach (var IG in sbsp.GeomInstances) { if (sbsp.ModelSections[IG.SectionIndex].Submeshes.Count > 0) IGnode.Nodes.Add(new TreeNode(IG.Name) { Tag = IG, Checked = true }); } if (IGnode.Nodes.Count > 0) tvRegions.Nodes.Add(IGnode); isWorking = false; }
public UsageBlock(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Usage = Cache.Strings.GetItemByID(Reader.ReadInt32()); }
public void WriteBehind(CacheBase internalCache, object[] keys, object[] values, CacheEntry[] entries, string source, string taskId, OpCode operationCode, WriteBehindAsyncProcessor.TaskState state) { if (_asyncWrites && (_context.DatasourceMgr._writeBehindAsyncProcess != null)) { _context.DatasourceMgr._writeBehindAsyncProcess.Enqueue(new BulkWriteBehindTask(internalCache, this, keys, values, entries, source, taskId, _myProvider, operationCode, state)); } }
public void WriteBehind(CacheBase internalCache, object key, CacheEntry entry, string source, string taskId, OpCode operationCode) { if (_asyncWrites && (_context.DatasourceMgr._writeBehindAsyncProcess != null)) { _context.DatasourceMgr._writeBehindAsyncProcess.Enqueue(new WriteBehindTask(internalCache, this, key, entry, source, taskId, _myProvider, operationCode)); } }
public RawEntry(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Reader.SeekTo(Address + 12); TagID = Reader.ReadInt32(); RawID = Reader.ReadInt32(); FixupOffset = Reader.ReadInt32(); FixupSize = Reader.ReadInt32(); Reader.ReadInt32(); LocationType = Reader.ReadInt16(); SegmentIndex = Reader.ReadInt16(); Reader.ReadInt32(); #region Resource Fixups Reader.SeekTo(Address + 40); int iCount = Reader.ReadInt32(); int iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) Fixups.Add(new ResourceFixup(Cache, iOffset + 8 * i)); #endregion #region Resource Definition Fixups Reader.SeekTo(Address + 52); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) DefinitionFixups.Add(new ResourceDefinitionFixup(Cache, iOffset + 8 * i)); #endregion }
public bitmap(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); #region Sequence Chunk Reader.SeekTo(Address + 60); int iCount = Reader.ReadInt32(); int iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) { Sequences.Add(new Sequence(Cache, iOffset + 60 * i)); } #endregion #region BitmapData Chunk Reader.SeekTo(Address + 68); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) { Bitmaps.Add(new BitmapData(Cache, iOffset + 116 * i)); } #endregion }
public HashedLocalCache(IDictionary cacheClasses, CacheBase parentCache, IDictionary properties, ICacheEventsListener listener, CacheRuntimeContext context, bool logEntries, ActiveQueryAnalyzer activeQueryAnalyzer) : base(cacheClasses, parentCache, properties, listener, context, activeQueryAnalyzer) { _logMgr = new OpLogManager(logEntries, context); _stats.LocalBuckets = new HashVector(1000); _cacheStore.ISizableBucketIndexManager = this; }
public Submesh(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Reader.ReadInt32(); ShaderIndex = Reader.ReadInt16(); Reader.SeekTo(Address + 0x48); FaceCount = Reader.ReadInt32() + 2; FaceOffset = Reader.ReadInt32(); Reader.SeekTo(Address + 0x58); VertexCount = Reader.ReadInt32(); Reader.ReadInt32(); Reader.ReadInt32(); VertOffset = Reader.ReadInt32(); Reader.Skip(3); int iCount = Reader.ReadByte(); for (int i = 0; i < iCount; i++) { LocalNodes.Add(Reader.ReadByte()); } }
/// <summary> /// Checks whether the given entity key indexes are cached. /// </summary> /// <param name="entityKeys">The list of pairs of entity keys and their indexes.</param> /// <param name="keyIndexes">The array of indexes of <paramref name="entityKeys"/> that have to be checked.</param> /// <param name="persister">The entity persister.</param> /// <param name="batchableCache">The batchable cache.</param> /// <param name="checkCache">Whether to check the cache or just return <see langword="false" /> for all keys.</param> /// <returns>An array of booleans that contains the result for each key.</returns> private bool[] AreCached(List <KeyValuePair <EntityKey, int> > entityKeys, int[] keyIndexes, IEntityPersister persister, CacheBase batchableCache, bool checkCache) { var result = new bool[keyIndexes.Length]; if (!checkCache || !persister.HasCache || !context.Session.CacheMode.HasFlag(CacheMode.Get)) { return(result); } var cacheKeys = new object[keyIndexes.Length]; var i = 0; foreach (var index in keyIndexes) { var entityKey = entityKeys[index].Key; cacheKeys[i++] = context.Session.GenerateCacheKey( entityKey.Identifier, persister.IdentifierType, entityKey.EntityName); } var cacheResult = batchableCache.GetMany(cacheKeys); for (var j = 0; j < result.Length; j++) { result[j] = cacheResult[j] != null; } return(result); }
public cache_file_resource_layout_table(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); #region Shared Cache Block Reader.SeekTo(Address + 12); int iCount = Reader.ReadInt32(); int iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) SharedCaches.Add(new SharedCache(Cache, iOffset + 264 * i)); #endregion #region Page Block Reader.SeekTo(Address + 24); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) Pages.Add(new Page(Cache, iOffset + 88 * i)); #endregion #region Segment Block Reader.SeekTo(Address + 48); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) Segments.Add(new Segment(Cache, iOffset + 24 * i)); #endregion }
private void PutCacheData(CacheBase cache, Dictionary <CacheKey, List <object> > cacheData) { foreach (var pair in cacheData) { cache.Put(pair.Key, pair.Value); } }
/// <summary> /// Overloaded constructor. Takes the properties as a map. /// </summary> /// <param name="cacheSchemes">collection of cache schemes (config properties).</param> /// <param name="properties">properties collection for this cache.</param> /// <param name="listener">cache events listener</param> /// <param name="timeSched">scheduler to use for periodic tasks</param> public LocalCache(IDictionary cacheClasses, CacheBase parentCache, IDictionary properties, ICacheEventsListener listener, CacheRuntimeContext context) : base(properties, parentCache, listener, context) { _stats.ClassName = "local-cache"; Initialize(cacheClasses, properties); }
private void RemoveCacheData(CacheBase cache, Dictionary <CacheKey, List <object> > cacheData) { foreach (var pair in cacheData) { cache.Remove(pair.Key); } }
public void Dispose() { CacheSnapshotPool.Instance.DiposeSnapshot(_pointer.Id, _cache); //Disposes the snapshot from pool for this particular pointer _cache = null; _pointer = null; _snapshot = null; }
public WebDavSqlStoreCollection GetCollection(IWebDavStoreCollection parentCollection, string path, String rootPath, Guid rootGuid) { var p = PrincipleFactory.Instance.GetPrinciple(FromType.WebDav); string userkey = p.UserProfile.SecurityObjectId.ToString(); CacheBase mc = GetCachedObject(path) as CacheBase; WebDavSqlStoreCollection itm = null; if (mc != null) { itm = mc.GetCachedObject(userkey) as WebDavSqlStoreCollection; } if (itm != null) { return(itm); } itm = new WebDavSqlStoreCollection(parentCollection, path, rootPath, rootGuid, Store); if (mc == null) { mc = new CacheBase(); mc.AddCacheObject(userkey, itm); AddCacheObject(path, mc); } else { mc.AddCacheObject(userkey, itm); } return(itm); }
/// <summary> /// Returns an array containing list of keys contained in the cache. Null if there are no /// keys or if timeout occurs. /// </summary> /// <param name="cache"></param> /// <param name="timeout"></param> /// <returns></returns> internal static object[] GetKeys(CacheBase cache, int timeout) { int index = 0; var keys = cache.Keys; object[] objects = null; if (keys.Length < 1) { return(objects); } cache.Sync.AcquireWriterLock(timeout); try { objects = new object[keys.Length]; foreach (var key in keys) { if (index > keys.Length) { break; } objects[index++] = key; } } finally { cache.Sync.ReleaseWriterLock(); } return(objects); }
public render_method_template(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); #region Usage Blocks Reader.SeekTo(Address + 72); int iCount = Reader.ReadInt32(); int iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) { ArgumentBlocks.Add(new ArgumentBlock(Cache, iOffset + 4 * i)); } #endregion #region Usage Blocks Reader.SeekTo(Address + 108); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) { UsageBlocks.Add(new UsageBlock(Cache, iOffset + 4 * i)); } #endregion }
public ShaderProperties(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); #region ShaderProperties Chunk int iCount = Reader.ReadInt32(); int iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) { ShaderMaps.Add(new ShaderMap(Cache, iOffset + 20 * i)); } #endregion #region Tiling Chunk Reader.SeekTo(Address + 12); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) { Tilings.Add(new Tiling(Cache, iOffset + 16 * i)); } #endregion }
/// <summary> /// Remove a node from the cluster. /// </summary> /// <param name="hostPort"></param> /// <returns></returns> public bool RemoveNode(string hostname, int port) { // Request Layout: // HostLen int // Host byte[] UTF8 string // Port int byte[] data = null; using (MemoryStream ms = new MemoryStream()) { BinaryWriter w = new BinaryWriter(ms); byte[] hostBytes = CacheBase.WriteHostName(hostname); w.Write(IPAddress.HostToNetworkOrder(hostBytes.Length)); w.Write(hostBytes); w.Write(IPAddress.HostToNetworkOrder(port)); w.Flush(); ms.Flush(); data = ms.ToArray(); } Request request = new Request(Request.Types.RemoveNode, data); var response = base.SendRequest(base.MasterHostName, base.MasterPort, request); if (response == null) { return(false); } return(response.Type != Response.Types.Accepted); }
public BitmapData(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Class = Reader.ReadString(4); Width = Reader.ReadInt16(); Height = Reader.ReadInt16(); Depth = Reader.ReadByte(); Flags = new Bitmask(Reader.ReadByte()); Type = (BitmapType)Reader.ReadByte(); Reader.ReadByte(); //dunno what this is Format = (BitmapFormat)Reader.ReadInt16(); if ((int)Format > 31) //change to match defined format list Format -= 5; MoreFlags = new Bitmask(Reader.ReadInt16()); RegX = Reader.ReadInt16(); RegY = Reader.ReadInt16(); MipmapCount = Reader.ReadByte(); Reader.ReadByte(); InterleavedIndex = Reader.ReadByte(); Index2 = Reader.ReadByte(); PixelsOffset = Reader.ReadInt32(); PixelsSize = Reader.ReadInt32(); }
public void LoadBitmapTag(CacheBase Cache, CacheBase.IndexItem Tag) { exportAllImagesToolStripMenuItem.Visible = true; cache = Cache; tag = Tag; bitm = DefinitionsManager.bitm(cache, tag); lstBitmaps.Items.Clear(); var list = GetBitmapsByTag(cache, tag, PixelFormat.Format32bppArgb); for (int i = 0; i < list.Count; i++) { var submap = bitm.Bitmaps[i]; lstBitmaps.Items.Add(new ListViewItem(new string[] { i.ToString(), submap.Width.ToString(), submap.Height.ToString(), submap.Type.ToString(), submap.Format.ToString() }) { Tag = (list[i] == null) ? GetErrorImage() : list[i] }); } lstBitmaps.FocusedItem = lstBitmaps.Items[0]; lstBitmaps_SelectedIndexChanged(null, null); }
public InstancedGeometry(CacheBase Cache, int Address, int modifier) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); TransformScale = Reader.ReadSingle(); TransformMatrix = new Matrix(); TransformMatrix.m11 = Reader.ReadSingle(); TransformMatrix.m12 = Reader.ReadSingle(); TransformMatrix.m13 = Reader.ReadSingle(); TransformMatrix.m21 = Reader.ReadSingle(); TransformMatrix.m22 = Reader.ReadSingle(); TransformMatrix.m23 = Reader.ReadSingle(); TransformMatrix.m31 = Reader.ReadSingle(); TransformMatrix.m32 = Reader.ReadSingle(); TransformMatrix.m33 = Reader.ReadSingle(); TransformMatrix.m41 = Reader.ReadSingle(); TransformMatrix.m42 = Reader.ReadSingle(); TransformMatrix.m43 = Reader.ReadSingle(); SectionIndex = Reader.ReadInt16() + modifier; Reader.SeekTo(Address + 80); Name = Cache.Strings.GetItemByID(Reader.ReadInt16()); }
public cache_file_resource_gestalt(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); #region Raw Entries Reader.SeekTo(Address + 36); int iCount = Reader.ReadInt32(); int iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) { RawEntries.Add(new RawEntry(Cache, iOffset + 96 * i)); } #endregion #region Fixup Data Reader.SeekTo(Address + 132); iCount = Reader.ReadInt32(); Reader.ReadInt32(); Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; Reader.SeekTo(iOffset); FixupData = Reader.ReadBytes(iCount); #endregion }
/// <summary> /// Copies the entries of a cache into an array. Used for state transfer. /// </summary> /// <param name="cache">cache object</param> /// <param name="count">number of entries to return</param> /// <returns>array of cache entries</returns> public static CacheEntry[] GetCacheEntries(CacheBase cache, long count) { long index = 0; CacheEntry[] entArr = null; CacheEntry ent = null; cache.Sync.AcquireReaderLock(Timeout.Infinite); try { if (count == 0 || count > cache.Count) { count = cache.Count; } entArr = new CacheEntry[count]; IDictionaryEnumerator i = cache.GetEnumerator(); while (index < count && i.MoveNext()) { ent = i.Value as CacheEntry; entArr[index++] = ent.RoutableClone(null); } } catch (Exception e) { cache.Context.NCacheLog.Error("CacheHelper.CreateLocalEntry()", e.Message); return(null); } finally { cache.Sync.ReleaseReaderLock(); } return(entArr); }
private object SubmitMapReduceTask(MapReduceOperation operation) { try { _context.NCacheLog.CriticalInfo("MapReduce.TaskTracker ", "MapReduce task with taskId '" + operation.TaskID + "' is submitted"); CacheBase p = (CacheBase)((_context.CacheImpl != null && _context.CacheImpl is CacheBase) ? _context.CacheImpl : null); Runtime.MapReduce.MapReduceTask userTask = (Runtime.MapReduce.MapReduceTask)operation.Data; Filter filter = operation.Filter; if (userTask != null) { MapReduceTask serverTask = new MapReduceTask(p, Callback, userTask.Mapper, userTask.Combiner, userTask.Reducer, userTask.InputProvider == null ? new InputProviders.CacheInputProvider(p.InternalCache, filter != null ? filter.QueryFilter : null, this._context) : userTask.InputProvider, new InMemoryOutpuProvider(taskOutputStore), filter, _context, this.ChunkSize, this.MaxExceptions); serverTask.TaskId = operation.TaskID; serverTask.AddTaskCallbackInfo(operation.CallbackInfo); return(this.SubmitTask(serverTask)); } } catch (Exception ex) { throw new OperationFailedException(ex.Message); } return(null); }
/// <summary> /// Overloaded constructor. Takes the properties as a map. /// </summary> /// <param name="cacheSchemes">collection of cache schemes (config properties).</param> /// <param name="properties">properties collection for this cache.</param> /// <param name="listener">cache events listener</param> /// <param name="timeSched">scheduler to use for periodic tasks</param> public LocalCache(IDictionary cacheClasses, CacheBase parentCache, IDictionary properties, ICacheEventsListener listener, CacheRuntimeContext context) : base(properties, parentCache, listener, context) { _stats.ClassName = "local-cache"; Initialize(cacheClasses, properties); }
//H2X, H3B, H3R, ODST, HRB, HRR, H4R public static bitmap bitm(CacheBase Cache, CacheBase.IndexItem Tag) { switch (Cache.Version) { case DefinitionSet.Halo1PC: return new Halo1PC.bitmap(Cache, Tag.Offset); case DefinitionSet.Halo1CE: return new Halo1CE.bitmap(Cache, Tag.Offset); case DefinitionSet.Halo2Xbox: return new Halo2Xbox.bitmap(Cache, Tag.Offset); case DefinitionSet.Halo3Beta: case DefinitionSet.Halo3Retail: case DefinitionSet.Halo3ODST: return new Halo3Beta.bitmap(Cache, Tag.Offset); case DefinitionSet.HaloReachBeta: return new ReachBeta.bitmap(Cache, Tag.Offset); case DefinitionSet.HaloReachRetail: case DefinitionSet.Halo4Beta: case DefinitionSet.Halo4Retail: return new ReachRetail.bitmap(Cache, Tag.Offset); default: throw new NotSupportedException(errorMessage.Replace("----", "bitm")); } }
public ArgumentBlock(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Argument = Cache.Strings.GetItemByID(Reader.ReadInt32()); }
public bink(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Reader.Skip(4); RawID = Reader.ReadInt32(); }
public static CommandContext Create(CommandContext parent, OpenTagCache info, CacheBase blamCache) { var context = new CommandContext(parent, blamCache.Build); context.AddCommand(new PortShaderCommand(info, blamCache)); context.AddCommand(new PortModelCommand(info, blamCache)); context.AddCommand(new ListBitmapsCommand(info, blamCache)); return context; }
public gbxmodel(CacheBase Cache, int Address) { cache = Cache; EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Name = "gbxmodel"; Flags = new Bitmask(Reader.ReadInt16()); Reader.SeekTo(Address + 0x30); uScale = Reader.ReadSingle(); vScale = Reader.ReadSingle(); #region MarkerGroups Block Reader.SeekTo(Address + 0xAC); int iCount = Reader.ReadInt32(); int iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) MarkerGroups.Add(new MarkerGroup(Cache, iOffset + 64 * i)); #endregion #region Nodes Block Reader.SeekTo(Address + 0xB8); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) Nodes.Add(new Node(Cache, iOffset + 156 * i)); #endregion #region Regions Block Reader.SeekTo(Address + 0xC4); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) Regions.Add(new Region(Cache, iOffset + 76 * i)); #endregion #region ModelParts Block Reader.SeekTo(Address + 0xD0); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) ModelSections.Add(new ModelSection(Cache, iOffset + 48 * i) { FacesIndex = i, VertsIndex = i, NodeIndex = 255 }); #endregion #region Shaders Block Reader.SeekTo(Address + 0xDC); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) Shaders.Add(new Shader(Cache, iOffset + 32 * i)); #endregion #region BoundingBox Block BoundingBoxes.Add(new BoundingBox()); #endregion }
public render_model(CacheBase Cache, int Address) { cache = Cache; EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Name = Cache.Strings.GetItemByID(Reader.ReadInt16()); //Flags = new Bitmask(Reader.ReadInt32()); #region BoundingBox Block Reader.SeekTo(Address + 20); int iCount = Reader.ReadInt32(); int iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) BoundingBoxes.Add(new BoundingBox(Cache, iOffset + 56 * i)); #endregion #region Regions Block Reader.SeekTo(Address + 28); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) Regions.Add(new Region(Cache, iOffset + 16 * i)); #endregion #region ModelParts Block Reader.SeekTo(Address + 36); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) ModelSections.Add(new ModelSection(Cache, iOffset + 92 * i) { FacesIndex = i, VertsIndex = i, NodeIndex = 255 }); Reader.SeekTo(Address + 72); #endregion #region Nodes Block iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) Nodes.Add(new Node(Cache, iOffset + 96 * i)); #endregion #region MarkerGroups Block Reader.SeekTo(Address + 88); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) MarkerGroups.Add(new MarkerGroup(Cache, iOffset + 12 * i)); #endregion #region Shaders Block Reader.SeekTo(Address + 96); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) Shaders.Add(new Shader(Cache, iOffset + 32 * i)); #endregion }
public Codec(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Unknown = Reader.ReadByte(); Type = (SoundType)Reader.ReadByte(); Flags = new Bitmask(Reader.ReadByte()); }
public PortShaderCommand(OpenTagCache info, CacheBase blamCache) : base(CommandFlags.None, "portshader", "", "portshader <blam tag path>", "") { Info = info; BlamCache = blamCache; }
public CacheHeader(CacheBase Cache) { cache = Cache; EndianReader Reader = cache.Reader; Reader.SeekTo(8); fileSize = Reader.ReadInt32(); Reader.ReadInt32(); indexOffset = Reader.ReadInt32(); }
public SoundPermutation(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); NameIndex = Reader.ReadInt16(); Reader.SeekTo(Address + 8); RawChunkIndex = Reader.ReadInt32(); ChunkCount = Reader.ReadInt16(); }
//---, ---, ---, ----, ---, ---, H4R public static bink bink(CacheBase Cache, CacheBase.IndexItem Tag) { switch (Cache.Version) { case DefinitionSet.Halo4Retail: return new Halo4Retail.bink(Cache, Tag.Offset); default: throw new NotSupportedException(errorMessage.Replace("----", "bink")); } }
public ShaderMap(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Reader.SeekTo(Address + 12); BitmapTagID = Reader.ReadInt32(); Type = Reader.ReadInt16(); Reader.ReadByte(); TilingIndex = Reader.ReadByte(); }
public sound(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Reader.SeekTo(Address + 12); SoundAddress1 = Reader.ReadUInt32(); SoundAddress2 = Reader.ReadUInt32(); Reader.SeekTo(Address + 52); SoundBankTagID = Reader.ReadInt32(); }
public multilingual_unicode_string_list(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Reader.SeekTo(Address + 32); for (int i = 0; i < 12; i++) { Indices.Add(Reader.ReadUInt16()); Lengths.Add(Reader.ReadUInt16()); } }
static CacheFactory() { if (cacheBase == null) { lock (typeof(CacheBase)) { if (cacheBase == null) { cacheBase = WebCache.Instance; } } } }
private CacheManager() { switch (_storeType) { case StoreType.File: _cache = new FileCache(); break; case StoreType.SqLite: _cache = new SqliteCache(); break; default: throw new Exception(string.Format("CacheManager .ctor failed: {0} type not handled", _storeType)); } }
public Segment(CacheBase Cache, int Offset) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Offset); RequiredPageIndex = Reader.ReadInt16(); OptionalPageIndex = Reader.ReadInt16(); OptionalPageIndex2 = -1; //doesn't exist till Halo4 RequiredPageOffset = Reader.ReadInt32(); OptionalPageOffset = Reader.ReadInt32(); OptionalPageOffset2 = -1; //doesn't exist till Halo4 SoundNumber = Reader.ReadInt16(); SoundRawIndex = Reader.ReadInt16(); }
public ShaderProperties(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); TemplateTagID = -1; Reader.SeekTo(Address + 20); #region Tiling Chunk int iCount = Reader.ReadInt32(); int iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) Tilings.Add(new Tiling(Cache, iOffset + 16 * i)); #endregion }
public material(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Reader.SeekTo(Address + 12); BaseShaderTagID = Reader.ReadInt32(); #region ShaderProperties Chunk Reader.SeekTo(Address + 28); int iCount = Reader.ReadInt32(); int iOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < iCount; i++) Properties.Add(new ShaderProperties(Cache, iOffset + 140 * i)); #endregion }
public shader(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Reader.SeekTo(Address + 12); BaseShaderTagID = Reader.ReadInt32(); #region ShaderProperties Chunk Reader.SeekTo(Address + 56); int pCount = Reader.ReadInt32(); int pOffset = Reader.ReadInt32() - Cache.Magic; for (int i = 0; i < pCount; i++) Properties.Add(new ShaderProperties(Cache, pOffset + 172 * i)); #endregion }
public sound(CacheBase Cache, int Address) { EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Flags = new Bitmask(Reader.ReadInt16()); SoundClass = Reader.ReadByte(); SampleRate = (SampleRate)Reader.ReadByte(); Encoding = Reader.ReadByte(); CodecIndex = Reader.ReadByte(); PlaybackIndex = Reader.ReadInt16(); DialogueUnknown = Reader.ReadInt16(); Reader.SeekTo(Address + 28); RawID = Reader.ReadInt32(); }
public scenario_structure_bsp(CacheBase Cache, CacheBase.IndexItem Tag) { cache = Cache; int Address = Tag.Offset; EndianReader Reader = Cache.Reader; Reader.SeekTo(Address); Reader.SeekTo(Address + 68); XBounds = new Range<float>(Reader.ReadSingle(), Reader.ReadSingle()); YBounds = new Range<float>(Reader.ReadSingle(), Reader.ReadSingle()); ZBounds = new Range<float>(Reader.ReadSingle(), Reader.ReadSingle()); #region Clusters Block Reader.SeekTo(Address + 172); int iCount = Reader.ReadInt32(); int iOffset = Reader.ReadInt32() - Tag.Magic; for (int i = 0; i < iCount; i++) { ModelSections.Add(new ModelSection(Cache, Tag, iOffset + 176 * i, null) { FacesIndex = i, VertsIndex = i, NodeIndex = 255 }); Clusters.Add(new Cluster(i)); } #endregion #region Shaders Block Reader.SeekTo(Address + 180); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Tag.Magic; for (int i = 0; i < iCount; i++) Shaders.Add(new Halo2Xbox.render_model.Shader(Cache, iOffset + 32 * i)); #endregion #region ModelParts Block Reader.SeekTo(Address + 328); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Tag.Magic; for (int i = 0; i < iCount; i++) ModelSections.Add(new ModelSection(Cache, Tag, iOffset + 200 * i, BoundingBoxes) { FacesIndex = i + Clusters.Count, VertsIndex = i + Clusters.Count, NodeIndex = 255 }); #endregion #region GeometryInstances Block Reader.SeekTo(Address + 336); iCount = Reader.ReadInt32(); iOffset = Reader.ReadInt32() - Tag.Magic; for (int i = 0; i < iCount; i++) GeomInstances.Add(new InstancedGeometry(Cache, iOffset + 88 * i, Clusters.Count)); #endregion }