public PatternInfo(int pattype, int mType, AutomationElement item, BasePattern patObj) { PatternType = pattype; MethodType = mType; selectedItem = item; PatternObject = patObj; }
//public SnowController snowPrefab; //public EyeController eyePrefab; public BasePatternController CreateController(BasePattern bparam) { BasePatternController bctrl = null; /* TODO type switcher * switch(bparam.controllerType) { * case typeof(MoonController): * bctrl = Instantiate(moonPrefab); * break; * /* * case typeof(SnowController): * go = Instantiate(snowPrefab); * break; * case typeof(EyeController): * go = Instantiate(eyePrefab); * break; * default: * break; * } */ if (bparam.controllerType == typeof(MoonPatternController)) { bctrl = Instantiate(moonPrefab); } // if (bctrl) { bctrl.Initialize(bparam); } return(bctrl); }
public static void DisplayASTTransform(string patternText, AlgorithmType algorithmType, RegexOptions options) { BasePattern beforePattern = BasePattern.CreatePattern(patternText); BasePattern afterPattern = doTransform(patternText, algorithmType, options); displayASTTransform(patternText, beforePattern, afterPattern); }
public static void DisplayASTTransform(string patternText, BaseASTTransform transform) { BasePattern beforePattern = BasePattern.CreatePattern(patternText); BasePattern afterPattern = doTransform(beforePattern, transform); displayASTTransform(patternText, beforePattern, afterPattern); }
protected BaseMatcher(string patternText, RegexOptionsEx options) { Options = options; Pattern = BasePattern.CreatePattern(patternText); Pattern = TransformAST(Pattern); }
private void OnSwitchStateChanged(object sender, SwitchEventArgs switchEventArgs) { if (commonRunParameters1.InvokeRequired) { commonRunParameters1.Invoke(new Action(() => OnSwitchStateChanged(sender, switchEventArgs))); } if (switchEventArgs.SwitchEnabled) { if (_actualPattern == null) { World.Robot.RobotConsole[Leds.Led1].LedEnabled = switchEventArgs.SwitchEnabled; _actualPattern = new FindSpaceAndParkPattern((float)commonRunParameters1.UPSpeed.Value / 1000f, (float)commonRunParameters1.UPAcceleration.Value / 1000f); _actualPattern.PatternFinished += ActualPatternOnPatternFinished; _actualPattern.Start(); } else { _actualPattern.Restart(); } } else { if (_actualPattern != null) { _actualPattern.Halt(); } } }
public void CharEscapePattern_Empty() { BasePattern actual = BasePattern.CreatePattern(""); BasePattern expected = new GroupPattern(true, new BasePattern[] { }); Assert.AreEqual(expected, actual); }
public static void IsASTTransformCorrect(BasePattern expected, string patternText, AlgorithmType algorithmType, RegexOptions options) { BasePattern beforePattern = BasePattern.CreatePattern(patternText); BasePattern afterPattern = doTransform(patternText, algorithmType, options); displayASTTransform(patternText, beforePattern, afterPattern); Assert.AreEqual(expected, afterPattern); }
public static void IsASTTransformCorrect(BasePattern expected, string patternText, BaseASTTransform transform) { BasePattern beforePattern = BasePattern.CreatePattern(patternText); BasePattern afterPattern = doTransform(beforePattern, transform); displayASTTransform(patternText, beforePattern, afterPattern); Assert.AreEqual(expected, afterPattern); }
IEnumerator StartWithDelay(float delay, BasePattern bparam) { yield return(new WaitForSeconds(delay)); BasePatternController bctrl = patternFactory.CreateController(bparam); patternControllers.Add(bctrl); yield return(StartCoroutine(bctrl.Run())); }
public Scanner Pipe(BasePattern pattern) { while (pattern.IsMatch(_input)) { _input = pattern.CreateExpression(_input); } return(this); }
public BasePattern GetPattern(PATTERN_NAME patternName) { GameObject go = popFromPool(patternName); go.SetActive(true); BasePattern bp = go.GetComponent <BasePattern>(); return(bp); }
private static void displayASTTransform(string patternText, BasePattern beforePattern, BasePattern afterPattern) { Console.WriteLine("Pattern Text:\n {0}", patternText.ShowVerbatim()); Console.WriteLine("Before Transform:"); Console.WriteLine(beforePattern.FormatAsTree(1)); Console.WriteLine("After Transform{0}:", afterPattern.Equals(beforePattern) ? " (unchanged)" : ""); Console.WriteLine(afterPattern.FormatAsTree(1)); Console.Write("\n"); }
public BasePattern GetPattern(PatternState stat) { GameObject go = popFromPool(stat.m_ePattern); go.SetActive(true); BasePattern bp = go.GetComponent <BasePattern>(); return(bp); }
public static Promotion BuildRecurrentPromotion(BasePattern pattern, TimeSchedule timeSchedule, DateRange effectiveDateRange) { var promotion = BuildDefinitePromotion(null); promotion.Period = new Recurrent { Pattern = pattern, TimeSchedule = timeSchedule, EffectiveDateRange = effectiveDateRange }; return(promotion); }
public void CharEscapePattern_Short() { BasePattern actual = BasePattern.CreatePattern("abc"); BasePattern expected = new GroupPattern(true, new BasePattern[] { new CharEscapePattern('a'), new CharEscapePattern('b'), new CharEscapePattern('c') }); Assert.AreEqual(expected, actual); }
//=================================================================================================== // SetPattern 함수에서 넣은 패턴을 차례대로 실행합시다!! // 패턴을 패턴 매니저로 부터 꺼내오고 -> 패턴을 실행한다. // -> 패턴을 현재 실행중인 패턴 리스트에 집어넣는다. -> 만약 다음 패턴도 같이 섞어야 하면 같이 실행하자. //=================================================================================================== private void realPlayPattern() { BasePattern pattern = null; pattern = PatternMGR.Instance.GetPattern(m_cBossPatternList[m_CurPatternLevel].m_Pattern); pattern.PatternInit(m_cMover, PlayerMGR.Instance.m_Player, m_cBossPatternList[m_CurPatternLevel]); pattern.PatternStart(m_cBossPatternList[m_CurPatternLevel].m_PPDelay); m_CurPatternList.Add(pattern); MixPattern(); }
public void NegativeRanges() { BasePattern actual = BasePattern.CreatePattern("[A-Z][^x][^a-z][0-9]"); BasePattern expected = new GroupPattern(true, new BasePattern[] { new CharGroupPattern(true, new[] { uppercase }), new CharGroupPattern(false, "x"), new CharGroupPattern(false, new[] { lowercase }), new CharGroupPattern(true, new[] { digits }) }); Assert.AreEqual(expected, actual); }
public void Doubled() { BasePattern actual = BasePattern.CreatePattern(@"((ab)+)+"); BasePattern expected = new GroupPattern(true, new QuantifierPattern( new GroupPattern(true, new QuantifierPattern( new GroupPattern(true, new CharEscapePattern('a'), new CharEscapePattern('b')), 1, null, true)), 1, null, true)); Assert.AreEqual(expected, actual, "With parentheses"); }
private Parser <char, string> createParser(BasePattern pattern) { if (pattern == null) { throw new ArgumentNullException("pattern.", "Pattern is null when creating match parser."); } switch (pattern.Type) { case PatternType.Group: return(from vs in CharParsers.Sequence(((GroupPattern)pattern).Patterns .Select(p => createParser(p))) select vs.JoinStrings()); case PatternType.Quantifier: QuantifierPattern quant = (QuantifierPattern)pattern; return(from vs in CharParsers.Count(quant.MinOccurrences, quant.MaxOccurrences, createParser(quant.ChildPattern)) select vs.JoinStrings()); case PatternType.Alternation: return(CharParsers.Choice(((AlternationPattern)pattern).Alternatives .Select(p => createParser(p)) .ToArray())); case PatternType.String: return(CharParsers.String(((StringPattern)pattern).Value)); case PatternType.Char: return(from c in CharParsers.Satisfy(((CharPattern)pattern).IsMatch) select new string(c, 1)); default: throw new ApplicationException( string.Format("ExplicitDFAMatcher: unrecognized pattern type ({0}).", pattern.GetType().Name)); } }
void Start() { fullName = name.Split('_'); body = GetComponent <Rigidbody2D>(); scream = GetComponent <AudioSource>(); startPos = transform.position; controller = GetComponentInChildren <BasePattern>(); automator = GetComponentInChildren <AutomateBase>(); int delay = Random.Range(60, 120); StartCoroutine( CoroutineExt.WaitForFramesDo(delay, () => { controller.TriggerAutoFire = true; automator.enabled = true; }) ); endScreen.SetActive(false); }
public void Quantifiers() { BasePattern actual = BasePattern.CreatePattern(@"\d*\s?\W+x*?\n??y+?"); BasePattern expected = new GroupPattern( true, new BasePattern[] { new QuantifierPattern(CharGroupPattern.DigitChar, 0, null, true), new QuantifierPattern(CharGroupPattern.WhitespaceChar, 0, 1, true), new QuantifierPattern(CharGroupPattern.WordChar.Negated, 1, null, true), new QuantifierPattern(new CharEscapePattern('x'), 0, null, false), new QuantifierPattern(new CharEscapePattern('\n'), 0, 1, false), new QuantifierPattern(new CharEscapePattern('y'), 1, null, false) }); Assert.AreEqual(expected, actual); }
public void GroupPattern() { string pattern = "t(h(in))g"; BasePattern actual = BasePattern.CreatePattern(pattern); BasePattern expected = new GroupPattern(true, new BasePattern[] { new CharEscapePattern('t'), new GroupPattern(true, new BasePattern[] { new CharEscapePattern('h'), new GroupPattern(true, new BasePattern[] { new CharEscapePattern('i'), new CharEscapePattern('n') }), }), new CharEscapePattern('g') }); Assert.AreEqual(expected, actual, pattern); }
public void CharSetsAndRanges() { BasePattern actual = BasePattern.CreatePattern("[A-Z]"); BasePattern expected = new GroupPattern(true, new BasePattern[] { new CharGroupPattern(true, new[] { uppercase }) }); Assert.AreEqual(expected, actual, "One Range"); actual = BasePattern.CreatePattern("[.,;:?!A-Za-z][xya-zm-wA-M][msabcdm ;xyz]"); expected = new GroupPattern(true, new BasePattern[] { new CharGroupPattern(true, ".,;:?!", new[] { uppercase, lowercase }), new CharGroupPattern(true, "xy", new[] { lowercase, new CharRangePattern('m', 'w'), new CharRangePattern('A', 'M') }), new CharGroupPattern(true, "msabcd ;xyz") }); Assert.AreEqual(expected, actual); }
public override BasePattern Transform(BasePattern pattern) { if (pattern.Type == PatternType.Quantifier) { QuantifierPattern quant = (QuantifierPattern)pattern; BasePattern transformedChild = Transform(quant.ChildPattern); if (IsEmpty(transformedChild)) { return(GroupPattern.Empty); } BasePattern[] newPatterns = new[] { new QuantifierPattern(transformedChild, quant.MinOccurrences, quant.MinOccurrences, quant.IsGreedy), new QuantifierPattern(transformedChild, 0, quant.MaxOccurrences != null ? quant.MaxOccurrences - quant.MinOccurrences : null, quant.IsGreedy), } .Select(q => reduceQuantifier(q)) .Where(IsNotEmpty) .ToArray(); if (newPatterns.Length == 1) { return(newPatterns[0]); } else { return(new GroupPattern(false, newPatterns)); } } else { return(base.Transform(pattern)); } }
public override BasePattern Transform(BasePattern pattern) { if (pattern.Type == PatternType.Group) { // TODO: use groupBy (Haskell-style) GroupPattern group = (GroupPattern)pattern; List <BasePattern> newChildPatterns = new List <BasePattern>(); StringBuilder currentString = new StringBuilder(); foreach (BasePattern oldChildPattern in group.Patterns) { if (oldChildPattern is CharEscapePattern) { currentString.Append(((CharEscapePattern)oldChildPattern).Value); } else { if (currentString.Length > 0) { addStringPattern(newChildPatterns, currentString.ToString()); currentString = new StringBuilder(); } newChildPatterns.Add(Transform(oldChildPattern)); } } if (currentString.Length > 0) { addStringPattern(newChildPatterns, currentString.ToString()); } return(CreateGroupOrSingleton(group.IsCapturing, newChildPatterns.ToArray())); } else { return(base.Transform(pattern)); } }
public virtual BasePattern Transform(BasePattern pattern) { // The Identity transform switch (pattern.Type) { case PatternType.Group: GroupPattern group = (GroupPattern)pattern; BasePattern[] newChildren = group.Patterns .Select(p => Transform(p)) .Where(IsNotEmpty) .ToArray(); return(CreateGroupOrSingleton(group.IsCapturing, newChildren)); case PatternType.Quantifier: QuantifierPattern quant = (QuantifierPattern)pattern; BasePattern newChild = Transform(quant.ChildPattern); if (IsNotEmpty(newChild)) { return(new QuantifierPattern(newChild, quant.MinOccurrences, quant.MaxOccurrences, quant.IsGreedy)); } else { return(GroupPattern.Empty); } case PatternType.Alternation: return(new AlternationPattern(((AlternationPattern)pattern).Alternatives .Select(a => Transform(a)))); default: return(pattern); } }
public override BasePattern Transform(BasePattern pattern) { BasePattern transformed = pattern; if (pattern.Type == PatternType.Char) { if (Options.Singleline && transformed is AnyCharPattern) { transformed = new AnyCharPattern(true); } if (Options.IgnoreCase) { transformed = ((CharPattern)transformed).CaseInsensitive; } } else if (pattern.Type == PatternType.Anchor) { AnchorPattern anchor = (AnchorPattern)pattern; if (anchor.AnchorType == AnchorType.StartOfStringOrLine) { transformed = new AnchorPattern(Options.Multiline ? AnchorType.StartOfLine : AnchorType.StartOfString); } else if (anchor.AnchorType == AnchorType.EndOfStringOrLine) { transformed = new AnchorPattern(Options.Multiline ? AnchorType.EndOfLine : AnchorType.EndOfStringOrBeforeEndingNewline); } } if (transformed != pattern) { return(transformed); } else { return(base.Transform(pattern)); } }
public void Ranges() { BasePattern actual = BasePattern.CreatePattern("[A-Z]"); BasePattern expected = new GroupPattern(true, new BasePattern[] { new CharGroupPattern(true, new[] { uppercase }) }); Assert.AreEqual(expected, actual, "One Range"); actual = BasePattern.CreatePattern("[A-Z][a-z][0-9][a-zA-Z][A-Za-z0-9][a-zm-wA-M]"); expected = new GroupPattern(true, new BasePattern[] { new CharGroupPattern(true, new[] { uppercase }), new CharGroupPattern(true, new[] { lowercase }), new CharGroupPattern(true, new[] { digits }), new CharGroupPattern(true, new[] { lowercase, uppercase }), new CharGroupPattern(true, new[] { uppercase, lowercase, digits }), new CharGroupPattern(true, new[] { lowercase, new CharRangePattern('m', 'w'), new CharRangePattern('A', 'M') }) }); Assert.AreEqual(expected, actual, "Many Ranges"); }
protected override Result <char, Match2> Parse(ArrayConsList <char> consList, int afterLastMatchIndex) { BacktrackPoint lastBacktrackPoint = null; StackFrame callStack = new GroupStackFrame(null, Pattern); var partialResult = new Result <char, int>(0, consList); while (callStack != null) { if (callStack is QuantifierStackFrame) { QuantifierStackFrame quantStackFrame = (QuantifierStackFrame)callStack; if (quantStackFrame.IsPositionChanged(partialResult.Tree)) { lastBacktrackPoint = new BacktrackPoint(lastBacktrackPoint, quantStackFrame.SecondAlternative(partialResult.Tree), partialResult); callStack = quantStackFrame.FirstAlternative(partialResult.Tree); } else { callStack = quantStackFrame.Parent; } } else { BasePattern currentPattern = callStack.RemainingChildren.Head; if (currentPattern.MinCharLength > partialResult.Rest.Length) { partialResult = null; } else { callStack = ((GroupStackFrame)callStack).MoveToNextChild(); switch (currentPattern.Type) { case PatternType.Group: callStack = new GroupStackFrame(callStack, ((GroupPattern)currentPattern).Patterns); break; case PatternType.Quantifier: var quant = (QuantifierPattern)currentPattern; quant.AssertCanonicalForm(); if (quant.MinOccurrences == quant.MaxOccurrences) { callStack = new GroupStackFrame(callStack, new RepeaterConsList <BasePattern>(quant.ChildPattern, quant.MinOccurrences)); } else { callStack = new QuantifierStackFrame(callStack, quant); } break; case PatternType.Alternation: var alternatives = ((AlternationPattern)currentPattern).Alternatives; foreach (var alt in alternatives.Skip(1).Reverse()) { lastBacktrackPoint = new BacktrackPoint(lastBacktrackPoint, new GroupStackFrame(callStack, alt), partialResult); } callStack = new GroupStackFrame(callStack, alternatives.First()); break; case PatternType.Anchor: if (!doesAnchorMatch(((AnchorPattern)currentPattern).AnchorType, (ArrayConsList <char>)partialResult.Rest, afterLastMatchIndex)) { partialResult = null; } break; case PatternType.Char: partialResult = parseChar(partialResult, ((CharPattern)currentPattern).IsMatch); break; default: throw new ApplicationException( string.Format("BacktrackingMatcher: unrecognized pattern type ({0}).", currentPattern.GetType().Name)); } } if (partialResult == null) { if (lastBacktrackPoint != null) { callStack = lastBacktrackPoint.CallStack; partialResult = lastBacktrackPoint.PartialResult; lastBacktrackPoint = lastBacktrackPoint.Previous; } else { return(new Result <char, Match2>(Match2.Empty, consList)); } } } callStack = unwindEmptyFrames(callStack); } return(new Result <char, Match2>( new Match2(consList.ArrayIndex, partialResult.Tree, consList.AsEnumerable().Take(partialResult.Tree).AsString()), partialResult.Rest)); }