Example #1
0
 public TrustedHtml AddAttributes(string tag, params string[] keys)
 {
     if (string.IsNullOrEmpty(tag))
     {
         throw new System.ArgumentNullException("tag");
     }
     if (keys == null)
     {
         throw new System.ArgumentNullException("keys");
     }
     HashSet<string> hashSet = new HashSet<string>();
     for (int i = 0; i < keys.Length; i++)
     {
         string text = keys[i];
         if (string.IsNullOrEmpty(text))
         {
             throw new System.Exception("key");
         }
         hashSet.Add(text);
     }
     if (this._attributes.ContainsKey(tag))
     {
         using (HashSet<string>.Enumerator enumerator = hashSet.GetEnumerator())
         {
             while (enumerator.MoveNext())
             {
                 string current = enumerator.Current;
                 this._attributes[tag].Add(current);
             }
             return this;
         }
     }
     this._attributes.Add(tag, hashSet);
     return this;
 }
        public void TestIterators()
        {
            List<int> myList = new List<int> { 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5 };
              HashSet<int> mySet = new HashSet<int> { 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5 };
              for (int i = 0; i < myList.Count; i++)
            Console.Write("{0} ", myList[i]);
              Console.WriteLine();

              IEnumerator<int> pi = mySet.GetEnumerator();
              while (pi.MoveNext())
              {
            int x = pi.Current;
            Console.Write("{0} ", x);
              }
              Console.WriteLine();

              foreach (int x in myList)
            Console.Write("{0} ", x);
              Console.WriteLine();

              MyIntList myIntList = new MyIntList { 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5 };
              IEnumerator<int> px = myIntList.GetEnumerator(x => 0 == x % 3);
              while ( px.MoveNext())
            Console.Write("{0} ", px.Current);
              Console.WriteLine();
              // displays 3 9 6 3

              foreach(int x in myIntList)
            Console.Write("{0} ", x);
              Console.WriteLine();
              // displays 3 1 4 1 5 9 2 6 5 3 5

              Console.ReadKey();
        }
Example #3
0
    static void Main()
    {
        // -9,223,372,036,854,775,808 == long.MinValue
        //  9,223,372,036,854,775,807 == long.MaxValue
        // long.MinValue <= a[i] <= long.MaxValue
        // 1 <= i <= 99,999

        // Input data
        int n = int.Parse(Console.ReadLine());
        long[] a = new long[n];
        for (int i = 0; i < n; i++)
        {
            a[i] = long.Parse(Console.ReadLine());
        }
        // Calculate
        HashSet<long> oddElementValues = new HashSet<long>();
        for (int i = 0; i < n; i++)
        {
            if (oddElementValues.Contains(a[i]))
            {
                oddElementValues.Remove(a[i]);
            }
            else
            {
                oddElementValues.Add(a[i]);
            }
        }
        HashSet<long>.Enumerator enumerator = oddElementValues.GetEnumerator();
        enumerator.MoveNext();
        // Output data
        Console.WriteLine(enumerator.Current);
    }
Example #4
0
    public int[] allClique(string[] graphEdge)
    {
        int n = graphEdge.Length;
        int[] ret = new int[n];
        HashSet<int> c = new HashSet<int>();
        HashSet<int> s = new HashSet<int>();
        for (int i = 0; i < n; i++)
        {
            ret[i] = 0;
            c.Add(1<<i);
        }

        ret[0] = n;
        for (int k = 1; k < n; k++)
        {
            HashSet<int> cc = new HashSet<int>();
            HashSet<int>.Enumerator ee = c.GetEnumerator();
            while(ee.MoveNext())
            {
                List<int> l = new List<int>();
                int set = ee.Current;
                for (int i = 0; i < n; i++)
                {
                    if ((set & (1 << i)) == (1 << i))
                        continue;

                    bool found = true;
                    int e = set; int p = 0;
                    while (e > 0)
                    {
                        if ((e & 1) == 1)
                        {
                            if (graphEdge[p][i] == '0')
                            {
                                found = false;
                                break;
                            }
                        }
                        e = e >> 1;
                        p++;
                    }

                    if (found)
                    {
                        l.Add(i);
                    }
                }
                for (int i = 0; i < l.Count; i++)
                {
                    cc.Add(set | (1 << l[i]));
                }
            }
            ret[k] = cc.Count;

            c = cc;
        }

        return ret;
    }
Example #5
0
    public static void Main () {
        var hs = new HashSet<string>() {
            "a",
            "b",
            "c"
        };

        foreach (var s in hs)
            Console.WriteLine(s);

        Console.WriteLine(hs.Count);

        var test = hs.GetEnumerator();
    }
Example #6
0
        static int lonelyinteger(int[] a)
        {
            HashSet<int> myInts = new HashSet<int>();

            foreach (int item in a)
            {
                if (myInts.Contains(item))
                    myInts.Remove(item);

                else
                    myInts.Add(item);
            }

            IEnumerator<int> itr = myInts.GetEnumerator();
            itr.MoveNext();

            return itr.Current;
        }
    void ModifiedBFS()
    {
        HashSet<Node> tempRoadSet = new HashSet<Node>(grid.RoadSet);
        Queue<Node> trafficQ = new Queue<Node>();
        trafficQ.Enqueue(grid.ARoadNode);

        while (tempRoadSet.Count != 0)
        {
            while (trafficQ.Count > 0)
            {
                Node current = trafficQ.Dequeue();
                if (tempRoadSet.Remove(current))
                {
                    foreach (Node n in grid.BFSGetRoadNeighbours(current))     // GetRoadNeighbors adds in/out => trafficWeight
                    {
                        if(tempRoadSet.Contains(n))
                            trafficQ.Enqueue(n);
                    }
                }
            }

            // Stranded roads
            // There maybe a chance that we take the small set. Need to improve this more.
            while (tempRoadSet.Count > 0)
            {
                HashSet<Node>.Enumerator node = tempRoadSet.GetEnumerator();
                if (node.MoveNext())
                {
                    grid.RoadSet.Remove(node.Current);     // remove stranded road
                    tempRoadSet.Remove(node.Current);
                    node.Current.IsRoad = false;
                }
            }
        }
    }
Example #8
0
    /// <summary>
    /// カットを実行
    /// </summary>
    public void ExecuteCut()
    {
        int h = plateBuildMap_.GetLength(0);
        int w = plateBuildMap_.GetLength(1);

        var labelMap = new int[h,w];
        var labelLinkTbl = new Dictionary<int,int>();
        int labelSeed = 0;

        // ラベリングしていきます
        for (int yy = 0; yy < h; yy++)
        {
            if (yy == 0)
            {
                // 縦の開始の場合
                int nowLabel = labelSeed++;
                for (int xx = 0; xx < w; xx++)
                {
                    if (xx != 0)
                    {
                        if(cutting_.GetVertLineCutOp(xx-1, yy) == CuttingInfo_.CutOperations.Cut)
                        {
                            nowLabel = labelSeed++;
                        }
                    }
                    labelMap[yy, xx] = nowLabel;
                }
            }
            else
            {
                // 一つ上のブロックを起点にします
                int nowLabel = labelMap[yy-1, 0];
                for (int xx = 0; xx < w; xx++)
                {
                    if (cutting_.GetHoriLineCutOp(yy - 1, xx) == CuttingInfo_.CutOperations.None)
                    {
                        if (xx==0 || cutting_.GetVertLineCutOp(xx - 1, yy) == CuttingInfo_.CutOperations.None)
                        {
                            //上とつながる、左とつながる場合
                            if (labelMap[yy - 1, xx] != nowLabel)
                            {
                                // 上と違うラベルの場合、2つの領域が連結されます
                                labelLinkTbl[nowLabel] = labelMap[yy - 1, xx];
                            }
                        }
                        else
                        {
                            //上とつながる、左とつながら無い場合
                            nowLabel = labelMap[yy - 1, xx];
                        }
                    }
                    else
                    {
                        if (xx==0)
                        {
                            //上とつながら無い、横の起点び場合
                            nowLabel = labelSeed++;
                        }
                        else if(cutting_.GetVertLineCutOp(xx - 1, yy) == CuttingInfo_.CutOperations.None)
                        {
                            //上とつながら無い、左とつながる場合
                        }
                        else
                        {
                            //上とつながら無い、左とつながら無い場合
                            nowLabel = labelSeed++;
                        }
                    }
                    labelMap[yy, xx] = nowLabel;
                }
            }
        }
        // ラベルを振りなおします
        var labelSet = new HashSet<int>();
        for (int yy = 0; yy < h; yy++)
        {
            for (int xx = 0; xx < w; xx++)
            {
                if (labelLinkTbl.ContainsKey(labelMap[yy, xx]))
                {
                    labelMap[yy, xx] = labelLinkTbl[labelMap[yy, xx]];
                }
                labelSet.Add(labelMap[yy, xx]);
            }
        }
        // 領域が2つ以上であれば分割します
        if(labelSet.Count>1)
        {
            Debug.Log(string.Format("labelSet.Count = {0}", labelSet.Count));

            for (int zz = 0; zz < h; zz++)
            {
                for (int xx = 0; xx < w; xx++)
                {
                    if(labelMap[zz, xx] != labelSet.GetEnumerator().Current)
                    {
                        plateBuildMap_[zz, xx].TestOffsetY = -labelMap[zz, xx] * 2.8f;
                    }
                }
            }
            RebuildDrawPlateObject_();
            cutting_.ClearAll();
            cutting_.ReBuildDrawObject();
        }
    }
