private static async Task <IHydraResource> GatherLinks(
ITypedEntity resource,
Statement statement,
ProcessingState processingState,
IHydraResource hydraResource,
CancellationToken cancellationToken)
{
var relationResource = await resource.Context.Load <IDereferencableLink>(statement.Predicate, cancellationToken);
var @object = await resource.Context.Load <IResource>(statement.Object, cancellationToken);
var linkType = relationResource.GetLinkType() ?? @object.GetLinkType(processingState.LinksPolicy, processingState.Root);
if (linkType != null)
{
hydraResource = hydraResource ?? resource.ActLike <IHydraResource>();
var owner = hydraResource;
processingState.MarkAsOwned(relationResource.Iri);
processingState.MarkAsOwned(@object.Iri);
processingState.ProcessingCompleted +=
(sender, e) => CreateRelationHandler((ProcessingState)sender, owner, relationResource, @object, linkType);
}
return(hydraResource);
}
static public void Set <T0, T1, T2, T3>
(this ComponentDataFromEntity <T3> componentDataFromEntity, ITypedEntity <T0, T1, T2, T3> entity, T3 componentData)
where T0 : struct, IComponentData
where T1 : struct, IComponentData
where T2 : struct, IComponentData
where T3 : struct, IComponentData
=> componentDataFromEntity[entity.Entity] = componentData;
static public T2 Get <T0, T1, T2, T3>
(this ComponentDataFromEntity <T2> componentDataFromEntity, ITypedEntity <T0, T1, T2, T3> entity)
where T0 : struct, IComponentData
where T1 : struct, IComponentData
where T2 : struct, IComponentData
where T3 : struct, IComponentData
=> componentDataFromEntity[entity.Entity];
public ReferenceExpression CreateTypedReference(string name, ITypedEntity entity)
{
ReferenceExpression expression = new ReferenceExpression(name);
expression.Entity = entity;
expression.ExpressionType = entity.Type;
return(expression);
}
private static Task <IResource> PointingResourceInitializer(
ITypedEntity resource,
IHydraClient client,
ProcessingState processingState,
CancellationToken cancellationToken)
{
resource.Unwrap().SetProperty(ResourceExtensions.BaseUrlPropertyInfo, (Uri)processingState.BaseUrl);
return(ResourceInitializer(resource.ActLike <IHydraResource>(), client, processingState, cancellationToken));
}
private static Task <IResource> ClientInitializer(
ITypedEntity resource,
IHydraClient client,
ProcessingState processingState,
CancellationToken cancellationToken)
{
resource.Unwrap().SetProperty(ClientPropertyInfo, client);
return(ResourceInitializer(
resource.Is(hydra.ApiDocumentation) ? (ITypedEntity)resource.ActLike <IApiDocumentation>() : resource.ActLike <ICollection>(),
client,
processingState,
cancellationToken));
}
private static async Task <IResource> ResourceInitializer(
ITypedEntity resource,
IHydraClient client,
ProcessingState processingState,
CancellationToken cancellationToken)
{
IHydraResource hydraResource = resource as IHydraResource
?? (resource.Is(hydra.Resource) ? resource.ActLike <IHydraResource>() : null);
bool hasView = false;
foreach (var statement in processingState.StatementsOf(resource.Iri))
{
hydraResource = await GatherLinks(resource, statement, processingState, hydraResource, cancellationToken);
if (statement.Predicate == hydra.view)
{
hasView = true;
}
}
if (hydraResource != null && processingState.NumberOfStatementsOf(resource.Iri) > 0)
{
GatherOperationTargets(hydraResource, processingState);
if (hasView)
{
hydraResource = hydraResource.ActLike <IResourceView>();
}
var addToHypermedia = !processingState.ForbiddenHypermeda.Contains(hydraResource.Iri) &&
(!hydraResource.Iri.IsBlank || IsHydraDependent(hydraResource));
if (addToHypermedia)
{
processingState.AllHypermedia.Add(hydraResource.Iri);
}
}
return(hydraResource);
}
public ReferenceExpression CreateTypedReference(string name, ITypedEntity entity)
{
ReferenceExpression expression = new ReferenceExpression(name);
expression.Entity = entity;
expression.ExpressionType = entity.Type;
return expression;
}
internal DynamicTypedEntity(ITypedEntity entity)
: base(entity)
{
Contract.Requires(entity != null);
_entity = entity;
}
bool AssertDelegateArgument(Node sourceNode, ITypedEntity delegateMember, ITypedEntity argumentInfo)
{
if (!IsAssignableFrom(delegateMember.Type, argumentInfo.Type))
{
Error(CompilerErrorFactory.EventArgumentMustBeAMethod(sourceNode, delegateMember));
return false;
}
return true;
}
public static CompilerError EventArgumentMustBeAMethod(Node node, ITypedEntity eventMember)
{
return(Instantiate("BCE0032", node, eventMember, eventMember.Type, LanguageAmbiance.CallableKeyword));
}
static public void Set <T0, T1>
(this ComponentDataFromEntity <T1> componentDataFromEntity, ITypedEntity <T0, T1> entity, T1 componentData)
where T0 : struct, IComponentData
where T1 : struct, IComponentData
=> componentDataFromEntity[entity.Entity] = componentData;
static public T1 Get <T0, T1>
(this ComponentDataFromEntity <T1> componentDataFromEntity, ITypedEntity <T0, T1> entity)
where T0 : struct, IComponentData
where T1 : struct, IComponentData
=> componentDataFromEntity[entity.Entity];
static public void Set <T>
(this ComponentDataFromEntity <T> componentDataFromEntity, ITypedEntity <T> entity, T componentData)
where T : struct, IComponentData
=> componentDataFromEntity[entity.Entity] = componentData;
static public T Get <T>
(this ComponentDataFromEntity <T> componentDataFromEntity, ITypedEntity <T> entity)
where T : struct, IComponentData
=> componentDataFromEntity[entity.Entity];
private static bool IsHydraDependent(ITypedEntity resource)
{
return(resource.Type.Any(_ => _.ToString().StartsWith(hydra.Namespace) && !HydraIndependentTypes.Contains(_)));
}
public void Setup()
{
_entity = new TypedEntity();
_rdfTypeCache = new RdfTypeCache();
}
internal DynamicTypedEntity(ITypedEntity entity)
: base(entity)
{
Contract.Requires(entity != null);
_entity = entity;
}
/// <summary>
/// Converts an instance of <see cref="ITypedEntity"/> to a dynamic object
/// </summary>
/// <param name="entity">The entity to convert.</param>
/// <returns>An instance of <see cref="DynamicTypedEntity"/> which is a dynamic object</returns>
public static dynamic AsDynamic(this ITypedEntity entity)
{
Contract.Requires(entity != null);
return(new DynamicTypedEntity(entity));
}
public static CompilerError EventArgumentMustBeAMethod(Node node, ITypedEntity eventMember)
{
return Instantiate("BCE0032", node, eventMember, eventMember.Type, LanguageAmbiance.CallableKeyword);
}
