int clone_range(IoCtxImpl& io, const object_t& dst_oid, uint64_t dst_offset,
const object_t& src_oid, uint64_t src_offset, uint64_t len);
int read(IoCtxImpl& io, const object_t& oid, bufferlist& bl, size_t len, uint64_t off);
- int mapext(IoCtxImpl& io, const object_t& oid, uint64_t off, size_t len, std::map<uint64_t,uint64_t>& m);
- int sparse_read(IoCtxImpl& io, const object_t& oid, std::map<uint64_t,uint64_t>& m, bufferlist& bl,
- size_t len, uint64_t off);
+ int mapext(IoCtxImpl& io, const object_t& oid, uint64_t off, size_t len,
+ std::map<uint64_t,uint64_t>& m);
+ int sparse_read(IoCtxImpl& io, const object_t& oid, std::map<uint64_t,uint64_t>& m,
+ bufferlist& bl, size_t len, uint64_t off);
int remove(IoCtxImpl& io, const object_t& oid);
int stat(IoCtxImpl& io, const object_t& oid, uint64_t *psize, time_t *pmtime);
int trunc(IoCtxImpl& io, const object_t& oid, uint64_t size);
int get_fs_stats(ceph_statfs& result);
int pool_create(string& name, unsigned long long auid=0, __u8 crush_rule=0);
- int pool_create_async(string& name, PoolAsyncCompletionImpl *c, unsigned long long auid=0, __u8 crush_rule=0);
+ int pool_create_async(string& name, PoolAsyncCompletionImpl *c, unsigned long long auid=0,
+ __u8 crush_rule=0);
int pool_delete(const char *name);
int pool_change_auid(rados_ioctx_t io, unsigned long long auid);
int pool_get_auid(rados_ioctx_t io, unsigned long long *auid);
static AioCompletionImpl *aio_create_completion() {
return new AioCompletionImpl;
}
- static AioCompletionImpl *aio_create_completion(void *cb_arg, rados_callback_t cb_complete, rados_callback_t cb_safe) {
+ static AioCompletionImpl *aio_create_completion(void *cb_arg,
+ rados_callback_t cb_complete,
+ rados_callback_t cb_safe) {
AioCompletionImpl *c = new AioCompletionImpl;
if (cb_complete)
c->set_complete_callback(cb_arg, cb_complete);
librados::WatchCtx *ctx;
uint64_t linger_id;
- WatchContext(IoCtxImpl *io_ctx_impl_, const object_t& _oc, librados::WatchCtx *_ctx) : io_ctx_impl(io_ctx_impl_), oid(_oc), ctx(_ctx), linger_id(0) {
+ WatchContext(IoCtxImpl *io_ctx_impl_, const object_t& _oc, librados::WatchCtx *_ctx)
+ : io_ctx_impl(io_ctx_impl_), oid(_oc), ctx(_ctx), linger_id(0) {
io_ctx_impl->get();
}
~WatchContext() {
}
};
-librados::IoCtxImpl::
-IoCtxImpl()
+librados::IoCtxImpl::IoCtxImpl()
: aio_write_list_lock("librados::IoCtxImpl::aio_write_list_lock")
{
}
-librados::IoCtxImpl::
-IoCtxImpl(RadosClient *c, int pid, const char *pool_name_, snapid_t s)
+librados::IoCtxImpl::IoCtxImpl(RadosClient *c, int pid, const char *pool_name_, snapid_t s)
: ref_cnt(0), client(c), poolid(pid),
pool_name(pool_name_), snap_seq(s), assert_ver(0),
notify_timeout(c->cct->_conf->client_notify_timeout), oloc(pid),
{
}
-void librados::IoCtxImpl::
-set_snap_read(snapid_t s)
+void librados::IoCtxImpl::set_snap_read(snapid_t s)
{
if (!s)
s = CEPH_NOSNAP;
snap_seq = s;
}
-int librados::IoCtxImpl::
-set_snap_write_context(snapid_t seq, vector<snapid_t>& snaps)
+int librados::IoCtxImpl::set_snap_write_context(snapid_t seq, vector<snapid_t>& snaps)
{
::SnapContext n;
ldout(client->cct, 10) << "set snap write context: seq = " << seq << " and snaps = " << snaps << dendl;
return 0;
}
-int librados::RadosClient::
-connect()
+int librados::RadosClient::connect()
{
common_init_finish(cct);
return err;
}
-void librados::RadosClient::
-shutdown()
+void librados::RadosClient::shutdown()
{
lock.Lock();
monclient.shutdown();
ldout(cct, 1) << "shutdown" << dendl;
}
-librados::RadosClient::
-~RadosClient()
+librados::RadosClient::~RadosClient()
{
if (messenger)
messenger->destroy();
}
-bool librados::RadosClient::
-ms_dispatch(Message *m)
+bool librados::RadosClient::ms_dispatch(Message *m)
{
lock.Lock();
bool ret = _dispatch(m);
return ret;
}
-void librados::RadosClient::
-ms_handle_connect(Connection *con)
+void librados::RadosClient::ms_handle_connect(Connection *con)
{
Mutex::Locker l(lock);
objecter->ms_handle_connect(con);
}
-bool librados::RadosClient::
-ms_handle_reset(Connection *con)
+bool librados::RadosClient::ms_handle_reset(Connection *con)
{
Mutex::Locker l(lock);
objecter->ms_handle_reset(con);
return false;
}
-void librados::RadosClient::
-ms_handle_remote_reset(Connection *con)
+void librados::RadosClient::ms_handle_remote_reset(Connection *con)
{
Mutex::Locker l(lock);
objecter->ms_handle_remote_reset(con);
}
-bool librados::RadosClient::
-_dispatch(Message *m)
+bool librados::RadosClient::_dispatch(Message *m)
{
switch (m->get_type()) {
// OSD
return true;
}
-int librados::RadosClient::
-pool_list(std::list<std::string>& v)
+int librados::RadosClient::pool_list(std::list<std::string>& v)
{
Mutex::Locker l(lock);
for (map<int,pg_pool_t>::const_iterator p = osdmap.get_pools().begin();
return 0;
}
-int librados::RadosClient::
-get_pool_stats(std::list<string>& pools, map<string,::pool_stat_t>& result)
+int librados::RadosClient::get_pool_stats(std::list<string>& pools,
+ map<string,::pool_stat_t>& result)
{
Mutex mylock("RadosClient::get_pool_stats::mylock");
Cond cond;
return 0;
}
-int librados::RadosClient::
-get_fs_stats(ceph_statfs& stats)
+int librados::RadosClient::get_fs_stats(ceph_statfs& stats)
{
Mutex mylock ("RadosClient::get_fs_stats::mylock");
Cond cond;
// SNAPS
-int librados::RadosClient::
-snap_create(rados_ioctx_t io, const char *snapName)
+int librados::RadosClient::snap_create(rados_ioctx_t io, const char *snapName)
{
int reply;
int poolID = ((IoCtxImpl *)io)->poolid;
return reply;
}
-int librados::RadosClient::
-selfmanaged_snap_create(rados_ioctx_t io, uint64_t *psnapid)
+int librados::RadosClient::selfmanaged_snap_create(rados_ioctx_t io, uint64_t *psnapid)
{
int reply;
int poolID = ((IoCtxImpl *)io)->poolid;
return reply;
}
-int librados::RadosClient::
-snap_remove(rados_ioctx_t io, const char *snapName)
+int librados::RadosClient::snap_remove(rados_ioctx_t io, const char *snapName)
{
int reply;
int poolID = ((IoCtxImpl *)io)->poolid;
return reply;
}
-int librados::RadosClient::
-selfmanaged_snap_rollback_object(rados_ioctx_t io,
- const object_t& oid, ::SnapContext& snapc, uint64_t snapid)
+int librados::RadosClient::selfmanaged_snap_rollback_object(rados_ioctx_t io,
+ const object_t& oid,
+ ::SnapContext& snapc,
+ uint64_t snapid)
{
int reply;
IoCtxImpl* ctx = (IoCtxImpl *) io;
return reply;
}
-int librados::RadosClient::
-rollback(rados_ioctx_t io_, const object_t& oid,
- const char *snapName)
+int librados::RadosClient::rollback(rados_ioctx_t io_, const object_t& oid,
+ const char *snapName)
{
IoCtxImpl* io = (IoCtxImpl *) io_;
string sName(snapName);
return selfmanaged_snap_rollback_object(io_, oid, io->snapc, snap);
}
-int librados::RadosClient::
-selfmanaged_snap_remove(rados_ioctx_t io, uint64_t snapid)
+int librados::RadosClient::selfmanaged_snap_remove(rados_ioctx_t io, uint64_t snapid)
{
int reply;
int poolID = ((IoCtxImpl *)io)->poolid;
return (int)reply;
}
-int librados::RadosClient::
-pool_create(string& name, unsigned long long auid,
- __u8 crush_rule)
+int librados::RadosClient::pool_create(string& name, unsigned long long auid,
+ __u8 crush_rule)
{
int reply;
return reply;
}
-int librados::RadosClient::
-pool_create_async(string& name, PoolAsyncCompletionImpl *c, unsigned long long auid,
- __u8 crush_rule)
+int librados::RadosClient::pool_create_async(string& name, PoolAsyncCompletionImpl *c,
+ unsigned long long auid,
+ __u8 crush_rule)
{
Mutex::Locker l(lock);
objecter->create_pool(name,
return 0;
}
-int librados::RadosClient::
-pool_delete(const char *name)
+int librados::RadosClient::pool_delete(const char *name)
{
int tmp_pool_id = osdmap.lookup_pg_pool_name(name);
if (tmp_pool_id < 0)
return reply;
}
-int librados::RadosClient::
-pool_delete_async(const char *name, PoolAsyncCompletionImpl *c)
+int librados::RadosClient::pool_delete_async(const char *name, PoolAsyncCompletionImpl *c)
{
int tmp_pool_id = osdmap.lookup_pg_pool_name(name);
if (tmp_pool_id < 0)
* auid: the auid you wish the io to have.
* Returns: 0 on success, or -ERROR# on failure.
*/
-int librados::RadosClient::
-pool_change_auid(rados_ioctx_t io, unsigned long long auid)
+int librados::RadosClient::pool_change_auid(rados_ioctx_t io, unsigned long long auid)
{
int reply;
return reply;
}
-int librados::RadosClient::
-pool_change_auid_async(rados_ioctx_t io, unsigned long long auid, PoolAsyncCompletionImpl *c)
+int librados::RadosClient::pool_change_auid_async(rados_ioctx_t io, unsigned long long auid,
+ PoolAsyncCompletionImpl *c)
{
int poolID = ((IoCtxImpl *)io)->poolid;
return 0;
}
-int librados::RadosClient::
-pool_get_auid(rados_ioctx_t io, unsigned long long *auid)
+int librados::RadosClient::pool_get_auid(rados_ioctx_t io, unsigned long long *auid)
{
Mutex::Locker l(lock);
int pool_id = ((IoCtxImpl *)io)->poolid;
return 0;
}
-int librados::RadosClient::
-snap_list(IoCtxImpl *io, vector<uint64_t> *snaps)
+int librados::RadosClient::snap_list(IoCtxImpl *io, vector<uint64_t> *snaps)
{
Mutex::Locker l(lock);
const pg_pool_t *pi = objecter->osdmap->get_pg_pool(io->poolid);
return 0;
}
-int librados::RadosClient::
-snap_lookup(IoCtxImpl *io, const char *name, uint64_t *snapid)
+int librados::RadosClient::snap_lookup(IoCtxImpl *io, const char *name, uint64_t *snapid)
{
Mutex::Locker l(lock);
const pg_pool_t *pi = objecter->osdmap->get_pg_pool(io->poolid);
return -ENOENT;
}
-int librados::RadosClient::
-snap_get_name(IoCtxImpl *io, uint64_t snapid, std::string *s)
+int librados::RadosClient::snap_get_name(IoCtxImpl *io, uint64_t snapid, std::string *s)
{
Mutex::Locker l(lock);
const pg_pool_t *pi = objecter->osdmap->get_pg_pool(io->poolid);
return 0;
}
-int librados::RadosClient::
-snap_get_stamp(IoCtxImpl *io, uint64_t snapid, time_t *t)
+int librados::RadosClient::snap_get_stamp(IoCtxImpl *io, uint64_t snapid, time_t *t)
{
Mutex::Locker l(lock);
const pg_pool_t *pi = objecter->osdmap->get_pg_pool(io->poolid);
// IO
-int librados::RadosClient::
-list(Objecter::ListContext *context, int max_entries)
+int librados::RadosClient::list(Objecter::ListContext *context, int max_entries)
{
Cond cond;
bool done;
return r;
}
-int librados::RadosClient::
-create(IoCtxImpl& io, const object_t& oid, bool exclusive)
+int librados::RadosClient::create(IoCtxImpl& io, const object_t& oid, bool exclusive)
{
utime_t ut = ceph_clock_now(cct);
return r;
}
-int librados::RadosClient::create(IoCtxImpl& io, const object_t& oid, bool exclusive, const std::string& category)
+int librados::RadosClient::create(IoCtxImpl& io, const object_t& oid, bool exclusive,
+ const std::string& category)
{
utime_t ut = ceph_clock_now(cct);
return pop;
}
-int librados::RadosClient::
-write(IoCtxImpl& io, const object_t& oid, bufferlist& bl, size_t len, uint64_t off)
+int librados::RadosClient::write(IoCtxImpl& io, const object_t& oid, bufferlist& bl,
+ size_t len, uint64_t off)
{
utime_t ut = ceph_clock_now(cct);
return len;
}
-int librados::RadosClient::
-append(IoCtxImpl& io, const object_t& oid, bufferlist& bl, size_t len)
+int librados::RadosClient::append(IoCtxImpl& io, const object_t& oid, bufferlist& bl, size_t len)
{
utime_t ut = ceph_clock_now(cct);
return len;
}
-int librados::RadosClient::
-write_full(IoCtxImpl& io, const object_t& oid, bufferlist& bl)
+int librados::RadosClient::write_full(IoCtxImpl& io, const object_t& oid, bufferlist& bl)
{
utime_t ut = ceph_clock_now(cct);
return r;
}
-int librados::RadosClient::
-clone_range(IoCtxImpl& io, const object_t& dst_oid, uint64_t dst_offset, const object_t& src_oid, uint64_t src_offset, uint64_t len)
+int librados::RadosClient::clone_range(IoCtxImpl& io,
+ const object_t& dst_oid, uint64_t dst_offset,
+ const object_t& src_oid, uint64_t src_offset,
+ uint64_t len)
{
utime_t ut = ceph_clock_now(cct);
return r;
}
-int librados::RadosClient::
-operate(IoCtxImpl& io, const object_t& oid, ::ObjectOperation *o, time_t *pmtime)
+int librados::RadosClient::operate(IoCtxImpl& io, const object_t& oid,
+ ::ObjectOperation *o, time_t *pmtime)
{
utime_t ut;
if (pmtime) {
return r;
}
-int librados::RadosClient::
-operate_read(IoCtxImpl& io, const object_t& oid, ::ObjectOperation *o, bufferlist *pbl)
+int librados::RadosClient::operate_read(IoCtxImpl& io, const object_t& oid,
+ ::ObjectOperation *o, bufferlist *pbl)
{
utime_t ut = ceph_clock_now(cct);
return r;
}
-int librados::RadosClient::
-aio_operate(IoCtxImpl& io, const object_t& oid, ::ObjectOperation *o, AioCompletionImpl *c)
+int librados::RadosClient::aio_operate(IoCtxImpl& io, const object_t& oid,
+ ::ObjectOperation *o, AioCompletionImpl *c)
{
utime_t ut = ceph_clock_now(cct);
Context *onack = new C_aio_Ack(c);
return 0;
}
-int librados::RadosClient::
-aio_read(IoCtxImpl& io, const object_t oid, AioCompletionImpl *c,
- bufferlist *pbl, size_t len, uint64_t off)
+int librados::RadosClient::aio_read(IoCtxImpl& io, const object_t oid, AioCompletionImpl *c,
+ bufferlist *pbl, size_t len, uint64_t off)
{
Context *onack = new C_aio_Ack(c);
return 0;
}
-int librados::RadosClient::
-aio_read(IoCtxImpl& io, const object_t oid, AioCompletionImpl *c,
- char *buf, size_t len, uint64_t off)
+int librados::RadosClient::aio_read(IoCtxImpl& io, const object_t oid, AioCompletionImpl *c,
+ char *buf, size_t len, uint64_t off)
{
Context *onack = new C_aio_Ack(c);
return 0;
}
-int librados::RadosClient::
-aio_sparse_read(IoCtxImpl& io, const object_t oid,
- AioCompletionImpl *c, std::map<uint64_t,uint64_t> *m,
- bufferlist *data_bl, size_t len, uint64_t off)
+int librados::RadosClient::aio_sparse_read(IoCtxImpl& io, const object_t oid,
+ AioCompletionImpl *c, std::map<uint64_t,uint64_t> *m,
+ bufferlist *data_bl, size_t len, uint64_t off)
{
C_aio_sparse_read_Ack *onack = new C_aio_sparse_read_Ack(c);
return 0;
}
-int librados::RadosClient::
-aio_write(IoCtxImpl& io, const object_t &oid, AioCompletionImpl *c,
- const bufferlist& bl, size_t len, uint64_t off)
+int librados::RadosClient::aio_write(IoCtxImpl& io, const object_t &oid, AioCompletionImpl *c,
+ const bufferlist& bl, size_t len, uint64_t off)
{
utime_t ut = ceph_clock_now(cct);
return 0;
}
-int librados::RadosClient::
-aio_append(IoCtxImpl& io, const object_t &oid, AioCompletionImpl *c,
- const bufferlist& bl, size_t len)
+int librados::RadosClient::aio_append(IoCtxImpl& io, const object_t &oid, AioCompletionImpl *c,
+ const bufferlist& bl, size_t len)
{
utime_t ut = ceph_clock_now(cct);
return 0;
}
-int librados::RadosClient::
-aio_write_full(IoCtxImpl& io, const object_t &oid,
- AioCompletionImpl *c, const bufferlist& bl)
+int librados::RadosClient::aio_write_full(IoCtxImpl& io, const object_t &oid,
+ AioCompletionImpl *c, const bufferlist& bl)
{
utime_t ut = ceph_clock_now(cct);
return 0;
}
-int librados::RadosClient::
-remove(IoCtxImpl& io, const object_t& oid)
+int librados::RadosClient::remove(IoCtxImpl& io, const object_t& oid)
{
::SnapContext snapc;
utime_t ut = ceph_clock_now(cct);
return r;
}
-int librados::RadosClient::
-trunc(IoCtxImpl& io, const object_t& oid, uint64_t size)
+int librados::RadosClient::trunc(IoCtxImpl& io, const object_t& oid, uint64_t size)
{
utime_t ut = ceph_clock_now(cct);
}
-int librados::RadosClient::
-exec(IoCtxImpl& io, const object_t& oid, const char *cls, const char *method,
- bufferlist& inbl, bufferlist& outbl)
+int librados::RadosClient::exec(IoCtxImpl& io, const object_t& oid,
+ const char *cls, const char *method,
+ bufferlist& inbl, bufferlist& outbl)
{
utime_t ut = ceph_clock_now(cct);
return r;
}
-int librados::
-RadosClient::read(IoCtxImpl& io, const object_t& oid,
- bufferlist& bl, size_t len, uint64_t off)
+int librados::RadosClient::read(IoCtxImpl& io, const object_t& oid,
+ bufferlist& bl, size_t len, uint64_t off)
{
CephContext *cct = io.client->cct;
Mutex mylock("RadosClient::read::mylock");
return bl.length();
}
-int librados::RadosClient::
-mapext(IoCtxImpl& io, const object_t& oid, uint64_t off, size_t len, std::map<uint64_t,uint64_t>& m)
+int librados::RadosClient::mapext(IoCtxImpl& io, const object_t& oid,
+ uint64_t off, size_t len, std::map<uint64_t,uint64_t>& m)
{
CephContext *cct = io.client->cct;
bufferlist bl;
return m.size();
}
-int librados::RadosClient::
-sparse_read(IoCtxImpl& io, const object_t& oid,
- std::map<uint64_t,uint64_t>& m, bufferlist& data_bl, size_t len, uint64_t off)
+int librados::RadosClient::sparse_read(IoCtxImpl& io, const object_t& oid,
+ std::map<uint64_t,uint64_t>& m,
+ bufferlist& data_bl, size_t len, uint64_t off)
{
CephContext *cct = io.client->cct;
bufferlist bl;
return m.size();
}
-int librados::RadosClient::
-stat(IoCtxImpl& io, const object_t& oid, uint64_t *psize, time_t *pmtime)
+int librados::RadosClient::stat(IoCtxImpl& io, const object_t& oid, uint64_t *psize, time_t *pmtime)
{
CephContext *cct = io.client->cct;
Mutex mylock("RadosClient::stat::mylock");
return r;
}
-int librados::RadosClient::
-getxattr(IoCtxImpl& io, const object_t& oid, const char *name, bufferlist& bl)
+int librados::RadosClient::getxattr(IoCtxImpl& io, const object_t& oid,
+ const char *name, bufferlist& bl)
{
CephContext *cct = io.client->cct;
Mutex mylock("RadosClient::getxattr::mylock");
return bl.length();
}
-int librados::RadosClient::
-rmxattr(IoCtxImpl& io, const object_t& oid, const char *name)
+int librados::RadosClient::rmxattr(IoCtxImpl& io, const object_t& oid, const char *name)
{
utime_t ut = ceph_clock_now(cct);
return 0;
}
-int librados::RadosClient::
-setxattr(IoCtxImpl& io, const object_t& oid, const char *name, bufferlist& bl)
+int librados::RadosClient::setxattr(IoCtxImpl& io, const object_t& oid,
+ const char *name, bufferlist& bl)
{
utime_t ut = ceph_clock_now(cct);
return 0;
}
-int librados::RadosClient::
-getxattrs(IoCtxImpl& io, const object_t& oid, map<std::string, bufferlist>& attrset)
+int librados::RadosClient::getxattrs(IoCtxImpl& io, const object_t& oid,
+ map<std::string, bufferlist>& attrset)
{
CephContext *cct = io.client->cct;
Mutex mylock("RadosClient::getexattrs::mylock");
return r;
}
-void librados::RadosClient::
-watch_notify(MWatchNotify *m)
+void librados::RadosClient::watch_notify(MWatchNotify *m)
{
assert(lock.is_locked());
WatchContext *wc = NULL;
wc->notify(this, m);
}
-int librados::RadosClient::
-watch(IoCtxImpl& io, const object_t& oid, uint64_t ver,
- uint64_t *cookie, librados::WatchCtx *ctx)
+int librados::RadosClient::watch(IoCtxImpl& io, const object_t& oid, uint64_t ver,
+ uint64_t *cookie, librados::WatchCtx *ctx)
{
utime_t ut = ceph_clock_now(cct);
/* this is called with RadosClient::lock held */
-int librados::RadosClient::
-_notify_ack(IoCtxImpl& io, const object_t& oid, uint64_t notify_id, uint64_t ver)
+int librados::RadosClient::_notify_ack(IoCtxImpl& io, const object_t& oid,
+ uint64_t notify_id, uint64_t ver)
{
utime_t ut = ceph_clock_now(cct);
return 0;
}
-int librados::RadosClient::
-unwatch(IoCtxImpl& io, const object_t& oid, uint64_t cookie)
+int librados::RadosClient::unwatch(IoCtxImpl& io, const object_t& oid, uint64_t cookie)
{
utime_t ut = ceph_clock_now(cct);
bufferlist inbl, outbl;
return r;
}// ---------------------------------------------
-int librados::RadosClient::
-notify(IoCtxImpl& io, const object_t& oid, uint64_t ver, bufferlist& bl)
+int librados::RadosClient::notify(IoCtxImpl& io, const object_t& oid, uint64_t ver, bufferlist& bl)
{
utime_t ut = ceph_clock_now(cct);
bufferlist inbl, outbl;
}
///////////////////////////// ObjectIterator /////////////////////////////
-librados::ObjectIterator::
-ObjectIterator(ObjListCtx *ctx_)
-: ctx(ctx_)
+librados::ObjectIterator::ObjectIterator(ObjListCtx *ctx_)
+ : ctx(ctx_)
{
}
-librados::ObjectIterator::
-~ObjectIterator()
+librados::ObjectIterator::~ObjectIterator()
{
ctx.reset();
}
-bool librados::ObjectIterator::
-operator==(const librados::ObjectIterator& rhs) const {
+bool librados::ObjectIterator::operator==(const librados::ObjectIterator& rhs) const {
return (ctx.get() == rhs.ctx.get());
}
-bool librados::ObjectIterator::
-operator!=(const librados::ObjectIterator& rhs) const {
+bool librados::ObjectIterator::operator!=(const librados::ObjectIterator& rhs) const {
return (ctx.get() != rhs.ctx.get());
}
-const std::string& librados::ObjectIterator::
-operator*() const {
+const std::string& librados::ObjectIterator::operator*() const {
return cur_obj;
}
-librados::ObjectIterator& librados::ObjectIterator::
-operator++()
+librados::ObjectIterator& librados::ObjectIterator::operator++()
{
get_next();
return *this;
}
-librados::ObjectIterator librados::ObjectIterator::
-operator++(int)
+librados::ObjectIterator librados::ObjectIterator::operator++(int)
{
librados::ObjectIterator ret(*this);
get_next();
return ret;
}
-void librados::ObjectIterator::
-get_next()
+void librados::ObjectIterator::get_next()
{
const char *entry;
int ret = rados_objects_list_next(ctx.get(), &entry);
cur_obj = entry;
}
-const librados::ObjectIterator librados::ObjectIterator::
-__EndObjectIterator(NULL);
+const librados::ObjectIterator librados::ObjectIterator::__EndObjectIterator(NULL);
///////////////////////////// PoolAsyncCompletion //////////////////////////////
-int librados::PoolAsyncCompletion::PoolAsyncCompletion::
-set_callback(void *cb_arg, rados_callback_t cb)
+int librados::PoolAsyncCompletion::PoolAsyncCompletion::set_callback(void *cb_arg,
+ rados_callback_t cb)
{
PoolAsyncCompletionImpl *c = (PoolAsyncCompletionImpl *)pc;
return c->set_callback(cb_arg, cb);
}
-int librados::PoolAsyncCompletion::PoolAsyncCompletion::
-wait()
+int librados::PoolAsyncCompletion::PoolAsyncCompletion::wait()
{
PoolAsyncCompletionImpl *c = (PoolAsyncCompletionImpl *)pc;
return c->wait();
}
-bool librados::PoolAsyncCompletion::PoolAsyncCompletion::
-is_complete()
+bool librados::PoolAsyncCompletion::PoolAsyncCompletion::is_complete()
{
PoolAsyncCompletionImpl *c = (PoolAsyncCompletionImpl *)pc;
return c->is_complete();
}
-int librados::PoolAsyncCompletion::PoolAsyncCompletion::
-get_return_value()
+int librados::PoolAsyncCompletion::PoolAsyncCompletion::get_return_value()
{
PoolAsyncCompletionImpl *c = (PoolAsyncCompletionImpl *)pc;
return c->get_return_value();
}
-void librados::PoolAsyncCompletion::PoolAsyncCompletion::
-release()
+void librados::PoolAsyncCompletion::PoolAsyncCompletion::release()
{
PoolAsyncCompletionImpl *c = (PoolAsyncCompletionImpl *)pc;
c->release();
}
///////////////////////////// AioCompletion //////////////////////////////
-int librados::AioCompletion::AioCompletion::
-set_complete_callback(void *cb_arg, rados_callback_t cb)
+int librados::AioCompletion::AioCompletion::set_complete_callback(void *cb_arg, rados_callback_t cb)
{
AioCompletionImpl *c = (AioCompletionImpl *)pc;
return c->set_complete_callback(cb_arg, cb);
}
-int librados::AioCompletion::AioCompletion::
-set_safe_callback(void *cb_arg, rados_callback_t cb)
+int librados::AioCompletion::AioCompletion::set_safe_callback(void *cb_arg, rados_callback_t cb)
{
AioCompletionImpl *c = (AioCompletionImpl *)pc;
return c->set_safe_callback(cb_arg, cb);
}
-int librados::AioCompletion::AioCompletion::
-wait_for_complete()
+int librados::AioCompletion::AioCompletion::wait_for_complete()
{
AioCompletionImpl *c = (AioCompletionImpl *)pc;
return c->wait_for_complete();
}
-int librados::AioCompletion::AioCompletion::
-wait_for_safe()
+int librados::AioCompletion::AioCompletion::wait_for_safe()
{
AioCompletionImpl *c = (AioCompletionImpl *)pc;
return c->wait_for_safe();
}
-bool librados::AioCompletion::AioCompletion::
-is_complete()
+bool librados::AioCompletion::AioCompletion::is_complete()
{
AioCompletionImpl *c = (AioCompletionImpl *)pc;
return c->is_complete();
}
-bool librados::AioCompletion::AioCompletion::
-is_safe()
+bool librados::AioCompletion::AioCompletion::is_safe()
{
AioCompletionImpl *c = (AioCompletionImpl *)pc;
return c->is_safe();
}
-int librados::AioCompletion::AioCompletion::
-get_return_value()
+int librados::AioCompletion::AioCompletion::get_return_value()
{
AioCompletionImpl *c = (AioCompletionImpl *)pc;
return c->get_return_value();
}
-int librados::AioCompletion::AioCompletion::
-get_version()
+int librados::AioCompletion::AioCompletion::get_version()
{
AioCompletionImpl *c = (AioCompletionImpl *)pc;
return c->get_version();
}
-void librados::AioCompletion::AioCompletion::
-release()
+void librados::AioCompletion::AioCompletion::release()
{
AioCompletionImpl *c = (AioCompletionImpl *)pc;
c->release();
}
///////////////////////////// IoCtx //////////////////////////////
-librados::IoCtx::
-IoCtx() : io_ctx_impl(NULL)
+librados::IoCtx::IoCtx() : io_ctx_impl(NULL)
{
}
-void librados::IoCtx::
-from_rados_ioctx_t(rados_ioctx_t p, IoCtx &io)
+void librados::IoCtx::from_rados_ioctx_t(rados_ioctx_t p, IoCtx &io)
{
IoCtxImpl *io_ctx_impl = (IoCtxImpl*)p;
io_ctx_impl->get();
}
-librados::IoCtx::
-IoCtx(const IoCtx& rhs)
+librados::IoCtx::IoCtx(const IoCtx& rhs)
{
io_ctx_impl = rhs.io_ctx_impl;
io_ctx_impl->get();
}
-librados::IoCtx& librados::IoCtx::
-operator=(const IoCtx& rhs)
+librados::IoCtx& librados::IoCtx::operator=(const IoCtx& rhs)
{
if (io_ctx_impl)
io_ctx_impl->put();
return *this;
}
-librados::IoCtx::
-~IoCtx()
+librados::IoCtx::~IoCtx()
{
close();
}
-void librados::IoCtx::
-close()
+void librados::IoCtx::close()
{
if (io_ctx_impl)
io_ctx_impl->put();
io_ctx_impl = 0;
}
-void librados::IoCtx::
-dup(const IoCtx& rhs)
+void librados::IoCtx::dup(const IoCtx& rhs)
{
if (io_ctx_impl)
io_ctx_impl->put();
io_ctx_impl->dup(*rhs.io_ctx_impl);
}
-int librados::IoCtx::
-set_auid(uint64_t auid_)
+int librados::IoCtx::set_auid(uint64_t auid_)
{
return io_ctx_impl->client->pool_change_auid(io_ctx_impl, auid_);
}
-int librados::IoCtx::
-set_auid_async(uint64_t auid_, PoolAsyncCompletion *c)
+int librados::IoCtx::set_auid_async(uint64_t auid_, PoolAsyncCompletion *c)
{
return io_ctx_impl->client->pool_change_auid_async(io_ctx_impl, auid_, c->pc);
}
-int librados::IoCtx::
-get_auid(uint64_t *auid_)
+int librados::IoCtx::get_auid(uint64_t *auid_)
{
return io_ctx_impl->client->pool_get_auid(io_ctx_impl, (unsigned long long *)auid_);
}
return io_ctx_impl->client->create(*io_ctx_impl, obj, exclusive, category);
}
-int librados::IoCtx::
-write(const std::string& oid, bufferlist& bl, size_t len, uint64_t off)
+int librados::IoCtx::write(const std::string& oid, bufferlist& bl, size_t len, uint64_t off)
{
object_t obj(oid);
return io_ctx_impl->client->write(*io_ctx_impl, obj, bl, len, off);
}
-int librados::IoCtx::
-append(const std::string& oid, bufferlist& bl, size_t len)
+int librados::IoCtx::append(const std::string& oid, bufferlist& bl, size_t len)
{
object_t obj(oid);
return io_ctx_impl->client->append(*io_ctx_impl, obj, bl, len);
}
-int librados::IoCtx::
-write_full(const std::string& oid, bufferlist& bl)
+int librados::IoCtx::write_full(const std::string& oid, bufferlist& bl)
{
object_t obj(oid);
return io_ctx_impl->client->write_full(*io_ctx_impl, obj, bl);
}
-int librados::IoCtx::
-clone_range(const std::string& dst_oid, uint64_t dst_off,
- const std::string& src_oid, uint64_t src_off,
- size_t len)
+int librados::IoCtx::clone_range(const std::string& dst_oid, uint64_t dst_off,
+ const std::string& src_oid, uint64_t src_off,
+ size_t len)
{
object_t src(src_oid), dst(dst_oid);
return io_ctx_impl->client->clone_range(*io_ctx_impl, dst, dst_off, src, src_off, len);
}
-int librados::IoCtx::
-read(const std::string& oid, bufferlist& bl, size_t len, uint64_t off)
+int librados::IoCtx::read(const std::string& oid, bufferlist& bl, size_t len, uint64_t off)
{
object_t obj(oid);
return io_ctx_impl->client->read(*io_ctx_impl, obj, bl, len, off);
}
-int librados::IoCtx::
-remove(const std::string& oid)
+int librados::IoCtx::remove(const std::string& oid)
{
object_t obj(oid);
return io_ctx_impl->client->remove(*io_ctx_impl, obj);
}
-int librados::IoCtx::
-trunc(const std::string& oid, uint64_t size)
+int librados::IoCtx::trunc(const std::string& oid, uint64_t size)
{
object_t obj(oid);
return io_ctx_impl->client->trunc(*io_ctx_impl, obj, size);
}
-int librados::IoCtx::
-mapext(const std::string& oid, uint64_t off, size_t len, std::map<uint64_t,uint64_t>& m)
+int librados::IoCtx::mapext(const std::string& oid, uint64_t off, size_t len,
+ std::map<uint64_t,uint64_t>& m)
{
object_t obj(oid);
return io_ctx_impl->client->mapext(*io_ctx_impl, oid, off, len, m);
}
-int librados::IoCtx::
-sparse_read(const std::string& oid, std::map<uint64_t,uint64_t>& m,
- bufferlist& bl, size_t len, uint64_t off)
+int librados::IoCtx::sparse_read(const std::string& oid, std::map<uint64_t,uint64_t>& m,
+ bufferlist& bl, size_t len, uint64_t off)
{
object_t obj(oid);
return io_ctx_impl->client->sparse_read(*io_ctx_impl, oid, m, bl, len, off);
}
-int librados::IoCtx::
-getxattr(const std::string& oid, const char *name, bufferlist& bl)
+int librados::IoCtx::getxattr(const std::string& oid, const char *name, bufferlist& bl)
{
object_t obj(oid);
return io_ctx_impl->client->getxattr(*io_ctx_impl, obj, name, bl);
}
-int librados::IoCtx::
-getxattrs(const std::string& oid, map<std::string, bufferlist>& attrset)
+int librados::IoCtx::getxattrs(const std::string& oid, map<std::string, bufferlist>& attrset)
{
object_t obj(oid);
return io_ctx_impl->client->getxattrs(*io_ctx_impl, obj, attrset);
}
-int librados::IoCtx::
-setxattr(const std::string& oid, const char *name, bufferlist& bl)
+int librados::IoCtx::setxattr(const std::string& oid, const char *name, bufferlist& bl)
{
object_t obj(oid);
return io_ctx_impl->client->setxattr(*io_ctx_impl, obj, name, bl);
}
-int librados::IoCtx::
-rmxattr(const std::string& oid, const char *name)
+int librados::IoCtx::rmxattr(const std::string& oid, const char *name)
{
object_t obj(oid);
return io_ctx_impl->client->rmxattr(*io_ctx_impl, obj, name);
}
-int librados::IoCtx::
-stat(const std::string& oid, uint64_t *psize, time_t *pmtime)
+int librados::IoCtx::stat(const std::string& oid, uint64_t *psize, time_t *pmtime)
{
object_t obj(oid);
return io_ctx_impl->client->stat(*io_ctx_impl, oid, psize, pmtime);
}
-int librados::IoCtx::
-exec(const std::string& oid, const char *cls, const char *method,
- bufferlist& inbl, bufferlist& outbl)
+int librados::IoCtx::exec(const std::string& oid, const char *cls, const char *method,
+ bufferlist& inbl, bufferlist& outbl)
{
object_t obj(oid);
return io_ctx_impl->client->exec(*io_ctx_impl, obj, cls, method, inbl, outbl);
}
-void librados::IoCtx::
-snap_set_read(snap_t seq)
+void librados::IoCtx::snap_set_read(snap_t seq)
{
io_ctx_impl->set_snap_read(seq);
}
-int librados::IoCtx::
-selfmanaged_snap_set_write_ctx(snap_t seq, vector<snap_t>& snaps)
+int librados::IoCtx::selfmanaged_snap_set_write_ctx(snap_t seq, vector<snap_t>& snaps)
{
vector<snapid_t> snv;
snv.resize(snaps.size());
return io_ctx_impl->set_snap_write_context(seq, snv);
}
-int librados::IoCtx::
-snap_create(const char *snapname)
+int librados::IoCtx::snap_create(const char *snapname)
{
return io_ctx_impl->client->snap_create(io_ctx_impl, snapname);
}
-int librados::IoCtx::
-snap_lookup(const char *name, snap_t *snapid)
+int librados::IoCtx::snap_lookup(const char *name, snap_t *snapid)
{
return io_ctx_impl->client->snap_lookup(io_ctx_impl, name, snapid);
}
-int librados::IoCtx::
-snap_get_stamp(snap_t snapid, time_t *t)
+int librados::IoCtx::snap_get_stamp(snap_t snapid, time_t *t)
{
return io_ctx_impl->client->snap_get_stamp(io_ctx_impl, snapid, t);
}
-int librados::IoCtx::
-snap_get_name(snap_t snapid, std::string *s)
+int librados::IoCtx::snap_get_name(snap_t snapid, std::string *s)
{
return io_ctx_impl->client->snap_get_name(io_ctx_impl, snapid, s);
}
-int librados::IoCtx::
-snap_remove(const char *snapname)
+int librados::IoCtx::snap_remove(const char *snapname)
{
return io_ctx_impl->client->snap_remove(io_ctx_impl, snapname);
}
-int librados::IoCtx::
-snap_list(std::vector<snap_t> *snaps)
+int librados::IoCtx::snap_list(std::vector<snap_t> *snaps)
{
return io_ctx_impl->client->snap_list(io_ctx_impl, snaps);
}
-int librados::IoCtx::
-rollback(const std::string& oid, const char *snapname)
+int librados::IoCtx::rollback(const std::string& oid, const char *snapname)
{
return io_ctx_impl->client->rollback(io_ctx_impl, oid, snapname);
}
-int librados::IoCtx::
-selfmanaged_snap_create(uint64_t *snapid)
+int librados::IoCtx::selfmanaged_snap_create(uint64_t *snapid)
{
return io_ctx_impl->client->selfmanaged_snap_create(io_ctx_impl, snapid);
}
-int librados::IoCtx::
-selfmanaged_snap_remove(uint64_t snapid)
+int librados::IoCtx::selfmanaged_snap_remove(uint64_t snapid)
{
return io_ctx_impl->client->selfmanaged_snap_remove(io_ctx_impl, snapid);
}
-int librados::IoCtx::
-selfmanaged_snap_rollback(const std::string& oid, uint64_t snapid)
+int librados::IoCtx::selfmanaged_snap_rollback(const std::string& oid, uint64_t snapid)
{
return io_ctx_impl->client->selfmanaged_snap_rollback_object(io_ctx_impl,
oid,
snapid);
}
-librados::ObjectIterator librados::IoCtx::
-objects_begin()
+librados::ObjectIterator librados::IoCtx::objects_begin()
{
rados_list_ctx_t listh;
rados_objects_list_open(io_ctx_impl, &listh);
return iter;
}
-const librados::ObjectIterator& librados::IoCtx::
-objects_end() const
+const librados::ObjectIterator& librados::IoCtx::objects_end() const
{
return ObjectIterator::__EndObjectIterator;
}
-uint64_t librados::IoCtx::
-get_last_version()
+uint64_t librados::IoCtx::get_last_version()
{
eversion_t ver = io_ctx_impl->client->last_version(*io_ctx_impl);
return ver.version;
}
-int librados::IoCtx::
-aio_read(const std::string& oid, librados::AioCompletion *c,
- bufferlist *pbl, size_t len, uint64_t off)
+int librados::IoCtx::aio_read(const std::string& oid, librados::AioCompletion *c,
+ bufferlist *pbl, size_t len, uint64_t off)
{
return io_ctx_impl->client->aio_read(*io_ctx_impl, oid, c->pc, pbl, len, off);
}
-int librados::IoCtx::
-aio_sparse_read(const std::string& oid, librados::AioCompletion *c,
- std::map<uint64_t,uint64_t> *m, bufferlist *data_bl,
- size_t len, uint64_t off)
+int librados::IoCtx::aio_sparse_read(const std::string& oid, librados::AioCompletion *c,
+ std::map<uint64_t,uint64_t> *m, bufferlist *data_bl,
+ size_t len, uint64_t off)
{
return io_ctx_impl->client->aio_sparse_read(*io_ctx_impl, oid, c->pc,
m, data_bl, len, off);
}
-int librados::IoCtx::
-aio_write(const std::string& oid, librados::AioCompletion *c, const bufferlist& bl,
- size_t len, uint64_t off)
+int librados::IoCtx::aio_write(const std::string& oid, librados::AioCompletion *c,
+ const bufferlist& bl, size_t len, uint64_t off)
{
return io_ctx_impl->client->aio_write(*io_ctx_impl, oid, c->pc, bl, len, off);
}
-int librados::IoCtx::
-aio_append(const std::string& oid, librados::AioCompletion *c, const bufferlist& bl,
- size_t len)
+int librados::IoCtx::aio_append(const std::string& oid, librados::AioCompletion *c,
+ const bufferlist& bl, size_t len)
{
return io_ctx_impl->client->aio_append(*io_ctx_impl, oid, c->pc, bl, len);
}
-int librados::IoCtx::
-aio_write_full(const std::string& oid, librados::AioCompletion *c, const bufferlist& bl)
+int librados::IoCtx::aio_write_full(const std::string& oid, librados::AioCompletion *c,
+ const bufferlist& bl)
{
object_t obj(oid);
return io_ctx_impl->client->aio_write_full(*io_ctx_impl, obj, c->pc, bl);
}
-int librados::IoCtx::
-aio_flush()
+int librados::IoCtx::aio_flush()
{
io_ctx_impl->flush_aio_writes();
return 0;
}
-int librados::IoCtx::
-watch(const string& oid, uint64_t ver, uint64_t *cookie, librados::WatchCtx *ctx)
+int librados::IoCtx::watch(const string& oid, uint64_t ver, uint64_t *cookie,
+ librados::WatchCtx *ctx)
{
object_t obj(oid);
return io_ctx_impl->client->watch(*io_ctx_impl, obj, ver, cookie, ctx);
}
-int librados::IoCtx::
-unwatch(const string& oid, uint64_t handle)
+int librados::IoCtx::unwatch(const string& oid, uint64_t handle)
{
uint64_t cookie = handle;
object_t obj(oid);
return io_ctx_impl->client->unwatch(*io_ctx_impl, obj, cookie);
}
-int librados::IoCtx::
-notify(const string& oid, uint64_t ver, bufferlist& bl)
+int librados::IoCtx::notify(const string& oid, uint64_t ver, bufferlist& bl)
{
object_t obj(oid);
return io_ctx_impl->client->notify(*io_ctx_impl, obj, ver, bl);
}
-void librados::IoCtx::
-set_notify_timeout(uint32_t timeout)
+void librados::IoCtx::set_notify_timeout(uint32_t timeout)
{
io_ctx_impl->client->set_notify_timeout(*io_ctx_impl, timeout);
}
-void librados::IoCtx::
-set_assert_version(uint64_t ver)
+void librados::IoCtx::set_assert_version(uint64_t ver)
{
io_ctx_impl->client->set_assert_version(*io_ctx_impl, ver);
}
-void librados::IoCtx::
-set_assert_src_version(const std::string& oid, uint64_t ver)
+void librados::IoCtx::set_assert_src_version(const std::string& oid, uint64_t ver)
{
object_t obj(oid);
io_ctx_impl->client->set_assert_src_version(*io_ctx_impl, obj, ver);
}
-const std::string& librados::IoCtx::
-get_pool_name() const
+const std::string& librados::IoCtx::get_pool_name() const
{
return io_ctx_impl->pool_name;
}
-void librados::IoCtx::
-locator_set_key(const string& key)
+void librados::IoCtx::locator_set_key(const string& key)
{
io_ctx_impl->oloc.key = key;
}
-int librados::IoCtx::
-get_id()
+int librados::IoCtx::get_id()
{
return io_ctx_impl->get_id();
}
-CephContext *librados::IoCtx::
-cct()
+CephContext *librados::IoCtx::cct()
{
return io_ctx_impl->client->cct;
}
-librados::IoCtx::
-IoCtx(IoCtxImpl *io_ctx_impl_)
+librados::IoCtx::IoCtx(IoCtxImpl *io_ctx_impl_)
: io_ctx_impl(io_ctx_impl_)
{
}
///////////////////////////// Rados //////////////////////////////
-void librados::Rados::
-version(int *major, int *minor, int *extra)
+void librados::Rados::version(int *major, int *minor, int *extra)
{
rados_version(major, minor, extra);
}
-librados::Rados::
-Rados() : client(NULL)
+librados::Rados::Rados() : client(NULL)
{
}
-librados::Rados::
-~Rados()
+librados::Rados::~Rados()
{
shutdown();
}
-int librados::Rados::
-init(const char * const id)
+int librados::Rados::init(const char * const id)
{
return rados_create((rados_t *)&client, id);
}
-int librados::Rados::
-init_with_context(CephContext *cct_)
+int librados::Rados::init_with_context(CephContext *cct_)
{
return rados_create_with_context((rados_t *)&client, cct_);
}
-int librados::Rados::
-connect()
+int librados::Rados::connect()
{
return client->connect();
}
-void librados::Rados::
-shutdown()
+void librados::Rados::shutdown()
{
if (!client)
return;
client = NULL;
}
-int librados::Rados::
-conf_read_file(const char * const path) const
+int librados::Rados::conf_read_file(const char * const path) const
{
return rados_conf_read_file((rados_t)client, path);
}
-int librados::Rados::
-conf_parse_argv(int argc, const char ** argv) const
+int librados::Rados::conf_parse_argv(int argc, const char ** argv) const
{
return rados_conf_parse_argv((rados_t)client, argc, argv);
}
-int librados::Rados::
-conf_set(const char *option, const char *value)
+int librados::Rados::conf_set(const char *option, const char *value)
{
return rados_conf_set((rados_t)client, option, value);
}
-int librados::Rados::
-conf_get(const char *option, std::string &val)
+int librados::Rados::conf_get(const char *option, std::string &val)
{
char *str;
md_config_t *conf = client->cct->_conf;
return 0;
}
-int librados::Rados::
-pool_create(const char *name)
+int librados::Rados::pool_create(const char *name)
{
string str(name);
return client->pool_create(str);
}
-int librados::Rados::
-pool_create(const char *name, uint64_t auid)
+int librados::Rados::pool_create(const char *name, uint64_t auid)
{
string str(name);
return client->pool_create(str, auid);
}
-int librados::Rados::
-pool_create(const char *name, uint64_t auid, __u8 crush_rule)
+int librados::Rados::pool_create(const char *name, uint64_t auid, __u8 crush_rule)
{
string str(name);
return client->pool_create(str, auid, crush_rule);
}
-int librados::Rados::
-pool_create_async(const char *name, PoolAsyncCompletion *c)
+int librados::Rados::pool_create_async(const char *name, PoolAsyncCompletion *c)
{
string str(name);
return client->pool_create_async(str, c->pc);
}
-int librados::Rados::
-pool_create_async(const char *name, uint64_t auid, PoolAsyncCompletion *c)
+int librados::Rados::pool_create_async(const char *name, uint64_t auid, PoolAsyncCompletion *c)
{
string str(name);
return client->pool_create_async(str, c->pc, auid);
}
-int librados::Rados::
-pool_create_async(const char *name, uint64_t auid, __u8 crush_rule, PoolAsyncCompletion *c)
+int librados::Rados::pool_create_async(const char *name, uint64_t auid, __u8 crush_rule,
+ PoolAsyncCompletion *c)
{
string str(name);
return client->pool_create_async(str, c->pc, auid, crush_rule);
}
-int librados::Rados::
-pool_delete(const char *name)
+int librados::Rados::pool_delete(const char *name)
{
return client->pool_delete(name);
}
-int librados::Rados::
-pool_delete_async(const char *name, PoolAsyncCompletion *c)
+int librados::Rados::pool_delete_async(const char *name, PoolAsyncCompletion *c)
{
return client->pool_delete_async(name, c->pc);
}
-int librados::Rados::
-pool_list(std::list<std::string>& v)
+int librados::Rados::pool_list(std::list<std::string>& v)
{
return client->pool_list(v);
}
-int librados::Rados::
-pool_lookup(const char *name)
+int librados::Rados::pool_lookup(const char *name)
{
return client->lookup_pool(name);
}
-int librados::Rados::
-ioctx_create(const char *name, IoCtx &io)
+int librados::Rados::ioctx_create(const char *name, IoCtx &io)
{
rados_ioctx_t p;
int ret = rados_ioctx_create((rados_t)client, name, &p);
return 0;
}
-int librados::Rados::
-get_pool_stats(std::list<string>& v, std::map<string, stats_map>& result)
+int librados::Rados::get_pool_stats(std::list<string>& v, std::map<string, stats_map>& result)
{
string category;
return get_pool_stats(v, category, result);
}
-int librados::Rados::
-get_pool_stats(std::list<string>& v, string& category, std::map<string, stats_map>& result)
+int librados::Rados::get_pool_stats(std::list<string>& v, string& category,
+ std::map<string, stats_map>& result)
{
map<string,::pool_stat_t> rawresult;
int r = client->get_pool_stats(v, rawresult);
return r;
}
-int librados::Rados::
-cluster_stat(cluster_stat_t& result)
+int librados::Rados::cluster_stat(cluster_stat_t& result)
{
ceph_statfs stats;
int r = client->get_fs_stats(stats);
return r;
}
-librados::PoolAsyncCompletion *librados::Rados::
-pool_async_create_completion()
+librados::PoolAsyncCompletion *librados::Rados::pool_async_create_completion()
{
PoolAsyncCompletionImpl *c = RadosClient::pool_async_create_completion();
return new PoolAsyncCompletion(c);
}
-librados::AioCompletion *librados::Rados::
-aio_create_completion()
+librados::AioCompletion *librados::Rados::aio_create_completion()
{
AioCompletionImpl *c = RadosClient::aio_create_completion();
return new AioCompletion(c);
}
-librados::AioCompletion *librados::Rados::
-aio_create_completion(void *cb_arg, callback_t cb_complete, callback_t cb_safe)
+librados::AioCompletion *librados::Rados::aio_create_completion(void *cb_arg,
+ callback_t cb_complete,
+ callback_t cb_safe)
{
AioCompletionImpl *c = RadosClient::aio_create_completion(cb_arg, cb_complete, cb_safe);
return new AioCompletion(c);
projects / ceph.git / commitdiff