private static IConditionKeyword?ReadKeyword(IWordReader reader, List <string> messages)
{
if (reader.WordType == WordType.Null)
{
return(new ConstantCondition(null));
}
if (reader.WordType == WordType.Variable)
{
return(new VariableCondition(reader.Word));
}
if (reader.WordType == WordType.String)
{
return(new ConstantCondition(reader.Word));
}
if (reader.WordType == WordType.Number)
{
if (int.TryParse(reader.Word, out var number))
{
return(new ConstantCondition(number));
}
messages.Add(string.Format(InvalidNumber, reader.Word));
return(null);
}
messages.Add(string.Format(InvalidOperand, reader.Word));
return(null);
}
public ReadRootContext(IWordReader reader, List <string> messages, bool allowCloseParenthesys, bool singleCondition)
{
Reader = reader;
Messages = messages;
SingleCondition = singleCondition;
AllowCloseParenthesys = allowCloseParenthesys;
}
public IEnumerable <string> FilterWords(IWordReader reader)
{
return(reader
.ReadWords()
.Select(_converter.ConvertWord)
.Where(_analyzer.IsCorrectWord));
}
private static ICondition?ReadNullCondition(IConditionKeyword operand, IWordReader reader, List <string> messages)
{
if (!ReadExpectingNotBeTheEnd(reader, messages))
{
return(null);
}
if (reader.WordType == WordType.Null)
{
return(new IsNullCondition(operand));
}
if (reader.WordType != WordType.Not)
{
messages.Add(string.Format(InvalidTokenAfterIs, reader.Word));
return(null);
}
if (!ReadExpectingNotBeTheEnd(reader, messages))
{
return(null);
}
if (reader.WordType == WordType.Null)
{
return(new IsNotNullCondition(operand));
}
messages.Add(string.Format(InvalidTokenAfterIsNot, reader.Word));
return(null);
}
public ConsoleTagsCloudCreator(ITagsCloudCreator creator, IImageSaver saver, IWordReader reader,
IWordProcessor processor)
{
this.creator = creator;
this.saver = saver;
this.reader = reader;
this.processor = processor;
}
public CloudCreator(Config config, IWordReader wordReader, ITextFilter textFilter, IDrawer drawer, ITagMaker tagMaker)
{
this.config = config;
this.textFilter = textFilter;
this.wordReader = wordReader;
this.drawer = drawer;
this.tagMaker = tagMaker;
}
public IEnumerable <WeightedWord> WeightWords(IWordReader reader)
{
return(_filter
.FilterWords(reader)
.GroupBy(word => word)
.Select(group => new WeightedWord(group.Key, group.Count()))
.OrderByDescending(weightedWord => weightedWord.Weight)
.ToList());
}
public TranslationManager()
{
wordReader = WordReaderFactory.GetCurrentInstance();
wordWriter = WordWriterFactory.GetCurrentInstance();
translatorCreator = new TranslatorCreator();
ConfigureObjects();
ConfigureThreadPool();
}
// The main word processing algorithm
public static void ProcessWords(IWordReader reader, IWordProcessor processor)
{
string word;
while((word = reader.ReadWord()) != null) {
processor.ProcessWord(word);
}
processor.Finish();
}
public void SetUp()
{
var processor = new SimpleWordProcessor();
reader = Substitute.For <IWordReader>();
var provider = new SimpleWordProvider(reader, processor);
creator = new SimpleTagsCreator(provider);
}
public WordSourceProvider(TextReaderFactory textReaderFactory, IWordReader textSplitter,
IChangerFactory changerFactory,
ISelectorFactory selectorFactory)
{
this.textReaderFactory = textReaderFactory;
this.changerFactory = changerFactory;
this.selectorFactory = selectorFactory;
this.textSplitter = textSplitter;
}
private static ICondition?ReadCondition(IWordReader reader, List <string> messages)
{
var left = ReadKeyword(reader, messages);
if (left is null)
{
return(null);
}
if (!reader.Read())
{
messages.Add(UnexpectedExpressionEnd);
return(null);
}
switch (reader.WordType)
{
case WordType.Invalid:
messages.Add(string.Format(InvalidToken, reader.Word));
return(null);
case WordType.Equals:
return(ReadOperator(reader, messages, left, (l, r) => new EqualsToCondition(l, r)));
case WordType.NotEqualsTo:
return(ReadOperator(reader, messages, left, (l, r) => new NotEqualsToCondition(l, r)));
case WordType.GreaterThan:
return(ReadOperator(reader, messages, left, (l, r) => new GreaterThanCondition(l, r)));
case WordType.LowerThan:
return(ReadOperator(reader, messages, left, (l, r) => new LowerThanCondition(l, r)));
case WordType.EqualOrGreaterThan:
return(ReadOperator(reader, messages, left, (l, r) => new EqualOrGreaterThanCondition(l, r)));
case WordType.EqualOrLowerThan:
return(ReadOperator(reader, messages, left, (l, r) => new EqualOrLowerThanCondition(l, r)));
case WordType.In:
return(ReadInCondition(left, false, reader, messages));
case WordType.Between:
return(ReadBetweenCondition(left, false, reader, messages));
case WordType.Not:
return(ReadNotOperator(reader, messages, left));
case WordType.Is:
return(ReadNullCondition(left, reader, messages));
default:
messages.Add(string.Format(InvalidOperator, reader.Word));
return(null);
}
}
public TranslationManager(IWordReader wordReader,
IWordWriter wordWriter, ITranslatorCreator translatorCreator)
{
this.wordReader = wordReader;
this.wordWriter = wordWriter;
this.translatorCreator = translatorCreator;
ConfigureObjects();
ConfigureThreadPool();
}
// The main word processing algorithm
public static void ProcessWords(IWordReader reader, IWordProcessor processor)
{
string word;
while ((word = reader.ReadWord()) != null)
{
processor.ProcessWord(word);
}
processor.Finish();
}
public CloudImageBuilder(
ICloudBuilder builder,
IWordReader reader,
IWordWeighter weighter,
IWordDrawer drawer,
Size imageSize
)
{
_weighter = weighter;
_drawer = drawer;
BuildCloudImage(builder, reader, imageSize);
}
private void BuildCloudImage(ICloudBuilder builder, IWordReader reader, Size imageSize)
{
_cloudImage = new Bitmap(imageSize.Width, imageSize.Height);
var graphics = Graphics.FromImage(_cloudImage);
var weightedWords = _weighter.WeightWords(reader);
foreach (var weightedWord in weightedWords)
{
var rectanglePlace = builder.PutNextRectangle(_drawer.GetWordSize(graphics, weightedWord));
graphics.DrawRectangle(Pens.RoyalBlue, rectanglePlace);
_drawer.DrawWord(graphics, weightedWord, rectanglePlace);
}
}
private static ICondition?ReadOperator(
IWordReader reader,
List <string> messages,
IConditionKeyword left,
Func <IConditionKeyword, IConditionKeyword, ICondition> factory
)
{
var right = ReadNextKeyword(reader, messages);
if (right is null)
{
return(null);
}
return(factory.Invoke(left, right));
}
public static IWordReader GetCurrentInstance()
{
if(currentWordReader == null)
{
lock(syncRoot)
{
if(currentWordReader == null)
{
ConfigureWordReaderType();
currentWordReader = ActiveteInstance();
}
}
}
return currentWordReader;
}
private static IConditionKeyword?ReadNextKeyword(IWordReader reader, List <string> messages)
{
if (!reader.Read())
{
messages.Add(UnexpectedExpressionEnd);
return(null);
}
if (reader.WordType == WordType.Invalid)
{
messages.Add(string.Format(InvalidToken, reader.Word));
return(null);
}
return(ReadKeyword(reader, messages));
}
private static bool ReadExpectingNotBeTheEnd(IWordReader reader, List <string> messages)
{
if (!reader.Read())
{
messages.Add(UnexpectedExpressionEnd);
return(false);
}
if (reader.WordType == WordType.Invalid)
{
messages.Add(string.Format(InvalidToken, reader.Word));
return(false);
}
return(true);
}
public void ZarovnejVypis()
{
reader = fileProcessor.dalsiSoubor();
while (true)
{
bool konecOdstavce = false;
slovo = reader.vratSlovo();
if (slovo == "\n")
{
konecOdstavce = true;
}
if (reader.konecSouboru)
{
PosledniSlovo(konecOdstavce);
fileProcessor.zavriSr();
reader = fileProcessor.dalsiSoubor();
if (reader == null)
{
vypisRadek(slovaRadku, delkaRadku, false, true);
return;
}
}
else
{
if ((slovo.Length + slovaRadku.Count + delkaRadku > povolenaDelkaRadku || konecOdstavce) && slovaRadku.Count > 0)
{
vypisRadek(slovaRadku, delkaRadku, konecOdstavce, false);
slovaRadku.Clear();
delkaRadku = 0;
}
if (!konecOdstavce)
{
delkaRadku += slovo.Length;
slovaRadku.Add(slovo);
}
}
}
}
private static ICondition?ReadNotOperator(
IWordReader reader,
List <string> messages,
IConditionKeyword left
)
{
if (!ReadExpectingNotBeTheEnd(reader, messages))
{
return(null);
}
if (reader.WordType == WordType.In)
{
return(ReadInCondition(left, true, reader, messages));
}
if (reader.WordType == WordType.Between)
{
return(ReadBetweenCondition(left, true, reader, messages));
}
messages.Add(string.Format(InvalidTokenAfterNot, reader.Word));
return(null);
}
private static ICondition?ReadingError(IWordReader reader, List <string> messages, string message)
{
messages.Add(string.Format(message, reader.Word));
return(null);
}
public BasicWordsSelector(IWordReader reader, WordSetting wordSetting)
{
this.reader = reader;
this.wordSetting = wordSetting;
}
public void RebuildCloudImage(ICloudBuilder builder, IWordReader reader, Size imageSize)
{
BuildCloudImage(builder, reader, imageSize);
}
public TagsCreator(IWordReader wordReader, IStatisticsMaker statisticsMaker)
{
this.wordReader = wordReader;
this.statisticsMaker = statisticsMaker;
}
public SimpleWordProvider(IWordReader reader, IWordProcessor processor)
{
this.reader = reader;
this.processor = processor;
}
private static ICondition?ReadRoot(IWordReader reader, List <string> messages, bool allowCloseParenthesys, bool singleCondition)
{
if (!reader.Read())
{
messages.Add(UnexpectedExpressionEnd);
return(null);
}
var context = new ReadRootContext(reader, messages, allowCloseParenthesys, singleCondition);
do
{
switch (reader.WordType)
{
case WordType.Invalid:
return(ReadingError(reader, messages, InvalidToken));
case WordType.Variable:
case WordType.String:
case WordType.Number:
case WordType.Null:
ReadRootVariableOrConstant(context);
break;
case WordType.OpenParenthesys:
ReadRootOpenParenthesys(context);
break;
case WordType.CloseParenthesys:
ReadRootCloseParenthesys(context);
break;
case WordType.And:
ReadRootLogicalOperator(context, (l, r) => new AndCondition(l, r));
break;
case WordType.Or:
ReadRootLogicalOperator(context, (l, r) => new OrCondition(l, r));
break;
case WordType.Not:
ReadRootNot(context);
break;
default:
return(ReadingError(reader, messages, MisplacedKeyword));
}
if (context.ShouldReturnCurrent)
{
return(context.Current);
}
}while (reader.Read());
if (context.AllowCloseParenthesys || context.Current is null)
{
messages.Add(UnexpectedExpressionEnd);
return(null);
}
return(context.Current);
}
private static ICondition?ReadInCondition(IConditionKeyword operand, bool negated, IWordReader reader, List <string> messages)
{
if (!ReadExpectingNotBeTheEnd(reader, messages))
{
return(null);
}
if (reader.WordType != WordType.OpenParenthesys)
{
messages.Add(string.Format(InvalidTokenAfterIn, reader.Word));
return(null);
}
var values = new List <IConditionKeyword>();
IConditionKeyword?value;
for (; ;)
{
value = ReadNextKeyword(reader, messages);
if (value is null)
{
return(null);
}
values.Add(value);
if (!ReadExpectingNotBeTheEnd(reader, messages))
{
return(null);
}
if (reader.WordType == WordType.CloseParenthesys)
{
break;
}
if (reader.WordType != WordType.Comma)
{
messages.Add(string.Format(InvalidTokenAfterInValue, reader.Word));
return(null);
}
}
if (negated)
{
return(new NotInCondition(operand, values));
}
return(new InCondition(operand, values));
}
public void SetUp()
{
processor = new SimpleWordProcessor();
reader = Substitute.For <IWordReader>();
provider = new SimpleWordProvider(reader, processor);
}
private static ICondition?ReadBetweenCondition(IConditionKeyword operand, bool negated, IWordReader reader, List <string> messages)
{
var min = ReadNextKeyword(reader, messages);
if (min is null)
{
return(null);
}
if (!ReadExpectingNotBeTheEnd(reader, messages))
{
return(null);
}
if (reader.WordType != WordType.And)
{
messages.Add(string.Format(BetweenWithoutAnd, reader.Word));
return(null);
}
var max = ReadNextKeyword(reader, messages);
if (max is null)
{
return(null);
}
if (negated)
{
return(new NotBetweenCondition(operand, min, max));
}
return(new BetweenCondition(operand, min, max));
}
public WordsAnalyzer(IFilter filter, IWordReader wordReader)
{
this.filter = filter;
this.wordReader = wordReader;
}
public WordPreprocessor(IWordReader reader, IPreprocessingRule[] rules)
{
this.reader = reader;
this.rules = rules;
}
