public override IAnswer Process(IQuestionProcessingContext context)
{
var allStatements = context.SemanticNetwork.Statements.Enumerate(context.ActiveContexts);
IEnumerable <IStatement> statements;
var parentChild = Statement as IParentChild <IConcept>;
if (parentChild != null)
{
statements = allStatements.FindPath(Statement.GetType(), parentChild.Parent, parentChild.Child);
}
else
{
var statement = allStatements.FirstOrDefault(p => p.Equals(Statement));
statements = statement != null ? new[] { statement } : Array.Empty <IStatement>();
}
var result = new UnstructuredContainer();
System.Boolean isTrue = statements.Any();
result.Append(
language => Strings.ParamAnswer,
new Dictionary <String, IKnowledge> {
{ Strings.ParamAnswer, isTrue.ToLogicalValue() }
});
result.Append(isTrue ? Statement.DescribeTrue() : Statement.DescribeFalse());
return(new BooleanAnswer(
isTrue,
result,
new Explanation(statements)));
}
public virtual StringBuilder Represent(UnstructuredContainer text, ILanguage language)
{
return(representContainer(
text,
language,
(lineNumber, lineCount) => String.Empty));
}
private IText formatAnswer(
ICollection <IConcept> parents,
IDictionary <IConcept, Tuple <IConcept, IConcept> > signValueStatements)
{
var result = new UnstructuredContainer(new FormattedText(
language => language.GetExtension <ILanguageSetModule>().Questions.Answers.CompareConceptsResult,
new Dictionary <String, IKnowledge>
{
{ Strings.ParamConcept1, Concept1 },
{ Strings.ParamConcept2, Concept2 },
})).AppendBulletsList(parents.Enumerate());
if (signValueStatements.Count > 0)
{
foreach (var sign in signValueStatements)
{
WriteOneLine(result, sign.Key, sign.Value.Item1, sign.Value.Item2);
}
}
else
{
WriteNotEmptyResultWithoutData(result);
}
return(result);
}
public void CreateEmptyUnstructuredContainer()
{
// act
var container = new UnstructuredContainer();
// assert
Assert.AreEqual(0, container.Items.Count);
}
public static ITextContainer Append(this IText text1, IText text2)
{
var container = text1 as UnstructuredContainer;
if (container == null)
{
container = new UnstructuredContainer(text1);
}
return(container.Append(text2));
}
public static IText DescribeRules(this ISemanticNetwork semanticNetwork)
{
var result = new UnstructuredContainer();
foreach (var statement in semanticNetwork.Statements)
{
result.Append(statement.DescribeTrue());
}
return(result);
}
public virtual StringBuilder Represent(UnstructuredContainer text, ILanguage language)
{
return(representContainer(
text,
language,
String.Empty,
String.Empty,
String.Empty,
String.Empty));
}
public void CreateOneItemUnstructuredContainer()
{
// arrange
var item = new SpaceText();
// act
var container = new UnstructuredContainer(item);
// assert
Assert.AreSame(item, container.Items.Single());
}
private static StatementAnswer createAnswer(ComparisonStatement statement, IQuestionProcessingContext <ComparisonQuestion> context, ICollection <IStatement> transitiveStatements = null)
{
var resultStatement = statement.SwapOperandsToMatchOrder(context.Question);
var text = new UnstructuredContainer();
text.Append(resultStatement.DescribeTrue());
var explanation = transitiveStatements == null
? new Explanation(statement)
: new Explanation(transitiveStatements);
return(new StatementAnswer(resultStatement, text, explanation));
}
public void CreateManyItemsUnstructuredContainer()
{
// arrange
var items = new List <IText>
{
new SpaceText(),
new LineBreakText(),
new FormattedText(language => string.Empty),
};
// act
var container = new UnstructuredContainer(items);
// assert
Assert.IsTrue(items.SequenceEqual(container.Items));
}
public void EnsureAnyLevelOfTextBlockIsSupported(IStructuredTextRepresenter representer)
{
// arrange
string searchingToken = "QWERTY";
IText text = new FormattedText(language => searchingToken);
// act
for (int i = 0; i < 10; i++)
{
text = new UnstructuredContainer(text);
string representation = representer.Represent(text, Language.Default).ToString();
// assert
Assert.IsTrue(representation.Contains(searchingToken));
}
}
public static IText CheckConsistency(this ISemanticNetwork semanticNetwork)
{
var result = new UnstructuredContainer();
// 1. check all duplicates
checkStatementDuplicates(semanticNetwork, result);
// 2. check specific statements
foreach (var statementDefinition in Repositories.Statements.Definitions.Values)
{
statementDefinition.CheckConsistency(semanticNetwork, result);
}
if (result.Items.Count == 0)
{
result.Append(language => language.Statements.Consistency.CheckOk);
}
return(result);
}
public static IText GetDescriptionWithExplanation(this IAnswer answer)
{
if (answer.Explanation.Statements.Count > 0)
{
var explanedResult = new UnstructuredContainer(answer.Description);
explanedResult.AppendLineBreak();
explanedResult.Append(new Text.Primitives.FormattedText(language => language.Questions.Answers.Explanation));
foreach (var statement in answer.Explanation.Statements)
{
explanedResult.Append(statement.DescribeTrue());
}
return(explanedResult);
}
else
{
return(answer.Description);
}
}
private static StatementsAnswer <ProcessesStatement> createAnswer(ICollection <ProcessesStatement> statements, IQuestionProcessingContext <ProcessesQuestion> context, ICollection <IStatement> transitiveStatements = null)
{
var resultStatements = new HashSet <ProcessesStatement>();
var text = new UnstructuredContainer();
foreach (var statement in statements)
{
var resultStatement = statement.SwapOperandsToMatchOrder(context.Question);
if (resultStatements.All(s => s.SequenceSign != resultStatement.SequenceSign))
{
resultStatements.Add(resultStatement);
text.Append(resultStatement.DescribeTrue());
}
addStatementConsequences(resultStatements, resultStatement, context);
}
var explanation = transitiveStatements == null
? new Explanation(statements)
: new Explanation(transitiveStatements);
return(new StatementsAnswer <ProcessesStatement>(resultStatements, text, explanation));
}
public IAnswer SelectAllConcepts(
Func <StatementT, IConcept> resultConceptSelector,
Func <QuestionT, IConcept> titleConceptSelector,
String titleConceptCaption,
Func <ILanguage, String> answerFormat,
Func <IEnumerable <IConcept>, IEnumerable <IConcept> > conceptsFilter = null)
{
ProcessChildrenIfNeed();
if (Statements.Any())
{
if (conceptsFilter == null)
{
conceptsFilter = concepts => concepts;
}
var resultConcepts = conceptsFilter(Statements.Select(resultConceptSelector)).ToList();
var format = new UnstructuredContainer(new FormattedText(
language => answerFormat(Context.Language),
new Dictionary <String, IKnowledge>
{
{ titleConceptCaption, titleConceptSelector(Context.Question) },
})).AppendBulletsList(resultConcepts.Enumerate());
var answer = new ConceptsAnswer(
resultConcepts,
format,
new Explanation(Statements.OfType <IStatement>()));
answer.Explanation.Expand(AdditionalTransitives);
return(answer);
}
else
{
return(Answer.CreateUnknown());
}
}
public void CheckTypedToUntypedAndViceVersaTransformations()
{
// arrange
var concept1 = ConceptCreationHelper.CreateConcept();
var concept2 = ConceptCreationHelper.CreateConcept();
var resultStatementsTyped = new IsStatement[]
{
new IsStatement(null, concept1, concept2),
new IsStatement(null, concept2, concept1),
};
var resultStatementsUntyped = resultStatementsTyped.OfType <IStatement>().ToArray();
var text = new UnstructuredContainer();
var explanationStatements = new IStatement[]
{
new HasPartStatement(null, concept1, concept2),
new HasPartStatement(null, concept2, concept1),
};
var typedAnswer = new StatementsAnswer <IsStatement>(resultStatementsTyped, text, new Explanation(explanationStatements));
var untypedAnswer = new StatementsAnswer(resultStatementsUntyped, text, new Explanation(explanationStatements));
// act
var genericAnswer = typedAnswer.MakeGeneric();
var explicitAnswer = untypedAnswer.MakeExplicit <IsStatement>();
// assert
Assert.IsTrue(typedAnswer.Result.SequenceEqual(explicitAnswer.Result));
Assert.IsTrue(typedAnswer.Explanation.Statements.SequenceEqual(explicitAnswer.Explanation.Statements));
Assert.IsTrue(untypedAnswer.Result.SequenceEqual(genericAnswer.Result));
Assert.IsTrue(untypedAnswer.Explanation.Statements.SequenceEqual(genericAnswer.Explanation.Statements));
}
