public static Boolean TryParse(String path, out Configuration aConfiguration)
{
Errors = new List <String>();
ActualIntersectingKeys = new Boolean[26];
ActualNonIntersectingKeys = new Boolean[26];
ActualKeys = new List <string>();
aConfiguration = new Configuration(path);
if (aConfiguration.ConfigurationFileName.IndexOfAny(Path.GetInvalidFileNameChars()) > -1)
{
Errors.Add(String.Format(ConfigurationErrors.FilenameError, path));
}
else
{
StreamReader fileIn = new StreamReader(path);
// Validate file.
while (!fileIn.EndOfStream)
{
// Read a line.
String line = fileIn.ReadLine();
// Parse a configuration item.
ConfigurationFileItem aConfigurationItem;
if (ConfigurationFileItem.TryParse(line, out aConfigurationItem))
{
if (aConfigurationItem.KeyValue != null && ActualKeys.Contains(aConfigurationItem.KeyValue.Key))
{
Errors.Add(String.Format(ConfigurationErrors.DuplicateKeyError, aConfigurationItem.KeyValue.OriginalKeyValue));
}
else
{
// Record that this key has been found.
if (aConfigurationItem.KeyValue != null)
{
ActualKeys.Add(aConfigurationItem.KeyValue.Key);
}
// Process the key-value.
if (aConfigurationItem.IsLogFile)
{
// Get the value representing an invalid score.
aConfiguration.LogFileName = aConfigurationItem.KeyValue.Value.Trim();
if (Validator.IsDelimited(aConfiguration.LogFileName, Crozzle.StringDelimiters))
{
aConfiguration.LogFileName = aConfiguration.LogFileName.Trim(Crozzle.StringDelimiters);
if (!Validator.IsFilename(aConfiguration.LogFileName))
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMinimumNumberOfUniqueWords)
{
// Get the value of the minimum number of unique words allowed in the wordlist.
int minimum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumNumberOfUniqueWords = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMaximumNumberOfUniqueWords)
{
// Get the value of the maximum number of unique words allowed in the wordlist.
int maximum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumNumberOfUniqueWords = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsInvalidCrozzleScore)
{
// Get the value representing an invalid score.
aConfiguration.InvalidCrozzleScore = aConfigurationItem.KeyValue.Value.Trim();
if (Validator.IsDelimited(aConfiguration.InvalidCrozzleScore, Crozzle.StringDelimiters))
{
aConfiguration.InvalidCrozzleScore = aConfiguration.InvalidCrozzleScore.Trim(Crozzle.StringDelimiters);
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsUppercase)
{
// Get the Boolean value that determines whether to display the crozzle letters in uppercase or lowercase.
Boolean uppercase = true;
if (!Validator.IsMatch(aConfigurationItem.KeyValue.Value, allowedBooleans))
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
aConfiguration.Uppercase = uppercase;
}
else if (aConfigurationItem.IsStyle)
{
// Get the value of the HTML style to display the crozzle in an HTML table.
aConfiguration.Style = aConfigurationItem.KeyValue.Value.Trim();
if (Validator.IsDelimited(aConfiguration.Style, Crozzle.StringDelimiters))
{
aConfiguration.Style = aConfiguration.Style.Trim(Crozzle.StringDelimiters);
if (!Validator.IsStyleTag(aConfiguration.Style))
{
Errors.Add(String.Format(ConfigurationErrors.StyleError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsBGcolourEmptyTD)
{
// Get the value of the background colour for an empty TD (HTML table data).
aConfiguration.BGcolourEmptyTD = aConfigurationItem.KeyValue.Value.Trim();
if (!Validator.IsHexColourCode(aConfiguration.BGcolourEmptyTD))
{
Errors.Add(String.Format(ConfigurationErrors.ColourError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsBGcolourNonEmptyTD)
{
// Get the value of the background colour for a non empty TD (HTML table data).
aConfiguration.BGcolourNonEmptyTD = aConfigurationItem.KeyValue.Value.Trim();
if (!Validator.IsHexColourCode(aConfiguration.BGcolourNonEmptyTD))
{
Errors.Add(String.Format(ConfigurationErrors.ColourError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMinimumNumberOfRows)
{
// Get the value of the minimum number of rows per crozzle.
int minimum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumNumberOfRows = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMaximumNumberOfRows)
{
// Get the value of the maximum number of rows per crozzle.
int maximum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumNumberOfRows = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMinimumNumberOfColumns)
{
// Get the value of the minimum number of columns per crozzle.
int minimum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumNumberOfColumns = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMaximumNumberOfColumns)
{
// Get the value of the maximum number of columns per crozzle.
int maximum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumNumberOfColumns = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMinimumHorizontalWords)
{
// Get the value of the minimum number of horizontal words in a crozzle.
int minimum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumHorizontalWords = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMaximumHorizontalWords)
{
// Get the value of the maximum number of horizontal words in a crozzle.
int maximum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumHorizontalWords = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMinimumVerticalWords)
{
// Get the value of the minimum number of vertical words in a crozzle.
int minimum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumVerticalWords = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMaximumVerticalWords)
{
// Get the value of the maximum number of vertical words in a crozzle.
int maximum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumVerticalWords = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMinimumIntersectionsInHorizontalWords)
{
// Get the value of the minimum number of the intersections in a horizontal word.
int minimum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumIntersectionsInHorizontalWords = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMaximumIntersectionsInHorizontalWords)
{
// Get the value of the maximum number of the intersections in a horizontal word.
int maximum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumIntersectionsInHorizontalWords = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMinimumIntersectionsInVerticalWords)
{
// Get the value of the minimum number of the intersections in a vertical word.
int minimum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumIntersectionsInVerticalWords = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMaximumIntersectionsInVerticalWords)
{
// Get the value of the maximum number of the intersections in a vertical word.
int maximum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumIntersectionsInVerticalWords = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMinimumNumberOfTheSameWord)
{
// Get the value of the minimum number of the same word per crozzle limit.
int minimum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumNumberOfTheSameWord = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMaximumNumberOfTheSameWord)
{
// Get the value of the maximum number of the same word per crozzle limit.
int maximum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumNumberOfTheSameWord = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMinimumNumberOfGroups)
{
// Get the value of the minimum number of groups per crozzle limit.
int minimum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumNumberOfGroups = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsMaximumNumberOfGroups)
{
// Get the value of the maximum number of groups per crozzle limit.
int maximum;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumNumberOfGroups = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsPointsPerWord)
{
// Get the value of points per words.
int pointsPerWord;
if (Validator.IsInt32(aConfigurationItem.KeyValue.Value.Trim(), out pointsPerWord))
{
aConfiguration.PointsPerWord = pointsPerWord;
if (!Validator.TryRange(pointsPerWord, 0, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aConfigurationItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aConfigurationItem.IsIntersecting)
{
// Get the values of each INTERSECTING point.
String originalValues = aConfigurationItem.KeyValue.Value.Trim();
if (Validator.IsDelimited(originalValues, Crozzle.StringDelimiters))
{
originalValues = originalValues.Trim(Crozzle.StringDelimiters).Trim();
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, originalValues, Validator.Errors[0]));
}
String[] intersectingPoints = originalValues.Split(PointSeparators);
foreach (String intersectingPoint in intersectingPoints)
{
KeyValue aKeyValue;
if (KeyValue.TryParse(intersectingPoint, @"[A-Z]", out aKeyValue))
{
int points;
if (Validator.IsInt32(aKeyValue.Value, out points))
{
int index = (int)aKeyValue.Key[0] - (int)'A';
aConfiguration.IntersectingPointsPerLetter[index] = points;
ActualIntersectingKeys[index] = true;
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aKeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.AddRange(KeyValue.Errors);
}
}
}
else if (aConfigurationItem.IsNonIntersecting)
{
// Get the value of each NONINTERSECTING point.
String originalValues = aConfigurationItem.KeyValue.Value.Trim();
if (Validator.IsDelimited(originalValues, Crozzle.StringDelimiters))
{
originalValues = originalValues.Trim(Crozzle.StringDelimiters).Trim();
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, originalValues, Validator.Errors[0]));
}
String[] nonIntersectingPoints = originalValues.Split(PointSeparators);
foreach (String nonIntersectingPoint in nonIntersectingPoints)
{
KeyValue aKeyValue;
if (KeyValue.TryParse(nonIntersectingPoint, @"[A-Z]", out aKeyValue))
{
int points;
if (Validator.IsInt32(aKeyValue.Value, out points))
{
int index = (int)aKeyValue.Key[0] - (int)'A';
aConfiguration.NonIntersectingPointsPerLetter[index] = points;
ActualNonIntersectingKeys[index] = true;
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aKeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.AddRange(KeyValue.Errors);
}
}
}
}
}
else
{
Errors.AddRange(ConfigurationFileItem.Errors);
}
}
// Close files.
fileIn.Close();
// Check which keys are missing from the configuration file.
foreach (string expectedKey in ExpectedKeys)
{
if (!ActualKeys.Contains(expectedKey))
{
Errors.Add(String.Format(ConfigurationErrors.MissingKeyError, expectedKey));
}
}
for (char ch = 'A'; ch <= 'Z'; ch++)
{
if (!ActualIntersectingKeys[(int)ch - (int)'A'])
{
Errors.Add(String.Format(ConfigurationErrors.MissingIntersectionKeyError, ch.ToString()));
}
}
for (char ch = 'A'; ch <= 'Z'; ch++)
{
if (!ActualNonIntersectingKeys[(int)ch - (int)'A'])
{
Errors.Add(String.Format(ConfigurationErrors.MissingNonIntersectionKeyError, ch.ToString()));
}
}
// Check that minimum values are <= to their maximmum counterpart values.
if (ActualKeys.Contains("MINIMUM_NUMBER_OF_UNIQUE_WORDS") && ActualKeys.Contains("MAXIMUM_NUMBER_OF_UNIQUE_WORDS"))
{
if (aConfiguration.MinimumNumberOfUniqueWords > aConfiguration.MaximumNumberOfUniqueWords)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "MINIMUM_NUMBER_OF_UNIQUE_WORDS",
aConfiguration.MinimumNumberOfUniqueWords, aConfiguration.MaximumNumberOfUniqueWords));
}
}
if (ActualKeys.Contains("MINIMUM_NUMBER_OF_ROWS") && ActualKeys.Contains("MAXIMUM_NUMBER_OF_ROWS"))
{
if (aConfiguration.MinimumNumberOfRows > aConfiguration.MaximumNumberOfRows)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "MINIMUM_NUMBER_OF_ROWS",
aConfiguration.MinimumNumberOfRows, aConfiguration.MaximumNumberOfRows));
}
}
if (ActualKeys.Contains("MINIMUM_NUMBER_OF_COLUMNS") && ActualKeys.Contains("MAXIMUM_NUMBER_OF_COLUMNS"))
{
if (aConfiguration.MinimumNumberOfColumns > aConfiguration.MaximumNumberOfColumns)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "MINIMUM_NUMBER_OF_COLUMNS",
aConfiguration.MinimumNumberOfColumns, aConfiguration.MaximumNumberOfColumns));
}
}
if (ActualKeys.Contains("MINIMUM_HORIZONTAL_WORDS") && ActualKeys.Contains("MAXIMUM_HORIZONTAL_WORDS"))
{
if (aConfiguration.MinimumHorizontalWords > aConfiguration.MaximumHorizontalWords)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "MINIMUM_HORIZONTAL_WORDS",
aConfiguration.MinimumHorizontalWords, aConfiguration.MaximumHorizontalWords));
}
}
if (ActualKeys.Contains("MINIMUM_VERTICAL_WORDS") && ActualKeys.Contains("MAXIMUM_VERTICAL_WORDS"))
{
if (aConfiguration.MinimumVerticalWords > aConfiguration.MaximumVerticalWords)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "MINIMUM_VERTICAL_WORDS",
aConfiguration.MinimumVerticalWords, aConfiguration.MaximumVerticalWords));
}
}
if (ActualKeys.Contains("MINIMUM_INTERSECTIONS_IN_HORIZONTAL_WORDS") && ActualKeys.Contains("MAXIMUM_INTERSECTIONS_IN_HORIZONTAL_WORDS"))
{
if (aConfiguration.MinimumIntersectionsInHorizontalWords > aConfiguration.MaximumIntersectionsInHorizontalWords)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "MINIMUM_INTERSECTIONS_IN_HORIZONTAL_WORDS",
aConfiguration.MinimumIntersectionsInHorizontalWords, aConfiguration.MaximumIntersectionsInHorizontalWords));
}
}
if (ActualKeys.Contains("MAXIMUM_INTERSECTIONS_IN_VERTICAL_WORDS") && ActualKeys.Contains("MAXIMUM_INTERSECTIONS_IN_VERTICAL_WORDS"))
{
if (aConfiguration.MinimumIntersectionsInVerticalWords > aConfiguration.MaximumIntersectionsInVerticalWords)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "MAXIMUM_INTERSECTIONS_IN_VERTICAL_WORDS",
aConfiguration.MinimumIntersectionsInVerticalWords, aConfiguration.MaximumIntersectionsInVerticalWords));
}
}
if (ActualKeys.Contains("MINIMUM_NUMBER_OF_THE_SAME_WORD") && ActualKeys.Contains("MAXIMUM_NUMBER_OF_THE_SAME_WORD"))
{
if (aConfiguration.MinimumNumberOfTheSameWord > aConfiguration.MaximumNumberOfTheSameWord)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "MINIMUM_NUMBER_OF_THE_SAME_WORD",
aConfiguration.MinimumNumberOfTheSameWord, aConfiguration.MaximumNumberOfTheSameWord));
}
}
if (ActualKeys.Contains("MINIMUM_NUMBER_OF_GROUPS") && ActualKeys.Contains("MAXIMUM_NUMBER_OF_GROUPS"))
{
if (aConfiguration.MinimumNumberOfGroups > aConfiguration.MaximumNumberOfGroups)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "MINIMUM_NUMBER_OF_GROUPS",
aConfiguration.MinimumNumberOfGroups, aConfiguration.MaximumNumberOfGroups));
}
}
}
// Store validity.
aConfiguration.Valid = Errors.Count == 0;
return(aConfiguration.Valid);
}
public static Boolean TryParse(String configurationFileItem, out ConfigurationFileItem aConfigurationFileItem)
{
Errors = new List <String>();
configurationFileItem = configurationFileItem.Trim();
aConfigurationFileItem = new ConfigurationFileItem(configurationFileItem);
// Discard comment.
if (configurationFileItem.Contains("//"))
{
int index = configurationFileItem.IndexOf("//");
configurationFileItem = configurationFileItem.Remove(index);
configurationFileItem = configurationFileItem.Trim();
}
if (Regex.IsMatch(configurationFileItem, @"^\s*$"))
{
// Check for only 0 or more white spaces.
aConfigurationFileItem.Name = NoConfigItem;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + LogfileName + @".*"))
{
// Get the LogFile key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, LogfileName, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = LogfileName;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumNumberOfUniqueWords + @".*"))
{
// Get the MinimumNumberOfUniqueWords key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumNumberOfUniqueWords, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumNumberOfUniqueWords;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumNumberOfUniqueWords + @".*"))
{
// Get the MaximumNumberOfUniqueWords key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumNumberOfUniqueWords, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumNumberOfUniqueWords;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + InvalidCrozzleScore + @".*"))
{
// Get the CrozzleInvalidScoreValue key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, InvalidCrozzleScore, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = InvalidCrozzleScore;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + Uppercase + @".*"))
{
// Get the CrozzleUppercase key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, Uppercase, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = Uppercase;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + Style + @".*"))
{
// Get the CrozzleHtmlStyle key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, Style, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = Style;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + BGcolourEmptyTD + @".*"))
{
// Get the CrozzleHtmlTdBgcolourSpace key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, BGcolourEmptyTD, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = BGcolourEmptyTD;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + BGcolourNonEmptyTD + @".*"))
{
// Get the CrozzleHtmlTdBgcolourNoSpace key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, BGcolourNonEmptyTD, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = BGcolourNonEmptyTD;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumNumberOfRows + @".*"))
{
// Get the MinimumNumberOfRows key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumNumberOfRows, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumNumberOfRows;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumNumberOfRows + @".*"))
{
// Get the MaximumNumberOfRows key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumNumberOfRows, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumNumberOfRows;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumNumberOfColumns + @".*"))
{
// Get the MinimumNumberOfColumns key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumNumberOfColumns, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumNumberOfColumns;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumNumberOfColumns + @".*"))
{
// Get the MaximumNumberOfColumns key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumNumberOfColumns, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumNumberOfColumns;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumHorizontalWords + @".*"))
{
// Get the MinimumHorizontalWords key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumHorizontalWords, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumHorizontalWords;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumVerticalWords + @".*"))
{
// Get the MinimumVerticalWords key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumVerticalWords, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumVerticalWords;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumHorizontalWords + @".*"))
{
// Get the MaximumHorizontalWords key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumHorizontalWords, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumHorizontalWords;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumVerticalWords + @".*"))
{
// Get the MaximumVerticalWords key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumVerticalWords, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumVerticalWords;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumIntersectionsInHorizontalWord + @".*"))
{
// Get the MinimumIntersectionsInHorizontalWord key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumIntersectionsInHorizontalWord, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumIntersectionsInHorizontalWord;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumIntersectionsInHorizontalWord + @".*"))
{
// Get the MaximumIntersectionsInHorizontalWord key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumIntersectionsInHorizontalWord, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumIntersectionsInHorizontalWord;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumIntersectionsInVerticalWord + @".*"))
{
// Get the MinimumIntersectionsInVerticalWord key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumIntersectionsInVerticalWord, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumIntersectionsInVerticalWord;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumIntersectionsInVerticalWord + @".*"))
{
// Get the MaximumIntersectionsInVerticalWord key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumIntersectionsInVerticalWord, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumIntersectionsInVerticalWord;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumNumberOfTheSameWord + @".*"))
{
// Get the MinimumNumberOfTheSameWord key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumNumberOfTheSameWord, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumNumberOfTheSameWord;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumNumberOfTheSameWord + @".*"))
{
// Get the MaximumNumberOfTheSameWord key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumNumberOfTheSameWord, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumNumberOfTheSameWord;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumNumberOfGroups + @".*"))
{
// Get the MinimumNumberOfGroups key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumNumberOfGroups, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumNumberOfGroups;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumNumberOfGroups + @".*"))
{
// Get the MaximumNumberOfGroups key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumNumberOfGroups, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumNumberOfGroups;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + PointsPerWord + @".*"))
{
// Get the PointsPerWord key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, PointsPerWord, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = PointsPerWord;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + IntersectingPointsPerLetter + @".*"))
{
// Get the key-value pair for the intersecting points.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, IntersectingPointsPerLetter, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = IntersectingPointsPerLetter;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + NonIntersectingPointsPerLetter + @".*"))
{
// Get the key-value pair for the non-intersecting points.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, NonIntersectingPointsPerLetter, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = NonIntersectingPointsPerLetter;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else
{
Errors.Add(String.Format(ConfigurationFileItemErrors.SymbolError, configurationFileItem));
}
aConfigurationFileItem.Valid = Errors.Count == 0;
return(aConfigurationFileItem.Valid);
}
public static Boolean TryParse(String path, out Configuration aConfiguration)
{
Errors = new List <String>();
ActualIntersectingKeys = new Boolean[26];
ActualNonIntersectingKeys = new Boolean[26];
ActualKeys = new List <string>();
aConfiguration = new Configuration(path);
if (aConfiguration.ConfigurationFileName.IndexOfAny(Path.GetInvalidFileNameChars()) > -1)
{
Errors.Add(String.Format(ConfigurationErrors.FilenameError, path));
}
else
{
StreamReader fileIn = new StreamReader(path);
// Validate file.
while (!fileIn.EndOfStream)
{
List <String> fragment = new List <String>();
do
{
/// Add multiple lines as part of a text fragment until the last element is empty or null.
fragment.Add(fileIn.ReadLine());
} while (!String.IsNullOrEmpty(fragment.Last()));
// Parse a configuration fragment.
FileFragment <ConfigurationFileItem> aConfigurationFileFragment;
if (ConfigurationFileItem.TryParse(fragment, out aConfigurationFileFragment))
{
List <ConfigurationFileItem> aItemsWithErrors;
if ((aItemsWithErrors = aConfigurationFileFragment.Items.Where(item => item.KeyValue != null && ActualKeys.Contains(item.KeyValue.Key)).ToList()).Any())
{
foreach (ConfigurationFileItem error in aItemsWithErrors)
{
Errors.Add(String.Format(ConfigurationErrors.DuplicateKeyError, error.KeyValue.OriginalKeyValue));
}
}
else
{
/// TODO: Process key record and key-value validation.
String aFragmentKey = aConfigurationFileFragment.Name;
foreach (ConfigurationFileItem aItem in aConfigurationFileFragment.Items)
{
/// Record that this key has been found.
if (aItem.KeyValue.Key != null)
{
/// Identified fragments contain keys that have the same string. To minimise duplicate key error, lead the key with the fragment's name.
if (new string[] { ConfigurationKeys.UNIQUESEQ_OPENBRACKET, ConfigurationKeys.DUPE_OPENBRACKET,
ConfigurationKeys.VALIDGROUP_OPENBRACKET, ConfigurationKeys.DIRECTIONALSEQ_OPENBRACKET,
ConfigurationKeys.DIRECTIONALINTERSECT_OPENBRACKET }.Contains(aFragmentKey))
{
ActualKeys.Add(aFragmentKey + "-" + aItem.KeyValue.Key);
}
else if (!(new string[] { ConfigurationKeys.INTERSECT_OPENBRACKET, ConfigurationKeys.NONINTERSECT_OPENBRACKET }.Contains(aFragmentKey)))
{
ActualKeys.Add(aItem.KeyValue.Key);
}
}
/// Process the key-value, given the current fragment key.
if (aFragmentKey.Equals(ConfigurationKeys.LOGFILE_OPENBRACKET))
{
if (aItem.Name == ConfigurationKeys.LOGFILE_FILENAME)
{
aConfiguration.LogFileName = aItem.KeyValue.Value.Trim();
if (Validator.IsDelimited(aConfiguration.LogFileName, Crozzle.StringDelimiters))
{
String value = aConfiguration.LogFileName.Trim(Crozzle.StringDelimiters);
aConfiguration.LogFileName = (!String.IsNullOrEmpty(value)) ? value : DefaultLogFileName;
if (!Validator.IsFilename(aConfiguration.LogFileName))
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
}
else if (aFragmentKey.Equals(ConfigurationKeys.UNIQUESEQ_OPENBRACKET))
{
if (aItem.Name == ConfigurationKeys.UNIQUESEQ_MINIMUM)
{
int minimum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumNumberOfUniqueWords = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aItem.Name == ConfigurationKeys.UNIQUESEQ_MAXIMUM)
{
int maximum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumNumberOfUniqueWords = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
}
else if (aFragmentKey.Equals(ConfigurationKeys.OUTPUT_OPENBRACKET))
{
if (aItem.Name == ConfigurationKeys.OUTPUT_INVALID)
{
aConfiguration.InvalidCrozzleScore = aItem.KeyValue.Value.Trim();
if (Validator.IsDelimited(aConfiguration.InvalidCrozzleScore, Crozzle.StringDelimiters))
{
aConfiguration.InvalidCrozzleScore = aConfiguration.InvalidCrozzleScore.Trim(Crozzle.StringDelimiters);
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aItem.Name == ConfigurationKeys.OUTPUT_UPPERCASE)
{
Boolean uppercase = true;
if (!Validator.IsMatch(aItem.KeyValue.Value, allowedBooleans))
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
aConfiguration.Uppercase = uppercase;
}
else if (aItem.Name == ConfigurationKeys.OUTPUT_STYLE)
{
aConfiguration.Style = aItem.KeyValue.Value.Trim();
if (Validator.IsDelimited(aConfiguration.Style, Crozzle.StringDelimiters))
{
aConfiguration.Style = aConfiguration.Style.Trim(Crozzle.StringDelimiters);
if (!Validator.IsStyleTag(aConfiguration.Style))
{
Errors.Add(String.Format(ConfigurationErrors.StyleError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aItem.Name == ConfigurationKeys.OUTPUT_BGCOLOUR_EMPTY)
{
aConfiguration.BGcolourEmptyTD = aItem.KeyValue.Value.Trim();
if (!Validator.IsHexColourCode(aConfiguration.BGcolourEmptyTD))
{
Errors.Add(String.Format(ConfigurationErrors.ColourError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aItem.Name == ConfigurationKeys.OUTPUT_BGCOLOUR_NONEMPTY)
{
aConfiguration.BGcolourNonEmptyTD = aItem.KeyValue.Value.Trim();
if (!Validator.IsHexColourCode(aConfiguration.BGcolourNonEmptyTD))
{
Errors.Add(String.Format(ConfigurationErrors.ColourError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
}
else if (aFragmentKey.Equals(ConfigurationKeys.SIZE_OPENBRACKET))
{
if (aItem.Name == ConfigurationKeys.SIZE_MINIMUMROWS)
{
int minimum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumNumberOfRows = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aItem.Name == ConfigurationKeys.SIZE_MAXIMUMROWS)
{
int maximum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumNumberOfRows = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aItem.Name == ConfigurationKeys.SIZE_MINIMUMCOLUMNS)
{
int minimum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumNumberOfColumns = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aItem.Name == ConfigurationKeys.SIZE_MAXIMUMCOLUMNS)
{
int maximum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumNumberOfColumns = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
}
else if (aFragmentKey.Equals(ConfigurationKeys.DIRECTIONALSEQ_OPENBRACKET))
{
if (aItem.Name == ConfigurationKeys.DIRECTIONALSEQ_MINIMUMHORZ)
{
int minimum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumHorizontalWords = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aItem.Name == ConfigurationKeys.DIRECTIONALSEQ_MAXIMUMHORZ)
{
int maximum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumHorizontalWords = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aItem.Name == ConfigurationKeys.DIRECTIONALSEQ_MINIMUMVERT)
{
int minimum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumVerticalWords = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aItem.Name == ConfigurationKeys.DIRECTIONALSEQ_MAXIMUMVERT)
{
int maximum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumVerticalWords = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
}
else if (aFragmentKey.Equals(ConfigurationKeys.DIRECTIONALINTERSECT_OPENBRACKET))
{
if (aItem.Name == ConfigurationKeys.DIRECTIONALINTERSECT_MINIMUMHORZ)
{
int minimum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumIntersectionsInHorizontalWords = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aItem.Name == ConfigurationKeys.DIRECTIONALINTERSECT_MAXIMUMHORZ)
{
int maximum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumIntersectionsInHorizontalWords = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aItem.Name == ConfigurationKeys.DIRECTIONALINTERSECT_MINIMUMVERT)
{
int minimum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumIntersectionsInVerticalWords = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aItem.Name == ConfigurationKeys.DIRECTIONALINTERSECT_MAXIMUMVERT)
{
int maximum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumIntersectionsInVerticalWords = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
}
else if (aFragmentKey.Equals(ConfigurationKeys.DUPE_OPENBRACKET))
{
if (aItem.Name == ConfigurationKeys.DUPE_MINIMUMVALID)
{
int minimum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumNumberOfTheSameWord = minimum;
if (!Validator.TryRange(minimum, 0, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aItem.Name == ConfigurationKeys.DUPE_MAXIMUMVALID)
{
int maximum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumNumberOfTheSameWord = maximum;
if (!Validator.TryRange(maximum, 0, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
}
else if (aFragmentKey.Equals(ConfigurationKeys.VALIDGROUP_OPENBRACKET))
{
if (aItem.Name == ConfigurationKeys.VALIDGROUP_MINIMUM)
{
int minimum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out minimum))
{
aConfiguration.MinimumNumberOfGroups = minimum;
if (!Validator.TryRange(minimum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aItem.Name == ConfigurationKeys.VALIDGROUP_MAXIMUM)
{
int maximum;
if (Validator.IsInt32(aItem.KeyValue.Value.Trim(), out maximum))
{
aConfiguration.MaximumNumberOfGroups = maximum;
if (!Validator.TryRange(maximum, 1, Int32.MaxValue))
{
Errors.Add(String.Format(ConfigurationErrors.IntegerError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
}
else if (aFragmentKey.Equals(ConfigurationKeys.INTERSECT_OPENBRACKET))
{
if (aItem.Name.Length == 1) /// ConfigurationFileItem.cs defines the key as the letter used in the CFG
{
String originalValues = aItem.KeyValue.Value.Trim();
int points;
if (Validator.IsInt32(aItem.KeyValue.Value, out points))
{
int index = (int)aItem.KeyValue.Key[0] - (int)'A';
aConfiguration.IntersectingPointsPerLetter[index] = points;
ActualIntersectingKeys[index] = true;
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else if (aFragmentKey.Equals(ConfigurationKeys.NONINTERSECT_OPENBRACKET))
{
if (aItem.Name.Length == 1) /// ConfigurationFileItem.cs defines the key as the letter used in the CFG
{
String originalValues = aItem.KeyValue.Value.Trim();
int points;
if (Validator.IsInt32(aItem.KeyValue.Value, out points))
{
int index = (int)aItem.KeyValue.Key[0] - (int)'A';
aConfiguration.NonIntersectingPointsPerLetter[index] = points;
ActualNonIntersectingKeys[index] = true;
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.Add(String.Format(ConfigurationErrors.ValueError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0]));
}
}
else
{
Errors.AddRange(ConfigurationFileItem.Errors);
}
}
}
}
}
// Close files.
fileIn.Close();
// Check which keys are missing from the configuration file.
foreach (string expectedKey in ExpectedKeys)
{
if (!ActualKeys.Contains(expectedKey))
{
Errors.Add(String.Format(ConfigurationErrors.MissingKeyError, expectedKey));
}
}
for (char ch = 'A'; ch <= 'Z'; ch++)
{
if (!ActualIntersectingKeys[(int)ch - (int)'A'])
{
Errors.Add(String.Format(ConfigurationErrors.MissingIntersectionKeyError, ch.ToString()));
}
}
for (char ch = 'A'; ch <= 'Z'; ch++)
{
if (!ActualNonIntersectingKeys[(int)ch - (int)'A'])
{
Errors.Add(String.Format(ConfigurationErrors.MissingNonIntersectionKeyError, ch.ToString()));
}
}
// Check that minimum values are <= to their maximmum counterpart values.
if (ActualKeys.Contains("SEQUENCES-IN-FILE-MINIMUM") && ActualKeys.Contains("SEQUENCES-IN-FILE-MAXIMUM"))
{
if (aConfiguration.MinimumNumberOfUniqueWords > aConfiguration.MaximumNumberOfUniqueWords)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "SEQUENCES-IN-FILE-MINIMUM",
aConfiguration.MinimumNumberOfUniqueWords, aConfiguration.MaximumNumberOfUniqueWords));
}
}
if (ActualKeys.Contains("MINIMUM-ROWS") && ActualKeys.Contains("MAXIMUM-ROWS"))
{
if (aConfiguration.MinimumNumberOfRows > aConfiguration.MaximumNumberOfRows)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "MINIMUM-ROWS",
aConfiguration.MinimumNumberOfRows, aConfiguration.MaximumNumberOfRows));
}
}
if (ActualKeys.Contains("MINIMUM-COLUMNS") && ActualKeys.Contains("MAXIMUM-COLUMNS"))
{
if (aConfiguration.MinimumNumberOfColumns > aConfiguration.MaximumNumberOfColumns)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "MINIMUM-COLUMNS",
aConfiguration.MinimumNumberOfColumns, aConfiguration.MaximumNumberOfColumns));
}
}
if (ActualKeys.Contains("SEQUENCES-IN-CROZZLE-MINIMUM-HORIZONTAL") && ActualKeys.Contains("SEQUENCES-IN-CROZZLE-MAXIMUM-HORIZONTAL"))
{
if (aConfiguration.MinimumHorizontalWords > aConfiguration.MaximumHorizontalWords)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "SEQUENCES-IN-CROZZLE-MINIMUM-HORIZONTAL",
aConfiguration.MinimumHorizontalWords, aConfiguration.MaximumHorizontalWords));
}
}
if (ActualKeys.Contains("SEQUENCES-IN-CROZZLE-MINIMUM-VERTICAL") && ActualKeys.Contains("SEQUENCES-IN-CROZZLE-MAXIMUM-VERTICAL"))
{
if (aConfiguration.MinimumVerticalWords > aConfiguration.MaximumVerticalWords)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "SEQUENCES-IN-CROZZLE-MINIMUM-VERTICAL",
aConfiguration.MinimumVerticalWords, aConfiguration.MaximumVerticalWords));
}
}
if (ActualKeys.Contains("INTERSECTIONS-IN-SEQUENCES-MINIMUM-HORIZONTAL") && ActualKeys.Contains("INTERSECTIONS-IN-SEQUENCES-MINIMUM-HORIZONTAL"))
{
if (aConfiguration.MinimumIntersectionsInHorizontalWords > aConfiguration.MaximumIntersectionsInHorizontalWords)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "INTERSECTIONS-IN-SEQUENCES-MINIMUM-VERTICAL",
aConfiguration.MinimumIntersectionsInHorizontalWords, aConfiguration.MaximumIntersectionsInHorizontalWords));
}
}
if (ActualKeys.Contains("INTERSECTIONS-IN-SEQUENCES-MINIMUM-VERTICAL") && ActualKeys.Contains("INTERSECTIONS-IN-SEQUENCES-MINIMUM-VERTICAL"))
{
if (aConfiguration.MinimumIntersectionsInVerticalWords > aConfiguration.MaximumIntersectionsInVerticalWords)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "INTERSECTIONS-IN-SEQUENCES-MINIMUM-VERTICAL",
aConfiguration.MinimumIntersectionsInVerticalWords, aConfiguration.MaximumIntersectionsInVerticalWords));
}
}
if (ActualKeys.Contains("DUPLICATE-SEQUENCES-MINIMUM") && ActualKeys.Contains("DUPLICATE-SEQUENCES-MAXIMUM"))
{
if (aConfiguration.MaximumNumberOfTheSameWord < aConfiguration.MinimumNumberOfTheSameWord)
{
Errors.Add(String.Format(ConfigurationErrors.MaxDupeLowerThanMinError, "DUPLICATE-SEQUENCES-MAXIMUM",
aConfiguration.MaximumNumberOfTheSameWord, aConfiguration.MaximumNumberOfTheSameWord));
}
}
if (ActualKeys.Contains("VALID-GROUPS-MINIMUM") && ActualKeys.Contains("VALID-GROUPS-MAXIMUM"))
{
if (aConfiguration.MinimumNumberOfGroups > aConfiguration.MaximumNumberOfGroups)
{
Errors.Add(String.Format(ConfigurationErrors.MinGreaterThanMaxError, "VALID-GROUPS-MINIMUM",
aConfiguration.MinimumNumberOfGroups, aConfiguration.MaximumNumberOfGroups));
}
}
}
// Store validity.
aConfiguration.Valid = Errors.Count == 0;
return(aConfiguration.Valid);
}
public static Boolean TryParse(String configurationFileItem, out ConfigurationFileItem aConfigurationFileItem)
{
Errors = new List <String>();
configurationFileItem = configurationFileItem.Trim();
aConfigurationFileItem = new ConfigurationFileItem(configurationFileItem);
// Discard comment.
if (configurationFileItem.Contains("//"))
{
int index = configurationFileItem.IndexOf("//");
configurationFileItem = configurationFileItem.Remove(index);
configurationFileItem = configurationFileItem.Trim();
}
// New UPDATE
// add name for unrecognized line
if (Regex.IsMatch(configurationFileItem, @"^\s*$"))
{
// Check for only 0 or more white spaces.
aConfigurationFileItem.Name = NoConfigItem;
}
// New UPDATE
// add name for unrecognized line
else if (configurationFileItem.Contains(LogfileStart))
{
aConfigurationFileItem.Name = LogfileStart;
}
// New UPDATE
// add name for unrecognized line
else if (configurationFileItem.Contains(CrozzleOutputStart))
{
aConfigurationFileItem.Name = CrozzleOutputStart;
}
// New UPDATE
// add name for unrecognized line
// and deleted
else if (configurationFileItem.Contains("-END-"))
{
BufferClass.Identifier = "";
int index = configurationFileItem.IndexOf("-END-");
configurationFileItem = configurationFileItem.Remove(index);
configurationFileItem = configurationFileItem.Trim();
aConfigurationFileItem.Name = "END";
}
// New UPDATE
// Put data to buffer
else if (Regex.IsMatch(configurationFileItem, @"^" + SequenceStartFile + "$"))
{
BufferClass.Identifier = SequenceStartFile;
aConfigurationFileItem.Name = SequenceStartFile;
}
// New UPDATE
// Put data to buffer
else if (Regex.IsMatch(configurationFileItem, @"^" + CrozzleSizeStart + "$"))
{
BufferClass.Identifier = CrozzleSizeStart;
aConfigurationFileItem.Name = CrozzleSizeStart;
}
// New UPDATE
// Put data to buffer
else if (Regex.IsMatch(configurationFileItem, @"^" + SequencesStartCrozzle + "$"))
{
BufferClass.Identifier = SequencesStartCrozzle;
aConfigurationFileItem.Name = SequencesStartCrozzle;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + IntersectionsStart + "$"))
{
BufferClass.Identifier = IntersectionsStart;
aConfigurationFileItem.Name = IntersectionsStart;
}
// New UPDATE
// Put data to buffer
else if (Regex.IsMatch(configurationFileItem, @"^" + DuplicateSequencesStart + "$"))
{
BufferClass.Identifier = DuplicateSequencesStart;
aConfigurationFileItem.Name = DuplicateSequencesStart;
}
// New UPDATE
// Put data to buffer
else if (Regex.IsMatch(configurationFileItem, @"^" + ValidGroupsStart + "$"))
{
BufferClass.Identifier = ValidGroupsStart;
aConfigurationFileItem.Name = ValidGroupsStart;
}
// New UPDATE
// Put data to buffer
else if (Regex.IsMatch(configurationFileItem, @"^" + IntersectingPointsPerLetter + "$"))
{
BufferClass.Identifier = IntersectingPointsPerLetter;
aConfigurationFileItem.Name = IntersectingPointsPerLetter;
}
// New UPDATE
// Put data to buffer
else if (Regex.IsMatch(configurationFileItem, @"^" + NonIntersectingPointsPerLetter + "$"))
{
BufferClass.Identifier = NonIntersectingPointsPerLetter;
aConfigurationFileItem.Name = NonIntersectingPointsPerLetter;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + LogfileName + @".*"))
{
// Get the LogFile key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, LogfileName, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = LogfileName;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumNumberOfUniqueWords + @".*"))
{
// Get the MinimumNumberOfUniqueWords key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumNumberOfUniqueWords, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumNumberOfUniqueWords;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumNumberOfUniqueWords + @".*"))
{
// Get the MaximumNumberOfUniqueWords key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumNumberOfUniqueWords, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumNumberOfUniqueWords;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + InvalidCrozzleScore + @".*"))
{
// Get the CrozzleInvalidScoreValue key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, InvalidCrozzleScore, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = InvalidCrozzleScore;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + Uppercase + @".*"))
{
// Get the CrozzleUppercase key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, Uppercase, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = Uppercase;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + Style + @".*"))
{
// Get the CrozzleHtmlStyle key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, Style, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = Style;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + BGcolourEmptyTD + @".*"))
{
// Get the CrozzleHtmlTdBgcolourSpace key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, BGcolourEmptyTD, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = BGcolourEmptyTD;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + BGcolourNonEmptyTD + @".*"))
{
// Get the CrozzleHtmlTdBgcolourNoSpace key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, BGcolourNonEmptyTD, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = BGcolourNonEmptyTD;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumNumberOfRows + @".*"))
{
// Get the MinimumNumberOfRows key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumNumberOfRows, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumNumberOfRows;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumNumberOfRows + @".*"))
{
// Get the MaximumNumberOfRows key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumNumberOfRows, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumNumberOfRows;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumNumberOfColumns + @".*"))
{
// Get the MinimumNumberOfColumns key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumNumberOfColumns, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumNumberOfColumns;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumNumberOfColumns + @".*"))
{
// Get the MaximumNumberOfColumns key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumNumberOfColumns, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumNumberOfColumns;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumHorizontalWords + @".*"))
{
// Get the MinimumHorizontalWords key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumHorizontalWords, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumHorizontalWords;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumVerticalWords + @".*"))
{
// Get the MinimumVerticalWords key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumVerticalWords, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumVerticalWords;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumHorizontalWords + @".*"))
{
// Get the MaximumHorizontalWords key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumHorizontalWords, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumHorizontalWords;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumVerticalWords + @".*"))
{
// Get the MaximumVerticalWords key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumVerticalWords, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumVerticalWords;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumIntersectionsInHorizontalWord + @".*"))
{
// Get the MinimumIntersectionsInHorizontalWord key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumIntersectionsInHorizontalWord, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumIntersectionsInHorizontalWord;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumIntersectionsInHorizontalWord + @".*"))
{
// Get the MaximumIntersectionsInHorizontalWord key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumIntersectionsInHorizontalWord, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumIntersectionsInHorizontalWord;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumIntersectionsInVerticalWord + @".*"))
{
// Get the MinimumIntersectionsInVerticalWord key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumIntersectionsInVerticalWord, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumIntersectionsInVerticalWord;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumIntersectionsInVerticalWord + @".*"))
{
// Get the MaximumIntersectionsInVerticalWord key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumIntersectionsInVerticalWord, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumIntersectionsInVerticalWord;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumNumberOfTheSameWord + @".*"))
{
// Get the MinimumNumberOfTheSameWord key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumNumberOfTheSameWord, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumNumberOfTheSameWord;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumNumberOfTheSameWord + @".*"))
{
// Get the MaximumNumberOfTheSameWord key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumNumberOfTheSameWord, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumNumberOfTheSameWord;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MinimumNumberOfGroups + @".*"))
{
// Get the MinimumNumberOfGroups key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MinimumNumberOfGroups, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MinimumNumberOfGroups;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + MaximumNumberOfGroups + @".*"))
{
// Get the MaximumNumberOfGroups key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, MaximumNumberOfGroups, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = MaximumNumberOfGroups;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + IntersectingPointsPerLetter + @"-[A-Z].*$"))
{
// Get the key-value pair for the intersecting points.
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, @"[A-Z]", out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
String[] pointAZ = configurationFileItem.Split('=');
aConfigurationFileItem.Name = pointAZ[0];
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(configurationFileItem, @"^" + NonIntersectingPointsPerLetter + @"-[A-Z].*$"))
{
// Get the key-value pair for the non-intersecting points.
// Updated
KeyValue aKeyValue;
if (!KeyValue.TryParse(configurationFileItem, @"[A-Z]", out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
String[] pointAZ = configurationFileItem.Split('=');
aConfigurationFileItem.Name = pointAZ[0];
aConfigurationFileItem.KeyValue = aKeyValue;
}
else
{
Errors.Add(String.Format(ConfigurationFileItemErrors.SymbolError, configurationFileItem));
}
aConfigurationFileItem.Valid = Errors.Count == 0;
return(aConfigurationFileItem.Valid);
}
public static Boolean TryParse(List <String> configurationFileFragment, out FileFragment <ConfigurationFileItem> aConfigurationFileFragment)
{
Errors = new List <String>();
configurationFileFragment.RemoveAll(s => String.IsNullOrEmpty(s));
aConfigurationFileFragment = new FileFragment <ConfigurationFileItem>();
String formattedLine = String.Empty;
DataKeys flag = DataKeys.UNDEFINED;
foreach (String line in configurationFileFragment)
{
/// Discard comment and trim possible whitespace.
if (line.Contains("//"))
{
int index = line.IndexOf("//");
formattedLine = line.Remove(index);
}
else
{
formattedLine = line;
}
formattedLine = formattedLine.Trim();
ConfigurationFileItem aConfigurationFileItem = new ConfigurationFileItem(formattedLine);
if (Regex.IsMatch(formattedLine, @"^\s*$"))
{
continue;
}
else if (Regex.IsMatch(formattedLine, ForeignCharacters))
{
Errors.Add(String.Format(ConfigurationFileItemErrors.SymbolError, aConfigurationFileItem)); /// Checks if the line contains foreign characters
}
else
{
switch (flag)
{
case DataKeys.UNDEFINED:
/// fragment specification.
if (Regex.IsMatch(formattedLine, @"^" + LogFileKeys.OpenBracket + @".*"))
{
flag = DataKeys.LOGFILE;
aConfigurationFileFragment.Name = LogFileKeys.OpenBracket;
}
else if (Regex.IsMatch(formattedLine, @"^" + UniqueSequenceKeys.OpenBracket + @".*"))
{
flag = DataKeys.SEQUENCES;
aConfigurationFileFragment.Name = UniqueSequenceKeys.OpenBracket;
}
else if (Regex.IsMatch(formattedLine, @"^" + CrozzleOutputKeys.OpenBracket + @".*"))
{
flag = DataKeys.OUTPUT;
aConfigurationFileFragment.Name = CrozzleOutputKeys.OpenBracket;
}
else if (Regex.IsMatch(formattedLine, @"^" + CrozzleSizeKeys.OpenBracket + @".*"))
{
flag = DataKeys.SIZE;
aConfigurationFileFragment.Name = CrozzleSizeKeys.OpenBracket;
}
else if (Regex.IsMatch(formattedLine, @"^" + DirectionalSequenceKeys.OpenBracket + @".*"))
{
flag = DataKeys.LIMITSEQUENCE;
aConfigurationFileFragment.Name = DirectionalSequenceKeys.OpenBracket;
}
else if (Regex.IsMatch(formattedLine, @"^" + DirectionalIntersectionKeys.OpenBracket + @".*"))
{
flag = DataKeys.LIMITINTERSECT;
aConfigurationFileFragment.Name = DirectionalIntersectionKeys.OpenBracket;
}
else if (Regex.IsMatch(formattedLine, @"^" + DuplicateSequenceKeys.OpenBracket + @".*"))
{
flag = DataKeys.DUPLICATE;
aConfigurationFileFragment.Name = DuplicateSequenceKeys.OpenBracket;
}
else if (Regex.IsMatch(formattedLine, @"^" + ValidGroupKeys.OpenBracket + @".*"))
{
flag = DataKeys.VALIDGROUP;
aConfigurationFileFragment.Name = ValidGroupKeys.OpenBracket;
}
else if (Regex.IsMatch(formattedLine, @"^" + IntersectionKeys.OpenBracket + @".*"))
{
flag = DataKeys.INTERSECT;
aConfigurationFileFragment.Name = IntersectionKeys.OpenBracket;
}
else if (Regex.IsMatch(formattedLine, @"^" + NonIntersectionKeys.OpenBracket + @".*"))
{
flag = DataKeys.NONINTERSECT;
aConfigurationFileFragment.Name = NonIntersectionKeys.OpenBracket;
}
break;
case DataKeys.LOGFILE:
if (Regex.IsMatch(formattedLine, @"^" + LogFileKeys.FileName + @".*"))
{
/// get the LogFile key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, LogFileKeys.FileName, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = LogFileKeys.FileName;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + LogFileKeys.EndBracket + @".*"))
{
flag = DataKeys.UNDEFINED;
}
break;
case DataKeys.SEQUENCES:
if (Regex.IsMatch(formattedLine, @"^" + UniqueSequenceKeys.MinUnique + @".*"))
{
/// get the MinimumUniqueLetterSequences key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, UniqueSequenceKeys.MinUnique, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = UniqueSequenceKeys.MinUnique;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + UniqueSequenceKeys.MaxUnique + @".*"))
{
/// get the MaximumUniqueLetterSequences key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, UniqueSequenceKeys.MaxUnique, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = UniqueSequenceKeys.MaxUnique;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + UniqueSequenceKeys.EndBracket + @".*"))
{
flag = DataKeys.UNDEFINED;
}
break;
case DataKeys.OUTPUT:
if (Regex.IsMatch(formattedLine, @"^" + CrozzleOutputKeys.InvalidScore + @".*"))
{
/// get the InvalidCrozzleScore key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, CrozzleOutputKeys.InvalidScore, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = CrozzleOutputKeys.InvalidScore;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + CrozzleOutputKeys.Uppercase + @".*"))
{
/// get the Uppercase key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, CrozzleOutputKeys.Uppercase, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = CrozzleOutputKeys.Uppercase;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + CrozzleOutputKeys.Style + @".*"))
{
/// get the Style key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, CrozzleOutputKeys.Style, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = CrozzleOutputKeys.Style;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + CrozzleOutputKeys.BGColourEmptyTD + @".*"))
{
/// get the BGColourEmptyTD key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, CrozzleOutputKeys.BGColourEmptyTD, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = CrozzleOutputKeys.BGColourEmptyTD;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + CrozzleOutputKeys.BGColourNonEmptyTD + @".*"))
{
/// get the BGColourNonEmptyTD key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, CrozzleOutputKeys.BGColourNonEmptyTD, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = CrozzleOutputKeys.BGColourNonEmptyTD;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + CrozzleOutputKeys.EndBracket + @".*"))
{
flag = DataKeys.UNDEFINED;
}
break;
case DataKeys.SIZE:
if (Regex.IsMatch(formattedLine, @"^" + CrozzleSizeKeys.MinRows + @".*"))
{
/// get the MinimumCrozzleSizeRows key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, CrozzleSizeKeys.MinRows, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = CrozzleSizeKeys.MinRows;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + CrozzleSizeKeys.MaxRows + @".*"))
{
/// get the MaximumCrozzleSizeRows key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, CrozzleSizeKeys.MaxRows, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = CrozzleSizeKeys.MaxRows;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + CrozzleSizeKeys.MinCols + @".*"))
{
/// get the MinimumCrozzleSizeColumns key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, CrozzleSizeKeys.MinCols, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = CrozzleSizeKeys.MinCols;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + CrozzleSizeKeys.MaxCols + @".*"))
{
/// get the MaximumCrozzleSizeColumns key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, CrozzleSizeKeys.MaxCols, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = CrozzleSizeKeys.MaxCols;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + CrozzleSizeKeys.EndBracket + @".*"))
{
flag = DataKeys.UNDEFINED;
}
break;
case DataKeys.LIMITSEQUENCE:
if (Regex.IsMatch(formattedLine, @"^" + DirectionalSequenceKeys.MinHorz + @".*"))
{
/// get the MinimumHorizontalSequences key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, DirectionalSequenceKeys.MinHorz, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = DirectionalSequenceKeys.MinHorz;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + DirectionalSequenceKeys.MaxHorz + @".*"))
{
/// get the MaximumHorizontalSequences key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, DirectionalSequenceKeys.MaxHorz, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = DirectionalSequenceKeys.MaxHorz;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + DirectionalSequenceKeys.MinVert + @".*"))
{
/// get the MinimumVerticalSequences key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, DirectionalSequenceKeys.MinVert, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = DirectionalSequenceKeys.MinVert;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + DirectionalSequenceKeys.MaxVert + @".*"))
{
/// get the MaximumVerticalSequences key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, DirectionalSequenceKeys.MaxVert, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = DirectionalSequenceKeys.MaxVert;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + DirectionalSequenceKeys.EndBracket + @".*"))
{
flag = DataKeys.UNDEFINED;
}
break;
case DataKeys.LIMITINTERSECT:
if (Regex.IsMatch(formattedLine, @"^" + DirectionalIntersectionKeys.MinHorz + @".*"))
{
/// get the MinimumHorizontalIntersections key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, DirectionalIntersectionKeys.MinHorz, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = DirectionalIntersectionKeys.MinHorz;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + DirectionalIntersectionKeys.MaxHorz + @".*"))
{
/// get the MaximumHorizontalIntersections key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, DirectionalIntersectionKeys.MaxHorz, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = DirectionalIntersectionKeys.MaxHorz;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + DirectionalIntersectionKeys.MinVert + @".*"))
{
/// get the MinimumVerticalIntersections key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, DirectionalIntersectionKeys.MinVert, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = DirectionalIntersectionKeys.MinVert;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + DirectionalIntersectionKeys.MaxVert + @".*"))
{
/// get the MaximumVerticalIntersections key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, DirectionalIntersectionKeys.MaxVert, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = DirectionalIntersectionKeys.MaxVert;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + DirectionalIntersectionKeys.EndBracket + @".*"))
{
flag = DataKeys.UNDEFINED;
}
break;
case DataKeys.DUPLICATE:
if (Regex.IsMatch(formattedLine, @"^" + DuplicateSequenceKeys.MinDupe + @".*"))
{
/// get the MinimumDuplicateSequences key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, DuplicateSequenceKeys.MinDupe, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = DuplicateSequenceKeys.MinDupe;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + DuplicateSequenceKeys.MaxDupe + @".*"))
{
/// get the MaximumDuplicateSequences key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, DuplicateSequenceKeys.MaxDupe, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = DuplicateSequenceKeys.MaxDupe;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + DuplicateSequenceKeys.EndBracket + @".*"))
{
flag = DataKeys.UNDEFINED;
}
break;
case DataKeys.VALIDGROUP:
if (Regex.IsMatch(formattedLine, @"^" + ValidGroupKeys.MinValidGroup + @".*"))
{
/// get the MinimumValidGroups key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, ValidGroupKeys.MinValidGroup, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ValidGroupKeys.MinValidGroup;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + ValidGroupKeys.MaxValidGroup + @".*"))
{
/// get the MaximumValidGroups key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, ValidGroupKeys.MaxValidGroup, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ValidGroupKeys.MaxValidGroup;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + ValidGroupKeys.EndBracket + @".*"))
{
flag = DataKeys.UNDEFINED;
}
break;
case DataKeys.INTERSECT:
if (Regex.IsMatch(formattedLine, AtoZ))
{
/// get the AtoZ key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, AtoZ, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = aKeyValue.Key;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + IntersectionKeys.EndBracket + @".*"))
{
flag = DataKeys.UNDEFINED;
}
break;
case DataKeys.NONINTERSECT:
if (Regex.IsMatch(formattedLine, AtoZ))
{
/// get the AtoZ key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, AtoZ, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = aKeyValue.Key;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + NonIntersectionKeys.EndBracket + @".*"))
{
flag = DataKeys.UNDEFINED;
}
break;
}
}
aConfigurationFileItem.Valid = Errors.Count == 0;
/// If the current line is the opening bracket to a fragment, do not add as a new item. Else, do so.
if (aConfigurationFileItem.Name != null)
{
aConfigurationFileFragment.AddNewItem(aConfigurationFileItem);
}
}
/// FALSE TRUE FALSE
/// FALSE FALSE TRUE
return(!aConfigurationFileFragment.Items.Exists(item => item.Valid == false));
}
public static Boolean TryParse(List <String> configurationFileGroup, out CfgGroup aconfigurationFileGroup)
{
Errors = new List <String>();
aconfigurationFileGroup = new CfgGroup();
String ConfigurationLine = "";
String SymbolMark = "NULL";
foreach (String line in configurationFileGroup)
{
// Discard comment.
if (line.Contains("//"))
{
int index = line.IndexOf("//");
ConfigurationLine = line.Remove(index);
}
else
{
ConfigurationLine = line;
}
ConfigurationLine = ConfigurationLine.Trim();
// Use Configuration object to store name and keyvalue
ConfigurationFileItem aConfigurationFileItem = new ConfigurationFileItem(ConfigurationLine);
if (Regex.IsMatch(line, @"^\s*$"))
{
aConfigurationFileItem.Name = ConfigurationKeys.NO_CONFIGURATION_ITEM;
}
else
{
if (String.IsNullOrEmpty(ConfigurationLine))
{
continue;
}
// Process the log file block
if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.LOGFILE + @".*"))
{
SymbolMark = "FILE-OPEN";
aconfigurationFileGroup.CfgTitle = ConfigurationKeys.LOGFILE;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.LOGFILE_NAME + @".*") && SymbolMark == "FILE-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.LOGFILE_NAME, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.LOGFILE_NAME;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.END_LOGFILE + @".*"))
{
SymbolMark = "NULL";
}
// Process the letter sequences configuration(limits on the number os unique letter sequences)
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.SEQUENCES_IN_FILE + @".*"))
{
SymbolMark = "SEQUENCES-IN-FILE-OPEN";
aconfigurationFileGroup.CfgTitle = ConfigurationKeys.SEQUENCES_IN_FILE;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MINIMUM_NUMBER_OF_UNIQUE_WORDS + @".*") && SymbolMark == "SEQUENCES-IN-FILE-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MINIMUM_NUMBER_OF_UNIQUE_WORDS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MINIMUM_NUMBER_OF_UNIQUE_WORDS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MAXIMUM_NUMBER_OF_UNIQUE_WORDS + @".*") && SymbolMark == "SEQUENCES-IN-FILE-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MAXIMUM_NUMBER_OF_UNIQUE_WORDS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MAXIMUM_NUMBER_OF_UNIQUE_WORDS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.END_SEQUENCES_IN_FILE + @".*"))
{
SymbolMark = "NULL";
}
// Process the crozzle output configuration
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.CROZZLE_OUTPUT + @".*"))
{
SymbolMark = "CROZZLE-OUTPUT-OPEN";
aconfigurationFileGroup.CfgTitle = ConfigurationKeys.CROZZLE_OUTPUT;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.INVALID_CROZZLE_SCORE + @".*") && SymbolMark == "CROZZLE-OUTPUT-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.INVALID_CROZZLE_SCORE, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.INVALID_CROZZLE_SCORE;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.UPPERCASE + @".*") && SymbolMark == "CROZZLE-OUTPUT-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.UPPERCASE, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.UPPERCASE;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.STYLE + @".*") && SymbolMark == "CROZZLE-OUTPUT-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.STYLE, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.STYLE;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.BGCOLOUR_EMPTY_TD + @".*") && SymbolMark == "CROZZLE-OUTPUT-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.BGCOLOUR_EMPTY_TD, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.BGCOLOUR_EMPTY_TD;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.BGCOLOUR_NON_EMPTY_TD + @".*") && SymbolMark == "CROZZLE-OUTPUT-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.BGCOLOUR_NON_EMPTY_TD, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.BGCOLOUR_NON_EMPTY_TD;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.END_CROZZLE_OUTPUT + @".*"))
{
SymbolMark = "NULL";
}
// Process the limits on the size of the crozlle grid
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.CROZZLE_SIZE + @".*"))
{
SymbolMark = "CROZZLE-SIZE-OPEN";
aconfigurationFileGroup.CfgTitle = ConfigurationKeys.CROZZLE_SIZE;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MINIMUM_NUMBER_OF_ROWS + @".*") && SymbolMark == "CROZZLE-SIZE-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MINIMUM_NUMBER_OF_ROWS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MINIMUM_NUMBER_OF_ROWS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MAXIMUM_NUMBER_OF_ROWS + @".*") && SymbolMark == "CROZZLE-SIZE-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MAXIMUM_NUMBER_OF_ROWS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MAXIMUM_NUMBER_OF_ROWS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MINIMUM_NUMBER_OF_COLUMNS + @".*") && SymbolMark == "CROZZLE-SIZE-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MINIMUM_NUMBER_OF_COLUMNS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MINIMUM_NUMBER_OF_COLUMNS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MAXIMUM_NUMBER_OF_COLUMNS + @".*") && SymbolMark == "CROZZLE-SIZE-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MAXIMUM_NUMBER_OF_COLUMNS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MAXIMUM_NUMBER_OF_COLUMNS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.END_CROZZLE_OUTPUT + @".*"))
{
SymbolMark = "NULL";
}
// Process the sequence in crozzle
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.SEQUENCES_IN_CROZZLE + @".*"))
{
SymbolMark = "SEQUENCES-IN-CROZZLE-OPEN";
aconfigurationFileGroup.CfgTitle = ConfigurationKeys.SEQUENCES_IN_CROZZLE;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MINIMUM_HORIZONTAL_WORDS + @".*") && SymbolMark == "SEQUENCES-IN-CROZZLE-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MINIMUM_HORIZONTAL_WORDS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MINIMUM_HORIZONTAL_WORDS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MAXIMUM_VERTICAL_WORDS + @".*") && SymbolMark == "SEQUENCES-IN-CROZZLE-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MAXIMUM_VERTICAL_WORDS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MAXIMUM_VERTICAL_WORDS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MAXIMUM_HORIZONTAL_WORDS + @".*") && SymbolMark == "SEQUENCES-IN-CROZZLE-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MAXIMUM_HORIZONTAL_WORDS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MAXIMUM_HORIZONTAL_WORDS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MINIMUM_VERTICAL_WORDS + @".*") && SymbolMark == "SEQUENCES-IN-CROZZLE-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MINIMUM_VERTICAL_WORDS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MINIMUM_VERTICAL_WORDS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.END_SEQUENCES_IN_CROZZLE + @".*"))
{
SymbolMark = "NULL";
}
// Process the limits on the number of intersections
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.INTERSECTIONS_IN_SEQUENCES + @".*"))
{
SymbolMark = "INTERSECTIONS_IN_SEQUENCES-OPEN";
aconfigurationFileGroup.CfgTitle = ConfigurationKeys.INTERSECTIONS_IN_SEQUENCES;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MINIMUM_INTERSECTIONS_IN_HORIZONTAL_WORDS + @".*") && SymbolMark == "INTERSECTIONS_IN_SEQUENCES-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MINIMUM_INTERSECTIONS_IN_HORIZONTAL_WORDS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MINIMUM_INTERSECTIONS_IN_HORIZONTAL_WORDS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MAXIMUM_INTERSECTIONS_IN_HORIZONTAL_WORDS + @".*") && SymbolMark == "INTERSECTIONS_IN_SEQUENCES-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MAXIMUM_INTERSECTIONS_IN_HORIZONTAL_WORDS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MAXIMUM_INTERSECTIONS_IN_HORIZONTAL_WORDS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MINIMUM_INTERSECTIONS_IN_VERTICAL_WORDS + @".*") && SymbolMark == "INTERSECTIONS_IN_SEQUENCES-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MINIMUM_INTERSECTIONS_IN_VERTICAL_WORDS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MINIMUM_INTERSECTIONS_IN_VERTICAL_WORDS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MAXIMUM_INTERSECTIONS_IN_VERTICAL_WORDS + @".*") && SymbolMark == "INTERSECTIONS_IN_SEQUENCES-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MAXIMUM_INTERSECTIONS_IN_VERTICAL_WORDS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MAXIMUM_INTERSECTIONS_IN_VERTICAL_WORDS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.END_INTERSECTIONS_IN_SEQUENCES + @".*"))
{
SymbolMark = "NULL";
}
//process the duplicate sequence
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.DUPLICATE_SEQUENCES + @".*"))
{
SymbolMark = "DUPLICATE-SEQUENCES-OPEN";
aconfigurationFileGroup.CfgTitle = ConfigurationKeys.DUPLICATE_SEQUENCES;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MINIMUM_NUMBER_OF_THE_SAME_WORD + @".*") && SymbolMark == "DUPLICATE-SEQUENCES-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MINIMUM_NUMBER_OF_THE_SAME_WORD, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MINIMUM_NUMBER_OF_THE_SAME_WORD;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MAXIMUM_NUMBER_OF_THE_SAME_WORD + @".*") && SymbolMark == "DUPLICATE-SEQUENCES-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MAXIMUM_NUMBER_OF_THE_SAME_WORD, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MAXIMUM_NUMBER_OF_THE_SAME_WORD;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.END_DUPLICATE_SEQUENCES + @".*"))
{
SymbolMark = "NULL";
}
//process the valid group
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.VALID_GROUPS + @".*"))
{
SymbolMark = "VALID-GROUPS-OPEN";
aconfigurationFileGroup.CfgTitle = ConfigurationKeys.VALID_GROUPS;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MAXIMUM_NUMBER_OF_GROUPS + @".*") && SymbolMark == "VALID-GROUPS-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MAXIMUM_NUMBER_OF_GROUPS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MAXIMUM_NUMBER_OF_GROUPS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.MINIMUM_NUMBER_OF_GROUPS + @".*") && SymbolMark == "VALID-GROUPS-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, ConfigurationKeys.MINIMUM_NUMBER_OF_GROUPS, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = ConfigurationKeys.MINIMUM_NUMBER_OF_GROUPS;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.END_VALID_GROUPS + @".*"))
{
SymbolMark = "NULL";
}
//process the intersection points
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.INTERSECTING_POINTS + @".*"))
{
SymbolMark = "INTERSECTING-POINTS-OPEN";
aconfigurationFileGroup.CfgTitle = ConfigurationKeys.INTERSECTING_POINTS;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + AtoZ + @".*") && SymbolMark == "INTERSECTING-POINTS-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, AtoZ, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = aKeyValue.Key;
aConfigurationFileItem.KeyValue = aKeyValue;
// If the score of the word is not a number
if (aConfigurationFileItem.KeyValue.Value != null && Regex.IsMatch(aConfigurationFileItem.KeyValue.Value, Configuration.allowedCharacters))
{
Errors.Add(String.Format(KeyValueErrors.InvalidValueError, ConfigurationLine));
aConfigurationFileItem.InvalidTitle = ConfigurationKeys.INTERSECTING_POINTS;
}
}
// If the pre-defined intersecting character is not a single character from A-Z
else if (Regex.IsMatch(ConfigurationLine.Split('=')[0], Configuration.allowedCharacters) && SymbolMark == "INTERSECTING-POINTS-OPEN")
{
Errors.Add(String.Format(KeyValueErrors.InvalidKeyError, ConfigurationLine));
aConfigurationFileItem.InvalidTitle = ConfigurationKeys.INTERSECTING_POINTS;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.END_INTERSECTION_POINTS + @".*"))
{
SymbolMark = "NULL";
}
//Process the non-intersection points
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.NON_INTERSECTING_POINTS + @".*"))
{
SymbolMark = "NON-INTERSECTING-POINTS-OPEN";
aconfigurationFileGroup.CfgTitle = ConfigurationKeys.NON_INTERSECTING_POINTS;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + AtoZ + @".*") && SymbolMark == "NON-INTERSECTING-POINTS-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(ConfigurationLine, AtoZ, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aConfigurationFileItem.Name = aKeyValue.Key;
aConfigurationFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(ConfigurationLine, @"^" + ConfigurationKeys.END_NON_INTERSECTING_POINTS + @".*"))
{
SymbolMark = "NULL";
}
}
aConfigurationFileItem.Valid = Errors.Count == 0;
if (aConfigurationFileItem.Name != null)
{
aconfigurationFileGroup.Lines.Add(aConfigurationFileItem);
}
}
// Check the validation
Boolean Valid = true;
foreach (ConfigurationFileItem line in aconfigurationFileGroup.Lines)
{
if (line.Valid == false)
{
Valid = false;
}
}
return(Valid);
}
