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));
}
