1 files changed, 14 insertions, 66 deletions

diff --git a/cpp/src/qpid/Serializer.h b/cpp/src/qpid/Serializer.h
index a2fbf944ae..95cc2d5875 100644
--- a/cpp/src/qpid/Serializer.h
+++ b/cpp/src/qpid/Serializer.h
@@ -1,5 +1,5 @@
-#ifndef QPID_SERIALIZERBASE_H
-#define QPID_SERIALIZERBASE_H
+#ifndef QPID_SERIALIZER_H
+#define QPID_SERIALIZER_H
 
 /*
  *
@@ -22,88 +22,36 @@
  *
  */
 
-#include <boost/cast.hpp>
-#include <boost/array.hpp>
+#include <boost/type_traits/remove_const.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <algorithm>
 
 namespace qpid {
 
 /**
- * Base template for serializers, provides generic serialization for
- * conmpound types and common encode/decode/size functions.
- *
- * Derived template must provide
- * - Derived& op()(T) for primitive types.
- * - Derived& raw(void*, size_t) for raw binary data
- * - Derived& byte(char) for single bytes.
- * 
- * Derived templatse may override any of the functions provided by
- * this base class.
- *
- * This class provides templates to break down compound types 
- * into primitive types and delegate to the derived class.
- *
+ * Base class for serializers.
  */
 template <class Derived> class Serializer {
   public:
-
-    /** Call T::serialize() for classes that have their own serialize function */
-    template <class T>
-    typename boost::enable_if<boost::is_class<T>, Derived>::type
-    operator()(T& t) { t.serialize(self()); return self(); }
-
-    template <class T, size_t N>
-    Derived& operator()(boost::array<T,N>& a) {
-        std::for_each(a.begin(), a.end(), self());
-        return self();
-    }
-
-    Derived& operator()(char& x) { return self().byte((char&)x); }
-    Derived& operator()(int8_t& x) { return self().byte((char&)x); }
-    Derived& operator()(uint8_t& x) { return self().byte((char&)x); }
-
-  protected:
-    template <class T> Derived& raw(T& t) {
-        return self().raw(&t, sizeof(T));
-    }
-
-  private:
-    Derived& self() { return *static_cast<Derived*>(this); }
-};
-
-/** Like Serializer but does not modify the values passed to it. */
-template <class Derived> class ConstSerializer {
-  public:
     template <class T>
-    typename boost::enable_if<boost::is_class<T>, Derived>::type
-    operator()(const T& t) {
-        // Const cast so we don't have to write 2 serialize() functions
-        // for every class.
-        const_cast<T&>(t).serialize(self());
+    typename boost::enable_if<boost::is_class<T>, Derived&>::type
+    operator()(T& t) {
+        // const_cast so we don't need 2 serialize() members for every class.
+        const_cast<typename boost::remove_const<T>::type&>(t).serialize(self());
         return self();
     }
 
-    template <class T, size_t N>
-    Derived& operator()(const boost::array<T,N>& a) {
-        std::for_each(a.begin(), a.end(), self());
+    template <class Iter> Derived& iterate(Iter begin, Iter end) {
+        std::for_each(begin, end, self());
         return self();
     }
 
-    Derived& operator()(char x) { return self().byte(x); }
-    Derived& operator()(int8_t x) { return self().byte(x); }
-    Derived& operator()(uint8_t x) { return self().byte(x); }
-
-  protected:
-    template <class T> Derived& raw(const T& t) {
-        return self().raw(&t, sizeof(T));
-    }
-
   private:
     Derived& self() { return *static_cast<Derived*>(this); }
 };
 
-
 } // namespace qpid
 
-#endif  /*!QPID_SERIALIZERBASE_H*/
+#endif  /*!QPID_SERIALIZER_H*/