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 BerkeleyDbError Put(IntPtr pdb, Byte[] key, Byte[] data, BerkeleyDbWriteMode flags)
{
var keyDbt = new db_dbt();
var dataDbt = new db_dbt();
try
{
keyDbt.Init(key);
dataDbt.Init(data);
return((BerkeleyDbError)_put(pdb, IntPtr.Zero, ref keyDbt, ref dataDbt, (uint)flags));
}
finally
{
keyDbt.Dispose();
dataDbt.Dispose();
}
}
public BerkeleyDbError PutMultipleKey(IntPtr pdb, Byte[] data, BerkeleyDbWriteMode flags)
{
var keyDbt = new db_dbt();
var dataDbt = new db_dbt();
try
{
keyDbt.Init(data);
keyDbt.flags |= db_dbt.DB_DBT_BULK;
dataDbt.flags |= db_dbt.DB_DBT_READONLY;
return((BerkeleyDbError)_put(pdb, IntPtr.Zero, ref keyDbt, ref dataDbt, (uint)flags | (int)BerkeleyDbMultiple.DB_MULTIPLE_KEY));
}
finally
{
keyDbt.Dispose();
dataDbt.Dispose();
}
}
public static String ToStringEx(this BerkeleyDbWriteMode flag)
{
switch (flag)
{
case 0:
return("0");
case BerkeleyDbWriteMode.DB_APPEND:
return("db_append");
case BerkeleyDbWriteMode.DB_NODUPDATA:
return("db_nodupdata");
case BerkeleyDbWriteMode.DB_NOOVERWRITE:
return("db_nooverwrite");
case BerkeleyDbWriteMode.DB_OVERWRITE_DUP:
return("db_overwrite_dup");
default:
throw new ArgumentOutOfRangeException(flag.ToString());
}
}
public abstract Task<BerkeleyError> WriteMultipleAsync(BerkeleyDb db, Dto.BerkeleyDtoPut data, BerkeleyDbWriteMode writeMode);
public abstract Task<BerkeleyError> WriteDuplicateAsync(BerkeleyDb db, Dto.BerkeleyDtoPut data, int bufferSize, BerkeleyDbWriteMode writeMode);
public abstract Task<BerkeleyError> WriteAsync(BerkeleyDb db, Byte[] key, Byte[] value, BerkeleyDbWriteMode writeMode);
public BerkeleyDbError WriteMultipleKey([FromUri] ulong handle, BerkeleyDbWriteMode writeMode, [FromBody] Byte[] data)
{
DbHandle db = GetDb(handle);
return(db.Methods.PutMultipleKey(db.Handle, data, writeMode));
}
public BerkeleyDbError WriteMultipleDuplicate([FromUri] ulong handle, BerkeleyDbWriteMode writeMode, [FromBody] BerkeleyDtoPut data)
{
DbHandle db = GetDb(handle);
return db.Methods.PutMultipleDuplicate(db.Handle, data.Key, data.Value, writeMode);
}
public BerkeleyDbError Put(IntPtr pdb, Byte[] key, Byte[] data, BerkeleyDbWriteMode flags)
{
var keyDbt = new db_dbt();
var dataDbt = new db_dbt();
try
{
keyDbt.Init(key);
dataDbt.Init(data);
return (BerkeleyDbError)_put(pdb, IntPtr.Zero, ref keyDbt, ref dataDbt, (uint)flags);
}
finally
{
keyDbt.Dispose();
dataDbt.Dispose();
}
}
public abstract Task <BerkeleyError> WriteMultipleAsync(BerkeleyDb db, Dto.BerkeleyDtoPut data, BerkeleyDbWriteMode writeMode);
public override async Task <BerkeleyError> WriteMultipleAsync(BerkeleyDb db, BerkeleyDtoPut data, BerkeleyDbWriteMode writeMode)
{
String requestUri;
ObjectContent content;
if (data.Key == null)
{
requestUri = "api/database/writemultiplekey/?handle=" + db.Handle.ToString() + "&writemode=" + writeMode.ToStringEx();
content = new ObjectContent <Byte[]>(data.Value, _formatter, (String)null);
}
else
{
requestUri = "api/database/write/?handle=" + db.Handle.ToString() + "&writemode=" + writeMode.ToStringEx();
content = new ObjectContent <BerkeleyDtoPut>(data, _formatter, (String)null);
}
HttpResponseMessage response = await _httpClient.PostAsync(requestUri, content);
if (!response.IsSuccessStatusCode)
{
return(new BerkeleyError(response.StatusCode));
}
BerkeleyDbError error = await SerializeHelper.GetErrorAsync(_serializer, response.Content).ConfigureAwait(false);
return(new BerkeleyError(error));
}
public override async Task <BerkeleyError> WriteDuplicateAsync(BerkeleyDb db, BerkeleyDtoPut data, int bufferSize, BerkeleyDbWriteMode writeMode)
{
String requestUri;
BerkeleyDtoPut dataPost;
if (data.Key.Length <= bufferSize && data.Value.Length <= bufferSize)
{
requestUri = "api/database/writemultipleduplicate/?handle=" + db.Handle.ToString() + "&writemode=" + writeMode.ToStringEx();
dataPost = new BerkeleyDtoPut(data.Key, data.Value);
}
else
{
requestUri = "api/database/write/?handle=" + db.Handle.ToString() + "&writemode=" + writeMode.ToStringEx();
dataPost = data;
}
ObjectContent content = new ObjectContent <BerkeleyDtoPut>(dataPost, _formatter, (String)null);
HttpResponseMessage response = await _httpClient.PostAsync(requestUri, content).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(new BerkeleyError(response.StatusCode));
}
BerkeleyDbError error = await SerializeHelper.GetErrorAsync(_serializer, response.Content).ConfigureAwait(false);
return(new BerkeleyError(error));
}
public async Task <BerkeleyError> WriteAsync(Byte[] key, Byte[] value, BerkeleyDbWriteMode writeMode)
{
return(await _methods.WriteAsync(this, key, value, writeMode).ConfigureAwait(false));
}
public abstract Task <BerkeleyError> WriteAsync(BerkeleyDb db, Byte[] key, Byte[] value, BerkeleyDbWriteMode writeMode);
public abstract Task <BerkeleyError> WriteDuplicateAsync(BerkeleyDb db, Dto.BerkeleyDtoPut data, int bufferSize, BerkeleyDbWriteMode writeMode);
public override async Task<BerkeleyError> WriteDuplicateAsync(BerkeleyDb db, BerkeleyDtoPut data, int bufferSize, BerkeleyDbWriteMode writeMode)
{
String requestUri;
BerkeleyDtoPut dataPost;
if (data.Key.Length <= bufferSize && data.Value.Length <= bufferSize)
{
requestUri = "api/database/writemultipleduplicate/?handle=" + db.Handle.ToString() + "&writemode=" + writeMode.ToStringEx();
dataPost = new BerkeleyDtoPut(data.Key, data.Value);
}
else
{
requestUri = "api/database/write/?handle=" + db.Handle.ToString() + "&writemode=" + writeMode.ToStringEx();
dataPost = data;
}
ObjectContent content = new ObjectContent<BerkeleyDtoPut>(dataPost, _formatter, (String)null);
HttpResponseMessage response = await _httpClient.PostAsync(requestUri, content).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
return new BerkeleyError(response.StatusCode);
BerkeleyDbError error = await SerializeHelper.GetErrorAsync(_serializer, response.Content).ConfigureAwait(false);
return new BerkeleyError(error);
}
public async Task<BerkeleyError> WriteAsync(Byte[] key, Byte[] value, BerkeleyDbWriteMode writeMode)
{
return await _methods.WriteAsync(this, key, value, writeMode).ConfigureAwait(false);
}
public override async Task<BerkeleyError> WriteAsync(BerkeleyDb db, Byte[] key, Byte[] value, BerkeleyDbWriteMode writeMode)
{
String requestUri = "api/database/write/?handle=" + db.Handle.ToString() + "&writemode=" + writeMode.ToStringEx();
var data = new BerkeleyDtoPut(key, value);
var content = new ObjectContent<BerkeleyDtoPut>(data, _formatter, (String)null);
HttpResponseMessage response = await _httpClient.PostAsync(requestUri, content).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
return new BerkeleyError(response.StatusCode);
BerkeleyDbError error = await SerializeHelper.GetErrorAsync(_serializer, response.Content).ConfigureAwait(false);
return new BerkeleyError(error);
}
public BerkeleyDbError PutMultipleKey(IntPtr pdb, Byte[] data, BerkeleyDbWriteMode flags)
{
var keyDbt = new db_dbt();
var dataDbt = new db_dbt();
try
{
keyDbt.Init(data);
keyDbt.flags |= db_dbt.DB_DBT_BULK;
dataDbt.flags |= db_dbt.DB_DBT_READONLY;
return (BerkeleyDbError)_put(pdb, IntPtr.Zero, ref keyDbt, ref dataDbt, (uint)flags | (int)BerkeleyDbMultiple.DB_MULTIPLE_KEY);
}
finally
{
keyDbt.Dispose();
dataDbt.Dispose();
}
}
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 BerkeleyDbError WriteMultipleKey([FromUri] ulong handle, BerkeleyDbWriteMode writeMode, [FromBody] Byte[] data)
{
DbHandle db = GetDb(handle);
return db.Methods.PutMultipleKey(db.Handle, data, writeMode);
}
public BerkeleyDbError WriteMultipleDuplicate([FromUri] ulong handle, BerkeleyDbWriteMode writeMode, [FromBody] BerkeleyDtoPut data)
{
DbHandle db = GetDb(handle);
return(db.Methods.PutMultipleDuplicate(db.Handle, data.Key, data.Value, writeMode));
}
