public ResolveResultDTO <DataType> GetStoredEntityAsResolveResult(ResolveRequestDTO req)
{
if (string.IsNullOrEmpty(req.key))
{
return(ResolveResultDTO <DataType> .ResolveError(
req, "null or empty key"
));
}
var store = Services.Require <HasEntities <DataType> >();
Entity <DataType> entity;
if (!store.GetEntity(req.key, out entity) || !entity.status.hasResolved)
{
return(string.IsNullOrEmpty(entity.status.resolveError) ?
ResolveResultDTO <DataType> .ResolveNotFound(req) :
ResolveResultDTO <DataType> .ResolveError(
req, entity.status.resolveError
));
}
var status = entity.status;
return(ResolveResultDTO <DataType> .ResolveSucceeded(
req, entity.id, entity.data, status.maxAgeSecs, status.timestamp
));
}
/// <summary>
/// Allows you to request an entity (from the store) and get a callback when load succeeds or fails.
/// If the entity is not initially loaded, sends the usual notifications and then listens for updates
/// </summary>
public static Request <ResolveMultipleResultDTO <DataType> > ResolveAll(
IEnumerable <string> keys,
HasEntities <DataType> store,
Action <Request <ResolveMultipleResultDTO <DataType> > > callback = null)
{
var promise = new Promise <ResolveMultipleResultDTO <DataType> >((resolve, reject, cancel, attach) =>
{
var all = new JoinRequests();
foreach (var k in keys)
{
all.Add(new DataRequest(NewResolveRequest(k), store));
}
all.Execute(result =>
{
var allResult = result as JoinRequests;
using (var resultRequests = ListPool <Request> .Get())
using (var resultItems = ListPool <ResolveResultDTO <DataType> > .Get())
{
allResult.GetResults(resultRequests);
foreach (var rr in resultRequests)
{
var key = (rr as DataRequest).loadKey;
var reqDTO = (rr as DataRequest).requestDTO;
if (rr.hasError)
{
resultItems.Add(
ResolveResultDTO <DataType> .ResolveError(
reqDTO, rr.error
)
);
continue;
}
Entity <DataType> entity;
if (!store.GetEntity(key, out entity))
{
resultItems.Add(
ResolveResultDTO <DataType> .ResolveError(
reqDTO,
"enity not in store after resolve"
)
);
continue;
}
var status = entity.status;
resultItems.Add(ResolveResultDTO <DataType> .ResolveSucceeded(
reqDTO, entity.id, entity.data, status.maxAgeSecs, status.timestamp
));
}
resolve(new ResolveMultipleResultDTO <DataType>
{
entities = resultItems.ToArray()
});
}
});
});
promise.Execute(callback);
return(promise);
}
/// <summary>
/// Resolve the data and metadata for a key from an async method using await.
/// NOTE: this method will return a ResolveResult<DataType> even if the item
/// fails to load, e.g. either not found or resolve error.
/// Use this version if you want to handle failed responses without try/catch.
/// If you'd rather an exception be thrown any time the data isn't available,
/// use @see ResolveOrThrowAsync.
/// </summary>
/// <returns>The async.</returns>
public static async System.Threading.Tasks.Task <ResolveResultDTO <DataType> > ResolveAsync(
string loadKey,
HasEntities <DataType> store)
{
var req = NewResolveRequest(loadKey);
if (string.IsNullOrEmpty(loadKey))
{
return(ResolveResultDTO <DataType> .ResolveError(
req,
"Load key cannot be null or empty"
));
}
var r = new ResolveResultRequest(req, store);
try
{
await r.ExecuteAsync();
return(r.item);
}
catch (Exception e)
{
#if UNITY_EDITOR || DEBUG_UNSTRIP
var ae = e as AggregateException;
if (ae != null)
{
foreach (var ie in ae.InnerExceptions)
{
Debug.LogError("error on execute async for type "
+ typeof(DataType).Name
+ " and load key '" + loadKey
+ ": " + ie.Message
+ "\n" + ie.StackTrace
);
}
}
else
{
Debug.LogError("error on execute async for type "
+ typeof(DataType).Name
+ " and load key '" + loadKey
+ ": " + e.Message
);
}
#endif
return(ResolveResultDTO <DataType> .ResolveError(
req, e.Message
));
}
}
private void OnStoreUpdate(string id)
{
if (id != this.loadKey)
{
return;
}
Entity <DataType> entity;
if (!store.GetEntity(this.loadKey, out entity))
{
var err = "entity not tracked in store (expected in progress or complete)";
this.item = ResolveResultDTO <DataType> .ResolveError(
this.requestDTO, err
);
CompleteWithError(err);
return;
}
ResolveStatus stat = entity.status;
if (stat.isResolveInProgress)
{
return;
}
if (!stat.hasResolved)
{
var err = stat.resolveError ?? "not found";
this.item = ResolveResultDTO <DataType> .ResolveError(
this.requestDTO, err
);
CompleteWithError(err);
return;
}
this.item = ResolveResultDTO <DataType> .ResolveSucceeded(
this.requestDTO, entity.id, entity.data,
stat.maxAgeSecs, stat.timestamp
);
CompleteRequest();
}
