public void StoreQuestion(Question question) { using (var redis = RedisManager.GetClient()) { var redisQuestions = redis.As <Question>(); if (question.Tags == null) { question.Tags = new List <string>(); } if (question.Id == default(long)) { question.Id = redisQuestions.GetNextSequence(); question.CreatedDate = DateTime.UtcNow; //Increment the popularity for each new question tag question.Tags.ForEach(tag => redis.IncrementItemInSortedSet(TagIndex.All, tag, 1)); } redisQuestions.Store(question); redisQuestions.AddToRecentsList(question); redis.AddItemToSet(UserQuestionIndex.Questions(question.UserId), question.Id.ToString()); //Populate tag => questions index for each tag question.Tags.ForEach(tag => redis.AddItemToSet(TagIndex.Questions(tag), question.Id.ToString())); } }
/// <summary> /// Delete question by performing compensating actions to StoreQuestion() to keep the datastore in a consistent state /// </summary> /// <param name="questionId"></param> public void DeleteQuestion(long questionId) { using (var redis = RedisManager.GetClient()) { var redisQuestions = redis.As <Question>(); var question = redisQuestions.GetById(questionId); if (question == null) { return; } //decrement score in tags list question.Tags.ForEach(tag => redis.IncrementItemInSortedSet(TagIndex.All, tag, -1)); //remove all related answers redisQuestions.DeleteRelatedEntities <Answer>(questionId); //remove this question from user index redis.RemoveItemFromSet(UserQuestionIndex.Questions(question.UserId), questionId.ToString()); //remove tag => questions index for each tag question.Tags.ForEach(tag => redis.RemoveItemFromSet(TagIndex.Questions(tag), questionId.ToString())); redisQuestions.DeleteById(questionId); } }
internal void LoadTagDatums(TagIndex tagIndex) { var classes = tagIndex.ClassHeirarchies.Select(x => x.Class); treeView1.SuspendLayout( ); foreach (var tagClass in classes) { var tags = tagIndex.Where(tagClass).ToArray( ); if (tags.Length <= 0) { continue; } var node = new TreeNode(tagClass.ToString( )); var childrenNodes = new TreeNode[tags.Length]; for (var index = 0; index < tags.Length; index++) { var tagDatum = tags[index]; childrenNodes[index] = new TreeNode(tagDatum.Path) { Tag = tagDatum }; } node.Nodes.AddRange(childrenNodes); treeView1.Nodes.Add(node); } treeView1.ResumeLayout( ); }
/// <summary> /// Halo1 export interface class constructor /// </summary> /// <param name="tag_index">Tag index containing the tag being exported</param> /// <param name="tag_datum">DatumIndex of the tag being exported</param> public ColladaHalo1(TagIndex tag_index, DatumIndex tag_datum) { tagIndex = tag_index; tagManager = tag_index[tag_datum]; GenerateInfoList(); }
///------------------------------------------------------------------------------------------------- /// <summary> Creates the node list. </summary> ///------------------------------------------------------------------------------------------------- private void CreateNodeList() { // Get all of the object instances to include var objectInstances = mScenarioDataProvider.GetObjectInstances(); for (int i = 0; i < objectInstances.Count; i++) { var objectInstance = objectInstances[i]; // Create a node for the object instance ColladaNCName nodeName = ""; if (objectInstance.ObjectName == null) { if (!TagIndex.IsValid(objectInstance.ObjectType.ObjectTagDatum)) { throw new ColladaException("Failed to load the object type tag {0}", objectInstance.ObjectType.ObjectTagPath); } ColladaNCName objectName = Path.GetFileNameWithoutExtension(mTagIndex[objectInstance.ObjectType.ObjectTagDatum].Name); nodeName = i.ToString() + "-" + objectName; } else { nodeName = objectInstance.ObjectName.Name; } var node = CreateNode(nodeName, "", "", Enums.ColladaNodeType.NODE); // Set the nodes position var translate = new Core.ColladaTranslate(); translate.SetTranslate(objectInstance.Position, 100); node.Add(translate); // Set the nodes rotation node.AddRange( ColladaUtilities.CreateRotationSet(objectInstance.Rotation.R, objectInstance.Rotation.P, objectInstance.Rotation.Y , new LowLevel.Math.real_vector3d(1, 0, 0) , new LowLevel.Math.real_vector3d(0, -1, 0) , new LowLevel.Math.real_vector3d(0, 0, 1) , ColladaUtilities.ColladaRotationOrder.XYZ) ); var nodeIdList = GetNodeReferences(objectInstance.ObjectType, objectInstance.Permutation.ToString("D2")); if (nodeIdList.Count > 0) { node.InstanceNode = new List <ColladaInstanceNode>(); foreach (var nodeId in nodeIdList) { node.InstanceNode.Add(new ColladaInstanceNode() { URL = "#" + nodeId }); } } listNode.Add(node); } }
public List <QuestionResult> GetQuestionsTaggedWith(string tagName) { using var redis = RedisManager.GetReadOnlyClient(); var questionIds = redis.GetAllItemsFromSet(TagIndex.Questions(tagName)); var questions = redis.As <Question>().GetByIds(questionIds); return(ToQuestionResults(questions)); }
public TagsController(EventStoreService eventStore, CacheDatabaseManager db, InMemoryCache cache) { _eventStore = eventStore; _db = db; _entityIndex = cache.Index <EntityIndex>(); _mediaIndex = cache.Index <MediaIndex>(); _tagIndex = cache.Index <TagIndex>(); _referencesIndex = cache.Index <ReferencesIndex>(); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting /// unmanaged resources. /// </summary> public void Dispose() { if (TagIndex.IsValid(mIndexHandle)) { BlamLib.Program.GetManager(mGameVersion).CloseTagIndex(mIndexHandle); mIndexInterface = null; mIndexHandle = DatumIndex.Null; } }
private Module(string fileName, Module parentModule) { FileName = fileName; using (var reader = CreateReader()) { Header = reader.ReadObject <ModuleHeader>(); Items = new List <ModuleItem>(Header.ItemCount); for (int i = 0; i < Header.ItemCount; i++) { Items.Add(reader.ReadObject <ModuleItem>((int)Header.Version)); } var origin = reader.BaseStream.Position; Strings = new Dictionary <int, string>(); while (reader.BaseStream.Position < origin + Header.StringsSize) { Strings.Add((int)(reader.BaseStream.Position - origin), reader.ReadNullTerminatedString()); } Resources = new List <int>(Header.ResourceCount); for (int i = 0; i < Header.ResourceCount; i++) { Resources.Add(reader.ReadInt32()); } Blocks = new List <Block>(Header.BlockCount); for (int i = 0; i < Header.BlockCount; i++) { Blocks.Add(reader.ReadObject <Block>((int)Header.Version)); } DataAddress = reader.BaseStream.Position; tagIndex = parentModule?.tagIndex ?? new TagIndex(Items); linkedModules = parentModule?.linkedModules ?? new List <Module>(Enumerable.Repeat(this, 1)); } }
private void LuceneInitIndex(Dictionary <TagNodeKey, List <TagNode> > tags) { if (bool.Parse(AppSettingCache.Instance["TagSearchAct"])) { Thread thread = new Thread(state => { if (!_indexlock.TryEnter()) { return; } try { _log.Info("TagCache开始建立LuceneNet索引"); var dic = TagLuceneNet.Instance.Init(); foreach (var kv in tags) { foreach (var tag in kv.Value) { TagIndex.AddTag(tag, kv.Key.Dimension, dic); } } TagLuceneNet.Instance.CompleteIndex(dic); _log.Info("TagCache索引建立完成"); } catch (Exception ex) { _log.Error(ex); } finally { _indexlock.Exit(); } }); thread.Start(); } }
/// <summary> /// Retrieves a reference to a tag stored in the runtime asset. /// </summary> /// <param name="tagIndex">The tag index to retrieve the reference for.</param> /// <returns>Tag reference that corresponds to the index passed as argument.</returns> public ref Tag GetTag(TagIndex tagIndex) { Assert.IsTrue(tagIndex < numTags); return(ref tags[tagIndex]); }
/// <summary> /// Determines whether two tag indices are equal. /// </summary> /// <param name="tagIndex">The index to compare against the current index.</param> /// <returns>True if the specified index is equal to the current index; otherwise, false.</returns> public bool Equals(TagIndex tagIndex) { return(value == tagIndex.value); }
private List <string> GetNodeReferences(ScenarioData.ScenarioObject objectType, string permutation) { var nodeIds = new List <string>(); // Add geometry instances to the node if (!TagIndex.IsValid(objectType.ObjectTagDatum)) { throw new ColladaException("Failed to load the object type tag {0}", objectType.ObjectTagPath); } var objectName = Path.GetFileNameWithoutExtension(objectType.ObjectTagPath); objectName += "-perm" + permutation; // Collect data about the object var objectData = new ObjectData(); objectData.CollectData(mTagIndex, mTagIndex[objectType.ObjectTagDatum]); if (!TagIndex.IsValid(objectData.Model)) { return(nodeIds); } if (COLLADAFile.LibraryNodes == null) { AddLibraryNodes(); } // Collect data about the model var modelData = new ModelData(); modelData.CollectData(mTagIndex, mTagIndex[objectData.Model]); // Get all of the geometries that make up the permutation at the highest lod var geometryList = modelData.GetGeometries(permutation, Blam.Halo1.TypeEnums.LevelOfDetailEnum.SuperHigh); // Add geometry instances for all geometries foreach (var geometrySet in geometryList) { var name = objectName + "-" + geometrySet.Name; ColladaNCName nodeName = name; ColladaID <ColladaNode> nodeId = name; nodeIds.Add(nodeId); if (COLLADAFile.LibraryNodes.Node.Exists(node => node.ID == nodeId.ToString())) { break; } // Create shader references for all shaders used by the geometry var materialReferences = new MaterialReferenceList(); foreach (var shader in geometrySet.Shaders) { ColladaNCName symbolName = shader.MaterialName; ColladaID <Fx.ColladaMaterial> shaderName = shader.MaterialName; var url = ColladaUtilities.BuildExternalReference(modelData, colladaSettings.RootDirectory, shaderName); materialReferences.Add(new MaterialReference(shaderName, url, symbolName)); } // Build the geometry reference URL and add the geometry instance string geometryURL = ColladaUtilities.BuildExternalReference(modelData, colladaSettings.RootDirectory, new ColladaID <Core.ColladaGeometry>(geometrySet.Name)); var nodeType = CreateNode(nodeName, "", nodeId, Enums.ColladaNodeType.NODE); nodeType.Add(CreateInstanceGeometry(geometryURL, geometrySet.Name, materialReferences)); COLLADAFile.LibraryNodes.Node.Add(nodeType); } return(nodeIds); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> Exports the provided bsp's lightmap sizes with a multiplier. </summary> /// /// <param name="tagIndex"> Tag index the bsp belongs to. </param> /// <param name="tagManager"> The bsp tag's manager. </param> /// <param name="sizeMultiplier"> The lightmap size multiplier. </param> /// <param name="outputFile"> The bsp's output file. </param> public void Export(TagIndexBase tagIndex, BlamLib.Managers.TagManager tagManager, int sizeMultiplier, string outputFile) { // Collect the necessary data var structureBSP = tagManager.TagDefinition as BlamLib.Blam.Halo1.Tags.structure_bsp_group; if (!TagIndex.IsValid(structureBSP.LightmapBitmaps.Datum)) { mMessageHandler.SendMessage("Failed to open lightmap bitmap {0}", structureBSP.LightmapBitmaps.ToString()); return; } var bitmapManager = tagIndex[structureBSP.LightmapBitmaps.Datum]; if (bitmapManager == null) { mMessageHandler.SendMessage("Failed to open lightmap bitmap {0}", structureBSP.LightmapBitmaps.ToString()); return; } if (structureBSP.Lightmaps.Count == 0) { mMessageHandler.SendMessage("BSP has no lightmaps {0}", tagManager.Name); return; } var bitmap = bitmapManager.TagDefinition as BlamLib.Blam.Halo1.Tags.bitmap_group; if (bitmap == null) { mMessageHandler.SendMessage("Failed to open lightmap bitmap {0}", structureBSP.LightmapBitmaps.ToString()); return; } // Build the lightmap size list var lightmapSizeList = new List <string>(); var bspName = Path.GetFileNameWithoutExtension(tagManager.Name); foreach (var lightmap in structureBSP.Lightmaps) { if (lightmap.Bitmap.Value == -1) { continue; } if (lightmap.Bitmap.Value >= bitmap.Bitmaps.Count) { mMessageHandler.SendMessage("Failed to export lightmap sizes. A lightmap bitmap and bsp do not have matching lightmap counts {0}", tagManager.Name); return; } var bitmapInfo = bitmap.Bitmaps[lightmap.Bitmap.Value]; lightmapSizeList.Add(String.Format("{0}_{1}\t[{2},{3}]" , bspName , lightmap.Bitmap.Value , bitmapInfo.Width * sizeMultiplier , bitmapInfo.Height * sizeMultiplier)); } // Save the sizes to file var sizeFileName = Path.ChangeExtension(outputFile, "lmsz"); try { using (var outputStream = File.OpenWrite(sizeFileName)) { var writer = new StreamWriter(outputStream); writer.Write(String.Join("\r\n", lightmapSizeList)); writer.Flush(); } mMessageHandler.SendMessage("BSP lightmap sizes saved"); } catch (IOException) { mMessageHandler.SendMessage("Failed to open the lightmap sizes file"); } }