Compare() public method

public Compare ( object x, object y ) : int
x object
y object
return int
Example #1
0
        /// <summary>
        /// Gets all the node indices with matching names.
        /// </summary>
        private IEnumerable<int> FindNodes(string name, StringComparer comparer)
        {
            // find any node that matches
            var position = BinarySearch(name, comparer);

            if (position != -1)
            {
                // back up to the first node that matches.
                var start = position;
                while (start > 0 && comparer.Compare(nodes[start - 1].Name, name) == 0)
                {
                    start--;
                }

                // yield the nodes we already know that match
                for (int i = start; i <= position; i++)
                {
                    yield return i;
                }

                // also yield any following nodes that might also match
                for (int i = position + 1; i < nodes.Count; i++)
                {
                    var node = nodes[i];
                    if (comparer.Compare(node.Name, name) == 0)
                    {
                        yield return i;
                    }
                    else
                    {
                        break;
                    }
                }
            }
        }
 public static string GetParam(this Application application, string name, StringComparer stringComparer)
 {
     stringComparer = stringComparer ?? StringComparer.CurrentCulture;
     return (from child in HtmlPage.Plugin.Children
             let nameAttribute = child.GetProperty("name") as string
             let valueAttribute = child.GetProperty("value") as string
             where stringComparer.Compare(name, nameAttribute) == 0
             select valueAttribute as string).FirstOrDefault();
 }
Example #3
0
        internal TypeDeobfuscator(XElement typeNode)
        {
            m_comparer = StringComparer.Ordinal;
            ObfuscatedName = ((string)typeNode.Element("newname")).Replace('/', '+');
            OriginalName = ((string)typeNode.Element("name")).Replace('/', '+');

            m_fields = (from fieldNode in typeNode.Elements("fieldlist").Elements("field")
                        let originalName = (string)fieldNode.Element("name")
                        let obfuscatedName = (string)fieldNode.Element("newname")
                        select new ObfuscatedField(obfuscatedName, originalName)).ToArray();

            Array.Sort(m_fields, (left, right) => m_comparer.Compare(left.ObfuscatedName, right.ObfuscatedName));
        }
Example #4
0
        private static void VerifyComparer(StringComparer sc, bool ignoreCase)
        {
            String s1 = "Hello";
            String s1a = "Hello";
            String s1b = "HELLO";
            String s2 = "There";

            Assert.True(sc.Equals(s1, s1a));
            Assert.True(sc.Equals(s1, s1a));

            Assert.Equal(0, sc.Compare(s1, s1a));
            Assert.Equal(0, ((IComparer)sc).Compare(s1, s1a));

            Assert.True(sc.Equals(s1, s1));
            Assert.True(((IEqualityComparer)sc).Equals(s1, s1));
            Assert.Equal(0, sc.Compare(s1, s1));
            Assert.Equal(0, ((IComparer)sc).Compare(s1, s1));

            Assert.False(sc.Equals(s1, s2));
            Assert.False(((IEqualityComparer)sc).Equals(s1, s2));
            Assert.True(sc.Compare(s1, s2) < 0);
            Assert.True(((IComparer)sc).Compare(s1, s2) < 0);

            Assert.Equal(ignoreCase, sc.Equals(s1, s1b));
            Assert.Equal(ignoreCase, ((IEqualityComparer)sc).Equals(s1, s1b));

            int result = sc.Compare(s1, s1b);
            if (ignoreCase)
                Assert.Equal(0, result);
            else
                Assert.NotEqual(0, result);

            result = ((IComparer)sc).Compare(s1, s1b);
            if (ignoreCase)
                Assert.Equal(0, result);
            else
                Assert.NotEqual(0, result);
        }
        public static ProjectItem FindItemByPath(this ProjectItems items, string itemFilePath, StringComparer comparer)
        {
            foreach (var item in items)
            {
                var projectItem = item as ProjectItem;
                if (projectItem != null)
                {
                    if (projectItem.TryGetFullPath(out var filePath) && comparer.Compare(filePath, itemFilePath) == 0)
                    {
                        return projectItem;
                    }
                }
            }

            return null;
        }