Example #9
0
        public HashSet<List<Tuple<long, long>>> GetShortestPath(HashSet<Node> myIntersectNodes)
        {
            foundLeft = foundRight = false;

            //set maximum part lengths
            _MaxPartLengthLeft = _MaxPartLengthRight = (_MaxPathLength / 2);

            //if the max path length is odd add one
            if (_MaxPathLength % 2 != 0)
            {
                _MaxPartLengthLeft += 1;
                _MaxPartLengthRight += 1;
            }

            var enumerator = myIntersectNodes.GetEnumerator();

            while (enumerator.MoveNext() && _Paths.Count == 0)
            {
                //calculate parts from intersect node to end
                getShortestPathDownwards(enumerator.Current);

                ///recalculate the max part length...
                ///it could happen that the intersect node is not in the middle,
                ///so the max part length left could be less than calculated,
                ///if this happens the right part length must be adapted
                _MaxPartLengthRight = _MaxPathLength - _MaxPartLengthLeft;

                //check if max path length is odd
                if (_MaxPathLength % 2 != 0)
                {
                    _MaxPartLengthRight += 1;
                }

                //calculate parts from intersect node to start
                getShortestPathUpwards(enumerator.Current);

                //calculate full path
                if (_PathsLeft.Count > 0 && _PathsRight.Count > 0)
                {
                    //forach part from left
                    foreach (var leftPath in _PathsLeft)
                    {
                        var first = leftPath.First();

                        //foreach part from right
                        foreach (var rightPath in _PathsRight)
                            //if there starts are the same (the intersect node)
                            if (rightPath.First().Equals(first) &&
                                ((rightPath.Count + leftPath.Count - 1) <= _MaxPathLength))
                            {
                                var temp = new List<Tuple<long, long>>(rightPath);
                                temp.Reverse();
                                leftPath.RemoveAt(0);
                                temp.InsertRange(temp.Count, leftPath);

                                _Paths.Add(temp);

                                return _Paths;
                            }
                    }
                }
            }

            return null;
        }
Example #10
0
        /// <summary>
        /// Tries all filenames (complete path) included in the fullFileNameFile file.
        /// </summary>
        /// <param name="fullFileNameFile"></param>
        /// <returns> number of newly found filenames</returns>
        public long ParseFilenames(string fullFileNameFile)
        {
            Start();
            hashDic.CreateHelpers();
            long result = 0;
            if (File.Exists(fullFileNameFile))
            {
                Hasher warhash = new Hasher(hasherType);

                //Read the file
                FileStream fs = new FileStream(fullFileNameFile, FileMode.Open);
                StreamReader reader = new StreamReader(fs);

                HashSet<string> fileList = new HashSet<string>();

                string line;
                while ((line = reader.ReadLine()) != null)
                    fileList.Add(line.ToLower().Replace('\\', '/'));

                reader.Close();
                fs.Close();

                // strip input file from duplicates.
                File.Delete(fullFileNameFile);
                fs = new FileStream(fullFileNameFile, FileMode.Create);
                StreamWriter writer = new StreamWriter(fs);

                foreach (string file in fileList)
                    writer.WriteLine(file);

                writer.Close();
                fs.Close();

                foundNames = new Dictionary<string, bool>();

                foreach (string fn in fileList)
                {
                    foundNames[fn] = false;
                }

                //Just in case someday we want to multi thread.
                parseFileList = fileList.GetEnumerator();
                string filename;
                while ((filename = GetFileName_ParseFilenames()) != null)
                {

                    warhash.Hash(filename, 0xDEADBEEF);
                    UpdateResults found = hashDic.UpdateHash(warhash.ph, warhash.sh, filename, 0);
                    if (found == UpdateResults.NAME_UPDATED || found == UpdateResults.ARCHIVE_UPDATED)
                        result++;
                    if (found != UpdateResults.NOT_FOUND)
                        foundNames[filename] = true;
                }
                if (active)
                {
                    string outputFileRoot = Path.GetDirectoryName(fullFileNameFile) + "/" + Path.GetFileNameWithoutExtension(fullFileNameFile);
                    FileStream ofsFound = new FileStream(outputFileRoot + "-found.txt", FileMode.Create);
                    FileStream ofsNotFound = new FileStream(outputFileRoot + "-notfound.txt", FileMode.Create);
                    StreamWriter swf = new StreamWriter(ofsFound);
                    StreamWriter swnf = new StreamWriter(ofsNotFound);

                    foreach (KeyValuePair<string, Boolean> file in foundNames)
                        if (file.Value == true)
                        {
                            warhash.Hash(file.Key, 0xDEADBEEF);
                            swf.WriteLine("{0:X8}" + HashDictionary.hashSeparator
                                + "{1:X8}" + HashDictionary.hashSeparator
                                + "{2}", warhash.ph, warhash.sh, file.Key);
                        }
                        else
                        {
                            //this is a quick and dirty fix to get some more debug info
                            // to be removed in the future !!!
                            warhash.Hash(file.Key, 0xDEADBEEF);
                            //swnf.WriteLine("{0:X8}" + HashDictionary.hashSeparator
                            //    + "{1:X8}" + HashDictionary.hashSeparator
                            //    + "{2}", warhash.ph, warhash.sh, file.Key);
                            swnf.WriteLine(file.Key);
                        }

                    swnf.Close();
                    swf.Close();
                    ofsFound.Close();
                    ofsNotFound.Close();
                }
            }
            return result;
        }
