public void AddExample() { var whatAnimalEatHashList = new HashList<string, string>(); whatAnimalEatHashList.Add("cat", "milk"); whatAnimalEatHashList.Add("cat", "fish"); whatAnimalEatHashList.Add("dog", "dog food"); whatAnimalEatHashList.Add("dog", "bones"); whatAnimalEatHashList.Add("tiger", "people"); // There should be 3 items. Assert.AreEqual(3, whatAnimalEatHashList.Count); }
public void AddParamsExample() { var whatAnimalEatHashList = new HashList<string, string>(); whatAnimalEatHashList.Add("cat", "milk", "fish"); whatAnimalEatHashList.Add("dog", "dog food", "bones"); whatAnimalEatHashList.Add("tiger", "people"); // There are 3 keys. Assert.AreEqual(3, whatAnimalEatHashList.KeyCount); // There are 5 values. Assert.AreEqual(5, whatAnimalEatHashList.ValueCount); }
public override PathCond Or(PathCond other) { if (other is CachedAtom && conds.Contains(((CachedAtom)other).Negate())) { // Reduce Or(OR(...,e,...), NOT(e)) and Or(OR(...,NOT(e),...), e) to TRUE return TRUE; } else if (other is Disj) { HashList<PathCond> result = new HashList<PathCond>(); result.AddAll(conds); foreach (PathCond cond in ((Disj)other).conds) { if (cond is CachedAtom && conds.Contains((cond as CachedAtom).Negate())) { // Reduce Or(OR(...,e,...),OR(...,NOT(e),...)) to TRUE // and Or(OR(...,NOT(e),...),OR(...,e,...)) to TRUE return TRUE; } result.Add(cond); } return Disj.Make(result.ToArray()); } else if (other is Conj) { if (((Conj)other).conds.Contains(this)) { // Reduce (pi | (p1 & ... & pn)) to pi return this; } else { if (((Conj)other).conds.Any(cond => conds.Contains(cond))) { return this; } } return Disj.Make(AddItem(this.conds, other)); } else { return Disj.Make(AddItem(this.conds, other)); } }
public void Simple() { var hashList = new HashList<int, string> {{2, "a"}}; Assert.AreEqual(hashList.ValueCount, 1); Assert.AreEqual(hashList.KeyCount, 1); hashList.Add(4, new List<string>(new[] { "2", "3", "4", "5" })); Assert.AreEqual(hashList.ValueCount, 5); Assert.AreEqual(hashList.KeyCount, 2); var enumerator = hashList.GetValueEnumerator(); var list = new List<string>(); while (enumerator.MoveNext()) { list.Add(enumerator.Current); } Assert.AreEqual(list.Count, 5); Assert.IsTrue(list.Contains("a")); Assert.IsTrue(list.Contains("2")); Assert.IsTrue(list.Contains("3")); Assert.IsTrue(list.Contains("4")); Assert.IsTrue(list.Contains("5")); }
public void Params() { var hashList = new HashList<int, string> { {2, "a", "b"} }; Assert.AreEqual(hashList.ValueCount, 2); Assert.AreEqual(hashList.KeyCount, 1); hashList.Add(4, "2", "3", "4", "5"); Assert.AreEqual(hashList.ValueCount, 6); Assert.AreEqual(hashList.KeyCount, 2); hashList.Add(2, "2", "3", "4", "5"); Assert.AreEqual(hashList.ValueCount, 10); Assert.AreEqual(hashList.KeyCount, 2); }
public void Simple() { var hashList = new HashList<int, string> { {2, "a"} }; Assert.AreEqual(hashList.ValueCount, 1); Assert.AreEqual(hashList.KeyCount, 1); hashList.Add(4, new List<string>(new[] { "2", "3", "4", "5" })); Assert.AreEqual(hashList.ValueCount, 5); Assert.AreEqual(hashList.KeyCount, 2); hashList.Add(2, new List<string>(new[] { "2", "3", "4", "5" })); Assert.AreEqual(hashList.ValueCount, 9); Assert.AreEqual(hashList.KeyCount, 2); }
public static PathCond Make(params PathCond[] conjs) { HashList<PathCond> result = new HashList<PathCond>(); foreach (PathCond conj in conjs) { if (conj.Is(false)) { return FALSE; } else if (!conj.Is(true)) { result.Add(conj); } } if (result.Count == 0) { return TRUE; } else if (result.Count == 1) { return result.Single(); } else { return new Conj(result.ToArray()); } }
// Use this for initialization void Start () { list = new List<HashList<int>>(); for (int i = 0; i < 1000; i++) { var hash = new HashList<int>(15000); for (int j = 0; j < 10000; j++) { hash.Add(Random.Range(int.MinValue, int.MaxValue)); } } var set = new HashList<int>(); Debug.Log("Add 1 " + set.Add(1)); Debug.Log("Add 1 " + set.Add(1)); set.Add(30000); set.Add(444); Debug.Log("Add 5555 " + set.Add(5555)); set.Add(500000); set.Add(364892679); set.Remove(444); Debug.Log("Set contains 444 = " + set.Contains(444)); Debug.Log("Size = " + set.Count); foreach (var i in set) { Debug.Log("Set contains " + i + " = " + set.Contains(i)); } Debug.Log("Set contains 11 = " + set.Contains(11)); Debug.Log("Set contains 23 = " + set.Contains(23)); Debug.Log("Set contains 16 = " + set.Contains(16)); Debug.Log("Set contains 32 = " + set.Contains(32)); Debug.Log("Set contains 33 = " + set.Contains(33)); }
internal void Add(ArbiterKey key, Arbiter arbiter) { keysSortedList.Add(key); dictionaryKeys.Add(key, arbiter); }
private void Change(BuildAssembly assembly) { var module = (BuildModule)assembly.Module; var strings = new HashList <string>(); MainType.Create(assembly); if (assembly.EncryptIL) { strings.Add("."); // Dot is at index 0 } if (_evaluationPeriodInDays > 0) { module.MainType.GenerateCheckForExpiredEvaluation(_evaluationPeriodInDays); } if (assembly.StripObfuscationAttributeExists) { ObfuscationAttributeStripper.Strip(assembly); } if (assembly.SuppressILdasm) { CA.SuppressIldasmAttribute.AddIfNotExists(assembly.CustomAttributes); } if (assembly.RenameMembers || assembly.DevirtualizeMethods) { ExplicitMethodCallBuilder.Build(assembly); } if (CancellationPending) { return; } if (_renameAssemblies) { MemberRenameHelper.BuildRenamedAssemblyResolver(assembly, _renamedAssemblyNames); } if (assembly.HasWpfResource && (_renameAssemblies || _renameMembers)) { BamlMemberReferenceMapper.Map(assembly, _log); } if (assembly.HasWpfResource && _renameAssemblies) { ResourceHelper.RenameWpfResource(assembly); } if (_renameAssemblies) { ResourceHelper.RenameSatelliteAssemblies(assembly); } if (assembly.ObfuscateResources) { ResourceObfuscator.Obfuscate(assembly); } if (_obfuscateResources) { ResourceResolverGenerator.Generate(assembly); } if (assembly.ObfuscateStrings) { StringObfuscator.Obfuscate(assembly, strings); } if (CancellationPending) { return; } if (assembly.SealTypes) { TypeSealer.Seal(assembly); } if (assembly.DevirtualizeMethods) { MethodDevirtualizer.Devirtualize(assembly); } if (CancellationPending) { return; } if (_renameMembers) { ExplicitMethodOverrideBuilder.Build(assembly, _nameGenerator); } if (_encryptIL) { ILCryptoMapper.Map(assembly); } if (assembly.EncryptIL) { ILCryptoObfuscator.Obfuscate(assembly, strings); } if (CancellationPending) { return; } if (assembly.RemoveUnusedMembers) { Stripper.Strip(assembly); } if (assembly.ObfuscateControlFlow) { ControlFlowObfuscator.Obfuscate(assembly, true); } if (strings.Count > 0) { StringLoaderGenerator.Generate(assembly, strings); } if (CancellationPending) { return; } // From this point no more code can be added. MainType.Generate(assembly); DelegateTypeGenerator.Generate(assembly); GeneratedCodeObfuscator.Obfuscate(assembly, _nameGenerator); if (CancellationPending) { return; } ILCryptoBlobBuilder.MapMemberReferences(assembly); MemberReferenceMapper.Map(assembly); MemberNameChanger.Change(assembly); if (CancellationPending) { return; } assembly.Compile(); Scavenge(); }
/// <summary> /// Create an automatic constructor to set all fields /// </summary> /// <param name="type">Type node</param> private void GenerateAutoCtor(TypeNode type) { var node = new MethodNode(".ctor", new SignatureNode("void"), false); var parameters = new HashList<ParameterNode>(); int idx = 0; foreach(var curr in type.Fields) { var param = new ParameterNode("_" + curr, type.Fields[curr].Type, idx); parameters.Add("_" + curr, param); idx++; var assignNode = new IdentifierSetNode(curr, true); assignNode.Expression = new IdentifierGetNode("_" + curr); node.Body.Statements.Add(assignNode); } node.SetParameters(parameters); node.Owner = type; AddMethod(type, node); }
/// <summary> /// Create an automatic .Equal() method /// </summary> /// <param name="type">Type node</param> private void GenerateAutoComparator(TypeNode type) { var node = new MethodNode("equal", new SignatureNode("bool"), false); // define parameter var parameters = new HashList<ParameterNode>(); var param = new ParameterNode("_obj", new SignatureNode(type.Name), 0); parameters.Add(param.Name, param); // generate series of comparisons foreach(var curr in type.Fields) { // // if(@<name> != _obj.<name>) return false; // node.Body.Statements.Add( Expr.If( Expr.Compare( Expr.IdentifierGet(curr, true), Lexer.LexemType.NotEqual, Expr.IdentifierGet(curr, Expr.IdentifierGet("_obj")) ), Expr.Return( Expr.Bool(true) ) ) ); } // return true node.Body.Statements.Add( Expr.Return( Expr.Bool(true) ) ); node.SetParameters(parameters); node.Owner = type; AddMethod(type, node); }
public void Simple() { var hashList = new HashList<int, string> {{2, "a"}}; Assert.AreEqual(hashList.ValueCount, 1); Assert.AreEqual(hashList.KeyCount, 1); hashList.Add(4, new List<string>(new[] { "2", "3", "4", "5" })); Assert.AreEqual(hashList.ValueCount, 5); Assert.AreEqual(hashList.KeyCount, 2); Assert.IsTrue(hashList.Remove(2)); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 4); Assert.IsFalse(hashList.Remove(2)); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 4); Assert.IsTrue(hashList.RemoveValue("2")); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 3); Assert.IsFalse(hashList.Remove(3, "2")); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 3); Assert.IsFalse(hashList.Remove(4, "2")); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 3); Assert.IsTrue(hashList.Remove(4, "5")); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 2); hashList.Add(4, "4"); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 3); hashList.RemoveAll("4"); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 1); Assert.IsFalse(hashList.Remove(10)); hashList.Add(4, "5"); hashList.Add(4, "6"); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 3); Assert.IsTrue(hashList.RemoveValue("5")); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 2); Assert.IsFalse(hashList.RemoveValue("5")); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 2); }
public void Add_Valid_Adds() { hashList.Add(new Dummy()); Assert.IsNotEmpty(hashList); }
public void DefineGetAllInstancesMethod(TypeDefinition containerType, ModuleDefinition module, IDictionary<IDependency, IImplementation> serviceMap) { var targetMethods = new List<MethodDefinition>(); foreach (MethodDefinition method in containerType.Methods) { if (method.Name != "GetAllInstances") continue; targetMethods.Add(method); } var getAllInstancesMethod = targetMethods[0]; // Remove the stub implementation var body = getAllInstancesMethod.Body; var IL = body.GetILProcessor(); body.InitLocals = true; body.Instructions.Clear(); var listVariable = getAllInstancesMethod.AddLocal<List<object>>(); var listCtor = module.ImportConstructor<List<object>>(); IL.Emit(OpCodes.Newobj, listCtor); IL.Emit(OpCodes.Stloc, listVariable); // Group the dependencies by type var dependenciesByType = new HashList<System.Type, IDependency>(); foreach (var dependency in serviceMap.Keys) { var serviceType = dependency.ServiceType; dependenciesByType.Add(serviceType, dependency); } var getTypeFromHandleMethod = typeof(System.Type).GetMethod("GetTypeFromHandle", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static); var getTypeFromHandle = module.Import(getTypeFromHandleMethod); var addItem = module.ImportMethod<List<object>>("Add"); var currentService = getAllInstancesMethod.AddLocal<object>(); foreach (var currentType in dependenciesByType.Keys) { var currentTypeRef = module.Import(currentType); var currentList = dependenciesByType[currentType]; if (currentList.Count == 0) continue; var skipAdd = IL.Create(OpCodes.Nop); IL.Emit(OpCodes.Ldarg_1); IL.Emit(OpCodes.Ldtoken, currentTypeRef); IL.Emit(OpCodes.Call, getTypeFromHandle); IL.Emit(OpCodes.Ceq); IL.Emit(OpCodes.Brfalse, skipAdd); foreach (var dependency in currentList) { IL.Emit(OpCodes.Ldloc, listVariable); var implementation = serviceMap[dependency]; implementation.Emit(dependency, serviceMap, getAllInstancesMethod); IL.Emit(OpCodes.Stloc, currentService); // Call IInitialize.Initialize(container) on the current service type _initializer.Initialize(IL, module, currentService); IL.Emit(OpCodes.Ldloc, currentService); IL.Emit(OpCodes.Callvirt, addItem); } IL.Append(skipAdd); } var skipOtherContainerCall = IL.Create(OpCodes.Nop); var getNextContainer = module.ImportMethod<IMicroContainer>("get_NextContainer"); var otherContainer = getAllInstancesMethod.AddLocal<IMicroContainer>(); // var otherContainer = this.NextContainer; IL.Emit(OpCodes.Ldarg_0); IL.Emit(OpCodes.Callvirt, getNextContainer); IL.Emit(OpCodes.Stloc, otherContainer); // if (otherContainer != null && this != otherContainer) { IL.Emit(OpCodes.Ldloc, otherContainer); IL.Emit(OpCodes.Brfalse, skipOtherContainerCall); IL.Emit(OpCodes.Ldloc, otherContainer); IL.Emit(OpCodes.Ldarg_0); IL.Emit(OpCodes.Ceq); IL.Emit(OpCodes.Brtrue, skipOtherContainerCall); // var otherInstances = NextContainer.GetAllInstances(type); var otherGetAllInstancesMethod = module.ImportMethod<IMicroContainer>("GetAllInstances"); IL.Emit(OpCodes.Ldloc, listVariable); IL.Emit(OpCodes.Ldloc, otherContainer); IL.Emit(OpCodes.Ldarg_1); IL.Emit(OpCodes.Callvirt, otherGetAllInstancesMethod); // resultList.AddRange(otherInstances); var addRangeMethod = module.ImportMethod<List<object>>("AddRange"); IL.Emit(OpCodes.Callvirt, addRangeMethod); // } // Cast the results down to an IEnumerable<object> var enumerableType = module.ImportType<IEnumerable<object>>(); IL.Append(skipOtherContainerCall); IL.Emit(OpCodes.Ldloc, listVariable); IL.Emit(OpCodes.Isinst, enumerableType); IL.Emit(OpCodes.Ret); }
/// <summary> /// Creates a new method with argument types given by function arguments. /// </summary> internal MethodEntity CreateMethod(string name, TypeSignature returnType, IEnumerable<FunctionArgument> args = null, bool isStatic = false, bool isVirtual = false, bool prepare = false) { var argHash = new HashList<FunctionArgument>(); if(args != null) foreach (var curr in args) argHash.Add(curr.Name, curr); var me = createMethodCore(name, isStatic, isVirtual, prepare); me.ReturnTypeSignature = returnType; me.Arguments = argHash; return me; }
/// <summary> /// Find or create an output file for a corresponding input file /// </summary> /// <param name="InputFile">The input file</param> /// <param name="IncludeStack">The current include stack</param> /// <param name="OutputFiles">List of output files</param> /// <param name="OutputFileLookup">Mapping from source file to output file</param> /// <returns>The new or existing output file</returns> static OutputFile FindOrCreateOutputFile(List <SourceFile> InputFileStack, Dictionary <SourceFile, SourceFile> CppFileToHeaderFile, HashList <OutputFile> PreviousFiles, Dictionary <SourceFile, OutputFile> OutputFileLookup, Dictionary <Symbol, OutputFile> FwdSymbolToHeader, bool bMakeStandalone, bool bUseOriginalIncludes, TextWriter Log) { // Get the file at the top of the stack SourceFile InputFile = InputFileStack[InputFileStack.Count - 1]; // Try to find an existing file OutputFile OutputFile; if (OutputFileLookup.TryGetValue(InputFile, out OutputFile)) { if (OutputFile == null) { throw new Exception("Circular include dependencies are not allowed."); } foreach (OutputFile IncludedFile in OutputFile.OriginalIncludedFiles.Where(x => !PreviousFiles.Contains(x))) { PreviousFiles.Add(IncludedFile); } } else { // Add a placeholder entry in the output file lookup, so we can detect circular include dependencies OutputFileLookup[InputFile] = null; // Duplicate the list of previously included files, so we can construct the List <OutputFile> PreviousFilesCopy = new List <OutputFile>(PreviousFiles); // Build a list of includes for this file. First include is a placeholder for any missing includes that need to be inserted. List <OutputFileInclude> Includes = new List <OutputFileInclude>(); if ((InputFile.Flags & SourceFileFlags.External) == 0) { for (int MarkupIdx = 0; MarkupIdx < InputFile.Markup.Length; MarkupIdx++) { PreprocessorMarkup Markup = InputFile.Markup[MarkupIdx]; if (Markup.IsActive && Markup.IncludedFile != null && (Markup.IncludedFile.Flags & SourceFileFlags.Inline) == 0 && Markup.IncludedFile.Counterpart == null) { InputFileStack.Add(Markup.IncludedFile); OutputFile IncludeFile = FindOrCreateOutputFile(InputFileStack, CppFileToHeaderFile, PreviousFiles, OutputFileLookup, FwdSymbolToHeader, bMakeStandalone, bUseOriginalIncludes, Log); InputFileStack.RemoveAt(InputFileStack.Count - 1); Includes.Add(new OutputFileInclude(MarkupIdx, IncludeFile)); } } } // Find the matching header file OutputFile HeaderFile = null; if ((InputFile.Flags & SourceFileFlags.TranslationUnit) != 0) { SourceFile CandidateHeaderFile; if (CppFileToHeaderFile.TryGetValue(InputFile, out CandidateHeaderFile) && (CandidateHeaderFile.Flags & SourceFileFlags.Standalone) != 0) { OutputFileLookup.TryGetValue(CandidateHeaderFile, out HeaderFile); } } // Create the output file. if ((InputFile.Flags & SourceFileFlags.Output) != 0 && !bUseOriginalIncludes) { OutputFile = CreateOptimizedOutputFile(InputFile, HeaderFile, PreviousFilesCopy, Includes, InputFileStack, FwdSymbolToHeader, bMakeStandalone, Log); } else { OutputFile = CreatePassthroughOutputFile(InputFile, Includes, Log); } // Replace the null entry in the output file lookup that we added earlier OutputFileLookup[InputFile] = OutputFile; // Add this file to the list of included files PreviousFiles.Add(OutputFile); // If the output file dependends on something on the stack, make sure it's marked as pinned if ((InputFile.Flags & SourceFileFlags.Pinned) == 0) { SourceFragment Dependency = OutputFile.Dependencies.FirstOrDefault(x => InputFileStack.Contains(x.File) && x.File != InputFile); if (Dependency != null) { throw new Exception(String.Format("'{0}' is not marked as pinned, but depends on '{1}' which includes it", InputFile.Location.GetFileName(), Dependency.UniqueName)); } } } return(OutputFile); }
public void add(String name, Figura f) { objects.Add(name, f); }
/// <summary> /// Constructor /// </summary> /// <param name="InputFile">The input file that this output file corresponds to</param> public OutputFile(SourceFile InputFile, OutputFile HeaderFile, IEnumerable <OutputFile> PreviousFiles, List <OutputFileInclude> Includes, List <SourceFile> InputFileStack, Dictionary <Symbol, OutputFile> FwdSymbolToHeader, bool bMakeStandalone, TextWriter Log) { this.InputFile = InputFile; this.Includes = Includes; Debug.Assert(HeaderFile == null || (InputFile.Flags & SourceFileFlags.TranslationUnit) != 0); // Traverse through all the included headers, figuring out the first unique include for each file and fragment HashSet <OutputFile> VisitedFiles = new HashSet <OutputFile>(); HashSet <SourceFragment> VisitedFragments = new HashSet <SourceFragment>(); // Go through the standalone headers first OutputFile MonolithicHeader = null; if (HeaderFile == null && (InputFile.Flags & SourceFileFlags.Standalone) != 0 && (InputFile.Flags & SourceFileFlags.External) == 0 && (InputFile.Flags & SourceFileFlags.Aggregate) == 0) { // Insert a dummy include to receive all the inserted headers OutputFileInclude ImplicitInclude = new OutputFileInclude(-1, null); ImplicitInclude.ExpandedReferences = new List <OutputFileReference>(); Includes.Insert(0, ImplicitInclude); // Determine which monolithic header to use IEnumerable <OutputFile> PotentialMonolithicHeaders = PreviousFiles.Union(Includes.Select(x => x.TargetFile).Where(x => x != null).SelectMany(x => x.IncludedFiles)); if (InputFile.Module != null && InputFile.Module.PublicDependencyModules.Union(InputFile.Module.PrivateDependencyModules).Any(x => x.Name == "Core")) { MonolithicHeader = PotentialMonolithicHeaders.FirstOrDefault(x => (x.InputFile.Flags & SourceFileFlags.IsCoreMinimal) != 0); } else { MonolithicHeader = PotentialMonolithicHeaders.FirstOrDefault(x => (x.InputFile.Flags & SourceFileFlags.IsCoreTypes) != 0); } // Update the dependencies to treat all the contents of a monolithic header as pinned if (MonolithicHeader != null) { SourceFragment[] UniqueFragments = MonolithicHeader.IncludedFragments.Except(VisitedFragments).ToArray(); ImplicitInclude.ExpandedReferences.Add(new OutputFileReference(MonolithicHeader, UniqueFragments)); VisitedFragments.UnionWith(UniqueFragments); VisitedFiles.Add(MonolithicHeader); } // Insert all the forward declaration headers, but only treat them as supplying the forward declarations themselves. They may happen to include // some utility classes (eg. TSharedPtr), and we don't want to include an unrelated header to satisfy that dependency. foreach (OutputFile FwdHeader in FwdSymbolToHeader.Values) { FindExpandedReferences(FwdHeader, ImplicitInclude.ExpandedReferences, VisitedFiles, VisitedFragments, true); } // Add all the other files if (bMakeStandalone) { foreach (OutputFile PreviousFile in PreviousFiles) { if ((PreviousFile.InputFile.Flags & SourceFileFlags.Inline) == 0 && (PreviousFile.InputFile.Flags & SourceFileFlags.Pinned) == 0 && VisitedFiles.Add(PreviousFile)) { SourceFragment[] UniqueFragments = PreviousFile.IncludedFragments.Except(VisitedFragments).ToArray(); ImplicitInclude.ExpandedReferences.Add(new OutputFileReference(PreviousFile, UniqueFragments)); VisitedFragments.UnionWith(UniqueFragments); } } } } // Figure out a list of files which are uniquely reachable through each include. Force an include of the matching header as the first thing. foreach (OutputFileInclude Include in Includes) { if (Include.ExpandedReferences == null) { Include.ExpandedReferences = new List <OutputFileReference>(); if (Include == Includes[0] && HeaderFile != null) { Include.ExpandedReferences.Add(new OutputFileReference(HeaderFile, HeaderFile.IncludedFragments)); VisitedFragments.UnionWith(HeaderFile.IncludedFragments); } FindExpandedReferences(Include.TargetFile, Include.ExpandedReferences, VisitedFiles, VisitedFragments, true); } } // Find all the symbols which are referenced by this file HashSet <SourceFragment> FragmentsWithReferencedSymbols = new HashSet <SourceFragment>(); foreach (SourceFragment Fragment in InputFile.Fragments) { foreach (KeyValuePair <Symbol, SymbolReferenceType> ReferencedSymbol in Fragment.ReferencedSymbols) { if (ReferencedSymbol.Value == SymbolReferenceType.RequiresDefinition) { FragmentsWithReferencedSymbols.Add(ReferencedSymbol.Key.Fragment); } } } // Aggregate headers are designed to explicitly include headers from the current module. Expand out a list of them, so they can be included when encountered. HashSet <OutputFile> ExplicitIncludes = new HashSet <OutputFile>(); if ((InputFile.Flags & SourceFileFlags.Aggregate) != 0) { foreach (OutputFileInclude Include in Includes) { ExplicitIncludes.UnionWith(Include.ExpandedReferences.Where(x => x.File.InputFile.Location.IsUnderDirectory(InputFile.Location.Directory)).Select(x => x.File)); } foreach (OutputFileInclude Include in Includes) { ExplicitIncludes.Remove(Include.TargetFile); } } // Create the list of remaining dependencies for this file, and add any forward declarations Dependencies = new HashSet <SourceFragment>(); AddForwardDeclarations(InputFile, ForwardDeclarations, Dependencies, FwdSymbolToHeader); // Reduce the list of includes to those that are required. for (int FragmentIdx = InputFile.Fragments.Length - 1, IncludeIdx = Includes.Count - 1; FragmentIdx >= 0; FragmentIdx--) { // Update the dependency lists for this fragment SourceFragment InputFragment = InputFile.Fragments[FragmentIdx]; if (InputFragment.Dependencies != null) { Dependencies.UnionWith(InputFragment.Dependencies); } Dependencies.Remove(InputFragment); // Scan backwards through the list of includes, expanding each include to those which are required int MarkupMin = (FragmentIdx == 0)? -1 : InputFragment.MarkupMin; for (; IncludeIdx >= 0 && Includes[IncludeIdx].MarkupIdx >= MarkupMin; IncludeIdx--) { OutputFileInclude Include = Includes[IncludeIdx]; // Always include the same header for aggregates if ((InputFile.Flags & SourceFileFlags.Aggregate) != 0) { Include.FinalFiles.Insert(0, Include.TargetFile); Dependencies.ExceptWith(Include.TargetFile.IncludedFragments); Dependencies.UnionWith(Include.TargetFile.Dependencies); } // Include any indirectly included files for (int Idx = Include.ExpandedReferences.Count - 1; Idx >= 0; Idx--) { // Make sure we haven't already added it above OutputFileReference Reference = Include.ExpandedReferences[Idx]; if (!Include.FinalFiles.Contains(Reference.File)) { if (Dependencies.Any(x => Reference.UniqueFragments.Contains(x)) || (Reference.File.InputFile.Flags & SourceFileFlags.Pinned) != 0 || Reference.File == HeaderFile || Reference.File == MonolithicHeader || ExplicitIncludes.Contains(Reference.File) || ((InputFile.Flags & SourceFileFlags.Aggregate) != 0 && Reference.File == Include.TargetFile) || // Always include the original header for aggregates. They are written explicitly to include certain files. Reference.UniqueFragments.Any(x => FragmentsWithReferencedSymbols.Contains(x))) { Include.FinalFiles.Insert(0, Reference.File); Dependencies.ExceptWith(Reference.File.IncludedFragments); Dependencies.UnionWith(Reference.File.Dependencies); } } } } } // Remove any includes that are already included by the matching header if (HeaderFile != null) { HashSet <OutputFile> HeaderIncludedFiles = new HashSet <OutputFile>(HeaderFile.Includes.SelectMany(x => x.FinalFiles)); foreach (OutputFileInclude Include in Includes) { Include.FinalFiles.RemoveAll(x => HeaderIncludedFiles.Contains(x)); } } // Check that all the dependencies have been satisfied if (Dependencies.Count > 0) { // Find those which are completely invalid List <SourceFragment> InvalidDependencies = Dependencies.Where(x => !InputFileStack.Contains(x.File)).ToList(); if (InvalidDependencies.Count > 0) { Log.WriteLine("warning: {0} does not include {1}; may have missing dependencies.", InputFile, String.Join(", ", InvalidDependencies.Select(x => x.Location.FullName))); } Dependencies.ExceptWith(InvalidDependencies); // Otherwise warn about those which were not pinned foreach (SourceFile DependencyFile in Dependencies.Select(x => x.File)) { Log.WriteLine("warning: {0} is included by {1} ({2}), but depends on it and should be marked as pinned.", InputFile, DependencyFile, String.Join(" -> ", InputFileStack.SkipWhile(x => x != DependencyFile).Select(x => x.Location.GetFileName()))); } // Mark it as non-standalone and pinned InputFile.Flags = (InputFile.Flags | SourceFileFlags.Pinned) & ~SourceFileFlags.Standalone; } // Do one more forward pass through all the headers, and remove anything that's included more than once. That can happen if we have a referenced symbol as well as // an explicit include, for example. HashSet <OutputFile> FinalIncludes = new HashSet <OutputFile>(); foreach (OutputFileInclude Include in Includes) { for (int Idx = 0; Idx < Include.FinalFiles.Count; Idx++) { if (!FinalIncludes.Add(Include.FinalFiles[Idx])) { Include.FinalFiles.RemoveAt(Idx); Idx--; } } } // Build the list of satisfied dependencies IncludedFragments = new HashSet <SourceFragment>(); IncludedFragments.UnionWith(Includes.SelectMany(x => x.FinalFiles).SelectMany(x => x.IncludedFragments)); IncludedFragments.UnionWith(InputFile.Fragments); // Build the list of all the included files, so other output files that include it can expand it out. IncludedFiles = new HashList <OutputFile>(); IncludedFiles.UnionWith(Includes.SelectMany(x => x.FinalFiles).SelectMany(x => x.IncludedFiles)); IncludedFiles.Add(this); }
/// <summary> /// Calculate the route from start to end. /// </summary> /// <param name="start">Start.</param> /// <param name="end">End.</param> public void Route(T start, T end, List <T> route) { route.Clear(); if (start == null || end == null) { return; } for (int i = 0, nodesLength = nodes.Length; i < nodesLength; i++) { var s = nodes[i]; g[s] = 0f; parent[s] = null; inPath[s] = false; } openset.Clear(); closedset.Clear(); path.Clear(); var current = start; openset.Add(current); while (openset.Count > 0) { current = openset[0]; for (var i = 1; i < openset.Count; i++) { var d = g[current].CompareTo(g[openset[i]]); if (d < 0) { current = openset[i]; } } //openset.Sort ((a,b) => g [a].CompareTo (g [b])); current = openset[0]; if (current == end) { while (parent[current] != null) { path.Enqueue(current); inPath[current] = true; current = parent[current]; if (path.Count >= nodes.Length) { return; } } inPath[current] = true; path.Enqueue(current); while (path.Count > 0) { route.Add(path.Dequeue()); } return; } openset.Remove(current); closedset.Add(current); var connectedNodes = current.GetConnectedNodes(); for (int i = 0, connectedNodesCount = connectedNodes.Count; i < connectedNodesCount; i++) { var node = connectedNodes[i]; if (closedset.Contains(node)) { continue; } if (openset.Contains(node)) { var new_g = g[current] + current.CalculateMoveCost(node); if (g[node] > new_g) { g[node] = new_g; parent[node] = current; } } else { g[node] = g[current] + current.CalculateMoveCost(node); parent[node] = current; openset.Add(node); } } } return; }
private void CollisionDetected(RigidBody body1, RigidBody body2, TSVector point1, TSVector point2, TSVector normal, FP penetration) { bool anyBodyColliderOnly = body1.IsColliderOnly || body2.IsColliderOnly; Arbiter arbiter = null; ArbiterMap selectedArbiterMap = null; if (anyBodyColliderOnly) { selectedArbiterMap = arbiterTriggerMap; } else { selectedArbiterMap = arbiterMap; } bool arbiterCreated = false; lock (selectedArbiterMap) { selectedArbiterMap.LookUpArbiter(body1, body2, out arbiter); if (arbiter == null) { arbiter = Arbiter.Pool.GetNew(); arbiter.body1 = body1; arbiter.body2 = body2; selectedArbiterMap.Add(new ArbiterKey(body1, body2), arbiter); arbiterCreated = true; } } Contact contact = null; if (arbiter.body1 == body1) { TSVector.Negate(ref normal, out normal); contact = arbiter.AddContact(point1, point2, normal, penetration, contactSettings); } else { contact = arbiter.AddContact(point2, point1, normal, penetration, contactSettings); } if (arbiterCreated) { if (anyBodyColliderOnly) { /*if (body1.isColliderOnly) { * events.RaiseTriggerBeginCollide(body1, body2); * } else { * events.RaiseTriggerBeginCollide(body2, body1); * }*/ events.RaiseTriggerBeginCollide(contact); body1.arbitersTrigger.Add(arbiter); body2.arbitersTrigger.Add(arbiter); OverlapPairContact overlapContact = new OverlapPairContact(body1, body2); overlapContact.contact = contact; initialTriggers.Add(overlapContact); } else { events.RaiseBodiesBeginCollide(contact); addedArbiterQueue.Enqueue(arbiter); OverlapPairContact overlapContact = new OverlapPairContact(body1, body2); overlapContact.contact = contact; initialCollisions.Add(overlapContact); } } if (!anyBodyColliderOnly && contact != null) { events.RaiseContactCreated(contact); } }
private void AddNode(HashList<FullCellAddr> sorted, FullCellAddr node) { HashSet<FullCellAddr> precedents; if (GetPrecedents(node, out precedents)) { Cell cell; foreach (FullCellAddr precedent in precedents) { // By including only non-input Formula and ArrayFormula cells, we avoid that // constant cells get stored in local variables. The result will not contain // constants cells (and will contain an input cell only if it is also the // output cell), so must the raw graph to find all cells belonging to an SDF. if (!sorted.Contains(precedent) && precedent.TryGetCell(out cell) && (cell is Formula || cell is ArrayFormula) && !inputCellSet.Contains(precedent)) { AddNode(sorted, precedent); } } } sorted.Add(node); // Last in HashList }
public void DefineGetAllInstancesMethod(TypeDefinition containerType, ModuleDefinition module, IDictionary <IDependency, IImplementation> serviceMap) { var targetMethods = new List <MethodDefinition>(); foreach (MethodDefinition method in containerType.Methods) { if (method.Name != "GetAllInstances") { continue; } targetMethods.Add(method); } var getAllInstancesMethod = targetMethods[0]; // Remove the stub implementation var body = getAllInstancesMethod.Body; var IL = body.GetILProcessor(); body.InitLocals = true; body.Instructions.Clear(); var listVariable = getAllInstancesMethod.AddLocal <List <object> >(); var listCtor = module.ImportConstructor <List <object> >(); IL.Emit(OpCodes.Newobj, listCtor); IL.Emit(OpCodes.Stloc, listVariable); // Group the dependencies by type var dependenciesByType = new HashList <Type, IDependency>(); foreach (var dependency in serviceMap.Keys) { var serviceType = dependency.ServiceType; dependenciesByType.Add(serviceType, dependency); } var getTypeFromHandleMethod = typeof(Type).GetMethod("GetTypeFromHandle", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static); var getTypeFromHandle = module.Import(getTypeFromHandleMethod); var addItem = module.ImportMethod <List <object> >("Add"); var currentService = getAllInstancesMethod.AddLocal <object>(); foreach (var currentType in dependenciesByType.Keys) { var currentTypeRef = module.Import(currentType); var currentList = dependenciesByType[currentType]; if (currentList.Count == 0) { continue; } var skipAdd = IL.Create(OpCodes.Nop); IL.Emit(OpCodes.Ldarg_1); IL.Emit(OpCodes.Ldtoken, currentTypeRef); IL.Emit(OpCodes.Call, getTypeFromHandle); IL.Emit(OpCodes.Ceq); IL.Emit(OpCodes.Brfalse, skipAdd); foreach (var dependency in currentList) { IL.Emit(OpCodes.Ldloc, listVariable); var implementation = serviceMap[dependency]; implementation.Emit(dependency, serviceMap, getAllInstancesMethod); IL.Emit(OpCodes.Stloc, currentService); // Call IInitialize.Initialize(container) on the current service type _initializer.Initialize(IL, module, currentService); IL.Emit(OpCodes.Ldloc, currentService); IL.Emit(OpCodes.Callvirt, addItem); } IL.Append(skipAdd); } var skipOtherContainerCall = IL.Create(OpCodes.Nop); var getNextContainer = module.ImportMethod <IMicroContainer>("get_NextContainer"); var otherContainer = getAllInstancesMethod.AddLocal <IMicroContainer>(); // var otherContainer = this.NextContainer; IL.Emit(OpCodes.Ldarg_0); IL.Emit(OpCodes.Callvirt, getNextContainer); IL.Emit(OpCodes.Stloc, otherContainer); // if (otherContainer != null && this != otherContainer) { IL.Emit(OpCodes.Ldloc, otherContainer); IL.Emit(OpCodes.Brfalse, skipOtherContainerCall); IL.Emit(OpCodes.Ldloc, otherContainer); IL.Emit(OpCodes.Ldarg_0); IL.Emit(OpCodes.Ceq); IL.Emit(OpCodes.Brtrue, skipOtherContainerCall); // var otherInstances = NextContainer.GetAllInstances(type); var otherGetAllInstancesMethod = module.ImportMethod <IMicroContainer>("GetAllInstances"); IL.Emit(OpCodes.Ldloc, listVariable); IL.Emit(OpCodes.Ldloc, otherContainer); IL.Emit(OpCodes.Ldarg_1); IL.Emit(OpCodes.Callvirt, otherGetAllInstancesMethod); // resultList.AddRange(otherInstances); var addRangeMethod = module.ImportMethod <List <object> >("AddRange"); IL.Emit(OpCodes.Callvirt, addRangeMethod); // } // Cast the results down to an IEnumerable<object> var enumerableType = module.ImportType <IEnumerable <object> >(); IL.Append(skipOtherContainerCall); IL.Emit(OpCodes.Ldloc, listVariable); IL.Emit(OpCodes.Isinst, enumerableType); IL.Emit(OpCodes.Ret); }
public void AddDependencies(Bundle subBundle) { subBundle.Parent = this; Dependencies.Add(subBundle); }
/// <summary> /// Obtains a list of services (grouped by type) from the list of assemblies. /// </summary> /// <param name="assemblies">The list of assemblies that contain the types that will be injected into the dependency map.</param> /// <returns>A list of services grouped by type.</returns> private HashList<Type, IServiceInfo> GetServiceList(IEnumerable<Assembly> assemblies) { if (assemblies == null) throw new ArgumentNullException("assemblies"); var serviceList = new HashList<Type, IServiceInfo>(); foreach (var assembly in assemblies) { var services = _serviceLoader.Load(assembly); foreach (var service in services) { var serviceType = service.ServiceType; // Group the services by service type serviceList.Add(serviceType, service); } } return serviceList; }
/// <summary> /// type_method = [ "static" ], signature, method_name, [ ":", signature, identifier, { ",", signature, identifier } ], "{", { local_stmt }, "}" ; /// </summary> private void ParseTypeMethod() { // ? "static" bool isStatic = false; if (PeekLexem(LexemType.Static)) { SkipLexem(); isStatic = true; } // signature var methodType = ParseSignature(); // <method_name> if (!PeekLexem(LexemType.Identifier)) Error(Resources.errMethodNameExpected); var methodName = GetLexem(); if (ReservedMethods.ContainsKey(methodName.Data) && ReservedMethods[methodName.Data] != methodType.Signature) Error(String.Format(Resources.errSpecialIncorrectReturnType, methodName.Data, ReservedMethods[methodName.Data])); // validate static constructor if (methodName.Data == "construct" && isStatic) Error(String.Format(Resources.errStaticConstructor, Compiler.Emitter.CurrentType.Name)); SkipLexem(); HashList<ParameterNode> parameters = null; // ? "(", params, ")" if(PeekLexem(LexemType.ParenOpen)) { SkipLexem(); parameters = new HashList<ParameterNode>(); var idx = 0; while(!PeekLexem(LexemType.ParenClose, LexemType.EOF)) { // separator if(idx > 0) { if (!PeekLexem(LexemType.Comma)) Error(Resources.errCommaExpected); SkipLexem(); } // signature var paramType = ParseSignature(); // <name> if (!PeekLexem(LexemType.Identifier)) Error(Resources.errParameterNameExpected); var paramName = GetLexem(); if (parameters.Contains(paramName.Data)) Error(String.Format(Resources.errParameterNameDuplicated, paramName.Data)); parameters.Add(paramName.Data, new ParameterNode(paramName.Data, paramType, idx)); SkipLexem(); idx++; } // ")" if (!PeekLexem(LexemType.ParenClose)) Error(Resources.errParenExpected); SkipLexem(); } MethodNode method; if (methodName.Data == "construct") method = Compiler.Emitter.CreateCtor(Compiler.Emitter.CurrentType, parameters); else method = Compiler.Emitter.CreateMethod(Compiler.Emitter.CurrentType, methodName.Data, methodType, parameters, isStatic); method.Lexem = methodName; Compiler.Emitter.CurrentMethod = method; // lookahead "{" if (!PeekLexem(LexemType.CurlyOpen)) Error(Resources.errMethodCurlyBrace); method.Body = ParseCodeBlock(); Compiler.Emitter.CurrentMethod = null; }
public void Simple() { var hashList = new HashList <int, string> { { 2, "a" } }; Assert.AreEqual(hashList.ValueCount, 1); Assert.AreEqual(hashList.KeyCount, 1); hashList.Add(4, new List <string>(new[] { "2", "3", "4", "5" })); Assert.AreEqual(hashList.ValueCount, 5); Assert.AreEqual(hashList.KeyCount, 2); Assert.IsTrue(hashList.Remove(2)); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 4); Assert.IsFalse(hashList.Remove(2)); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 4); Assert.IsTrue(hashList.RemoveValue("2")); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 3); Assert.IsFalse(hashList.Remove(3, "2")); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 3); Assert.IsFalse(hashList.Remove(4, "2")); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 3); Assert.IsTrue(hashList.Remove(4, "5")); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 2); hashList.Add(4, "4"); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 3); hashList.RemoveAll("4"); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 1); Assert.IsFalse(hashList.Remove(10)); hashList.Add(4, "5"); hashList.Add(4, "6"); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 3); Assert.IsTrue(hashList.RemoveValue("5")); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 2); Assert.IsFalse(hashList.RemoveValue("5")); Assert.AreEqual(hashList.KeyCount, 1); Assert.AreEqual(hashList.ValueCount, 2); }