public BerkeleyBulkEnumerator(BerkeleyError error)
{
_error = error;
_cursor = null;
_current = new BerkeleyKeyValueBulk();
}
public BerkeleyBulkEnumerator(BerkeleyBulkCursorBase cursor)
{
_cursor = cursor;
_current = new BerkeleyKeyValueBulk();
_error = BerkeleyError.NoError;
}
public async Task <BerkeleyError> WriteAsync(Byte[] key, Byte[] value)
{
BerkeleyError error = await base.OpenAsync().ConfigureAwait(false);
if (error.HasError)
{
return(error);
}
int offset = 0;
do
{
int bufferSize = Math.Min(value.Length - offset, base.BufferSize);
error = await base.Methods.WritePartialAsync(this, key, value, offset, bufferSize).ConfigureAwait(false);
if (error.HasError)
{
return(error);
}
offset += bufferSize;
}while (offset < value.Length);
return(BerkeleyError.NoError);
}
public async Task <BerkeleyResult <Byte[]> > ReadAsync(Byte[] key)
{
BerkeleyError error = await base.OpenAsync().ConfigureAwait(false);
if (error.HasError)
{
return(new BerkeleyResult <Byte[]>(error));
}
var readData = new List <Byte[]>();
int offset = 0;
for (; ;)
{
BerkeleyResult <Byte[]> result = await base.Methods.ReadPartialAsync(this, key, offset, base.BufferSize).ConfigureAwait(false);
if (result.HasError)
{
return(result);
}
Byte[] value = result.Result;
readData.Add(value);
offset += value.Length;
if (value.Length < base.BufferSize)
{
break;
}
}
return(new BerkeleyResult <Byte[]>(Join(readData)));
}
public async Task <BerkeleyError> DeleteCurrentAsync(BerkeleyDbDelete flag = 0)
{
BerkeleyError error = await OpenAsync().ConfigureAwait(false);
if (error.HasError)
{
return(error);
}
return(await Methods.DeleteCurrentAsync(this, flag).ConfigureAwait(false));
}
public async Task <BerkeleyError> CloseAsync()
{
if (_handle == InvalidHandle)
{
return(BerkeleyError.NoError);
}
BerkeleyError error = await _methods.CloseCursorAsync(this).ConfigureAwait(false);
_handle = InvalidHandle;
return(error);
}
public async Task <BerkeleyError> WriteAsync(BerkeleyDbWriteMode writeMode)
{
CloseWriteBuffer();
foreach (Dto.BerkeleyDtoPut data in _writeData)
{
BerkeleyError error = await base.BerkeleyDb.Methods.WriteDuplicateAsync(base.BerkeleyDb, data, _writeKeyBuffer.BufferSize, writeMode).ConfigureAwait(false);
if (error.HasError)
{
return(error);
}
}
_writeData.Clear();
return(BerkeleyError.NoError);
}
public async Task <BerkeleyError> CloseAsync(BerkeleyDbClose flags)
{
if (_handle == InvalidHandle)
{
return(BerkeleyError.NoError);
}
BerkeleyError error = await _methods.CloseDbAsync(this, flags).ConfigureAwait(false);
if (!error.HasError)
{
_handle = InvalidHandle;
}
return(error);
}
public async Task <BerkeleyError> DeleteAsync()
{
CloseDeleteBuffer();
foreach (Byte[] data in _deleteData)
{
BerkeleyError error = await base.BerkeleyDb.DeleteAsync(data, 0, BerkeleyDbMultiple.DB_MULTIPLE_KEY).ConfigureAwait(false);
if (error.HasError)
{
return(error);
}
}
_deleteData.Clear();
return(BerkeleyError.NoError);
}
protected async Task <BerkeleyError> SetBuffer(Byte[] key, BerkeleyDbOperation operation)
{
BerkeleyError error = await base.OpenAsync().ConfigureAwait(false);
if (error.HasError)
{
return(error);
}
BerkeleyResult <Dto.BerkeleyDtoGet> resultDtoGet = await base.Methods.GetDtoGet(this, key, operation, _multiple, base.BufferSize).ConfigureAwait(false);
if (!resultDtoGet.HasError)
{
Dto.BerkeleyDtoGet dtoGet = resultDtoGet.Result;
SetDtoGet(ref dtoGet);
}
return(resultDtoGet.Error);
}
public async Task <BerkeleyResult <BerkeleyKeyValue> > ReadAsync(Byte[] key, BerkeleyDbOperation operation)
{
BerkeleyError error = await base.OpenAsync().ConfigureAwait(false);
if (error.HasError)
{
return(new BerkeleyResult <BerkeleyKeyValue>(error));
}
BerkeleyResult <Dto.BerkeleyDtoGet> resultDtoGet = await base.Methods.GetDtoGet(this, key, operation, 0, 0).ConfigureAwait(false);
if (resultDtoGet.HasError)
{
return(new BerkeleyResult <BerkeleyKeyValue>(resultDtoGet.Error));
}
var keyValue = new BerkeleyKeyValue(resultDtoGet.Result.Key, resultDtoGet.Result.Value);
return(new BerkeleyResult <BerkeleyKeyValue>(keyValue));
}
public BerkeleyResult(BerkeleyDbError berkeleyDbError, T result)
{
_error = new BerkeleyError(berkeleyDbError);
_result = result;
}
public BerkeleyResult(T result)
{
_result = result;
_error = BerkeleyError.NoError;
}
public BerkeleyResult(HttpStatusCode httpStatusCode)
{
_error = new BerkeleyError(httpStatusCode);
_result = default(T);
}
public BerkeleyResult(BerkeleyDbError berkeleyDbError)
{
_error = new BerkeleyError(berkeleyDbError);
_result = default(T);
}
public async Task <BerkeleyBulkEnumerator> ReadAsync(Byte[] key, BerkeleyDbOperation operation)
{
BerkeleyError error = await SetBuffer(key, operation).ConfigureAwait(false);
return(error.HasError ? new BerkeleyBulkEnumerator(error) : new BerkeleyBulkEnumerator(this));
}
public BerkeleyResult(BerkeleyError error)
{
_error = error;
_result = default(T);
}