Example #11
0
		public void EnterSSA()
		{
			IRControlFlowGraph cfg = IRControlFlowGraph.Build(this);
			if (cfg == null) return;
			int originalCount = Locals.Count;
			bool[] originalAssignments = new bool[originalCount];
			int[] originalIterations = new int[originalCount];
			IRLocal tempLocal = null;

			Locals.ForEach(l => l.SSAData = new IRLocal.IRLocalSSAData(l));
			// Add new local iterations for each assignment to an original local, and keep
			// track of final iterations for each node, assigning true to indicate it was
			// assigned, false means propagated (used later)
			foreach (IRControlFlowGraphNode node in cfg.Nodes)
			{
				node.SSAFinalIterations = new Tuple<IRLocal, bool>[originalCount];
				node.SSAPhis = new IRLocal[originalCount];
				foreach (IRInstruction instruction in node.Instructions)
				{
					if (instruction.Destination == null || instruction.Destination.Type != IRLinearizedLocationType.Local) continue;
					tempLocal = Locals[instruction.Destination.Local.LocalIndex];
					if (!originalAssignments[tempLocal.Index])
					{
						originalAssignments[tempLocal.Index] = true;
						node.SSAFinalIterations[tempLocal.Index] = new Tuple<IRLocal, bool>(tempLocal, true);
						continue;
					}
					tempLocal = tempLocal.Clone(this);
					Locals.Add(tempLocal);
					tempLocal.SSAData.Iteration = ++originalIterations[tempLocal.SSAData.Original.Index];
					instruction.Destination.Local.LocalIndex = tempLocal.Index;
					node.SSAFinalIterations[tempLocal.SSAData.Original.Index] = new Tuple<IRLocal, bool>(tempLocal, true);
				}
			}

			// Any SSAFinalIterations missing from the entry node means the entry node
			// did not assign to the original local, so they can be filled in with
			// propagated original locals by, assigning false to indicate propagated
			for (int index = 0; index < originalCount; ++index)
			{
				if (cfg.Nodes[0].SSAFinalIterations[index] == null)
					cfg.Nodes[0].SSAFinalIterations[index] = new Tuple<IRLocal, bool>(Locals[index], false);
			}
			// Any SSAFinalIterations missing from any node means the node did not
			// assign to the original local, so they can be filled in with propagated
			// locals using the dominance tree, assigning false to indicate propagated
			foreach (IRControlFlowGraphNode node in cfg.Nodes)
			{
				for (int index = 0; index < originalCount; ++index)
				{
					if (node.SSAFinalIterations[index] == null)
					{
						IRControlFlowGraphNode treeNode = node.Dominator;
						while (treeNode.SSAFinalIterations[index] == null) treeNode = treeNode.Dominator;
						node.SSAFinalIterations[index] = new Tuple<IRLocal, bool>(treeNode.SSAFinalIterations[index].Item1, false);
					}
				}
			}

			// Now that all final iterations are known, we also know if the final
			// iteration for a node was assigned or propagated
			// So now we can create a phi, in the dominance frontiers of nodes which
			// have assignments to original locals
			// If the phi is the only assignment in a dominance frontier node, then
			// the phi destination becomes the final iteration for that node
			int localsBeforePhis = Locals.Count;
			BitArray phiInserted = new BitArray(cfg.Nodes.Count, false);
			BitArray localAssigned = new BitArray(cfg.Nodes.Count, false);
			HashSet<IRControlFlowGraphNode> unprocessedNodes = new HashSet<IRControlFlowGraphNode>();
			HashSet<IRControlFlowGraphNode>.Enumerator unprocessedNodesEnumerator;
			IRControlFlowGraphNode processingNode = null;
			for (int originalIndex = 0; originalIndex < originalCount; ++originalIndex)
			{
				phiInserted.SetAll(false);
				localAssigned.SetAll(false);
				foreach (IRControlFlowGraphNode node in cfg.Nodes)
				{
					if (node.SSAFinalIterations[originalIndex].Item2)
					{
						localAssigned.Set(node.Index, true);
						unprocessedNodes.Add(node);
					}
				}
				while (unprocessedNodes.Count > 0)
				{
					unprocessedNodesEnumerator = unprocessedNodes.GetEnumerator();
					unprocessedNodesEnumerator.MoveNext();
					processingNode = unprocessedNodesEnumerator.Current;
					unprocessedNodes.Remove(processingNode);
					foreach (IRControlFlowGraphNode frontierNode in processingNode.Frontiers)
					{
						if (!phiInserted[frontierNode.Index])
						{
							tempLocal = Locals[originalIndex].Clone(this);
							Locals.Add(tempLocal);
							tempLocal.SSAData.Iteration = ++originalIterations[originalIndex];
							tempLocal.SSAData.Phi = true;
							frontierNode.SSAPhis[originalIndex] = tempLocal;
							if (!frontierNode.SSAFinalIterations[originalIndex].Item2) frontierNode.SSAFinalIterations[originalIndex] = new Tuple<IRLocal, bool>(tempLocal, true);
							phiInserted.Set(frontierNode.Index, true);
							if (!localAssigned[frontierNode.Index])
							{
								localAssigned.Set(frontierNode.Index, true);
								unprocessedNodes.Add(frontierNode);
							}
						}
					}
				}
			}

			// Now we have assignments expanded, phi's created, and we can
			// determine phi sources from a nodes parents final iterations,
			// which we will use later
			// Initial iterations for each original local in a node can now
			// be found through using the SSAPhi's if available, otherwise
			// using immediate dominator final iterations, the entry node
			// cannot have phis, and has no immediate dominator, so we just
			// copy the original locals (iteration 0) as the currentIterations
			// So finally, now we can retarget uses of original locals by
			// keeping track of the current iterations, replacing source uses
			// with current iterations, and updating the current iterations
			// when there is local assignments
			IRLocal[] currentIterations = new IRLocal[originalCount];
			foreach (IRControlFlowGraphNode node in cfg.Nodes)
			{
				if (node.Index == 0) Locals.CopyTo(0, currentIterations, 0, originalCount);
				else
				{
					for (int index = 0; index < originalCount; ++index)
						currentIterations[index] = node.SSAPhis[index] ?? node.Dominator.SSAFinalIterations[index].Item1;
				}
				foreach (IRInstruction instruction in node.Instructions)
				{
					instruction.Sources.ForEach(l => l.RetargetLocals(currentIterations));
					if (instruction.Destination != null)
					{
						if (instruction.Destination.Type == IRLinearizedLocationType.Local)
						{
							tempLocal = Locals[instruction.Destination.Local.LocalIndex];
							currentIterations[tempLocal.SSAData.Original.Index] = tempLocal;
						}
						else
						{
							instruction.Destination.RetargetLocals(currentIterations);
						}
					}
				}
			}


			// At this point, most of the requirements set by SSA have been
			// fulfilled, all we want to do now is insert a move instruction
			// with a linearized phi source for each phi in the frontiers using
			// the parent final iterations created earlier, with phi reductions
			// based on lifetime analysis, so that various optimizations occuring
			// before leaving SSA can be done much more effectively
			IRMoveInstruction moveInstruction = null;
			IRLinearizedLocation location = null;
			HashSet<int> sourceLocals = new HashSet<int>(); // Used to prevent us from adding the same source twice
			foreach (IRControlFlowGraphNode node in cfg.Nodes)
			{
				for (int originalIndex = originalCount - 1; originalIndex >= 0; --originalIndex)
				{
					if (node.SSAPhis[originalIndex] != null)
					{
						moveInstruction = new IRMoveInstruction();
						moveInstruction.Destination = new IRLinearizedLocation(moveInstruction, IRLinearizedLocationType.Local);
						moveInstruction.Destination.Local.LocalIndex = node.SSAPhis[originalIndex].Index;
						location = new IRLinearizedLocation(moveInstruction, IRLinearizedLocationType.Phi);
						location.Phi.SourceLocations = new List<IRLinearizedLocation>();
						foreach (IRControlFlowGraphNode parentNode in node.ParentNodes)
						{
							int finalIterationIndex = parentNode.SSAFinalIterations[originalIndex].Item1.Index;
							if (sourceLocals.Add(finalIterationIndex))
							{
								IRLinearizedLocation phiSourceLocation = new IRLinearizedLocation(moveInstruction, IRLinearizedLocationType.Local);
								phiSourceLocation.Local.LocalIndex = finalIterationIndex;
								location.Phi.SourceLocations.Add(phiSourceLocation);
							}
						}
						sourceLocals.Clear();
						if (location.Phi.SourceLocations.Count == 1)
						{
							location.Type = IRLinearizedLocationType.Local;
							location.Local.LocalIndex = location.Phi.SourceLocations[0].Local.LocalIndex;
							location.Phi.SourceLocations = null;
						}
						moveInstruction.Sources.Add(location);
						InsertInstruction(node.Instructions[0].IRIndex, moveInstruction);
						node.Instructions.Insert(0, moveInstruction);
					}
				}
			}
			mInstructions.FixInsertedTargetInstructions();

			// Analyze local lifespans
			CalculateLocalSSALifespans(cfg);

			// Find dead phis that got move instructions inserted, and remove
			// the unneeded instructions, then fix branch targets again
			List<IRLocal> deadPhis = mLocals.FindAll(l => l.SSAData.Phi && l.SSAData.LifeBegins == l.SSAData.LifeEnds);
			IRInstruction onlyInstruction = null;
			foreach (IRLocal deadPhi in deadPhis)
			{
				onlyInstruction = deadPhi.SSAData.LifeBegins;
				mInstructions.Remove(onlyInstruction);
				deadPhi.SSAData.LifeBegins = null;
				deadPhi.SSAData.LifeEnds = null;
			}
			mInstructions.FixRemovedTargetInstructions();

			// Ensure that SSA lifespan analysis data is unusable, as it was
			// invalidated by dead phi removal
			mLocals.ForEach(l => l.SSAData.LifeBegins = l.SSAData.LifeEnds = null);
			//LayoutLocals();

			// Test that we did stuff right, make sure no local is assigned
			// more than once, though some may never get assigned due to
			// phi reductions that occur, if an exception is thrown here
			// it is most likely due to something that caused dead code
			// but never removed it before entering SSA, or a bug with
			// branching that removed a valid node and we luckily caught a
			// duplicate assignment due to unprocessed instructions
			bool[] assigned = new bool[Locals.Count];
			foreach (IRInstruction instruction in Instructions)
			{
				if (instruction.Destination != null && instruction.Destination.Type == IRLinearizedLocationType.Local)
				{
					if (assigned[instruction.Destination.Local.LocalIndex]) throw new Exception();
					assigned[instruction.Destination.Local.LocalIndex] = true;
				}
			}
		}
 private static void WriteModuleAndClassRegistrationFile(string file, HashSet<string> nativeModules, HashSet<string> nativeClasses, HashSet<string> classesToSkip)
 {
   using (TextWriter w = (TextWriter) new StreamWriter(file))
   {
     CodeStrippingUtils.WriteStaticallyLinkedModuleRegistration(w, nativeModules, nativeClasses);
     w.WriteLine();
     w.WriteLine("void RegisterAllClasses()");
     w.WriteLine("{");
     if (nativeClasses == null)
     {
       w.WriteLine("\tvoid RegisterAllClassesGranular();");
       w.WriteLine("\tRegisterAllClassesGranular();");
     }
     else
     {
       w.WriteLine("\t//Total: {0} classes", (object) nativeClasses.Count);
       int num = 0;
       using (HashSet<string>.Enumerator enumerator = nativeClasses.GetEnumerator())
       {
         while (enumerator.MoveNext())
         {
           string current = enumerator.Current;
           w.WriteLine("\t//{0}. {1}", (object) num, (object) current);
           if (classesToSkip.Contains(current))
           {
             w.WriteLine("\t//Skipping {0}", (object) current);
           }
           else
           {
             w.WriteLine("\tvoid RegisterClass_{0}();", (object) current);
             w.WriteLine("\tRegisterClass_{0}();", (object) current);
           }
           w.WriteLine();
           ++num;
         }
       }
     }
     w.WriteLine("}");
     w.Close();
   }
 }
        private void CheckTermsOrder(IndexReader r, ISet<string> allTerms, bool isTop)
        {
            TermsEnum terms = MultiFields.GetFields(r).Terms("f").Iterator(null);

            BytesRef last = new BytesRef();

            HashSet<string> seenTerms = new HashSet<string>();

            while (true)
            {
                BytesRef term = terms.Next();
                if (term == null)
                {
                    break;
                }

                Assert.IsTrue(last.CompareTo(term) < 0);
                last.CopyBytes(term);

                string s = term.Utf8ToString();
                Assert.IsTrue(allTerms.Contains(s), "term " + TermDesc(s) + " was not added to index (count=" + allTerms.Count + ")");
                seenTerms.Add(s);
            }

            if (isTop)
            {
                Assert.IsTrue(allTerms.SetEquals(seenTerms));
            }

            // Test seeking:
            IEnumerator<string> it = seenTerms.GetEnumerator();
            while (it.MoveNext())
            {
                BytesRef tr = new BytesRef(it.Current);
                Assert.AreEqual(TermsEnum.SeekStatus.FOUND, terms.SeekCeil(tr), "seek failed for term=" + TermDesc(tr.Utf8ToString()));
            }
        }
