public Boolean Contains(SequenceData data) { return(List.Contains(data)); }
public static Boolean TryParse(String path, Configuration aConfiguration, out WordList aWordList) { StreamReader fileIn = new StreamReader(path); Errors = new List <String>(); aWordList = new WordList(path, aConfiguration); /// Split the sequence file, and extract the WordDataValidator. aWordList.OriginalList = fileIn.ReadToEnd().Split(WordSeparators).Where(x => x != String.Empty).ToArray(); /// Validate the SequenceValidator; possible case of invalid fields. SequenceData seq; SequenceData.TryParse(aWordList.OriginalList.First(), IS_VALIDATOR, out seq); if (SequenceData.Errors.Any()) { Errors.AddRange(SequenceData.Errors); } else { aWordList.SequenceValidator = seq; aWordList.OriginalList = aWordList.OriginalList.Skip(1).ToArray(); /// existence of magic number. // Check each field in the wordlist. int totalPotentialScore = 0, totalPotentialLength = 0, totalPotentialAsciiSum = 0, totalPotentialHashTotal = 0; foreach (String potentialWord in aWordList.OriginalList) { SequenceData data; SequenceData.TryParse(potentialWord, !IS_VALIDATOR, out data); if (SequenceData.Errors.Any()) { Errors.AddRange(SequenceData.Errors); } else { /// Check that the sequence is not empty. if (data.Sequence.Length > 0) { /// Check if sequence is alphabetic, then check if sequence length matches its pre-determined length. if (Regex.IsMatch(data.Sequence, aWordList.SequenceValidator.Sequence)) { if (data.ReturnLength() != data.SequenceLength) { Errors.Add(String.Format(WordListErrors.NonIdenticalLengthError, data.OriginalData)); } else { aWordList.Add(data); totalPotentialLength += data.SequenceLength; } } else { Errors.Add(String.Format(WordListErrors.AlphabeticError, data.Sequence, data.OriginalData)); } totalPotentialScore += data.Score; /// Check if sequence's ASCII sum matches its pre-determined sum. if (data.ReturnAsciiSum() != data.AsciiSum) { Errors.Add(String.Format(WordListErrors.NonIdenticalAsciiSumError, data.OriginalData)); } else { totalPotentialAsciiSum += data.AsciiSum; } /// Check if seqence's hash total matches its pre-determined total. if (data.ReturnHashTotal() != data.HashTotal) { Errors.Add(String.Format(WordListErrors.NonIdenticalHashTotalError, data.OriginalData)); } else { totalPotentialHashTotal += data.HashTotal; } } else { Errors.Add(String.Format(WordListErrors.MissingWordError, data.OriginalData)); } } } /// Check if totaled potential values match the sequence validator. if (totalPotentialScore != aWordList.SequenceValidator.Score) { Errors.Add(String.Format(WordListErrors.IncorrectBatchScoreError, totalPotentialScore, aWordList.SequenceValidator.Score)); } if (totalPotentialLength != aWordList.SequenceValidator.SequenceLength) { Errors.Add(String.Format(WordListErrors.IncorrectBatchLengthError, totalPotentialLength, aWordList.SequenceValidator.SequenceLength)); } if (totalPotentialAsciiSum != aWordList.SequenceValidator.AsciiSum) { Errors.Add(String.Format(WordListErrors.IncorrectBatchAsciiSumError, totalPotentialAsciiSum, aWordList.SequenceValidator.SequenceLength)); } if (totalPotentialHashTotal != aWordList.SequenceValidator.HashTotal) { Errors.Add(String.Format(WordListErrors.IncorrectBatchHashTotalError, totalPotentialHashTotal, aWordList.SequenceValidator.HashTotal)); } // 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); }
public void Add(SequenceData data) { List.Add(data); }
public static Boolean TryParse(String originalSequenceData, Boolean isSequenceValidator, out SequenceData sequenceData) { sequenceData = new SequenceData(); Errors = new List <string>(); if (String.IsNullOrWhiteSpace(originalSequenceData)) { Errors.Add(String.Format("")); } else { sequenceData.OriginalData = originalSequenceData; if (isSequenceValidator) { /// Separate the regex specified in the sequence validator from the other fields. sequenceData.Sequence = originalSequenceData.Substring(0, originalSequenceData.LastIndexOf('"') + 1); originalSequenceData = originalSequenceData.Remove(0, sequenceData.Sequence.Length); sequenceData.Sequence = sequenceData.Sequence.Trim('"'); } else { sequenceData.Sequence = originalSequenceData.Substring(0, originalSequenceData.IndexOf(',')); originalSequenceData = originalSequenceData.Remove(0, sequenceData.Sequence.Length); } String[] data = originalSequenceData.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); if (data.Length != 4) { Errors.Add(String.Format("")); } else { int parsedValue; for (int i = 0; i < data.Length; i++) { switch (i) { case 0: if (!Int32.TryParse(data[i], out parsedValue)) { Errors.Add(String.Format("")); } else { sequenceData.Score = parsedValue; } break; case 1: if (!Int32.TryParse(data[i], out parsedValue)) { Errors.Add(String.Format("")); } else { sequenceData.SequenceLength = parsedValue; } break; case 2: if (!Int32.TryParse(data[i], out parsedValue)) { Errors.Add(String.Format("")); } else { sequenceData.AsciiSum = parsedValue; } break; case 3: if (!Int32.TryParse(data[i], out parsedValue)) { Errors.Add(String.Format("")); } else { sequenceData.HashTotal = parsedValue; } break; } } } } return(Errors.Count == 0); }