Пример #1
0
        public void Rollback(RollbackInfo rollbackInfo)
        {
            foreach (var tag in rollbackInfo.Tags)
            {
                this[tag.Key] = tag.Value;
            }

            ChangeFileName(rollbackInfo.OldFileName);
        }
Пример #2
0
        public void Dispose()
        {
            if (!_fileChanged)
            {
                return;
            }

            var data = new RollbackInfo(GetId3Data().ToList(), FilePath, _oldFilePath);

            new RollbackManager(_saver).AddAction(data).Dispose();
        }
Пример #3
0
        private void SaveRollBackInfo(int exIndex, int patIndex)
        {
            RollbackInfo info = new RollbackInfo();

            info.exIndex  = exIndex;
            info.patIndex = patIndex;

            if (rollBackStack == null)
            {
                rollBackStack = new Stack <RollbackInfo>();
            }

            rollBackStack.Push(info);
        }
Пример #4
0
        //---------------------------------------------------------------------
        private void RequestPopRollback(UIWindow currentWin)
        {
            if (m_InRequestRollback || m_RollbackStack.Count == 0)
            {
                return;
            }

            m_InRequestRollback = true;
            RollbackInfo info = m_RollbackStack.Peek();

            if (!CanRollback(currentWin) || info.source != currentWin)
            {
                m_InRequestRollback = false;
                return;
            }

            int remainShowCount = info.winList.Count;

            currentWin.CancelHide();
            for (int i = 0; i < info.winList.Count; ++i)
            {
                UIWindow rollbackWin    = info.winList[i];
                Action   preShowHandler = null;
                preShowHandler = delegate() {
                    currentWin.PreShowEvent -= preShowHandler;
                    --remainShowCount;
                    if (remainShowCount == 0)
                    {
                        bool lastState = m_InRequestRollback;
                        m_InRequestRollback = true;
                        currentWin.Hide();
                        m_InRequestRollback = lastState;
                    }
                };
                rollbackWin.PreShowEvent += preShowHandler;

                if (rollbackWin.IsShow())
                {
                    preShowHandler();
                }
                else
                {
                    rollbackWin.Show((object[])rollbackWin.NotifyPopRollback());
                }
            }

            m_InRequestRollback = false;
        }
Пример #5
0
        public UpdaterCore(WindowsPatcherConfig windowsPatcherConfig, Process hostProcess,
                           IPatcherTranslation translation)
        {
            _windowsPatcherConfig = windowsPatcherConfig;
            _hostProcess          = hostProcess;
            _environmentManager   = new EnvironmentManager(windowsPatcherConfig);
            _rollbackInfo         = new RollbackInfo("rollbackInfo.json")
            {
                ApplicationPath = windowsPatcherConfig.ApplicationPath,
                PatcherConfig   = windowsPatcherConfig
            };
            _logger     = new Logger(Path.Combine(windowsPatcherConfig.ActionConfig.ProjectId.GetTempDirectory(), "patcher", "log.txt"));
            Translation = translation;

            _statusUpdater = new StatusUpdater(Translation);
            _statusUpdater.StatusUpdated += StatusUpdaterOnStatusUpdated;
        }
        public static void DoPveRollback(ShopInfo shopInfo, Units unit)
        {
            RollbackInfo rollbackInfo = shopInfo.RollbackStack.Peek();

            if (rollbackInfo != null)
            {
                BattleEquipTools_op.ChangeHeroMoney(unit.unique_id, -rollbackInfo._deltaMoney);
                BattleEquipTools_op.SetHeroItems(unit, rollbackInfo._items);
            }
            byte[] msgParam = SerializeHelper.Serialize <RetaMsg>(new RetaMsg
            {
                retaCode = 0
            });
            MobaMessage message = MobaMessageManager.GetMessage(PvpCode.C2P_RevertShop, msgParam, 0f, null);

            MobaMessageManager.DispatchMsg(message);
        }
Пример #7
0
        private bool RollBackToLastPartialMatch(ref int exIndex, ref int patIndex)
        {
            if (rollBackStack == null || rollBackStack.Count == 0)
            {
                return(false);
            }

            // restore state up to the last expression variable
            RollbackInfo info = (RollbackInfo)rollBackStack.Pop();

            exIndex  = info.exIndex;
            patIndex = info.patIndex;

            // clear values of all bound variables starting later than patIndex
            ClearBoundValues(patIndex);
            return(true);
        }