Example #14
0
    public override bool run()
    {
        BoardState boardState = new BoardState(droids, tiles, mapWidth(), mapHeight(), playerID());

          Console.WriteLine("Turn Number: " + turnNumber().ToString());

          // Find rightmost enemy turret and spawn terminator
          // If this is our first turn
          if (turnNumber() < 2)
          {
          int x1 = 10;
          int y1 = 0;
          int x2 = 10;
          int y2 = 0;
          bool foundSpot = false;
          bool foundSecondSpot = false;
          for (int i = 0; i < droids.Length; i++)
          {
              if (droids[i].Variant == (int)Unit.TURRET)
              {
                  if (droids[i].Owner != playerID())
                  {
                      if (getTile(droids[i].X, droids[i].Y).TurnsUntilAssembled == 0)
                      {
                          if (playerID() == 0)
                          {
                              if (droids[i].X > x1)
                              {
                                  foundSpot = true;
                                  x1 = droids[i].X;
                                  y1 = droids[i].Y;
                              }
                              else if (droids[i].X > x2)
                              {
                                  foundSecondSpot = true;
                                  x2 = droids[i].X;
                                  y2 = droids[i].Y;
                              }
                          }
                          else
                          {
                              if (droids[i].X < x1)
                              {
                                  foundSpot = true;
                                  x1 = droids[i].X;
                                  y1 = droids[i].Y;
                              }
                              else if (droids[i].X < x2)
                              {
                                  foundSecondSpot = true;
                                  x2 = droids[i].X;
                                  y2 = droids[i].Y;
                              }
                          }
                      }
                  }
              }
          }
          if (players[playerID()].ScrapAmount >= modelVariants[(int)Unit.TERMINATOR].Cost && foundSpot)
          {
              players[playerID()].orbitalDrop(x1, y1, (int)Unit.TERMINATOR);
          }
          if (players[playerID()].ScrapAmount >= modelVariants[(int)Unit.TERMINATOR].Cost && foundSecondSpot)
          {
              players[playerID()].orbitalDrop(x2, y2, (int)Unit.TERMINATOR);
          }
          }

          // Find and spawn claws on enemy turrets
          // also count how many of each type we have
          int terminators = 0, claws = 0, archers = 0, hackers = 0, repair = 0;
          for (int i = 0; i < droids.Length; i++)
          {
          if (droids[i].Variant == (int)Unit.TURRET)
          {
              if (droids[i].Owner != playerID())
              {
                  if (getTile(droids[i].X, droids[i].Y).TurnsUntilAssembled == 0)
                  {
                      if (players[playerID()].ScrapAmount >= modelVariants[(int)Unit.CLAW].Cost)
                      {
                          players[playerID()].orbitalDrop(droids[i].X, droids[i].Y, (int)Unit.CLAW);
                      }
                  }
              }
          }
          else
          {
              if (droids[i].Owner == playerID())
              {
                  switch (droids[i].Variant)
                  {
                      case (int)Unit.TERMINATOR:
                          terminators++;
                          break;
                      case (int)Unit.CLAW:
                          claws++;
                          break;
                      case (int)Unit.ARCHER:
                          archers++;
                          break;
                      case (int)Unit.HACKER:
                          hackers++;
                          break;
                      case (int)Unit.REPAIRER:
                          repair++;
                          break;
                  }
              }
          }
          }

          // DETECT WALLS
          int numUnits = 0;
          int colWithWall = -1;
          for (int i = 15; i < 25; i++)
          {
          int tempCount = 0;
          for (int j = 0; j < 20; j++)
          {
              if (boardState.theirMovables.getValueFromSpot(i, j) && !(getTile(i, j).TurnsUntilAssembled > 0))
                  tempCount++;
          }
          if (tempCount > numUnits)
          {
              numUnits = tempCount;
              colWithWall = i;
          }
          }
          // SPAWN CLAWS ON WALLS
          if (numUnits > 5)
          {
          for (int i = 0; i < 20; i++)
          {
              if (getTile(colWithWall, i).TurnsUntilAssembled == 0 && boardState.theirMovables.getValueFromSpot(colWithWall, i))
              {
                  if (players[playerID()].ScrapAmount >= modelVariants[(int)Unit.CLAW].Cost)
                  {
                      players[playerID()].orbitalDrop(colWithWall, i, (int)Unit.CLAW);
                  }
              }
          }
          }

          Func<Point, bool> isWalkable = delegate(Point p)
          {
          return boardState.walkable.getValueFromSpot(p.X, p.Y);
          };

          // Search for best spawn location
          int bestRow = 0;
          Bb middleRows = new Bb(mapWidth(), mapHeight());
          HashSet<int> badRows = new HashSet<int>();
          for (int i = 19; i < 21; i++)
          {
          for (int j = 0; j < mapHeight(); j++)
          {
              middleRows.setValueAtSpot(i, j);
          }
          }
          bool foundRow = false;
          int curCol = (playerID() == 0) ? 0 : mapWidth() - 1;
          Func<Point, bool> middleTarget = spot =>
          {
          return middleRows.getValueFromSpot(spot.X, spot.Y);
          };
          Bb spawnWalkable = new Bb(mapWidth(), mapHeight());
          spawnWalkable.board = spawnWalkable.board.Or(boardState.walkable.board);
          spawnWalkable.board = spawnWalkable.board.Or(boardState.ourMovables.board);
          spawnWalkable.board = spawnWalkable.board.Or(boardState.theirMovables.board);
          int searches = 0;
          Func<Point, bool> spawnWalkableFunc = spot =>
          {
          return spawnWalkable.getValueFromSpot(spot.X, spot.Y);
          };
          while (!foundRow && searches < 15)
          {
          int shortest = 50;
          searches++;
          for (int i = 0; i < mapHeight(); i++)
          {
              if (getTile(curCol, i).TurnsUntilAssembled == 0)
              {
                  IEnumerable<Point> path = Searcher.findPath(new Point(curCol, i), middleTarget, spawnWalkableFunc);
                  int temp = -1;
                  foreach (Point p in path)
                  {
                      temp++;
                  }
                  if (temp != -1 && temp < shortest)
                  {
                      shortest = temp;
                      bestRow = i;
                      foundRow = true;
                  }
                  else if (temp == -1)
                  {
                      badRows.Add(i);
                  }
              }
          }
          if (!foundRow)
          {
              curCol = playerID() == 0 ? curCol + 1 : curCol - 1;
              badRows.Clear();
              if (curCol < 0 || curCol >= mapWidth())
              {
                  curCol = (playerID() == 0) ? 0 : mapWidth() - 1;
                  break;
              }
          }
          }
          if (searches >= 5)
          {
          curCol = playerID() == 0 ? curCol + 1 : curCol - 1;
          badRows.Clear();
          bestRow = 0;
          }
          // want 1 terminator and hacker per 2 archers and 3 claws
          bool spawnClaws = terminators > claws && turnNumber() < 250;
          bool spawnArch = 2 * terminators > archers && !spawnClaws;
          bool spawnHack = terminators > hackers && turnNumber() > 25 && !spawnArch;
          bool spawnRepair = .5 * terminators > repair && turnNumber() > 75 && !spawnHack;

          int cost = 10;
          int unitID = 0;
          bool doomDrop = false;
          if (spawnClaws)
          {
          unitID = (int)Unit.CLAW;
          cost = modelVariants[(int)Unit.CLAW].Cost;
          }
          else if (spawnArch)
          {
          unitID = (int)Unit.ARCHER;
          cost = modelVariants[(int)Unit.ARCHER].Cost;
          }
          else if (spawnHack)
          {
          unitID = (int)Unit.HACKER;
          cost = modelVariants[(int)Unit.HACKER].Cost;
          }
          else if (spawnRepair)
          {
          unitID = (int)Unit.REPAIRER;
          cost = modelVariants[(int)Unit.REPAIRER].Cost;
          }
          else
          {
          Random rand = new Random();
          if (rand.Next() % 3 == 0 && 500 - turnNumber() > 90)
          {
              // DOOM DROP TERMINATORS
              doomDrop = true;
          }
          unitID = (int)Unit.TERMINATOR;
          cost = modelVariants[(int)Unit.TERMINATOR].Cost;
          }

          Bb myUnits = new Bb(mapWidth(), mapHeight());
          myUnits.board = myUnits.board.Or(boardState.ourHangers.board);
          myUnits.board = myUnits.board.Or(boardState.ourImmovables.board);
          myUnits.board = myUnits.board.Or(boardState.ourMovables.board);
          int iter = bestRow;
          int rowsChecked = 0;
          if (doomDrop)
          {
          // Search for walls
          bool foundAWall = true;
          while (players[playerID()].ScrapAmount >= modelVariants[(int)Unit.TERMINATOR].Cost && foundAWall)
          {
              bool foundWallThisIter = false;
              for (int i = 0; i < droids.Length; i++)
              {
                  if (droids[i].Owner != playerID())
                  {
                      if (droids[i].Variant == (int)Unit.WALL)
                      {
                          if (getTile(droids[i].X, droids[i].Y).TurnsUntilAssembled == 0)
                          {
                              if (playerID() == 0)
                              {
                                  if (droids[i].X > 20)
                                  {
                                      players[playerID()].orbitalDrop(droids[i].X, droids[i].Y, (int)Unit.TERMINATOR);
                                      foundWallThisIter = true;
                                  }
                              }
                              else
                              {
                                  if (droids[i].X < 20)
                                  {
                                      players[playerID()].orbitalDrop(droids[i].X, droids[i].Y, (int)Unit.TERMINATOR);
                                      foundWallThisIter = true;
                                  }
                              }
                          }
                      }
                  }
              }
              if (!foundWallThisIter)
                  foundAWall = false;
          }
          if (players[playerID()].ScrapAmount >= modelVariants[(int)Unit.TERMINATOR].Cost)
          {
              // search for unreachable squares
              int theirFirstCol = mapWidth() - 1;
              if (playerID() == 1)
                  theirFirstCol = 0;
              int doomSearchIter = 0;
              bool blockedSpotFound = false;
              HashSet<int> rowsToSpawn = new HashSet<int>();
              while (doomSearchIter < 12 && !blockedSpotFound)
              {
                  for (int i = 0; i < mapHeight(); i++)
                  {
                      if (!(getTile(theirFirstCol, i).TurnsUntilAssembled > 0))
                      {
                          IEnumerable<Point> path = Searcher.findPath(new Point(theirFirstCol, i), middleTarget, spawnWalkableFunc);
                          int temp = -1;
                          foreach (Point p in path)
                          {
                              temp++;
                          }
                          if (temp == -1)
                          {
                              rowsToSpawn.Add(i);
                          }
                      }
                  }
                  if (rowsToSpawn.Count > 0)
                  {
                      blockedSpotFound = true;
                  }
                  else
                  {
                      doomSearchIter++;
                      if (playerID() == 0)
                      {
                          theirFirstCol--;
                      }
                      else
                      {
                          theirFirstCol++;
                      }
                  }
              }
              Console.WriteLine("Doom drop search spot done");
              if (doomSearchIter >= 7)
              {
                  doomSearchIter = 0;
              }
              int anotherIter = 0;
              while (players[playerID()].ScrapAmount >= modelVariants[(int)Unit.TERMINATOR].Cost && rowsToSpawn.Count > 0 && anotherIter < 2)
              {
                  int chooseRow = rowsToSpawn.GetEnumerator().Current;
                  players[playerID()].orbitalDrop(theirFirstCol, chooseRow, (int)Unit.TERMINATOR);
                  rowsToSpawn.Remove(chooseRow);
                  anotherIter++;
              }
              Console.WriteLine("Best spots have been tried");
              if (players[playerID()].ScrapAmount >= modelVariants[(int)Unit.TERMINATOR].Cost)
              {
                  theirFirstCol = mapWidth() - 1;
                  if (playerID() == 1)
                      theirFirstCol = 0;
                  for (int i = 0; i < mapHeight() && players[playerID()].ScrapAmount >= modelVariants[(int)Unit.TERMINATOR].Cost; i++)
                  {
                      if (!(getTile(theirFirstCol, i).TurnsUntilAssembled > 0))
                      {
                          if (!boardState.theirHangers.getValueFromSpot(theirFirstCol, i))
                          {
                              players[playerID()].orbitalDrop(theirFirstCol, i, (int)Unit.TERMINATOR);
                          }
                      }
                  }
              }
          }
          }
          else
          {
          while (rowsChecked < mapHeight())
          {
              // Not a bad row
              if (!badRows.Contains(iter))
              {
                  // enough scrap
                  if (players[playerID()].ScrapAmount >= cost)
                  {
                      // nothing spawning here
                      if (getTile(curCol, iter).TurnsUntilAssembled == 0)
                      {
                          if (!myUnits.getValueFromSpot(curCol, iter))
                          {
                              // spawn it
                              players[playerID()].orbitalDrop(curCol, iter, unitID);
                          }
                      }
                  }
                  iter++;
                  if (iter >= mapHeight())
                      iter = 0;
              }
              rowsChecked++;
          }
          }

          // ATTACK
          Func<Point, bool> isAttackable = delegate(Point p)
          {
          return boardState.theirHangers.getValueFromSpot(p.X, p.Y) || boardState.hackTargets.getValueFromSpot(p.X, p.Y);
          };
          Func<Point, bool> nope = delegate(Point p)
          {
          return false;
          };
          for (int i = 0; i < droids.Length; i++)
          {
          //if you have control of the droid
          if ((droids[i].Owner == playerID() && droids[i].HackedTurnsLeft <= 0) ||
              (droids[i].Owner != playerID() && droids[i].HackedTurnsLeft > 0))
          {
              //if there are any attacks left
              if (droids[i].AttacksLeft > 0)
              {
                  if (droids[i].Variant == (int)Unit.REPAIRER)
                  {
                      Bb targets = new Bb(boardState.ourHangers.width, boardState.ourHangers.height);
                      targets.board = targets.board.Or(boardState.ourHangers.board);
                      targets.board = targets.board.Or(boardState.ourMovables.board);
                      targets.board = targets.board.Or(boardState.ourImmovables.board);
                      Func<Point, bool> target = spot =>
                      {
                          return targets.getValueFromSpot(spot.X, spot.Y);
                      };
                      CIA.runMission(new Mission(MissionTypes.attackInRange, droids[i], target, isWalkable, nope));
                  }
                  else
                  {
                      Func<Point, bool> hackerTarget = spot =>
                      {
                          return boardState.hackTargets.getValueFromSpot(spot.X, spot.Y);
                      };
                      Func<Point, bool> target = spot =>
                      {
                          return boardState.attackTargets.getValueFromSpot(spot.X, spot.Y);
                      };

                      if (droids[i].Variant != (int)Unit.HACKER)
                      {
                          CIA.runMission(new Mission(MissionTypes.attackInRange, droids[i], target, isWalkable, nope));
                      }
                      else
                      {
                          CIA.runMission(new Mission(MissionTypes.attackInRange, droids[i], hackerTarget, isWalkable, nope));
                      }
                  }
                  boardState.update(droids, tiles);
              }
          }
          }

          Func<Point, bool> isEnemyHangar = delegate(Point p)
          {
          return boardState.theirHangers.getValueFromSpot(p.X, p.Y);
          };
          Func<Point, bool> isNotAttacked = delegate(Point p)
          {
          return boardState.notAttackedByEnemy.getValueFromSpot(p.X, p.Y);
          };
          Func<Point, bool> isGoalHacker = delegate(Point p)
          {
          return boardState.hackTargets.getValueFromSpot(p.X, p.Y);
          };

          for (int i = 0; i < droids.Length; i++)
          {
          if (droids[i].MovementLeft > 0 && ((droids[i].Owner == playerID() && droids[i].HackedTurnsLeft == 0) || (droids[i].Owner != playerID() && droids[i].HackedTurnsLeft > 0)))
          {
              if (droids[i].HealthLeft < .3 * droids[i].MaxHealth)
              {
                  Bb spotsOnOurSide = new Bb(mapWidth(), mapHeight());
                  spotsOnOurSide.board = spotsOnOurSide.board.Or(boardState.ourHalf.board);
                  if (droids[i].Variant == (int)Unit.REPAIRER)
                  {
                      Bb ourUnitsOurSide = new Bb(mapWidth(), mapHeight());
                      ourUnitsOurSide.board = ourUnitsOurSide.board.Or(boardState.ourHalf.board);
                      ourUnitsOurSide.board = ourUnitsOurSide.board.And(boardState.ourMovables.board);
                      Func<Point, bool> healTarget = spot =>
                      {
                          return ourUnitsOurSide.getValueFromSpot(spot.X, spot.Y);
                      };
                      CIA.runMission(new Mission(MissionTypes.goTo, droids[i], healTarget, isWalkable, nope));
                      spotsOnOurSide.board = spotsOnOurSide.board.And(boardState.walkable.board);
                      Func<Point, bool> runAway = spot =>
                      {
                          return spotsOnOurSide.getValueFromSpot(spot.X, spot.Y);
                      };
                      CIA.runMission(new Mission(MissionTypes.goTo, droids[i], runAway, isWalkable, isAttackable));
                  }
                  else
                  {
                      Bb theirUnitsOurSide = new Bb(mapWidth(), mapHeight());
                      theirUnitsOurSide.board = theirUnitsOurSide.board.Or(boardState.ourHalf.board);
                      theirUnitsOurSide.board = theirUnitsOurSide.board.And(boardState.theirMovables.board);
                      Func<Point, bool> attackOurSide = spot =>
                      {
                          return theirUnitsOurSide.getValueFromSpot(spot.X, spot.Y);
                      };
                      CIA.runMission(new Mission(MissionTypes.goTo, droids[i], attackOurSide, isWalkable, isAttackable));
                      spotsOnOurSide.board = spotsOnOurSide.board.And(boardState.walkable.board);
                      Func<Point, bool> runAway = spot =>
                      {
                          return spotsOnOurSide.getValueFromSpot(spot.X, spot.Y);
                      };
                      CIA.runMission(new Mission(MissionTypes.goTo, droids[i], runAway, isWalkable, isAttackable));
                  }
              }
              else
              {
                  if (!(droids[i].Variant == (int)Unit.HACKER))
                  {
                      if (droids[i].Variant == (int)Unit.REPAIRER)
                      {
                          Func<Point, bool> healTarget = spot =>
                          {
                              return boardState.ourUnitsLowArmor.getValueFromSpot(spot.X, spot.Y);
                          };
                          CIA.runMission(new Mission(MissionTypes.goTo, droids[i], healTarget, isWalkable, nope));
                      }
                      else if (droids[i].Variant == (int)Unit.TERMINATOR)
                      {
                          if (!CIA.runMission(new Mission(MissionTypes.goTo, droids[i], isEnemyHangar, isWalkable, isAttackable)))
                          {
                              CIA.runMission(new Mission(MissionTypes.goTo, droids[i], isGoalHacker, isWalkable, isAttackable));
                          }
                      }
                      else
                      {
                          if (!CIA.runMission(new Mission(MissionTypes.goTo, droids[i], isGoalHacker, isWalkable, isAttackable)))
                          {
                              CIA.runMission(new Mission(MissionTypes.goTo, droids[i], isEnemyHangar, isWalkable, isAttackable));
                          }
                      }
                  }
                  else
                  {
                      CIA.runMission(new Mission(MissionTypes.goTo, droids[i], isGoalHacker, isWalkable, isAttackable));
                  }
              }
              boardState.update(droids, tiles);
          }
          }

          // ATTACK again
          for (int i = 0; i < droids.Length; i++)
          {
          //if you have control of the droid
          if ((droids[i].Owner == playerID() && droids[i].HackedTurnsLeft <= 0) ||
              (droids[i].Owner != playerID() && droids[i].HackedTurnsLeft > 0))
          {
              //if there are any attacks left
              if (droids[i].AttacksLeft > 0)
              {
                  if (droids[i].Variant == (int)Unit.REPAIRER)
                  {
                      Bb targets = new Bb(boardState.ourHangers.width, boardState.ourHangers.height);
                      targets.board = targets.board.Or(boardState.ourHangers.board);
                      targets.board = targets.board.Or(boardState.ourMovables.board);
                      targets.board = targets.board.Or(boardState.ourImmovables.board);
                      Func<Point, bool> target = spot =>
                      {
                          return targets.getValueFromSpot(spot.X, spot.Y);
                      };
                      CIA.runMission(new Mission(MissionTypes.attackInRange, droids[i], target, isWalkable, nope));
                  }
                  else
                  {
                      Func<Point, bool> hackerTarget = spot =>
                      {
                          return boardState.hackTargets.getValueFromSpot(spot.X, spot.Y);
                      };
                      Func<Point, bool> target = spot =>
                      {
                          return boardState.attackTargets.getValueFromSpot(spot.X, spot.Y);
                      };
                      if (droids[i].Variant != (int)Unit.HACKER)
                      {
                          CIA.runMission(new Mission(MissionTypes.attackInRange, droids[i], target, isWalkable, nope));
                      }
                      else
                      {
                          CIA.runMission(new Mission(MissionTypes.attackInRange, droids[i], hackerTarget, isWalkable, nope));
                      }
                  }
                  boardState.update(droids, tiles);
              }
          }
          }

          #region Old Spawn Code
          //for (int i = 0; i < mapHeight(); i++)
          //{
          //    //make sure you own enough scrap
          //    if (players[playerID()].ScrapAmount >= modelVariants[(int)Unit.CLAW].Cost)
          //    {
          //        //make sure nothing is spawning there
          //        if (getTile((mapWidth() - 1) * playerID(), i).TurnsUntilAssembled == 0)
          //        {
          //            //make sure there isn't a hangar there
          //            if (!boardState.ourHangers.getValueFromSpot((mapWidth() - 1) * playerID(), i))
          //            {
          //                //spawn the claw
          //                players[playerID()].orbitalDrop((mapWidth() - 1) * playerID(), i, (int)Unit.CLAW);
          //            }
          //        }
          //    }
          //}
          #endregion

          return true;
    }
