public override async Task <object> GenerateAsync(IAccessCallback callback, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using (await(_asyncLock.LockAsync()).ConfigureAwait(false))
{
if (_lastSourceValue < 0)
{
_lastSourceValue = await(callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false);
while (_lastSourceValue <= 0)
{
_lastSourceValue = await(callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false);
}
// upperLimit defines the upper end of the bucket values
_upperLimit = (_lastSourceValue * IncrementSize) + 1;
// initialize value to the low end of the bucket
_value = _upperLimit - IncrementSize;
}
else if (_upperLimit <= _value)
{
_lastSourceValue = await(callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false);
_upperLimit = (_lastSourceValue * IncrementSize) + 1;
}
return(Make(_value++));
}
}
public override async Task <object> GenerateAsync(IAccessCallback callback, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using (await _generate.LockAsync())
{
if (_hiValue < 0)
{
_value = await(callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false);
if (_value < 1)
{
// unfortunately not really safe to normalize this
// to 1 as an initial value like we do the others
// because we would not be able to control this if
// we are using a sequence...
Log.Info("pooled optimizer source reported [" + _value + "] as the initial value; use of 1 or greater highly recommended");
}
if ((_initialValue == -1 && _value < IncrementSize) || _value == _initialValue)
{
_hiValue = await(callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false);
}
else
{
_hiValue = _value;
_value = _hiValue - IncrementSize;
}
}
else if (_value >= _hiValue)
{
_hiValue = await(callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false);
_value = _hiValue - IncrementSize;
}
return(Make(_value++));
}
}
public override object Generate(IAccessCallback callback)
{
if (_hiValue < 0)
{
_value = callback.GetNextValue();
if (_value < 1)
{
// unfortunately not really safe to normalize this
// to 1 as an initial value like we do the others
// because we would not be able to control this if
// we are using a sequence...
Log.Info("pooled optimizer source reported [" + _value + "] as the initial value; use of 1 or greater highly recommended");
}
if ((_initialValue == -1 && _value < IncrementSize) || _value == _initialValue)
{
_hiValue = callback.GetNextValue();
}
else
{
_hiValue = _value;
_value = _hiValue - IncrementSize;
}
}
else if (_value >= _hiValue)
{
_hiValue = callback.GetNextValue();
_value = _hiValue - IncrementSize;
}
return(Make(_value++));
}
public override object Generate(IAccessCallback callback)
{
using (_asyncLock.Lock())
{
if (_lastSourceValue < 0)
{
_lastSourceValue = callback.GetNextValue();
while (_lastSourceValue <= 0)
{
_lastSourceValue = callback.GetNextValue();
}
// upperLimit defines the upper end of the bucket values
_upperLimit = (_lastSourceValue * IncrementSize) + 1;
// initialize value to the low end of the bucket
_value = _upperLimit - IncrementSize;
}
else if (_upperLimit <= _value)
{
_lastSourceValue = callback.GetNextValue();
_upperLimit = (_lastSourceValue * IncrementSize) + 1;
}
return(Make(_value++));
}
}
public override object Generate(IAccessCallback callback)
{
if (_lastSourceValue < 0 || _value >= (_lastSourceValue + IncrementSize))
{
_lastSourceValue = callback.GetNextValue();
_value = _lastSourceValue;
// handle cases where initial-value is less than one (hsqldb for instance).
while (_value < 1)
{
_value++;
}
}
return(Make(_value++));
}
public override object Generate(IAccessCallback callback)
{
if (lastSourceValue == -1)
{
while (lastSourceValue <= 0)
{
lastSourceValue = callback.NextValue;
}
}
else
{
lastSourceValue = callback.NextValue;
}
return(Make(lastSourceValue));
}
public override async Task <object> GenerateAsync(IAccessCallback callback, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using (await _generate.LockAsync())
{
if (_lastSourceValue < 0 || _value >= (_lastSourceValue + IncrementSize))
{
_lastSourceValue = await(callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false);
_value = _lastSourceValue;
// handle cases where initial-value is less than one (hsqldb for instance).
while (_value < 1)
{
_value++;
}
}
return(Make(_value++));
}
}
public override object Generate(IAccessCallback callback)
{
// We must use a local variable here to avoid concurrency issues.
// With the local value we can avoid synchronizing the whole method.
long val = -1;
while (val <= 0)
{
val = callback.GetNextValue();
}
// This value is only stored for easy access in test. Should be no
// threading concerns there.
_lastSourceValue = val;
return(Make(val));
}
public override object Generate(IAccessCallback callback)
{
if (lastSourceValue < 0)
{
lastSourceValue = callback.NextValue;
while (lastSourceValue <= 0)
{
lastSourceValue = callback.NextValue;
}
hiValue = (lastSourceValue * IncrementSize) + 1;
value_Renamed = hiValue - IncrementSize;
}
else if (value_Renamed >= hiValue)
{
lastSourceValue = callback.NextValue;
hiValue = (lastSourceValue * IncrementSize) + 1;
}
return(Make(value_Renamed++));
}
public override async Task <object> GenerateAsync(IAccessCallback callback, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
// We must use a local variable here to avoid concurrency issues.
// With the local value we can avoid synchronizing the whole method.
long val = -1;
while (val <= 0)
{
val = await(callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false);
}
// This value is only stored for easy access in test. Should be no
// threading concerns there.
_lastSourceValue = val;
return(Make(val));
}
public override object Generate(IAccessCallback callback)
{
if (hiValue < 0)
{
value_Renamed = callback.NextValue;
if (value_Renamed < 1)
{
// unfortunately not really safe to normalize this
// to 1 as an initial value like we do the others
// because we would not be able to control this if
// we are using a sequence...
log.Info("pooled optimizer source reported [" + value_Renamed
+ "] as the initial value; use of 1 or greater highly recommended");
}
hiValue = callback.NextValue;
}
else if (value_Renamed >= hiValue)
{
hiValue = callback.NextValue;
value_Renamed = hiValue - IncrementSize;
}
return(Make(value_Renamed++));
}
public override object Generate(IAccessCallback callback)
{
if (_lastSourceValue < 0 || _value >= (_lastSourceValue + IncrementSize))
{
_lastSourceValue = callback.GetNextValue();
_value = _lastSourceValue;
// handle cases where initial-value is less than one (hsqldb for instance).
while (_value < 1)
_value++;
}
return Make(_value++);
}
public abstract object Generate(IAccessCallback param);
public abstract Task <object> GenerateAsync(IAccessCallback param, CancellationToken cancellationToken);
public override object Generate(IAccessCallback callback)
{
if (hiValue < 0)
{
value_Renamed = callback.NextValue;
if (value_Renamed < 1)
{
// unfortunately not really safe to normalize this
// to 1 as an initial value like we do the others
// because we would not be able to control this if
// we are using a sequence...
log.Info("pooled optimizer source reported [" + value_Renamed
+ "] as the initial value; use of 1 or greater highly recommended");
}
hiValue = callback.NextValue;
}
else if (value_Renamed >= hiValue)
{
hiValue = callback.NextValue;
value_Renamed = hiValue - IncrementSize;
}
return Make(value_Renamed++);
}
public override object Generate(IAccessCallback callback)
{
if (lastSourceValue == -1)
{
while (lastSourceValue <= 0)
{
lastSourceValue = callback.NextValue;
}
}
else
{
lastSourceValue = callback.NextValue;
}
return Make(lastSourceValue);
}
public override object Generate(IAccessCallback callback)
{
if (_hiValue < 0)
{
_value = callback.GetNextValue();
if (_value < 1)
{
// unfortunately not really safe to normalize this
// to 1 as an initial value like we do the others
// because we would not be able to control this if
// we are using a sequence...
Log.Info("pooled optimizer source reported [" + _value + "] as the initial value; use of 1 or greater highly recommended");
}
if ((_initialValue == -1 && _value < IncrementSize) || _value == _initialValue)
_hiValue = callback.GetNextValue();
else
{
_hiValue = _value;
_value = _hiValue - IncrementSize;
}
}
else if (_value >= _hiValue)
{
_hiValue = callback.GetNextValue();
_value = _hiValue - IncrementSize;
}
return Make(_value++);
}
public abstract object Generate(IAccessCallback param);
public override object Generate(IAccessCallback callback)
{
// We must use a local variable here to avoid concurrency issues.
// With the local value we can avoid synchronizing the whole method.
long val = -1;
while (val <= 0)
val = callback.GetNextValue();
// This value is only stored for easy access in test. Should be no
// threading concerns there.
_lastSourceValue = val;
return Make(val);
}
public override object Generate(IAccessCallback callback)
{
if (_lastSourceValue < 0)
{
_lastSourceValue = callback.GetNextValue();
while (_lastSourceValue <= 0)
{
_lastSourceValue = callback.GetNextValue();
}
// upperLimit defines the upper end of the bucket values
_upperLimit = (_lastSourceValue * IncrementSize) + 1;
// initialize value to the low end of the bucket
_value = _upperLimit - IncrementSize;
}
else if (_upperLimit <= _value)
{
_lastSourceValue = callback.GetNextValue();
_upperLimit = (_lastSourceValue * IncrementSize) + 1;
}
return Make(_value++);
}
public override object Generate(IAccessCallback callback)
{
if (lastSourceValue < 0)
{
lastSourceValue = callback.NextValue;
while (lastSourceValue <= 0)
{
lastSourceValue = callback.NextValue;
}
hiValue = (lastSourceValue * IncrementSize) + 1;
value_Renamed = hiValue - IncrementSize;
}
else if (value_Renamed >= hiValue)
{
lastSourceValue = callback.NextValue;
hiValue = (lastSourceValue * IncrementSize) + 1;
}
return Make(value_Renamed++);
}
