public bool Match(string input)
{
string romanAlphabet = RomanSymbol.GetAlphabet();
string[] parts = Regex.Split(input, Constant.ExpressionSplitter, RegexOptions.IgnoreCase);
if (parts.Length != 2)
{
return(false);
}
string roman = parts[1];
bool found = false;
for (int i = 0; i < romanAlphabet.Length; i++)
{
if (String.Equals(roman, romanAlphabet[i].ToString(), StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
return(found);
}
public bool Match(string input)
{
string romanAlphabet = RomanSymbol.GetAlphabet();
string[] parts = input.ToUpper().Split(new string[] { " IS " }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length != 2)
{
return(false);
}
string roman = parts[1];
bool found = false;
for (int i = 0; i < romanAlphabet.Length; i++)
{
if (String.Equals(roman, romanAlphabet[i].ToString(), StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
return(found);
}
public bool IsMatch(string symbols)
{
var romanSymbols = RomanSymbol.GetRomanSymbols();
var parts = symbols.Split(" is ", StringSplitOptions.RemoveEmptyEntries);
if (parts.Length != 2)
{
return(false);
}
return(romanSymbols.Contains(parts[1]));
}
public void CanDeclareConstant()
{
var interpreter = new LineInterpreter();
interpreter.ParseAndExecute("glob is I");
var globSymbol = new ConstantSymbol("glob");
var iSymbol = new RomanSymbol("I");
Assert.IsTrue(interpreter.Processor.ConstantsTable.ContainsKey(globSymbol));
Assert.AreEqual(iSymbol, interpreter.Processor.ConstantsTable[globSymbol]);
}
public bool Execute(string input)
{
for (int i = 0; i < input.Length; i++)
{
if (i < input.Length - 1)
{
if (RomanSymbol.IsSmaller(input[i].ToString(), input[i + 1].ToString()) && !RomanSymbol.IsSubtractionAllowed(input[i].ToString()))
{
Console.WriteLine("InvalidSubtraction Rule has been violated");
return(false);
}
}
}
return(true);
}
public Symbol GetNextSymbol()
{
Symbol ret;
if (_arguments.Length == _currentReadPosition)
{
return(null);
}
var lastArg = _arguments[_currentReadPosition];
switch (lastArg)
{
case Keywords.Operators.Is:
ret = new Symbol(lastArg, SymbolKind.Operator);
break;
case Keywords.Qualifiers.QueryCommandQualifier:
ret = new Symbol(lastArg, SymbolKind.QueryQualifier);
break;
case Keywords.RomanSymbols.I:
case Keywords.RomanSymbols.V:
case Keywords.RomanSymbols.X:
case Keywords.RomanSymbols.L:
case Keywords.RomanSymbols.C:
case Keywords.RomanSymbols.D:
case Keywords.RomanSymbols.M:
ret = new RomanSymbol(lastArg);
break;
case Keywords.Statements.How:
ret = new Symbol(lastArg, SymbolKind.Statement);
break;
case Keywords.SubStatements.Many:
case Keywords.SubStatements.Much:
ret = new Symbol(lastArg, SymbolKind.SubStatemant);
break;
default:
ret = GetDeclarationSymbol(lastArg);
break;
}
_currentReadPosition++;
return(ret);
}
public bool CheckViolation(string input)
{
if (input.Length < 3)
{
return(true);
}
for (int i = input.Length - 1; i >= 2; i--)
{
if (RomanSymbol.IsSmaller(input[i - 1].ToString(), input[i].ToString()) &&
RomanSymbol.IsSmaller(input[i - 2].ToString(), input[i].ToString()))
{
Console.WriteLine("SingleSubtraction Rule has been violated");
return(false);
}
}
return(true);
}
private int CalculateAbsoluteValue()
{
int resultValue = 0;
RomanSymbol current = RomanSymbol.Null;
for (int i = Text.Length - 1; i >= 0; i--)
{
RomanSymbol before = (RomanSymbol)Enum.Parse(typeof(RomanSymbol), Text[i].ToString());
if (before >= current)
{
resultValue += (int)before;
}
else
{
resultValue -= (int)before;
}
current = before;
}
return(resultValue);
}
private static IEnumerable <RomanSymbol> ExtractSymbolPart(ArabicNumber arabic, RomanSymbol romanSymbol)
{
if (SpecialRomanSymbols.ContainsEquivalent(arabic))
{
return(SpecialRomanSymbols.GetItemsFromEquivalent(arabic));
}
var repetition = RomanSymbolRepetition.FromOcurrancesOfSymbol(romanSymbol, arabic);
return(repetition.Equals(RomanSymbolRepetition.Empty)
? new RomanSymbol[0]
: repetition.Items);
}
public int DevidedBy(RomanSymbol romanSymbol) => Value / romanSymbol.ArabicValue;
private int ToNegative(RomanSymbol romanSymbol) => romanSymbol.ArabicValue * -1;
public bool IsNegativeRoman(RomanSymbol romanSymbol) => Value == ToNegative(romanSymbol);
public bool IsGreaterOrEqualTo(RomanSymbol romanSymbol) => Value == romanSymbol.ArabicValue || IsGreaterThan(romanSymbol);
public bool IsGreaterThan(RomanSymbol romanSymbol) => Value > romanSymbol.ArabicValue;
public void CleanTestData()
{
romanSymbol = null;
irregularSymbolsDefinition.Clear();
}
public void Init()
{
romanSymbol = new RomanSymbol("I", 1, "VX", true, true);
irregularSymbolsDefinition = new System.Collections.Generic.Dictionary <string, RomanSymbol>();
irregularSymbolsDefinition.Add("glob", romanSymbol);
}