Пример #8
0
        //---------------------------------------------------------------------
        public bool IsRollback(string name)
        {
            Stack <RollbackInfo> .Enumerator iter =
                Instance.m_RollbackStack.GetEnumerator();
            while (iter.MoveNext())
            {
                RollbackInfo info = iter.Current;
                for (int index = 0; index < info.winList.Count; ++index)
                {
                    if (info.winList[index].WindowName == name)
                    {
                        return(true);
                    }
                }
            }

            return(false);
        }
Пример #9
0
        private void SaveRollBackInfo(int exIndex, int patIndex)
        {
            RollbackInfo info = new RollbackInfo();
            info.exIndex = exIndex;
            info.patIndex = patIndex;

            if (rollBackStack == null)
                rollBackStack = new Stack<RollbackInfo>();

            rollBackStack.Push(info);
        }
Пример #10
0
		public static bool Match(PassiveExpression expression, Pattern pattern)
		{
			bool match = true;
			Stack rollBackStack = new Stack();

			// assume that expression and pattern aren't empty
			int exIndex = 0, patIndex = 0;

			while (true)
			{
				while (match && patIndex < pattern.Count && exIndex < expression.Count)
				{
					object ex = expression[exIndex];
					object pat = pattern[patIndex];

					bool needRollback = false;

					// braces can only match itself
					if (pat is OpeningBrace)
					{
						if (ex is OpeningBrace)
						{
							exIndex++; patIndex++;
							continue;
						}
						else
							needRollback = true;
					}
					else if (pat is ClosingBrace)
					{
						if (ex is ClosingBrace)
						{
							exIndex++; patIndex++;
							continue;
						}
						else
							needRollback = true;
					}

					// symbol matches single symbol
					else if (!(pat is Variable))
					{
						// check for () is redundant because of ex.Equals(pat)
						if (ex.Equals(pat) && !(ex is StructureBrace))
						{
							exIndex++; patIndex++;
							continue;
						}
						else
							needRollback = true;
					}

					// symbol or term variable matches single symbol
					else if ((pat is SymbolVariable || pat is TermVariable) && !(ex is StructureBrace))
					{
						Variable var = pat as Variable;

						if (patIndex == var.FirstOccurance)
						{
							var.Value = ex;
							exIndex++; patIndex++;
							continue;
						}
						else if (ex.Equals(var.Value))
						{
							exIndex++; patIndex++;
							continue;
						}
						else 
						{
							// symbol don't match the bound variable,
							// roll back to the last expression variable
							needRollback = true;
						}
					}

					// term variable matches subexpression in structure braces
					else if ((pat is TermVariable) && (ex is StructureBrace))
					{
						TermVariable term = pat as TermVariable;

						// first occurance => copy subexpression
						if (patIndex == term.FirstOccurance)
						{
							if (ex is OpeningBrace)
							{
								term.Expression.Add(ex);
								exIndex++; patIndex++;

								// extract subexpression within the structure braces
								int rank = 1;
								while (exIndex < expression.Count && rank > 0)
								{
									ex = expression[exIndex++];
									term.Expression.Add(ex);

									if (ex is OpeningBrace)
										rank++;
									else if (ex is ClosingBrace)
										rank--;
								}

								// subexpression with surrounding braces is extracted
								if (rank == 0)
									continue;
								else
								{
									// closing structure brace not found => rolling back
									// in fact, this can only be caused by unmatched braces...
									needRollback = true;
								}
							}
							else 
							{
								needRollback = true;
							}
						}
						else // not the first occurance => compare expression
						{
							if (CompareExpressions(expression, exIndex, term.Expression))
							{
								exIndex += term.Expression.Count; patIndex++;
								continue;
							}
							else
								needRollback = true;
						}
					}

					// expression variable can match nothing, symbol(s), 
					// and expression(s) within structure braces
					else if (pat is ExpressionVariable)
					{
						ExpressionVariable var = pat as ExpressionVariable;

						if (patIndex == var.FirstOccurance)
						{
							if (var.Expression == null)
							{
								// start with empty expression
								var.Expression = new PassiveExpression();
								RollbackInfo info = new RollbackInfo();
								info.exIndex = exIndex;
								info.patIndex = patIndex;
								rollBackStack.Push(info);
								patIndex++;
								continue;
							}
							else
							{
								// continue adding terms to expression
								if (!(ex is StructureBrace))
								{
									var.Expression.Add(ex);
									RollbackInfo info = new RollbackInfo();
									info.exIndex = exIndex + 1;
									info.patIndex = patIndex;
									rollBackStack.Push(info);
									exIndex++; patIndex++;
									continue;
								}
								// handle structure braces, extract subexpression
								else if (ex is OpeningBrace)
								{
									var.Expression.Add(ex);
									exIndex++;

									// extract subexpression within the structure braces
									int rank = 1;
									while (exIndex < expression.Count && rank > 0)
									{
										ex = expression[exIndex++];
										var.Expression.Add(ex);

										if (ex is OpeningBrace)
											rank++;
										else if (ex is ClosingBrace)
											rank--;
									}

									// subexpression with surrounding braces is extracted
									if (rank == 0)
										continue;
									else
									{
										// closing structure brace not found => rolling back
										// this can only be caused by unmatched braces => error in compiler
										needRollback = true;
									}
								}
								else
								{
									// extra closing brace ) => roll back
									needRollback = true;
								}
							}
						}
						else // not the first occurance, compare expressions
						{
							if (CompareExpressions(expression, exIndex, var.Expression))
							{
								exIndex += var.Expression.Count; patIndex++;
								continue;
							}
							else
								// expression don't match, roll back
								needRollback = true;
						}
					}

					// if can't find any match, roll back
					else
					{
						needRollback = true;
					}

					// roll back to the last expression variable, if needed
					if (needRollback)
					{
						// can't roll back => matching failed
						if (rollBackStack.Count == 0)
						{
							match = false;
						}
						else
						{
							// restore state up to the last expression variable
							RollbackInfo info = (RollbackInfo)rollBackStack.Pop();
							exIndex = info.exIndex;
							patIndex = info.patIndex;

							// clear values of all bound variables starting later than patIndex
							ClearBoundValues(pattern, patIndex);
						}
					} // if (needRollback)

				} // while()

				if (match && patIndex >= pattern.Count && exIndex >= expression.Count)
					return true;

				// check for special case: expression has ended, but pattern contains a few expression variables
				// in that case, matching should succeed, with all remaining variables taking empty values
				if (match && exIndex >= expression.Count && patIndex < pattern.Count)
				{
					while (match && patIndex < pattern.Count)
					{
						object pat = pattern[patIndex++];
						if (!(pat is ExpressionVariable))
						{
							match = false;
							break;
						}

						ExpressionVariable var = (ExpressionVariable)pat;
						var.Expression = new PassiveExpression();
					}

					if (match && patIndex >= pattern.Count)
						return true;
				}

				// if can roll back, try once more
				if (rollBackStack.Count == 0)
				{
					// nothing to roll back => matching has failed
					return false;
				}
				else
				{
					// restore state up to the last expression variable and iterate once more!
					RollbackInfo info = (RollbackInfo)rollBackStack.Pop();
					exIndex = info.exIndex;
					patIndex = info.patIndex;

					// clear values of all bound variables starting later than patIndex
					ClearBoundValues(pattern, patIndex);
				}
			}
		}
