internal virtual void Initialize(Entity entity)
{
//// TODO: Think about currating the resulting data set against i.e. ontology to trim unnecessary proxy property values.
var context = new EntityInitializationContext();
InitializeInternal(entity, _entitySource.Load(entity.Iri), context);
}
private void InitializeChildEntities(EntityInitializationContext context)
{
foreach (var otherEntity in context.EntitiesCreated.Where(otherEntity => !otherEntity.IsInitialized))
{
IEnumerable <Statement> statements = null;
ISet <Statement> otherStatements;
if (!context.EntityStatements.TryGetValue(otherEntity.Iri, out otherStatements))
{
statements = _entitySource.Load(otherEntity.Iri);
}
InitializeInternal(otherEntity, otherStatements ?? statements, context);
context.EntityStatements.Remove(otherEntity.Iri);
}
}
internal static void InitializeLists(this Entity entity, EntityInitializationContext context)
{
Dictionary <Iri, ICollectionMapping> linkedLists;
if (!context.LinkedLists.TryGetValue(entity.Iri, out linkedLists))
{
return;
}
foreach (var head in linkedLists)
{
entity.SetList(head.Key, head.Value, context);
}
context.LinkedLists.Remove(entity.Iri);
}
internal static void SetList(this Entity entity, Iri head, ICollectionMapping collectionMapping, EntityInitializationContext context)
{
Iri previousHead = null;
while (true)
{
ISet <Statement> statements;
if ((previousHead == head) || (!context.EntityStatements.TryGetValue(head, out statements)))
{
break;
}
context.EntityStatements.Remove(previousHead = head);
foreach (var statement in statements)
{
if (statement.Predicate == rdf.first)
{
entity.SetProperty(statement, collectionMapping, context);
}
else if (statement.Predicate == rdf.rest)
{
head = statement.Object;
}
}
}
}
internal static void SetProperty(this Entity entity, Statement statement, IPropertyMapping propertyMapping, EntityInitializationContext context)
{
object value;
if (statement.Object != null)
{
var otherEntity = (IEntity)((DefaultEntityContext)entity.Context)
.CreateInternal(statement.Object, false)
.ActLike(propertyMapping.ReturnType.GetItemType());
context.EntitiesCreated.Add(otherEntity.UnwrapEntity());
value = otherEntity;
}
else
{
value = propertyMapping.ValueConverter.ConvertFrom(statement);
}
entity.SetPropertyInternal(propertyMapping.PropertyInfo, value);
}
internal virtual void InitializeInternal(Entity entity, IEnumerable <Statement> statements, EntityInitializationContext context, Action <Statement> onIteration = null)
{
if (onIteration == null)
{
onIteration = _ => { };
}
foreach (var statement in statements)
{
onIteration(statement);
if (!statement.IsRelatedTo(entity))
{
context.EntityStatements.EnsureKey(statement.Subject).Add(statement);
continue;
}
if (statement.IsTypeAssertion())
{
var entityMapping = Mappings.FindEntityMappingFor(entity, statement.Object, statement.Graph);
if (entityMapping != null)
{
entity.CastedTypes.Add(entityMapping.Type);
}
continue;
}
var propertyMapping = Mappings.FindPropertyMappingFor(entity, statement.Predicate, statement.Graph);
if ((propertyMapping == null) && (UnmappedPropertyEncountered != null))
{
var e = new UnmappedPropertyEventArgs(this, statement);
UnmappedPropertyEncountered(this, e);
propertyMapping = e.PropertyMapping;
}
if ((propertyMapping == null) || (!statement.Matches(propertyMapping.Graph)))
{
continue;
}
//// TODO: Develop a dictionary statements handling.
var collectionMapping = propertyMapping as ICollectionMapping;
if (collectionMapping?.StoreAs == CollectionStorageModel.LinkedList)
{
context.LinkedLists.EnsureKey(entity.Iri)[statement.Object] = collectionMapping;
continue;
}
entity.SetProperty(statement, propertyMapping, context);
}
entity.InitializeLists(context);
entity.IsInitialized = true;
InitializeChildEntities(context);
}