Example #15
0
        public NetworkGraph( int numNodePairs )
        {
            HashSet<Edge> initialEdges = new HashSet<Edge>();
            String nodeType1;
            String nodeType2;

            for (int i = 0; i < numNodePairs; i++)
            {
                String address1 = this.GenerateIPAddress();
                String address2 = this.GenerateIPAddress();

                if (uniqueAddresses.Contains(address1) || uniqueAddresses.Contains(address2))
                    continue;

                do
                {
                    nodeType1 = GenerateNodeType();
                    nodeType2 = GenerateNodeType();
                } while (!ValidateNodeConnection(nodeType1, nodeType2));

                Node x = new Node(nodeType1, address1);
                Node y = new Node(nodeType2, address2);

                Edge edge = new Edge(x, y, GenerateWeight());

                x.AddEdge(edge);
                y.AddEdge(edge);

                initialEdges.Add(edge);
                networkGraph.Add(x);
                networkGraph.Add(y);

                uniqueAddresses.Add(address1);
                uniqueAddresses.Add(address2);
            }

            using (IEnumerator<Edge> it = initialEdges.GetEnumerator())
            {

                it.MoveNext();

                Edge curEdge = it.Current;

                while (it.MoveNext())
                {
                    Edge nextEdge = it.Current;

                    Node curX = curEdge.GetX();
                    Node curY = curEdge.GetY();

                    Node nextX = nextEdge.GetX();
                    Node nextY = nextEdge.GetY();

                    if (ValidateNodeConnection(curX.GetType().ToString(), nextX.GetType().ToString()))
                    {
                        Edge newXX = new Edge(curX, nextX, GenerateWeight());

                        curX.AddEdge(newXX);
                        nextX.AddEdge(newXX);
                    }
                    else if (ValidateNodeConnection(curX.GetType().ToString(), nextY.GetType().ToString()))
                    {
                        Edge newXY = new Edge(curX, nextY, GenerateWeight());

                        curX.AddEdge(newXY);
                        nextY.AddEdge(newXY);
                    }
                    else if (ValidateNodeConnection(curY.GetType().ToString(), nextX.GetType().ToString()))
                    {
                        Edge newYX = new Edge(curY, nextX, GenerateWeight());

                        curX.AddEdge(newYX);
                        nextY.AddEdge(newYX);
                    }
                    else if (ValidateNodeConnection(curY.GetType().ToString(), nextY.GetType().ToString()))
                    {
                        Edge newYY = new Edge(curY, nextY, GenerateWeight());

                        curX.AddEdge(newYY);
                        nextY.AddEdge(newYY);
                    }
                    curEdge = nextEdge;
                }
            }
        }
