private static Match[] MatchSubstring(string i_source, string i_matchPattern, bool i_uniqueMatch)
        {
            //<note> use RegexOptions.Multiline, otherwise it will treat the whole thing as 1 string
            Regex regex = new Regex(i_matchPattern, RegexOptions.Multiline);

            MatchCollection matchCollection = regex.Matches(i_source);

            Match[] result;
            if (!i_uniqueMatch)
            {
                result = new Match[matchCollection.Count];
                matchCollection.CopyTo(result, 0);
            }
            else
            {
                //<note> cannot use HashSet<Match> because each Match object is unique, even though they may have same value (string). Can use HashSet<string>
                //SortedList is more like sorted Dictionary<key, value>
                SortedList uniqueMatchCollection = new SortedList();
                foreach(Match match in matchCollection)
                {
                    if (!uniqueMatchCollection.ContainsKey(match.Value))
                    {
                        uniqueMatchCollection.Add(match.Value, match);
                    }
                }

                result = new Match[uniqueMatchCollection.Count];
                uniqueMatchCollection.Values.CopyTo(result, 0);     //<note> cannot use uniqueMatchCollection.CopyTo(...) since SortedList member is not type-match with destination array member
            }

            Console.WriteLine("Found {0} matches", result.Length);
            return result;
        }

        //SpriteFont debugfont;
        public Scene(Game game)
            : base(game)
        {
            World = new World(new Vector2(0, 18));
            PhysicsDebug = new DebugViewXNA(World);
            InputManager = new InputManager(Game);
            Transitioner = new Transitioner(Game, this);
            #if !FINAL_RELEASE
            SelectionManager = new SelectionManager(Game, this);
            #endif
            SceneLoader = new SceneLoader(Game);
            Camera = new Camera(Game, this);
            GarbageElements = new SortedList<Element>();
            RespawnElements = new SortedList<Element>();
            Elements = new SortedList<Element>();

            PhysicsDebug.Enabled = false;
            SelectionManager.ShowEmblems = false;
            Kinect.ColorStream.Enable();
            Kinect.DepthStream.Enable();
            Kinect.SkeletonStream.Enable();
            Kinect.Start();

            //SelectionManager.ShowForm = false;
        }

        public void ComputeTrendTest(SortedList<int, double> years, int currentYear)
        {
            var map = new ExtractValuesForIndicatorsMapper();
            var data = new SortedList<int, double>();
            double[] inflationVal ={100.764370305146,104.476042578907,
            164.776810573524,343.810676313218,626.718592068498,672.180651051974,
            90.0966050749321,131.327020980362,342.955110191569,3079.8097030531,
            2313.96466339751,171.671696468307,24.8999485988254,10.6114940961306,
            4.17734724367,3.37611684980121,0.155695900742245,0.527258257063252
            ,0.920336467095566,-1.16689546970002,-0.935939411978723,-1.06663550777849,
            25.8684978656633,13.4428492915644,4.41571792341912,9.63939954620811,
            10.901124534884,
            8.83141298885049};
            int length = inflationVal.Count();

            int year = 2007;
            for (int i = length - 1; i >= 0; i--)
            {
                data.Add(year, inflationVal[i]);
                year--;
            }
            Assert.IsTrue( map.ComputeTrend(data, 1998)<1);
            Assert.IsTrue( map.ComputeTrend(data, 1999)<1);
            Assert.IsTrue( map.ComputeTrend(data, 2000)<1);
            Assert.IsTrue( map.ComputeTrend(data, 2001)<1);
             Assert.IsTrue(map.ComputeTrend(data, 2002)>1);
            Assert.IsTrue(map.ComputeTrend(data, 2003)>1);
            
        }

 private RowRecordsAggregate(SharedValueManager svm)
 {
     _rowRecords = new SortedList();
     _valuesAgg = new ValueRecordsAggregate();
     _unknownRecords = new ArrayList();
     _sharedValueManager = svm;
 }

		public void TestConstructor3 ()
		{
			Hashtable d = new Hashtable ();
			d.Add ("one", "Mircosoft");
			d.Add ("two", "will");
			d.Add ("three", "rule");
			d.Add ("four", "the world");

			SortedList temp1 = new SortedList (d);
			Assert.IsNotNull (temp1, "#A1");
			Assert.AreEqual (4, temp1.Capacity, "#A2");
			Assert.AreEqual (4, temp1.Count, "#A3");

			try {
				new SortedList ((Hashtable) null);
				Assert.Fail ("#B");
			} catch (ArgumentNullException) {
			}

			try {
				d = new Hashtable ();
				d.Add ("one", "Mircosoft");
				d.Add ("two", "will");
				d.Add ("three", "rule");
				d.Add ("four", "the world");
				d.Add (7987, "lkj");
				new SortedList (d);
				Assert.Fail ("#C");
			} catch (InvalidOperationException) {
			}
		}

 public ThemeProvider(IDesignerHost host, string name, string themeDefinition, string[] cssFiles, string themePath)
 {
     this._themeName = name;
     this._themePath = themePath;
     this._cssFiles = cssFiles;
     this._host = host;
     ControlBuilder builder = DesignTimeTemplateParser.ParseTheme(host, themeDefinition, themePath);
     this._contentHashCode = themeDefinition.GetHashCode();
     ArrayList subBuilders = builder.SubBuilders;
     this._skinBuilders = new Hashtable();
     for (int i = 0; i < subBuilders.Count; i++)
     {
         ControlBuilder builder2 = subBuilders[i] as ControlBuilder;
         if (builder2 != null)
         {
             IDictionary dictionary = this._skinBuilders[builder2.ControlType] as IDictionary;
             if (dictionary == null)
             {
                 dictionary = new SortedList(StringComparer.OrdinalIgnoreCase);
                 this._skinBuilders[builder2.ControlType] = dictionary;
             }
             Control control = builder2.BuildObject() as Control;
             if (control != null)
             {
                 dictionary[control.SkinID] = builder2;
             }
         }
     }
 }

 private EventStreamSlice()
 {
     m_streamPosition = EventStreamPosition.Start;
     m_events = new SortedList<StreamVersion, JournaledEvent>(0);
     m_endOfStream = true;
     m_currentSlicePosition = EventStreamPosition.Start;
 }

        public Button()
        {
            this.m_bNoScalingOnSetRect = true;
            Name = "Button";
            this.MouseActive = true;
            m_plStateSprites = new SortedList();

            Frame spFrame = new Frame();
            spFrame.Parent = this;
            spFrame.Member = new MemberSpriteBitmap("Button2Up");
            spFrame.Ink = RasterOps.ROPs.BgTransparent;
            spFrame.Member.ColorKey = Color.FromArgb(0,0,0);
            spFrame.Rect = new ERectangleF(0,0,50,50);
            m_plStateSprites.Add(Sprite.MouseEventType.Leave, (Sprite)spFrame);

            spFrame = new Frame();
            spFrame.Parent = this;
            spFrame.Member = new MemberSpriteBitmap("Button2Down");
            spFrame.Ink = RasterOps.ROPs.BgTransparent;
            spFrame.Member.ColorKey = Color.FromArgb(0,0,0);
            spFrame.Rect = new ERectangleF(0,0,50,50);
            m_plStateSprites.Add(Sprite.MouseEventType.Enter, (Sprite)spFrame);

            for (int i = 0; i < m_plStateSprites.Count; i++)
            {
                ((Sprite)m_plStateSprites.GetByIndex(i)).Visible = false;
            }
            ((Sprite)m_plStateSprites[MouseEventType.Leave]).Visible = true;
        }

        void btnSave_Click(object sender, EventArgs e)
        {
            SortedList sl = new SortedList();

            Qry = "delete from Unit_master where UnitGroupName='" + cboUnitType.Text + "'";
            sl.Add(sl.Count + 1, Qry);

            for (int i = 0; i < dgvInfo.Rows.Count - 1; i++)
            {
                Qry = "INSERT INTO [dbo].[Unit_Master] " +
                      " ([UnitGroupName]" +
                      " ,[UnitID]" +
                      " ,[UnitName]" +
                      " ,[RelativeFactor]" +
                      " ,[IsBaseUOM]" +
                      " ,[AddedBy]" +
                      " ,[DateAdded])" +
                 " VALUES " +
                       " ('" + cboUnitType.Text + "'," +
                       "'" + dgvInfo.Rows[i].Cells[0].Value.ToString() + "'," +
                      "'" + dgvInfo.Rows[i].Cells[1].Value.ToString() + "'," +
                       "" + dgvInfo.Rows[i].Cells[2].Value.ToString() + "," +
                       "'" + Convert.ToBoolean(dgvInfo.Rows[i].Cells[3].Value) + "'," +
                      "'" + LoginSession.UserID + "',getdate())";
                sl.Add(sl.Count + 1, Qry);
            }

            DbUtility.ExecuteQuery(sl, "");
            MessageBox.Show("Saved");
        }

        /// <summary>
        ///     Class constructor.
        /// </summary>
        /// <param name="properties"></param>
        public Type2CIDFont(FontProperties properties) {
            this.properties = properties;
            this.baseFontName = properties.FaceName.Replace(" ", "-");
            this.usedGlyphs = new SortedList();

            ObtainFontMetrics();
        }

 public TemplateCollection()
 {
   eX4XcIhHpDXt70u2x3N.k8isAcYzkUOGF();
   // ISSUE: explicit constructor call
   base.\u002Ector();
   this.aJ8duHpkdC = new SortedList();
 }

        public string ExecuteSclrBySP(string sp, SortedList sl)
        {
            string err = string.Empty;
            string returnSclr = "-1";

            SqlConnection con = new SqlConnection(DbConnStr);
            SqlCommand cmd = new SqlCommand(sp, con);

            cmd.CommandType = CommandType.StoredProcedure;

            foreach (DictionaryEntry entry in sl)
            {
                cmd.Parameters.Add(new SqlParameter(entry.Key.ToString(), entry.Value));
            }

            try
            {
                con.Open();
                returnSclr = Convert.ToString(cmd.ExecuteScalar());

            }
            catch (Exception ex)
            {
                err = ex.Message;
            }
            finally
            {
                con.Close();
            }

            return returnSclr;
        }

        public DataSet ServerDBQuery(string strProcName, DataSet dsIN)
        {
            try
            {
                SortedList SDList = new SortedList();
                if (dsIN.Tables.Count > 0 && dsIN.Tables[0].Rows.Count > 0)
                {
                    DataRow dR = dsIN.Tables[0].Rows[0];
                    for (int i = 0; i < dsIN.Tables[0].Columns.Count; i++)
                    {
                        SDList[dsIN.Tables[0].Columns[i].ColumnName] = dR[i];
                    }
                }
                return WSBDB.proGetDS(SDList, strProcName);
            }
            catch (Exception Ex)
            {
                #region 错误日志
                string strSDList = "";
                if (dsIN.Tables.Count > 0 && dsIN.Tables[0].Rows.Count > 0)
                {
                    DataRow dR = dsIN.Tables[0].Rows[0];
                    for (int i = 0; i < dsIN.Tables[0].Columns.Count; i++)
                    {
                        strSDList += dsIN.Tables[0].Columns[i].ColumnName + ":" + dR[i] + "$";
                    }
                }
                string strErrEx = "出现未知错误，请联系系统管理员查询日志，方法" + strProcName + "参数：" + strSDList + "错误ID：" + Guid.NewGuid().ToString();
                WSBDB.txtSaveErro(strErrEx + ":" + Ex.ToString());
                #endregion

                return null;
            }
        }

        public static Match[] FindSubstrings(string source, string matchPattern, bool findAllUnique)
        {
            SortedList uniqueMatches = new SortedList();
            Match[] retArray = null;

            Regex RE = new Regex(matchPattern, RegexOptions.Multiline);
            MatchCollection theMatches = RE.Matches(source);

            if (findAllUnique)
            {
                for (int counter = 0; counter < theMatches.Count; counter++)
                {
                    if (!uniqueMatches.ContainsKey(theMatches[counter].Value))
                    {
                        uniqueMatches.Add(theMatches[counter].Value,
                                          theMatches[counter]);
                    }
                }

                retArray = new Match[uniqueMatches.Count];
                uniqueMatches.Values.CopyTo(retArray, 0);
            }
            else
            {
                retArray = new Match[theMatches.Count];
                theMatches.CopyTo(retArray, 0);
            }

            return (retArray);
        }

 protected void TargetSelectorCallback(Address start, SortedList score_table, Address current) {
   Assert.IsTrue(score_table.Count > 0);
   if (current == null) {
     Address min_target = (Address) score_table.GetByIndex(0);
     Assert.AreEqual(_addr_list[_idx++], min_target);
   }
 }

 //  StoreChildNode: Store data associated with each nodeName
 //                  so that we know whether the nodeName is an array or not.
 private static void StoreChildNode(SortedList childNodeNames, string nodeName, object nodeValue)
 {
     // Pre-process contraction of XmlElement-s
     if (nodeValue is XmlElement)
     {
         // Convert  <aa></aa> into "aa":null
         //          <aa>xx</aa> into "aa":"xx"
         XmlNode cnode = (XmlNode)nodeValue;
         if (cnode.Attributes.Count == 0)
         {
             XmlNodeList children = cnode.ChildNodes;
             if (children.Count == 0)
                 nodeValue = null;
             else if (children.Count == 1 && (children[0] is XmlText))
                 nodeValue = ((XmlText)(children[0])).InnerText;
         }
     }
     // Add nodeValue to ArrayList associated with each nodeName
     // If nodeName doesn't exist then add it
     object oValuesAL = childNodeNames[nodeName];
     ArrayList ValuesAL;
     if (oValuesAL == null)
     {
         ValuesAL = new ArrayList();
         childNodeNames[nodeName] = ValuesAL;
     }
     else
         ValuesAL = (ArrayList)oValuesAL;
     ValuesAL.Add(nodeValue);
 }

 public FamiliaCompetencias(ModeloCompetencias mod)
 {
     competencias = new SortedList<int, Competencia>();
     creationDate = DateTime.Now;
     familiaID = -1;
     modelo = mod;
 }

 public GetUnicodeCategory_char()
   {
   m_CharData = new SortedList();
   m_uCharsRead = 0;
   m_uTestCaseCount = 0;
   m_uFailureCount = 0;
   }

 public GetNumericValue_str_i()
   {
   m_CharData = new SortedList();
   m_uCharsRead = 0;
   m_uTestCaseCount = 0;
   m_uFailureCount = 0;
   }

		public void JavascriptAsGenericSortedListTestOptionsTest()
		{
			IDictionary<string, string> options = new SortedList<string, string>();
			options.Add("key1","option1");
			options.Add("key2","option2");
			Assert.AreEqual("{key1:option1, key2:option2}",AbstractHelper.JavascriptOptions(options));
		}