public static Boolean TryParse(String originalRowData, String originalColumnData, Crozzle aCrozzle, out Coordinate aCoordinate) { int anInteger; String[] originalCoordinate = new String[] { originalRowData, originalColumnData }; Errors = new List <String>(); aCoordinate = new Coordinate(originalCoordinate); // Check that the row value is an integer and in range. if (Validator.IsInt32(originalRowData, out anInteger)) { aCoordinate.Row = anInteger; if (!Validator.TryRange(aCoordinate.Row, 1, aCrozzle.Rows)) { Errors.Add(String.Format(CoordinateErrors.RowValueError, originalRowData, Validator.Errors[0])); } } else { Errors.Add(String.Format(CoordinateErrors.RowValueError, originalRowData, Validator.Errors[0])); } // Check that the column value is an integer and in range. if (Validator.IsInt32(originalColumnData, out anInteger)) { aCoordinate.Column = anInteger; if (!Validator.TryRange(aCoordinate.Column, 1, aCrozzle.Columns)) { Errors.Add(String.Format(CoordinateErrors.ColumnValueError, originalColumnData, Validator.Errors[0])); } } else { Errors.Add(String.Format(CoordinateErrors.ColumnValueError, originalColumnData, Validator.Errors[0])); } aCoordinate.Valid = Errors.Count == 0; return(aCoordinate.Valid); }
public static Boolean TryParse(String path, Configuration aConfiguration, WordList wordList, out Crozzle aCrozzle, bool isRemote = false) { Errors = new List <String>(); aCrozzle = new Crozzle(path, aConfiguration, wordList, isRemote); // Open file. StreamReader fileIn = null; if (!isRemote) { fileIn = new StreamReader(path); } else { WebClient webClient = new WebClient(); Stream stream = webClient.OpenRead(path); fileIn = new StreamReader(stream); } List <String> wordData = new List <string>(); // Validate file. while (!fileIn.EndOfStream) { // Read a line. String line = fileIn.ReadLine(); // Parse a crozzle file item. CrozzleFileItem aCrozzleFileItem; if (CrozzleFileItem.TryParse(line, out aCrozzleFileItem)) { if (aCrozzleFileItem.IsConfigurationFile) { // Get the configuration file name. String configurationPath = aCrozzleFileItem.KeyValue.Value; if (configurationPath == null) { Errors.Add(CrozzleFileErrors.ConfigurationFilenameMissing); } else { configurationPath = configurationPath.Trim(); if (Validator.IsDelimited(configurationPath, StringDelimiters)) { configurationPath = configurationPath.Trim(StringDelimiters); } if (!isRemote && !Path.IsPathRooted(configurationPath)) { String directoryName = Path.GetDirectoryName(path); configurationPath = directoryName + @"\" + configurationPath; } aCrozzle.ConfigurationPath = configurationPath; } } else if (aCrozzleFileItem.IsWordListFile) { // Get the word list file name. String wordListPath = aCrozzleFileItem.KeyValue.Value; if (wordListPath == null) { Errors.Add(CrozzleFileErrors.WordlistFilenameMissing); } else { wordListPath = wordListPath.Trim(); if (Validator.IsDelimited(wordListPath, StringDelimiters)) { wordListPath = wordListPath.Trim(StringDelimiters); } if (!isRemote && !Path.IsPathRooted(wordListPath)) { String directoryName = Path.GetDirectoryName(path); wordListPath = directoryName + @"\" + wordListPath; } aCrozzle.WordListPath = wordListPath; } } else if (aCrozzleFileItem.IsRows) { // Get the number of rows. int rows; if (Validator.IsInt32(aCrozzleFileItem.KeyValue.Value.Trim(), out rows)) { aCrozzle.Rows = rows; } else { Errors.Add(String.Format(CrozzleFileErrors.RowError, aCrozzleFileItem.KeyValue.OriginalKeyValue, Validator.Errors[0])); } } else if (aCrozzleFileItem.IsColumns) { // Get the number of columns. int columns; if (Validator.IsInt32(aCrozzleFileItem.KeyValue.Value.Trim(), out columns)) { aCrozzle.Columns = columns; } else { Errors.Add(String.Format(CrozzleFileErrors.ColumnError, aCrozzleFileItem.KeyValue.OriginalKeyValue, Validator.Errors[0])); } } else if (aCrozzleFileItem.IsRow) { // Collect potential word data for a horizontal word. wordData.Add(aCrozzleFileItem.KeyValue.OriginalKeyValue); } else if (aCrozzleFileItem.IsColumn) { // Collect potential word data for a vertical word. wordData.Add(aCrozzleFileItem.KeyValue.OriginalKeyValue); } } else { Errors.AddRange(CrozzleFileItem.Errors); } } // Close files. fileIn.Close(); aCrozzle.Node = Node.GreedyAlgorithm(aCrozzle.Rows, aCrozzle.Columns, aConfiguration, wordList.List); // Validate file sections. // Check the configuration file name. if (aCrozzle.Configuration != null) { if (aCrozzle.Configuration.ConfigurationPath != aCrozzle.ConfigurationPath) { Errors.Add(String.Format(CrozzleFileErrors.ConfigurationFilenameError, aCrozzle.ConfigurationPath, aCrozzle.Configuration.ConfigurationFileName)); } } // Check the word list file name. if (aCrozzle.WordList != null) { if (aCrozzle.WordList.WordlistPath != aCrozzle.WordListPath) { Errors.Add(String.Format(CrozzleFileErrors.WordlistFilenameError, aCrozzle.WordListPath, aCrozzle.WordList.WordlistFileName)); } } aCrozzle.CrozzleRows = aCrozzle.Node.Grid.GridRows; aCrozzle.CrozzleColumns = aCrozzle.Node.Grid.GridColumns; // Store validity. aCrozzle.FileValid = Errors.Count == 0; return(aCrozzle.FileValid); }
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 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 path, Configuration aConfiguration, WordList wordList, out Crozzle aCrozzle) { Errors = new List <String>(); aCrozzle = new Crozzle(path, aConfiguration, wordList); // Open file. StreamReader fileIn = new StreamReader(path); List <String> wordData = new List <string>(); // Validate file. while (!fileIn.EndOfStream) { // Read a line. String line = fileIn.ReadLine(); // Parse a crozzle file item. CrozzleFileItem aCrozzleFileItem; if (CrozzleFileItem.TryParse(line, out aCrozzleFileItem)) { if (aCrozzleFileItem.IsConfigurationFile) { // Get the configuration file name. String configurationPath = aCrozzleFileItem.KeyValue.Value; if (configurationPath == null) { Errors.Add(CrozzleFileErrors.ConfigurationFilenameMissing); } else { configurationPath = configurationPath.Trim(); if (Validator.IsDelimited(configurationPath, StringDelimiters)) { configurationPath = configurationPath.Trim(StringDelimiters); } if (!Path.IsPathRooted(configurationPath)) { String directoryName = Path.GetDirectoryName(path); configurationPath = directoryName + @"\" + configurationPath; } aCrozzle.ConfigurationPath = configurationPath; } } else if (aCrozzleFileItem.IsWordListFile) { // Get the word list file name. String wordListPath = aCrozzleFileItem.KeyValue.Value; if (wordListPath == null) { Errors.Add(CrozzleFileErrors.WordlistFilenameMissing); } else { wordListPath = wordListPath.Trim(); if (Validator.IsDelimited(wordListPath, StringDelimiters)) { wordListPath = wordListPath.Trim(StringDelimiters); } if (!Path.IsPathRooted(wordListPath)) { String directoryName = Path.GetDirectoryName(path); wordListPath = directoryName + @"\" + wordListPath; } aCrozzle.WordListPath = wordListPath; } } else if (aCrozzleFileItem.IsRows) { // Get the number of rows. int rows; if (Validator.IsInt32(aCrozzleFileItem.KeyValue.Value.Trim(), out rows)) { aCrozzle.Rows = rows; } else { Errors.Add(String.Format(CrozzleFileErrors.RowError, aCrozzleFileItem.KeyValue.OriginalKeyValue, Validator.Errors[0])); } } else if (aCrozzleFileItem.IsColumns) { // Get the number of columns. int columns; if (Validator.IsInt32(aCrozzleFileItem.KeyValue.Value.Trim(), out columns)) { aCrozzle.Columns = columns; } else { Errors.Add(String.Format(CrozzleFileErrors.ColumnError, aCrozzleFileItem.KeyValue.OriginalKeyValue, Validator.Errors[0])); } } else if (aCrozzleFileItem.IsRow) { // Collect potential word data for a horizontal word. wordData.Add(aCrozzleFileItem.KeyValue.OriginalKeyValue); } else if (aCrozzleFileItem.IsColumn) { // Collect potential word data for a vertical word. wordData.Add(aCrozzleFileItem.KeyValue.OriginalKeyValue); } } else { Errors.AddRange(CrozzleFileItem.Errors); } } // Close files. fileIn.Close(); // Get potential word data list. WordDataList wordDataList; if (!WordDataList.TryParse(wordData, aCrozzle, out wordDataList)) { Errors.AddRange(WordDataList.Errors); } aCrozzle.WordDataList = wordDataList; // Validate file sections. // Check the configuration file name. if (aCrozzle.Configuration != null) { if (aCrozzle.Configuration.ConfigurationPath != aCrozzle.ConfigurationPath) { Errors.Add(String.Format(CrozzleFileErrors.ConfigurationFilenameError, aCrozzle.ConfigurationPath, aCrozzle.Configuration.ConfigurationFileName)); } } // Check the word list file name. if (aCrozzle.WordList != null) { if (aCrozzle.WordList.WordlistPath != aCrozzle.WordListPath) { Errors.Add(String.Format(CrozzleFileErrors.WordlistFilenameError, aCrozzle.WordListPath, aCrozzle.WordList.WordlistFileName)); } } // Raw word data of horizontal and vertical words were obtained when reading the crozzle file, // but now we need to create crozzle rows and crozzle columns that represent the crozzle. aCrozzle.CreateCrozzleRows(aCrozzle.WordDataList); aCrozzle.CreateCrozzleColumns(aCrozzle.WordDataList); // Store validity. aCrozzle.FileValid = Errors.Count == 0; return(aCrozzle.FileValid); }
public static Boolean TryParse(SequenceFragment fragment, Crozzle aCrozzle, out WordData aWordData) { Errors = new List <String>(); aWordData = new WordData(); Orientation anOrientation; if (!Orientation.TryParse(fragment.DirectionIdentifier, out anOrientation)) { Errors.AddRange(Orientation.Errors); } aWordData.Orientation = anOrientation; String[] fields = fragment.OriginalWordData.Split(new char[] { ',' }, 2); if (fields.Length != 2) { Errors.Add(String.Format(WordDataErrors.FieldCountError, fields.Length, (fields.Length == 1) ? String.Empty : "s", fragment.OriginalWordData)); } else { if (fields.Where(i => i.Contains("SEQUENCE")).Any() && fields.Where(i => i.Contains("LOCATION")).Any()) { String[] wordField = fields.Where(item => item.Contains("SEQUENCE")).First().Split('='); if (String.IsNullOrEmpty(wordField[1])) { Errors.Add(String.Format(WordDataErrors.BlankFieldError, fragment.OriginalWordData, wordField[0])); } else { if (Regex.IsMatch(wordField[1], Configuration.allowedCharacters)) { aWordData.Letters = wordField[1]; } else { Errors.Add(String.Format(WordDataErrors.AlphabeticError, wordField[1])); } } String[] locationField = fields.Where(item => item.Contains("LOCATION")).First().Split('='); if (String.IsNullOrEmpty(locationField[1])) { Errors.Add(String.Format(WordDataErrors.BlankFieldError, fragment.OriginalWordData, wordField[0])); } else { String[] values = locationField[1].Split(','); if (values.Length != 2) { Errors.Add(String.Format(WordDataErrors.SequencePositionIncompleteError, fragment.OriginalWordData)); } else { int posx, posy; if (!Validator.IsInt32(values[0], out posx) || !Validator.IsInt32(values[1], out posy)) { Errors.Add(String.Format(WordDataErrors.SequencePositionInvalidError, fragment.OriginalWordData)); } else { aWordData.Location = new Coordinate(posx, posy); } } } } else { Errors.Add(String.Format(WordDataErrors.SeqOrLocFieldMissingError, fragment.OriginalWordData)); } } aWordData.OriginalWordData = new string[] { (aWordData.Orientation != null) ? aWordData.Orientation.Direction : null, (aWordData.Location != null) ? aWordData.Location.Row.ToString() : null, (aWordData.Location != null) ? aWordData.Location.Column.ToString() : null, (aWordData.Letters != null) ? aWordData.Letters : null }; aWordData.Valid = Errors.Count == 0; return(aWordData.Valid); }
public static Boolean TryParse(String path, Configuration aConfiguration, WordList wordList, out Crozzle aCrozzle) { Errors = new List <String>(); aCrozzle = new Crozzle(path, aConfiguration, wordList); // Open file. StreamReader fileIn = new StreamReader(path); List <String> wordData = new List <string>(); String section = null; bool newBlock = false; // Validate file while (!fileIn.EndOfStream) { // Read a line. String line = fileIn.ReadLine(); // Processing empty lines if (Regex.IsMatch(line, @"^\s*$")) { continue; } line = line.Trim(); // Processing comments if (line.Contains("//")) { if (line.StartsWith("//")) { continue; } else { Errors.Add(String.Format(ConfigurationErrors.MixConfigWithComentError, line)); continue; } } // Section check switch (line) { case "FILE-DEPENDENCIES": case "CROZZLE-SIZE": case "HORIZONTAL-SEQUENCES": case "VERTICAL-SEQUENCES": section = line; newBlock = true; break; case "END-FILE-DEPENDENCIES": case "END-CROZZLE-SIZE": case "END-HORIZONTAL-SEQUENCES": case "END-VERTICAL-SEQUENCES": section = null; newBlock = true; break; default: break; } if (newBlock) { newBlock = false; continue; } // Parse a crozzle file item. CrozzleFileItem aCrozzleFileItem; // Out of section comment if (section == null) { Errors.Add(String.Format(ConfigurationErrors.OutOfSectionError, line)); } // Parse a crozzle item else if (CrozzleFileItem.TryParse(line, out aCrozzleFileItem)) { if (aCrozzleFileItem.IsConfigurationFile) { // Get the configuration file name. String configurationPath = aCrozzleFileItem.KeyValue.Value; if (configurationPath == null) { Errors.Add(CrozzleFileErrors.ConfigurationFilenameMissing); } else { configurationPath = configurationPath.Trim(); if (Validator.IsDelimited(configurationPath, StringDelimiters)) { configurationPath = configurationPath.Trim(StringDelimiters); } if (!Path.IsPathRooted(configurationPath)) { String directoryName = Path.GetDirectoryName(path); configurationPath = directoryName + @"\" + configurationPath; } aCrozzle.ConfigurationPath = configurationPath; } } else if (aCrozzleFileItem.IsWordListFile) { // Get the word list file name. String wordListPath = aCrozzleFileItem.KeyValue.Value; if (wordListPath == null) { Errors.Add(CrozzleFileErrors.WordlistFilenameMissing); } else { wordListPath = wordListPath.Trim(); if (Validator.IsDelimited(wordListPath, StringDelimiters)) { wordListPath = wordListPath.Trim(StringDelimiters); } if (!Path.IsPathRooted(wordListPath)) { String directoryName = Path.GetDirectoryName(path); wordListPath = directoryName + @"\" + wordListPath; } aCrozzle.WordListPath = wordListPath; } } // Replace else if (aCrozzleFileItem.IsSize) { // Split row & col String rawSizeData = aCrozzleFileItem.KeyValue.Value.Trim(); String[] sizeSplit = rawSizeData.Split(new String[] { SizeDelimiter }, 2, StringSplitOptions.None); if (sizeSplit.Length != SizeValueLength) { Errors.Add(String.Format(KeyValueErrors.FieldCountError, sizeSplit.Length, rawSizeData, SizeValueLength)); } else { int rows; if (Validator.IsInt32(sizeSplit[0].Trim(), out rows)) { aCrozzle.Rows = rows; } else { Errors.Add(String.Format(CrozzleFileErrors.RowError, aCrozzleFileItem.KeyValue.OriginalKeyValue, Validator.Errors[0])); } int columns; if (Validator.IsInt32(sizeSplit[1].Trim(), out columns)) { aCrozzle.Columns = columns; } else { Errors.Add(String.Format(CrozzleFileErrors.ColumnError, aCrozzleFileItem.KeyValue.OriginalKeyValue, Validator.Errors[0])); } } } else if (aCrozzleFileItem.IsSequence) { // Collect potential word data for a horizontal word. //wordData.Add(aCrozzleFileItem.KeyValue.OriginalKeyValue); String type; if (section == "HORIZONTAL-SEQUENCES") { type = "ROW"; try { String oldFormat = aCrozzleFileItem.KeyValue.OriginalKeyValue; oldFormat = oldFormat.Substring("SEQUENCE=".Length); string[] split; split = oldFormat.Split(','); String key = split[0]; String row = split[1].Split('=')[1]; String col = split[2]; String newFormat = type + "=" + row + "," + key + "," + col; Console.WriteLine("New Format = " + newFormat); wordData.Add(newFormat); } catch (Exception e) { Errors.Add(String.Format(CrozzleFileErrors.SequenceFormatError, aCrozzleFileItem.KeyValue.OriginalKeyValue)); } } else if (section == "VERTICAL-SEQUENCES") { type = "COLUMN"; try { String oldFormat = aCrozzleFileItem.KeyValue.OriginalKeyValue; oldFormat = oldFormat.Substring("SEQUENCE=".Length); string[] split; split = oldFormat.Split(','); String key = split[0]; String row = split[1].Split('=')[1]; String col = split[2]; String newFormat = type + "=" + col + "," + key + "," + row; Console.WriteLine("New Format = " + newFormat); wordData.Add(newFormat); } catch (Exception e) { Errors.Add(String.Format(CrozzleFileErrors.SequenceFormatError, aCrozzleFileItem.KeyValue.OriginalKeyValue)); } } else { Errors.AddRange(CrozzleFileItem.Errors); break; } } } else { Errors.AddRange(CrozzleFileItem.Errors); } } // Close files. fileIn.Close(); // Get potential word data list. WordDataList wordDataList; if (!WordDataList.TryParse(wordData, aCrozzle, out wordDataList)) { Errors.AddRange(WordDataList.Errors); } aCrozzle.WordDataList = wordDataList; // Validate file sections. // Check the configuration file name. if (aCrozzle.Configuration != null) { if (aCrozzle.Configuration.ConfigurationPath != aCrozzle.ConfigurationPath) { Errors.Add(String.Format(CrozzleFileErrors.ConfigurationFilenameError, aCrozzle.ConfigurationPath, aCrozzle.Configuration.ConfigurationFileName)); } } // Check the word list file name. if (aCrozzle.WordList != null) { if (aCrozzle.WordList.WordlistPath != aCrozzle.WordListPath) { Errors.Add(String.Format(CrozzleFileErrors.WordlistFilenameError, aCrozzle.WordListPath, aCrozzle.WordList.WordlistFileName)); } } // Raw word data of horizontal and vertical words were obtained when reading the crozzle file, // but now we need to create crozzle rows and crozzle columns that represent the crozzle. aCrozzle.CreateCrozzleRows(aCrozzle.WordDataList); aCrozzle.CreateCrozzleColumns(aCrozzle.WordDataList); // Store validity. aCrozzle.FileValid = Errors.Count == 0; return(aCrozzle.FileValid); }
public static Boolean TryParse(String path, Configuration aConfiguration, WordList wordList, out Crozzle aCrozzle) { Errors = new List <String>(); aCrozzle = new Crozzle(path, aConfiguration, wordList); StreamReader fileIn; if (path.Contains("http")) { WebClient webClient = new WebClient(); Stream aStream = webClient.OpenRead(path); fileIn = new StreamReader(aStream); } else { fileIn = new StreamReader(path); } List <String> wordData = new List <string>(); // Validate file. while (!fileIn.EndOfStream) { // Read a line. String line = fileIn.ReadLine(); // Parse a crozzle file item. CrozzleFileItem aCrozzleFileItem; if (CrozzleFileItem.TryParse(line, out aCrozzleFileItem)) { if (aCrozzleFileItem.IsConfigurationFile) { // Get the configuration file name. String configurationPath = aCrozzleFileItem.KeyValue.Value; if (configurationPath == null) { Errors.Add(CrozzleFileErrors.ConfigurationFilenameMissing); } else { configurationPath = configurationPath.Trim(); if (Validator.IsDelimited(configurationPath, StringDelimiters)) { configurationPath = configurationPath.Trim(StringDelimiters); } if (!Path.IsPathRooted(configurationPath)) { // Seperate local files and files from web server if (!path.Contains("http")) { String directoryName = Path.GetDirectoryName(path); configurationPath = directoryName + @"\" + configurationPath; } } aCrozzle.ConfigurationPath = configurationPath; } } else if (aCrozzleFileItem.IsWordListFile) { // Get the word list file name. String wordListPath = aCrozzleFileItem.KeyValue.Value; if (wordListPath == null) { Errors.Add(CrozzleFileErrors.WordlistFilenameMissing); } else { wordListPath = wordListPath.Trim(); if (Validator.IsDelimited(wordListPath, StringDelimiters)) { wordListPath = wordListPath.Trim(StringDelimiters); } if (!Path.IsPathRooted(wordListPath)) { // Seperate local files and files from web server if (!path.Contains("http")) { String directoryName = Path.GetDirectoryName(path); wordListPath = directoryName + @"\" + wordListPath; } } aCrozzle.WordListPath = wordListPath; } } else if (aCrozzleFileItem.IsRows) { // Get the number of rows. int rows; if (Validator.IsInt32(aCrozzleFileItem.KeyValue.Value.Trim(), out rows)) { aCrozzle.Rows = rows; } else { Errors.Add(String.Format(CrozzleFileErrors.RowError, aCrozzleFileItem.KeyValue.OriginalKeyValue, Validator.Errors[0])); } } else if (aCrozzleFileItem.IsColumns) { // Get the number of columns. int columns; if (Validator.IsInt32(aCrozzleFileItem.KeyValue.Value.Trim(), out columns)) { aCrozzle.Columns = columns; } else { Errors.Add(String.Format(CrozzleFileErrors.ColumnError, aCrozzleFileItem.KeyValue.OriginalKeyValue, Validator.Errors[0])); } } else if (aCrozzleFileItem.IsRow) { // Collect potential word data for a horizontal word. wordData.Add(aCrozzleFileItem.KeyValue.OriginalKeyValue); } else if (aCrozzleFileItem.IsColumn) { // Collect potential word data for a vertical word. wordData.Add(aCrozzleFileItem.KeyValue.OriginalKeyValue); } } else { Errors.AddRange(CrozzleFileItem.Errors); } } // Close files. fileIn.Close(); // If the file does not have location and orientation of words if (wordData.Count == 0) { // Initialize an empty key-value group List <String> GenerateKeyValueGroup = new List <String>(); // Use an dictionary to store inserting and non-inserting words score Dictionary <char, int> IntersectingPointsPerLetter = new Dictionary <char, int>(); Dictionary <char, int> NonIntersectingPointsPerLetter = new Dictionary <char, int>(); // Append score to corresponding letter char[] alphabet = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' }; for (int i = 0; i < alphabet.Length; i++) { IntersectingPointsPerLetter.Add(alphabet[i], aConfiguration.IntersectingPointsPerLetter[i]); NonIntersectingPointsPerLetter.Add(alphabet[i], aConfiguration.NonIntersectingPointsPerLetter[i]); } // Use greedy algorithm to get a group with maximun number of words Grid grid = new Grid(aCrozzle.Rows, aCrozzle.Columns, IntersectingPointsPerLetter, NonIntersectingPointsPerLetter, aConfiguration.PointsPerWord); grid.GetConfiguration(aCrozzle.Configuration); GenerateKeyValueGroup = grid.GreedyAlgorithm(wordList.List, aConfiguration.MaximumNumberOfGroups, aConfiguration.MinimumNumberOfGroups, out aCrozzle.timeConsume); // Append NewkeyValue instead of OriginalKeyValue to old program in terms of compatibility foreach (string GenerateKeyValue in GenerateKeyValueGroup) { wordData.Add(GenerateKeyValue); } } // Get potential word data list. WordDataList wordDataList; if (!WordDataList.TryParse(wordData, aCrozzle, out wordDataList)) { Errors.AddRange(WordDataList.Errors); } aCrozzle.WordDataList = wordDataList; // Validate file sections. // Check the configuration file name. if (aCrozzle.Configuration != null) { if (aCrozzle.Configuration.ConfigurationPath != aCrozzle.ConfigurationPath) { Errors.Add(String.Format(CrozzleFileErrors.ConfigurationFilenameError, aCrozzle.ConfigurationPath, aCrozzle.Configuration.ConfigurationFileName)); } } // Check the word list file name. if (aCrozzle.WordList != null) { if (aCrozzle.WordList.WordlistPath != aCrozzle.WordListPath) { Errors.Add(String.Format(CrozzleFileErrors.WordlistFilenameError, aCrozzle.WordListPath, aCrozzle.WordList.WordlistFileName)); } } // Raw word data of horizontal and vertical words were obtained when reading the crozzle file, // but now we need to create crozzle rows and crozzle columns that represent the crozzle. aCrozzle.CreateCrozzleRows(aCrozzle.WordDataList); aCrozzle.CreateCrozzleColumns(aCrozzle.WordDataList); // Store validity. aCrozzle.FileValid = Errors.Count == 0; return(aCrozzle.FileValid); }
public static Boolean TryParse(String path, Configuration aConfiguration, out WordList aWordList) { Errors = new List <String>(); // path for wordlist aWordList = new WordList(path, aConfiguration); StreamReader fileIn = new StreamReader(path); List <Sequence> WordListSequence = new List <Sequence>(); // Read all the line inside the file int row = 0; while (!fileIn.EndOfStream) { // New UPDATE // Split the original wordlist from the file usin specific regex // Which will skip the comma ',' inside the double-quotes Regex CSVParser = new Regex(",(?=(?:[^\"]*\"[^\"]*\")*(?![^\"]*\"))"); aWordList.OriginalList = CSVParser.Split(fileIn.ReadLine()); // Check each field in the wordlist. // which in the new class //int fieldNumber = 0; Sequence wordList = new Sequence(); wordList.Word = aWordList.OriginalList[0]; wordList.Score = aWordList.OriginalList[1]; wordList.Length = aWordList.OriginalList[2]; wordList.Ascii = aWordList.OriginalList[3]; wordList.Total = aWordList.OriginalList[4]; WordListSequence.Add(wordList); if (row > 0) { Configuration.PointsPerWord.Add(aWordList.OriginalList[0] + "," + aWordList.OriginalList[1]); } row++; } int totalPointPerWord = 0; int totalLengthWord = 0; int totalASCIIPoint = 0; int totalAccPoint = 0; // Repeat for all the word listed in the group for (int i = 1; i < WordListSequence.Capacity; i++) { if (Sequence.Test(WordListSequence[i].Word, WordListSequence[0].Word)) { if (Regex.IsMatch(WordListSequence[i].Word, Configuration.allowedCharacters)) { aWordList.Add(WordListSequence[i].Word); } else { Errors.Add(String.Format(WordListErrors.AlphabeticError, WordListSequence[i].Word, i - 1)); } } else { Errors.Add(String.Format(WordListErrors.UnidentifiedSequenceWordError, WordListSequence[i].Word)); } // Check the total of character of the word // Initialisation int countChar; Validator.IsInt32(WordListSequence[i].Length, out countChar); if (WordListSequence[i].Word.Length != countChar) { Errors.Add(String.Format(WordListErrors.CharacterWordLengthError, WordListSequence[i].Word)); } int asciiNum = 0; byte[] asciiBytes = Encoding.ASCII.GetBytes(WordListSequence[i].Word); // Accumulating the ASCII score for each character inside a word foreach (byte ascii in asciiBytes) { asciiNum += (int)ascii; } int asciiString; Validator.IsInt32(WordListSequence[i].Ascii, out asciiString); // If and error management if (asciiNum != asciiString) { Errors.Add(String.Format(WordListErrors.AsciiNumberofWordError, WordListSequence[i].Word)); } // Check the Total validation number of the word\ // Initialisation int intScore; Validator.IsInt32(WordListSequence[i].Score, out intScore); int Total = asciiNum + intScore + countChar; int intTotal; // If and error management Validator.IsInt32(WordListSequence[i].Total, out intTotal); if (Total != intTotal) { Errors.Add(String.Format(WordListErrors.TotalNumberValidationError, WordListSequence[i].Word)); } // calculating the total point each row totalPointPerWord += intScore; totalLengthWord += countChar; totalASCIIPoint += asciiNum; totalAccPoint += Total; } // Check the accumulation at the top for point row int rulesPoint; Validator.IsInt32(WordListSequence[0].Score, out rulesPoint); if (totalPointPerWord != rulesPoint) { Errors.Add(String.Format(WordListErrors.TotalPointPerRowError)); } // Check the accumulation at the top for length row int rulesLength; Validator.IsInt32(WordListSequence[0].Length, out rulesLength); if (totalLengthWord != rulesLength) { Errors.Add(String.Format(WordListErrors.TotalLengthPointError)); } // Check the accumulation at the top for ascii row int rulesASCII; Validator.IsInt32(WordListSequence[0].Ascii, out rulesASCII); if (totalASCIIPoint != rulesASCII) { Errors.Add(String.Format(WordListErrors.TotalAsciiPointError)); } // Check the accumulation at the top for accumulation point row int rulesAccPoint; Validator.IsInt32(WordListSequence[0].Total, out rulesAccPoint); if (totalAccPoint != rulesAccPoint) { Errors.Add(String.Format(WordListErrors.TotalAccumulationPointError)); } // Check the minimmum word limit. if (aWordList.Count < aConfiguration.MinimumNumberOfUniqueWords) { Errors.Add(String.Format(WordListErrors.MinimumSizeError, aWordList.Count, aConfiguration.MinimumNumberOfUniqueWords)); } // Check the maximum word limit. if (aWordList.Count > aConfiguration.MaximumNumberOfUniqueWords) { Errors.Add(String.Format(WordListErrors.MaximumSizeError, aWordList.Count, aConfiguration.MaximumNumberOfUniqueWords)); } aWordList.Valid = Errors.Count == 0; return(aWordList.Valid); }
private int CrozzleScore() { int score = 0; // New UPDATE // New loop for score listed in the sequence // list all the sequence in the crozzle foreach (WordData Sequence in CrozzleSequences.Sequences) { // loops in all wordlist foreach (String Point in Configuration.PointsPerWord) { string[] PointPerWordRow = Point.Split(','); // for match if (Regex.IsMatch(PointPerWordRow[0], @"^" + Sequence.Letters + "$")) { int point; if (Validator.IsInt32(PointPerWordRow[1], out point)) { score += point; } } } } // Increase the score for each word. // Increase the score for intersecting letters. List <Char> intersectingLetters = CrozzleSequences.GetIntersectingLetters(); foreach (Char letter in intersectingLetters) { score += Configuration.IntersectingPointsPerLetter[(int)letter - (int)'A']; } // Get all letters. List <Char> allLetters = new List <Char>(); foreach (String[] letters in CrozzleRows) { foreach (String letter in letters) { if (letter[0] != ' ') { allLetters.Add(letter[0]); } } } // Remove each intersecting letter from allLetters. List <Char> nonIntersectingLetters = allLetters; foreach (Char letter in intersectingLetters) { nonIntersectingLetters.Remove(letter); } // Increase the score for non-intersecting letters. foreach (Char letter in nonIntersectingLetters) { score += Configuration.NonIntersectingPointsPerLetter[(int)letter - (int)'A']; } return(score); }
public static Boolean TryParse(String path, Configuration aConfiguration, WordList wordList, out Crozzle aCrozzle) { Errors = new List <String>(); aCrozzle = new Crozzle(path, aConfiguration, wordList); // Open file. StreamReader fileIn = new StreamReader(path); List <SequenceFragment> wordData = new List <SequenceFragment>(); // 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 crozzle file fragment. FileFragment <CrozzleFileItem> aCrozzleFileFragment; if (CrozzleFileItem.TryParse(fragment, out aCrozzleFileFragment)) { String aFragmentKey = aCrozzleFileFragment.Name; foreach (CrozzleFileItem aItem in aCrozzleFileFragment.Items) { /// Process the key-value, given the current fragment key. if (aFragmentKey == CrozzleFileKeys.DEPENDENCIES_OPENBRACKET) { if (aItem.Name == CrozzleFileKeys.DEPENDENCIES_CONFIGDATA) { String configurationPath = aItem.KeyValue.Value; if (configurationPath == null) { Errors.Add(CrozzleFileErrors.ConfigurationFilenameMissing); } else { configurationPath = configurationPath.Trim(); if (Validator.IsDelimited(configurationPath, StringDelimiters)) { configurationPath = configurationPath.Trim(StringDelimiters); } if (!Path.IsPathRooted(configurationPath)) { String directoryName = Path.GetDirectoryName(path); configurationPath = directoryName + @"\" + configurationPath; } aCrozzle.ConfigurationPath = configurationPath; } } else if (aItem.Name == CrozzleFileKeys.DEPENDENCIES_SEQDATA) { String wordListPath = aItem.KeyValue.Value; if (wordListPath == null) { Errors.Add(CrozzleFileErrors.WordlistFilenameMissing); } else { wordListPath = wordListPath.Trim(); if (Validator.IsDelimited(wordListPath, StringDelimiters)) { wordListPath = wordListPath.Trim(StringDelimiters); } if (!Path.IsPathRooted(wordListPath)) { String directoryName = Path.GetDirectoryName(path); wordListPath = directoryName + @"\" + wordListPath; } aCrozzle.WordListPath = wordListPath; } } } else if (aFragmentKey == CrozzleFileKeys.SIZE_OPENBRACKET) { int rows, columns; String[] values = aItem.KeyValue.Value.Trim().Split(','); if (Validator.IsInt32(values[0], out rows)) { aCrozzle.Rows = rows; } else { Errors.Add(String.Format(CrozzleFileErrors.RowError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0])); } if (Validator.IsInt32(values[1], out columns)) { aCrozzle.Columns = columns; } else { Errors.Add(String.Format(CrozzleFileErrors.ColumnError, aItem.KeyValue.OriginalKeyValue, Validator.Errors[0])); } } else if (new[] { CrozzleFileKeys.HORZSEQ_OPENBRACKET, CrozzleFileKeys.VERTSEQ_OPENBRACKET }.Contains(aFragmentKey)) { wordData.Add(new SequenceFragment(aFragmentKey, aItem.KeyValue.OriginalKeyValue)); } else { Errors.AddRange(CrozzleFileItem.Errors); } } } } // Close files. fileIn.Close(); // Get potential word data list. WordDataList wordDataList; if (!WordDataList.TryParse(wordData, aCrozzle, out wordDataList)) { Errors.AddRange(WordDataList.Errors); } aCrozzle.WordDataList = wordDataList; // Validate file sections. // Check the configuration file name. if (aCrozzle.Configuration != null) { if (aCrozzle.Configuration.ConfigurationPath != aCrozzle.ConfigurationPath) { Errors.Add(String.Format(CrozzleFileErrors.ConfigurationFilenameError, aCrozzle.ConfigurationPath, aCrozzle.Configuration.ConfigurationFileName)); } } // Check the word list file name. if (aCrozzle.WordList != null) { if (aCrozzle.WordList.WordlistPath != aCrozzle.WordListPath) { Errors.Add(String.Format(CrozzleFileErrors.WordlistFilenameError, aCrozzle.WordListPath, aCrozzle.WordList.WordlistFileName)); } } // Raw word data of horizontal and vertical words were obtained when reading the crozzle file, // but now we need to create crozzle rows and crozzle columns that represent the crozzle. aCrozzle.CreateCrozzleRows(aCrozzle.WordDataList); aCrozzle.CreateCrozzleColumns(aCrozzle.WordDataList); // Store validity. aCrozzle.FileValid = Errors.Count == 0; return(aCrozzle.FileValid); }
public static Boolean TryParse(String path, Configuration aConfiguration, WordList wordList, out Crozzle aCrozzle) { Errors = new List <String>(); aCrozzle = new Crozzle(path, aConfiguration, wordList); // Open file. StreamReader fileIn = new StreamReader(path); List <TitleSequence> wordData = new List <TitleSequence>(); // Validate file. while (!fileIn.EndOfStream) { // Create a Block to store a group of data List <String> Block = new List <String>(); // Read a line. String line = fileIn.ReadLine(); while (!String.IsNullOrEmpty(line)) { Block.Add(line); line = fileIn.ReadLine(); } // Parse a block in crozzle file CzlGroup aCrozzleFileGroup; if (CrozzleFileItem.TryParse(Block, out aCrozzleFileGroup)) { String title = aCrozzleFileGroup.CzlTitle; for (int i = 0; i < aCrozzleFileGroup.Lines.Count; i++) { // Whether the title equals to "FILE-DEPENDENCIES" if (title == CrozzleKeys.FileDependencies) { if (aCrozzleFileGroup.Lines[i].Name == CrozzleKeys.ConfigData) { String configurationPath = aCrozzleFileGroup.Lines[i].KeyValue.Value; if (configurationPath == null) { Errors.Add(CrozzleFileErrors.ConfigurationFilenameMissing); } else { configurationPath = configurationPath.Trim(); if (Validator.IsDelimited(configurationPath, StringDelimiters)) { configurationPath = configurationPath.Trim(StringDelimiters); } if (!Path.IsPathRooted(configurationPath)) { String directoryName = Path.GetDirectoryName(path); configurationPath = directoryName + @"\" + configurationPath; } aCrozzle.ConfigurationPath = configurationPath; } } else if (aCrozzleFileGroup.Lines[i].Name == CrozzleKeys.SequenceData) { String wordListPath = aCrozzleFileGroup.Lines[i].KeyValue.Value; if (wordListPath == null) { Errors.Add(CrozzleFileErrors.ConfigurationFilenameMissing); } else { wordListPath = wordListPath.Trim(); if (Validator.IsDelimited(wordListPath, StringDelimiters)) { wordListPath = wordListPath.Trim(StringDelimiters); } if (!Path.IsPathRooted(wordListPath)) { String directoryName = Path.GetDirectoryName(path); wordListPath = directoryName + @"\" + wordListPath; } aCrozzle.WordListPath = wordListPath; } } } // Whether the title equals to "CROZZLE-SIZE" else if (title == CrozzleKeys.CrozzleSize) { int rows, columns; String[] coordinate = aCrozzleFileGroup.Lines[i].KeyValue.Value.Split(','); if (Validator.IsInt32(coordinate[0].Trim(), out rows)) { aCrozzle.Rows = rows; } else { Errors.Add(String.Format(CrozzleFileErrors.RowError, aCrozzleFileGroup.Lines[i].KeyValue.OriginalKeyValue, Errors[0])); } if (Validator.IsInt32(coordinate[1].Trim(), out columns)) { aCrozzle.Columns = columns; } else { Errors.Add(String.Format(CrozzleFileErrors.ColumnError, aCrozzleFileGroup.Lines[i].KeyValue.OriginalKeyValue, Errors[1])); } } // Whether the title equals to "HORIZONTAL-SEQUENCES" or "VERTICAL-SEQUENCE" else if (title == CrozzleKeys.HorizontalSequence || title == CrozzleKeys.VerticalSequence) { TitleSequence temp = new TitleSequence(title, aCrozzleFileGroup.Lines[i].KeyValue.OriginalKeyValue); wordData.Add(temp); } // If there exist unidentified titles else { Errors.AddRange(CrozzleFileItem.Errors); } } } } // Close files. fileIn.Close(); // Get potential word data list. WordDataList wordDataList; if (!WordDataList.TryParse(wordData, aCrozzle, out wordDataList)) { Errors.AddRange(WordDataList.Errors); } aCrozzle.WordDataList = wordDataList; // Validate file sections. // Check the configuration file name. if (aCrozzle.Configuration != null) { if (aCrozzle.Configuration.ConfigurationPath != aCrozzle.ConfigurationPath) { Errors.Add(String.Format(CrozzleFileErrors.ConfigurationFilenameError, aCrozzle.ConfigurationPath, aCrozzle.Configuration.ConfigurationPath)); } } // Check the word list file name. if (aCrozzle.WordList != null) { if (aCrozzle.WordList.WordlistPath != aCrozzle.WordListPath) { Errors.Add(String.Format(CrozzleFileErrors.WordlistFilenameError, aCrozzle.WordListPath, aCrozzle.WordList.WordlistFileName)); } } // Raw word data of horizontal and vertical words were obtained when reading the crozzle file, // but now we need to create crozzle rows and crozzle columns that represent the crozzle. aCrozzle.CreateCrozzleRows(aCrozzle.WordDataList); aCrozzle.CreateCrozzleColumns(aCrozzle.WordDataList); // Store validity. aCrozzle.FileValid = Errors.Count == 0; return(aCrozzle.FileValid); }