void encode(bufferlist &bl) const {
ENCODE_START(1, 1, bl);
- ::encode(tag_timeout, bl);
+ encode(tag_timeout, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START(1, bl);
- ::decode(tag_timeout, bl);
+ decode(tag_timeout, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void encode(bufferlist &bl) const {
ENCODE_START(7, 5, bl);
uint8_t c = (uint8_t)op;
- ::encode(c, bl);
- ::encode(tag, bl);
- ::encode(locator, bl);
- ::encode(log_op, bl);
- ::encode(key, bl);
- ::encode(bilog_flags, bl);
- ::encode(zones_trace, bl);
+ encode(c, bl);
+ encode(tag, bl);
+ encode(locator, bl);
+ encode(log_op, bl);
+ encode(key, bl);
+ encode(bilog_flags, bl);
+ encode(zones_trace, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(7, 3, 3, bl);
uint8_t c;
- ::decode(c, bl);
+ decode(c, bl);
op = (RGWModifyOp)c;
if (struct_v < 5) {
- ::decode(key.name, bl);
+ decode(key.name, bl);
}
- ::decode(tag, bl);
+ decode(tag, bl);
if (struct_v >= 2) {
- ::decode(locator, bl);
+ decode(locator, bl);
}
if (struct_v >= 4) {
- ::decode(log_op, bl);
+ decode(log_op, bl);
}
if (struct_v >= 5) {
- ::decode(key, bl);
+ decode(key, bl);
}
if (struct_v >= 6) {
- ::decode(bilog_flags, bl);
+ decode(bilog_flags, bl);
}
if (struct_v >= 7) {
- ::decode(zones_trace, bl);
+ decode(zones_trace, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist &bl) const {
ENCODE_START(9, 7, bl);
uint8_t c = (uint8_t)op;
- ::encode(c, bl);
- ::encode(ver.epoch, bl);
- ::encode(meta, bl);
- ::encode(tag, bl);
- ::encode(locator, bl);
- ::encode(remove_objs, bl);
- ::encode(ver, bl);
- ::encode(log_op, bl);
- ::encode(key, bl);
- ::encode(bilog_flags, bl);
- ::encode(zones_trace, bl);
+ encode(c, bl);
+ encode(ver.epoch, bl);
+ encode(meta, bl);
+ encode(tag, bl);
+ encode(locator, bl);
+ encode(remove_objs, bl);
+ encode(ver, bl);
+ encode(log_op, bl);
+ encode(key, bl);
+ encode(bilog_flags, bl);
+ encode(zones_trace, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(9, 3, 3, bl);
uint8_t c;
- ::decode(c, bl);
+ decode(c, bl);
op = (RGWModifyOp)c;
if (struct_v < 7) {
- ::decode(key.name, bl);
+ decode(key.name, bl);
}
- ::decode(ver.epoch, bl);
- ::decode(meta, bl);
- ::decode(tag, bl);
+ decode(ver.epoch, bl);
+ decode(meta, bl);
+ decode(tag, bl);
if (struct_v >= 2) {
- ::decode(locator, bl);
+ decode(locator, bl);
}
if (struct_v >= 4 && struct_v < 7) {
list<string> old_remove_objs;
- ::decode(old_remove_objs, bl);
+ decode(old_remove_objs, bl);
for (list<string>::iterator iter = old_remove_objs.begin();
iter != old_remove_objs.end(); ++iter) {
remove_objs.push_back(k);
}
} else {
- ::decode(remove_objs, bl);
+ decode(remove_objs, bl);
}
if (struct_v >= 5) {
- ::decode(ver, bl);
+ decode(ver, bl);
} else {
ver.pool = -1;
}
if (struct_v >= 6) {
- ::decode(log_op, bl);
+ decode(log_op, bl);
}
if (struct_v >= 7) {
- ::decode(key, bl);
+ decode(key, bl);
}
if (struct_v >= 8) {
- ::decode(bilog_flags, bl);
+ decode(bilog_flags, bl);
}
if (struct_v >= 9) {
- ::decode(zones_trace, bl);
+ decode(zones_trace, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(5, 1, bl);
- ::encode(key, bl);
- ::encode(olh_tag, bl);
- ::encode(delete_marker, bl);
- ::encode(op_tag, bl);
- ::encode(meta, bl);
- ::encode(olh_epoch, bl);
- ::encode(log_op, bl);
- ::encode(bilog_flags, bl);
+ encode(key, bl);
+ encode(olh_tag, bl);
+ encode(delete_marker, bl);
+ encode(op_tag, bl);
+ encode(meta, bl);
+ encode(olh_epoch, bl);
+ encode(log_op, bl);
+ encode(bilog_flags, bl);
uint64_t t = ceph::real_clock::to_time_t(unmod_since);
- ::encode(t, bl);
- ::encode(unmod_since, bl);
- ::encode(high_precision_time, bl);
- ::encode(zones_trace, bl);
+ encode(t, bl);
+ encode(unmod_since, bl);
+ encode(high_precision_time, bl);
+ encode(zones_trace, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(5, bl);
- ::decode(key, bl);
- ::decode(olh_tag, bl);
- ::decode(delete_marker, bl);
- ::decode(op_tag, bl);
- ::decode(meta, bl);
- ::decode(olh_epoch, bl);
- ::decode(log_op, bl);
- ::decode(bilog_flags, bl);
+ decode(key, bl);
+ decode(olh_tag, bl);
+ decode(delete_marker, bl);
+ decode(op_tag, bl);
+ decode(meta, bl);
+ decode(olh_epoch, bl);
+ decode(log_op, bl);
+ decode(bilog_flags, bl);
if (struct_v == 2) {
uint64_t t;
- ::decode(t, bl);
+ decode(t, bl);
unmod_since = ceph::real_clock::from_time_t(static_cast<time_t>(t));
}
if (struct_v >= 3) {
uint64_t t;
- ::decode(t, bl);
- ::decode(unmod_since, bl);
+ decode(t, bl);
+ decode(unmod_since, bl);
}
if (struct_v >= 4) {
- ::decode(high_precision_time, bl);
+ decode(high_precision_time, bl);
}
if (struct_v >= 5) {
- ::decode(zones_trace, bl);
+ decode(zones_trace, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(3, 1, bl);
- ::encode(key, bl);
- ::encode(op_tag, bl);
- ::encode(olh_epoch, bl);
- ::encode(log_op, bl);
- ::encode(bilog_flags, bl);
- ::encode(olh_tag, bl);
- ::encode(zones_trace, bl);
+ encode(key, bl);
+ encode(op_tag, bl);
+ encode(olh_epoch, bl);
+ encode(log_op, bl);
+ encode(bilog_flags, bl);
+ encode(olh_tag, bl);
+ encode(zones_trace, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(3, bl);
- ::decode(key, bl);
- ::decode(op_tag, bl);
- ::decode(olh_epoch, bl);
- ::decode(log_op, bl);
- ::decode(bilog_flags, bl);
+ decode(key, bl);
+ decode(op_tag, bl);
+ decode(olh_epoch, bl);
+ decode(log_op, bl);
+ decode(bilog_flags, bl);
if (struct_v >= 2) {
- ::decode(olh_tag, bl);
+ decode(olh_tag, bl);
}
if (struct_v >= 3) {
- ::decode(zones_trace, bl);
+ decode(zones_trace, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist &bl) const {
ENCODE_START(1, 1, bl);
- ::encode(olh, bl);
- ::encode(ver_marker, bl);
- ::encode(olh_tag, bl);
+ encode(olh, bl);
+ encode(ver_marker, bl);
+ encode(olh_tag, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START(1, bl);
- ::decode(olh, bl);
- ::decode(ver_marker, bl);
- ::decode(olh_tag, bl);
+ decode(olh, bl);
+ decode(ver_marker, bl);
+ decode(olh_tag, bl);
DECODE_FINISH(bl);
}
static void generate_test_instances(list<rgw_cls_read_olh_log_op *>& o);
void encode(bufferlist &bl) const {
ENCODE_START(1, 1, bl);
- ::encode(log, bl);
- ::encode(is_truncated, bl);
+ encode(log, bl);
+ encode(is_truncated, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START(1, bl);
- ::decode(log, bl);
- ::decode(is_truncated, bl);
+ decode(log, bl);
+ decode(is_truncated, bl);
DECODE_FINISH(bl);
}
static void generate_test_instances(list<rgw_cls_read_olh_log_ret *>& o);
void encode(bufferlist &bl) const {
ENCODE_START(1, 1, bl);
- ::encode(olh, bl);
- ::encode(ver, bl);
- ::encode(olh_tag, bl);
+ encode(olh, bl);
+ encode(ver, bl);
+ encode(olh_tag, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START(1, bl);
- ::decode(olh, bl);
- ::decode(ver, bl);
- ::decode(olh_tag, bl);
+ decode(olh, bl);
+ decode(ver, bl);
+ decode(olh_tag, bl);
DECODE_FINISH(bl);
}
static void generate_test_instances(list<rgw_cls_trim_olh_log_op *>& o);
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(key, bl);
- ::encode(olh_tag, bl);
+ encode(key, bl);
+ encode(olh_tag, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(key, bl);
- ::decode(olh_tag, bl);
+ decode(key, bl);
+ decode(olh_tag, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist &bl) const {
ENCODE_START(5, 4, bl);
- ::encode(num_entries, bl);
- ::encode(filter_prefix, bl);
- ::encode(start_obj, bl);
- ::encode(list_versions, bl);
+ encode(num_entries, bl);
+ encode(filter_prefix, bl);
+ encode(start_obj, bl);
+ encode(list_versions, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(5, 2, 2, bl);
if (struct_v < 4) {
- ::decode(start_obj.name, bl);
+ decode(start_obj.name, bl);
}
- ::decode(num_entries, bl);
+ decode(num_entries, bl);
if (struct_v >= 3)
- ::decode(filter_prefix, bl);
+ decode(filter_prefix, bl);
if (struct_v >= 4)
- ::decode(start_obj, bl);
+ decode(start_obj, bl);
if (struct_v >= 5)
- ::decode(list_versions, bl);
+ decode(list_versions, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void encode(bufferlist &bl) const {
ENCODE_START(2, 2, bl);
- ::encode(dir, bl);
- ::encode(is_truncated, bl);
+ encode(dir, bl);
+ encode(is_truncated, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
- ::decode(dir, bl);
- ::decode(is_truncated, bl);
+ decode(dir, bl);
+ decode(is_truncated, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void encode(bufferlist &bl) const {
ENCODE_START(1, 1, bl);
- ::encode(existing_header, bl);
- ::encode(calculated_header, bl);
+ encode(existing_header, bl);
+ encode(calculated_header, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START(1, bl);
- ::decode(existing_header, bl);
- ::decode(calculated_header, bl);
+ decode(existing_header, bl);
+ decode(calculated_header, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void encode(bufferlist &bl) const {
ENCODE_START(1, 1, bl);
- ::encode(absolute, bl);
- ::encode(stats, bl);
+ encode(absolute, bl);
+ encode(stats, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START(1, bl);
- ::decode(absolute, bl);
- ::decode(stats, bl);
+ decode(absolute, bl);
+ decode(stats, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(keep_attr_prefixes, bl);
+ encode(keep_attr_prefixes, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(keep_attr_prefixes, bl);
+ decode(keep_attr_prefixes, bl);
DECODE_FINISH(bl);
}
};
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(attr, bl);
+ encode(attr, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(attr, bl);
+ decode(attr, bl);
DECODE_FINISH(bl);
}
};
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(check_prefix, bl);
- ::encode(fail_if_exist, bl);
+ encode(check_prefix, bl);
+ encode(fail_if_exist, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(check_prefix, bl);
- ::decode(fail_if_exist, bl);
+ decode(check_prefix, bl);
+ decode(fail_if_exist, bl);
DECODE_FINISH(bl);
}
};
void encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
- ::encode(mtime, bl);
- ::encode((uint8_t)type, bl);
- ::encode(high_precision_time, bl);
+ encode(mtime, bl);
+ encode((uint8_t)type, bl);
+ encode(high_precision_time, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(2, bl);
- ::decode(mtime, bl);
+ decode(mtime, bl);
uint8_t c;
- ::decode(c, bl);
+ decode(c, bl);
type = (RGWCheckMTimeType)c;
if (struct_v >= 2) {
- ::decode(high_precision_time, bl);
+ decode(high_precision_time, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
- ::encode(info, bl);
- ::encode(user.to_str(), bl);
+ encode(info, bl);
+ encode(user.to_str(), bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(2, bl);
- ::decode(info, bl);
+ decode(info, bl);
if (struct_v >= 2) {
string s;
- ::decode(s, bl);
+ decode(s, bl);
user.from_str(s);
}
DECODE_FINISH(bl);
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(key, bl);
- ::encode((uint8_t)type, bl);
+ encode(key, bl);
+ encode((uint8_t)type, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(key, bl);
+ decode(key, bl);
uint8_t c;
- ::decode(c, bl);
+ decode(c, bl);
type = (BIIndexType)c;
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entry, bl);
+ encode(entry, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entry, bl);
+ decode(entry, bl);
DECODE_FINISH(bl);
}
};
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entry, bl);
+ encode(entry, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entry, bl);
+ decode(entry, bl);
DECODE_FINISH(bl);
}
};
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(max, bl);
- ::encode(name, bl);
- ::encode(marker, bl);
+ encode(max, bl);
+ encode(name, bl);
+ encode(marker, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(max, bl);
- ::decode(name, bl);
- ::decode(marker, bl);
+ decode(max, bl);
+ decode(name, bl);
+ decode(marker, bl);
DECODE_FINISH(bl);
}
};
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entries, bl);
- ::encode(is_truncated, bl);
+ encode(entries, bl);
+ encode(is_truncated, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entries, bl);
- ::decode(is_truncated, bl);
+ decode(entries, bl);
+ decode(is_truncated, bl);
DECODE_FINISH(bl);
}
};
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(start_epoch, bl);
- ::encode(end_epoch, bl);
- ::encode(owner, bl);
- ::encode(iter, bl);
- ::encode(max_entries, bl);
+ encode(start_epoch, bl);
+ encode(end_epoch, bl);
+ encode(owner, bl);
+ encode(iter, bl);
+ encode(max_entries, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(start_epoch, bl);
- ::decode(end_epoch, bl);
- ::decode(owner, bl);
- ::decode(iter, bl);
- ::decode(max_entries, bl);
+ decode(start_epoch, bl);
+ decode(end_epoch, bl);
+ decode(owner, bl);
+ decode(iter, bl);
+ decode(max_entries, bl);
DECODE_FINISH(bl);
}
};
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(usage, bl);
- ::encode(truncated, bl);
- ::encode(next_iter, bl);
+ encode(usage, bl);
+ encode(truncated, bl);
+ encode(next_iter, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(usage, bl);
- ::decode(truncated, bl);
- ::decode(next_iter, bl);
+ decode(usage, bl);
+ decode(truncated, bl);
+ decode(next_iter, bl);
DECODE_FINISH(bl);
}
};
void encode(bufferlist& bl) const {
ENCODE_START(2, 2, bl);
- ::encode(start_epoch, bl);
- ::encode(end_epoch, bl);
- ::encode(user, bl);
+ encode(start_epoch, bl);
+ encode(end_epoch, bl);
+ encode(user, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(2, bl);
- ::decode(start_epoch, bl);
- ::decode(end_epoch, bl);
- ::decode(user, bl);
+ decode(start_epoch, bl);
+ decode(end_epoch, bl);
+ decode(user, bl);
DECODE_FINISH(bl);
}
};
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(expiration_secs, bl);
- ::encode(info, bl);
+ encode(expiration_secs, bl);
+ encode(info, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(expiration_secs, bl);
- ::decode(info, bl);
+ decode(expiration_secs, bl);
+ decode(info, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(expiration_secs, bl);
- ::encode(tag, bl);
+ encode(expiration_secs, bl);
+ encode(tag, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(expiration_secs, bl);
- ::decode(tag, bl);
+ decode(expiration_secs, bl);
+ decode(tag, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
- ::encode(marker, bl);
- ::encode(max, bl);
- ::encode(expired_only, bl);
+ encode(marker, bl);
+ encode(max, bl);
+ encode(expired_only, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(2, bl);
- ::decode(marker, bl);
- ::decode(max, bl);
+ decode(marker, bl);
+ decode(max, bl);
if (struct_v >= 2) {
- ::decode(expired_only, bl);
+ decode(expired_only, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
- ::encode(entries, bl);
- ::encode(next_marker, bl);
- ::encode(truncated, bl);
+ encode(entries, bl);
+ encode(next_marker, bl);
+ encode(truncated, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(2, bl);
- ::decode(entries, bl);
+ decode(entries, bl);
if (struct_v >= 2)
- ::decode(next_marker, bl);
- ::decode(truncated, bl);
+ decode(next_marker, bl);
+ decode(truncated, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(tags, bl);
+ encode(tags, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(tags, bl);
+ decode(tags, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(marker, bl);
- ::encode(max, bl);
+ encode(marker, bl);
+ encode(max, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(marker, bl);
- ::decode(max, bl);
+ decode(marker, bl);
+ decode(max, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(start_marker, bl);
- ::encode(end_marker, bl);
+ encode(start_marker, bl);
+ encode(end_marker, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(start_marker, bl);
- ::decode(end_marker, bl);
+ decode(start_marker, bl);
+ decode(end_marker, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entries, bl);
- ::encode(truncated, bl);
+ encode(entries, bl);
+ encode(truncated, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entries, bl);
- ::decode(truncated, bl);
+ decode(entries, bl);
+ decode(truncated, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(marker, bl);
+ encode(marker, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(marker, bl);
+ decode(marker, bl);
DECODE_FINISH(bl);
}
};
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entry, bl);
+ encode(entry, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entry, bl);
+ decode(entry, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entry, bl);
+ encode(entry, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entry, bl);
+ decode(entry, bl);
DECODE_FINISH(bl);
}
};
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entry, bl);
+ encode(entry, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entry, bl);
+ decode(entry, bl);
DECODE_FINISH(bl);
}
};
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(head, bl);
+ encode(head, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(head, bl);
+ decode(head, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(head, bl);
+ encode(head, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(head, bl);
+ decode(head, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(marker, bl);
- ::encode(max_entries, bl);
+ encode(marker, bl);
+ encode(max_entries, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(marker, bl);
- ::decode(max_entries, bl);
+ decode(marker, bl);
+ decode(max_entries, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
- ::encode(entries, bl);
- ::encode(is_truncated, bl);
+ encode(entries, bl);
+ encode(is_truncated, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(2, bl);
- ::decode(entries, bl);
+ decode(entries, bl);
if (struct_v >= 2) {
- ::decode(is_truncated, bl);
+ decode(is_truncated, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entry, bl);
+ encode(entry, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entry, bl);
+ decode(entry, bl);
DECODE_FINISH(bl);
}
static void generate_test_instances(list<cls_rgw_reshard_add_op*>& o);
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(max, bl);
- ::encode(marker, bl);
+ encode(max, bl);
+ encode(marker, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(max, bl);
- ::decode(marker, bl);
+ decode(max, bl);
+ decode(marker, bl);
DECODE_FINISH(bl);
}
static void generate_test_instances(list<cls_rgw_reshard_list_op*>& o);
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entries, bl);
- ::encode(is_truncated, bl);
+ encode(entries, bl);
+ encode(is_truncated, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entries, bl);
- ::decode(is_truncated, bl);
+ decode(entries, bl);
+ decode(is_truncated, bl);
DECODE_FINISH(bl);
}
static void generate_test_instances(list<cls_rgw_reshard_list_ret*>& o);
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entry, bl);
+ encode(entry, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entry, bl);
+ decode(entry, bl);
DECODE_FINISH(bl);
}
static void generate_test_instances(list<cls_rgw_reshard_get_op*>& o);
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entry, bl);
+ encode(entry, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entry, bl);
+ decode(entry, bl);
DECODE_FINISH(bl);
}
static void generate_test_instances(list<cls_rgw_reshard_get_ret*>& o);
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(tenant, bl);
- ::encode(bucket_name, bl);
- ::encode(bucket_id, bl);
+ encode(tenant, bl);
+ encode(bucket_name, bl);
+ encode(bucket_id, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(tenant, bl);
- ::decode(bucket_name, bl);
- ::decode(bucket_id, bl);
+ decode(tenant, bl);
+ decode(bucket_name, bl);
+ decode(bucket_id, bl);
DECODE_FINISH(bl);
}
static void generate_test_instances(list<cls_rgw_reshard_remove_op*>& o);
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entry, bl);
+ encode(entry, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entry, bl);
+ decode(entry, bl);
DECODE_FINISH(bl);
}
static void generate_test_instances(list<cls_rgw_set_bucket_resharding_op*>& o);
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(ret_err, bl);
+ encode(ret_err, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(ret_err, bl);
+ decode(ret_err, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(new_instance, bl);
+ encode(new_instance, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(new_instance, bl);
+ decode(new_instance, bl);
DECODE_FINISH(bl);
}
namespace ceph {
class Formatter;
}
+using ceph::operator <<;
using rgw_zone_set = std::set<std::string>;
void encode(bufferlist &bl) const {
ENCODE_START(2, 2, bl);
uint8_t s = (uint8_t)state;
- ::encode(s, bl);
- ::encode(timestamp, bl);
- ::encode(op, bl);
+ encode(s, bl);
+ encode(timestamp, bl);
+ encode(op, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
uint8_t s;
- ::decode(s, bl);
+ decode(s, bl);
state = (RGWPendingState)s;
- ::decode(timestamp, bl);
- ::decode(op, bl);
+ decode(timestamp, bl);
+ decode(op, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void encode(bufferlist &bl) const {
ENCODE_START(5, 3, bl);
- ::encode(category, bl);
- ::encode(size, bl);
- ::encode(mtime, bl);
- ::encode(etag, bl);
- ::encode(owner, bl);
- ::encode(owner_display_name, bl);
- ::encode(content_type, bl);
- ::encode(accounted_size, bl);
- ::encode(user_data, bl);
+ encode(category, bl);
+ encode(size, bl);
+ encode(mtime, bl);
+ encode(etag, bl);
+ encode(owner, bl);
+ encode(owner_display_name, bl);
+ encode(content_type, bl);
+ encode(accounted_size, bl);
+ encode(user_data, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(5, 3, 3, bl);
- ::decode(category, bl);
- ::decode(size, bl);
- ::decode(mtime, bl);
- ::decode(etag, bl);
- ::decode(owner, bl);
- ::decode(owner_display_name, bl);
+ decode(category, bl);
+ decode(size, bl);
+ decode(mtime, bl);
+ decode(etag, bl);
+ decode(owner, bl);
+ decode(owner_display_name, bl);
if (struct_v >= 2)
- ::decode(content_type, bl);
+ decode(content_type, bl);
if (struct_v >= 4)
- ::decode(accounted_size, bl);
+ decode(accounted_size, bl);
else
accounted_size = size;
if (struct_v >= 5)
- ::decode(user_data, bl);
+ decode(user_data, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
template<class T>
void encode_packed_val(T val, bufferlist& bl)
{
+ using ceph::encode;
if ((uint64_t)val < 0x80) {
- ::encode((uint8_t)val, bl);
+ encode((uint8_t)val, bl);
} else {
unsigned char c = 0x80;
if ((uint64_t)val < 0x100) {
c |= 1;
- ::encode(c, bl);
- ::encode((uint8_t)val, bl);
+ encode(c, bl);
+ encode((uint8_t)val, bl);
} else if ((uint64_t)val <= 0x10000) {
c |= 2;
- ::encode(c, bl);
- ::encode((uint16_t)val, bl);
+ encode(c, bl);
+ encode((uint16_t)val, bl);
} else if ((uint64_t)val <= 0x1000000) {
c |= 4;
- ::encode(c, bl);
- ::encode((uint32_t)val, bl);
+ encode(c, bl);
+ encode((uint32_t)val, bl);
} else {
c |= 8;
- ::encode(c, bl);
- ::encode((uint64_t)val, bl);
+ encode(c, bl);
+ encode((uint64_t)val, bl);
}
}
}
template<class T>
void decode_packed_val(T& val, bufferlist::iterator& bl)
{
+ using ceph::decode;
unsigned char c;
- ::decode(c, bl);
+ decode(c, bl);
if (c < 0x80) {
val = c;
return;
case 1:
{
uint8_t v;
- ::decode(v, bl);
+ decode(v, bl);
val = v;
}
break;
case 2:
{
uint16_t v;
- ::decode(v, bl);
+ decode(v, bl);
val = v;
}
break;
case 4:
{
uint32_t v;
- ::decode(v, bl);
+ decode(v, bl);
val = v;
}
break;
case 8:
{
uint64_t v;
- ::decode(v, bl);
+ decode(v, bl);
val = v;
}
break;
void encode(bufferlist &bl) const {
ENCODE_START(1, 1, bl);
- ::encode_packed_val(pool, bl);
- ::encode_packed_val(epoch, bl);
+ encode_packed_val(pool, bl);
+ encode_packed_val(epoch, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START(1, bl);
- ::decode_packed_val(pool, bl);
- ::decode_packed_val(epoch, bl);
+ decode_packed_val(pool, bl);
+ decode_packed_val(epoch, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
}
void encode(bufferlist &bl) const {
ENCODE_START(1, 1, bl);
- ::encode(name, bl);
- ::encode(instance, bl);
+ encode(name, bl);
+ encode(instance, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START(1, bl);
- ::decode(name, bl);
- ::decode(instance, bl);
+ decode(name, bl);
+ decode(instance, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const {
void encode(bufferlist &bl) const {
ENCODE_START(8, 3, bl);
- ::encode(key.name, bl);
- ::encode(ver.epoch, bl);
- ::encode(exists, bl);
- ::encode(meta, bl);
- ::encode(pending_map, bl);
- ::encode(locator, bl);
- ::encode(ver, bl);
- ::encode_packed_val(index_ver, bl);
- ::encode(tag, bl);
- ::encode(key.instance, bl);
- ::encode(flags, bl);
- ::encode(versioned_epoch, bl);
+ encode(key.name, bl);
+ encode(ver.epoch, bl);
+ encode(exists, bl);
+ encode(meta, bl);
+ encode(pending_map, bl);
+ encode(locator, bl);
+ encode(ver, bl);
+ encode_packed_val(index_ver, bl);
+ encode(tag, bl);
+ encode(key.instance, bl);
+ encode(flags, bl);
+ encode(versioned_epoch, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(8, 3, 3, bl);
- ::decode(key.name, bl);
- ::decode(ver.epoch, bl);
- ::decode(exists, bl);
- ::decode(meta, bl);
- ::decode(pending_map, bl);
+ decode(key.name, bl);
+ decode(ver.epoch, bl);
+ decode(exists, bl);
+ decode(meta, bl);
+ decode(pending_map, bl);
if (struct_v >= 2) {
- ::decode(locator, bl);
+ decode(locator, bl);
}
if (struct_v >= 4) {
- ::decode(ver, bl);
+ decode(ver, bl);
} else {
ver.pool = -1;
}
if (struct_v >= 5) {
- ::decode_packed_val(index_ver, bl);
- ::decode(tag, bl);
+ decode_packed_val(index_ver, bl);
+ decode(tag, bl);
}
if (struct_v >= 6) {
- ::decode(key.instance, bl);
+ decode(key.instance, bl);
}
if (struct_v >= 7) {
- ::decode(flags, bl);
+ decode(flags, bl);
}
if (struct_v >= 8) {
- ::decode(versioned_epoch, bl);
+ decode(versioned_epoch, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode((uint8_t)type, bl);
- ::encode(idx, bl);
- ::encode(data, bl);
+ encode((uint8_t)type, bl);
+ encode(idx, bl);
+ encode(data, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
uint8_t c;
- ::decode(c, bl);
+ decode(c, bl);
type = (BIIndexType)c;
- ::decode(idx, bl);
- ::decode(data, bl);
+ decode(idx, bl);
+ decode(data, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist &bl) const {
ENCODE_START(1, 1, bl);
- ::encode(epoch, bl);
- ::encode((__u8)op, bl);
- ::encode(op_tag, bl);
- ::encode(key, bl);
- ::encode(delete_marker, bl);
+ encode(epoch, bl);
+ encode((__u8)op, bl);
+ encode(op_tag, bl);
+ encode(key, bl);
+ encode(delete_marker, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START(1, bl);
- ::decode(epoch, bl);
+ decode(epoch, bl);
uint8_t c;
- ::decode(c, bl);
+ decode(c, bl);
op = (OLHLogOp)c;
- ::decode(op_tag, bl);
- ::decode(key, bl);
- ::decode(delete_marker, bl);
+ decode(op_tag, bl);
+ decode(key, bl);
+ decode(delete_marker, bl);
DECODE_FINISH(bl);
}
static void generate_test_instances(list<rgw_bucket_olh_log_entry*>& o);
void encode(bufferlist &bl) const {
ENCODE_START(1, 1, bl);
- ::encode(key, bl);
- ::encode(delete_marker, bl);
- ::encode(epoch, bl);
- ::encode(pending_log, bl);
- ::encode(tag, bl);
- ::encode(exists, bl);
- ::encode(pending_removal, bl);
+ encode(key, bl);
+ encode(delete_marker, bl);
+ encode(epoch, bl);
+ encode(pending_log, bl);
+ encode(tag, bl);
+ encode(exists, bl);
+ encode(pending_removal, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START(1, bl);
- ::decode(key, bl);
- ::decode(delete_marker, bl);
- ::decode(epoch, bl);
- ::decode(pending_log, bl);
- ::decode(tag, bl);
- ::decode(exists, bl);
- ::decode(pending_removal, bl);
+ decode(key, bl);
+ decode(delete_marker, bl);
+ decode(epoch, bl);
+ decode(pending_log, bl);
+ decode(tag, bl);
+ decode(exists, bl);
+ decode(pending_removal, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void encode(bufferlist &bl) const {
ENCODE_START(4, 1, bl);
- ::encode(id, bl);
- ::encode(object, bl);
- ::encode(timestamp, bl);
- ::encode(ver, bl);
- ::encode(tag, bl);
+ encode(id, bl);
+ encode(object, bl);
+ encode(timestamp, bl);
+ encode(ver, bl);
+ encode(tag, bl);
uint8_t c = (uint8_t)op;
- ::encode(c, bl);
+ encode(c, bl);
c = (uint8_t)state;
- ::encode(c, bl);
+ encode(c, bl);
encode_packed_val(index_ver, bl);
- ::encode(instance, bl);
- ::encode(bilog_flags, bl);
- ::encode(owner, bl);
- ::encode(owner_display_name, bl);
- ::encode(zones_trace, bl);
+ encode(instance, bl);
+ encode(bilog_flags, bl);
+ encode(owner, bl);
+ encode(owner_display_name, bl);
+ encode(zones_trace, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START(4, bl);
- ::decode(id, bl);
- ::decode(object, bl);
- ::decode(timestamp, bl);
- ::decode(ver, bl);
- ::decode(tag, bl);
+ decode(id, bl);
+ decode(object, bl);
+ decode(timestamp, bl);
+ decode(ver, bl);
+ decode(tag, bl);
uint8_t c;
- ::decode(c, bl);
+ decode(c, bl);
op = (RGWModifyOp)c;
- ::decode(c, bl);
+ decode(c, bl);
state = (RGWPendingState)c;
decode_packed_val(index_ver, bl);
if (struct_v >= 2) {
- ::decode(instance, bl);
- ::decode(bilog_flags, bl);
+ decode(instance, bl);
+ decode(bilog_flags, bl);
}
if (struct_v >= 3) {
- ::decode(owner, bl);
- ::decode(owner_display_name, bl);
+ decode(owner, bl);
+ decode(owner_display_name, bl);
}
if (struct_v >= 4) {
- ::decode(zones_trace, bl);
+ decode(zones_trace, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist &bl) const {
ENCODE_START(3, 2, bl);
- ::encode(total_size, bl);
- ::encode(total_size_rounded, bl);
- ::encode(num_entries, bl);
- ::encode(actual_size, bl);
+ encode(total_size, bl);
+ encode(total_size_rounded, bl);
+ encode(num_entries, bl);
+ encode(actual_size, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(3, 2, 2, bl);
- ::decode(total_size, bl);
- ::decode(total_size_rounded, bl);
- ::decode(num_entries, bl);
+ decode(total_size, bl);
+ decode(total_size_rounded, bl);
+ decode(num_entries, bl);
if (struct_v >= 3) {
- ::decode(actual_size, bl);
+ decode(actual_size, bl);
} else {
actual_size = total_size;
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode((uint8_t)reshard_status, bl);
- ::encode(new_bucket_instance_id, bl);
- ::encode(num_shards, bl);
+ encode((uint8_t)reshard_status, bl);
+ encode(new_bucket_instance_id, bl);
+ encode(num_shards, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
uint8_t s;
- ::decode(s, bl);
+ decode(s, bl);
reshard_status = (cls_rgw_reshard_status)s;
- ::decode(new_bucket_instance_id, bl);
- ::decode(num_shards, bl);
+ decode(new_bucket_instance_id, bl);
+ decode(num_shards, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist &bl) const {
ENCODE_START(7, 2, bl);
- ::encode(stats, bl);
- ::encode(tag_timeout, bl);
- ::encode(ver, bl);
- ::encode(master_ver, bl);
- ::encode(max_marker, bl);
- ::encode(new_instance, bl);
- ::encode(syncstopped,bl);
+ encode(stats, bl);
+ encode(tag_timeout, bl);
+ encode(ver, bl);
+ encode(master_ver, bl);
+ encode(max_marker, bl);
+ encode(new_instance, bl);
+ encode(syncstopped,bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(6, 2, 2, bl);
- ::decode(stats, bl);
+ decode(stats, bl);
if (struct_v > 2) {
- ::decode(tag_timeout, bl);
+ decode(tag_timeout, bl);
} else {
tag_timeout = 0;
}
if (struct_v >= 4) {
- ::decode(ver, bl);
- ::decode(master_ver, bl);
+ decode(ver, bl);
+ decode(master_ver, bl);
} else {
ver = 0;
}
if (struct_v >= 5) {
- ::decode(max_marker, bl);
+ decode(max_marker, bl);
}
if (struct_v >= 6) {
- ::decode(new_instance, bl);
+ decode(new_instance, bl);
} else {
new_instance = cls_rgw_bucket_instance_entry();
}
if (struct_v >= 7) {
- ::decode(syncstopped,bl);
+ decode(syncstopped,bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist &bl) const {
ENCODE_START(2, 2, bl);
- ::encode(header, bl);
- ::encode(m, bl);
+ encode(header, bl);
+ encode(m, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
- ::decode(header, bl);
- ::decode(m, bl);
+ decode(header, bl);
+ decode(m, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(bytes_sent, bl);
- ::encode(bytes_received, bl);
- ::encode(ops, bl);
- ::encode(successful_ops, bl);
+ encode(bytes_sent, bl);
+ encode(bytes_received, bl);
+ encode(ops, bl);
+ encode(successful_ops, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(bytes_sent, bl);
- ::decode(bytes_received, bl);
- ::decode(ops, bl);
- ::decode(successful_ops, bl);
+ decode(bytes_sent, bl);
+ decode(bytes_received, bl);
+ decode(ops, bl);
+ decode(successful_ops, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(3, 1, bl);
- ::encode(owner.to_str(), bl);
- ::encode(bucket, bl);
- ::encode(epoch, bl);
- ::encode(total_usage.bytes_sent, bl);
- ::encode(total_usage.bytes_received, bl);
- ::encode(total_usage.ops, bl);
- ::encode(total_usage.successful_ops, bl);
- ::encode(usage_map, bl);
- ::encode(payer.to_str(), bl);
+ encode(owner.to_str(), bl);
+ encode(bucket, bl);
+ encode(epoch, bl);
+ encode(total_usage.bytes_sent, bl);
+ encode(total_usage.bytes_received, bl);
+ encode(total_usage.ops, bl);
+ encode(total_usage.successful_ops, bl);
+ encode(usage_map, bl);
+ encode(payer.to_str(), bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(3, bl);
string s;
- ::decode(s, bl);
+ decode(s, bl);
owner.from_str(s);
- ::decode(bucket, bl);
- ::decode(epoch, bl);
- ::decode(total_usage.bytes_sent, bl);
- ::decode(total_usage.bytes_received, bl);
- ::decode(total_usage.ops, bl);
- ::decode(total_usage.successful_ops, bl);
+ decode(bucket, bl);
+ decode(epoch, bl);
+ decode(total_usage.bytes_sent, bl);
+ decode(total_usage.bytes_received, bl);
+ decode(total_usage.ops, bl);
+ decode(total_usage.successful_ops, bl);
if (struct_v < 2) {
usage_map[""] = total_usage;
} else {
- ::decode(usage_map, bl);
+ decode(usage_map, bl);
}
if (struct_v >= 3) {
string p;
- ::decode(p, bl);
+ decode(p, bl);
payer.from_str(p);
}
DECODE_FINISH(bl);
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entries, bl);
+ encode(entries, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entries, bl);
+ decode(entries, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(user, bl);
- ::encode(bucket, bl);
+ encode(user, bl);
+ encode(bucket, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(user, bl);
- ::decode(bucket, bl);
+ decode(user, bl);
+ decode(bucket, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
- ::encode(pool, bl);
- ::encode(key.name, bl);
- ::encode(loc, bl);
- ::encode(key, bl);
+ encode(pool, bl);
+ encode(key.name, bl);
+ encode(loc, bl);
+ encode(key, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(2, bl);
- ::decode(pool, bl);
- ::decode(key.name, bl);
- ::decode(loc, bl);
+ decode(pool, bl);
+ decode(key.name, bl);
+ decode(loc, bl);
if (struct_v >= 2) {
- ::decode(key, bl);
+ decode(key, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(objs, bl);
+ encode(objs, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(objs, bl);
+ decode(objs, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(tag, bl);
- ::encode(chain, bl);
- ::encode(time, bl);
+ encode(tag, bl);
+ encode(chain, bl);
+ encode(time, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(tag, bl);
- ::decode(chain, bl);
- ::decode(time, bl);
+ decode(tag, bl);
+ decode(chain, bl);
+ decode(time, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
uint64_t t = start_date;
- ::encode(t, bl);
- ::encode(marker, bl);
+ encode(t, bl);
+ encode(marker, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
uint64_t t;
- ::decode(t, bl);
+ decode(t, bl);
start_date = static_cast<time_t>(t);
- ::decode(marker, bl);
+ decode(marker, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(time, bl);
- ::encode(tenant, bl);
- ::encode(bucket_name, bl);
- ::encode(bucket_id, bl);
- ::encode(new_instance_id, bl);
- ::encode(old_num_shards, bl);
- ::encode(new_num_shards, bl);
+ encode(time, bl);
+ encode(tenant, bl);
+ encode(bucket_name, bl);
+ encode(bucket_id, bl);
+ encode(new_instance_id, bl);
+ encode(old_num_shards, bl);
+ encode(new_num_shards, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(time, bl);
- ::decode(tenant, bl);
- ::decode(bucket_name, bl);
- ::decode(bucket_id, bl);
- ::decode(new_instance_id, bl);
- ::decode(old_num_shards, bl);
- ::decode(new_num_shards, bl);
+ decode(time, bl);
+ decode(tenant, bl);
+ decode(bucket_name, bl);
+ decode(bucket_id, bl);
+ decode(new_instance_id, bl);
+ decode(old_num_shards, bl);
+ decode(new_num_shards, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entries, bl);
- ::encode(add, bl);
- ::encode(time, bl);
+ encode(entries, bl);
+ encode(add, bl);
+ encode(time, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entries, bl);
- ::decode(add, bl);
- ::decode(time, bl);
+ decode(entries, bl);
+ decode(add, bl);
+ decode(time, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(bucket, bl);
+ encode(bucket, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(bucket, bl);
+ decode(bucket, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
- ::encode(marker, bl);
- ::encode(max_entries, bl);
- ::encode(end_marker, bl);
+ encode(marker, bl);
+ encode(max_entries, bl);
+ encode(end_marker, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(2, bl);
- ::decode(marker, bl);
- ::decode(max_entries, bl);
+ decode(marker, bl);
+ decode(max_entries, bl);
if (struct_v >= 2) {
- ::decode(end_marker, bl);
+ decode(end_marker, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entries, bl);
- ::encode(marker, bl);
- ::encode(truncated, bl);
+ encode(entries, bl);
+ encode(marker, bl);
+ encode(truncated, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entries, bl);
- ::decode(marker, bl);
- ::decode(truncated, bl);
+ decode(entries, bl);
+ decode(marker, bl);
+ decode(truncated, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(header, bl);
+ encode(header, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(header, bl);
+ decode(header, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(time, bl);
+ encode(time, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(time, bl);
+ decode(time, bl);
DECODE_FINISH(bl);
}
*/
if (!placement_id.empty()) {
ENCODE_START(9, 8, bl);
- ::encode(name, bl);
- ::encode(marker, bl);
- ::encode(bucket_id, bl);
- ::encode(placement_id, bl);
+ encode(name, bl);
+ encode(marker, bl);
+ encode(bucket_id, bl);
+ encode(placement_id, bl);
ENCODE_FINISH(bl);
} else {
ENCODE_START(7, 3, bl);
- ::encode(name, bl);
- ::encode(explicit_placement.data_pool, bl);
- ::encode(marker, bl);
- ::encode(bucket_id, bl);
- ::encode(explicit_placement.index_pool, bl);
- ::encode(explicit_placement.data_extra_pool, bl);
+ encode(name, bl);
+ encode(explicit_placement.data_pool, bl);
+ encode(marker, bl);
+ encode(bucket_id, bl);
+ encode(explicit_placement.index_pool, bl);
+ encode(explicit_placement.data_extra_pool, bl);
ENCODE_FINISH(bl);
}
}
void decode(bufferlist::iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN(8, 3, 3, bl);
- ::decode(name, bl);
+ decode(name, bl);
if (struct_v < 8) {
- ::decode(explicit_placement.data_pool, bl);
+ decode(explicit_placement.data_pool, bl);
}
if (struct_v >= 2) {
- ::decode(marker, bl);
+ decode(marker, bl);
if (struct_v <= 3) {
uint64_t id;
- ::decode(id, bl);
+ decode(id, bl);
char buf[16];
snprintf(buf, sizeof(buf), "%llu", (long long)id);
bucket_id = buf;
} else {
- ::decode(bucket_id, bl);
+ decode(bucket_id, bl);
}
}
if (struct_v < 8) {
if (struct_v >= 5) {
- ::decode(explicit_placement.index_pool, bl);
+ decode(explicit_placement.index_pool, bl);
} else {
explicit_placement.index_pool = explicit_placement.data_pool;
}
if (struct_v >= 7) {
- ::decode(explicit_placement.data_extra_pool, bl);
+ decode(explicit_placement.data_extra_pool, bl);
}
} else {
- ::decode(placement_id, bl);
+ decode(placement_id, bl);
if (struct_v == 8 && placement_id.empty()) {
- ::decode(explicit_placement.data_pool, bl);
- ::decode(explicit_placement.index_pool, bl);
- ::decode(explicit_placement.data_extra_pool, bl);
+ decode(explicit_placement.data_pool, bl);
+ decode(explicit_placement.index_pool, bl);
+ decode(explicit_placement.data_extra_pool, bl);
}
}
DECODE_FINISH(bl);
uint64_t s = size;
__u32 mt = ceph::real_clock::to_time_t(creation_time);
string empty_str; // originally had the bucket name here, but we encode bucket later
- ::encode(empty_str, bl);
- ::encode(s, bl);
- ::encode(mt, bl);
- ::encode(count, bl);
- ::encode(bucket, bl);
+ encode(empty_str, bl);
+ encode(s, bl);
+ encode(mt, bl);
+ encode(count, bl);
+ encode(bucket, bl);
s = size_rounded;
- ::encode(s, bl);
- ::encode(user_stats_sync, bl);
- ::encode(creation_time, bl);
+ encode(s, bl);
+ encode(user_stats_sync, bl);
+ encode(creation_time, bl);
//::encode(placement_rule, bl); removed in v9
ENCODE_FINISH(bl);
}
__u32 mt;
uint64_t s;
string empty_str; // backward compatibility
- ::decode(empty_str, bl);
- ::decode(s, bl);
- ::decode(mt, bl);
+ decode(empty_str, bl);
+ decode(s, bl);
+ decode(mt, bl);
size = s;
if (struct_v < 7) {
creation_time = ceph::real_clock::from_time_t(mt);
}
if (struct_v >= 2)
- ::decode(count, bl);
+ decode(count, bl);
if (struct_v >= 3)
- ::decode(bucket, bl);
+ decode(bucket, bl);
if (struct_v >= 4)
- ::decode(s, bl);
+ decode(s, bl);
size_rounded = s;
if (struct_v >= 6)
- ::decode(user_stats_sync, bl);
+ decode(user_stats_sync, bl);
if (struct_v >= 7)
- ::decode(creation_time, bl);
+ decode(creation_time, bl);
if (struct_v == 8) { // added in v8, removed in v9
std::string placement_rule;
- ::decode(placement_rule, bl);
+ decode(placement_rule, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(total_entries, bl);
- ::encode(total_bytes, bl);
- ::encode(total_bytes_rounded, bl);
+ encode(total_entries, bl);
+ encode(total_bytes, bl);
+ encode(total_bytes_rounded, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(total_entries, bl);
- ::decode(total_bytes, bl);
- ::decode(total_bytes_rounded, bl);
+ decode(total_entries, bl);
+ decode(total_bytes, bl);
+ decode(total_bytes_rounded, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(stats, bl);
- ::encode(last_stats_sync, bl);
- ::encode(last_stats_update, bl);
+ encode(stats, bl);
+ encode(last_stats_sync, bl);
+ encode(last_stats_update, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(stats, bl);
- ::decode(last_stats_sync, bl);
- ::decode(last_stats_update, bl);
+ decode(stats, bl);
+ decode(last_stats_sync, bl);
+ decode(last_stats_update, bl);
DECODE_FINISH(bl);
}
#define COMMON_CEPH_TIME_H
#include <chrono>
+#include <iostream>
#include "include/assert.h"
-#include "include/encoding.h"
#if defined(__APPLE__)
#include <sys/_types/_timespec.h>
// time_point + duration to assert on overflow, but I don't think we
// should.
-} // namespace ceph
-// We need these definitions to be able to hande ::encode/::decode on
-// time points.
-
-template<typename Clock, typename Duration>
-void encode(const std::chrono::time_point<Clock, Duration>& t,
- ceph::bufferlist &bl) {
- auto ts = Clock::to_timespec(t);
- // A 32 bit count of seconds causes me vast unhappiness.
- uint32_t s = ts.tv_sec;
- uint32_t ns = ts.tv_nsec;
- ::encode(s, bl);
- ::encode(ns, bl);
+inline timespan abs(signedspan z) {
+ return z > signedspan::zero() ?
+ std::chrono::duration_cast<timespan>(z) :
+ timespan(-z.count());
}
-
-template<typename Clock, typename Duration>
-void decode(std::chrono::time_point<Clock, Duration>& t,
- bufferlist::iterator& p) {
- uint32_t s;
- uint32_t ns;
- ::decode(s, p);
- ::decode(ns, p);
- struct timespec ts = {
- static_cast<time_t>(s),
- static_cast<long int>(ns)};
-
- t = Clock::from_timespec(ts);
+inline timespan to_timespan(signedspan z) {
+ ceph_assert(z >= signedspan::zero());
+ return std::chrono::duration_cast<timespan>(z);
}
-
-// C++ Overload Resolution requires that our encode/decode functions
-// be defined in the same namespace as the type. So we need this
-// to handle things like ::encode(std::vector<ceph::real_time // > >)
-
-namespace std {
- namespace chrono {
- template<typename Clock, typename Duration>
- void encode(const time_point<Clock, Duration>& t,
- ceph::bufferlist &bl) {
- ::encode(t, bl);
- }
-
- template<typename Clock, typename Duration>
- void decode(time_point<Clock, Duration>& t, bufferlist::iterator &p) {
- ::decode(t, p);
- }
- } // namespace chrono
-
- // An overload of our own
- namespace {
- inline timespan abs(signedspan z) {
- return z > signedspan::zero() ?
- std::chrono::duration_cast<timespan>(z) :
- timespan(-z.count());
- }
- inline timespan to_timespan(signedspan z) {
- ceph_assert(z >= signedspan::zero());
- return std::chrono::duration_cast<timespan>(z);
- }
- }
-} // namespace std
+} // namespace ceph
#endif // COMMON_CEPH_TIME_H
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
+#include <iomanip>
+#include <sstream>
+
#include "iso_8601.h"
#include "include/timegm.h"
-#include <sstream>
-
namespace ceph {
using std::chrono::duration_cast;
using std::chrono::nanoseconds;
#ifndef CEPH_COMMON_ISO_8601_H
#define CEPH_COMMON_ISO_8601_H
+#include <boost/optional.hpp>
#include <boost/utility/string_ref.hpp>
#include "common/ceph_time.h"
#include "include/unordered_map.h"
#include "include/unordered_set.h"
+#include "common/ceph_time.h"
#include "include/int_types.h"
p.copy(len, s);
}
+// Time, since the templates are defined in std::chrono
-// full bl decoder
-template<class T>
-inline void decode(T &o, bufferlist& bl)
-{
- bufferlist::iterator p = bl.begin();
- decode(o, p);
- assert(p.end());
+template<typename Clock, typename Duration>
+void encode(const std::chrono::time_point<Clock, Duration>& t,
+ ceph::bufferlist &bl) {
+ auto ts = Clock::to_timespec(t);
+ // A 32 bit count of seconds causes me vast unhappiness.
+ uint32_t s = ts.tv_sec;
+ uint32_t ns = ts.tv_nsec;
+ encode(s, bl);
+ encode(ns, bl);
}
+template<typename Clock, typename Duration>
+void decode(std::chrono::time_point<Clock, Duration>& t,
+ bufferlist::iterator& p) {
+ uint32_t s;
+ uint32_t ns;
+ decode(s, p);
+ decode(ns, p);
+ struct timespec ts = {
+ static_cast<time_t>(s),
+ static_cast<long int>(ns)};
+
+ t = Clock::from_timespec(ts);
+}
// -----------------------------
// STL container types
inline std::enable_if_t<!traits::supported>
decode(std::array<T, N>& v, bufferlist::iterator& p);
+// full bl decoder
+template<class T>
+inline void decode(T &o, bufferlist& bl)
+{
+ bufferlist::iterator p = bl.begin();
+ decode(o, p);
+ assert(p.end());
+}
+
+
+
// boost optional
template<typename T>
* (Reliable Autonomic Distributed Object Store).
*/
+#include <string.h>
#include "msgr.h"
/*
#ifndef __CEPH_LOG_LOG_H
#define __CEPH_LOG_LOG_H
+#include <memory>
+
#include "common/Thread.h"
#include "EntryQueue.h"
std::string m_log_stderr_prefix;
- shared_ptr<Graylog> m_graylog;
+ std::shared_ptr<Graylog> m_graylog;
bool m_stop;
void start_graylog();
void stop_graylog();
- shared_ptr<Graylog> graylog() { return m_graylog; }
+ std::shared_ptr<Graylog> graylog() { return m_graylog; }
Entry *create_entry(int level, int subsys, const char* msg = nullptr);
Entry *create_entry(int level, int subsys, size_t* expected_size);
OSDOp& osd_op = add_op(op);
osd_op.op.pgls.count = count;
osd_op.op.pgls.start_epoch = start_epoch;
- ::encode(cookie, osd_op.indata);
+ encode(cookie, osd_op.indata);
}
void add_pgls_filter(int op, uint64_t count, const bufferlist& filter,
collection_list_handle_t cookie, epoch_t start_epoch) {
osd_op.op.pgls.start_epoch = start_epoch;
string cname = "pg";
string mname = "filter";
- ::encode(cname, osd_op.indata);
- ::encode(mname, osd_op.indata);
+ encode(cname, osd_op.indata);
+ encode(mname, osd_op.indata);
osd_op.indata.append(filter);
- ::encode(cookie, osd_op.indata);
+ encode(cookie, osd_op.indata);
}
void add_alloc_hint(int op, uint64_t expected_object_size,
uint64_t expected_write_size,
try {
uint64_t size;
ceph::real_time mtime;
- ::decode(size, p);
- ::decode(mtime, p);
+ decode(size, p);
+ decode(mtime, p);
if (psize)
*psize = size;
if (pmtime)
// potential IO path.
if (bl.length() > 0) {
try {
- ::decode(*extents, iter);
- ::decode(*data_bl, iter);
+ decode(*extents, iter);
+ decode(*data_bl, iter);
} catch (buffer::error& e) {
if (prval)
*prval = -EIO;
bufferlist::iterator p = bl.begin();
try {
if (pattrs)
- ::decode(*pattrs, p);
+ decode(*pattrs, p);
if (ptruncated) {
std::map<std::string,bufferlist> ignore;
if (!pattrs) {
- ::decode(ignore, p);
+ decode(ignore, p);
pattrs = &ignore;
}
if (!p.end()) {
- ::decode(*ptruncated, p);
+ decode(*ptruncated, p);
} else {
// the OSD did not provide this. since old OSDs do not
// enfoce omap result limits either, we can infer it from
bufferlist::iterator p = bl.begin();
try {
if (pattrs)
- ::decode(*pattrs, p);
+ decode(*pattrs, p);
if (ptruncated) {
std::set<std::string> ignore;
if (!pattrs) {
- ::decode(ignore, p);
+ decode(ignore, p);
pattrs = &ignore;
}
if (!p.end()) {
- ::decode(*ptruncated, p);
+ decode(*ptruncated, p);
} else {
// the OSD did not provide this. since old OSDs do not
// enforce omap result limits either, we can infer it from
bufferlist::iterator p = bl.begin();
try {
obj_list_watch_response_t resp;
- ::decode(resp, p);
+ decode(resp, p);
if (pwatchers) {
for (list<watch_item_t>::iterator i = resp.entries.begin() ;
i != resp.entries.end() ; ++i) {
bufferlist::iterator p = bl.begin();
try {
obj_list_snap_response_t resp;
- ::decode(resp, p);
+ decode(resp, p);
if (psnaps) {
psnaps->clones.clear();
for (vector<clone_info>::iterator ci = resp.clones.begin();
}
void setxattrs(map<string, bufferlist>& attrs) {
bufferlist bl;
- ::encode(attrs, bl);
+ encode(attrs, bl);
add_xattr(CEPH_OSD_OP_RESETXATTRS, 0, bl.length());
}
void resetxattrs(const char *prefix, map<string, bufferlist>& attrs) {
bufferlist bl;
- ::encode(attrs, bl);
+ encode(attrs, bl);
add_xattr(CEPH_OSD_OP_RESETXATTRS, prefix, bl);
}
int *prval) {
OSDOp &op = add_op(CEPH_OSD_OP_OMAPGETKEYS);
bufferlist bl;
- ::encode(start_after, bl);
- ::encode(max_to_get, bl);
+ encode(start_after, bl);
+ encode(max_to_get, bl);
op.op.extent.offset = 0;
op.op.extent.length = bl.length();
op.indata.claim_append(bl);
int *prval) {
OSDOp &op = add_op(CEPH_OSD_OP_OMAPGETVALS);
bufferlist bl;
- ::encode(start_after, bl);
- ::encode(max_to_get, bl);
- ::encode(filter_prefix, bl);
+ encode(start_after, bl);
+ encode(max_to_get, bl);
+ encode(filter_prefix, bl);
op.op.extent.offset = 0;
op.op.extent.length = bl.length();
op.indata.claim_append(bl);
int *prval) {
OSDOp &op = add_op(CEPH_OSD_OP_OMAPGETVALSBYKEYS);
bufferlist bl;
- ::encode(to_get, bl);
+ encode(to_get, bl);
op.op.extent.offset = 0;
op.op.extent.length = bl.length();
op.indata.claim_append(bl);
int *prval) {
OSDOp &op = add_op(CEPH_OSD_OP_OMAP_CMP);
bufferlist bl;
- ::encode(assertions, bl);
+ encode(assertions, bl);
op.op.extent.offset = 0;
op.op.extent.length = bl.length();
op.indata.claim_append(bl);
try {
bufferlist::iterator p = bl.begin();
object_copy_data_t copy_reply;
- ::decode(copy_reply, p);
+ decode(copy_reply, p);
if (r == -ENOENT) {
if (out_reqids)
*out_reqids = copy_reply.reqids;
int *prval) {
OSDOp& osd_op = add_op(CEPH_OSD_OP_COPY_GET);
osd_op.op.copy_get.max = max;
- ::encode(*cursor, osd_op.indata);
- ::encode(max, osd_op.indata);
+ encode(*cursor, osd_op.indata);
+ encode(max, osd_op.indata);
unsigned p = ops.size() - 1;
out_rval[p] = prval;
C_ObjectOperation_copyget *h =
try {
bufferlist::iterator p = bl.begin();
bool isdirty;
- ::decode(isdirty, p);
+ decode(isdirty, p);
if (pisdirty)
*pisdirty = isdirty;
} catch (buffer::error& e) {
try {
bufferlist::iterator p = bl.begin();
std::list< std::pair<ceph::real_time, ceph::real_time> > ls;
- ::decode(ls, p);
+ decode(ls, p);
if (ptls) {
ptls->clear();
for (auto p = ls.begin(); p != ls.end(); ++p)
void omap_set(const map<string, bufferlist> &map) {
bufferlist bl;
- ::encode(map, bl);
+ encode(map, bl);
add_data(CEPH_OSD_OP_OMAPSETVALS, 0, bl.length(), bl);
}
void omap_rm_keys(const std::set<std::string> &to_remove) {
bufferlist bl;
- ::encode(to_remove, bl);
+ encode(to_remove, bl);
add_data(CEPH_OSD_OP_OMAPRMKEYS, 0, bl.length(), bl);
}
bufferlist &bl, bufferlist *inbl) {
OSDOp& osd_op = add_op(CEPH_OSD_OP_NOTIFY);
osd_op.op.notify.cookie = cookie;
- ::encode(prot_ver, *inbl);
- ::encode(timeout, *inbl);
- ::encode(bl, *inbl);
+ encode(prot_ver, *inbl);
+ encode(timeout, *inbl);
+ encode(bl, *inbl);
osd_op.indata.append(*inbl);
}
bufferlist& reply_bl) {
OSDOp& osd_op = add_op(CEPH_OSD_OP_NOTIFY_ACK);
bufferlist bl;
- ::encode(notify_id, bl);
- ::encode(cookie, bl);
- ::encode(reply_bl, bl);
+ encode(notify_id, bl);
+ encode(cookie, bl);
+ encode(reply_bl, bl);
osd_op.indata.append(bl);
}
osd_op.op.copy_from.src_version = src_version;
osd_op.op.copy_from.flags = flags;
osd_op.op.copy_from.src_fadvise_flags = src_fadvise_flags;
- ::encode(src, osd_op.indata);
- ::encode(src_oloc, osd_op.indata);
+ encode(src, osd_op.indata);
+ encode(src_oloc, osd_op.indata);
}
/**
OSDOp& osd_op = add_op(CEPH_OSD_OP_SET_REDIRECT);
osd_op.op.copy_from.snapid = snapid;
osd_op.op.copy_from.src_version = tgt_version;
- ::encode(tgt, osd_op.indata);
- ::encode(tgt_oloc, osd_op.indata);
+ encode(tgt, osd_op.indata);
+ encode(tgt_oloc, osd_op.indata);
}
void set_chunk(uint64_t src_offset, uint64_t src_length, object_locator_t tgt_oloc,
object_t tgt_oid, uint64_t tgt_offset) {
OSDOp& osd_op = add_op(CEPH_OSD_OP_SET_CHUNK);
- ::encode(src_offset, osd_op.indata);
- ::encode(src_length, osd_op.indata);
- ::encode(tgt_oloc, osd_op.indata);
- ::encode(tgt_oid, osd_op.indata);
- ::encode(tgt_offset, osd_op.indata);
+ encode(src_offset, osd_op.indata);
+ encode(src_length, osd_op.indata);
+ encode(tgt_oloc, osd_op.indata);
+ encode(tgt_oid, osd_op.indata);
+ encode(tgt_offset, osd_op.indata);
}
void set_alloc_hint(uint64_t expected_object_size,
bufferlist::iterator p = bl.begin();
uint64_t s;
ceph::real_time m;
- ::decode(s, p);
- ::decode(m, p);
+ decode(s, p);
+ decode(m, p);
if (psize)
*psize = s;
if (pmtime)
void finish(int r) override {
if (r >= 0) {
bufferlist::iterator p = bl.begin();
- ::decode(attrset, p);
+ decode(attrset, p);
}
fin->complete(r);
}
RGWUserBuckets& operator=(const RGWUserBuckets&) = default;
void encode(bufferlist& bl) const {
- ::encode(buckets, bl);
+ using ceph::encode;
+ encode(buckets, bl);
}
void decode(bufferlist::iterator& bl) {
- ::decode(buckets, bl);
+ using ceph::decode;
+ decode(buckets, bl);
}
/**
* Check if the user owns a bucket by the given name.
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
uint8_t t = (uint8_t)entity_type;
- ::encode(t, bl);
- ::encode(key, bl);
- ::encode(timestamp, bl);
+ encode(t, bl);
+ encode(key, bl);
+ encode(timestamp, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
uint8_t t;
- ::decode(t, bl);
+ decode(t, bl);
entity_type = (DataLogEntityType)t;
- ::decode(key, bl);
- ::decode(timestamp, bl);
+ decode(key, bl);
+ decode(timestamp, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(log_id, bl);
- ::encode(log_timestamp, bl);
- ::encode(entry, bl);
+ encode(log_id, bl);
+ encode(log_timestamp, bl);
+ encode(entry, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(log_id, bl);
- ::decode(log_timestamp, bl);
- ::decode(entry, bl);
+ decode(log_id, bl);
+ decode(log_timestamp, bl);
+ decode(entry, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(2, 2, bl);
- ::encode(id, bl);
- ::encode(key, bl);
- ::encode(subuser, bl);
+ encode(id, bl);
+ encode(key, bl);
+ encode(subuser, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN_32(2, 2, 2, bl);
- ::decode(id, bl);
- ::decode(key, bl);
- ::decode(subuser, bl);
+ decode(id, bl);
+ decode(key, bl);
+ decode(subuser, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
RGWSubUser() : perm_mask(0) {}
void encode(bufferlist& bl) const {
ENCODE_START(2, 2, bl);
- ::encode(name, bl);
- ::encode(perm_mask, bl);
+ encode(name, bl);
+ encode(perm_mask, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN_32(2, 2, 2, bl);
- ::decode(name, bl);
- ::decode(perm_mask, bl);
+ decode(name, bl);
+ decode(perm_mask, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(caps, bl);
+ encode(caps, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(caps, bl);
+ decode(caps, bl);
DECODE_FINISH(bl);
}
int check_cap(const string& cap, uint32_t perm);
void encode(bufferlist& bl) const {
ENCODE_START(19, 9, bl);
- ::encode(auid, bl);
+ encode(auid, bl);
string access_key;
string secret_key;
if (!access_keys.empty()) {
access_key = k.id;
secret_key = k.key;
}
- ::encode(access_key, bl);
- ::encode(secret_key, bl);
- ::encode(display_name, bl);
- ::encode(user_email, bl);
+ encode(access_key, bl);
+ encode(secret_key, bl);
+ encode(display_name, bl);
+ encode(user_email, bl);
string swift_name;
string swift_key;
if (!swift_keys.empty()) {
swift_name = k.id;
swift_key = k.key;
}
- ::encode(swift_name, bl);
- ::encode(swift_key, bl);
- ::encode(user_id.id, bl);
- ::encode(access_keys, bl);
- ::encode(subusers, bl);
- ::encode(suspended, bl);
- ::encode(swift_keys, bl);
- ::encode(max_buckets, bl);
- ::encode(caps, bl);
- ::encode(op_mask, bl);
- ::encode(system, bl);
- ::encode(default_placement, bl);
- ::encode(placement_tags, bl);
- ::encode(bucket_quota, bl);
- ::encode(temp_url_keys, bl);
- ::encode(user_quota, bl);
- ::encode(user_id.tenant, bl);
- ::encode(admin, bl);
- ::encode(type, bl);
+ encode(swift_name, bl);
+ encode(swift_key, bl);
+ encode(user_id.id, bl);
+ encode(access_keys, bl);
+ encode(subusers, bl);
+ encode(suspended, bl);
+ encode(swift_keys, bl);
+ encode(max_buckets, bl);
+ encode(caps, bl);
+ encode(op_mask, bl);
+ encode(system, bl);
+ encode(default_placement, bl);
+ encode(placement_tags, bl);
+ encode(bucket_quota, bl);
+ encode(temp_url_keys, bl);
+ encode(user_quota, bl);
+ encode(user_id.tenant, bl);
+ encode(admin, bl);
+ encode(type, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN_32(19, 9, 9, bl);
- if (struct_v >= 2) ::decode(auid, bl);
+ if (struct_v >= 2) decode(auid, bl);
else auid = CEPH_AUTH_UID_DEFAULT;
string access_key;
string secret_key;
- ::decode(access_key, bl);
- ::decode(secret_key, bl);
+ decode(access_key, bl);
+ decode(secret_key, bl);
if (struct_v < 6) {
RGWAccessKey k;
k.id = access_key;
k.key = secret_key;
access_keys[access_key] = k;
}
- ::decode(display_name, bl);
- ::decode(user_email, bl);
+ decode(display_name, bl);
+ decode(user_email, bl);
/* We populate swift_keys map later nowadays, but we have to decode. */
string swift_name;
string swift_key;
- if (struct_v >= 3) ::decode(swift_name, bl);
- if (struct_v >= 4) ::decode(swift_key, bl);
+ if (struct_v >= 3) decode(swift_name, bl);
+ if (struct_v >= 4) decode(swift_key, bl);
if (struct_v >= 5)
- ::decode(user_id.id, bl);
+ decode(user_id.id, bl);
else
user_id.id = access_key;
if (struct_v >= 6) {
- ::decode(access_keys, bl);
- ::decode(subusers, bl);
+ decode(access_keys, bl);
+ decode(subusers, bl);
}
suspended = 0;
if (struct_v >= 7) {
- ::decode(suspended, bl);
+ decode(suspended, bl);
}
if (struct_v >= 8) {
- ::decode(swift_keys, bl);
+ decode(swift_keys, bl);
}
if (struct_v >= 10) {
- ::decode(max_buckets, bl);
+ decode(max_buckets, bl);
} else {
max_buckets = RGW_DEFAULT_MAX_BUCKETS;
}
if (struct_v >= 11) {
- ::decode(caps, bl);
+ decode(caps, bl);
}
if (struct_v >= 12) {
- ::decode(op_mask, bl);
+ decode(op_mask, bl);
} else {
op_mask = RGW_OP_TYPE_ALL;
}
if (struct_v >= 13) {
- ::decode(system, bl);
- ::decode(default_placement, bl);
- ::decode(placement_tags, bl); /* tags of allowed placement rules */
+ decode(system, bl);
+ decode(default_placement, bl);
+ decode(placement_tags, bl); /* tags of allowed placement rules */
}
if (struct_v >= 14) {
- ::decode(bucket_quota, bl);
+ decode(bucket_quota, bl);
}
if (struct_v >= 15) {
- ::decode(temp_url_keys, bl);
+ decode(temp_url_keys, bl);
}
if (struct_v >= 16) {
- ::decode(user_quota, bl);
+ decode(user_quota, bl);
}
if (struct_v >= 17) {
- ::decode(user_id.tenant, bl);
+ decode(user_id.tenant, bl);
} else {
user_id.tenant.clear();
}
if (struct_v >= 18) {
- ::decode(admin, bl);
+ decode(admin, bl);
}
if (struct_v >= 19) {
- ::decode(type, bl);
+ decode(type, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(10, 10, bl);
- ::encode(name, bl);
- ::encode(ns, bl);
+ encode(name, bl);
+ encode(ns, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN(10, 3, 3, bl);
- ::decode(name, bl);
+ decode(name, bl);
if (struct_v < 10) {
*/
} else {
- ::decode(ns, bl);
+ decode(ns, bl);
}
DECODE_FINISH(bl);
void encode(bufferlist& bl) const {
ENCODE_START(6, 6, bl);
- ::encode(pool, bl);
- ::encode(oid, bl);
- ::encode(loc, bl);
+ encode(pool, bl);
+ encode(oid, bl);
+ encode(loc, bl);
ENCODE_FINISH(bl);
}
decode_from_rgw_obj(bl);
return;
}
- ::decode(pool, bl);
- ::decode(oid, bl);
- ::decode(loc, bl);
+ decode(pool, bl);
+ decode(oid, bl);
+ decode(loc, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(10, 10, bl);
- ::encode(name, bl);
- ::encode(marker, bl);
- ::encode(bucket_id, bl);
- ::encode(tenant, bl);
+ encode(name, bl);
+ encode(marker, bl);
+ encode(bucket_id, bl);
+ encode(tenant, bl);
bool encode_explicit = !explicit_placement.data_pool.empty();
- ::encode(encode_explicit, bl);
+ encode(encode_explicit, bl);
if (encode_explicit) {
- ::encode(explicit_placement.data_pool, bl);
- ::encode(explicit_placement.data_extra_pool, bl);
- ::encode(explicit_placement.index_pool, bl);
+ encode(explicit_placement.data_pool, bl);
+ encode(explicit_placement.data_extra_pool, bl);
+ encode(explicit_placement.index_pool, bl);
}
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN(10, 3, 3, bl);
- ::decode(name, bl);
+ decode(name, bl);
if (struct_v < 10) {
- ::decode(explicit_placement.data_pool.name, bl);
+ decode(explicit_placement.data_pool.name, bl);
}
if (struct_v >= 2) {
- ::decode(marker, bl);
+ decode(marker, bl);
if (struct_v <= 3) {
uint64_t id;
- ::decode(id, bl);
+ decode(id, bl);
char buf[16];
snprintf(buf, sizeof(buf), "%llu", (long long)id);
bucket_id = buf;
} else {
- ::decode(bucket_id, bl);
+ decode(bucket_id, bl);
}
}
if (struct_v < 10) {
if (struct_v >= 5) {
- ::decode(explicit_placement.index_pool.name, bl);
+ decode(explicit_placement.index_pool.name, bl);
} else {
explicit_placement.index_pool = explicit_placement.data_pool;
}
if (struct_v >= 7) {
- ::decode(explicit_placement.data_extra_pool.name, bl);
+ decode(explicit_placement.data_extra_pool.name, bl);
}
}
if (struct_v >= 8) {
- ::decode(tenant, bl);
+ decode(tenant, bl);
}
if (struct_v >= 10) {
bool decode_explicit = !explicit_placement.data_pool.empty();
- ::decode(decode_explicit, bl);
+ decode(decode_explicit, bl);
if (decode_explicit) {
- ::decode(explicit_placement.data_pool, bl);
- ::decode(explicit_placement.data_extra_pool, bl);
- ::decode(explicit_placement.index_pool, bl);
+ decode(explicit_placement.data_pool, bl);
+ decode(explicit_placement.data_extra_pool, bl);
+ decode(explicit_placement.index_pool, bl);
}
}
DECODE_FINISH(bl);
void encode(bufferlist& bl) const {
ENCODE_START(19, 4, bl);
- ::encode(bucket, bl);
- ::encode(owner.id, bl);
- ::encode(flags, bl);
- ::encode(zonegroup, bl);
+ encode(bucket, bl);
+ encode(owner.id, bl);
+ encode(flags, bl);
+ encode(zonegroup, bl);
uint64_t ct = real_clock::to_time_t(creation_time);
- ::encode(ct, bl);
- ::encode(placement_rule, bl);
- ::encode(has_instance_obj, bl);
- ::encode(quota, bl);
- ::encode(num_shards, bl);
- ::encode(bucket_index_shard_hash_type, bl);
- ::encode(requester_pays, bl);
- ::encode(owner.tenant, bl);
- ::encode(has_website, bl);
+ encode(ct, bl);
+ encode(placement_rule, bl);
+ encode(has_instance_obj, bl);
+ encode(quota, bl);
+ encode(num_shards, bl);
+ encode(bucket_index_shard_hash_type, bl);
+ encode(requester_pays, bl);
+ encode(owner.tenant, bl);
+ encode(has_website, bl);
if (has_website) {
- ::encode(website_conf, bl);
+ encode(website_conf, bl);
}
- ::encode((uint32_t)index_type, bl);
- ::encode(swift_versioning, bl);
+ encode((uint32_t)index_type, bl);
+ encode(swift_versioning, bl);
if (swift_versioning) {
- ::encode(swift_ver_location, bl);
+ encode(swift_ver_location, bl);
}
- ::encode(creation_time, bl);
- ::encode(mdsearch_config, bl);
- ::encode(reshard_status, bl);
- ::encode(new_bucket_instance_id, bl);
+ encode(creation_time, bl);
+ encode(mdsearch_config, bl);
+ encode(reshard_status, bl);
+ encode(new_bucket_instance_id, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN_32(19, 4, 4, bl);
- ::decode(bucket, bl);
+ decode(bucket, bl);
if (struct_v >= 2) {
string s;
- ::decode(s, bl);
+ decode(s, bl);
owner.from_str(s);
}
if (struct_v >= 3)
- ::decode(flags, bl);
+ decode(flags, bl);
if (struct_v >= 5)
- ::decode(zonegroup, bl);
+ decode(zonegroup, bl);
if (struct_v >= 6) {
uint64_t ct;
- ::decode(ct, bl);
+ decode(ct, bl);
if (struct_v < 17)
creation_time = ceph::real_clock::from_time_t((time_t)ct);
}
if (struct_v >= 7)
- ::decode(placement_rule, bl);
+ decode(placement_rule, bl);
if (struct_v >= 8)
- ::decode(has_instance_obj, bl);
+ decode(has_instance_obj, bl);
if (struct_v >= 9)
- ::decode(quota, bl);
+ decode(quota, bl);
if (struct_v >= 10)
- ::decode(num_shards, bl);
+ decode(num_shards, bl);
if (struct_v >= 11)
- ::decode(bucket_index_shard_hash_type, bl);
+ decode(bucket_index_shard_hash_type, bl);
if (struct_v >= 12)
- ::decode(requester_pays, bl);
+ decode(requester_pays, bl);
if (struct_v >= 13)
- ::decode(owner.tenant, bl);
+ decode(owner.tenant, bl);
if (struct_v >= 14) {
- ::decode(has_website, bl);
+ decode(has_website, bl);
if (has_website) {
- ::decode(website_conf, bl);
+ decode(website_conf, bl);
} else {
website_conf = RGWBucketWebsiteConf();
}
}
if (struct_v >= 15) {
uint32_t it;
- ::decode(it, bl);
+ decode(it, bl);
index_type = (RGWBucketIndexType)it;
} else {
index_type = RGWBIType_Normal;
swift_versioning = false;
swift_ver_location.clear();
if (struct_v >= 16) {
- ::decode(swift_versioning, bl);
+ decode(swift_versioning, bl);
if (swift_versioning) {
- ::decode(swift_ver_location, bl);
+ decode(swift_ver_location, bl);
}
}
if (struct_v >= 17) {
- ::decode(creation_time, bl);
+ decode(creation_time, bl);
}
if (struct_v >= 18) {
- ::decode(mdsearch_config, bl);
+ decode(mdsearch_config, bl);
}
if (struct_v >= 19) {
- ::decode(reshard_status, bl);
- ::decode(new_bucket_instance_id, bl);
+ decode(reshard_status, bl);
+ decode(new_bucket_instance_id, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(10, 8, bl);
- ::encode(bucket, bl);
- ::encode(owner.id, bl);
- ::encode(linked, bl);
+ encode(bucket, bl);
+ encode(owner.id, bl);
+ encode(linked, bl);
uint64_t ctime = (uint64_t)real_clock::to_time_t(creation_time);
- ::encode(ctime, bl);
- ::encode(owner, bl);
- ::encode(creation_time, bl);
+ encode(ctime, bl);
+ encode(owner, bl);
+ encode(creation_time, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
return;
}
has_bucket_info = false;
- ::decode(bucket, bl);
- ::decode(owner.id, bl);
- ::decode(linked, bl);
+ decode(bucket, bl);
+ decode(owner.id, bl);
+ decode(linked, bl);
uint64_t ctime;
- ::decode(ctime, bl);
+ decode(ctime, bl);
if (struct_v < 10) {
creation_time = real_clock::from_time_t((time_t)ctime);
}
if (struct_v >= 9) {
- ::decode(owner, bl);
+ decode(owner, bl);
}
if (struct_v >= 10) {
- ::decode(creation_time, bl);
+ decode(creation_time, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
- ::encode(name, bl);
- ::encode(instance, bl);
- ::encode(ns, bl);
+ encode(name, bl);
+ encode(instance, bl);
+ encode(ns, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(2, bl);
- ::decode(name, bl);
- ::decode(instance, bl);
+ decode(name, bl);
+ decode(instance, bl);
if (struct_v >= 2) {
- ::decode(ns, bl);
+ decode(ns, bl);
}
DECODE_FINISH(bl);
}
uint64_t s = size;
__u32 mt = ceph::real_clock::to_time_t(creation_time);
string empty_str; // originally had the bucket name here, but we encode bucket later
- ::encode(empty_str, bl);
- ::encode(s, bl);
- ::encode(mt, bl);
- ::encode(count, bl);
- ::encode(bucket, bl);
+ encode(empty_str, bl);
+ encode(s, bl);
+ encode(mt, bl);
+ encode(count, bl);
+ encode(bucket, bl);
s = size_rounded;
- ::encode(s, bl);
- ::encode(creation_time, bl);
- ::encode(placement_rule, bl);
+ encode(s, bl);
+ encode(creation_time, bl);
+ encode(placement_rule, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
__u32 mt;
uint64_t s;
string empty_str; // backward compatibility
- ::decode(empty_str, bl);
- ::decode(s, bl);
- ::decode(mt, bl);
+ decode(empty_str, bl);
+ decode(s, bl);
+ decode(mt, bl);
size = s;
if (struct_v < 6) {
creation_time = ceph::real_clock::from_time_t(mt);
}
if (struct_v >= 2)
- ::decode(count, bl);
+ decode(count, bl);
if (struct_v >= 3)
- ::decode(bucket, bl);
+ decode(bucket, bl);
if (struct_v >= 4)
- ::decode(s, bl);
+ decode(s, bl);
size_rounded = s;
if (struct_v >= 6)
- ::decode(creation_time, bl);
+ decode(creation_time, bl);
if (struct_v >= 7)
- ::decode(placement_rule, bl);
+ decode(placement_rule, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void encode(bufferlist& bl) const {
ENCODE_START(6, 6, bl);
- ::encode(bucket, bl);
- ::encode(key.ns, bl);
- ::encode(key.name, bl);
- ::encode(key.instance, bl);
-// ::encode(placement_id, bl);
+ encode(bucket, bl);
+ encode(key.ns, bl);
+ encode(key.name, bl);
+ encode(key.instance, bl);
+// encode(placement_id, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN(6, 3, 3, bl);
if (struct_v < 6) {
string s;
- ::decode(bucket.name, bl); /* bucket.name */
- ::decode(s, bl); /* loc */
- ::decode(key.ns, bl);
- ::decode(key.name, bl);
+ decode(bucket.name, bl); /* bucket.name */
+ decode(s, bl); /* loc */
+ decode(key.ns, bl);
+ decode(key.name, bl);
if (struct_v >= 2)
- ::decode(bucket, bl);
+ decode(bucket, bl);
if (struct_v >= 4)
- ::decode(key.instance, bl);
+ decode(key.instance, bl);
if (key.ns.empty() && key.instance.empty()) {
if (key.name[0] == '_') {
key.name = key.name.substr(1);
}
} else {
if (struct_v >= 5) {
- ::decode(key.name, bl);
+ decode(key.name, bl);
} else {
ssize_t pos = key.name.find('_', 1);
if (pos < 0) {
}
}
} else {
- ::decode(bucket, bl);
- ::decode(key.ns, bl);
- ::decode(key.name, bl);
- ::decode(key.instance, bl);
-// ::decode(placement_id, bl);
+ decode(bucket, bl);
+ decode(key.ns, bl);
+ decode(key.name, bl);
+ decode(key.instance, bl);
+// decode(placement_id, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
- ::encode(state, bl);
- ::encode(num_shards, bl);
- ::encode(period, bl);
- ::encode(realm_epoch, bl);
+ encode(state, bl);
+ encode(num_shards, bl);
+ encode(period, bl);
+ encode(realm_epoch, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(state, bl);
- ::decode(num_shards, bl);
+ decode(state, bl);
+ decode(num_shards, bl);
if (struct_v >= 2) {
- ::decode(period, bl);
- ::decode(realm_epoch, bl);
+ decode(period, bl);
+ decode(realm_epoch, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
- ::encode(state, bl);
- ::encode(marker, bl);
- ::encode(next_step_marker, bl);
- ::encode(total_entries, bl);
- ::encode(pos, bl);
- ::encode(timestamp, bl);
- ::encode(realm_epoch, bl);
+ encode(state, bl);
+ encode(marker, bl);
+ encode(next_step_marker, bl);
+ encode(total_entries, bl);
+ encode(pos, bl);
+ encode(timestamp, bl);
+ encode(realm_epoch, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(2, bl);
- ::decode(state, bl);
- ::decode(marker, bl);
- ::decode(next_step_marker, bl);
- ::decode(total_entries, bl);
- ::decode(pos, bl);
- ::decode(timestamp, bl);
+ decode(state, bl);
+ decode(marker, bl);
+ decode(next_step_marker, bl);
+ decode(total_entries, bl);
+ decode(pos, bl);
+ decode(timestamp, bl);
if (struct_v >= 2) {
- ::decode(realm_epoch, bl);
+ decode(realm_epoch, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(sync_info, bl);
- ::encode(sync_markers, bl);
+ encode(sync_info, bl);
+ encode(sync_markers, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(sync_info, bl);
- ::decode(sync_markers, bl);
+ decode(sync_info, bl);
+ decode(sync_markers, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(path, bl);
- ::encode(etag, bl);
- ::encode(size_bytes, bl);
+ encode(path, bl);
+ encode(etag, bl);
+ encode(size_bytes, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(path, bl);
- ::decode(etag, bl);
- ::decode(size_bytes, bl);
+ decode(path, bl);
+ decode(etag, bl);
+ decode(size_bytes, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(entries, bl);
- ::encode(total_size, bl);
+ encode(entries, bl);
+ encode(total_size, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entries, bl);
- ::decode(total_size, bl);
+ decode(entries, bl);
+ decode(total_size, bl);
DECODE_FINISH(bl);
}
};
}
bufferlist delatbl;
- ::encode(*delete_at, delatbl);
+ encode(*delete_at, delatbl);
attrs[RGW_ATTR_DELETE_AT] = delatbl;
} /* encode_delete_at_attr */
int RGWSystemMetaObj::read_default(RGWDefaultSystemMetaObjInfo& default_info, const string& oid)
{
+ using ceph::decode;
auto pool = get_pool(cct);
bufferlist bl;
RGWObjectCtx obj_ctx(store);
try {
bufferlist::iterator iter = bl.begin();
- ::decode(default_info, iter);
+ decode(default_info, iter);
} catch (buffer::error& err) {
ldout(cct, 0) << "error decoding data from " << pool << ":" << oid << dendl;
return -EIO;
int RGWSystemMetaObj::set_as_default(bool exclusive)
{
+ using ceph::encode;
string oid = get_default_oid();
rgw_pool pool(get_pool(cct));
RGWDefaultSystemMetaObjInfo default_info;
default_info.default_id = id;
- ::encode(default_info, bl);
+ encode(default_info, bl);
int ret = rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(),
exclusive, NULL, real_time(), NULL);
int RGWSystemMetaObj::read_id(const string& obj_name, string& object_id)
{
+ using ceph::decode;
rgw_pool pool(get_pool(cct));
bufferlist bl;
RGWNameToId nameToId;
try {
bufferlist::iterator iter = bl.begin();
- ::decode(nameToId, iter);
+ decode(nameToId, iter);
} catch (buffer::error& err) {
ldout(cct, 0) << "ERROR: failed to decode obj from " << pool << ":" << oid << dendl;
return -EIO;
nameToId.obj_id = id;
bufferlist bl;
- ::encode(nameToId, bl);
+ using ceph::encode;
+ encode(nameToId, bl);
return rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(), exclusive, NULL, real_time(), NULL);
}
ldout(cct, 0) << "failed reading obj info from " << pool << ":" << oid << ": " << cpp_strerror(-ret) << dendl;
return ret;
}
+ using ceph::decode;
try {
bufferlist::iterator iter = bl.begin();
- ::decode(*this, iter);
+ decode(*this, iter);
} catch (buffer::error& err) {
ldout(cct, 0) << "ERROR: failed to decode obj from " << pool << ":" << oid << dendl;
return -EIO;
string oid = get_info_oid_prefix() + id;
bufferlist bl;
- ::encode(*this, bl);
+ using ceph::encode;
+ encode(*this, bl);
return rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(), exclusive, NULL, real_time(), NULL);
}
int RGWRealm::notify_new_period(const RGWPeriod& period)
{
bufferlist bl;
+ using ceph::encode;
// push the period to dependent zonegroups/zones
- ::encode(RGWRealmNotify::ZonesNeedPeriod, bl);
- ::encode(period, bl);
+ encode(RGWRealmNotify::ZonesNeedPeriod, bl);
+ encode(period, bl);
// reload the gateway with the new period
- ::encode(RGWRealmNotify::Reload, bl);
+ encode(RGWRealmNotify::Reload, bl);
return notify_zone(bl);
}
if (ret < 0) {
return ret;
}
+ using ceph::decode;
try {
bufferlist::iterator iter = bl.begin();
- ::decode(*this, iter);
+ decode(*this, iter);
} catch (buffer::error& err) {
return -EIO;
}
const auto& pool = get_pool(store->ctx());
const auto& oid = get_oid(realm_id);
bufferlist bl;
- ::encode(*this, bl);
+ using ceph::encode;
+ encode(*this, bl);
return rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(),
false, nullptr, real_time(), nullptr);
}
}
try {
bufferlist::iterator iter = bl.begin();
- ::decode(info, iter);
+ using ceph::decode;
+ decode(info, iter);
} catch (buffer::error& err) {
ldout(cct, 0) << "error decoding data from " << pool << ":" << oid << dendl;
return -EIO;
RGWPeriodLatestEpochInfo info;
info.epoch = epoch;
- ::encode(info, bl);
+ using ceph::encode;
+ encode(info, bl);
return rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(),
exclusive, objv, real_time(), nullptr);
}
try {
+ using ceph::decode;
bufferlist::iterator iter = bl.begin();
- ::decode(*this, iter);
+ decode(*this, iter);
} catch (buffer::error& err) {
ldout(cct, 0) << "ERROR: failed to decode obj from " << pool << ":" << get_period_oid() << dendl;
return -EIO;
string oid = get_period_oid();
bufferlist bl;
- ::encode(*this, bl);
+ using ceph::encode;
+ encode(*this, bl);
return rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(),
exclusive, NULL, real_time(), NULL);
void RGWPeriodMap::encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
- ::encode(id, bl);
- ::encode(zonegroups, bl);
- ::encode(master_zonegroup, bl);
- ::encode(short_zone_ids, bl);
+ encode(id, bl);
+ encode(zonegroups, bl);
+ encode(master_zonegroup, bl);
+ encode(short_zone_ids, bl);
ENCODE_FINISH(bl);
}
void RGWPeriodMap::decode(bufferlist::iterator& bl) {
DECODE_START(2, bl);
- ::decode(id, bl);
- ::decode(zonegroups, bl);
- ::decode(master_zonegroup, bl);
+ decode(id, bl);
+ decode(zonegroups, bl);
+ decode(master_zonegroup, bl);
if (struct_v >= 2) {
- ::decode(short_zone_ids, bl);
+ decode(short_zone_ids, bl);
}
DECODE_FINISH(bl);
void RGWRegionMap::encode(bufferlist& bl) const {
ENCODE_START( 3, 1, bl);
- ::encode(regions, bl);
- ::encode(master_region, bl);
- ::encode(bucket_quota, bl);
- ::encode(user_quota, bl);
+ encode(regions, bl);
+ encode(master_region, bl);
+ encode(bucket_quota, bl);
+ encode(user_quota, bl);
ENCODE_FINISH(bl);
}
void RGWRegionMap::decode(bufferlist::iterator& bl) {
DECODE_START(3, bl);
- ::decode(regions, bl);
- ::decode(master_region, bl);
+ decode(regions, bl);
+ decode(master_region, bl);
if (struct_v >= 2)
- ::decode(bucket_quota, bl);
+ decode(bucket_quota, bl);
if (struct_v >= 3)
- ::decode(user_quota, bl);
+ decode(user_quota, bl);
DECODE_FINISH(bl);
}
void RGWZoneGroupMap::encode(bufferlist& bl) const {
ENCODE_START( 3, 1, bl);
- ::encode(zonegroups, bl);
- ::encode(master_zonegroup, bl);
- ::encode(bucket_quota, bl);
- ::encode(user_quota, bl);
+ encode(zonegroups, bl);
+ encode(master_zonegroup, bl);
+ encode(bucket_quota, bl);
+ encode(user_quota, bl);
ENCODE_FINISH(bl);
}
void RGWZoneGroupMap::decode(bufferlist::iterator& bl) {
DECODE_START(3, bl);
- ::decode(zonegroups, bl);
- ::decode(master_zonegroup, bl);
+ decode(zonegroups, bl);
+ decode(master_zonegroup, bl);
if (struct_v >= 2)
- ::decode(bucket_quota, bl);
+ decode(bucket_quota, bl);
if (struct_v >= 3)
- ::decode(user_quota, bl);
+ decode(user_quota, bl);
DECODE_FINISH(bl);
zonegroups_by_api.clear();
try {
bufferlist::iterator iter = bl.begin();
- ::decode(zonegroupmap, iter);
+ decode(zonegroupmap, iter);
} catch (buffer::error& err) {
ldout(cct, 0) << "error decoding regionmap from " << pool << ":" << oid << dendl;
return -EIO;
if (state->p.end())
return 0; // end of file
try {
- ::decode(*entry, state->p);
+ decode(*entry, state->p);
}
catch (const buffer::error &e) {
return -EINVAL;
.obj_key = obj_key,
.exp_time = delete_at };
bufferlist hebl;
- ::encode(he, hebl);
+ encode(he, hebl);
ObjectWriteOperation op;
cls_timeindex_add(op, utime_t(delete_at), keyext, hebl);
{
try {
bufferlist::iterator iter = ti_entry.value.begin();
- ::decode(hint_entry, iter);
+ decode(hint_entry, iter);
} catch (buffer::error& err) {
ldout(cct, 0) << "ERROR: couldn't decode avail_pools" << dendl;
}
try {
bufferlist::iterator iter = map_bl.begin();
- ::decode(m, iter);
+ decode(m, iter);
} catch (buffer::error& err) {
ldout(cct, 0) << "ERROR: couldn't decode avail_pools" << dendl;
}
if (write_map) {
bufferlist new_bl;
- ::encode(m, new_bl);
+ encode(m, new_bl);
ret = put_system_obj_data(NULL, obj, new_bl, -1, false);
if (ret < 0) {
ldout(cct, 0) << "WARNING: could not save avail pools map info ret=" << ret << dendl;
return ret;
bufferlist new_bl;
- ::encode(m, new_bl);
+ encode(m, new_bl);
ret = put_system_obj_data(NULL, obj, new_bl, -1, false);
if (ret < 0) {
ldout(cct, 0) << "WARNING: could not save avail pools map info ret=" << ret << dendl;
attrs.erase(iter);
bufferlist bl;
- ::encode(*meta.manifest, bl);
+ encode(*meta.manifest, bl);
op.setxattr(RGW_ATTR_MANIFEST, bl);
}
if (attrs.find(RGW_ATTR_SOURCE_ZONE) == attrs.end()) {
bufferlist bl;
- ::encode(store->get_zone_short_id(), bl);
+ encode(store->get_zone_short_id(), bl);
op.setxattr(RGW_ATTR_SOURCE_ZONE, bl);
}
cs_info.compression_type = plugin->get_type_name();
cs_info.orig_size = cb.get_data_len();
cs_info.blocks = move(compressor->get_compression_blocks());
- ::encode(cs_info, tmp);
+ encode(cs_info, tmp);
cb.get_attrs()[RGW_ATTR_COMPRESSION] = tmp;
}
map<string, bufferlist>::iterator iter = cb.get_attrs().find(RGW_ATTR_DELETE_AT);
if (iter != cb.get_attrs().end()) {
try {
- ::decode(delete_at, iter->second);
+ decode(delete_at, iter->second);
} catch (buffer::error& err) {
ldout(cct, 0) << "ERROR: failed to decode delete_at field in intra zone copy" << dendl;
}
if (i != attrs.end() && i->second.length() > 0) {
bufferlist::iterator iter = i->second.begin();
try {
- ::decode(pg_ver, iter);
+ decode(pg_ver, iter);
} catch (buffer::error& err) {
ldout(ctx(), 0) << "ERROR: failed to decode pg ver attribute, ignoring" << dendl;
/* non critical error */
if (state->get_attr(RGW_ATTR_DELETE_AT, bl)) {
try {
bufferlist::iterator iter = bl.begin();
- ::decode(delete_at, iter);
+ decode(delete_at, iter);
} catch (buffer::error& err) {
ldout(store->ctx(), 0) << "ERROR: couldn't decode RGW_ATTR_DELETE_AT" << dendl;
return -EIO;
try {
RGWCompressionInfo info;
auto p = iter->second.begin();
- ::decode(info, p);
+ decode(info, p);
s->accounted_size = info.orig_size;
} catch (buffer::error&) {
dout(0) << "ERROR: could not decode compression info for object: " << obj << dendl;
if (manifest_bl.length()) {
bufferlist::iterator miter = manifest_bl.begin();
try {
- ::decode(s->manifest, miter);
+ decode(s->manifest, miter);
s->has_manifest = true;
s->manifest.set_head(bucket_info.placement_rule, obj, s->size); /* patch manifest to reflect the head we just read, some manifests might be
broken due to old bugs */
if (pg_ver_bl.length()) {
bufferlist::iterator pgbl = pg_ver_bl.begin();
try {
- ::decode(s->pg_ver, pgbl);
+ decode(s->pg_ver, pgbl);
} catch (buffer::error& err) {
ldout(cct, 0) << "ERROR: couldn't decode pg ver attr for object " << s->obj << ", non-critical error, ignoring" << dendl;
}
if (zone_short_id_bl.length()) {
bufferlist::iterator zbl = zone_short_id_bl.begin();
try {
- ::decode(s->zone_short_id, zbl);
+ decode(s->zone_short_id, zbl);
} catch (buffer::error& err) {
ldout(cct, 0) << "ERROR: couldn't decode zone short id attr for object " << s->obj << ", non-critical error, ignoring" << dendl;
}
bufferlist& bl = iter->second;
bufferlist::iterator biter = bl.begin();
try {
- ::decode(result.manifest, biter);
+ decode(result.manifest, biter);
} catch (buffer::error& err) {
RGWRados *store = source->get_store();
ldout(store->ctx(), 0) << "ERROR: " << __func__ << ": failed to decode manifest" << dendl;
if (name.compare(RGW_ATTR_DELETE_AT) == 0) {
real_time ts;
try {
- ::decode(ts, bl);
+ decode(ts, bl);
rgw_obj_index_key obj_key;
obj.key.get_index_key(&obj_key);
bufferlist bl;
RGWOLHPendingInfo pending_info;
pending_info.time = real_clock::now();
- ::encode(pending_info, bl);
+ encode(pending_info, bl);
#define OLH_PENDING_TAG_LEN 32
/* tag will start with current time epoch, this so that entries are sorted by time */
info.target = target;
info.removed = delete_marker;
bufferlist bl;
- ::encode(info, bl);
+ encode(info, bl);
op.setxattr(RGW_ATTR_OLH_INFO, bl);
}
try {
bufferlist::iterator biter = iter->second.begin();
- ::decode(*olh, biter);
+ decode(*olh, biter);
} catch (buffer::error& err) {
ldout(cct, 0) << "ERROR: failed to decode olh info" << dendl;
return -EIO;
bufferlist::iterator biter = iter->second.begin();
RGWOLHPendingInfo pending_info;
try {
- ::decode(pending_info, biter);
+ decode(pending_info, biter);
} catch (buffer::error& err) {
/* skipping bad entry, we could remove it but it might hide a bug */
ldout(cct, 0) << "ERROR: failed to decode pending entry " << iter->first << dendl;
RGWOLHInfo olh;
try {
bufferlist::iterator biter = iter->second.begin();
- ::decode(olh, biter);
+ decode(olh, biter);
} catch (buffer::error& err) {
ldout(cct, 0) << "ERROR: failed to decode olh info" << dendl;
return -EIO;
bufferlist::iterator iter = epbl.begin();
try {
- ::decode(info, iter);
+ decode(info, iter);
} catch (buffer::error& err) {
ldout(cct, 0) << "ERROR: could not decode buffer info, caught buffer::error" << dendl;
return -EIO;
bufferlist::iterator iter = bl.begin();
try {
- ::decode(entry_point, iter);
+ decode(entry_point, iter);
} catch (buffer::error& err) {
ldout(cct, 0) << "ERROR: could not decode buffer info, caught buffer::error" << dendl;
return -EIO;
map<string, bufferlist> *pattrs)
{
bufferlist epbl;
- ::encode(entry_point, epbl);
+ encode(entry_point, epbl);
string bucket_entry;
rgw_make_bucket_entry_name(tenant_name, bucket_name, bucket_entry);
return rgw_bucket_store_info(this, bucket_entry, epbl, exclusive, pattrs, &objv_tracker, mtime);
info.has_instance_obj = true;
bufferlist bl;
- ::encode(info, bl);
+ encode(info, bl);
string key = info.bucket.get_key(); /* when we go through meta api, we don't use oid directly */
int ret = rgw_bucket_instance_store_info(this, key, bl, exclusive, pattrs, &info.objv_tracker, mtime);
}
bufferlist::iterator iter = bi_entry.data.begin();
try {
- ::decode(*dirent, iter);
+ decode(*dirent, iter);
} catch (buffer::error& err) {
ldout(cct, 0) << "ERROR: failed to decode bi_entry()" << dendl;
return -EIO;
dout(2) << "RGWRados::remove_objs_from_index bucket=" << bucket_info.bucket << " obj=" << entry.key.name << ":" << entry.key.instance << dendl;
entry.ver.epoch = (uint64_t)-1; // ULLONG_MAX, needed to that objclass doesn't skip out request
updates.append(CEPH_RGW_REMOVE | suggest_flag);
- ::encode(entry, updates);
+ encode(entry, updates);
}
bufferlist out;
if (value != attrs.end()) {
bufferlist::iterator bliter = value->second.begin();
try {
- ::decode(cs_info, bliter);
+ decode(cs_info, bliter);
} catch (buffer::error& err) {
return -EIO;
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(old_ofs, bl);
- ::encode(new_ofs, bl);
- ::encode(len, bl);
+ encode(old_ofs, bl);
+ encode(new_ofs, bl);
+ encode(len, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(old_ofs, bl);
- ::decode(new_ofs, bl);
- ::decode(len, bl);
+ decode(old_ofs, bl);
+ decode(new_ofs, bl);
+ decode(len, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(compression_type, bl);
- ::encode(orig_size, bl);
- ::encode(blocks, bl);
+ encode(compression_type, bl);
+ encode(orig_size, bl);
+ encode(blocks, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(compression_type, bl);
- ::decode(orig_size, bl);
- ::decode(blocks, bl);
+ decode(compression_type, bl);
+ decode(orig_size, bl);
+ decode(blocks, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(target, bl);
- ::encode(removed, bl);
+ encode(target, bl);
+ encode(removed, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(target, bl);
- ::decode(removed, bl);
+ decode(target, bl);
+ decode(removed, bl);
DECODE_FINISH(bl);
}
static void generate_test_instances(list<RGWOLHInfo*>& o);
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(time, bl);
+ encode(time, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(time, bl);
+ decode(time, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(2, 2, bl);
- ::encode(loc, bl);
- ::encode(loc_ofs, bl);
- ::encode(size, bl);
+ encode(loc, bl);
+ encode(loc_ofs, bl);
+ encode(size, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN_32(2, 2, 2, bl);
- ::decode(loc, bl);
- ::decode(loc_ofs, bl);
- ::decode(size, bl);
+ decode(loc, bl);
+ decode(loc_ofs, bl);
+ decode(size, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
- ::encode(start_part_num, bl);
- ::encode(start_ofs, bl);
- ::encode(part_size, bl);
- ::encode(stripe_max_size, bl);
- ::encode(override_prefix, bl);
+ encode(start_part_num, bl);
+ encode(start_ofs, bl);
+ encode(part_size, bl);
+ encode(stripe_max_size, bl);
+ encode(override_prefix, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(2, bl);
- ::decode(start_part_num, bl);
- ::decode(start_ofs, bl);
- ::decode(part_size, bl);
- ::decode(stripe_max_size, bl);
+ decode(start_part_num, bl);
+ decode(start_ofs, bl);
+ decode(part_size, bl);
+ decode(stripe_max_size, bl);
if (struct_v >= 2)
- ::decode(override_prefix, bl);
+ decode(override_prefix, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void encode(bufferlist& bl) const {
ENCODE_START(7, 6, bl);
- ::encode(obj_size, bl);
- ::encode(objs, bl);
- ::encode(explicit_objs, bl);
- ::encode(obj, bl);
- ::encode(head_size, bl);
- ::encode(max_head_size, bl);
- ::encode(prefix, bl);
- ::encode(rules, bl);
+ encode(obj_size, bl);
+ encode(objs, bl);
+ encode(explicit_objs, bl);
+ encode(obj, bl);
+ encode(head_size, bl);
+ encode(max_head_size, bl);
+ encode(prefix, bl);
+ encode(rules, bl);
bool encode_tail_bucket = !(tail_placement.bucket == obj.bucket);
- ::encode(encode_tail_bucket, bl);
+ encode(encode_tail_bucket, bl);
if (encode_tail_bucket) {
- ::encode(tail_placement.bucket, bl);
+ encode(tail_placement.bucket, bl);
}
bool encode_tail_instance = (tail_instance != obj.key.instance);
- ::encode(encode_tail_instance, bl);
+ encode(encode_tail_instance, bl);
if (encode_tail_instance) {
- ::encode(tail_instance, bl);
+ encode(tail_instance, bl);
}
- ::encode(head_placement_rule, bl);
- ::encode(tail_placement.placement_rule, bl);
+ encode(head_placement_rule, bl);
+ encode(tail_placement.placement_rule, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN_32(7, 2, 2, bl);
- ::decode(obj_size, bl);
- ::decode(objs, bl);
+ decode(obj_size, bl);
+ decode(objs, bl);
if (struct_v >= 3) {
- ::decode(explicit_objs, bl);
- ::decode(obj, bl);
- ::decode(head_size, bl);
- ::decode(max_head_size, bl);
- ::decode(prefix, bl);
- ::decode(rules, bl);
+ decode(explicit_objs, bl);
+ decode(obj, bl);
+ decode(head_size, bl);
+ decode(max_head_size, bl);
+ decode(prefix, bl);
+ decode(rules, bl);
} else {
explicit_objs = true;
if (!objs.empty()) {
if (struct_v >= 4) {
if (struct_v < 6) {
- ::decode(tail_placement.bucket, bl);
+ decode(tail_placement.bucket, bl);
} else {
bool need_to_decode;
- ::decode(need_to_decode, bl);
+ decode(need_to_decode, bl);
if (need_to_decode) {
- ::decode(tail_placement.bucket, bl);
+ decode(tail_placement.bucket, bl);
} else {
tail_placement.bucket = obj.bucket;
}
if (struct_v >= 5) {
if (struct_v < 6) {
- ::decode(tail_instance, bl);
+ decode(tail_instance, bl);
} else {
bool need_to_decode;
- ::decode(need_to_decode, bl);
+ decode(need_to_decode, bl);
if (need_to_decode) {
- ::decode(tail_instance, bl);
+ decode(tail_instance, bl);
} else {
tail_instance = obj.key.instance;
}
}
if (struct_v >= 7) {
- ::decode(head_placement_rule, bl);
- ::decode(tail_placement.placement_rule, bl);
+ decode(head_placement_rule, bl);
+ decode(tail_placement.placement_rule, bl);
}
update_iterators();
void encode(bufferlist& bl) const {
ENCODE_START(4, 2, bl);
- ::encode(num, bl);
- ::encode(size, bl);
- ::encode(etag, bl);
- ::encode(modified, bl);
- ::encode(manifest, bl);
- ::encode(cs_info, bl);
- ::encode(accounted_size, bl);
+ encode(num, bl);
+ encode(size, bl);
+ encode(etag, bl);
+ encode(modified, bl);
+ encode(manifest, bl);
+ encode(cs_info, bl);
+ encode(accounted_size, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN(4, 2, 2, bl);
- ::decode(num, bl);
- ::decode(size, bl);
- ::decode(etag, bl);
- ::decode(modified, bl);
+ decode(num, bl);
+ decode(size, bl);
+ decode(etag, bl);
+ decode(modified, bl);
if (struct_v >= 3)
- ::decode(manifest, bl);
+ decode(manifest, bl);
if (struct_v >= 4) {
- ::decode(cs_info, bl);
- ::decode(accounted_size, bl);
+ decode(cs_info, bl);
+ decode(accounted_size, bl);
} else {
accounted_size = size;
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(default_id, bl);
+ encode(default_id, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(default_id, bl);
+ decode(default_id, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(obj_id, bl);
+ encode(obj_id, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(obj_id, bl);
+ decode(obj_id, bl);
DECODE_FINISH(bl);
}
virtual void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(id, bl);
- ::encode(name, bl);
+ encode(id, bl);
+ encode(name, bl);
ENCODE_FINISH(bl);
}
virtual void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(id, bl);
- ::decode(name, bl);
+ decode(id, bl);
+ decode(name, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(6, 1, bl);
- ::encode(index_pool.to_str(), bl);
- ::encode(data_pool.to_str(), bl);
- ::encode(data_extra_pool.to_str(), bl);
- ::encode((uint32_t)index_type, bl);
- ::encode(compression_type, bl);
+ encode(index_pool.to_str(), bl);
+ encode(data_pool.to_str(), bl);
+ encode(data_extra_pool.to_str(), bl);
+ encode((uint32_t)index_type, bl);
+ encode(compression_type, bl);
ENCODE_FINISH(bl);
}
DECODE_START(6, bl);
string index_pool_str;
string data_pool_str;
- ::decode(index_pool_str, bl);
+ decode(index_pool_str, bl);
index_pool = rgw_pool(index_pool_str);
- ::decode(data_pool_str, bl);
+ decode(data_pool_str, bl);
data_pool = rgw_pool(data_pool_str);
if (struct_v >= 4) {
string data_extra_pool_str;
- ::decode(data_extra_pool_str, bl);
+ decode(data_extra_pool_str, bl);
data_extra_pool = rgw_pool(data_extra_pool_str);
}
if (struct_v >= 5) {
uint32_t it;
- ::decode(it, bl);
+ decode(it, bl);
index_type = (RGWBucketIndexType)it;
}
if (struct_v >= 6) {
- ::decode(compression_type, bl);
+ decode(compression_type, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const override {
ENCODE_START(10, 1, bl);
- ::encode(domain_root, bl);
- ::encode(control_pool, bl);
- ::encode(gc_pool, bl);
- ::encode(log_pool, bl);
- ::encode(intent_log_pool, bl);
- ::encode(usage_log_pool, bl);
- ::encode(user_keys_pool, bl);
- ::encode(user_email_pool, bl);
- ::encode(user_swift_pool, bl);
- ::encode(user_uid_pool, bl);
+ encode(domain_root, bl);
+ encode(control_pool, bl);
+ encode(gc_pool, bl);
+ encode(log_pool, bl);
+ encode(intent_log_pool, bl);
+ encode(usage_log_pool, bl);
+ encode(user_keys_pool, bl);
+ encode(user_email_pool, bl);
+ encode(user_swift_pool, bl);
+ encode(user_uid_pool, bl);
RGWSystemMetaObj::encode(bl);
- ::encode(system_key, bl);
- ::encode(placement_pools, bl);
- ::encode(metadata_heap, bl);
- ::encode(realm_id, bl);
- ::encode(lc_pool, bl);
- ::encode(tier_config, bl);
- ::encode(roles_pool, bl);
- ::encode(reshard_pool, bl);
+ encode(system_key, bl);
+ encode(placement_pools, bl);
+ encode(metadata_heap, bl);
+ encode(realm_id, bl);
+ encode(lc_pool, bl);
+ encode(tier_config, bl);
+ encode(roles_pool, bl);
+ encode(reshard_pool, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) override {
DECODE_START(10, bl);
- ::decode(domain_root, bl);
- ::decode(control_pool, bl);
- ::decode(gc_pool, bl);
- ::decode(log_pool, bl);
- ::decode(intent_log_pool, bl);
- ::decode(usage_log_pool, bl);
- ::decode(user_keys_pool, bl);
- ::decode(user_email_pool, bl);
- ::decode(user_swift_pool, bl);
- ::decode(user_uid_pool, bl);
+ decode(domain_root, bl);
+ decode(control_pool, bl);
+ decode(gc_pool, bl);
+ decode(log_pool, bl);
+ decode(intent_log_pool, bl);
+ decode(usage_log_pool, bl);
+ decode(user_keys_pool, bl);
+ decode(user_email_pool, bl);
+ decode(user_swift_pool, bl);
+ decode(user_uid_pool, bl);
if (struct_v >= 6) {
RGWSystemMetaObj::decode(bl);
} else if (struct_v >= 2) {
- ::decode(name, bl);
+ decode(name, bl);
id = name;
}
if (struct_v >= 3)
- ::decode(system_key, bl);
+ decode(system_key, bl);
if (struct_v >= 4)
- ::decode(placement_pools, bl);
+ decode(placement_pools, bl);
if (struct_v >= 5)
- ::decode(metadata_heap, bl);
+ decode(metadata_heap, bl);
if (struct_v >= 6) {
- ::decode(realm_id, bl);
+ decode(realm_id, bl);
}
if (struct_v >= 7) {
- ::decode(lc_pool, bl);
+ decode(lc_pool, bl);
} else {
lc_pool = log_pool.name + ":lc";
}
if (struct_v >= 8) {
- ::decode(tier_config, bl);
+ decode(tier_config, bl);
}
if (struct_v >= 9) {
- ::decode(roles_pool, bl);
+ decode(roles_pool, bl);
} else {
roles_pool = name + ".rgw.meta:roles";
}
if (struct_v >= 10) {
- ::decode(reshard_pool, bl);
+ decode(reshard_pool, bl);
} else {
reshard_pool = log_pool.name + ":reshard";
}
void encode(bufferlist& bl) const {
ENCODE_START(7, 1, bl);
- ::encode(name, bl);
- ::encode(endpoints, bl);
- ::encode(log_meta, bl);
- ::encode(log_data, bl);
- ::encode(bucket_index_max_shards, bl);
- ::encode(id, bl);
- ::encode(read_only, bl);
- ::encode(tier_type, bl);
- ::encode(sync_from_all, bl);
- ::encode(sync_from, bl);
- ::encode(redirect_zone, bl);
+ encode(name, bl);
+ encode(endpoints, bl);
+ encode(log_meta, bl);
+ encode(log_data, bl);
+ encode(bucket_index_max_shards, bl);
+ encode(id, bl);
+ encode(read_only, bl);
+ encode(tier_type, bl);
+ encode(sync_from_all, bl);
+ encode(sync_from, bl);
+ encode(redirect_zone, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(7, bl);
- ::decode(name, bl);
+ decode(name, bl);
if (struct_v < 4) {
id = name;
}
- ::decode(endpoints, bl);
+ decode(endpoints, bl);
if (struct_v >= 2) {
- ::decode(log_meta, bl);
- ::decode(log_data, bl);
+ decode(log_meta, bl);
+ decode(log_data, bl);
}
if (struct_v >= 3) {
- ::decode(bucket_index_max_shards, bl);
+ decode(bucket_index_max_shards, bl);
}
if (struct_v >= 4) {
- ::decode(id, bl);
- ::decode(read_only, bl);
+ decode(id, bl);
+ decode(read_only, bl);
}
if (struct_v >= 5) {
- ::decode(tier_type, bl);
+ decode(tier_type, bl);
}
if (struct_v >= 6) {
- ::decode(sync_from_all, bl);
- ::decode(sync_from, bl);
+ decode(sync_from_all, bl);
+ decode(sync_from, bl);
}
if (struct_v >= 7) {
- ::decode(redirect_zone, bl);
+ decode(redirect_zone, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(default_zonegroup, bl);
+ encode(default_zonegroup, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(default_zonegroup, bl);
+ decode(default_zonegroup, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(name, bl);
- ::encode(tags, bl);
+ encode(name, bl);
+ encode(tags, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(name, bl);
- ::decode(tags, bl);
+ decode(name, bl);
+ decode(tags, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
void encode(bufferlist& bl) const override {
ENCODE_START(4, 1, bl);
- ::encode(name, bl);
- ::encode(api_name, bl);
- ::encode(is_master, bl);
- ::encode(endpoints, bl);
- ::encode(master_zone, bl);
- ::encode(zones, bl);
- ::encode(placement_targets, bl);
- ::encode(default_placement, bl);
- ::encode(hostnames, bl);
- ::encode(hostnames_s3website, bl);
+ encode(name, bl);
+ encode(api_name, bl);
+ encode(is_master, bl);
+ encode(endpoints, bl);
+ encode(master_zone, bl);
+ encode(zones, bl);
+ encode(placement_targets, bl);
+ encode(default_placement, bl);
+ encode(hostnames, bl);
+ encode(hostnames_s3website, bl);
RGWSystemMetaObj::encode(bl);
- ::encode(realm_id, bl);
+ encode(realm_id, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) override {
DECODE_START(4, bl);
- ::decode(name, bl);
- ::decode(api_name, bl);
- ::decode(is_master, bl);
- ::decode(endpoints, bl);
- ::decode(master_zone, bl);
- ::decode(zones, bl);
- ::decode(placement_targets, bl);
- ::decode(default_placement, bl);
+ decode(name, bl);
+ decode(api_name, bl);
+ decode(is_master, bl);
+ decode(endpoints, bl);
+ decode(master_zone, bl);
+ decode(zones, bl);
+ decode(placement_targets, bl);
+ decode(default_placement, bl);
if (struct_v >= 2) {
- ::decode(hostnames, bl);
+ decode(hostnames, bl);
}
if (struct_v >= 3) {
- ::decode(hostnames_s3website, bl);
+ decode(hostnames_s3website, bl);
}
if (struct_v >= 4) {
RGWSystemMetaObj::decode(bl);
- ::decode(realm_id, bl);
+ decode(realm_id, bl);
} else {
id = name;
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(bucket_quota, bl);
- ::encode(user_quota, bl);
+ encode(bucket_quota, bl);
+ encode(user_quota, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(bucket_quota, bl);
- ::decode(user_quota, bl);
+ decode(bucket_quota, bl);
+ decode(user_quota, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
- ::encode(bucket_name, bl);
- ::encode(bucket_id, bl);
- ::encode(obj_key, bl);
- ::encode(exp_time, bl);
- ::encode(tenant, bl);
+ encode(bucket_name, bl);
+ encode(bucket_id, bl);
+ encode(obj_key, bl);
+ encode(exp_time, bl);
+ encode(tenant, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
// XXX Do we want DECODE_START_LEGACY_COMPAT_LEN(2, 1, 1, bl); ?
DECODE_START(2, bl);
- ::decode(bucket_name, bl);
- ::decode(bucket_id, bl);
- ::decode(obj_key, bl);
- ::decode(exp_time, bl);
+ decode(bucket_name, bl);
+ decode(bucket_id, bl);
+ decode(obj_key, bl);
+ decode(exp_time, bl);
if (struct_v >= 2) {
- ::decode(tenant, bl);
+ decode(tenant, bl);
} else {
tenant.clear();
}
void encode(bufferlist& bl) const override {
ENCODE_START(1, 1, bl);
RGWSystemMetaObj::encode(bl);
- ::encode(current_period, bl);
- ::encode(epoch, bl);
+ encode(current_period, bl);
+ encode(epoch, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) override {
DECODE_START(1, bl);
RGWSystemMetaObj::decode(bl);
- ::decode(current_period, bl);
- ::decode(epoch, bl);
+ decode(current_period, bl);
+ decode(epoch, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(epoch, bl);
+ encode(epoch, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(epoch, bl);
+ decode(epoch, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(id, bl);
- ::encode(epoch, bl);
- ::encode(realm_epoch, bl);
- ::encode(predecessor_uuid, bl);
- ::encode(sync_status, bl);
- ::encode(period_map, bl);
- ::encode(master_zone, bl);
- ::encode(master_zonegroup, bl);
- ::encode(period_config, bl);
- ::encode(realm_id, bl);
- ::encode(realm_name, bl);
+ encode(id, bl);
+ encode(epoch, bl);
+ encode(realm_epoch, bl);
+ encode(predecessor_uuid, bl);
+ encode(sync_status, bl);
+ encode(period_map, bl);
+ encode(master_zone, bl);
+ encode(master_zonegroup, bl);
+ encode(period_config, bl);
+ encode(realm_id, bl);
+ encode(realm_name, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(id, bl);
- ::decode(epoch, bl);
- ::decode(realm_epoch, bl);
- ::decode(predecessor_uuid, bl);
- ::decode(sync_status, bl);
- ::decode(period_map, bl);
- ::decode(master_zone, bl);
- ::decode(master_zonegroup, bl);
- ::decode(period_config, bl);
- ::decode(realm_id, bl);
- ::decode(realm_name, bl);
+ decode(id, bl);
+ decode(epoch, bl);
+ decode(realm_epoch, bl);
+ decode(predecessor_uuid, bl);
+ decode(sync_status, bl);
+ decode(period_map, bl);
+ decode(master_zone, bl);
+ decode(master_zonegroup, bl);
+ decode(period_config, bl);
+ decode(realm_id, bl);
+ decode(realm_name, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
projects / ceph-ci.git / commitdiff