use {ErrorCode, IndyError};
use std::ffi::CString;
use std::ptr::null;
use utils::callbacks::{ClosureHandler, ResultHandler};
use ffi::pool;
use ffi::{ResponseEmptyCB,
ResponseStringCB,
ResponseI32CB};
use futures::Future;
use ffi::{CommandHandle, PoolHandle};
pub fn create_pool_ledger_config(pool_name: &str, pool_config: Option<&str>) -> Box<Future<Item=(), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec();
let err = _create_pool_ledger_config(command_handle, pool_name, pool_config, cb);
ResultHandler::empty(command_handle, err, receiver)
}
fn _create_pool_ledger_config(command_handle: CommandHandle, pool_name: &str, pool_config: Option<&str>, cb: Option<ResponseEmptyCB>) -> ErrorCode {
let pool_name = c_str!(pool_name);
let pool_config_str = opt_c_str!(pool_config);
ErrorCode::from(unsafe { pool::indy_create_pool_ledger_config(command_handle, pool_name.as_ptr(), opt_c_ptr!(pool_config, pool_config_str), cb) })
}
pub fn open_pool_ledger(pool_name: &str, config: Option<&str>) -> Box<Future<Item=CommandHandle, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_handle();
let err = _open_pool_ledger(command_handle, pool_name, config, cb);
ResultHandler::handle(command_handle, err, receiver)
}
fn _open_pool_ledger(command_handle: CommandHandle, pool_name: &str, config: Option<&str>, cb: Option<ResponseI32CB>) -> ErrorCode {
let pool_name = c_str!(pool_name);
let config_str = opt_c_str!(config);
ErrorCode::from(unsafe { pool::indy_open_pool_ledger(command_handle, pool_name.as_ptr(), opt_c_ptr!(config, config_str), cb) })
}
pub fn refresh_pool_ledger(pool_handle: PoolHandle) -> Box<Future<Item=(), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec();
let err = _refresh_pool_ledger(command_handle, pool_handle, cb);
ResultHandler::empty(command_handle, err, receiver)
}
fn _refresh_pool_ledger(command_handle: CommandHandle, pool_handle: PoolHandle, cb: Option<ResponseEmptyCB>) -> ErrorCode {
ErrorCode::from(unsafe { pool::indy_refresh_pool_ledger(command_handle, pool_handle, cb) })
}
pub fn list_pools() -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _list_pools(command_handle, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _list_pools(command_handle: CommandHandle, cb: Option<ResponseStringCB>) -> ErrorCode {
ErrorCode::from(unsafe { pool::indy_list_pools(command_handle, cb) })
}
pub fn close_pool_ledger(pool_handle: PoolHandle) -> Box<Future<Item=(), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec();
let err = _close_pool_ledger(command_handle, pool_handle, cb);
ResultHandler::empty(command_handle, err, receiver)
}
fn _close_pool_ledger(command_handle: CommandHandle, pool_handle: PoolHandle, cb: Option<ResponseEmptyCB>) -> ErrorCode {
ErrorCode::from(unsafe { pool::indy_close_pool_ledger(command_handle, pool_handle, cb) })
}
pub fn delete_pool_ledger(pool_name: &str) -> Box<Future<Item=(), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec();
let err = _delete_pool_ledger(command_handle, pool_name, cb);
ResultHandler::empty(command_handle, err, receiver)
}
fn _delete_pool_ledger(command_handle: CommandHandle, pool_name: &str, cb: Option<ResponseEmptyCB>) -> ErrorCode {
let pool_name = c_str!(pool_name);
ErrorCode::from(unsafe { pool::indy_delete_pool_ledger_config(command_handle, pool_name.as_ptr(), cb) })
}
pub fn set_protocol_version(protocol_version: usize) -> Box<Future<Item=(), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec();
let err = _set_protocol_version(command_handle, protocol_version, cb);
ResultHandler::empty(command_handle, err, receiver)
}
fn _set_protocol_version(command_handle: CommandHandle, protocol_version: usize, cb: Option<ResponseEmptyCB>) -> ErrorCode {
ErrorCode::from(unsafe {
pool::indy_set_protocol_version(command_handle, protocol_version, cb)
})
}