async Task <bool> CollectNextUpdateBatchAsync() { m_keyBatch.Clear(); try { while (m_updateCandidates.MoveNext()) { UpdateCandidate candidate = m_updateCandidates.Current; IItemDataTyped item = await candidate.Chunk.View.GetLocalItemByKeyAsync(candidate.ViewKey.Key); if (item == null) { m_keyBatch.Add(candidate.ViewKey); } else { candidate.ViewKey.IsLoadPending = false; } if (m_keyBatch.Count >= m_maxBatchSize) { break; } } return(m_keyBatch.Count > 0); } catch { this.ClearUpdateStatusForBatch(); throw; } }
async Task <bool> CommitPutAsync(RecordItemChange change, long itemLockID) { IItemDataTyped item = await m_store.Local.GetByIDAsync(change.ItemID); if (item == null) { return(false); } change.LocalData = item; if (item.Key.IsLocal) { await this.CommitNewAsync(change); } else { await this.CommitUpdateAsync(change); } // // Refetch the item from HealthVault, to get updated dates etc... // await this.RefreshItemAsync(change, itemLockID); return(true); }
/// <summary> /// Puts a new item into the synchronized store. The new item will be comitted to the remote store in the background /// </summary> /// <param name="item"></param> /// <returns></returns> public IAsyncAction NewAsync(IItemDataTyped item) { if (item == null) { throw new ArgumentNullException("item"); } return(this.NewItemAsync(item.Item)); }
/// <summary> /// Updates an existing item. To update, you must first acquire a lock on it, and prove that you own the lock. /// Note: if you use higher level objects like SynchronizedStore, you won't have to acquire locks yourself. /// </summary> public IAsyncAction PutAsync(IItemDataTyped item, RecordItemLock itemLock) { if (item == null) { throw new ArgumentNullException("item"); } return(this.PutItemAsync(item.Item, itemLock)); }
public IAsyncOperation <ItemKey> PutAsync(IItemDataTyped data) { if (data == null) { throw new ArgumentNullException("data"); } return(PutItemAsync(data.Item)); }
internal IAsyncAction PutAsync(IItemDataTyped item, RecordItemLock itemLock) { this.ValidateItem(item); return(AsyncInfo.Run(async cancelToken => { await this.Data.PutAsync(item, itemLock); await this.UpdateKeyAsync(item.Item); })); }
public ItemData(IItemDataTyped typedData, ItemDataCommon commonData) { if (typedData == null) { throw new ArgumentNullException("typedData"); } Typed = typedData; Common = commonData; }
public static ViewKey FromTypedData(IItemDataTyped item) { if (item == null) { throw new ArgumentNullException("item"); } return(FromItem(item.Item)); }
public IAsyncOperation <ItemKey> NewAsync(IItemDataTyped data) { if (data == null) { throw new ArgumentNullException("data"); } data.Item.PrepareForNew(); return(PutAsync(data)); }
internal async Task <RecordItemEditOperation> OpenForEditAsync(ItemKey key, RecordItemLock itemLock) { IItemDataTyped data = await this.EnsureItemAvailableAndGetByKeyAsync(key); if (data == null) { return(null); } return(new RecordItemEditOperation(this, data, itemLock)); }
internal async Task <IItemDataTyped> LoadLocalItemAsync(ItemKey key) { IItemDataTyped item = await m_store.Local.GetAsyncImpl(key); if (item != null && m_data.TypeVersions.Contains(item.Type.ID)) { return(item); } return(null); }
void ValidateItem(IItemDataTyped item) { if (item == null) { throw new ArgumentNullException("item"); } item.Type.ValidateRequired("Type"); if (item.Type.ID != m_typeID) { throw new ArgumentException("TypeID mismatch"); } }
internal async Task <IItemDataTyped> GetItemAsync(int index, bool shouldAwaitRefresh, CancellationToken cancelToken) { if (!m_data.HasKeys) { return(null); } m_data.ValidateIndex(index); ViewKey viewKey = m_data.Keys[index]; // // Try to load the item from the local store // IItemDataTyped item = await this.LoadLocalItemAsync(viewKey.Key); if (item != null) { return(item); } // // Don't have the item locally available. Will need to fetch it. // While we do this, might as well read ahead // int startAt; if (this.ReadAheadMode == SynchronizedViewReadAheadMode.Page) { startAt = this.GetStartAtPositionForPage(index, this.ReadAheadChunkSize); } else { startAt = index; } await BeginRefreshAsync(startAt, shouldAwaitRefresh, cancelToken); if (!shouldAwaitRefresh) { return(null); } // // Reload the item // return(await Store.Local.GetAsyncImpl(viewKey.Key)); }
internal async Task <IList <ItemKey> > SelectKeysAsync(PredicateDelegate predicate, CancellationToken cancelToken) { if (predicate == null) { throw new ArgumentNullException("predicate"); } List <ItemKey> matches = new List <ItemKey>(); for (int i = 0, max = this.KeyCount; i < max; ++i) { IItemDataTyped item = await this.GetItemAsync(i, true, cancelToken); if (item != null && predicate(item)) { matches.Add(item.Key); } } return(matches); }
internal async Task <IList <IItemDataTyped> > EnsureItemsAvailableAndGetAsync(int startAt, int count, CancellationToken cancelToken) { if (!m_data.HasKeys) { return(null); } m_data.ValidateIndex(startAt); count = m_data.Keys.GetCorrectedCount(startAt, count); var items = new LazyList <IItemDataTyped>(); for (int i = startAt, max = startAt + count; i < max; ++i) { IItemDataTyped item = await EnsureItemAvailableAndGetAsync(i).AsTask(cancelToken); items.Add(item); } return(items.HasValue ? items.Value : null); }
internal async Task <IList <IItemDataTyped> > GetItemsAsync(int startAt, int count, bool shouldAwaitRefresh, CancellationToken cancelToken) { if (!m_data.HasKeys) { return(null); } m_data.ValidateIndex(startAt); count = m_data.Keys.GetCorrectedCount(startAt, count); var items = new LazyList <IItemDataTyped>(); for (int i = startAt, max = startAt + count; i < max; ++i) { IItemDataTyped item = await GetItemAsync(i, shouldAwaitRefresh, cancelToken); items.Add(item); } return(items.HasValue ? items.Value : null); }
internal async Task <IList <IItemDataTyped> > GetMultipleAsyncImpl( IEnumerable <ItemKey> keys, bool includeNullItems) { var items = new LazyList <IItemDataTyped>(); foreach (ItemKey key in keys) { key.Validate(); IItemDataTyped item = await GetAsyncImpl(key); if (includeNullItems) { items.Add(item); } else if (item != null) { items.Add(item); } } return((items.Count > 0) ? items.Value : null); }
/// <summary> /// Add a new item. The item is saved in the local store immediately, and a pending commit to the remote store is put in /// the synchronized store's change queue /// </summary> public IAsyncAction AddNewAsync(IItemDataTyped item) { this.ValidateItem(item); RecordItem recordItem = item.Item; SynchronizedStore.PrepareForNew(recordItem); return(AsyncInfo.Run(async cancelToken => { RecordItemLock rlock = this.AcquireItemLock(recordItem.Key); if (rlock == null) { return; } using (rlock) { await this.Data.PutItemAsync(recordItem, rlock); await this.AddKeyAsync(recordItem); } this.StartCommitChanges(); })); }
public IAsyncOperation <ItemKey> PutAsync(IItemDataTyped item) { this.ProduceError(); return(m_innerStore.PutAsync(item)); }
public ItemData(IItemDataTyped typedData) : this(typedData, null) { }
public IAsyncOperation<ItemKey> PutAsync(IItemDataTyped item) { return m_record.UpdateAsync(item); }
public RecordItem(string typeID, IItemDataTyped typedData) : this() { Type = new ItemType(typeID); Data = new ItemData(typedData); }
public IAsyncOperation<ItemKey> PutAsync(IItemDataTyped data) { if (data == null) { throw new ArgumentNullException("data"); } return PutItemAsync(data.Item); }
public IAsyncAction PutAsync(IItemDataTyped item) { if (item == null) { throw new ArgumentNullException("item"); } return PutItemAsync(item.Item); }
internal RecordItemEditOperation(SynchronizedType sType, IItemDataTyped data, RecordItemLock rLock) { m_sType = sType; m_rLock = rLock; m_data = data.Item.DeepClone().TypedData; }
public IAsyncOperation<ItemKey> PutAsync(IItemDataTyped item) { this.ProduceError(); return m_innerStore.PutAsync(item); }
internal IAsyncAction PutAsync(IItemDataTyped item, RecordItemLock itemLock) { this.ValidateItem(item); return AsyncInfo.Run(async cancelToken => { await this.Data.PutAsync(item, itemLock); await this.UpdateKeyAsync(item.Item); }); }
public IAsyncOperation <ItemKey> NewAsync(IItemDataTyped item) { return(m_record.NewAsync(item)); }
internal ItemProxy(string typeID, IItemDataTyped typedData) { m_typeID = typeID; m_typedData = typedData; m_itemData = null; }
public IAsyncOperation <ItemKey> PutAsync(IItemDataTyped item) { return(m_record.UpdateAsync(item)); }
public IAsyncOperation<ItemKey> NewAsync(IItemDataTyped data) { if (data == null) { throw new ArgumentNullException("data"); } data.Item.PrepareForNew(); return PutAsync(data); }
/// <summary> /// Updates an existing item. To update, you must first acquire a lock on it, and prove that you own the lock. /// Note: if you use higher level objects like SynchronizedStore, you won't have to acquire locks yourself. /// </summary> public IAsyncAction PutAsync(IItemDataTyped item, RecordItemLock itemLock) { if (item == null) { throw new ArgumentNullException("item"); } return this.PutItemAsync(item.Item, itemLock); }
/// <summary> /// Add a new item. The item is saved in the local store immediately, and a pending commit to the remote store is put in /// the synchronized store's change queue /// </summary> public IAsyncAction AddNewAsync(IItemDataTyped item) { this.ValidateItem(item); RecordItem recordItem = item.Item; SynchronizedStore.PrepareForNew(recordItem); return AsyncInfo.Run(async cancelToken => { RecordItemLock rlock = this.AcquireItemLock(recordItem.Key); if (rlock == null) { return; } using(rlock) { await this.Data.PutItemAsync(recordItem, rlock); await this.AddKeyAsync(recordItem); } this.StartCommitChanges(); }); }
public IAsyncOperation<ItemKey> NewAsync(IItemDataTyped item) { return m_record.NewAsync(item); }