Пример #1
0
        /// <summary>
        ///   Modifies the specified elements by regex with the specified modifier.
        /// </summary>
        /// <typeparam name = "T"></typeparam>
        /// <param name = "regex">The regex.</param>
        /// <param name = "modifier">The modifier.</param>
        public void Modify <T>(string regex, ProcessModifier modifier) where T : CppElement
        {
            var  cppElements  = new List <T>();
            bool modifyParent = regex.StartsWith("#");

            regex = regex.TrimStart('#');
            regex = "^" + regex + "$";
            Find(new Regex(regex), cppElements, modifier, ref modifyParent);
        }
Пример #2
0
 public bool Configure(ProcessInformation pinfo)
 {
     Text = System.String.Format(Resources.MemoryHackerFormatString, pinfo.ID, pinfo.Name, pinfo.FullPath);
     m_pm = ProcessModifier.Open((uint) pinfo.ID);
     if(m_pm == null)
         return false;
     UpdateList();
     UpdateList();	// The second call is for debugging any problems in this function.
     updList = new UpdateListDelegate(UpdateList);
     m_timer = new System.Threading.Timer(m_cb, this, 2000, 2000);
     return true;
 }
Пример #3
0
        /// <summary>
        /// Finds the specified elements by regex and modifier.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="regex">The regex.</param>
        /// <param name="toAdd">To add.</param>
        /// <param name="modifier">The modifier.</param>
        /// <param name="modifyParent">if set to <c>true</c> [modify parent].</param>
        /// <returns></returns>
        private bool Find <T>(Regex regex, List <T> toAdd, ProcessModifier modifier, ref bool modifyParent) where T : CppElement
        {
            bool   isToRemove = false;
            string path       = FullName;

            var elementToModify = modifyParent ? Parent : this;

            if ((elementToModify is T) && path != null && regex.Match(path).Success)
            {
                if (toAdd != null)
                {
                    toAdd.Add((T)elementToModify);
                }

                if (modifier != null)
                {
                    isToRemove = modifier(regex, elementToModify);
                }
            }

            var elementsToRemove = new List <CppElement>();

            // Force _findContext to reverse to null if not used anymore
            if (_findContext != null && _findContext.Count == 0)
            {
                _findContext = null;
            }

            if (_findContext == null)
            {
                // Optimized version with findContext
                foreach (var innerElement in AllItems)
                {
                    if (innerElement.Find(regex, toAdd, modifier, ref modifyParent))
                    {
                        elementsToRemove.Add(innerElement);
                    }
                }
            }
            else
            {
                foreach (var innerElement in AllItems)
                {
                    if (_findContext.Contains(innerElement.Name))
                    {
                        if (innerElement.Find(regex, toAdd, modifier, ref modifyParent))
                        {
                            elementsToRemove.Add(innerElement);
                        }
                    }
                }
            }

            // If we are removing the parent using modifyParent flag
            // Set modifyParent to false after removing in order to avoid recursive remove of all parents
            if (elementsToRemove.Count > 0 && modifyParent)
            {
                modifyParent = false;
                return(true);
            }

            foreach (var innerElementToRemove in elementsToRemove)
            {
                Remove(innerElementToRemove);
            }

            return(isToRemove);
        }