public IEnumerable <KeyValuePair <TKey, TValue> > CreateEnumerable(EnumerationMode enumerationMode)
{
if (enumerationMode == EnumerationMode.Ordered)
{
return(this.OrderBy(x => x.Key));
}
return(this);
}
public Task <Fabric.IAsyncEnumerable <KeyValuePair <TKey, TValue> > > CreateEnumerableAsync(
ITransaction txn, Func <TKey, bool> filter, EnumerationMode enumerationMode)
{
return(Task.FromResult <Fabric.IAsyncEnumerable <KeyValuePair <TKey, TValue> > >(
new MockAsyncEnumerable <KeyValuePair <TKey, TValue> >(
enumerationMode == EnumerationMode.Unordered
? this.dictionary.Where(x => filter(x.Key))
: this.dictionary.Where(x => filter(x.Key)).OrderBy(x => x.Key))));
}
internal SampleListEnumerator(SampleList sampleList, int index, int count, EnumerationMode mode)
{
this.sampleList = sampleList;
this.index = index;
this.startIndex = index;
this.endIndex = index + count;
this.mode = mode;
//this.current = false;
}
internal HashListEnumerator(HashList hashList, EnumerationMode mode)
{
_hashList = hashList;
_mode = mode;
_version = hashList._version;
_orderList = hashList._insertionOrderList;
_index = 0;
_key = null;
_value = null;
}
internal HashListEnumerator(HashList hashList, EnumerationMode mode)
{
_hashList = hashList;
_mode = mode;
_version = hashList._version;
_orderList = hashList._insertionOrderList;
_index = 0;
_key = null;
_value = null;
}
public static EnumerateResponse StartEnumeration(this IMessageBuilder messageBuilder, Filter filter, EnumerationMode enumerationMode, bool optimize, out IMessageBuilder nextMessageBuilder)
{
var responseMessage = messageBuilder
.WithAction(Constants.EnumerateAction)
.AddBody(new EnumerateRequest
{
EnumerationMode = enumerationMode,
OptimizeEnumeration = optimize ? new OptimizeEnumeration() : null,
Filter = filter,
})
.SendAndGetResponse(out nextMessageBuilder);
return responseMessage.GetPayload<EnumerateResponse>();
}
public void ReadXml(XmlReader reader)
{
if (reader.Name() == ItemElementName)
{
_mode = EnumerationMode.EnumerateObjectAndEPR;
reader.ReadStartElement(ItemElementName);
_rawValue = reader.ReadOuterXml();
}
_eprValue = new EndpointReference();
_eprValue.ReadOuterXml(reader);
if (IncludeObject())
{
reader.ReadEndElement();
}
}
public void ReadXml(XmlReader reader)
{
if (reader.Name() == ItemElementName)
{
_mode = EnumerationMode.EnumerateObjectAndEPR;
reader.ReadStartElement(ItemElementName);
_rawValue = reader.ReadOuterXml();
}
_eprValue = new EndpointReference();
_eprValue.ReadOuterXml(reader);
if (IncludeObject())
{
reader.ReadEndElement();
}
}
public IEnumerator <T> GetEnumeratorStack(EnumerationMode enumerationMode)
{
if (this.IsEmpty)
{
throw new InvalidOperationException();
}
return(enumerationMode switch
{
EnumerationMode.PreOrder => this.GetEnumeratorPreOrderStack(),
EnumerationMode.InOrder => this.GetEnumeratorInOrderStack(),
EnumerationMode.PostOrder => this.GetEnumeratorPostOrderStack(),
// In this case we need to use queue.
EnumerationMode.LevelOrder => this.GetEnumeratorLevelOrderQueue(),
_ => throw new ArgumentException(nameof(enumerationMode)),
});
public Task <IAsyncEnumerable <KeyValuePair <TKey, TValue> > > CreateEnumerableAsync(ITransaction txn, EnumerationMode enumerationMode)
{
return(Task.FromResult <IAsyncEnumerable <KeyValuePair <TKey, TValue> > >(
new MockAsyncEnumerable <KeyValuePair <TKey, TValue> >(
enumerationMode == EnumerationMode.Unordered
? (IEnumerable <KeyValuePair <TKey, TValue> >) this.dictionary
: this.dictionary.OrderBy(x => x.Key))));
}
public EnumerationState(IEnumerator<object> enumerator, EnumerationMode mode)
{
_enumerator = enumerator;
_mode = mode;
}
internal SampleListEnumerator(SampleList sampleList, int index, int count, EnumerationMode mode)
{
_sampleList = sampleList;
_index = index;
_startIndex = index;
_endIndex = index + count;
_mode = mode;
}
public EnumerationStartedEventArgs(IEnumerator <object> enumerator, EnumerationMode mode)
{
_enumerator = enumerator;
_mode = mode;
}
protected internal override IEnumerator <KeyValuePair <string, JSValue> > GetEnumerator(bool hideNonEnumerable, EnumerationMode enumeratorMode)
{
return(original.GetEnumerator(hideNonEnumerable, enumeratorMode));
}
public Task <IAsyncEnumerable <KeyValuePair <TKey, TValue> > > CreateEnumerableAsync(ITransaction txn, Func <TKey, bool> filter, EnumerationMode enumerationMode)
{
var enumerable = CreateEnumerable(txn, filter, enumerationMode);
return(Task.FromResult(enumerable));
}
public EnumerationItem(EndpointReference epr)
{
_eprValue = epr;
_mode = EnumerationMode.EnumerateEPR;
}
public EnumerationItem(EndpointReference epr, object value)
{
_eprValue = epr;
_objectValue = value;
_mode = EnumerationMode.EnumerateObjectAndEPR;
}
public EnumerationItem()
{
_mode = EnumerationMode.EnumerateEPR;
}
public PullResult(IEnumerable<object> items, EnumerationMode enumerationMode, bool endOfSequence)
{
_items = items;
_enumerationMode = enumerationMode;
_endOfSequence = endOfSequence;
}
public EnumerationStartedEventArgs(IEnumerator<object> enumerator, EnumerationMode mode)
{
_enumerator = enumerator;
_mode = mode;
}
private static IEnumerable<EnumerationItem> PullItems(int maximum, EnumerationMode mode, IEnumerator<object> enumerator, out bool endOfSequence)
{
int i = 0;
List<EnumerationItem> result = new List<EnumerationItem>();
bool moveNext = false;
while (i < maximum && (moveNext = enumerator.MoveNext()))
{
if (mode == EnumerationMode.EnumerateEPR)
{
if (i == 0)
{
EnumerationModeExtension.Activate(EnumerationMode.EnumerateEPR, null);
}
result.Add(new EnumerationItem((EndpointAddress)enumerator.Current));
}
else
{
if (i == 0)
{
EnumerationModeExtension.Activate(EnumerationMode.EnumerateObjectAndEPR,
enumerator.Current.GetType());
}
result.Add(new EnumerationItem(
new EndpointAddress("http://tempuri.org"),
enumerator.Current));
}
i++;
}
endOfSequence = !moveNext || i < maximum;
return result;
}
private static IEnumerable<EnumerationItem> EncapsulateItems(IEnumerable<object> enumerable, EnumerationMode enumerationMode)
{
return enumerationMode == EnumerationMode.EnumerateEPR ?
EncapsulateEPRs(enumerable)
: EncapsulateObjects(enumerable);
}
internal SampleListEnumerator(SampleList sampleList, int index, int count, EnumerationMode mode)
{
this.sampleList = sampleList;
this.index = index;
this.startIndex = index;
this.endIndex = index + count;
this.mode = mode;
}
public Task <IAsyncEnumerable <KeyValuePair <TKey, TValue> > > CreateEnumerableAsync(ITransaction txn, EnumerationMode enumerationMode)
{
return(CreateEnumerableAsync(txn, null, enumerationMode));
}
public async Task <IAsyncEnumerable <System.Collections.Generic.KeyValuePair <TKey, TValue> > > CreateEnumerableAsync(ITransaction tx, Func <TKey, bool> filter, EnumerationMode enumerationMode)
{
var keys = new System.Collections.Generic.List <TKey>();
try
{
BeginTransaction(tx);
foreach (var key in Dictionary.Keys)
{
if (filter == null || filter(key))
{
await LockManager.AcquireLock(tx.TransactionId, key, LockMode.Default);
keys.Add(key);
}
}
if (enumerationMode == EnumerationMode.Ordered)
{
keys.Sort();
}
IAsyncEnumerable <System.Collections.Generic.KeyValuePair <TKey, TValue> > result = new MockAsyncEnumerable <System.Collections.Generic.KeyValuePair <TKey, TValue> >(keys.Select(k => new System.Collections.Generic.KeyValuePair <TKey, TValue>(k, Dictionary[k])));
return(result);
}
catch
{
foreach (var key in keys)
{
LockManager.ReleaseLock(tx.TransactionId, key);
}
throw;
}
}
internal IAsyncEnumerable <KeyValuePair <TKey, TValue> > CreateEnumerable(ITransaction txn, Func <TKey, bool> filter, EnumerationMode enumerationMode)
{
var dictionary = GetSnapshot(txn);
var enumeration = dictionary.AsEnumerable();
if (filter != null)
{
enumeration = enumeration.Where(kv => filter(kv.Key));
}
if (enumerationMode == EnumerationMode.Ordered)
{
enumeration = enumeration.OrderBy(x => x.Key);
}
var enumerable = enumeration.AsFabricAsyncEnumerable();
return(enumerable);
}
public async Task <IAsyncEnumerable <TKey> > CreateKeyEnumerableAsync(ITransaction tx, EnumerationMode enumerationMode, TimeSpan timeout, CancellationToken cancellationToken)
{
var keys = new System.Collections.Generic.List <TKey>();
try
{
BeginTransaction(tx);
foreach (var key in Dictionary.Keys)
{
await LockManager.AcquireLock(tx.TransactionId, key, LockMode.Default, timeout, cancellationToken);
keys.Add(key);
}
if (enumerationMode == EnumerationMode.Ordered)
{
keys.Sort();
}
IAsyncEnumerable <TKey> result = new MockAsyncEnumerable <TKey>(keys);
return(result);
}
catch
{
foreach (var key in keys)
{
LockManager.ReleaseLock(tx.TransactionId, key);
}
throw;
}
}
public EnumerationPullHandler(IEnumerator<object> enumerator, EnumerationMode enumerationMode)
{
_enumerator = enumerator;
_enumerationMode = enumerationMode;
}
protected override IEnumerator<KeyValuePair<string, JSValue>> GetEnumerator(bool hideNonEnum, EnumerationMode enumerationMode) {
//return base.GetEnumerator(hideNonEnum, enumerationMode);
return _pins.OrderBy(z => z.Key).OrderBy(z => z.Value.layer).Select(z=>new KeyValuePair<string, JSValue>(z.Key, z.Value.owner._value)).GetEnumerator();
//return _pins.OrderBy(z => z.Key).OrderBy(z => z.Value.layer).Select(z => z.Key).GetEnumerator();
}
public Task <IAsyncEnumerable <System.Collections.Generic.KeyValuePair <TKey, TValue> > > CreateEnumerableAsync(ITransaction tx, EnumerationMode enumerationMode)
{
return(CreateEnumerableAsync(tx, null, enumerationMode));
}
public Task <IAsyncEnumerable <TKey> > CreateKeyEnumerableAsync(ITransaction tx, EnumerationMode enumerationMode)
{
return(_dictionary.CreateKeyEnumerableAsync(tx, enumerationMode));
}
public Task <IAsyncEnumerable <TKey> > CreateKeyEnumerableAsync(ITransaction tx, EnumerationMode enumerationMode)
{
return(CreateKeyEnumerableAsync(tx, enumerationMode, default(TimeSpan), CancellationToken.None));
}
public Task <IAsyncEnumerable <TFilter> > CreateIndexEnumerableAsync <TFilter>(ITransaction tx, string index, EnumerationMode enumerationMode)
where TFilter : IComparable <TFilter>, IEquatable <TFilter>
{
return(CreateIndexEnumerableAsync <TFilter>(tx, index, enumerationMode, DefaultTimeout, CancellationToken.None));
}
public RootQuery ConfigEnumerationMode(EnumerationMode mode)
{
ContainerObject.EnumerationMode = mode;
return(this);
}
protected internal virtual IEnumerator <KeyValuePair <string, JSValue> > GetEnumerator(bool hideNonEnumerable, EnumerationMode enumeratorMode)
{
if (_valueType >= JSValueType.Object && _oValue != this)
{
var innerObject = _oValue as JSValue;
if (innerObject != null)
{
return(innerObject.GetEnumerator(hideNonEnumerable, enumeratorMode));
}
}
return(GetEnumeratorImpl(hideNonEnumerable));
}
Task <IAsyncEnumerable <KeyValuePair <TKey, TValue> > > IReliableDictionary <TKey, TValue> .CreateEnumerableAsync(ITransaction tx, Func <TKey, bool> filter, EnumerationMode enumerationMode)
{
return(_dictionary.CreateEnumerableAsync(tx, filter, enumerationMode));
}
private void OnEnumerationStarted(string context, IEnumerator<object> enumerator, EnumerationMode enumerationMode)
{
_pullServer.RegisterPullHandler(context, new EnumerationPullHandler(enumerator, enumerationMode));
}
public Task <IAsyncEnumerable <TKey> > CreateKeyEnumerableAsync(ITransaction tx, EnumerationMode enumerationMode, TimeSpan timeout, CancellationToken cancellationToken)
{
return(_dictionary.CreateKeyEnumerableAsync(tx, enumerationMode, timeout, cancellationToken));
}
public Task <IAsyncEnumerable <TKey> > CreateKeyEnumerableAsync(ITransaction txn, EnumerationMode enumerationMode,
TimeSpan timeout, CancellationToken cancellationToken)
{
return(Task.FromResult <IAsyncEnumerable <TKey> >(
new MockAsyncEnumerable <TKey>(
enumerationMode == EnumerationMode.Ordered
? dictionary.Select(x => x.Key).OrderBy(k => k)
: dictionary.Select(x => x.Key))));
}
public Task <IAsyncEnumerable <TFilter> > CreateIndexEnumerableAsync <TFilter>(ITransaction tx, string indexName, EnumerationMode enumerationMode, TimeSpan timeout, CancellationToken token)
where TFilter : IComparable <TFilter>, IEquatable <TFilter>
{
// Find the index.
var index = GetFilterableIndex <TFilter>(indexName);
// Enumerate the keys (distinct filter values) of this index.
return(index.CreateEnumerableAsync(tx, enumerationMode, timeout, token));
}
protected internal override IEnumerator <KeyValuePair <string, JSValue> > GetEnumerator(bool hideNonEnumerable, EnumerationMode enumerationMode)
{
for (var i = 0; i < data.Count; i++)
{
yield return(new KeyValuePair <string, JSValue>(Tools.Int32ToString(i), (int)enumerationMode > 0 ? new Element(this, i) : null));
}
for (var e = base.GetEnumerator(hideNonEnumerable, enumerationMode); e.MoveNext();)
{
yield return(e.Current);
}
}
protected internal override IEnumerator <KeyValuePair <string, JSValue> > GetEnumerator(bool hideNonEnum, EnumerationMode enumeratorMode)
{
cloneValues();
if (a0 != null && a0.Exists && (!hideNonEnum || (a0._attributes & JSValueAttributesInternal.DoNotEnumerate) == 0))
{
yield return(new KeyValuePair <string, JSValue>("0", a0));
}
if (a1 != null && a1.Exists && (!hideNonEnum || (a1._attributes & JSValueAttributesInternal.DoNotEnumerate) == 0))
{
yield return(new KeyValuePair <string, JSValue>("1", a1));
}
if (a2 != null && a2.Exists && (!hideNonEnum || (a2._attributes & JSValueAttributesInternal.DoNotEnumerate) == 0))
{
yield return(new KeyValuePair <string, JSValue>("2", a2));
}
if (a3 != null && a3.Exists && (!hideNonEnum || (a3._attributes & JSValueAttributesInternal.DoNotEnumerate) == 0))
{
yield return(new KeyValuePair <string, JSValue>("3", a3));
}
if (a4 != null && a4.Exists && (!hideNonEnum || (a4._attributes & JSValueAttributesInternal.DoNotEnumerate) == 0))
{
yield return(new KeyValuePair <string, JSValue>("4", a4));
}
if (callee != null && callee.Exists && (!hideNonEnum || (callee._attributes & JSValueAttributesInternal.DoNotEnumerate) == 0))
{
yield return(new KeyValuePair <string, JSValue>("callee", callee));
}
if (caller != null && caller.Exists && (!hideNonEnum || (caller._attributes & JSValueAttributesInternal.DoNotEnumerate) == 0))
{
yield return(new KeyValuePair <string, JSValue>("caller", caller));
}
if (_lengthContainer != null && _lengthContainer.Exists && (!hideNonEnum || (_lengthContainer._attributes & JSValueAttributesInternal.DoNotEnumerate) == 0))
{
yield return(new KeyValuePair <string, JSValue>("length", _lengthContainer));
}
var be = base.GetEnumerator(hideNonEnum, enumeratorMode);
while (be.MoveNext())
{
yield return(be.Current);
}
}
public async Task <IAsyncEnumerable <TKey> > CreateEnumerableAsync(ITransaction tx, EnumerationMode enumerationMode = EnumerationMode.Unordered, Func <TKey, Boolean> filter = null)
{
IAsyncEnumerable <KeyValuePair <TKey, Object> > enumerable = await m_dictionary.CreateEnumerableAsync(tx, filter ?? (k => true), enumerationMode);
return(new ReliableListEnumerable <TKey>(enumerable));
}
protected internal override IEnumerator <KeyValuePair <string, JSValue> > GetEnumerator(bool hideNonEnum, EnumerationMode enumerationMode)
{
var pe = _staticProxy.GetEnumerator(hideNonEnum, enumerationMode);
while (pe.MoveNext())
{
yield return(pe.Current);
}
pe = __proto__.GetEnumerator(hideNonEnum, enumerationMode);
while (pe.MoveNext())
{
yield return(pe.Current);
}
}
/// <summary>
/// Create an async enumerable over the set of distinct filter values in this index.
/// </summary>
public Task <IAsyncEnumerable <TFilter> > CreateEnumerableAsync(ITransaction tx, EnumerationMode enumerationMode, TimeSpan timeout, CancellationToken token)
{
return(_index.CreateKeyEnumerableAsync(tx, enumerationMode, timeout, token));
}
public static Task ForeachAsync <TKey, TValue>(
this IReliableDictionary <TKey, TValue> instance, ITransaction tx, CancellationToken token, EnumerationMode enumMode, Func <TKey, bool> filter,
Action <KeyValuePair <TKey, TValue> > doSomething)
where TKey : IEquatable <TKey>, IComparable <TKey>
{
return(ForeachAsync <TKey, TValue>(instance.CreateEnumerableAsync(tx, filter, enumMode), token, doSomething));
}
/// <summary>
/// QueryCommand like setter for WithEnumerationMode
/// </summary>
/// <returns></returns>
public IQueryContainer WithEnumerationMode(EnumerationMode mode)
{
EnumerationMode = mode;
return this;
}
