public ElementBuilder AddLinkedConcept(IConcept concept) { throw new NotImplementedException(); //LinkedConceptsInternal.Add(concept); //return this; }
public void Update(String id, IConcept leftValue, IConcept rightValue, IConcept comparisonSign) { if (leftValue == null) { throw new ArgumentNullException(nameof(leftValue)); } if (rightValue == null) { throw new ArgumentNullException(nameof(rightValue)); } if (comparisonSign == null) { throw new ArgumentNullException(nameof(comparisonSign)); } if (!leftValue.HasAttribute <IsValueAttribute>()) { throw new ArgumentException("Left value concept has to be marked as IsValue Attribute.", nameof(leftValue)); } if (!rightValue.HasAttribute <IsValueAttribute>()) { throw new ArgumentException("Right value concept has to be marked as IsValue Attribute.", nameof(rightValue)); } if (!comparisonSign.HasAttribute <IsComparisonSignAttribute>()) { throw new ArgumentException("Comparison Sign concept has to be marked as IsComparisonSign Attribute.", nameof(comparisonSign)); } Update(id); LeftValue = leftValue; RightValue = rightValue; ComparisonSign = comparisonSign; }
public Relation([NotNull] IConcept from, [NotNull] IConcept to, Relationship relationship) { if (from == null) { throw new ArgumentNullException(nameof(from)); } if (to == null) { throw new ArgumentNullException(nameof(to)); } if (relationship == Relationship.Unknown) { throw new ArgumentException($"Concepts cannot be related using the unknown relationship."); } if (from == to) { throw new ArgumentException($"A concept may not be related to itself: {from.Name}"); } From = from; Relationship = relationship; To = to; }
private IEnumerable <NestedQuestion> GetNestedQuestions(IQuestionProcessingContext <ComparisonQuestion> context) { foreach (var statement in context.SemanticNetwork.Statements.Enumerate <ComparisonStatement>(context.ActiveContexts)) { IConcept newLeftValue = null; if (statement.LeftValue == LeftValue) { newLeftValue = statement.RightValue; } else if (statement.RightValue == LeftValue) { newLeftValue = statement.LeftValue; } if (newLeftValue != null) { var involvedValues = new HashSet <IConcept>(context.ActiveContexts .OfType <IQuestionProcessingContext <ComparisonQuestion> >() .Select(c => c.Question.LeftValue)); if (!involvedValues.Contains(newLeftValue)) { yield return(new NestedQuestion(new ComparisonQuestion(newLeftValue, RightValue), new IStatement[] { statement })); } } } }
public static SignValueStatement IsSignValue(this StatementBuilder builder, IConcept concept, IConcept sign) { var statement = new SignValueStatement(null, concept, sign, builder.Subject); builder.SemanticNetwork.Statements.Add(statement); return(statement); }
public void AddRelation(IConcept descendant, IConcept ancestor, Relationship relationship) { if (descendant == null) { throw new ArgumentNullException(nameof(descendant)); } if (ancestor == null) { throw new ArgumentNullException(nameof(ancestor)); } var relation = new Relation(descendant, ancestor, relationship); var key = (string.Compare(descendant.Name, ancestor.Name, StringComparison.InvariantCultureIgnoreCase) > 0)? $"{ancestor.Name}\0${descendant.Name}": $"{descendant.Name}\0${ancestor.Name}"; // Needs lock and backout if (_relations.TryAdd(key, relation)) { descendant.Relations.Add(relation); ancestor.Relations.Add(relation); } else { throw new StateException($"Relation between {descendant.Name} and {ancestor.Name} already exists."); } }
public static HasSignStatement IsSignOf(this StatementBuilder builder, IConcept concept) { var statement = new HasSignStatement(null, concept, builder.Subject); builder.SemanticNetwork.Statements.Add(statement); return(statement); }
public static HasPartStatement IsPartOf(this StatementBuilder builder, IConcept whole) { var statement = new HasPartStatement(null, whole, builder.Subject); builder.SemanticNetwork.Statements.Add(statement); return(statement); }
public static HasSignStatement HasSign(this StatementBuilder builder, IConcept sign) { var statement = new HasSignStatement(null, builder.Subject, sign); builder.SemanticNetwork.Statements.Add(statement); return(statement); }
public static GroupStatement IsSubjectAreaOf(this StatementBuilder builder, IConcept concept) { var statement = new GroupStatement(null, builder.Subject, concept); builder.SemanticNetwork.Statements.Add(statement); return(statement); }
public static HasPartStatement HasPart(this StatementBuilder builder, IConcept part) { var statement = new HasPartStatement(null, builder.Subject, part); builder.SemanticNetwork.Statements.Add(statement); return(statement); }
public void Update(String id, IConcept concept, IConcept sign, IConcept value) { if (concept == null) { throw new ArgumentNullException(nameof(concept)); } if (sign == null) { throw new ArgumentNullException(nameof(sign)); } if (value == null) { throw new ArgumentNullException(nameof(value)); } if (!sign.HasAttribute <IsSignAttribute>()) { throw new ArgumentException("Sign concept has to be marked as IsSign Attribute.", nameof(sign)); } if (!value.HasAttribute <IsValueAttribute>()) { throw new ArgumentException("Value concept has to be marked as IsValue Attribute.", nameof(value)); } Update(id); Concept = concept; Sign = sign; Value = value; }
private System.Boolean isCyclic(IEnumerable <IsStatement> allClasifications, IConcept concept, List <IConcept> chain) { if (chain.Contains(concept)) { return(true); } var clasifications = allClasifications.Where(c => c.Descendant == concept).ToList(); if (clasifications.Count == 0) { return(false); } else { foreach (var clasification in clasifications) { if (isCyclic(allClasifications, clasification.Ancestor, new List <IConcept>(chain) { clasification.Descendant })) { return(true); } } return(false); } }
protected Boolean SetCombination(IConcept left, IConcept right, IConcept sign) { Boolean updated = false; // get "row" using LEFT value as key, return true if row is added Dictionary <IConcept, HashSet <IConcept> > combinations; if (!AllSigns.TryGetValue(left, out combinations)) { AllSigns[left] = combinations = new Dictionary <IConcept, HashSet <IConcept> >(); updated = true; } // get "column" using RIGHT value as key, return true if column is added HashSet <IConcept> signs; if (!combinations.TryGetValue(right, out signs)) { combinations[right] = signs = new HashSet <IConcept>(); updated = true; } // add value to list, return true if added (= new unique) Int32 countBefore = signs.Count; signs.Add(sign); if (signs.Count > countBefore) { updated = true; } return(updated); }
public static IConcept CompareThreeValues(IConcept firstSign, IConcept secondSign) { ensureSuits(firstSign); ensureSuits(secondSign); if (firstSign == IsEqualTo) { return(secondSign); } else if (secondSign == IsEqualTo) { return(firstSign); } else if ((secondSign == IsGreaterThan || secondSign == IsGreaterThanOrEqualTo) && (firstSign == IsGreaterThan || firstSign == IsGreaterThanOrEqualTo)) { return((secondSign == IsGreaterThanOrEqualTo && firstSign == IsGreaterThanOrEqualTo) ? IsGreaterThanOrEqualTo : IsGreaterThan); } else if ((secondSign == IsLessThan || secondSign == IsLessThanOrEqualTo) && (firstSign == IsLessThan || firstSign == IsLessThanOrEqualTo)) { return((secondSign == IsLessThanOrEqualTo && firstSign == IsLessThanOrEqualTo) ? IsLessThanOrEqualTo : IsLessThan); } else { return(null); } }
public Concept(IConcept concept) { Name = new LocalizedString(concept.Name); Hint = new LocalizedString(concept.Hint); Attributes = concept.Attributes.Select(a => Attribute.Save(a)).ToList(); ID = concept.ID; }
public static IsStatement IsAncestorOf(this StatementBuilder builder, IConcept descendant) { var statement = new IsStatement(null, builder.Subject, descendant); builder.SemanticNetwork.Statements.Add(statement); return(statement); }
public static ICollection <IConcept> Consequently(this IConcept sign) { ensureSuits(sign); if (sign == StartsBeforeOtherStarted) { return(new[] { StartsBeforeOtherFinished }); } else if (sign == FinishesBeforeOtherStarted) { return(new[] { StartsBeforeOtherStarted, StartsBeforeOtherFinished, FinishesBeforeOtherFinished }); } else if (sign == StartsAfterOtherFinished) { return(new[] { FinishesAfterOtherFinished, FinishesAfterOtherStarted, StartsAfterOtherStarted }); } else if (sign == FinishesAfterOtherFinished) { return(new[] { FinishesAfterOtherStarted }); } else { return(Array.Empty <IConcept>()); } }
private static void ensureSuits(this IConcept value) { if (!All.Contains(value)) { throw new InvalidOperationException("This method can work only with logical values."); } }
public void ConceptWithSubjectAreaCanFindIt() { // arrange var language = Language.Default; var semanticNetwork = new TestSemanticNetwork(language); IList <IConcept> subjectAreas = new IConcept[] { semanticNetwork.SubjectArea_Transport, semanticNetwork.SubjectArea_Numbers, semanticNetwork.SubjectArea_Processes, }; var conceptsWithoutSubjectArea = new List <IConcept>(SystemConcepts.GetAll()); conceptsWithoutSubjectArea.AddRange(subjectAreas); foreach (var concept in semanticNetwork.SemanticNetwork.Concepts.Except(conceptsWithoutSubjectArea)) { // act var answer = semanticNetwork.SemanticNetwork.Ask().ToWhichSubjectAreasBelongs(concept); // assert Assert.IsFalse(answer.IsEmpty); var groupStatement = (GroupStatement)answer.Explanation.Statements.Single(); Assert.IsTrue(subjectAreas.Contains(groupStatement.Area)); Assert.AreSame(concept, groupStatement.Concept); var conceptsAnswer = (ConceptsAnswer)answer; Assert.AreSame(groupStatement.Area, conceptsAnswer.Result.Single()); } }
public static ComparisonStatement IsEqualTo(this StatementBuilder builder, IConcept other) { var statement = new ComparisonStatement(null, builder.Subject, other, ComparisonSigns.IsEqualTo); builder.SemanticNetwork.Statements.Add(statement); return(statement); }
public bool IsDescendantOf([NotNull] IConcept ancestor) { var cache = new HashSet <IConcept>(); var stack = new Stack <IConcept>(); IConcept candidate = this; var result = false; while (candidate != null) { if (!cache.Contains(candidate)) { if (candidate == ancestor) { result = true; break; } cache.Add(candidate); foreach (var target in candidate.Relations.Where(r => r.Relationship == Relationship.Parent).Select(r => r.To)) { stack.Push(target); } } candidate = stack.Count == 0? null: stack.Pop(); } return(result); }
public void Update(String id, IConcept processA, IConcept processB, IConcept sequenceSign) { if (processA == null) { throw new ArgumentNullException(nameof(processA)); } if (processB == null) { throw new ArgumentNullException(nameof(processB)); } if (sequenceSign == null) { throw new ArgumentNullException(nameof(sequenceSign)); } if (!processA.HasAttribute <IsProcessAttribute>()) { throw new ArgumentException("Process A concept has to be marked as IsProcess Attribute.", nameof(processA)); } if (!processB.HasAttribute <IsProcessAttribute>()) { throw new ArgumentException("Process B concept has to be marked as IsProcess Attribute.", nameof(processB)); } if (!sequenceSign.HasAttribute <IsSequenceSignAttribute>()) { throw new ArgumentException("Sequence Sign concept has to be marked as IsSequenceSign Attribute.", nameof(sequenceSign)); } Update(id); ProcessA = processA; ProcessB = processB; SequenceSign = sequenceSign; }
public static ProcessesStatement IsCausedBy(this StatementBuilder builder, IConcept other) { var statement = new ProcessesStatement(null, builder.Subject, other, SequenceSigns.IsCausedBy); builder.SemanticNetwork.Statements.Add(statement); return(statement); }
public static IConcept Revert(this IConcept sign) { ensureSuits(sign); if (sign == IsGreaterThanOrEqualTo) { return(IsLessThanOrEqualTo); } else if (sign == IsGreaterThan) { return(IsLessThan); } else if (sign == IsLessThanOrEqualTo) { return(IsGreaterThanOrEqualTo); } else if (sign == IsLessThan) { return(IsGreaterThan); } else { return(sign); } }
private static void ensureSuits(this IConcept sign) { if (!All.Contains(sign)) { throw new InvalidOperationException("This method can work only with comparison signs."); } }
public IsStatement(String id, IConcept ancestor, IConcept descendant) : base( id, new Func <ILanguage, String>(language => language.GetExtension <ILanguageClassificationModule>().Statements.Names.Clasification), new Func <ILanguage, String>(language => language.GetExtension <ILanguageClassificationModule>().Statements.Hints.Clasification)) { Update(id, ancestor, descendant); }
public ComparisonStatement(String id, IConcept leftValue, IConcept rightValue, IConcept comparisonSign) : base( id, new Func <ILanguage, String>(language => language.GetExtension <ILanguageMathematicsModule>().Statements.Names.Comparison), new Func <ILanguage, String>(language => language.GetExtension <ILanguageMathematicsModule>().Statements.Hints.Comparison)) { Update(id, leftValue, rightValue, comparisonSign); }
public static IConcept WithAttributes(this IConcept concept, IEnumerable <IAttribute> attributes) { foreach (var attribute in attributes) { concept.Attributes.Add(attribute); } return(concept); }
public FormMovie35(IConcept Concept) { InitializeComponent(); this.concept = Concept; lbxMovie.DataSource = concept.getAllMovies(); lbxActor.DataSource = concept.getAllActors(); }
public CustomStatement(string id, IConcept concept1, IConcept concept2) : base( id, new Func <ILanguage, string>(language => language.GetExtension <ILanguageCustomModule>().Statements.Names.Custom), new Func <ILanguage, string>(language => language.GetExtension <ILanguageCustomModule>().Statements.Hints.Custom)) { Update(id, concept1, concept2); }
public virtual bool AreEqual(IConceptModel model, IConcept entity) { return NameableEntityMapper.AreEqual(model, entity) // Concept Properties && model.StartYear == entity.StartYear // Related Objects && model.PrimaryImageFileId == entity.PrimaryImageFileId && model.FirstIssueAppearanceId == entity.FirstIssueAppearanceId ; }
public virtual void MapToEntity(IConceptModel model, ref IConcept entity, int currentDepth = 1) { currentDepth++; // Assign Base properties NameableEntityMapper.MapToEntity(model, ref entity); // Concept Properties entity.StartYear = model.StartYear; // Related Objects entity.PrimaryImageFileId = model.PrimaryImageFileId; entity.PrimaryImageFile = (ImageFile)model.PrimaryImageFile?.MapToEntity(); entity.FirstIssueAppearanceId = model.FirstIssueAppearanceId; entity.FirstIssueAppearance = (Issue)model.FirstIssueAppearance?.MapToEntity(); // Associated Objects entity.ConceptAliases = model.ConceptAliases?.Where(i => i.Active).Select(ConceptAliasMapperExtensions.MapToEntity).ToList(); entity.ConceptIssuesAppearedIn = model.ConceptIssuesAppearedIn?.Where(i => i.Active).Select(ConceptAppearedInIssueMapperExtensions.MapToEntity).ToList(); entity.ConceptIssues = model.ConceptIssues?.Where(i => i.Active).Select(ConceptIssueMapperExtensions.MapToEntity).ToList(); entity.ConceptMovies = model.ConceptMovies?.Where(i => i.Active).Select(ConceptMovieMapperExtensions.MapToEntity).ToList(); entity.ConceptVolumes = model.ConceptVolumes?.Where(i => i.Active).Select(ConceptVolumeMapperExtensions.MapToEntity).ToList(); }
public virtual IConceptModel MapToModel(IConcept entity, int currentDepth = 1) { currentDepth++; var model = NameableEntityMapper.MapToModel<IConcept, ConceptModel>(entity); // Concept Properties model.StartYear = entity.StartYear; // Related Objects model.PrimaryImageFileId = entity.PrimaryImageFileId; model.PrimaryImageFile = entity.PrimaryImageFile?.MapToModel(); model.FirstIssueAppearanceId = entity.FirstIssueAppearanceId; model.FirstIssueAppearance = entity.FirstIssueAppearance?.MapToModel(); // Associated Objects model.ConceptAliases = entity.ConceptAliases?.Where(i => i.Active).Select(ConceptAliasMapperExtensions.MapToModelLite).ToList(); model.ConceptIssuesAppearedIn = entity.ConceptIssuesAppearedIn?.Where(i => i.Active).Select(ConceptAppearedInIssueMapperExtensions.MapToModelLite).ToList(); model.ConceptIssues = entity.ConceptIssues?.Where(i => i.Active).Select(ConceptIssueMapperExtensions.MapToModelLite).ToList(); model.ConceptMovies = entity.ConceptMovies?.Where(i => i.Active).Select(ConceptMovieMapperExtensions.MapToModelLite).ToList(); model.ConceptVolumes = entity.ConceptVolumes?.Where(i => i.Active).Select(ConceptVolumeMapperExtensions.MapToModelLite).ToList(); // Return Entity return model; }
public static void MapToEntity(this IConceptModel model, ref IConcept entity, int currentDepth = 1) { Mapper.MapToEntity(model, ref entity, currentDepth); }
public static bool AreEqual(this IConceptModel model, IConcept entity) { return Mapper.AreEqual(model, entity); }
public virtual IConceptModel MapToModelLite(IConcept entity, int currentDepth = 1) { currentDepth++; var model = NameableEntityMapper.MapToModelLite<IConcept, ConceptModel>(entity); // Concept Properties model.StartYear = entity.StartYear; // Related Objects model.PrimaryImageFileId = entity.PrimaryImageFileId; model.FirstIssueAppearanceId = entity.FirstIssueAppearanceId; // Return Entity return model; }
public void Update(IConcept entity) { Context.SetModified(entity); }
protected bool Remove(IConcept entity) { if (entity == null) { return true; } // No entity found to remove, consider it passed // Remove it ConceptsRepository.Remove(entity); // Try to Save Changes ConceptsRepository.SaveChanges(); // Finished! return true; }
public void Deactivate(IConcept entity) { entity.Active = false; Update(entity); }
public void Remove(IConcept entity) { Context.Concepts.Remove((Concept)entity); }
protected bool Deactivate(IConcept entity) { // Deactivate it ConceptsRepository.Deactivate(entity); // Try to Save Changes ConceptsRepository.SaveChanges(); // Finished! return true; }
public void Add(IConcept entity) { Context.Concepts.Add((Concept)entity); }