Example #16
0
        internal static void _CrossOver(Location[] locations1, Location[] locations2, bool mutateFailedCrossovers)
        {
            // I am not validating parameters because this method is internal.
            // If you want to make it public, you should validate the parameters.

            var availableLocations = new HashSet<Location>(locations1);

            int startPosition = GetRandomValue(locations1.Length);
            int crossOverCount = GetRandomValue(locations1.Length - startPosition);

            if (mutateFailedCrossovers)
            {
                bool useMutation = true;
                int pastEndPosition = startPosition + crossOverCount;
                for (int i=startPosition; i<pastEndPosition; i++)
                {
                    if (locations1[i] != locations2[i])
                    {
                        useMutation = false;
                        break;
                    }
                }

                // if the crossover is not going to give any change, we
                // force a mutation.
                if (useMutation)
                {
                    MutateRandomLocations(locations1);
                    return;
                }
            }

            Array.Copy(locations2, startPosition, locations1, startPosition, crossOverCount);
            List<int> toReplaceIndexes = null;

            // Now we will remove the used locations from the available locations.
            // If we can't remove one, this means it was used in duplicate. At this
            // moment we only register those indexes that have duplicate locations.
            int index = 0;
            foreach(var value in locations1)
            {
                if (!availableLocations.Remove(value))
                {
                    if (toReplaceIndexes == null)
                        toReplaceIndexes = new List<int>();

                    toReplaceIndexes.Add(index);
                }

                index++;
            }

            // Finally we will replace duplicated items by those that are still available.
            // This is how we avoid having chromosomes that contain duplicated places to go.
            if (toReplaceIndexes != null)
            {
                // To do this, we enumerate two objects in parallel.
                // If we could use foreach(var indexToReplace, location from toReplaceIndexex, location1) it would be great.
                using(var enumeratorIndex = toReplaceIndexes.GetEnumerator())
                {
                    using(var enumeratorLocation = availableLocations.GetEnumerator())
                    {
                        while(true)
                        {
                            if (!enumeratorIndex.MoveNext())
                            {
                                Debug.Assert(!enumeratorLocation.MoveNext());
                                break;
                            }

                            if (!enumeratorLocation.MoveNext())
                                throw new InvalidOperationException("Something wrong happened.");

                            locations1[enumeratorIndex.Current] = enumeratorLocation.Current;
                        }
                    }
                }
            }
        }
Example #17
0
        /**
        * Allowed end-points /activities/{userId}/{groupId}/{optionalActvityId}+
        * /activities/{userId}+/{groupId}
        *
        * examples: /activities/john.doe/@self/1 /activities/john.doe/@self
        * /activities/john.doe,jane.doe/@friends
        */
        protected override object handleGet(RequestItem request)
        {
            request.applyUrlTemplate(ACTIVITY_ID_PATH);

            HashSet<UserId> userIds = request.getUsers();
            HashSet<String> optionalActivityIds = new HashSet<string>(request.getListParameter("activityId"));

            // Preconditions
            Preconditions<UserId>.requireNotEmpty(userIds, "No userId specified");
            if (userIds.Count > 1 && optionalActivityIds.Count != 0)
            {
                throw new ArgumentException("Cannot fetch same activityIds for multiple userIds");
            }

            CollectionOptions options = new CollectionOptions();
            options.setSortBy(request.getSortBy());
            options.setSortOrder(request.getSortOrder());
            options.setFilter(request.getFilterBy());
            options.setFilterOperation(request.getFilterOperation());
            options.setFilterValue(request.getFilterValue());
            options.setFirst(request.getStartIndex());
            options.setMax(request.getCount() ?? RequestItem.DEFAULT_COUNT);

            if (optionalActivityIds.Count != 0)
            {
                if (optionalActivityIds.Count == 1)
                {
                    IEnumerator<UserId> iuserid = userIds.GetEnumerator();
                    iuserid.MoveNext();
                    IEnumerator<string> iactivity = optionalActivityIds.GetEnumerator();
                    iactivity.MoveNext();
                    return service.getActivity(iuserid.Current, request.getGroup(),
                                               request.getAppId(), options, request.getFields(), iactivity.Current,
                                               request.getToken());
                }
                else
                {
                    IEnumerator<UserId> iuserid = userIds.GetEnumerator();
                    iuserid.MoveNext();
                    return service.getActivities(iuserid.Current, request.getGroup(),
                                                 request.getAppId(), request.getFields(), optionalActivityIds, request.getToken());
                }
            }

            return service.getActivities(userIds, request.getGroup(), request.getAppId(), options,
                                      request.getFields(), request.getToken());
        }
 private static void ExcludeModuleManagers(ref HashSet<string> nativeClasses)
 {
   string[] moduleNames = ModuleMetadata.GetModuleNames();
   int classId = BaseObjectTools.StringToClassID("GlobalGameManager");
   foreach (string moduleName in moduleNames)
   {
     if (ModuleMetadata.GetModuleStrippable(moduleName))
     {
       int[] moduleClasses = ModuleMetadata.GetModuleClasses(moduleName);
       HashSet<int> intSet = new HashSet<int>();
       HashSet<string> stringSet = new HashSet<string>();
       foreach (int num in moduleClasses)
       {
         if (BaseObjectTools.IsDerivedFromClassID(num, classId))
           intSet.Add(num);
         else
           stringSet.Add(BaseObjectTools.ClassIDToString(num));
       }
       if (stringSet.Count != 0 && !nativeClasses.Overlaps((IEnumerable<string>) stringSet))
       {
         using (HashSet<int>.Enumerator enumerator = intSet.GetEnumerator())
         {
           while (enumerator.MoveNext())
           {
             int current = enumerator.Current;
             nativeClasses.Remove(BaseObjectTools.ClassIDToString(current));
           }
         }
       }
     }
   }
 }
 private static void WriteStaticallyLinkedModuleRegistration(TextWriter w, HashSet<string> nativeModules, HashSet<string> nativeClasses)
 {
   w.WriteLine("struct ClassRegistrationContext;");
   w.WriteLine("void InvokeRegisterStaticallyLinkedModuleClasses(ClassRegistrationContext& context)");
   w.WriteLine("{");
   if (nativeClasses == null)
   {
     w.WriteLine("\tvoid RegisterStaticallyLinkedModuleClasses(ClassRegistrationContext&);");
     w.WriteLine("\tRegisterStaticallyLinkedModuleClasses(context);");
   }
   else
     w.WriteLine("\t// Do nothing (we're in stripping mode)");
   w.WriteLine("}");
   w.WriteLine();
   w.WriteLine("void RegisterStaticallyLinkedModulesGranular()");
   w.WriteLine("{");
   using (HashSet<string>.Enumerator enumerator = nativeModules.GetEnumerator())
   {
     while (enumerator.MoveNext())
     {
       string current = enumerator.Current;
       w.WriteLine("\tvoid RegisterModule_" + current + "();");
       w.WriteLine("\tRegisterModule_" + current + "();");
       w.WriteLine();
     }
   }
   w.WriteLine("}");
 }
Example #20
0
 private ObjectId GetFirst(HashSet<ObjectId> hashSet)
 {
     var enumerator = hashSet.GetEnumerator();
     enumerator.MoveNext();
     return enumerator.Current;
 }
Example #21
0
		/** Resume selectors on a set of targets.
		 This can be useful for undoing a call to pauseAllSelectors.
		 @since v2.0.0
		  */
		public void resumeTargets(HashSet<System.Object> targetsToResume){
			var enumerator = targetsToResume.GetEnumerator();
			while (enumerator.MoveNext()) {
				var target = enumerator.Current;
				resumeTarget(target);
			}
		}
