common: Use unqualified encoding in the rest of the files

And now we're done with this directory, for now.

Signed-off-by: Adam C. Emerson <aemerson@redhat.com>

diff --git a/src/common/DecayCounter.cc b/src/common/DecayCounter.cc
index 67a129ccd0965e470f9096772704122869dafb30..139332237f23d396757ef9600384372fa55b4919 100644 (file)
--- a/src/common/DecayCounter.cc
+++ b/src/common/DecayCounter.cc
@@ -18,9 +18,9 @@
 void DecayCounter::encode(bufferlist& bl) const
 {
   ENCODE_START(4, 4, bl);
-  ::encode(val, bl);
-  ::encode(delta, bl);
-  ::encode(vel, bl);
+  encode(val, bl);
+  encode(delta, bl);
+  encode(vel, bl);
   ENCODE_FINISH(bl);
 }
 
@@ -29,15 +29,15 @@ void DecayCounter::decode(const utime_t &t, bufferlist::iterator &p)
   DECODE_START_LEGACY_COMPAT_LEN(4, 4, 4, p);
   if (struct_v < 2) {
     double half_life;
-    ::decode(half_life, p);
+    decode(half_life, p);
   }
   if (struct_v < 3) {
     double k;
-    ::decode(k, p);
+    decode(k, p);
   }
-  ::decode(val, p);
-  ::decode(delta, p);
-  ::decode(vel, p);
+  decode(val, p);
+  decode(delta, p);
+  decode(vel, p);
   DECODE_FINISH(p);
 }
 

diff --git a/src/common/LogEntry.cc b/src/common/LogEntry.cc
index d9100fc46a25669ece7450f1c7460a94d19f5833..72ec66413ae2aab1c936c86ce6aa0f2eaca177b7 100644 (file)
--- a/src/common/LogEntry.cc
+++ b/src/common/LogEntry.cc
@@ -13,16 +13,18 @@
 
 void LogEntryKey::encode(bufferlist& bl, uint64_t features) const
 {
-  ::encode(who, bl, features);
-  ::encode(stamp, bl);
-  ::encode(seq, bl);
+  using ceph::encode;
+  encode(who, bl, features);
+  encode(stamp, bl);
+  encode(seq, bl);
 }
 
 void LogEntryKey::decode(bufferlist::iterator& bl)
 {
-  ::decode(who, bl);
-  ::decode(stamp, bl);
-  ::decode(seq, bl);
+  using ceph::decode;
+  decode(who, bl);
+  decode(stamp, bl);
+  decode(seq, bl);
   _calc_hash();
 }
 
@@ -208,13 +210,13 @@ void LogEntry::encode(bufferlist& bl, uint64_t features) const
 {
   ENCODE_START(4, 2, bl);
   __u16 t = prio;
-  ::encode(who, bl, features);
-  ::encode(stamp, bl);
-  ::encode(seq, bl);
-  ::encode(t, bl);
-  ::encode(msg, bl);
-  ::encode(channel, bl);
-  ::encode(name, bl);
+  encode(who, bl, features);
+  encode(stamp, bl);
+  encode(seq, bl);
+  encode(t, bl);
+  encode(msg, bl);
+  encode(channel, bl);
+  encode(name, bl);
   ENCODE_FINISH(bl);
 }
 
@@ -222,14 +224,14 @@ void LogEntry::decode(bufferlist::iterator& bl)
 {
   DECODE_START_LEGACY_COMPAT_LEN(4, 2, 2, bl);
   __u16 t;
-  ::decode(who, bl);
-  ::decode(stamp, bl);
-  ::decode(seq, bl);
-  ::decode(t, bl);
+  decode(who, bl);
+  decode(stamp, bl);
+  decode(seq, bl);
+  decode(t, bl);
   prio = (clog_type)t;
-  ::decode(msg, bl);
+  decode(msg, bl);
   if (struct_v >= 3) {
-    ::decode(channel, bl);
+    decode(channel, bl);
   } else {
     // prior to having logging channels we only had a cluster log.
     // Ensure we keep that appearance when the other party has no
@@ -237,7 +239,7 @@ void LogEntry::decode(bufferlist::iterator& bl)
     channel = CLOG_CHANNEL_CLUSTER;
   }
   if (struct_v >= 4) {
-    ::decode(name, bl);
+    decode(name, bl);
   }
   DECODE_FINISH(bl);
 }
