public static KinshipRet FindKinship(RelationKind prev, RelationKind cur) { RelationKind finRel = RelationKind.rkUndefined; int great = 0; int level = 0; int num = fKinships.Count; for (int i = 0; i < num; i++) { KinshipRec kinship = fKinships[i]; if (kinship.PrevRels.Contains(prev) && kinship.CurrRels.Contains(cur)) { RelationKind rel = kinship.FinRel; great = kinship.Great; level = kinship.Level; if (rel == RelationKind.rkSame) { rel = cur; } finRel = rel; } } return(new KinshipRet(finRel, great, level)); }
private void DispatchAction(RelationKind work, Action succeeded, Action <Exception> failed) { this.IsCommunicating = true; RequestQueue.EnqueueObservable(_source, new UpdateRelationRequest(_target, work)) .Finally(() => this.IsCommunicating = false) .Subscribe(_ => { }, failed, succeeded); }
public bool HasChangedRoles(Object derivable, RelationKind relationKind) { Func <IRoleType, bool> check; switch (relationKind) { case RelationKind.Regular: check = (roleType) => !roleType.RelationType.IsDerived && !roleType.RelationType.IsSynced; break; case RelationKind.Derived: check = (roleType) => roleType.RelationType.IsDerived; break; case RelationKind.Synced: check = (roleType) => roleType.RelationType.IsSynced; break; default: check = (roleType) => true; break; } this.RoleTypesByAssociation.TryGetValue(derivable.Id, out var changedRoleTypes); if (changedRoleTypes != null) { if (changedRoleTypes.Any(roleType => check(roleType))) { return(true); } } return(false); }
private static void SearchKGInt(IBaseContext context, Vertex prevNode, GDMIndividualRecord iRec, KinshipsGraph graph, RelationKind relation, RelationKind inverseRelation) { if (iRec == null) { return; } Vertex currNode = graph.FindVertex(iRec.XRef); if (currNode != null) { if (prevNode != null) { graph.AddRelation(prevNode, currNode, relation, inverseRelation); } return; } else { currNode = graph.AddIndividual(iRec); if (prevNode != null) { graph.AddRelation(prevNode, currNode, relation, inverseRelation); } } if (iRec.ChildToFamilyLinks.Count > 0) { GDMFamilyRecord fam = context.Tree.GetParentsFamily(iRec); if (fam != null) { GDMIndividualRecord father, mother; father = context.Tree.GetPtrValue(fam.Husband); mother = context.Tree.GetPtrValue(fam.Wife); SearchKGInt(context, currNode, father, graph, RelationKind.rkParent, RelationKind.rkChild); SearchKGInt(context, currNode, mother, graph, RelationKind.rkParent, RelationKind.rkChild); } } int num = iRec.SpouseToFamilyLinks.Count; for (int i = 0; i < num; i++) { GDMFamilyRecord family = context.Tree.GetPtrValue(iRec.SpouseToFamilyLinks[i]); GDMIndividualRecord spouse = (iRec.Sex == GDMSex.svMale) ? context.Tree.GetPtrValue(family.Wife) : context.Tree.GetPtrValue(family.Husband); SearchKGInt(context, currNode, spouse, graph, RelationKind.rkSpouse, RelationKind.rkSpouse); int num2 = family.Children.Count; for (int j = 0; j < num2; j++) { GDMIndividualRecord child = context.Tree.GetPtrValue(family.Children[j]); SearchKGInt(context, currNode, child, graph, RelationKind.rkChild, RelationKind.rkParent); } } }
private static void SearchKGInt(Vertex prevNode, GEDCOMIndividualRecord iRec, KinshipsGraph graph, RelationKind relation, RelationKind inverseRelation) { if (iRec == null) { return; } Vertex currNode = graph.FindVertex(iRec.XRef); if (currNode != null) { if (prevNode != null) { graph.AddRelation(prevNode, currNode, relation, inverseRelation); } return; } else { currNode = graph.AddIndividual(iRec); if (prevNode != null) { graph.AddRelation(prevNode, currNode, relation, inverseRelation); } } if (iRec.ChildToFamilyLinks.Count > 0) { GEDCOMFamilyRecord fam = iRec.GetParentsFamily(); if (fam != null) { GEDCOMIndividualRecord father, mother; father = fam.GetHusband(); mother = fam.GetWife(); SearchKGInt(currNode, father, graph, RelationKind.rkParent, RelationKind.rkChild); SearchKGInt(currNode, mother, graph, RelationKind.rkParent, RelationKind.rkChild); } } int num = iRec.SpouseToFamilyLinks.Count; for (int i = 0; i < num; i++) { GEDCOMFamilyRecord family = iRec.SpouseToFamilyLinks[i].Family; GEDCOMIndividualRecord spouse = ((iRec.Sex == GEDCOMSex.svMale) ? family.GetWife() : family.GetHusband()); SearchKGInt(currNode, spouse, graph, RelationKind.rkSpouse, RelationKind.rkSpouse); int num2 = family.Children.Count; for (int j = 0; j < num2; j++) { GEDCOMIndividualRecord child = (GEDCOMIndividualRecord)family.Children[j].Value; SearchKGInt(currNode, child, graph, RelationKind.rkChild, RelationKind.rkParent); } } }
/// <summary> /// 构造函数 /// </summary> /// <param name="masterTableMapping">主关联表的映射</param> /// <param name="relateTableType">关联类型</param> /// <param name="relationName">关联名</param> public RelationFieldMapping(DataEntityMapping masterTableMapping, Type relateTableType, string relationName) { _masterTableMapping = masterTableMapping; _relationName = relationName; if (relateTableType.IsArray) { _relationTableType = relateTableType.GetElementType(); _relationKind = RelationKind.OneToMany; _resultDataKind = DataKind.Array; } else if (relateTableType.IsGenericType) { Type frameType = relateTableType.GetGenericTypeDefinition(); if (frameType.FullName != "System.Collections.Generic.IList`1") { throw new LightDataException(RE.TheRelationTypeNotIList); } else { Type[] arguments = relateTableType.GetGenericArguments(); _relationTableType = arguments [0]; _relationKind = RelationKind.OneToMany; _resultDataKind = DataKind.IList; } } else { _relationTableType = relateTableType; _relationKind = RelationKind.OneToOne; _resultDataKind = DataKind.SingleObject; } }
public KinshipRec(EnumSet <RelationKind> prevRels, EnumSet <RelationKind> currRels, RelationKind finRel, short great, short level) { PrevRels = prevRels; CurrRels = currRels; FinRel = finRel; Great = great; Level = level; }
public NodeRelation(RelationKind relationKind, Node node1, Node node2) { this.RelationKind = relationKind; this.Node1 = node1; this.Node2 = node2; if (node1 == node2) { throw new InvalidOperationException("Node relation cannot have the same node on both sides."); } }
public Relation(string name) : base(name) { var(kind, relatedEntityType) = DetectDependentRelation() ?? DetectOptionalRelation() ?? DetectMultipleRelation() ?? throw new InvalidOperationException($"Unable to determine relation kind for {this}"); _kind = kind; _relatedEntity = Entity.GetDescriptorFromType(relatedEntityType); }
public RelatedToAttribute(Type left, Type right, RelationKind kind) { this.Settings = new RelationshipSettings { LeftModelName = left.Name, RightModelName = right.Name, LeftClrName = left.FullName, RightClrName = right.FullName, Kind = kind }; }
private static RelationKind FixLink(GDMIndividualRecord xFrom, GDMIndividualRecord xTo, RelationKind rel) { RelationKind resRel = rel; switch (rel) { case RelationKind.rkParent: switch (xTo.Sex) { case GDMSex.svMale: resRel = RelationKind.rkFather; break; case GDMSex.svFemale: resRel = RelationKind.rkMother; break; } break; case RelationKind.rkSpouse: switch (xTo.Sex) { case GDMSex.svMale: resRel = RelationKind.rkHusband; break; case GDMSex.svFemale: resRel = RelationKind.rkWife; break; } break; case RelationKind.rkChild: switch (xTo.Sex) { case GDMSex.svMale: resRel = RelationKind.rkSon; break; case GDMSex.svFemale: resRel = RelationKind.rkDaughter; break; } break; default: resRel = rel; break; } return(resRel); }
protected Relation( TypeReference source, MethodDefinition targetMettod, TypeReference target, MethodReference sourceMethod, Instruction op, int offset, RelationKind kind) { Source = source; SourceMethod = sourceMethod; Target = target; TargetMethod = targetMettod; Kind = kind; Op = op; Offset = offset; }
private void MapRelation(PropertyInfo property, Type relatedResourceType, RelationKind kind) { var name = property.GetJsonPropertyName(); if (!_properties.ContainsKey(name)) { throw new ArgumentException($"Property with JSON name {name} not found. Did you call {nameof(IgnoreProperty)} on the property?"); } if (_relations.ContainsKey(name)) { throw new ArgumentException($"Relation property with JSON name {name} already mapped", nameof(property)); } _relations.Add(name, new RelationInfo(property, relatedResourceType, kind)); }
private static string FixRelation(GDMIndividualRecord target, RelationKind rel, int great) { string tmp = ""; if (great != 0) { if (rel == RelationKind.rkUncle || rel == RelationKind.rkAunt) { tmp = GKData.Numerals[great] + GKData.NumKinship[(int)target.Sex] + " "; if (rel == RelationKind.rkUncle) { rel = RelationKind.rkGrandfather; } else if (rel == RelationKind.rkAunt) { rel = RelationKind.rkGrandmother; } } else if (rel == RelationKind.rkNephew || rel == RelationKind.rkNiece) { tmp = GKData.Numerals[great] + GKData.NumKinship[(int)target.Sex] + " "; if (rel == RelationKind.rkNephew) { rel = RelationKind.rkBrother; } else if (rel == RelationKind.rkNiece) { rel = RelationKind.rkSister; } } else { if (rel != RelationKind.rkUndefined) { tmp = GetGreat(great); } } } else { tmp = ""; } return(tmp + LangMan.LS(GKData.RelationKinds[(int)rel])); }
internal static Relation MethodCall(TypeDefinition type, MethodDefinition method, TypeReference targetType, MethodReference targetMethod) { var resolvedMethod = targetMethod.SmartResolve(); RelationKind kind = RelationKind.MethodCall; if (resolvedMethod != null) { if (resolvedMethod.IsConstructor) { kind = RelationKind.Construction; } if (resolvedMethod.IsGetter) { kind = RelationKind.MethodCallImmutable; } } return(new Relation(type, method, targetType, targetMethod, null, 0, kind)); }
public PreferenceFileReader(string filename, RelationKind relationKind) { fileName = filename; ClassRelations = new Dictionary<string, HashSet<string>>(); SetInRelationFunc(relationKind); }
public RelationInfo(PropertyInfo propertyInfo, Type relatedResourceType, RelationKind kind) { PropertyInfo = propertyInfo; ResourceType = relatedResourceType; Kind = kind; }
private static void RegisterKinship(RelationSet prevRels, RelationSet currRels, RelationKind finRel, sbyte great, sbyte level) { fKinships.Add(new KinshipRec(prevRels, currRels, finRel, great, level)); }
internal KinshipRet(RelationKind finRel, int great, int level) { FinRel = finRel; Great = great; Level = level; }
public TypeRelation(TypeDefinition usingType, TypeReference usedType, RelationKind kind) : base(usingType, null, usedType, null, null, 0, kind) { }
/// <summary> /// /// </summary> /// <param name="source"></param> /// <param name="target"></param> /// <param name="tsRel">target to source relation (if target is parent of source = Parent)</param> /// <param name="stRel">source to target relation (if target is parent of source = Child)</param> /// <returns></returns> public bool AddRelation(Vertex source, Vertex target, RelationKind tsRel, RelationKind stRel) { return(fGraph.AddUndirectedEdge(source, target, 1, (int)tsRel, (int)stRel)); }
private string GetRelationPart(GDMIndividualRecord ind1, GDMIndividualRecord ind2, RelationKind xrel, int great) { if (ind1 == null || ind2 == null) { return("???"); } string rel = FixRelation(ind2, xrel, great); string name1 = fContext.Culture.GetPossessiveName(ind1); string name2 = GKUtils.GetNameString(ind2, true, false); rel = string.Format(LangMan.LS(LSID.LSID_RelationshipMask), name2, rel, name1); return(rel); }
private void _addRelation(string name, RelationKind kind, bool isEnabled, bool isInitiallyExpanded, IEnumerable<BplClass> classes) { var targetClasses = classes.Where(c => c != Class).ToArray(); if (targetClasses.Length > 0) { Children.Add(new RelationNode(this, name, kind, isEnabled, isInitiallyExpanded, targetClasses)); } }
static string RelationKindToArrow(RelationKind relationKind) => relationKind switch {
public UpdateRelationRequest(long userId, RelationKind kind) { _userId = userId; _kind = kind; }
public UpdateRelationRequest(TwitterUser target, RelationKind kind) : this(target.Id, kind) { }
public string GetRelationship(GDMIndividualRecord targetRec, bool fullFormat = false) { if (targetRec == null) { return("???"); } Vertex target = fGraph.FindVertex(targetRec.XRef); if (target == null) { return("???"); } try { IEnumerable <Edge> edgesPath = fGraph.GetPath(target); string tmp = ""; RelationKind prevRel = RelationKind.rkNone; RelationKind finRel = RelationKind.rkNone; int great = 0; GDMIndividualRecord src = null, tgt = null, prev_tgt = null; string part, fullRel = ""; foreach (Edge edge in edgesPath) { GDMIndividualRecord xFrom = (GDMIndividualRecord)edge.Source.Value; GDMIndividualRecord xTo = (GDMIndividualRecord)edge.Target.Value; RelationKind curRel = FixLink(xFrom, xTo, (RelationKind)((int)edge.Value)); if (src == null) { src = xFrom; } prev_tgt = tgt; tgt = xTo; if (tmp != "") { tmp += ", "; } tmp += xFrom.XRef + ">" + GKData.RelationSigns[(int)curRel] + ">" + xTo.XRef; if (prevRel != RelationKind.rkUndefined) { int g, lev; finRel = KinshipsMan.FindKinship(prevRel, curRel, out g, out lev); great += g; // it's gap if (finRel == RelationKind.rkUndefined && fullFormat) { part = GetRelationPart(src, prev_tgt, prevRel, great); src = prev_tgt; great = 0; prevRel = RelationKind.rkNone; if (fullRel.Length > 0) { fullRel += ", "; } fullRel += part; finRel = KinshipsMan.FindKinship(prevRel, curRel, out g, out lev); great += g; } prevRel = finRel; } } IndividualsPath = targetRec.XRef + " [" + tmp + "]"; if (!fullFormat) { string relRes = FixRelation(targetRec, finRel, great); return(relRes); } else { part = GetRelationPart(src, tgt, finRel, great); if (fullRel.Length > 0) { fullRel += ", "; } fullRel += part; return(fullRel); } } catch (Exception ex) { Logger.WriteError("KinshipsGraph.GetRelationship()", ex); return(""); } }
private void _addPrecedents(string name, RelationKind kind, bool isEnabled, bool isInitiallyExpanded, Func<BplProperty, bool> cond) { var precedents = Class.UsedBy.Where(p => cond(p)).Select(p => p.Class).Distinct().OrderBy(c => c.Name); _addRelation(name, kind, isEnabled, isInitiallyExpanded, precedents); }
// Constructor public RelationNode(SourceNode parent, string name, RelationKind kind, bool isEnabled, bool isInitiallyExpanded, IEnumerable<BplClass> targetClasses) { IsEnabled = isEnabled; IsInitiallyExpanded = isInitiallyExpanded; Kind = kind; Name = name; Parent = parent; Children = new List<TargetNode>(); foreach (var c in targetClasses) { Children.Add(new TargetNode(this, isEnabled, c)); } UpdateSelection(true); }
private void DispatchAction(RelationKind work, Action succeeded, Action<Exception> failed) { this.IsCommunicating = true; RequestQueue.Enqueue(_source, new UpdateRelationRequest(_target, work)) .Finally(() => this.IsCommunicating = false) .Subscribe(_ => { }, failed, succeeded); }
public BaseRelation(Type type, RelationKind kind, Type relationWith) { Type = type; Kind = kind; RelationWith = relationWith; }
private void SetInRelationFunc(RelationKind relationKind) { switch (relationKind) { case RelationKind.Strict: inRelationFunc = AreInStrictRelation; break; case RelationKind.NonStrict: inRelationFunc = AreInNonStrictRelation; break; case RelationKind.Equal: inRelationFunc = AreInEqualRelation; break; default: throw new ArgumentOutOfRangeException("relationKind"); } }
private void _addDependents(string name, RelationKind kind, bool isEnabled, bool isInitiallyExpanded, Func<BplProperty, bool> cond) { var inherit = Diagram.DisplayOptions.Has(DisplayOptions.DisplayInheritedMembers); var properties = (inherit ? Class.Properties : Class.OwnProperties); if (Class.Operation != null) { var output = Class.Operation.Output; if (output != null) { properties = properties.Union(inherit ? output.Properties : output.OwnProperties); } } var dependents = properties.Where(p => cond(p)).Select(p => p.ReferencedClass).Distinct().OrderBy(c => c.Name); _addRelation(name, kind, isEnabled, isInitiallyExpanded, dependents); }
public CsvDataFileManager(string fileNameObjects, string separator, int classNameColumnIndex, string fileNameRelations, RelationKind kind) { csvReader = new CsvFileReader(fileNameObjects, separator, classNameColumnIndex); preferenceReader = new PreferenceFileReader(fileNameRelations, kind); }