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); }
public static Boolean TryParse(TitleSequence Block, Crozzle aCrozzle, out WordData aWordData) { String[] originalWordData = Block.SequenceLine.Split(new Char[] { ',' }, 2); Errors = new List <String>(); aWordData = new WordData(); String[] OldOriginalWordData = new string[4]; // Check that the original word data has the correct number of fields. if (originalWordData.Length != NumberOfFields) { Errors.Add(String.Format(WordDataErrors.FieldCountError, originalWordData.Length, Block.SequenceLine, NumberOfFields)); } // If the title symbol exist if (Block.Title.Length > 0) { // Check whether the title is an orientation value. Orientation anOrientation; if (!Orientation.TryParse(Block.Title, out anOrientation)) { Errors.AddRange(Orientation.Errors); } aWordData.Orientation = anOrientation; if (anOrientation.Valid) { // Handle the name & sequence side String[] WordName = originalWordData[0].Split('='); // Figure out whether WordName = ['SEQUENCE','(words)'] if (WordName[0] != "SEQUENCE") { Errors.Add(String.Format(WordDataErrors.MissingSymbol, Block.SequenceLine)); } else { // Figure out whether the word is missing if (String.IsNullOrEmpty(WordName[1])) { Errors.Add(String.Format(WordDataErrors.BlankFieldError, Block.SequenceLine, WordName[0])); } // Find out whether the word is alphabet else if (!Regex.IsMatch(WordName[1], Configuration.allowedCharacters)) { Errors.Add(String.Format(WordDataErrors.AlphabeticError, WordName[1])); } else { aWordData.Letters = WordName[1]; } } // Handle the coordinate side String[] WordCoordinate = originalWordData[1].Split('='); // If the format is correct if (WordName[0] == "SEQUENCE") { //find out whether the right side is seperated by equeal symbol if (WordCoordinate.Length != 2) { Errors.Add(String.Format(WordDataErrors.MissingSymbol, Block.SequenceLine)); } // Find out whether the coordinate exists else if (String.IsNullOrEmpty(WordCoordinate[1])) { Errors.Add(String.Format(WordDataErrors.BlankFieldError, Block.SequenceLine, WordCoordinate[0])); } else { // Get the Coordinate in string format String[] CoordinateString = WordCoordinate[1].Split(','); // Find out whether the CoordinateString is complete if (CoordinateString.Length != 2) { Errors.Add(String.Format(WordDataErrors.CoordinateIncomplete, CoordinateString[0], originalWordData[1])); } else { // Get the coordinate of each word String rowValue = CoordinateString[0]; String columnValue = CoordinateString[1]; if (rowValue.Length > 0 && columnValue.Length > 0) { Coordinate aCoordinate; if (!Coordinate.TryParse(rowValue, columnValue, aCrozzle, out aCoordinate)) { Errors.AddRange(Coordinate.Errors); } aWordData.Location = aCoordinate; } } } } } } // Switch to the old format if (aWordData.Orientation != null) { OldOriginalWordData[0] = aWordData.Orientation.Direction; } else if (aWordData.Location != null) { OldOriginalWordData[1] = aWordData.Location.Row.ToString(); OldOriginalWordData[3] = aWordData.Location.Column.ToString(); } else if (aWordData.Letters != null) { OldOriginalWordData[2] = aWordData.Letters; } // Pass the old format to old OldOriginalWordData aWordData.OriginalWordData = OldOriginalWordData; aWordData.Valid = Errors.Count == 0; return(aWordData.Valid); }