@@ -264,16 +266,16 @@ void LogEntry::generate_test_instances(list<LogEntry*>& o)
 void LogSummary::encode(bufferlist& bl, uint64_t features) const
 {
   ENCODE_START(2, 2, bl);
-  ::encode(version, bl);
-  ::encode(tail, bl, features);
+  encode(version, bl);
+  encode(tail, bl, features);
   ENCODE_FINISH(bl);
 }
 
 void LogSummary::decode(bufferlist::iterator& bl)
 {
   DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
-  ::decode(version, bl);
-  ::decode(tail, bl);
+  decode(version, bl);
+  decode(tail, bl);
   DECODE_FINISH(bl);
   keys.clear();
   for (auto& p : tail) {

diff --git a/src/common/SloppyCRCMap.cc b/src/common/SloppyCRCMap.cc
index c637f7a257ac292d21a3cac97160963093118830..0868325bb4afc615979a37f332cf013cfc485a70 100644 (file)
--- a/src/common/SloppyCRCMap.cc
+++ b/src/common/SloppyCRCMap.cc
@@ -141,8 +141,8 @@ void SloppyCRCMap::clone_range(uint64_t offset, uint64_t len,
 void SloppyCRCMap::encode(bufferlist& bl) const
 {
   ENCODE_START(1, 1, bl);
-  ::encode(block_size, bl);
-  ::encode(crc_map, bl);
+  encode(block_size, bl);
+  encode(crc_map, bl);
   ENCODE_FINISH(bl);
 }
 
@@ -150,9 +150,9 @@ void SloppyCRCMap::decode(bufferlist::iterator& bl)
 {
   DECODE_START(1, bl);
   uint32_t bs;
-  ::decode(bs, bl);
+  decode(bs, bl);
   set_block_size(bs);
-  ::decode(crc_map, bl);
+  decode(crc_map, bl);
   DECODE_FINISH(bl);
 }
 

diff --git a/src/common/entity_name.h b/src/common/entity_name.h
index e30b75f701fb9f90447b80f6dc34d8cfe27c3839..44edebb04863efbed0401c0dae9caa2876c21e73 100644 (file)
--- a/src/common/entity_name.h
+++ b/src/common/entity_name.h
@@ -29,14 +29,16 @@ struct EntityName
   EntityName();
 
   void encode(bufferlist& bl) const {
-    ::encode(type, bl);
-    ::encode(id, bl);
+    using ceph::encode;
+    encode(type, bl);
+    encode(id, bl);
   }
   void decode(bufferlist::iterator& bl) {
+    using ceph::decode;
     uint32_t type_;
     std::string id_;
-    ::decode(type_, bl);
-    ::decode(id_, bl);
+    decode(type_, bl);
+    decode(id_, bl);
     set(type_, id_);
   }
 

diff --git a/src/common/fs_types.cc b/src/common/fs_types.cc
index 929f3f2880681f5342b2fc1e4b751ba31336b4fe..2a19ab85b1f9a69e63b5e2d93e0cbe0f01c1e556 100644 (file)
--- a/src/common/fs_types.cc
+++ b/src/common/fs_types.cc
@@ -70,37 +70,39 @@ void file_layout_t::to_legacy(ceph_file_layout *fl) const
 
 void file_layout_t::encode(bufferlist& bl, uint64_t features) const
 {
+  using ceph::encode;
   if ((features & CEPH_FEATURE_FS_FILE_LAYOUT_V2) == 0) {
     ceph_file_layout fl;
     assert((stripe_unit & 0xff) == 0);  // first byte must be 0
     to_legacy(&fl);
-    ::encode(fl, bl);
+    encode(fl, bl);
     return;
   }
 
   ENCODE_START(2, 2, bl);
-  ::encode(stripe_unit, bl);
-  ::encode(stripe_count, bl);
-  ::encode(object_size, bl);
-  ::encode(pool_id, bl);
-  ::encode(pool_ns, bl);
+  encode(stripe_unit, bl);
+  encode(stripe_count, bl);
+  encode(object_size, bl);
+  encode(pool_id, bl);
+  encode(pool_ns, bl);
   ENCODE_FINISH(bl);
 }
 
 void file_layout_t::decode(bufferlist::iterator& p)
 {
+  using ceph::decode;
   if (*p == 0) {
     ceph_file_layout fl;
-    ::decode(fl, p);
+    decode(fl, p);
     from_legacy(fl);
     return;
   }
   DECODE_START(2, p);
-  ::decode(stripe_unit, p);
-  ::decode(stripe_count, p);
-  ::decode(object_size, p);
-  ::decode(pool_id, p);
-  ::decode(pool_ns, p);
+  decode(stripe_unit, p);
+  decode(stripe_count, p);
+  decode(object_size, p);
+  decode(pool_id, p);
+  decode(pool_ns, p);
   DECODE_FINISH(p);
 }
 

diff --git a/src/common/histogram.cc b/src/common/histogram.cc
index e1422923956ea13243cc568baaa62b356c1c3fbd..4959c4d58154d260e7990a8670bffb2a9c6fef83 100644 (file)
--- a/src/common/histogram.cc
+++ b/src/common/histogram.cc
@@ -28,14 +28,14 @@ void pow2_hist_t::dump(Formatter *f) const
 void pow2_hist_t::encode(bufferlist& bl) const
 {
   ENCODE_START(1, 1, bl);
-  ::encode(h, bl);
+  encode(h, bl);
   ENCODE_FINISH(bl);
 }
 
 void pow2_hist_t::decode(bufferlist::iterator& p)
 {
   DECODE_START(1, p);
-  ::decode(h, p);
+  decode(h, p);
   DECODE_FINISH(p);
 }
 

diff --git a/src/common/hobject.cc b/src/common/hobject.cc
index d3f554f7a5790d7e69969a6cb9575f56433134d0..99b8b944097b3312aae5450d1867249feb060274 100644 (file)
--- a/src/common/hobject.cc
+++ b/src/common/hobject.cc
@@ -104,13 +104,13 @@ string hobject_t::to_str() const
 void hobject_t::encode(bufferlist& bl) const
 {
   ENCODE_START(4, 3, bl);
-  ::encode(key, bl);
-  ::encode(oid, bl);
-  ::encode(snap, bl);
-  ::encode(hash, bl);
-  ::encode(max, bl);
-  ::encode(nspace, bl);
-  ::encode(pool, bl);
+  encode(key, bl);
+  encode(oid, bl);
+  encode(snap, bl);
+  encode(hash, bl);
+  encode(max, bl);
+  encode(nspace, bl);
+  encode(pool, bl);
   assert(!max || (*this == hobject_t(hobject_t::get_max())));
   ENCODE_FINISH(bl);
 }
@@ -119,17 +119,17 @@ void hobject_t::decode(bufferlist::iterator& bl)
 {
   DECODE_START_LEGACY_COMPAT_LEN(4, 3, 3, bl);
   if (struct_v >= 1)
-    ::decode(key, bl);
-  ::decode(oid, bl);
-  ::decode(snap, bl);
-  ::decode(hash, bl);
+    decode(key, bl);
+  decode(oid, bl);
+  decode(snap, bl);
+  decode(hash, bl);
   if (struct_v >= 2)
-    ::decode(max, bl);
+    decode(max, bl);
   else
     max = false;
   if (struct_v >= 4) {
-    ::decode(nspace, bl);
-    ::decode(pool, bl);
+    decode(nspace, bl);
+    decode(pool, bl);
     // for compat with hammer, which did not handle the transition
     // from pool -1 -> pool INT64_MIN for MIN properly.  this object
     // name looks a bit like a pgmeta object for the meta collection,
@@ -359,16 +359,16 @@ void ghobject_t::encode(bufferlist& bl) const
 {
   // when changing this, remember to update encoded_size() too.
   ENCODE_START(6, 3, bl);
-  ::encode(hobj.key, bl);
-  ::encode(hobj.oid, bl);
-  ::encode(hobj.snap, bl);
-  ::encode(hobj.hash, bl);
-  ::encode(hobj.max, bl);
-  ::encode(hobj.nspace, bl);
-  ::encode(hobj.pool, bl);
-  ::encode(generation, bl);
-  ::encode(shard_id, bl);
-  ::encode(max, bl);
+  encode(hobj.key, bl);
+  encode(hobj.oid, bl);
+  encode(hobj.snap, bl);
+  encode(hobj.hash, bl);
+  encode(hobj.max, bl);
+  encode(hobj.nspace, bl);
+  encode(hobj.pool, bl);
+  encode(generation, bl);
+  encode(shard_id, bl);
+  encode(max, bl);
   ENCODE_FINISH(bl);
 }
 
@@ -417,17 +417,17 @@ void ghobject_t::decode(bufferlist::iterator& bl)
 {
   DECODE_START_LEGACY_COMPAT_LEN(6, 3, 3, bl);
   if (struct_v >= 1)
-    ::decode(hobj.key, bl);
-  ::decode(hobj.oid, bl);
-  ::decode(hobj.snap, bl);
-  ::decode(hobj.hash, bl);
+    decode(hobj.key, bl);
+  decode(hobj.oid, bl);
+  decode(hobj.snap, bl);
+  decode(hobj.hash, bl);
   if (struct_v >= 2)
-    ::decode(hobj.max, bl);
+    decode(hobj.max, bl);
   else
     hobj.max = false;
   if (struct_v >= 4) {
-    ::decode(hobj.nspace, bl);
-    ::decode(hobj.pool, bl);
+    decode(hobj.nspace, bl);
+    decode(hobj.pool, bl);
     // for compat with hammer, which did not handle the transition from
     // pool -1 -> pool INT64_MIN for MIN properly (see hobject_t::decode()).
     if (hobj.pool == -1 &&
@@ -440,14 +440,14 @@ void ghobject_t::decode(bufferlist::iterator& bl)
     }
   }
   if (struct_v >= 5) {
-    ::decode(generation, bl);
-    ::decode(shard_id, bl);
+    decode(generation, bl);
+    decode(shard_id, bl);
   } else {
     generation = ghobject_t::NO_GEN;
     shard_id = shard_id_t::NO_SHARD;
   }
   if (struct_v >= 6) {
-    ::decode(max, bl);
+    decode(max, bl);
   } else {
     max = false;
   }

diff --git a/src/common/mClockCommon.h b/src/common/mClockCommon.h
index f8bf4b3724365f9bff091b7e4c3bf47aff0b3f3a..c7f64da7ec1201c372cbe4c6c607e43c46e68f32 100644 (file)
--- a/src/common/mClockCommon.h
+++ b/src/common/mClockCommon.h
@@ -30,12 +30,12 @@ WRITE_RAW_ENCODER(dmc::ReqParams)
 inline void encode(const dmc::PhaseType &phase, bufferlist& bl,
                    uint64_t features=0)
 {
-  ::encode(static_cast<uint8_t>(phase), bl);
+  encode(static_cast<uint8_t>(phase), bl);
 }
 
 inline void decode(dmc::PhaseType &phase, bufferlist::iterator& p)
 {
   uint8_t int_phase;
-  ::decode((uint8_t&)int_phase, p);
+  decode((uint8_t&)int_phase, p);
   phase = static_cast<dmc::PhaseType>(int_phase);
 }

diff --git a/src/common/obj_bencher.cc b/src/common/obj_bencher.cc
index 97cf7bf8ad3593358971dc3e10711d72e8958120..9a7547b01be802d1a8c49ebfc4f158a10754b1e9 100644 (file)
--- a/src/common/obj_bencher.cc
+++ b/src/common/obj_bencher.cc
@@ -367,11 +367,11 @@ int ObjBencher::fetch_bench_metadata(const std::string& metadata_file,
     return r;
   }
   bufferlist::iterator p = object_data.begin();
-  ::decode(*object_size, p);
-  ::decode(*num_objects, p);
-  ::decode(*prevPid, p);
+  decode(*object_size, p);
+  decode(*num_objects, p);
+  decode(*prevPid, p);
   if (!p.end()) {
-    ::decode(*op_size, p);
+    decode(*op_size, p);
   } else {
     *op_size = *object_size;
   }
@@ -607,11 +607,11 @@ int ObjBencher::write_bench(int secondsToRun,
     formatter->dump_format("min_latency", "%f", data.min_latency);
   }
   //write object size/number data for read benchmarks
-  ::encode(data.object_size, b_write);
+  encode(data.object_size, b_write);
   num_objects = (data.finished + writes_per_object - 1) / writes_per_object;
-  ::encode(num_objects, b_write);
-  ::encode(getpid(), b_write);
-  ::encode(data.op_size, b_write);
+  encode(num_objects, b_write);
+  encode(getpid(), b_write);
+  encode(data.op_size, b_write);
 
   // persist meta-data for further cleanup or read
   sync_write(run_name_meta, b_write, sizeof(int)*3);

diff --git a/src/common/scrub_types.cc b/src/common/scrub_types.cc
index abc575d7a0db5fa3d4e1850d69e4a9365c299f5e..fc59c38b8ce78242928083f765b99de7dda59b0f 100644 (file)
--- a/src/common/scrub_types.cc
+++ b/src/common/scrub_types.cc
@@ -5,49 +5,50 @@ using namespace librados;
 void object_id_wrapper::encode(bufferlist& bl) const
 {
   ENCODE_START(1, 1, bl);
-  ::encode(name, bl);
-  ::encode(nspace, bl);
-  ::encode(locator, bl);
-  ::encode(snap, bl);
+  encode(name, bl);
+  encode(nspace, bl);
+  encode(locator, bl);
+  encode(snap, bl);
   ENCODE_FINISH(bl);
 }
 
 void object_id_wrapper::decode(bufferlist::iterator& bp)
 {
   DECODE_START(1, bp);
-  ::decode(name, bp);
-  ::decode(nspace, bp);
-  ::decode(locator, bp);
-  ::decode(snap, bp);
+  decode(name, bp);
+  decode(nspace, bp);
+  decode(locator, bp);
+  decode(snap, bp);
   DECODE_FINISH(bp);
 }
 
+namespace librados {
 static void encode(const object_id_t& obj, bufferlist& bl)
 {
   reinterpret_cast<const object_id_wrapper&>(obj).encode(bl);
 }
+}
 
 void osd_shard_wrapper::encode(bufferlist& bl) const
 {
   ENCODE_START(1, 1, bl);
-  ::encode(osd, bl);
-  ::encode(shard, bl);
+  encode(osd, bl);
+  encode(shard, bl);
   ENCODE_FINISH(bl);
 }
 
 void osd_shard_wrapper::decode(bufferlist::iterator& bp)
 {
   DECODE_START(1, bp);
-  ::decode(osd, bp);
-  ::decode(shard, bp);
+  decode(osd, bp);
+  decode(shard, bp);
   DECODE_FINISH(bp);
 }
 
 namespace librados {
-  static void encode(const osd_shard_t& shard, bufferlist& bl)
-  {
-    reinterpret_cast<const osd_shard_wrapper&>(shard).encode(bl);
-  }
+static void encode(const osd_shard_t& shard, bufferlist& bl) {
+  reinterpret_cast<const osd_shard_wrapper&>(shard).encode(bl);
+}
 }
 
 void shard_info_wrapper::set_object(const ScrubMap::object& object)
@@ -71,36 +72,36 @@ void shard_info_wrapper::set_object(const ScrubMap::object& object)
 void shard_info_wrapper::encode(bufferlist& bl) const
 {
   ENCODE_START(3, 3, bl);
-  ::encode(errors, bl);
-  ::encode(primary, bl);
+  encode(errors, bl);
+  encode(primary, bl);
   if (has_shard_missing()) {
     return;
   }
-  ::encode(attrs, bl);
-  ::encode(size, bl);
-  ::encode(omap_digest_present, bl);
-  ::encode(omap_digest, bl);
-  ::encode(data_digest_present, bl);
-  ::encode(data_digest, bl);
-  ::encode(selected_oi, bl);
+  encode(attrs, bl);
+  encode(size, bl);
+  encode(omap_digest_present, bl);
+  encode(omap_digest, bl);
+  encode(data_digest_present, bl);
+  encode(data_digest, bl);
+  encode(selected_oi, bl);
   ENCODE_FINISH(bl);
 }
 
 void shard_info_wrapper::decode(bufferlist::iterator& bp)
 {
   DECODE_START(3, bp);
-  ::decode(errors, bp);
-  ::decode(primary, bp);
+  decode(errors, bp);
+  decode(primary, bp);
   if (has_shard_missing()) {
     return;
   }
-  ::decode(attrs, bp);
-  ::decode(size, bp);
-  ::decode(omap_digest_present, bp);
-  ::decode(omap_digest, bp);
-  ::decode(data_digest_present, bp);
-  ::decode(data_digest, bp);
-  ::decode(selected_oi, bp);
+  decode(attrs, bp);
+  decode(size, bp);
+  decode(omap_digest_present, bp);
+  decode(omap_digest, bp);
+  decode(data_digest_present, bp);
+  decode(data_digest, bp);
+  decode(selected_oi, bp);
   DECODE_FINISH(bp);
 }
 
@@ -150,11 +151,11 @@ namespace librados {
 void inconsistent_obj_wrapper::encode(bufferlist& bl) const
 {
   ENCODE_START(2, 2, bl);
-  ::encode(errors, bl);
-  ::encode(object, bl);
-  ::encode(version, bl);
-  ::encode(shards, bl);
-  ::encode(union_shards.errors, bl);
+  encode(errors, bl);
+  encode(object, bl);
+  encode(version, bl);
+  encode(shards, bl);
+  encode(union_shards.errors, bl);
   ENCODE_FINISH(bl);
 }
 
@@ -162,11 +163,11 @@ void inconsistent_obj_wrapper::decode(bufferlist::iterator& bp)
 {
   DECODE_START(2, bp);
   DECODE_OLDEST(2);
-  ::decode(errors, bp);
-  ::decode(object, bp);
-  ::decode(version, bp);
-  ::decode(shards, bp);
-  ::decode(union_shards.errors, bp);
+  decode(errors, bp);
+  decode(object, bp);
+  decode(version, bp);
+  decode(shards, bp);
+  decode(union_shards.errors, bp);
   DECODE_FINISH(bp);
 }
 
@@ -234,59 +235,59 @@ void inconsistent_snapset_wrapper::set_size_mismatch()
 void inconsistent_snapset_wrapper::encode(bufferlist& bl) const
 {
   ENCODE_START(1, 1, bl);
-  ::encode(errors, bl);
-  ::encode(object, bl);
-  ::encode(clones, bl);
-  ::encode(missing, bl);
+  encode(errors, bl);
+  encode(object, bl);
+  encode(clones, bl);
+  encode(missing, bl);
   ENCODE_FINISH(bl);
 }
 
 void inconsistent_snapset_wrapper::decode(bufferlist::iterator& bp)
 {
   DECODE_START(1, bp);
-  ::decode(errors, bp);
-  ::decode(object, bp);
-  ::decode(clones, bp);
-  ::decode(missing, bp);
+  decode(errors, bp);
+  decode(object, bp);
+  decode(clones, bp);
+  decode(missing, bp);
   DECODE_FINISH(bp);
 }
 
 void scrub_ls_arg_t::encode(bufferlist& bl) const
 {
   ENCODE_START(1, 1, bl);
-  ::encode(interval, bl);
-  ::encode(get_snapsets, bl);
-  ::encode(start_after.name, bl);
-  ::encode(start_after.nspace, bl);
-  ::encode(start_after.snap, bl);
-  ::encode(max_return, bl);
+  encode(interval, bl);
+  encode(get_snapsets, bl);
+  encode(start_after.name, bl);
+  encode(start_after.nspace, bl);
+  encode(start_after.snap, bl);
+  encode(max_return, bl);
   ENCODE_FINISH(bl);
 }
 
 void scrub_ls_arg_t::decode(bufferlist::iterator& bp)
 {
   DECODE_START(1, bp);
-  ::decode(interval, bp);
-  ::decode(get_snapsets, bp);
-  ::decode(start_after.name, bp);
-  ::decode(start_after.nspace, bp);
-  ::decode(start_after.snap, bp);
-  ::decode(max_return, bp);
+  decode(interval, bp);
+  decode(get_snapsets, bp);
+  decode(start_after.name, bp);
+  decode(start_after.nspace, bp);
+  decode(start_after.snap, bp);
+  decode(max_return, bp);
   DECODE_FINISH(bp);
 }
 
 void scrub_ls_result_t::encode(bufferlist& bl) const
 {
   ENCODE_START(1, 1, bl);
-  ::encode(interval, bl);
-  ::encode(vals, bl);
+  encode(interval, bl);
+  encode(vals, bl);
   ENCODE_FINISH(bl);
 }
 
 void scrub_ls_result_t::decode(bufferlist::iterator& bp)
 {
   DECODE_START(1, bp);
-  ::decode(interval, bp);
-  ::decode(vals, bp);
+  decode(interval, bp);
+  decode(vals, bp);
   DECODE_FINISH(bp);
 }

diff --git a/src/common/scrub_types.h b/src/common/scrub_types.h
index 9e30fbd9aa222ea0870239cea92242610d2fca07..1f4b9fb84f3625895f236c19a4d7958d4e357a5e 100644 (file)
--- a/src/common/scrub_types.h
+++ b/src/common/scrub_types.h
@@ -18,9 +18,11 @@ struct object_id_wrapper : public librados::object_id_t {
 
 WRITE_CLASS_ENCODER(object_id_wrapper)
 
-inline void decode(librados::object_id_t& obj, bufferlist::iterator& bp) {
+namespace librados {
+inline void decode(object_id_t& obj, bufferlist::iterator& bp) {
   reinterpret_cast<object_id_wrapper&>(obj).decode(bp);
 }
+}
 
 struct osd_shard_wrapper : public librados::osd_shard_t {
   void encode(bufferlist& bl) const;

diff --git a/src/common/snap_types.cc b/src/common/snap_types.cc
index 6b65d7cbea243042519e2c89ec207516d0b8a7eb..2393763396167833c5986276c9c6b4b6623c02c0 100644 (file)
--- a/src/common/snap_types.cc
+++ b/src/common/snap_types.cc
@@ -6,16 +6,18 @@ void SnapRealmInfo::encode(bufferlist& bl) const
 {
   h.num_snaps = my_snaps.size();
   h.num_prior_parent_snaps = prior_parent_snaps.size();
-  ::encode(h, bl);
-  ::encode_nohead(my_snaps, bl);
-  ::encode_nohead(prior_parent_snaps, bl);
+  using ceph::encode;
+  encode(h, bl);
+  encode_nohead(my_snaps, bl);
+  encode_nohead(prior_parent_snaps, bl);
 }
 
 void SnapRealmInfo::decode(bufferlist::iterator& bl)
 {
-  ::decode(h, bl);
-  ::decode_nohead(h.num_snaps, my_snaps, bl);
-  ::decode_nohead(h.num_prior_parent_snaps, prior_parent_snaps, bl);
+  using ceph::decode;
+  decode(h, bl);
+  decode_nohead(h.num_snaps, my_snaps, bl);
+  decode_nohead(h.num_prior_parent_snaps, prior_parent_snaps, bl);
 }
 
 void SnapRealmInfo::dump(Formatter *f) const

diff --git a/src/common/snap_types.h b/src/common/snap_types.h
index af0d02527612e32600fe5a55fcf34aa39b05c899..1bbb023103ea7ac503f899892d3658b5935ae154 100644 (file)
--- a/src/common/snap_types.h
+++ b/src/common/snap_types.h
@@ -54,12 +54,14 @@ struct SnapContext {
   bool empty() { return seq == 0; }
 
   void encode(bufferlist& bl) const {
-    ::encode(seq, bl);
-    ::encode(snaps, bl);
+    using ceph::encode;
+    encode(seq, bl);
+    encode(snaps, bl);
   }
   void decode(bufferlist::iterator& bl) {
-    ::decode(seq, bl);
-    ::decode(snaps, bl);
+    using ceph::decode;
+    decode(seq, bl);
+    decode(snaps, bl);
   }
   void dump(Formatter *f) const;
   static void generate_test_instances(list<SnapContext*>& o);

diff --git a/src/common/zipkin_trace.h b/src/common/zipkin_trace.h
index 86624715c29b3a2a35ddbc88d504a3146e7ae746..4ec615c2bf3a96f0e7328dbabed0701c137c2ce4 100644 (file)
--- a/src/common/zipkin_trace.h
+++ b/src/common/zipkin_trace.h
@@ -74,16 +74,16 @@ class Trace {
 
 static inline void encode(const blkin_trace_info& b, bufferlist& bl)
 {
-  ::encode(b.trace_id, bl);
-  ::encode(b.span_id, bl);
-  ::encode(b.parent_span_id, bl);
+  encode(b.trace_id, bl);
+  encode(b.span_id, bl);
+  encode(b.parent_span_id, bl);
 }
 
 static inline void decode(blkin_trace_info& b, bufferlist::iterator& p)
 {
-  ::decode(b.trace_id, p);
-  ::decode(b.span_id, p);
-  ::decode(b.parent_span_id, p);
+  decode(b.trace_id, p);
+  decode(b.span_id, p);
+  decode(b.parent_span_id, p);
 }