public virtual void Apply(IRelation relation, PropertyInfo prop)
{
DiscoverTargetTable(relation, prop);
DiscoverJoinKeys(relation, prop);
relation.Qualifier = _qualifier;
}
private void DeclareOneToManyProperty(IRelation relation, XmlNode mapIntoNode)
{
cw.SimpleProperty(
AccessLevel.Public,
VirtualisationLevel.Virtual,
String.Format("Iesi.Collections.Generic.ISet<{0}>", environment.ToTypeName(relation.ChildEntity, true)),
relation.ParentName,
true, true);
// Mapping
if (relation.Entity.Persistence.Persisted && relation.Entity2.Persistence.Persisted)
{
if (mapIntoNode == null)
{
return;
}
XmlNode refNode = map.CreateElement("set");
map.AddAttribute("name", relation.ParentName);
map.AddAttribute("table", relation.ChildEntity.Persistence.FullName);
map.AddAttribute("inverse", "true");
map.AddAttribute("lazy", "true");
map.AddAttribute("cascade", RelationCascadeToNHValue(relation.Cascade));
foreach (IAttribute a in relation.ChildAttributes)
{
XmlNode keyNode = map.CreateElement("key");
map.AddAttribute("column", a.Persistence.Name);
refNode.AppendChild(keyNode);
}
XmlNode relNode = map.CreateElement("one-to-many");
map.AddAttribute("class", environment.ToTypeName(relation.ChildEntity.Type, true));
refNode.AppendChild(relNode);
mapIntoNode.AppendChild(refNode);
}
}
private void dgvConditions_CellClick(object sender, DataGridViewCellEventArgs e)
{
if (e.ColumnIndex < 0 || e.RowIndex < 0)
{
return;
}
if (e.ColumnIndex == SelectColumnIndex ||
e.ColumnIndex == RelationColumnIndex)
{
DataGridViewRow dgvr = this.dgvConditions.Rows[e.RowIndex];
bool isSelect = Convert.ToBoolean(dgvr.Cells[SelectColumnIndex].Value);
LogColumn lc = LogColumnService.Instance.GetLogColumn(Convert.ToInt32(dgvr.Tag));
IRelation relation = RelationService.Instance.GetRelation(lc.Type,
Convert.ToString(dgvr.Cells[RelationColumnIndex].Value));
dgvr.Cells[ColumnNameColumnIndex].ReadOnly = true;
dgvr.Cells[ColumnNameColumnIndex].Style.BackColor = SystemColors.Control;
dgvr.Cells[RelationColumnIndex].ReadOnly = !isSelect;
dgvr.Cells[RelationColumnIndex].Style.BackColor = isSelect ? Color.White : SystemColors.Control;
dgvr.Cells[ContentColumnIndex].ReadOnly = !isSelect || relation.ParamsCount == 2;
dgvr.Cells[ContentColumnIndex].Style.BackColor = (isSelect && relation.ParamsCount == 1)?Color.White : SystemColors.Control;
dgvr.Cells[StartDateColumnIndex].ReadOnly = !isSelect || relation.ParamsCount == 1;
dgvr.Cells[StartDateColumnIndex].Style.BackColor = (isSelect && relation.ParamsCount == 2) ? Color.White : SystemColors.Control;
dgvr.Cells[EndDateColumnIndex].ReadOnly = !isSelect || relation.ParamsCount == 1;
dgvr.Cells[EndDateColumnIndex].Style.BackColor = (isSelect && relation.ParamsCount == 2) ? Color.White : SystemColors.Control;
}
}
public void Relation_Returns_Parent_Child_Object_Types_When_Creating()
{
IRelation r = CreateAndSaveRelation("Test", "test");
Assert.AreEqual(Constants.ObjectTypes.Document, r.ParentObjectType);
Assert.AreEqual(Constants.ObjectTypes.Media, r.ChildObjectType);
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.Impl == null))
{
IOperation implCasted = item.As <IOperation>();
if ((implCasted != null))
{
this._parent.Impl = implCasted;
return;
}
}
if ((this._parent.InDirectionOf == null))
{
ITypedModel inDirectionOfCasted = item.As <ITypedModel>();
if ((inDirectionOfCasted != null))
{
this._parent.InDirectionOf = inDirectionOfCasted;
return;
}
}
if ((this._parent.Relation == null))
{
IRelation relationCasted = item.As <IRelation>();
if ((relationCasted != null))
{
this._parent.Relation = relationCasted;
return;
}
}
}
/// <summary>
/// 从手中的牌生成所有可变的规则集合（3张）
/// </summary>
/// <param name="cards">手中的牌，或者包括当前摸的牌</param>
/// <param name="filterCards">在生成的规则中，必须包含某几张牌的Id</param>
/// <param name="includeCards">输出计算该规则包含的牌</param>
/// <param name="parsers">解析规则列表</param>
/// <returns></returns>
public static IRelation[] BuildCustomVariableRelations(Card[] cards, Card[] filterCards, out Card[] outputCards, params ParserDefines[] parsers)
{
List <IRelation> relations = new List <IRelation>();
List <Card> includeCards = new List <Card>();
foreach (var cardArray in new NoneResolver().Resolve <Card>(cards, 3, filterCards))
{
IRelation relation = null;
foreach (var parser in parsers)
{
relation = ParserFactory.Instance(parser).Parse(cardArray);
if (relation != null)
{
break;
}
}
if (relation != null)
{
relations.Add(relation);
for (var i = 0; i < relation.Cards.Length; i++)
{
if (!includeCards.Contains(relation.Cards[i]))
{
includeCards.Add(relation.Cards[i]);
}
}
}
}
outputCards = includeCards.ToArray();
return(relations.ToArray());
}
// Umbraco.Code.MapAll -ParentName -ChildName
private static void Map(IRelation source, RelationDisplay target, MapperContext context)
{
target.ChildId = source.ChildId;
target.Comment = source.Comment;
target.CreateDate = source.CreateDate;
target.ParentId = source.ParentId;
}
/// <summary>
/// Checks that the given content node has a relation to a media node, and creates a related media node if not
/// </summary>
/// <param name="node">The content node.</param>
public void EnsureRelatedMediaNodeExists(IContent node)
{
try
{
int contentRoot = String.IsNullOrWhiteSpace(_config.ReadSetting("syncFromContentRootNode")) ? -1 : Convert.ToInt32(_config.ReadSetting("syncFromContentRootNode"));
IContent contentRootNode = uMediaSyncHelper.contentService.GetById(contentRoot);
if (contentRoot == -1 || node.Path.Contains(contentRootNode.Path))
{
if (_config.SyncNode(node))
{
IRelation uMediaSyncRelation = uMediaSyncHelper.relationService.GetByParentId(node.Id).FirstOrDefault(r => r.RelationType.Alias == Constants.FolderRelationTypeAlias);
if (uMediaSyncRelation == null)
{
CreateRelatedMediaNode(node);
}
}
}
}
catch (Exception ex)
{
if (!ex.Data.Contains("Content node id"))
{
ex.Data.Add("Content node id", node.Id);
}
throw;
}
}
public void TryMatchRelationType()
{
var dataSet = new RelationRatingTestData.SingleMatchUsingSameTrait();
var childTraits = new RelationTraitCache.ChildTraits <float>(dataSet.FloatTraitValues);
var childTraitsList = new List <RelationTraitCache.ChildTraits <float> > {
childTraits, childTraits
};
var relationArray = new IRelation <float>[] { m_FloatRelation, m_FloatRelation };
var relationRatingsList = new List <Dictionary <RelationDataPair, float> >().Fill(2);
var dataPairs = new [] { new RelationDataPair(0, 1), new RelationDataPair(1, 0) };
var memberRatings = new []
{
// start with one of the members having no matches, to test the failure case
TestUtils.RandomRatings(), new Dictionary <int, float>()
};
// this index resetting is normally done by the function that wraps this function
RelationRatingTransform.CurrentRelationPairIndex = 0;
Assert.False(RelationRatingTransform.RateMatches(relationArray, childTraitsList, dataPairs,
memberRatings, relationRatingsList));
// give the member with no matches some matches, which should result in the whole type passing
memberRatings[1] = TestUtils.RandomRatings();
RelationRatingTransform.CurrentRelationPairIndex = 0;
Assert.True(RelationRatingTransform.RateMatches(relationArray, childTraitsList, dataPairs,
memberRatings, relationRatingsList));
VerifyRelationRatings(relationRatingsList[0], childTraits);
VerifyRelationRatings(relationRatingsList[1], childTraits);
}
public static Graph UniqueEntities(this Graph graph, Dictionary <Guid, IBHoMObject> replaceMap)
{
Dictionary <Guid, IBHoMObject> uniqueEntities = new Dictionary <Guid, IBHoMObject>();
foreach (KeyValuePair <Guid, IBHoMObject> kvp in graph.Entities)
{
IBHoMObject unique = replaceMap[kvp.Key];
if (!uniqueEntities.ContainsKey(unique.BHoM_Guid))
{
uniqueEntities.Add(unique.BHoM_Guid, unique);
}
}
graph.Entities = uniqueEntities;
List <IRelation> uniqueRelations = new List <IRelation>();
foreach (IRelation relation in graph.Relations)
{
IRelation relation1 = relation.UniqueEntities(replaceMap);
//keep if it does not already exist
if (!uniqueRelations.Any(r => r.Source.Equals(relation1.Source) && r.Target.Equals(relation1.Target)))
{
uniqueRelations.Add(relation1);
}
}
graph.Relations = uniqueRelations;
return(graph);
}
private ICollection <IField> GetAllFields(Type regType, Type subType)
{
List <IField> fields = GetFieldsIfManagedClass(regType, subType);
Type[] superTypes = ReflectionUtils.GetSuperTypesWithInterfacesImplemented(regType,
new Type[]
{ typeof(IReadOnlyEntity) });
for (int i = 0; i < superTypes.Length; i++)
{
Type superType = superTypes[i];
fields.AddRange(GetAllFields(superType, i > 0));
}
foreach (IField field in fields)
{
if (field is IRelation)
{
IRelation relation = (IRelation)field;
if (relation.FetchStrategy == FetchStrategy.Default)
{
relation.FetchStrategy = _config.FetchStrategy;
}
}
}
return(fields);
}
private void CreateJoinExpressionForDefinedRelation(QueryBuildInfo buildInfo)
{
string typeFromAlias = buildInfo.GetAlias(TypeFrom);
IRelation relation = processor.GetRelation(TypeFrom, TypeTo);
if (relation == null)
{
relation = processor.GetRelation(TypeTo, TypeFrom);
}
if (relation != null)
{
Expr = JoinExpr.Build();
ICollection <RelationColumnMapping> tableColumnMappings = relation.TableColumnMappings;
int i = 0;
foreach (RelationColumnMapping mapping in tableColumnMappings)
{
if (i > 0)
{
Expr.And();
}
Expr.Field(TypeFrom, typeFromAlias, mapping.FromField);
Expr.Eq();
Expr.Field(TypeTo, TypeToAlias, mapping.ToField);
i++;
}
}
}
public bool?LocateByRelation(ITestObject to, AutomationElement element)
{
IRelation relation = to.Relation;
if (relation == null)
{
return(null);
}
ITestObject leftTO = relation.Left;
ITestObject rightTO = relation.Right;
if (leftTO == null && rightTO == null)
{
return(null);
}
if (leftTO != null)
{
AutomationElement leftElement = UIAUtility.GetPreviousElement(element);
if (!Match(leftTO, leftElement))
{
return(false);
}
}
if (rightTO != null)
{
AutomationElement rightElement = UIAUtility.GetNextElement(element);
if (!Match(rightTO, rightElement))
{
return(false);
}
}
return(true);
}
private void DeclareManyToOneProperty(IRelation relation, XmlNode mapIntoNode)
{
cw.SimpleProperty(
AccessLevel.Public,
VirtualisationLevel.Virtual,
environment.ToTypeName(relation.ParentEntity.Type, true),
relation.ChildName,
true, true);
// Mapping
if (relation.Entity.Persistence.Persisted && relation.Entity2.Persistence.Persisted)
{
if (mapIntoNode == null)
{
return;
}
XmlNode refNode = map.CreateElement("many-to-one");
map.AddAttribute("name", relation.ChildName);
map.AddAttribute("class", environment.ToTypeName(relation.ParentEntity.Type, true));
map.AddAttribute("cascade", RelationCascadeToNHValue(relation.Cascade));
foreach (IAttribute a in relation.ChildAttributes)
{
XmlNode colNode = InitColumnNode(a);
refNode.AppendChild(colNode);
}
mapIntoNode.AppendChild(refNode);
}
}
public static double RelationLength(this Graph graph, IRelation relation)
{
if (graph == null)
{
BH.Engine.Reflection.Compute.RecordError("Cannot query the relation length of a null graph.");
return(0);
}
if (relation == null)
{
BH.Engine.Reflection.Compute.RecordError("Cannot query the relation length for a graph if the relation to query is null.");
return(0);
}
double length = 0;
if (relation.Curve != null)
{
length = relation.Curve.ILength();
}
else
{
IElement0D source = graph.Entities[relation.Source] as IElement0D;
IElement0D target = graph.Entities[relation.Target] as IElement0D;
length = source.IGeometry().Distance(target.IGeometry());
}
return(length);
}
protected virtual void DiscoverJoinKeys(IRelation relation, PropertyInfo prop)
{
var keyNames = BuildKeyNames(relation.Table);
relation.JoinKey = relation.Table.PrimaryKey;
relation.TargetJoinKey = FindColumnByNames(relation.TargetTable, keyNames);
}
public void UpdateRelatedEntitiesViolationDisabledReenabled()
{
TestDatabase database = new TestDatabase(false); // No identity
IRelation relation = database.AddMemberGroupRelation();
database.Groups.Insert(new Group {
Id = 1, Name = "Group 1"
});
database.Groups.Insert(new Group {
Id = 2, Name = "Group 2"
});
database.Members.Insert(new Member {
Id = "JD", Name = "John Doe", GroupId = 1
});
database.Members.Insert(new Member {
Id = "MS", Name = "Michael Smith", GroupId = 2
});
relation.IsEnabled = false;
database.Groups.Update(g => new Group {
Id = g.Id + 1
});
relation.IsEnabled = true;
}
private void CreateRelationColumns(IRelation relation)
{
EntityInfo relationInfo = CacheManager.GetEntityInfo(relation.RelatedObjectType);
while (relationInfo != null)
{
ICollection <IColumn> relationKeys = relationInfo.GetKeys();
foreach (IColumn relationKey in relationKeys)
{
RelationColumnMapping matchingMapping = null;
foreach (RelationColumnMapping mapping in relation.TableColumnMappings)
{
if (mapping.ToField.Equals(relationKey.AttributeName, StringComparison.InvariantCultureIgnoreCase))
{
matchingMapping = mapping;
break;
}
}
IColumn cloned = relationKey.Clone();
cloned.Key = false;
if (matchingMapping != null)
{
cloned.AttributeName = matchingMapping.FromField;
cloned.ColumnName = AbstractColumn.PredictColumnName(matchingMapping.FromField);
}
cloned.Nullable = relation.Nullable;
_columns.Add(cloned);
_relationColumnInfoList.Add(new EntityRelationColumnInfo(cloned, relation, matchingMapping));
}
relationInfo = relationInfo.SuperEntityInfo;
}
}
public virtual void Apply(IRelation relation, PropertyInfo prop)
{
DiscoverTargetTable(relation, prop);
DiscoverJoinKeys(relation, prop);
relation.Qualifier = _qualifier;
}
protected virtual void DiscoverJoinKeys(IRelation relation, PropertyInfo prop)
{
var keyNames = BuildKeyNames(relation.Table);
relation.JoinKey = relation.Table.PrimaryKey;
relation.TargetJoinKey = FindColumnByNames(relation.TargetTable, keyNames);
}
private void WriteObjectProperty(IAttribute attribute, IEnvironmentHelper environment)
{
IRelation r = attribute.UsedInRelations[0];
IEntity related = r.Entity;
if (r.Entity == attribute.Entity)
{
related = r.Entity2;
}
cw.WriteLine("private {0} {1};",
environment.ToTypeName(related, true),
environment.ToMemberName(attribute));
cw.BeginProperty(AccessLevel.Public,
VirtualisationLevel.Virtual,
environment.ToTypeName(related, true),
attribute.Name);
cw.BeginPropertyGet();
cw.WriteLine("return this.{0}.{1};",
PropertyName_DomainObjectProxy,
attribute.Name);
cw.EndPropertyAccessor();
cw.BeginPropertySet();
cw.WriteLine("this.{0}.{1} = value;",
PropertyName_DomainObjectProxy,
attribute.Name);
cw.EndPropertyAccessor();
cw.EndProperty();
}
public string CreateRelatedObjectsLoadQuery(IRelation relation)
{
var entityInfo = CacheManager.GetEntityInfo(relation.RelatedObjectType);
var sb = new StringBuilder();
sb.Append("SELECT * FROM ");
sb.Append(entityInfo.TableInfo.TableName);
sb.Append(" WHERE ");
IEnumerator <RelationColumnMapping> enumerator = relation.TableColumnMappings.GetEnumerator();
int i = 0;
enumerator.Reset();
while (enumerator.MoveNext())
{
RelationColumnMapping columnMapping = enumerator.Current;
if (i != 0)
{
sb.Append(" AND ");
}
sb.Append(entityInfo.FindColumnByAttribute(columnMapping.ToField).ColumnName);
sb.Append("= ?");
i++;
}
return(FixUpQuery(sb.ToString()));
}
public IRelation Parse(params Card[] cards)
{
IRelation relation = null;
if (cards.Length != 3)
{
return(relation);
}
if (cards[0].IsLarge != cards[1].IsLarge || cards[1].IsLarge != cards[2].IsLarge)
{
return(relation);
}
if (cards[0].Num + 2 == cards[2].Num && cards[1].Num + 1 == cards[2].Num)
{
if (cards[0].Num == 1)
{
relation = cards[0].IsLarge ? new Relation123Big() : (IRelation) new Relation123Small();
}
relation = cards[0].IsLarge ? new RelationStraightBig() : (IRelation) new RelationStraightSmall();
}
if (cards[0].Num == 2 && cards[1].Num == 7 && cards[2].Num == 10)
{
relation = cards[0].IsLarge ? new Relation2710Big() : (IRelation) new Relation2710Small();
}
if (relation != null)
{
relation.Cards = cards;
}
return(relation);
}
/// <summary>
/// Creates a relation between nodeForm and nodeTo in Neo4j.
/// </summary>
/// <param name="nodeFrom">Node From</param>
/// <param name="relation">Type of the Edge</param>
/// <param name="nodeTo">Node To</param>
/// <returns></returns>
public INode CreateRelation(INode nodeFrom, IRelation relation, INode nodeTo)
{
string tagFrom = nodeFrom.GetType().Name.ToLower();
string tagTo = nodeTo.GetType().Name.ToLower();
_client.Cypher.Merge(toNode(nodeFrom)).Merge(toNode(nodeTo)).Merge($"({tagFrom})-{toRelation(relation)}->({tagTo})").ExecuteWithoutResultsAsync();
return(nodeTo);
}
public static Command AsCommand(this IRelation relation, string commandText)
{
return(new Command()
{
CommandText = commandText,
Parameters = relation.AsParameters()
});
}
public static Query AsQuery(this IRelation relation, string queryText)
{
return(new Query()
{
QueryText = queryText,
Parameters = relation.AsParameters()
});
}
public static ISet <IKey> Keys(this IRelation relation)
{
if (!allRelationsKeys.ContainsKey(relation))
{
allRelationsKeys[relation] = new HashSet <IKey>();
}
return(allRelationsKeys[relation]);
}
public static IEnumerable <IConstraint> FromRelation(IRelation r)
{
return(r switch
{
ManyToMany m => new[] { (IConstraint) new ManyToManyConstraintTo(m), new ManyToManyConstraintFrom(m) },
OneToMany o => new[] { new OneToManyConstraint(o) },
ManyToOne m => new[] { new ManyToOneConstraint(m) }
});
internal AggregateContainsRelationCollectionSpan(AggregateContainsRelationCollection parent, IRelation relation)
{
Requires.NotNull(parent, nameof(parent));
Requires.NotNull(relation, nameof(relation));
_parent = parent;
Relation = relation;
}
public String process(IRelation relation)
{
CommonTree root = parse();
List <PlainItemDescription> idesc = evaluatePlainItemDescription(ref root);
PlainTextExporter exporter = new PlainTextExporter(idesc, relation);
String text = exporter.getText();
return(text);
}
private RelationRepresentation CreateRepresentation(IRelation relation)
{
var parentLinkTemplate = GetLinkTemplate(relation.RelationType.ParentObjectType);
var childLinkTemplate = GetLinkTemplate(relation.RelationType.ChildObjectType);
var rep = new RelationRepresentation(RelationLinkTemplate, parentLinkTemplate, childLinkTemplate);
return(Mapper.Map(relation, rep));
}
public ChildDataContainer(IRelation <T> relation)
{
if (relation == null)
{
throw new ArgumentException("Argument relation should not be null!");
}
_relation = relation;
}
private void UpdateFormFormGroupRelations(IRelation relation, bool isDelete)
{
var contentService = ApplicationContext.Current.Services.ContentService;
var parentContent = contentService.GetById(relation.ParentId);
string propertyAlias;
switch (parentContent.ContentType.Alias)
{
case "Form":
propertyAlias = "associatedGroups";
break;
case "FormGroup":
propertyAlias = "forms";
break;
default:
throw new NotSupportedException(string.Format("Document type '{0}' not supported by Relation Type '{1}'.", parentContent.ContentType.Alias, relation.RelationType.Alias));
}
var propertyValue = parentContent.GetValue<string>(propertyAlias) ?? string.Empty;
var propertyItems = propertyValue.ToDelimitedList();
var currentItem = propertyItems.FirstOrDefault(x => x == relation.ChildId.ToString());
if (isDelete && currentItem != null)
{
propertyItems.Remove(currentItem);
}
else if (!isDelete && currentItem == null)
{
propertyItems.Add(relation.ChildId.ToString());
}
else
{
return;
}
parentContent.SetValue(propertyAlias, string.Join(",", propertyItems));
contentService.Save(parentContent);
contentService.Publish(parentContent);
}
/// <summary>
/// Gets the Parent object from a Relation as an <see cref="IUmbracoEntity"/>
/// </summary>
/// <param name="relation">Relation to retrieve parent object from</param>
/// <param name="loadBaseType">Optional bool to load the complete object graph when set to <c>False</c></param>
/// <returns>An <see cref="IUmbracoEntity"/></returns>
public IUmbracoEntity GetParentEntityFromRelation(IRelation relation, bool loadBaseType = false)
{
var objectType = UmbracoObjectTypesExtensions.GetUmbracoObjectType(relation.RelationType.ParentObjectType);
return _entityService.Get(relation.ParentId, objectType, loadBaseType);
}
/// <summary>
/// Gets the Parent and Child objects from a Relation as a <see cref="Tuple"/>"/> with <see cref="IUmbracoEntity"/>.
/// </summary>
/// <param name="relation">Relation to retrieve parent and child object from</param>
/// <param name="loadBaseType">Optional bool to load the complete object graph when set to <c>False</c></param>
/// <returns>Returns a Tuple with Parent (item1) and Child (item2)</returns>
public Tuple<IUmbracoEntity, IUmbracoEntity> GetEntitiesFromRelation(IRelation relation, bool loadBaseType = false)
{
var childObjectType = UmbracoObjectTypesExtensions.GetUmbracoObjectType(relation.RelationType.ChildObjectType);
var parentObjectType = UmbracoObjectTypesExtensions.GetUmbracoObjectType(relation.RelationType.ParentObjectType);
var child = _entityService.Get(relation.ChildId, childObjectType, loadBaseType);
var parent = _entityService.Get(relation.ParentId, parentObjectType, loadBaseType);
return new Tuple<IUmbracoEntity, IUmbracoEntity>(parent, child);
}
/// <summary>
/// Deletes a <see cref="Relation"/>
/// </summary>
/// <param name="relation">Relation to Delete</param>
public void Delete(IRelation relation)
{
var uow = _uowProvider.GetUnitOfWork();
using (var repository = _repositoryFactory.CreateRelationRepository(uow))
{
repository.Delete(relation);
uow.Commit();
}
}
protected override void DiscoverJoinKeys(IRelation relation, PropertyInfo prop)
{
if (ThisClassContainsJoinKey)
{
relation.TargetJoinKey = relation.TargetTable.PrimaryKey;
var keyNames = BuildKeyNames(relation.TargetTable);
relation.JoinKey = FindColumnByNames(relation.Table, keyNames);
}
else
{
var keyNames = BuildKeyNames(relation.Table);
relation.TargetJoinKey = FindColumnByNames(relation.TargetTable, keyNames);
relation.JoinKey = relation.Table.PrimaryKey;
}
}
public static Hashtable/*<Key,Value[]>*/ Compact(IRelation/*<Key,Value>*/ irel, Type value_type)
{
Hashtable hash = new Hashtable();
foreach(object key in irel.GetKeys())
{
ISet vals = irel.GetValues(key);
if(vals.Count == 0)
continue;
System.Array array_vals = System.Array.CreateInstance(value_type, vals.Count);
vals.CopyTo(array_vals, 0);
if (typeof(Node).IsAssignableFrom(value_type))
{
Array.Sort(array_vals, DataStructUtil.NodeComparer);
}
hash.Add(key, array_vals);
}
return hash;
}
public virtual bool AddRelation(IRelation relation)
{
if(relation == null) return false;
bool changed = false;
foreach(object key in relation.GetKeys())
if(this.AddAll(key, relation.GetValues(key)))
changed = true;
return changed;
}
protected override Type GetRelationType(IRelation relation, PropertyInfo prop)
{
if (!prop.PropertyType.IsGenericType)
{
throw new InvalidOperationException("Expecting a generic collection to use this property as one to many collection");
}
var relationType = prop.PropertyType.GetGenericArguments()[0];
var listGeneric = typeof(List<>).MakeGenericType(relationType);
if (!prop.PropertyType.IsAssignableFrom(listGeneric))
{
throw new InvalidOperationException("Expecting a collection type that is assignable from List<T> to use this propery as one to many collection");
}
return relationType;
}
protected abstract Type GetRelationType(IRelation relation, PropertyInfo prop);
protected virtual void DiscoverTargetTable(IRelation relation, PropertyInfo prop)
{
relation.TargetType = GetRelationType(relation, prop);
relation.TargetTable = relation.Table.Provider.FindOrCreateTable(relation.TargetType);
}
protected override Type GetRelationType(IRelation relation, PropertyInfo prop)
{
return prop.PropertyType;
}
private RelationRepresentation CreateRepresentation(IRelation relation)
{
var parentLinkTemplate = GetLinkTemplate(relation.RelationType.ParentObjectType);
var childLinkTemplate = GetLinkTemplate(relation.RelationType.ChildObjectType);
var rep = new RelationRepresentation(RelationLinkTemplate, parentLinkTemplate, childLinkTemplate);
return Mapper.Map(relation, rep);
}
public virtual bool Accept(IRelation relation, PropertyInfo prop)
{
return true;
}
