private String GetWordlistFileName(String path)
{
CrozzleFileItem aCrozzleFileItem = null;
StreamReader fileIn = new StreamReader(path);
// Search for file name.
while (!fileIn.EndOfStream)
{
FileFragment <CrozzleFileItem> aFragment;
List <String> fragment = new List <String>();
do
{
fragment.Add(fileIn.ReadLine());
} while (!String.IsNullOrEmpty(fragment.Last()));
if (CrozzleFileItem.TryParse(fragment, out aFragment))
{
if ((aCrozzleFileItem = aFragment.Items.Where(item => item.Name == CrozzleFileKeys.DEPENDENCIES_SEQDATA).First()) != null)
{
break;
}
}
}
// Close files.
fileIn.Close();
// Return file name.
return((aCrozzleFileItem == null) ? null : aCrozzleFileItem.KeyValue.Value);
}
private String GetWordlistFileNameRemotely(String url)
{
CrozzleFileItem aCrozzleFileItem = null;
WebClient webClient = new WebClient();
Stream stream = webClient.OpenRead(url);
StreamReader fileIn = new StreamReader(stream);
// Search for file name.
while (!fileIn.EndOfStream)
{
if (CrozzleFileItem.TryParse(fileIn.ReadLine(), out aCrozzleFileItem))
{
if (aCrozzleFileItem.IsWordListFile)
{
break;
}
}
}
// Close files.
fileIn.Close();
// Return file name.
if (aCrozzleFileItem == null)
{
return(null);
}
else
{
return(aCrozzleFileItem.KeyValue.Value);
}
}
private String GetConfigurationFileName(String path)
{
CrozzleFileItem aCrozzleFileItem = null;
StreamReader fileIn;
if (path.Contains("http"))
{
WebClient webClient = new WebClient();
Stream aStream = webClient.OpenRead(path);
fileIn = new StreamReader(aStream);
}
else
{
fileIn = new StreamReader(path);
}
// Search for file name.
while (!fileIn.EndOfStream)
{
if (CrozzleFileItem.TryParse(fileIn.ReadLine(), out aCrozzleFileItem))
{
if (aCrozzleFileItem.IsConfigurationFile)
{
break;
}
}
}
// Close files.
fileIn.Close();
// Return file name.
if (aCrozzleFileItem == null)
{
return(null);
}
else
{
return(aCrozzleFileItem.KeyValue.Value);
}
}
public static Boolean TryParse(List <string> crozzleFileFragment, out FileFragment <CrozzleFileItem> aCrozzleFileFragment)
{
Errors = new List <String>();
crozzleFileFragment.RemoveAll(s => String.IsNullOrEmpty(s));
aCrozzleFileFragment = new FileFragment <CrozzleFileItem>();
String formattedLine = String.Empty;
DataKeys flag = DataKeys.UNDEFINED;
foreach (String line in crozzleFileFragment)
{
/// Discard comment and trim possible whitespace.
if (line.Contains("//"))
{
int index = line.IndexOf("//");
formattedLine = line.Remove(index);
}
else
{
formattedLine = line;
}
formattedLine = formattedLine.Trim();
CrozzleFileItem aCrozzleFileItem = new CrozzleFileItem(formattedLine);
if (Regex.IsMatch(formattedLine, @"^\s*$"))
{
continue;
}
else if (Regex.IsMatch(formattedLine, ForeignCharacters))
{
Errors.Add(String.Format(ConfigurationFileItemErrors.SymbolError, aCrozzleFileItem));
}
else
{
/// TODO: switch case with flag
switch (flag)
{
case DataKeys.UNDEFINED:
/// fragment specification
if (Regex.IsMatch(formattedLine, @"^" + FileDependenciesKeys.OpenBracket + @".*"))
{
flag = DataKeys.DEPENDENCIES;
aCrozzleFileFragment.Name = FileDependenciesKeys.OpenBracket;
}
else if (Regex.IsMatch(formattedLine, @"^" + CrozzleSizeKeys.OpenBracket + @".*"))
{
flag = DataKeys.SIZE;
aCrozzleFileFragment.Name = CrozzleSizeKeys.OpenBracket;
}
else if (Regex.IsMatch(formattedLine, @"^" + HorizontalSequenceKeys.OpenBracket + @".*"))
{
flag = DataKeys.HORZSEQUENCE;
aCrozzleFileFragment.Name = HorizontalSequenceKeys.OpenBracket;
}
else if (Regex.IsMatch(formattedLine, @"^" + VerticalSequenceKeys.OpenBracket + @".*"))
{
flag = DataKeys.VERTSEQUENCE;
aCrozzleFileFragment.Name = VerticalSequenceKeys.OpenBracket;
}
break;
case DataKeys.DEPENDENCIES:
if (Regex.IsMatch(formattedLine, @"^" + FileDependenciesKeys.ConfigFileName + @".*"))
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, FileDependenciesKeys.ConfigFileName, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = FileDependenciesKeys.ConfigFileName;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + FileDependenciesKeys.SequenceFileName + @".*"))
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, FileDependenciesKeys.SequenceFileName, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = FileDependenciesKeys.SequenceFileName;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + FileDependenciesKeys.EndBracket + @".*"))
{
flag = DataKeys.UNDEFINED;
}
break;
case DataKeys.SIZE:
if (Regex.IsMatch(formattedLine, @"^" + CrozzleSizeKeys.Size + @".*"))
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, CrozzleSizeKeys.Size, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = CrozzleSizeKeys.Size;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + CrozzleSizeKeys.EndBracket + @".*"))
{
flag = DataKeys.UNDEFINED;
}
break;
case DataKeys.HORZSEQUENCE:
if (Regex.IsMatch(formattedLine, @"^" + HorizontalSequenceKeys.Sequence + @".*"))
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, HorizontalSequenceKeys.Sequence, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = HorizontalSequenceKeys.Sequence;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + HorizontalSequenceKeys.EndBracket + @".*"))
{
flag = DataKeys.UNDEFINED;
}
break;
case DataKeys.VERTSEQUENCE:
if (Regex.IsMatch(formattedLine, @"^" + VerticalSequenceKeys.Sequence + @".*"))
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(formattedLine, VerticalSequenceKeys.Sequence, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = VerticalSequenceKeys.Sequence;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(formattedLine, @"^" + VerticalSequenceKeys.EndBracket + @".*"))
{
flag = DataKeys.UNDEFINED;
}
break;
}
aCrozzleFileItem.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 (aCrozzleFileItem.Name != null)
{
aCrozzleFileFragment.AddNewItem(aCrozzleFileItem);
}
}
}
/// FALSE TRUE FALSE
/// FALSE FALSE TRUE
return(!aCrozzleFileFragment.Items.Exists(item => item.Valid == false));
}
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(List <String> crozzleFileGroup, out CzlGroup aCrozzleFileGroup)
{
Errors = new List <String>();
aCrozzleFileGroup = new CzlGroup();
String CrozzleLine = "";
String SymbolMark = "NULL";
foreach (String line in crozzleFileGroup)
{
if (String.IsNullOrEmpty(line))
{
break;
}
// Discard comment.
else if (line.Contains("//"))
{
int index = line.IndexOf("//");
CrozzleLine = line.Remove(index);
}
else
{
CrozzleLine = line;
}
CrozzleLine = CrozzleLine.Trim();
// Use Crozzle object to store name and keyvalue
CrozzleFileItem aCrozzleFileItem = new CrozzleFileItem(CrozzleLine);
if (Regex.IsMatch(line, @"^\s*$"))
{
aCrozzleFileItem.Name = CrozzleKeys.NoCrozzleItem;
}
else
{ // Process the file-dependencies block
if (Regex.IsMatch(CrozzleLine, @"^" + CrozzleKeys.FileDependencies + @".*"))
{
SymbolMark = "FILE-OPEN";
aCrozzleFileGroup.CzlTitle = CrozzleKeys.FileDependencies;
}
else if (Regex.IsMatch(CrozzleLine, @"^" + CrozzleKeys.ConfigData + @".*") && SymbolMark == "FILE-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(CrozzleLine, CrozzleKeys.ConfigData, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = CrozzleKeys.ConfigData;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(CrozzleLine, @"^" + CrozzleKeys.SequenceData + @".*") && SymbolMark == "FILE-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(CrozzleLine, CrozzleKeys.SequenceData, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = CrozzleKeys.SequenceData;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(CrozzleLine, @"^" + CrozzleKeys.EndFileDependencies + @".*"))
{
SymbolMark = "NULL";
}
// Process the crozzle-size block
else if (Regex.IsMatch(CrozzleLine, @"^" + CrozzleKeys.CrozzleSize + @".*"))
{
SymbolMark = "SIZE-OPEN";
aCrozzleFileGroup.CzlTitle = CrozzleKeys.CrozzleSize;
}
else if (Regex.IsMatch(CrozzleLine, @"^" + CrozzleKeys.Size + @".*") && SymbolMark == "SIZE-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(CrozzleLine, CrozzleKeys.Size, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = CrozzleKeys.Size;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(CrozzleLine, @"^" + CrozzleKeys.EndCrozzleSize + @".*"))
{
SymbolMark = "NULL";
}
// Process horizontal-sequences block
else if (Regex.IsMatch(CrozzleLine, @"^" + CrozzleKeys.HorizontalSequence + @".*"))
{
SymbolMark = "HORIZON-OPEN";
aCrozzleFileGroup.CzlTitle = CrozzleKeys.HorizontalSequence;
}
else if (Regex.IsMatch(CrozzleLine, @"^" + CrozzleKeys.HSequence + @".*") && SymbolMark == "HORIZON-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(CrozzleLine, CrozzleKeys.HSequence, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = CrozzleKeys.HSequence;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(CrozzleLine, @"^" + "LOCATION" + @".*") && SymbolMark == "HORIZON-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(CrozzleLine, "LOCATION", out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = "LOCATION";
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(CrozzleLine, @"^" + CrozzleKeys.EndHorizontalSequence + @".*"))
{
SymbolMark = "NULL";
}
// Process vertical-sequences block
else if (Regex.IsMatch(CrozzleLine, @"^" + CrozzleKeys.VerticalSequence + @".*"))
{
SymbolMark = "VERTICAL-OPEN";
aCrozzleFileGroup.CzlTitle = CrozzleKeys.VerticalSequence;
}
else if (Regex.IsMatch(CrozzleLine, @"^" + CrozzleKeys.VSequence + @".*") && SymbolMark == "VERTICAL-OPEN")
{
KeyValue aKeyValue;
if (!KeyValue.TryParse(CrozzleLine, CrozzleKeys.VSequence, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = CrozzleKeys.VSequence;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(CrozzleLine, @"^" + CrozzleKeys.EndVerticalSequence + @".*"))
{
SymbolMark = "NULL";
}
}
// Determine whether the line is valid
aCrozzleFileItem.Valid = Errors.Count == 0;
// Add the core content in each block
if (aCrozzleFileItem.Name != null)
{
aCrozzleFileGroup.Lines.Add(aCrozzleFileItem);
}
}
// Check th Validity
Boolean Valid = true;
foreach (CrozzleFileItem line in aCrozzleFileGroup.Lines)
{
if (line.Valid == false)
{
Valid = false;
}
}
return(Valid);
}
public static Boolean TryParse(String crozzleFileItem, out CrozzleFileItem aCrozzleFileItem)
{
Debug.WriteLine(crozzleFileItem);
Errors = new List <String>();
aCrozzleFileItem = new CrozzleFileItem(crozzleFileItem);
// Discard comment.
if (crozzleFileItem.Contains("//"))
{
int index = crozzleFileItem.IndexOf("//");
crozzleFileItem = crozzleFileItem.Remove(index);
crozzleFileItem = crozzleFileItem.Trim();
aCrozzleFileItem.Name = "COMMENTED";
}
else if (Regex.IsMatch(crozzleFileItem, @"^\s*$"))
{
// Check for only 0 or more white spaces.
aCrozzleFileItem.Name = NoCrozzleItem;
}
else if (crozzleFileItem.Contains("-END-"))
{
// New UPDATE
// discard -end-
BufferClass.Identifier = "";
int index = crozzleFileItem.IndexOf("-END-");
crozzleFileItem = crozzleFileItem.Remove(index);
crozzleFileItem = crozzleFileItem.Trim();
aCrozzleFileItem.Name = "END";
}
else if (crozzleFileItem.Contains(FileDependencies))
{
// New UPDATE
// giving name for unrecognised line
aCrozzleFileItem.Name = FileDependencies;
}
else if (crozzleFileItem.Contains(CrozzleSize))
{
// New UPDATE
// giving name for unrecognised line
aCrozzleFileItem.Name = CrozzleSize;
}
else if (Regex.IsMatch(crozzleFileItem, @"^" + VerticalSequences + "$"))
{
// Check for check if the list is vertical sequences
BufferClass.Identifier = VerticalSequences;
aCrozzleFileItem.Name = VerticalSequences;
}
else if (Regex.IsMatch(crozzleFileItem, @"^" + HorizontalSequences + "$"))
{
// Check for check if the list is horizontal sequences
BufferClass.Identifier = HorizontalSequences;
aCrozzleFileItem.Name = HorizontalSequences;
}
else if (Regex.IsMatch(crozzleFileItem, @"^" + ConfigDataSymbol + ".*"))
{
// Get the CONFIGURATION_FILE key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(crozzleFileItem, ConfigDataSymbol, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = ConfigDataSymbol;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(crozzleFileItem, @"^" + SequenceDataSymbol + ".*"))
{
// Get the WORDLIST_FILE key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(crozzleFileItem, SequenceDataSymbol, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = SequenceDataSymbol;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(crozzleFileItem, @"^" + HorizontalSequencesLine + ".*"))
{
// Get the WORDLIST_FILE key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(crozzleFileItem, HorizontalSequencesLine, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = HorizontalSequencesLine;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(crozzleFileItem, @"^" + VerticalSequencesLine + ".*"))
{
// Get the WORDLIST_FILE key-value pair.
KeyValue aKeyValue;
if (!KeyValue.TryParse(crozzleFileItem, VerticalSequencesLine, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = VerticalSequencesLine;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(crozzleFileItem, @"^" + SizeSymbol + ".*"))
{
// Get the number of rows for the crozzle.
KeyValue aKeyValue;
if (!KeyValue.TryParse(crozzleFileItem, SizeSymbol, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = SizeSymbol;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(crozzleFileItem, @"^" + SequenceSymbol + ".*"))
{
// Get data for a horizontal word.
KeyValue aKeyValue;
if (!KeyValue.TryParse(crozzleFileItem, SequenceSymbol, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = SequenceSymbol;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else if (Regex.IsMatch(crozzleFileItem, @"^" + LocationSymbol + ".*"))
{
// Get data for a vertical word.
KeyValue aKeyValue;
if (!KeyValue.TryParse(crozzleFileItem, LocationSymbol, out aKeyValue))
{
Errors.AddRange(KeyValue.Errors);
}
aCrozzleFileItem.Name = LocationSymbol;
aCrozzleFileItem.KeyValue = aKeyValue;
}
else
{
Errors.Add(String.Format(CrozzleFileItemErrors.SymbolError, crozzleFileItem));
}
aCrozzleFileItem.Valid = Errors.Count == 0;
return(aCrozzleFileItem.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 <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);
}
