::decode(expiration, bl);
}
};
-WRITE_CLASS_ENCODER(ExpiringCryptoKey);
+WRITE_CLASS_ENCODER(ExpiringCryptoKey)
static inline ostream& operator<<(ostream& out, const ExpiringCryptoKey& c)
{
void dump();
};
-WRITE_CLASS_ENCODER(RotatingSecrets);
+WRITE_CLASS_ENCODER(RotatingSecrets)
void to_str(std::string& s) const;
};
-WRITE_CLASS_ENCODER(CryptoKey);
+WRITE_CLASS_ENCODER(CryptoKey)
static inline ostream& operator<<(ostream& out, const CryptoKey& k)
{
}
};
-WRITE_CLASS_ENCODER(KeyServerData);
-WRITE_CLASS_ENCODER(KeyServerData::Incremental);
+WRITE_CLASS_ENCODER(KeyServerData)
+WRITE_CLASS_ENCODER(KeyServerData::Incremental)
map<EntityName, EntityAuth>::iterator secrets_end()
{ return data.secrets_end(); }
};
-WRITE_CLASS_ENCODER(KeyServer);
+WRITE_CLASS_ENCODER(KeyServer)
#endif
::decode(server_challenge, bl);
}
};
-WRITE_CLASS_ENCODER(CephXServerChallenge);
+WRITE_CLASS_ENCODER(CephXServerChallenge)
// request/reply headers, for subsequent exchanges.
::decode(request_type, bl);
}
};
-WRITE_CLASS_ENCODER(CephXRequestHeader);
+WRITE_CLASS_ENCODER(CephXRequestHeader)
struct CephXResponseHeader {
uint16_t request_type;
::decode(status, bl);
}
};
-WRITE_CLASS_ENCODER(CephXResponseHeader);
+WRITE_CLASS_ENCODER(CephXResponseHeader)
struct CephXTicketBlob {
uint64_t secret_id;
::decode(blob, bl);
}
};
-WRITE_CLASS_ENCODER(CephXTicketBlob);
+WRITE_CLASS_ENCODER(CephXTicketBlob)
// client -> server response to challenge
struct CephXAuthenticate {
::decode(keys, bl);
}
};
-WRITE_CLASS_ENCODER(CephXServiceTicketRequest);
+WRITE_CLASS_ENCODER(CephXServiceTicketRequest)
/*
::decode(nonce_plus_one, bl);
}
};
-WRITE_CLASS_ENCODER(CephXAuthorizeReply);
+WRITE_CLASS_ENCODER(CephXAuthorizeReply)
struct CephXAuthorizer : public AuthAuthorizer {
::decode(validity, bl);
}
};
-WRITE_CLASS_ENCODER(CephXServiceTicket);
+WRITE_CLASS_ENCODER(CephXServiceTicket)
/* B */
struct CephXServiceTicketInfo {
::decode(session_key, bl);
}
};
-WRITE_CLASS_ENCODER(CephXServiceTicketInfo);
+WRITE_CLASS_ENCODER(CephXServiceTicketInfo)
struct CephXAuthorize {
uint64_t nonce;
::decode(nonce, bl);
}
};
-WRITE_CLASS_ENCODER(CephXAuthorize);
+WRITE_CLASS_ENCODER(CephXAuthorize)
/*
* Decode an extract ticket
::encode(id, *out);
return 0;
-};
+}
/**
* Set the id of an image. The object must already exist.
void decode_json(JSONObj *obj);
static void generate_test_instances(std::list<cls_replica_log_bound*>& ls);
};
-WRITE_CLASS_ENCODER(cls_replica_log_bound);
+WRITE_CLASS_ENCODER(cls_replica_log_bound)
#endif /* CLS_REPLICA_LOG_TYPES_H_ */
}
ret_ctx->handle_response(r, ret.dir.header);
- };
+ }
};
int cls_rgw_get_dir_header_async(IoCtx& io_ctx, string& oid, RGWGetDirHeader_CB *ctx)
}
free(function);
}
-};
+}
}
Align hd_align;
Align col_align;
- TextTableColumn() {};
+ TextTableColumn() {}
TextTableColumn(std::string h, int w, Align ha, Align ca) :
heading(h), width(w), hd_align(ha), col_align(ca) { }
~TextTableColumn() {}
void _enqueue(GenContext<ThreadPool::TPHandle&> *c) {
_queue.push_back(c);
- };
+ }
void _enqueue_front(GenContext<ThreadPool::TPHandle&> *c) {
_queue.push_front(c);
}
public:
virtual bool call(std::string command, cmdmap_t &cmdmap, std::string format,
bufferlist& out) = 0;
- virtual ~AdminSocketHook() {};
+ virtual ~AdminSocketHook() {}
};
class AdminSocket : public Thread
: data(c), len(l), nref(0),
crc_lock("buffer::raw::crc_lock", false, false)
{ }
- virtual ~raw() {};
+ virtual ~raw() {}
// no copying.
raw(const raw &other);
// splice in *replace (implement me later?)
last_p = begin(); // just in case we were in the removed region.
- };
+ }
void buffer::list::write(int off, int len, std::ostream& out) const
{
delete f;
lgeneric_dout(this, 1) << "do_command '" << command << "' '" << ss.str()
<< "result is " << out->length() << " bytes" << dendl;
-};
+}
CephContext::CephContext(uint32_t module_type_)
{
if (cur != last)
++cur;
-};
+}
JSONObj *JSONObjIter::operator*()
{
return cur->second;
-};
+}
// does not work, FIXME
ostream& operator<<(ostream& out, JSONObj& obj) {
public:
- JSONObj() : parent(NULL){};
+ JSONObj() : parent(NULL){}
virtual ~JSONObj();
uint32_t str_to_ceph_entity_type(const char * str);
-WRITE_CLASS_ENCODER(EntityName);
+WRITE_CLASS_ENCODER(EntityName)
WRITE_EQ_OPERATORS_2(EntityName, type, id)
return 0;
} ///< @return error value, 0 on success
};
-}; // namespace
+} // namespace
#endif
break;
}
return oss;
-};
+}
#endif
#endif
virtual int suicide() = 0;
////////////////DESTRUCTOR/////////////////
- virtual ~KeyValueStructure() {};
+ virtual ~KeyValueStructure() {}
////////////////UPDATERS///////////////////
case PIN_PURGING: return "purging";
default: return generic_pin_name(p);
}
- };
+ }
// -- wait --
//static const int WAIT_LOCK_OFFSET = 8;
g_num_inoa++;
state = 0;
if (auth) state_set(STATE_AUTH);
- };
+ }
~CInode() {
g_num_ino--;
g_num_inos++;
//check_rdcaps_list();
}
- void inc_last_seq() { last_sent++; };
+ void inc_last_seq() { last_sent++; }
ceph_seq_t get_last_seq() { return last_sent; }
ceph_seq_t get_last_issue() { return last_issue; }
}
return true; // we made a decision (see is_valid)
-};
+}
void MDS::ms_handle_accept(Connection *con)
case TABLESERVER_OP_SERVER_READY: return "server_ready";
default: assert(0); return 0;
}
-};
+}
enum {
TABLE_OP_CREATE,
case TABLE_OP_DESTROY: return "destroy";
default: assert(0); return 0;
}
-};
+}
#endif
void decode(bufferlist::iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<fnode_t*>& ls);
- fnode_t() : version(0) {};
+ fnode_t() : version(0) {}
};
WRITE_CLASS_ENCODER(fnode_t)
void dump(Formatter *f) const;
static void generate_test_instances(list<sr_t*>& ls);
};
-WRITE_CLASS_ENCODER(sr_t);
+WRITE_CLASS_ENCODER(sr_t)
#endif
{}
private:
- ~MPGStats() {};
+ ~MPGStats() {}
public:
const char *get_type_name() const { return "pg_stats"; }
};
-WRITE_CLASS_ENCODER_FEATURES(AuthMonitor::Incremental);
+WRITE_CLASS_ENCODER_FEATURES(AuthMonitor::Incremental)
#endif
isvalid = true;
}
return true;
-};
+}
#undef dout_prefix
#define dout_prefix *_dout
DECODE_FINISH(bl);
}
};
-WRITE_CLASS_ENCODER(MonCommand);
+WRITE_CLASS_ENCODER(MonCommand)
#endif
}
pair<string,string> get_last_key() {
return last_key;
- };
+ }
virtual bool has_next_chunk() {
return !done && _is_valid();
}
};
-WRITE_CLASS_ENCODER(MonitorDBStore::Op);
-WRITE_CLASS_ENCODER(MonitorDBStore::Transaction);
+WRITE_CLASS_ENCODER(MonitorDBStore::Op)
+WRITE_CLASS_ENCODER(MonitorDBStore::Transaction)
#endif /* CEPH_MONITOR_DB_STORE_H */
bool incremental_onetime; // has CEPH_FEATURE_INCSUBOSDMAP
Subscription(MonSession *s, const string& t) : session(s), type(t), type_item(this),
- next(0), onetime(false), incremental_onetime(false) {};
+ next(0), onetime(false), incremental_onetime(false) {}
};
struct MonSession : public RefCountedObject {
DECODE_FINISH(p);
}
};
-WRITE_CLASS_ENCODER(LevelDBStoreStats);
+WRITE_CLASS_ENCODER(LevelDBStoreStats)
// data stats
DECODE_FINISH(p);
}
};
-WRITE_CLASS_ENCODER(DataStats);
+WRITE_CLASS_ENCODER(DataStats)
struct ScrubResult {
map<string,uint32_t> prefix_crc; ///< prefix -> crc
ls.back()->prefix_keys["bar"] = 456;
}
};
-WRITE_CLASS_ENCODER(ScrubResult);
+WRITE_CLASS_ENCODER(ScrubResult)
static inline ostream& operator<<(ostream& out, const ScrubResult& r) {
return out << "ScrubResult(keys " << r.prefix_keys << " crc " << r.prefix_crc << ")";
bool m_filestore_btrfs_snap;
public:
BtrfsFileStoreBackend(FileStore *fs);
- ~BtrfsFileStoreBackend() {};
+ ~BtrfsFileStoreBackend() {}
int detect_features();
bool can_checkpoint();
int create_current();
}
public:
FileStoreBackend(FileStore *fs) : filestore(fs) {}
- virtual ~FileStoreBackend() {};
+ virtual ~FileStoreBackend() {}
virtual int detect_features() = 0;
virtual int create_current() = 0;
virtual bool can_checkpoint() = 0;
bool m_filestore_fsync_flushes_journal_data;
public:
GenericFileStoreBackend(FileStore *fs);
- virtual ~GenericFileStoreBackend() {};
+ virtual ~GenericFileStoreBackend() {}
virtual int detect_features();
virtual int create_current();
- virtual bool can_checkpoint() { return false; };
+ virtual bool can_checkpoint() { return false; }
virtual int list_checkpoints(list<string>& ls) { return 0; }
virtual int create_checkpoint(const string& name, uint64_t *cid) { return -EOPNOTSUPP; }
virtual int sync_checkpoint(uint64_t id) { return -EOPNOTSUPP; }
const string &prefix ///< [in] Prefix by which to remove keys
) = 0;
- virtual ~TransactionImpl() {};
+ virtual ~TransactionImpl() {}
};
typedef ceph::shared_ptr< TransactionImpl > Transaction;
int set_extsize(int fd, unsigned int val);
public:
XfsFileStoreBackend(FileStore *fs);
- ~XfsFileStoreBackend() {};
+ ~XfsFileStoreBackend() {}
int detect_features();
int set_alloc_hint(int fd, uint64_t hint);
};
get_parent()->bless_gencontext(
new FinishReadOp(this, op.tid)));
}
-};
+}
void ECBackend::check_recovery_sources(const OSDMapRef osdmap)
{
bool is_hinfo_key_string(const string &key);
const string &get_hinfo_key();
-};
+}
WRITE_CLASS_ENCODER(ECUtil::HashInfo)
#endif
private:
void reset_to_type(impl_type_t type);
};
-WRITE_CLASS_ENCODER(HitSet);
-WRITE_CLASS_ENCODER(HitSet::Params);
+WRITE_CLASS_ENCODER(HitSet)
+WRITE_CLASS_ENCODER(HitSet::Params)
typedef boost::shared_ptr<HitSet> HitSetRef;
s->put();
}
return true;
-};
+}
void OSD::do_waiters()
{
HeartbeatDispatcher(OSD *o) : Dispatcher(cct), osd(o) {}
bool ms_dispatch(Message *m) {
return osd->heartbeat_dispatch(m);
- };
+ }
bool ms_handle_reset(Connection *con) {
return osd->heartbeat_reset(con);
}
}
}
return discard_event();
-};
+}
boost::statechart::result PG::RecoveryState::GetMissing::react(const QueryState& q)
{
const char *get_state_name() { return state_name; }
NamedState(CephContext *cct_, const char *state_name_)
: state_name(state_name_),
- enter_time(ceph_clock_now(cct_)) {};
+ enter_time(ceph_clock_now(cct_)) {}
virtual ~NamedState() {}
};
const hobject_t &hoid,
const map<string, bufferptr> &attrs,
pg_shard_t osd,
- ostream &out) { return false; };
+ ostream &out) { return false; }
void clear_scrub_reserved();
void scrub_reserve_replicas();
void scrub_unreserve_replicas();
public:
/// Provide the final size of the copied object to the CopyCallback
- virtual ~CopyCallback() {};
+ virtual ~CopyCallback() {}
};
friend class CopyFromCallback;
DECODE_FINISH(bl);
}
};
-WRITE_CLASS_ENCODER(Mapping);
+WRITE_CLASS_ENCODER(Mapping)
string SnapMapper::get_prefix(snapid_t snap)
{
bh_set_state(bh2, bh1->get_state());
}
- void mark_missing(BufferHead *bh) { bh_set_state(bh, BufferHead::STATE_MISSING); };
- void mark_clean(BufferHead *bh) { bh_set_state(bh, BufferHead::STATE_CLEAN); };
- void mark_zero(BufferHead *bh) { bh_set_state(bh, BufferHead::STATE_ZERO); };
- void mark_rx(BufferHead *bh) { bh_set_state(bh, BufferHead::STATE_RX); };
- void mark_tx(BufferHead *bh) { bh_set_state(bh, BufferHead::STATE_TX); };
- void mark_error(BufferHead *bh) { bh_set_state(bh, BufferHead::STATE_ERROR); };
+ void mark_missing(BufferHead *bh) { bh_set_state(bh, BufferHead::STATE_MISSING); }
+ void mark_clean(BufferHead *bh) { bh_set_state(bh, BufferHead::STATE_CLEAN); }
+ void mark_zero(BufferHead *bh) { bh_set_state(bh, BufferHead::STATE_ZERO); }
+ void mark_rx(BufferHead *bh) { bh_set_state(bh, BufferHead::STATE_RX); }
+ void mark_tx(BufferHead *bh) { bh_set_state(bh, BufferHead::STATE_TX); }
+ void mark_error(BufferHead *bh) { bh_set_state(bh, BufferHead::STATE_ERROR); }
void mark_dirty(BufferHead *bh) {
bh_set_state(bh, BufferHead::STATE_DIRTY);
bh_lru_dirty.lru_touch(bh);
//bh->set_dirty_stamp(ceph_clock_now(g_ceph_context));
- };
+ }
void bh_add(Object *ob, BufferHead *bh);
void bh_remove(Object *ob, BufferHead *bh);
object_name = object_str;
}
- std::string& get_user_id() { return uid; };
- std::string& get_user_display_name() { return display_name; };
- std::string& get_bucket_name() { return bucket_name; };
- std::string& get_object_name() { return object_name; };
+ std::string& get_user_id() { return uid; }
+ std::string& get_user_display_name() { return display_name; }
+ std::string& get_bucket_name() { return bucket_name; }
+ std::string& get_object_name() { return object_name; }
- rgw_bucket& get_bucket() { return bucket; };
+ rgw_bucket& get_bucket() { return bucket; }
void set_bucket(rgw_bucket& _bucket) {
bucket = _bucket;
bucket_stored = true;
void set_bucket_id(const string& bi) {
bucket_id = bi;
}
- const string& get_bucket_id() { return bucket_id; };
+ const string& get_bucket_id() { return bucket_id; }
- bool will_fetch_stats() { return stat_buckets; };
- bool will_fix_index() { return fix_index; };
- bool will_delete_children() { return delete_child_objects; };
- bool will_check_objects() { return check_objects; };
- bool is_user_op() { return !uid.empty(); };
- bool is_system_op() { return uid.empty(); };
- bool has_bucket_stored() { return bucket_stored; };
+ bool will_fetch_stats() { return stat_buckets; }
+ bool will_fix_index() { return fix_index; }
+ bool will_delete_children() { return delete_child_objects; }
+ bool will_check_objects() { return check_objects; }
+ bool is_user_op() { return !uid.empty(); }
+ bool is_system_op() { return uid.empty(); }
+ bool has_bucket_stored() { return bucket_stored; }
RGWBucketAdminOpState() : list_buckets(false), stat_buckets(false), check_objects(false),
fix_index(false), delete_child_objects(false),
int policy_bl_to_stream(bufferlist& bl, ostream& o);
int get_policy(RGWBucketAdminOpState& op_state, ostream& o);
- void clear_failure() { failure = false; };
+ void clear_failure() { failure = false; }
};
class RGWBucketAdminOp
void decode_json(JSONObj *obj);
void decode_json(JSONObj *obj, bool swift);
};
-WRITE_CLASS_ENCODER(RGWAccessKey);
+WRITE_CLASS_ENCODER(RGWAccessKey)
struct RGWSubUser {
string name;
void decode_json(JSONObj *obj);
};
-WRITE_CLASS_ENCODER(RGWSubUser);
+WRITE_CLASS_ENCODER(RGWSubUser)
class RGWUserCaps
{
void decode_json(JSONObj *obj);
};
-WRITE_CLASS_ENCODER(RGWUserCaps);
+WRITE_CLASS_ENCODER(RGWUserCaps)
void encode_json(const char *name, const obj_version& v, Formatter *f);
void encode_json(const char *name, const RGWUserCaps& val, Formatter *f);
public:
class Metadata {
public:
- Metadata() : is_admin(false) { };
+ Metadata() : is_admin(false) { }
bool is_admin;
void decode_json(JSONObj *obj);
};
class Token {
public:
- Token() : expires(0) { };
+ Token() : expires(0) { }
class Tenant {
public:
- Tenant() : enabled(false) { };
+ Tenant() : enabled(false) { }
string id;
string name;
string description;
void *entry() {
pprocess->run();
return NULL;
- };
+ }
};
class RGWProcessFrontend : public RGWFrontend {
encode_json("read_version", read_version, f);
encode_json("write_version", write_version, f);
encode_json("status", LogStatusDump(status), f);
- };
+ }
};
-WRITE_CLASS_ENCODER(RGWMetadataLogData);
+WRITE_CLASS_ENCODER(RGWMetadataLogData)
int RGWMetadataLog::add_entry(RGWRados *store, RGWMetadataHandler *handler, const string& section, const string& key, bufferlist& bl) {
std::vector<string> objects;
bool quiet;
- bool is_quiet() { return quiet; };
+ bool is_quiet() { return quiet; }
};
class RGWMultiDelQuiet : public XMLObj
virtual void update_stats(const string& user, rgw_bucket& bucket, int obj_delta, uint64_t added_bytes, uint64_t removed_bytes) {
bucket_stats_cache.adjust_stats(user, bucket, obj_delta, added_bytes, removed_bytes);
user_stats_cache.adjust_stats(user, bucket, obj_delta, added_bytes, removed_bytes);
- };
+ }
};
RGWQuotaHandler *RGWQuotaHandler::generate_handler(RGWRados *store, bool quota_threads)
{
return new RGWQuotaHandlerImpl(store, quota_threads);
-};
+}
void RGWQuotaHandler::free_handler(RGWQuotaHandler *handler)
{
obj.init(bucket, obj_str);
return 0;
-};
+}
int RGWPutObjProcessor_Plain::handle_data(bufferlist& bl, off_t _ofs, void **phandle)
{
add_obj(cur_obj);
return 0;
-};
+}
int RGWPutObjProcessor_Atomic::complete_parts()
{
void dump(Formatter *f) const;
static void generate_test_instances(list<RGWObjManifestPart*>& o);
};
-WRITE_CLASS_ENCODER(RGWObjManifestPart);
+WRITE_CLASS_ENCODER(RGWObjManifestPart)
/*
The manifest defines a set of rules for structuring the object parts.
}
void dump(Formatter *f) const;
};
-WRITE_CLASS_ENCODER(RGWObjManifestRule);
+WRITE_CLASS_ENCODER(RGWObjManifestRule)
class RGWObjManifest {
protected:
}
};
};
-WRITE_CLASS_ENCODER(RGWObjManifest);
+WRITE_CLASS_ENCODER(RGWObjManifest)
struct RGWUploadPartInfo {
uint32_t num;
store = _store;
obj_ctx = _o;
return 0;
- };
+ }
virtual int handle_data(bufferlist& bl, off_t ofs, void **phandle) = 0;
virtual int throttle_data(void *handle) = 0;
virtual int complete(string& etag, time_t *mtime, time_t set_mtime, map<string, bufferlist>& attrs);
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
-WRITE_CLASS_ENCODER(RGWZonePlacementInfo);
+WRITE_CLASS_ENCODER(RGWZonePlacementInfo)
struct RGWZoneParams {
rgw_bucket domain_root;
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
-WRITE_CLASS_ENCODER(RGWZoneParams);
+WRITE_CLASS_ENCODER(RGWZoneParams)
struct RGWZone {
string name;
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
-WRITE_CLASS_ENCODER(RGWZone);
+WRITE_CLASS_ENCODER(RGWZone)
struct RGWDefaultRegionInfo {
string default_region;
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
-WRITE_CLASS_ENCODER(RGWDefaultRegionInfo);
+WRITE_CLASS_ENCODER(RGWDefaultRegionInfo)
struct RGWRegionPlacementTarget {
string name;
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
-WRITE_CLASS_ENCODER(RGWRegionPlacementTarget);
+WRITE_CLASS_ENCODER(RGWRegionPlacementTarget)
struct RGWRegion {
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
-WRITE_CLASS_ENCODER(RGWRegion);
+WRITE_CLASS_ENCODER(RGWRegion)
struct RGWRegionMap {
Mutex lock;
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
};
-WRITE_CLASS_ENCODER(RGWRegionMap);
+WRITE_CLASS_ENCODER(RGWRegionMap)
class RGWDataChangesLog;
class RGWReplicaLogger;
int RGWResolver::resolve_cname(const string& hostname, string& cname, bool *found) {
return resolver->resolve_cname(hostname, cname, found);
-};
+}
RGWResolver *rgw_resolver;
return new RGWOp_Check_Bucket_Index;
return new RGWOp_Bucket_Info;
-};
+}
RGWOp *RGWHandler_Bucket::op_put()
{
return new RGWOp_Bucket_Link;
-};
+}
RGWOp *RGWHandler_Bucket::op_post()
{
return new RGWOp_Bucket_Unlink;
-};
+}
RGWOp *RGWHandler_Bucket::op_delete()
{
return new RGWOp_Object_Remove;
return new RGWOp_Bucket_Remove;
-};
+}
RGWOp *RGWHandler_Usage::op_get()
{
return new RGWOp_Usage_Get;
-};
+}
RGWOp *RGWHandler_Usage::op_delete()
{
return new RGWOp_Usage_Delete;
-};
+}
return new RGWOp_Quota_Info;
return new RGWOp_User_Info;
-};
+}
RGWOp *RGWHandler_User::op_put()
{
return new RGWOp_Quota_Set;
return new RGWOp_User_Create;
-};
+}
RGWOp *RGWHandler_User::op_post()
{
return new RGWOp_Subuser_Modify;
return new RGWOp_User_Modify;
-};
+}
RGWOp *RGWHandler_User::op_delete()
{
return new RGWOp_Caps_Remove;
return new RGWOp_User_Remove;
-};
+}
++cur;
}
return obj;
-};
+}
ostream& operator<<(ostream& out, XMLObj& obj) {
out << obj.obj_type << ": " << obj.data;
#ifdef WITH_RADOSGW
#include "rgw/rgw_rados.h"
-TYPE(RGWObjManifestPart);
-TYPE(RGWObjManifest);
+TYPE(RGWObjManifestPart)
+TYPE(RGWObjManifest)
#include "rgw/rgw_acl.h"
TYPE(ACLPermission)
TYPE(cls_user_complete_stats_sync_op)
#include "rgw/rgw_common.h"
-TYPE(RGWAccessKey);
-TYPE(RGWSubUser);
+TYPE(RGWAccessKey)
+TYPE(RGWSubUser)
TYPE(RGWUserInfo)
TYPE(rgw_bucket)
TYPE(RGWBucketInfo)
class RadosTestECPP : public ::testing::Test {
public:
- RadosTestECPP() : cluster(s_cluster) {};
- virtual ~RadosTestECPP() {};
+ RadosTestECPP() : cluster(s_cluster) {}
+ virtual ~RadosTestECPP() {}
protected:
static void SetUpTestCase();
static void TearDownTestCase();
projects / ceph.git / commitdiff