Example #22
0
	private bool included(){
		
		List<Pair<Arc, HashSet<Arc>>> Q1=this.buildSingleCharacterSuperGraphs();

        foreach (Pair<Arc, HashSet<Arc>> g in Q1)
        {
            if (!double_graph_test(g, g, spec.InitialState.id))
            {
                return false;
            }
        }
        HashSet<Pair<Arc, HashSet<Arc>>> Next = new HashSet<Pair<Arc, HashSet<Arc>>>(Q1);
		HashSet<Pair<Arc, HashSet<Arc>>> Processed=new HashSet<Pair<Arc, HashSet<Arc>>>();
		
		while(Next.Count > 0){
            HashSet<Pair<Arc, HashSet<Arc>>>.Enumerator Enumerator = Next.GetEnumerator();
            Pair<Arc, HashSet<Arc>> g = Enumerator.Current;

            foreach (Pair<Arc, HashSet<Arc>> h in Processed)
            {
				if(!double_graph_test(g, h, spec.InitialState.id)||!double_graph_test(h, g, spec.InitialState.id))
					return false;
			}

            Next.Remove(g);

            Processed.Add(g);
			//debug("Processed:"+Processed);
			//debug("Next:"+Next);

            foreach (Pair<Arc, HashSet<Arc>> h in Q1)
            {
				List<Pair<Arc, HashSet<Arc>>> toRemove=new List<Pair<Arc, HashSet<Arc>>>();
				if(composable(g,h)){
				Pair<Arc, HashSet<Arc>> f=compose(g, h);
				bool discard=false;

				//debug("f:"+f +"="+g+";"+h);


                foreach (Pair<Arc, HashSet<Arc>> p in Processed)
                {

					if(smallerThan(f, p)){
						toRemove.Add(p);
					}
					if(smallerThan(p, f)){
						discard=true;
						break;
					}
				}
				if(discard)
					continue;

                foreach (Pair<Arc, HashSet<Arc>> p in Next)
                {

					if(smallerThan(f, p)){
						toRemove.Add(p);
					}
					if(smallerThan(p, f)){
						discard=true;
						break;
					}
				}
				if(discard)
					continue;
				if(!double_graph_test(f, f, spec.InitialState.id))
					return false;

				//Processed.removeAll(toRemove);
				//Next.removeAll(toRemove);

                foreach (Pair<Arc, HashSet<Arc>> pair in toRemove)
                {
                    Processed.Remove(pair);
                    Next.Remove(pair);
                }

				if(opt2)
					Next.Add(min(f));
				else
					Next.Add(f);
				}
			}
		}			
		return true;
	}
Example #23
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="dirs"></param>
        /// <param name="files"></param>
        /// <param name="exts"></param>
        /// <param name="saveFileListsFile">The complete file name (minus dot and extension) of result files</param>
        /// <returns></returns>
        public long ParseDirFilenamesAndExtension(HashSet<String> dirs, HashSet<String> files, HashSet<String> exts, string outputFileRoot)
        {
            Start();
            hashDic.CreateHelpers();
            long result = 0;

            // make it dual core friendly. cut by dirs...
            filenamesFoundInTest = 0;

            if (outputFileRoot != null)
            {
                foundNames = new Dictionary<string, bool>();

                foreach (string filename in files)
                    foundNames[filename] = false;
            }

            parseDirList = dirs.GetEnumerator();

            threadList = new List<Thread>();   // launches as many threads as processors
            for (int i = 0; i < System.Environment.ProcessorCount && i < HashCreatorConfig.MaxOperationThread; i++)
            {
                Thread t = new Thread(new ParameterizedThreadStart(calc));
                t.Start(new ThreadParam(dirs, files, exts, 0, dirs.Count / 2, outputFileRoot));
                threadList.Add(t);
            }

            for (int i = 0; i < threadList.Count; i++)
            {
                threadList[i].Join();
            }

            //if (dirs.Count > 10)
            //{
            //    Thread t1 = new Thread(new ParameterizedThreadStart(calc));
            //    Thread t2 = new Thread(new ParameterizedThreadStart(calc));
            //    t1.Start(new ThreadParam(dirs, files, exts, 0, dirs.Count / 2, outputFileRoot));
            //    t2.Start(new ThreadParam(dirs, files, exts, dirs.Count / 2, dirs.Count, outputFileRoot));

            //    t1.Join();
            //    t2.Join();
            //}
            //else
            //{
            //    Thread t1 = new Thread(new ParameterizedThreadStart(calc));
            //    t1.Start(new ThreadParam(dirs, files, exts, 0, dirs.Count, outputFileRoot));
            //    t1.Join();
            //}

            result = filenamesFoundInTest;
            filenamesFoundInTest = 0; // ok. The threads just exited.

            if (outputFileRoot != null && active)
            {
                FileStream ofsFound = new FileStream(outputFileRoot + "-found.txt", FileMode.Create);
                FileStream ofsNotFound = new FileStream(outputFileRoot + "-notfound.txt", FileMode.Create);
                StreamWriter swf = new StreamWriter(ofsFound);
                StreamWriter swnf = new StreamWriter(ofsNotFound);

                foreach (KeyValuePair<string, Boolean> file in foundNames)
                    if (file.Value == true)
                        swf.WriteLine(file.Key);
                    else
                        swnf.WriteLine(file.Key);

                swnf.Close();
                swf.Close();
                ofsFound.Close();
                ofsNotFound.Close();
            }

            return result;
        }
Example #24
0
        public override bool Begin() {
            if( !RaiseBeginningEvent( this ) ) return false;
            UndoState = Player.DrawBegin( this );
            StartTime = DateTime.UtcNow;

            if( !(Brush is NormalBrush) ) {
                // for nonstandard brushes, cache all coordinates up front
                nonStandardBrush = true;

                // Generate a list if all coordinates
                allCoords = new HashSet<Vector3I>();
                while( coordEnumerator.MoveNext() ) {
                    allCoords.Add( coordEnumerator.Current );
                }
                coordEnumerator.Dispose();

                // Replace our F2D enumerator with a HashSet enumerator
                coordEnumerator = allCoords.GetEnumerator();
            }

            HasBegun = true;
            Map.QueueDrawOp( this );
            RaiseBeganEvent( this );
            return true;
        }
Example #25
0
        public OpResult show_stats(string template, HashSet<int> results)
        {
            OpResult op_return = new OpResult(OpStatusCode.Ok);
            string template_list = "";
            int pic_count = photo_media_play_list.count;

            if (results.Count > 0) pic_count = results.Count;

            string output_template = getTemplate(template + "+", DEFAULT_STATS_HEAD);
            output_template += getTemplate(template, DEFAULT_STATS_RESULT);
            output_template += getTemplate(template + "-", DEFAULT_STATS_FOOT);

            if (output_template.Length > 0)
            {
                output_template = file_includer(output_template);
                output_template = do_conditional_replace(output_template, "results_count", String.Format("{0}", pic_count));
                output_template = do_conditional_replace(output_template, "tag_count", String.Format("{0}", kw_count));
                output_template = do_conditional_replace(output_template, "start_date", String.Format("{0}", first_date.ToShortDateString()));
                output_template = do_conditional_replace(output_template, "end_date", String.Format("{0}", last_date.ToShortDateString()));
                output_template = do_conditional_replace(output_template, "filter_is_tagged", String.Format("{0}", param_is_tagged));
                output_template = do_conditional_replace(output_template, "filter_not_tagged", String.Format("{0}", param_not_tagged));
                output_template = do_conditional_replace(output_template, "filter_start_date", String.Format("{0}", param_start_date));
                output_template = do_conditional_replace(output_template, "filter_end_date", String.Format("{0}", param_end_date));
                if (output_template.IndexOf("%available_templates%") >= 0)
                {
                    foreach (KeyValuePair<string, string> t in m_templates)
                    {
                        if (!t.Key.EndsWith("+") && !t.Key.EndsWith("-"))
                        {
                            if (template_list.Length > 0) template_list += ", ";
                            template_list += t.Key;
                        }
                    }
                }
                /* get random image index in results if needed */
                if (output_template.Contains("%random_id%"))
                {
                    int random_index = new Random().Next(pic_count);
                    string random = "";

                    if (results.Count > 0)
                    {
                        HashSet<int>.Enumerator results_enum = results.GetEnumerator();
                        for (int i = 0; i < random_index; i++) results_enum.MoveNext();
                        random = "" + results_enum.Current;
                    }
                    else random = "" + random_index;
                    output_template = do_conditional_replace(output_template, "random_id", random);
                }
                output_template = do_conditional_replace(output_template, "available_templates", template_list);
                op_return.AppendFormat("{0}", output_template);
            }

            return op_return;
        }
Example #26
0
        /// <summary> Reads the connection rule data file, and initialize the object.</summary>
        /// <param name="filePath">- the path for the connection rule file
        /// </param>
        /// <param name="tagCount">- the number of total tags in the tag set
        /// </param>
        /// <param name="tagSet">- the tag set which is used in the connection rules
        /// </param>
        /// <throws>  IOException </throws>
        private void readFile(System.String filePath, int tagCount, TagSet tagSet)
        {
            System.IO.StreamReader br = new System.IO.StreamReader(
                new System.IO.FileStream(filePath, System.IO.FileMode.Open, System.IO.FileAccess.Read),
                System.Text.Encoding.UTF8);
            System.String line = null;
            HashSet<int> tagSetA = new HashSet<int>();
            HashSet<int> tagSetB = new HashSet<int>();

            title = "";
            version = "";
            copyright = "";
            author = "";
            date = "";
            editor = "";
            startTag = "";
            connectionTable = new bool[tagCount][];
            for (int i = 0; i < tagCount; i++)
            {
                connectionTable[i] = new bool[tagCount];
            }

            for (int i = 0; i < tagCount; i++)
            {
                for (int j = 0; j < tagCount; j++)
                {
                    connectionTable[i][j] = false;
                }
            }

            while ((line = br.ReadLine()) != null)
            {
                StringTokenizer lineTokenizer = new StringTokenizer(line, "\t");
                if (lineTokenizer.HasMoreTokens == false)
                {
                    continue;
                }

                System.String lineToken = lineTokenizer.NextToken;

                if (lineToken.StartsWith("@"))
                {
                    if ("@title".Equals(lineToken))
                    {
                        title = lineTokenizer.NextToken;
                    }
                    else if ("@version".Equals(lineToken))
                    {
                        version = lineTokenizer.NextToken;
                    }
                    else if ("@copyright".Equals(lineToken))
                    {
                        copyright = lineTokenizer.NextToken;
                    }
                    else if ("@author".Equals(lineToken))
                    {
                        author = lineTokenizer.NextToken;
                    }
                    else if ("@date".Equals(lineToken))
                    {
                        date = lineTokenizer.NextToken;
                    }
                    else if ("@editor".Equals(lineToken))
                    {
                        editor = lineTokenizer.NextToken;
                    }
                }
                else if ("CONNECTION".Equals(lineToken))
                {
                    lineToken = lineTokenizer.NextToken;
                    System.String[] tagLists = lineToken.Split("\\*", 2);

                    StringTokenizer tagTokenizer = new StringTokenizer(tagLists[0], ",()");
                    while (tagTokenizer.HasMoreTokens)
                    {
                        System.String tagToken = tagTokenizer.NextToken;

                        StringTokenizer tok = new StringTokenizer(tagToken, "-");
                        while (tok.HasMoreTokens)
                        {
                            System.String t = tok.NextToken;
                            int[] fullTagIDSet = tagSet.getTags(t);

                            if (fullTagIDSet != null)
                            {
                                for (int i = 0; i < fullTagIDSet.Length; i++)
                                {
                                    tagSetA.Add(fullTagIDSet[i]);
                                }
                            }
                            else
                            {
                                tagSetA.Add(tagSet.getTagID(t));
                            }
                            while (tok.HasMoreTokens)
                            {
                                tagSetA.Remove(tagSet.getTagID(tok.NextToken));
                            }
                        }
                    }

                    tagTokenizer = new StringTokenizer(tagLists[1], ",()");
                    while (tagTokenizer.HasMoreTokens)
                    {
                        System.String tagToken = tagTokenizer.NextToken;

                        StringTokenizer tok = new StringTokenizer(tagToken, "-");
                        while (tok.HasMoreTokens)
                        {
                            System.String t = tok.NextToken;
                            int[] fullTagIDSet = tagSet.getTags(t);

                            if (fullTagIDSet != null)
                            {
                                for (int i = 0; i < fullTagIDSet.Length; i++)
                                {
                                    tagSetB.Add(fullTagIDSet[i]);
                                }
                            }
                            else
                            {
                                tagSetB.Add(tagSet.getTagID(t));
                            }
                            while (tok.HasMoreTokens)
                            {
                                tagSetB.Remove(tagSet.getTagID(tok.NextToken));
                            }
                        }
                    }

                    IEnumerator<int> iterA = tagSetA.GetEnumerator();
                    while (iterA.MoveNext())
                    {
                        int leftSide = iterA.Current;
                        IEnumerator<int> iterB = tagSetB.GetEnumerator();

                        while (iterB.MoveNext())
                        {
                            connectionTable[leftSide][iterB.Current] = true;
                        }
                    }

                    tagSetA.Clear();
                    tagSetB.Clear();
                }
                else if ("START_TAG".Equals(lineToken))
                {
                    startTag = lineTokenizer.NextToken;
                }
            }
            br.Close();
        }