Пример #11
0
 public void Rollback(RollbackInfo rollbackInfo)
 {
 }
Пример #12
0
        //---------------------------------------------------------------------
        private void RequestPushRollback(UIWindow currentWin)
        {
            if (m_InRequestRollback)
            {
                return;
            }

            m_InRequestRollback = true;
            if (!CanRollback(currentWin))
            {
                m_InRequestRollback = false;
                return;
            }

            if (m_RollbackStack.Count != 0 &&
                m_RollbackStack.Peek().source == currentWin)
            {
                m_InRequestRollback = false;
                return;
            }

            List <UIWindow> winList = new List <UIWindow>();

            for (int i = 0; i < m_WindowList.Count; ++i)
            {
                UIWindow lastWin = m_WindowList[i];
                if (lastWin != currentWin && lastWin.IsShow() && !lastWin.IsHiding() &&
                    m_RollbackGroupList.Contains(lastWin.windowGroup))
                {
                    winList.Add(lastWin);
                }

                /*
                 * if (lastWin != currentWin && lastWin.IsShow() &&
                 *  m_RollbackGroupList.Contains(lastWin.windowGroup)) {
                 *  winList.Add(lastWin);
                 * }
                 */
            }

            if (winList.Count != 0)
            {
                RollbackInfo info = new RollbackInfo(currentWin, winList);
                m_RollbackStack.Push(info);

                Action preShowHandler = null;
                preShowHandler = delegate() {
                    bool lastState = m_InRequestRollback;
                    m_InRequestRollback      = true;
                    currentWin.PreShowEvent -= preShowHandler;
                    for (int i = 0; i < info.winList.Count; ++i)
                    {
                        UIWindow rollbackWin = info.winList[i];
                        rollbackWin.Hide((object[])rollbackWin.NotifyPushRollback());
                    }
                    m_InRequestRollback = lastState;
                };
                currentWin.PreShowEvent += preShowHandler;
            }

            m_InRequestRollback = false;
        }