Example #6
0
        public static Boolean checkMd5Hash(this string input, string hash)
        {
            MD5 md5Hash = MD5.Create();

            string hashOfInput = input.Hash();


            StringComparer comparer = StringComparer.OrdinalIgnoreCase;

            if (0 == comparer.Compare(hashOfInput, hash))
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
        public bool VerifySHA256Hash(string input, string hash)
        {
            System.Security.Cryptography.SHA256 SHA256 = new System.Security.Cryptography.SHA256CryptoServiceProvider();
            // Hash the input.
            string hashOfInput = GetSHA256Hash(input);

            // Create a StringComparer an compare the hashes.
            StringComparer comparer = StringComparer.CurrentCulture;//.OrdinalIgnoreCase;

            if (0 == comparer.Compare(hashOfInput, hash))
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Example #8
0
        /// <summary>
        /// Verifies that the usser's passed in password matches with the hashed password stored in the database
        /// </summary>
        /// <param name="md5"></param>
        /// <param name="userInput"></param>
        /// <param name="storedHash"></param>
        /// <returns></returns>
        private bool VerifyPassword(MD5 md5, string userInput, string storedHash)
        {
            // Get a hash of the user's submitted password
            string hashOfUserInput = HashPassword(md5, userInput);

            // StringComparer used two compare the two hashed passwords
            StringComparer comparer = StringComparer.OrdinalIgnoreCase;

            // If the two stored passwords are the same, return true. Otherwise, return false
            if (0 == comparer.Compare(hashOfUserInput, storedHash))
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Example #9
0
        public static bool VerifyMd5Hash(byte[] input, string hash)
        {
            lock (verifyLocker)
            {
                string hashOfInput = GetMd5Hash(input);

                StringComparer comparer = StringComparer.OrdinalIgnoreCase;

                if (0 == comparer.Compare(hashOfInput, hash))
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
        }
Example #10
0
        /// <summary>
        /// Take input then hash and compare with already hash string before
        /// </summary>
        /// <param name="input">The input string need to compare</param>
        /// <param name="hash">The hashed one</param>
        /// <returns>true if equal</returns>
        public static bool VerifyMD5Hash(string input, string hash)
        {
            //Hash input
            string hashInput = GetMD5Hash(input);

            //Compare
            StringComparer cmp = StringComparer.Ordinal;

            //return 0 means equal
            if (cmp.Compare(hashInput, hash) == 0)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Example #11
0
            public int Compare(FileInfo x, FileInfo y)
            {
                // Create string comparer
                StringComparer sc = StringComparer.Create(CultureInfo.InvariantCulture, true);

                // Create flag to check if one of the file is a directory
                bool xDir = x.Attributes.HasFlag(FileAttributes.Directory);
                bool yDir = y.Attributes.HasFlag(FileAttributes.Directory);

                // String compare only if the fileinfo are of same type
                if ((xDir && yDir) || (!xDir && !yDir))
                {
                    return(sc.Compare(x.Name, y.Name));
                }

                // If not directory become first
                return(xDir ? -1 : 1);
            }
Example #12
0
        private void ThrowIfTypeExist(string typeName, ICodeSource code)
        {
            if (TypeManager.IsKnownType(typeName) && _loadedModules.ContainsKey(typeName))
            {
                using (MD5 md5Hash = MD5.Create())
                {
                    string moduleCode = code.Code;
                    string hash       = GetMd5Hash(md5Hash, moduleCode);
                    string storedHash = _fileHashes[typeName];

                    StringComparer comparer = StringComparer.OrdinalIgnoreCase;
                    if (comparer.Compare(hash, storedHash) != 0)
                    {
                        throw new RuntimeException("Type «" + typeName + "» already registered");
                    }
                }
            }
        }
Example #13
0
        private bool VerifyMd5Hash(string input, string hash)
        {
            string hashOfInput = Compute(input);

            Console.WriteLine("z veryfiy hash");
            Console.WriteLine(hashOfInput);
            Console.WriteLine(hash);
            StringComparer comparer = StringComparer.OrdinalIgnoreCase;

            if (0 == comparer.Compare(hashOfInput, hash))
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Example #14
0
        /// <summary>
        /// MD5验证
        /// </summary>
        /// <param name="input"></param>
        /// <param name="hash"></param>
        /// <returns></returns>
        public static bool VerifyMd5Hash(string input, string hash)
        {
            string hashOfInput = MD5Hash(input);

            using (MD5 md5Hash = MD5.Create())
            {
                StringComparer comparer = StringComparer.OrdinalIgnoreCase;

                if (0 == comparer.Compare(hashOfInput, hash))
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
        }
        // Verify a hash against a string.
        public static bool VerifyMd5Hash(string input, string hash)
        {
            // Hash the input.

            string hashOfInput = GetMd5Hash(input);

            // Create a StringComparer an compare the hashes.
            StringComparer comparer = StringComparer.OrdinalIgnoreCase;

            if (0 == comparer.Compare(hashOfInput, hash))
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Example #16
0
        // Verify a hash against a string.
        public static bool verifyMd5Hash(string hashOfInput)
        {
            // Hash the input.
            //string hashOfInput = getMd5Hash(input);

            // Create a StringComparer an compare the hashes.
            StringComparer comparer = StringComparer.OrdinalIgnoreCase;

            //use cpu id as hash
            if (0 == comparer.Compare(hashOfInput, getCpuIDhash()))
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Example #17
0
        /// <summary>
        /// 支付成功回调结果验签
        /// </summary>
        /// <param name="customernumber"></param>
        /// <param name="requestid"></param>
        /// <param name="code"></param>
        /// <param name="notifytype"></param>
        /// <param name="externalid"></param>
        /// <param name="amount"></param>
        /// <param name="cardno"></param>
        /// <param name="hmacKey"></param>
        /// <param name="VSign"></param>
        /// <returns></returns>
        public static bool PayResultVerifyHMAC(string customernumber, string requestid, int code, string notifytype, string externalid, string amount, string cardno, string hmacKey, string VSign)
        {
            string sign = "{0}{1}{2}{3}{4}{5}{6}";

            sign = string.Format(sign, customernumber, requestid, code, notifytype, externalid, amount, cardno);
            sign = HmacSign(sign, hmacKey);

            StringComparer comparer = StringComparer.OrdinalIgnoreCase;

            if (0 == comparer.Compare(sign, VSign))
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Example #18
0
        /// <summary>
        /// 修改帐号密码
        /// </summary>
        /// <param name="strOldPassword">原密码</param>
        /// <param name="strNewPassword">新密码</param>
        /// <param name="nOpStaffId">操作员工编码</param>
        /// <param name="strOpStaffName">操作员工姓名</param>
        /// <param name="strErrText">出错信息</param>
        /// <returns>成功返回True,否则返回False</returns>
        public bool UpdatePassword(string strOldPassword, string strNewPassword, long nOpStaffId, string strOpStaffName, out string strErrText)
        {
            try
            {
                using (TransactionScope transScope = new TransactionScope(TransactionScopeOption.Required, new TimeSpan(2, 0, 0)))
                {
                    using (AuthenticateDAO dao = new AuthenticateDAO())
                    {
                        //读取登录帐号数据
                        Account data = dao.LoadAccount(nOpStaffId, nOpStaffId, strOpStaffName, out strErrText);
                        if (data == null)
                        {
                            return(false);
                        }

                        //生成登录密码MD5码
                        string         strHash  = Utils.GetMD5Hash(data.Name + "@" + strOldPassword);
                        StringComparer comparer = StringComparer.OrdinalIgnoreCase;
                        if (comparer.Compare(strHash, data.Password) == 0)
                        {
                            data.Password = Utils.GetMD5Hash(data.Name + "@" + strNewPassword);

                            if (!dao.UpdateAccount(data, nOpStaffId, strOpStaffName, out strErrText))
                            {
                                return(false);
                            }
                        }
                        else
                        {
                            strErrText = InnoSoft.LS.Resources.Strings.OldPasswordIsIncorrect;
                            return(false);
                        }
                    }
                    transScope.Complete();
                }
                strErrText = String.Empty;
                return(true);
            }
            catch (Exception e)
            {
                strErrText = e.Message;
                return(false);
            }
        }
Example #19
0
        static void Main(string[] args)
        {
            string s1 = "Strasse";
            string s2 = "Straße";
            bool   eq;

            eq = string.Compare(s1, s2, StringComparison.Ordinal) == 0;
            Console.WriteLine("Ordinal comparission: {0} {2} {1}", s1, s2, eq ? "==" : "!=");
            CultureInfo ci = new CultureInfo("de-DE");

            eq = string.Compare(s1, s2, true, ci) == 0;
            Console.WriteLine("Cultural comparison: {0} {2} {1}", s1, s2, eq ? "==" : "!=");

            Console.WriteLine(((IConvertible)10).ToDouble(null) + 0.3);

            StringComparer s = StringComparer.Create(ci, true);

            Console.WriteLine(s.Compare(10, 10));
        }
Example #20
0
        /// <summary>
        /// Adds the specified cache index item.
        /// </summary>
        /// <param name="cacheIndexItem">The cache index item.</param>
        /// <param name="saveIndex">if set to <c>true</c> save the index to persietent storage.</param>
        public void Add(CacheIndexItem cacheIndexItem, bool saveIndex)
        {
            StringComparer comparer = CacheIndexMap.IgnoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

            lock (syncLock)
            {
                CacheIndexItem item1 = this.FirstOrDefault(item => comparer.Compare(item.RelativeUri, cacheIndexItem.RelativeUri) == 0);
                if (item1 != null)
                {
                    base.Remove(item1);
                }
                base.Add(cacheIndexItem);

                if (saveIndex)
                {
                    SerializeCacheIndex(this);
                }
            }
        }
Example #21
0
        public override int Compare(string x, string y)
        {
            int idxX = _priorityStrings.IndexOf(x);
            int idxY = _priorityStrings.IndexOf(y);

            if (idxX != -1 && idxY != -1)
            {
                return(idxX.CompareTo(idxY));
            }
            if (idxX != -1)
            {
                return(idxX);
            }
            if (idxY != -1)
            {
                return(idxY);
            }
            return(_defaultStringComparer.Compare(x, y));
        }
Example #22
0
        // Verify a hash against a string.
        static bool VerificarSenha(MD5 md5Hash, string senha, string hash)
        {
            string senhazeeng = "zeeng" + senha;

            // Hash the input.
            string hashOfInput = GetMd5Hash(md5Hash, senhazeeng);

            // Create a StringComparer an compare the hashes.
            StringComparer comparer = StringComparer.OrdinalIgnoreCase;

            if (0 == comparer.Compare(hashOfInput, hash))
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Example #23
0
        /*
         * Realiza a verificao de um hash em relacao a um texto para
         * saber o hash eh produto do texto passado.
         * @Return true caso o hash seja foi criado atraves do texto ou
         * fase caso contrario ou ocorra algum erro.
         */
        public bool verifyMD5HashText(string hash, string text)
        {
            bool ret = false;

            try
            {
                text = getMD5Hash(text);
                StringComparer comp = StringComparer.OrdinalIgnoreCase;
                if (comp.Compare(hash, text) == 0)
                {
                    ret = true;
                }
            }
            catch (Exception e)
            {
                ret = false;
            }
            return(ret);
        }
Example #24
0
        public static bool VerifyMd5Hash(this string input, string hash)
        {
            using (MD5 md5 = MD5.Create())
            {
                string hashOfInput = GetMd5Hash(md5, input);

                // Create a StringComparer an compare the hashes.
                StringComparer comparer = StringComparer.OrdinalIgnoreCase;

                if (0 == comparer.Compare(hashOfInput, hash))
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
        }
Example #25
0
        public bool VerifyHash(string text, string hash)
        {
            byte[]        dataToHash  = this.AES.GetBytes(EncryptContent(text));
            byte[]        HashOfInput = SHA_Hasher.ComputeHash(dataToHash);
            StringBuilder builder     = new StringBuilder();

            for (int i = 0; i < HashOfInput.Length; i++)
            {
                builder.Append(HashOfInput[i].ToString());
            }
            string         cleanedHash = builder.ToString();
            StringComparer comparer    = StringComparer.OrdinalIgnoreCase;

            if (comparer.Compare(cleanedHash, hash) == 0)
            {
                return(true);
            }
            return(false);
        }
        // Verify a hash against a string.
        public bool VerifyHash(string input, string hashPath)
        {
            // Hash the input.
            string hashOfInput = GetHash(input);

            var hash = File.ReadAllText(hashPath);

            // Create a StringComparer an compare the hashes.
            StringComparer comparer = StringComparer.OrdinalIgnoreCase;

            if (0 == comparer.Compare(hashOfInput, hash))
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Example #27
0
 public int Compare(TableIdentifier table1, TableIdentifier table2)
 {
     if (ReferenceEquals(table1, table2))
     {
         return(0);
     }
     else if (table1 == null)
     {
         return(-1);
     }
     else if (table2 == null)
     {
         return(1);
     }
     else
     {
         return(stringComparer.Compare(table1.QualifiedName, table2.QualifiedName));
     }
 }
Example #28
0
 /// <summary>See <see cref="Comparer{TModelElement}.Compare"/>.</summary>
 public sealed override int Compare(TModelElement x, TModelElement y)
 {
     if (x == y)
     {
         return(0);
     }
     else if (x == null)
     {
         return(-1);
     }
     else if (y == null)
     {
         return(1);
     }
     else
     {
         return(myStringComparer.Compare(DomainClassInfo.GetName(x), DomainClassInfo.GetName(y)));
     }
 }
Example #29
0
        public void Compare_ExpectedResults()
        {
            StringComparer c = StringComparer.Ordinal;

            Assert.Equal(0, c.Compare((object)"hello", (object)"hello"));
#pragma warning disable 0618 // suppress obsolete warning for String.Copy
            Assert.Equal(0, c.Compare((object)"hello", (object)string.Copy("hello")));
#pragma warning restore 0618 // restore warning when accessing obsolete members
            Assert.Equal(-1, c.Compare(null, (object)"hello"));
            Assert.Equal(1, c.Compare((object)"hello", null));

            Assert.InRange(c.Compare((object)"hello", (object)"world"), int.MinValue, -1);
            Assert.InRange(c.Compare((object)"world", (object)"hello"), 1, int.MaxValue);
        }
Example #30
0
        /// <summary>
        /// Gets or sets the <see cref="MimeKit.Parameter"/> at the specified index.
        /// </summary>
        /// <param name="index">The index.</param>
        /// <exception cref="System.ArgumentNullException">
        /// The <paramref name="value"/> is <c>null</c>.
        /// </exception>
        /// <exception cref="System.ArgumentOutOfRangeException">
        /// The <paramref name="index"/> is out of range.
        /// </exception>
        /// <exception cref="System.ArgumentException">
        /// A parameter with the same name as <paramref name="value"/>
        /// already exists.
        /// </exception>
        public Parameter this [int index] {
            get {
                return(parameters[index]);
            }
            set {
                if (index < 0 || index > Count)
                {
                    throw new ArgumentOutOfRangeException("index");
                }

                var param = parameters[index];

                if (param == value)
                {
                    return;
                }

                if (icase.Compare(param.Name, value.Name) == 0)
                {
                    // replace the old param with the new one
                    if (table[param.Name] == param)
                    {
                        table[param.Name] = value;
                    }
                }
                else if (table.ContainsKey(value.Name))
                {
                    throw new ArgumentException("A parameter of that name already exists.");
                }
                else
                {
                    table.Add(value.Name, value);
                    table.Remove(param.Name);
                }

                param.Changed    -= OnParamChanged;
                value.Changed    += OnParamChanged;
                parameters[index] = value;

                OnChanged();
            }
        }
        public override int Compare(String x, String y)
        {
            int xIndex = 0;
            int yIndex = 0;

            x = (x ?? String.Empty);
            y = (y ?? String.Empty);

            while (xIndex < x.Length || yIndex < y.Length)
            {
                var xEntry = GetNextPart(x, xIndex);
                xIndex += xEntry.length;

                var yEntry = GetNextPart(y, yIndex);
                yIndex += xEntry.length;

                if (xEntry.value is double && yEntry.value is double)
                {
                    var xNumber = (double)xEntry.value;
                    var yNumber = (double)yEntry.value;

                    var order = xNumber.CompareTo(yNumber);
                    if (order != 0)
                    {
                        return(order);
                    }
                }
                else
                {
                    var xText = Convert.ToString(xEntry.value);
                    var yText = Convert.ToString(yEntry.value);

                    var order = _comparer.Compare(xText, yText);
                    if (order != 0)
                    {
                        return(order);
                    }
                }
            }

            return(0);
        }
Example #32
0
        public void StartPicDownload()
        {
            int    cntTMP   = curCount++;
            var    post     = posts.ToArray() [cntTMP];
            string filePath = Path.Combine(outPath, ParseFilenameMask(textBoxNameMask.Text, Path.GetFileNameWithoutExtension(post ["file_url"].ToString()), post ["file_ext"].ToString(), cntTMP + (checkBoxStartOne.Checked ? 1 : 0)));

            if (File.Exists(filePath))
            {
                using (var str = File.OpenRead(filePath)) {
                    StringComparer comparer = StringComparer.OrdinalIgnoreCase;
                    if (comparer.Compare(GetMD5HashFromStream(str), post ["md5"].ToString()) == 0)
                    {
                        StartPicDownload();
                        return;
                    }
                }
            }
            SetHeaders(picClient.Headers);
            picClient.DownloadFileAsync(new Uri(post ["file_url"].ToString()), Path.Combine(outPath, ParseFilenameMask(textBoxNameMask.Text, Path.GetFileNameWithoutExtension(post ["file_url"].ToString()), post ["file_ext"].ToString(), cntTMP + (checkBoxStartOne.Checked ? 1 : 0))));
        }
Example #33
0
        /// <summary>
        /// Verify a hash against a string
        /// </summary>
        /// <param name="input">The input string</param>
        /// <param name="hash">The MD5 hash to use to verify the input string</param>
        /// <returns>True if the input string is verified</returns>
        public static bool VerifyMd5Hash(string input, string hash)
        {
            using (var md5 = System.Security.Cryptography.MD5.Create())
            {
                // Hash the input.
                string hashOfInput = GetMd5Hash(input, md5);

                // Create a StringComparer an compare the hashes.
                StringComparer comparer = StringComparer.OrdinalIgnoreCase;

                if (0 == comparer.Compare(hashOfInput, hash))
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
        }
        private bool VerifyHash(string input, string hash)
        {
            using (SHA256 sha256 = SHA256.Create())
            {
                // Hash the input.
                string hashOfInput = GetHash(input);

                // Create a StringComparer an compare the hashes.
                StringComparer comparer = StringComparer.OrdinalIgnoreCase;

                if (0 == comparer.Compare(hashOfInput, hash))
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
        }
Example #35
0
 /// <summary>
 /// 验证输入数据的合法性
 /// </summary>
 /// <param name="input">输入数据</param>
 /// <param name="hash">比对数据</param>
 /// <returns></returns>
 private bool VerifyMd5Hash(string input, string hash)
 {
     if (!string.IsNullOrEmpty(hash))
     {
         string         hashOfInput = MSGetMd5Hash(input);
         StringComparer comparer    = StringComparer.OrdinalIgnoreCase;
         if (0 == comparer.Compare(hashOfInput, hash))
         {
             return(true);
         }
         else
         {
             return(false);
         }
     }
     else
     {
         return(true);
     }
 }
Example #36
0
 public static bool Contains(this string[] strings, string value, StringComparer comparer)
 {
     return strings.Any(val => comparer.Compare(val, value) == 0);
 }
		public static Predicate<INode> ByNodeName(string name, StringComparer comparer)
		{
			return ByNodeName(delegate(string value) { return comparer.Compare(value, name) == 0; });
		}
Example #38
0
        // search for a node with matching name in ordered list
        private int BinarySearch(string name, StringComparer nameComparer)
        {
            int max = nodes.Count - 1;
            int min = 0;

            while (max >= min)
            {
                int mid = min + ((max - min) >> 1);

                var comparison = nameComparer.Compare(nodes[mid].Name, name);
                if (comparison < 0)
                {
                    min = mid + 1;
                }
                else if (comparison > 0)
                {
                    max = mid - 1;
                }
                else
                {
                    return mid;
                }
            }

            return -1;
        }
Example #39
0
 public static ProjectItem FindItem(this ProjectItems items, string itemName, StringComparer comparer)
 {
     return items.OfType<ProjectItem>().FirstOrDefault(p => comparer.Compare(p.Name, itemName) == 0);
 }
Example #40
0
        /// <summary>
        /// Calculates information about types and namespaces immediately contained within a namespace.
        /// </summary>
        /// <param name="isGlobalNamespace">
        /// Is current namespace a global namespace?
        /// </param>
        /// <param name="namespaceNameLength">
        /// Length of the fully-qualified name of this namespace.
        /// </param>
        /// <param name="typesByNS">
        /// The sequence of groups of TypeDef row ids for types contained within the namespace, 
        /// recursively including those from nested namespaces. The row ids must be grouped by the 
        /// fully-qualified namespace name in case-sensitive manner. 
        /// Key of each IGrouping is a fully-qualified namespace name, which starts with the name of 
        /// this namespace. There could be multiple groups for each fully-qualified namespace name.
        /// 
        /// The groups must be sorted by the keys in a manner consistent with comparer passed in as
        /// nameComparer. Therefore, all types immediately contained within THIS namespace, if any, 
        /// must be in several IGrouping at the very beginning of the sequence.
        /// </param>
        /// <param name="nameComparer">
        /// Equality comparer to compare namespace names.
        /// </param>
        /// <param name="types">
        /// Output parameter, never null:
        /// A sequence of groups of TypeDef row ids for types immediately contained within this namespace.
        /// </param>
        /// <param name="namespaces">
        /// Output parameter, never null:
        /// A sequence with information about namespaces immediately contained within this namespace.
        /// For each pair:
        ///   Key - contains simple name of a child namespace.
        ///   Value – contains a sequence similar to the one passed to this function, but
        ///           calculated for the child namespace. 
        /// </param>
        /// <remarks></remarks>
        public static void GetInfoForImmediateNamespaceMembers(
            bool isGlobalNamespace,
            int namespaceNameLength,
            IEnumerable<IGrouping<string, TypeDefinitionHandle>> typesByNS,
            StringComparer nameComparer,
            out IEnumerable<IGrouping<string, TypeDefinitionHandle>> types,
            out IEnumerable<KeyValuePair<string, IEnumerable<IGrouping<string, TypeDefinitionHandle>>>> namespaces)
        {
            Debug.Assert(typesByNS != null);
            Debug.Assert(namespaceNameLength >= 0);
            Debug.Assert(!isGlobalNamespace || namespaceNameLength == 0);

            // A list of groups of TypeDef row ids for types immediately contained within this namespace.
            var nestedTypes = new List<IGrouping<string, TypeDefinitionHandle>>();

            // A list accumulating information about namespaces immediately contained within this namespace.
            // For each pair:
            //   Key - contains simple name of a child namespace.
            //   Value – contains a sequence similar to the one passed to this function, but
            //           calculated for the child namespace. 
            var nestedNamespaces = new List<KeyValuePair<string, IEnumerable<IGrouping<string, TypeDefinitionHandle>>>>();
            bool possiblyHavePairsWithDuplicateKey = false;

            var enumerator = typesByNS.GetEnumerator();

            using (enumerator)
            {
                if (enumerator.MoveNext())
                {
                    var pair = enumerator.Current;

                    // Simple name of the last encountered child namespace.
                    string lastChildNamespaceName = null;

                    // A list accumulating information about types within the last encountered child namespace.
                    // The list is similar to the sequence passed to this function.
                    List<IGrouping<string, TypeDefinitionHandle>> typesInLastChildNamespace = null;

                    // if there are any types in this namespace,
                    // they will be in the first several groups if their key length 
                    // is equal to namespaceNameLength.
                    while (pair.Key.Length == namespaceNameLength)
                    {
                        nestedTypes.Add(pair);

                        if (!enumerator.MoveNext())
                        {
                            goto DoneWithSequence;
                        }

                        pair = enumerator.Current;
                    }

                    // Account for the dot following THIS namespace name.
                    if (!isGlobalNamespace)
                    {
                        namespaceNameLength++;
                    }

                    do
                    {
                        pair = enumerator.Current;

                        string childNamespaceName = ExtractSimpleNameOfChildNamespace(namespaceNameLength, pair.Key);

                        int cmp = nameComparer.Compare(lastChildNamespaceName, childNamespaceName);
                        if (cmp == 0)
                        {
                            // We are still processing the same child namespace
                            typesInLastChildNamespace.Add(pair);
                        }
                        else
                        {
                            // This is a new child namespace
                            if (cmp > 0)
                            {
                                // The sort order is violated for child namespace names. Obfuscation is the likely reason for this. 
                                Debug.Assert((object)lastChildNamespaceName != null);
                                possiblyHavePairsWithDuplicateKey = true;
                            }

                            // Preserve information about previous child namespace.
                            if (typesInLastChildNamespace != null)
                            {
                                Debug.Assert(typesInLastChildNamespace.Count != 0);
                                nestedNamespaces.Add(
                                    new KeyValuePair<string, IEnumerable<IGrouping<string, TypeDefinitionHandle>>>(
                                        lastChildNamespaceName, typesInLastChildNamespace));
                            }

                            typesInLastChildNamespace = new List<IGrouping<string, TypeDefinitionHandle>>();
                            lastChildNamespaceName = childNamespaceName;
                            Debug.Assert((object)lastChildNamespaceName != null);

                            typesInLastChildNamespace.Add(pair);
                        }
                    }
                    while (enumerator.MoveNext());

                    // Preserve information about last child namespace.
                    if (typesInLastChildNamespace != null)
                    {
                        Debug.Assert(typesInLastChildNamespace.Count != 0);
                        nestedNamespaces.Add(
                            new KeyValuePair<string, IEnumerable<IGrouping<string, TypeDefinitionHandle>>>(
                                lastChildNamespaceName, typesInLastChildNamespace));
                    }

                DoneWithSequence:
                    /*empty statement*/
                    ;
                }
            } // using

            types = nestedTypes;

            // Merge pairs with the same key
            if (possiblyHavePairsWithDuplicateKey)
            {
                var names = new Dictionary<string, int>(nestedNamespaces.Count, nameComparer);

                for (int i = nestedNamespaces.Count - 1; i >= 0; i--)
                {
                    names[nestedNamespaces[i].Key] = i;
                }

                if (names.Count != nestedNamespaces.Count) // nothing to merge otherwise
                {
                    for (int i = 1; i < nestedNamespaces.Count; i++)
                    {
                        var pair = nestedNamespaces[i];
                        int keyIndex = names[pair.Key];
                        if (keyIndex != i)
                        {
                            Debug.Assert(keyIndex < i);
                            var primaryPair = nestedNamespaces[keyIndex];
                            nestedNamespaces[keyIndex] = KeyValuePair.Create(primaryPair.Key, primaryPair.Value.Concat(pair.Value));
                            nestedNamespaces[i] = default(KeyValuePair<string, IEnumerable<IGrouping<string, TypeDefinitionHandle>>>);
                        }
                    }

                    int removed = nestedNamespaces.RemoveAll(pair => (object)pair.Key == null);
                    Debug.Assert(removed > 0);
                }
            }

            namespaces = nestedNamespaces;

            Debug.Assert(types != null);
            Debug.Assert(namespaces != null);
        }
    private bool VerificationHelper(StringComparer sc, string x, string y, int expected, string errorno)
    {
        bool retVal = true;

       int actual = sc.Compare(x, y);

       


        if (actual != expected)
        {
            TestLibrary.TestFramework.LogError(errorno, "Compare returns wrong value");
            TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE]");
            retVal = false;
        }
        else if (actual < expected)
        {

 
        }

        return retVal;
    }