Example #27
0
        /// <summary>
        /// Reads events into a linked list. The predicates associated with each event are 
        /// counted and any which occur at least N times (cutoff) are added to the
        /// <paramref name="predicatesInOut"/> map along with a unique integer index.
        /// </summary>
        /// <param name="eventStore">A writer to which the events are written to for later processing.</param>
        /// <param name="predicatesInOut">The predicates in out.</param>
        /// <returns>The number of events readed from the event stream.</returns>
        private int ComputeEventCounts(StreamWriter eventStore, Dictionary<string, int> predicatesInOut) {

            int eventCount = 0;
            var counter = new Dictionary<string, int>();
            //var predicateSet = new Java.HashSet<string>();

            var predicateSet = new HashSet<string>();

            Event ev;
            while ((ev = EventStream.Read()) != null) {

                if (Monitor != null && Monitor.Token.CanBeCanceled)
                    Monitor.Token.ThrowIfCancellationRequested();

                eventCount++;

                eventStore.Write(FileEventStream.ToLine(ev));

                Update(ev.Context, predicateSet, counter, Cutoff);
            }

            predCounts = new int[predicateSet.Count];
            int index = 0;
            for (var e = predicateSet.GetEnumerator(); e.MoveNext(); index++) {
                if (e.Current != null) {
                    predCounts[index] = counter[e.Current];
                    predicatesInOut.Add(e.Current, index);
                } 
            }
            eventStore.Flush();
            eventStore.Close();

            return eventCount;
        }
 /// <summary>
 /// 
 /// <para>
 /// This causes the set of players that can see this object to be rebuild. The OnRebuildObservers callback function will be invoked on each NetworkBehaviour.
 /// </para>
 /// 
 /// </summary>
 /// <param name="initialize">True if this is the first time.</param>
 public void RebuildObservers(bool initialize)
 {
     if (this.m_Observers == null)
     return;
       bool flag = false;
       HashSet<NetworkConnection> observers = new HashSet<NetworkConnection>();
       HashSet<NetworkConnection> hashSet = new HashSet<NetworkConnection>((IEnumerable<NetworkConnection>) this.m_Observers);
       for (int index = 0; index < this.m_NetworkBehaviours.Length; ++index)
       {
     NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[index];
     flag |= networkBehaviour.OnRebuildObservers(observers, initialize);
       }
       if (!flag)
       {
     if (!initialize)
       return;
     using (List<NetworkConnection>.Enumerator enumerator = NetworkServer.connections.GetEnumerator())
     {
       while (enumerator.MoveNext())
       {
     NetworkConnection current = enumerator.Current;
     if (current != null && current.isReady)
       this.AddObserver(current);
       }
     }
     using (List<NetworkConnection>.Enumerator enumerator = NetworkServer.localConnections.GetEnumerator())
     {
       while (enumerator.MoveNext())
       {
     NetworkConnection current = enumerator.Current;
     if (current != null && current.isReady)
       this.AddObserver(current);
       }
     }
       }
       else
       {
     using (HashSet<NetworkConnection>.Enumerator enumerator = observers.GetEnumerator())
     {
       while (enumerator.MoveNext())
       {
     NetworkConnection current = enumerator.Current;
     if (initialize || !hashSet.Contains(current))
     {
       current.AddToVisList(this);
       if (LogFilter.logDebug)
       {
         object[] objArray = new object[4];
         int index1 = 0;
         string str1 = "New Observer for ";
         objArray[index1] = (object) str1;
         int index2 = 1;
         GameObject gameObject = this.gameObject;
         objArray[index2] = (object) gameObject;
         int index3 = 2;
         string str2 = " ";
         objArray[index3] = (object) str2;
         int index4 = 3;
         NetworkConnection networkConnection = current;
         objArray[index4] = (object) networkConnection;
         Debug.Log((object) string.Concat(objArray));
       }
     }
       }
     }
     using (HashSet<NetworkConnection>.Enumerator enumerator = hashSet.GetEnumerator())
     {
       while (enumerator.MoveNext())
       {
     NetworkConnection current = enumerator.Current;
     if (!observers.Contains(current))
     {
       current.RemoveFromVisList(this, false);
       if (LogFilter.logDebug)
       {
         object[] objArray = new object[4];
         int index1 = 0;
         string str1 = "Removed Observer for ";
         objArray[index1] = (object) str1;
         int index2 = 1;
         GameObject gameObject = this.gameObject;
         objArray[index2] = (object) gameObject;
         int index3 = 2;
         string str2 = " ";
         objArray[index3] = (object) str2;
         int index4 = 3;
         NetworkConnection networkConnection = current;
         objArray[index4] = (object) networkConnection;
         Debug.Log((object) string.Concat(objArray));
       }
     }
       }
     }
     if (initialize)
     {
       using (List<NetworkConnection>.Enumerator enumerator = NetworkServer.localConnections.GetEnumerator())
       {
     while (enumerator.MoveNext())
     {
       NetworkConnection current = enumerator.Current;
       if (!observers.Contains(current))
         this.OnSetLocalVisibility(false);
     }
       }
     }
     this.m_Observers = new List<NetworkConnection>((IEnumerable<NetworkConnection>) observers);
       }
 }
 /// <summary>
 /// Reads the events from <paramref name="eventStream"/> into a <see cref="Collections.Generic.LinkedList"/>.
 /// The predicates associated with each event are counted and any which occur at least <paramref name="cutoff"/>
 /// times are added to the <paramref name="predicateIndex"/> dictionary along
 /// with an unique integer index.
 /// </summary>
 /// <param name="eventStream">The event stream.</param>
 /// <param name="predicateIndex">Index of the predicate.</param>
 /// <param name="cutoff">The cutoff.</param>
 /// <returns>A <see cref="Collections.Generic.LinkedList"/> of events.</returns>
 private LinkedList<Event> ComputeEventCounts(IEventStream eventStream, Dictionary<string, int> predicateIndex, int cutoff)
 {
     LinkedList<Event> events = new LinkedList<Event>();
     HashSet<string> predicatesSet = new HashSet<string>();
     IDictionary<string, int> counter = new Dictionary<string, int>();
     while (eventStream.HasNext())
     {
         Event next = eventStream.Next();
         events.AddLast(next);
         Update(next.Context, predicatesSet, counter, cutoff);
     }
     PredicateCounts = new int[predicatesSet.Count];
     int index = 0;
     HashSet<string>.Enumerator enumerator = predicatesSet.GetEnumerator();
     while (enumerator.MoveNext())
     {
         string predicate = enumerator.Current;
         PredicateCounts[index] = counter[predicate];
         predicateIndex[predicate] = index;
     }
     return events;
 }
Example #30
0
		public void TransientOrphanDelete()
		{
			ISession s = OpenSession();
			ITransaction t = s.BeginTransaction();
			Baz baz = new Baz();
			var bars = new HashSet<BarProxy> { new Bar(), new Bar(), new Bar() };
			baz.CascadingBars = bars;
			IList<Foo> foos = new List<Foo>();
			foos.Add(new Foo());
			foos.Add(new Foo());
			baz.FooBag = foos;
			s.Save(baz);

			IEnumerator enumer = new JoinedEnumerable(new IEnumerable[] {foos, bars}).GetEnumerator();
			while (enumer.MoveNext())
			{
				FooComponent cmp = ((Foo) enumer.Current).Component;
				s.Delete(cmp.Glarch);
				cmp.Glarch = null;
			}

			t.Commit();
			s.Close();

			var enumerBar = bars.GetEnumerator();
			enumerBar.MoveNext();
			bars.Remove(enumerBar.Current);
			foos.RemoveAt(1);
			s = OpenSession();
			t = s.BeginTransaction();
			s.Update(baz);
			Assert.AreEqual(2, s.CreateQuery("from Bar bar").List().Count);
			Assert.AreEqual(3, s.CreateQuery("from Foo foo").List().Count);
			t.Commit();
			s.Close();

			foos.RemoveAt(0);
			s = OpenSession();
			t = s.BeginTransaction();
			s.Update(baz);
			enumerBar = bars.GetEnumerator();
			enumerBar.MoveNext();
			bars.Remove(enumerBar.Current);
			s.Delete(baz);
			s.Flush();
			Assert.AreEqual(0, s.CreateQuery("from Foo foo").List().Count);
			t.Commit();
			s.Close();
		}