zorba-coders team mailing list archive

[Markos Zaharioudakis <markos_za@xxxxxxxxx>]

Markos Zaharioudakis has proposed merging lp:~zorba-coders/zorba/no-expr-serialization into lp:zorba.

Requested reviews:
  Markos Zaharioudakis (markos-za)
Related bugs:
  Bug #1014975 in Zorba: "Reworked Plan serializer"
  https://bugs.launchpad.net/zorba/+bug/1014975

For more details, see:
https://code.launchpad.net/~zorba-coders/zorba/no-expr-serialization/+merge/112428

A better fix for compilation problems involving integer types.
-- 
https://code.launchpad.net/~zorba-coders/zorba/no-expr-serialization/+merge/112428
Your team Zorba Coders is subscribed to branch lp:zorba.

=== modified file 'src/compiler/expression/var_expr.cpp'
--- src/compiler/expression/var_expr.cpp	2012-06-18 10:06:47 +0000
+++ src/compiler/expression/var_expr.cpp	2012-06-27 20:44:23 +0000
@@ -142,7 +142,7 @@
 
   SERIALIZE_ENUM(var_kind, theVarKind);
 
-  serialize_ulong(ar, theUniqueId);
+  ar & theUniqueId;
 
   ar & theName;
   ar & theDeclaredType;

=== modified file 'src/compiler/expression/var_expr.h'
--- src/compiler/expression/var_expr.h	2012-06-18 10:06:47 +0000
+++ src/compiler/expression/var_expr.h	2012-06-27 20:44:23 +0000
@@ -152,7 +152,7 @@
   };
 
 protected:
-  unsigned long         theUniqueId;
+  ulong                 theUniqueId;
 
   var_kind              theVarKind;
 

=== modified file 'src/compiler/xqddf/value_index.cpp'
--- src/compiler/xqddf/value_index.cpp	2012-06-25 09:22:44 +0000
+++ src/compiler/xqddf/value_index.cpp	2012-06-27 20:44:23 +0000
@@ -91,7 +91,7 @@
   SERIALIZE_ENUM(ContainerKind, theContainerKind);
   //ar & theDomainClause;
   //ar & theKeyExprs;
-  serialize_csize(ar, theNumKeyExprs);
+  ar & theNumKeyExprs;
   ar & theKeyTypes;
   ar & theOrderModifiers;
 

=== modified file 'src/context/static_context.cpp'
--- src/context/static_context.cpp	2012-06-25 09:22:44 +0000
+++ src/context/static_context.cpp	2012-06-27 20:44:23 +0000
@@ -820,8 +820,8 @@
     lNumURLResolvers = theURLResolvers.size();
 
     ar.set_is_temp_field(true);
-    serialize_csize(ar, lNumURIMappers);
-    serialize_csize(ar, lNumURLResolvers);
+    ar & lNumURIMappers;
+    ar & lNumURLResolvers;
     ar.set_is_temp_field(false);
   }
   else
@@ -833,9 +833,9 @@
 
     ar.set_is_temp_field(true);
     // number of URIMappers passed by the user
-    serialize_csize(ar, lNumURIMappers);
+    ar & lNumURIMappers;
     // number of URLResolvers passed by the user
-    serialize_csize(ar, lNumURLResolvers);
+    ar & lNumURLResolvers;
     ar.set_is_temp_field(false);
 
     // callback required but not available

=== modified file 'src/debugger/debugger_commons.cpp'
--- src/debugger/debugger_commons.cpp	2012-06-25 09:30:47 +0000
+++ src/debugger/debugger_commons.cpp	2012-06-27 20:44:23 +0000
@@ -167,7 +167,7 @@
   {
     ar.set_is_temp_field(true);
     csize s = theBreakableIDs.size();
-    serialize_csize(ar, s);
+    ar & s;
     ar.set_is_temp_field(false);
 
     BreakableIdMap::iterator it = theBreakableIDs.begin();
@@ -184,7 +184,7 @@
   {
     ar.set_is_temp_field(true);
     csize s;
-    serialize_csize(ar, s);
+    ar & s;
     ar.set_is_temp_field(false);
 
     std::pair<QueryLoc, unsigned int> p;
@@ -212,7 +212,7 @@
   ar & theBreak;
   ar & theCause;
   ar & theIteratorStack;
-  serialize_csize(ar, theBreakCondition);
+  ar & theBreakCondition;
 
   if (ar.is_serializing_out())
     thePlanState = NULL;

=== modified file 'src/runtime/booleans/BooleanImpl.cpp'
--- src/runtime/booleans/BooleanImpl.cpp	2012-06-21 09:10:57 +0000
+++ src/runtime/booleans/BooleanImpl.cpp	2012-06-27 20:44:23 +0000
@@ -350,7 +350,7 @@
   SERIALIZE_ENUM(CompareConsts::CompareType, theCompType)
   ar & theIsGeneralComparison;
   SERIALIZE_TYPEMANAGER(TypeManager, theTypeManager);
-  serialize_long(ar, theTimezone);
+  ar & theTimezone;
   ar & theCollation;
 }
 
@@ -1027,7 +1027,7 @@
   (NaryBaseIterator<TypedValueCompareIterator<ATC>, PlanIteratorState>*)this);
 
   SERIALIZE_ENUM(CompareConsts::CompareType, theCompType);
-  serialize_long(ar, theTimezone);
+  ar & theTimezone;
   ar & theCollation;
 }
 
@@ -1178,7 +1178,7 @@
   (BinaryBaseIterator<AtomicValuesEquivalenceIterator, PlanIteratorState>*)this);
 
   SERIALIZE_TYPEMANAGER(TypeManager, theTypeManager);
-  serialize_long(ar, theTimezone);
+  ar & theTimezone;
   ar & theCollation;
 }
 

=== modified file 'src/runtime/core/gflwor/window_iterator.cpp'
--- src/runtime/core/gflwor/window_iterator.cpp	2012-06-18 10:06:47 +0000
+++ src/runtime/core/gflwor/window_iterator.cpp	2012-06-27 20:44:23 +0000
@@ -614,7 +614,7 @@
   ar & theEndClause;
   ar & theLazyEval;
 
-  serialize_ulong(ar, theMaxNeededHistory);
+  ar & theMaxNeededHistory;
 }
 
 

=== modified file 'src/runtime/core/trycatch.h'
--- src/runtime/core/trycatch.h	2012-06-18 10:06:47 +0000
+++ src/runtime/core/trycatch.h	2012-06-27 20:44:23 +0000
@@ -63,7 +63,7 @@
     };
 
   public:
-    typedef std::map<uint32_t, std::vector<LetVarIter_t> > VarMap_t;
+    typedef std::map<ulong, std::vector<LetVarIter_t> > VarMap_t;
 
   public:
     std::vector<NodeNameTest_t> node_names;

=== modified file 'src/runtime/core/var_iterators.cpp'
--- src/runtime/core/var_iterators.cpp	2012-06-18 10:06:47 +0000
+++ src/runtime/core/var_iterators.cpp	2012-06-27 20:44:23 +0000
@@ -82,7 +82,7 @@
   serialize_baseclass(ar,
   (NaryBaseIterator<CtxVarDeclareIterator, PlanIteratorState>*)this);
 
-  serialize_ulong(ar, theVarId);
+  ar & theVarId;
   ar & theVarName;
   ar & theIsExternal;
   ar & theSingleItem;
@@ -148,7 +148,7 @@
   serialize_baseclass(ar,
   (UnaryBaseIterator<CtxVarAssignIterator, PlanIteratorState>*)this);
 
-  serialize_ulong(ar, theVarId);
+  ar & theVarId;
 
   ar & theVarName;
   ar & theIsLocal;
@@ -211,7 +211,7 @@
   serialize_baseclass(ar,
   (NoaryBaseIterator<CtxVarIsSetIterator, PlanIteratorState>*)this);
 
-  serialize_ulong(ar, theVarId);
+  ar & theVarId;
 
   ar & theVarName;
 }
@@ -286,7 +286,7 @@
   serialize_baseclass(ar,
   (NoaryBaseIterator<CtxVarIterator, CtxVarState>*)this);
 
-  serialize_ulong(ar, theVarId);
+  ar & theVarId;
 
   ar & theVarName;
   ar & theIsLocal;

=== modified file 'src/types/schema/schema.cpp'
--- src/types/schema/schema.cpp	2012-06-25 09:30:47 +0000
+++ src/types/schema/schema.cpp	2012-06-27 20:44:23 +0000
@@ -2061,7 +2061,7 @@
 
    if (ar.is_serializing_out())
    {
-     serialize_csize(ar, size_of_size_t);
+     ar & size_of_size_t;
      ar & le_be_value.cvalue[0];
 
      if (!is_grammar_NULL)
@@ -2087,7 +2087,7 @@
      csize size_of_size_t2;
      unsigned char le_be_value_first_char;
 
-     serialize_csize(ar, size_of_size_t2);
+     ar & size_of_size_t2;
      ar & le_be_value_first_char;
 
      if (size_of_size_t2 != size_of_size_t ||

=== modified file 'src/zorbaserialization/serialize_basic_types.cpp'
--- src/zorbaserialization/serialize_basic_types.cpp	2012-06-22 15:19:14 +0000
+++ src/zorbaserialization/serialize_basic_types.cpp	2012-06-27 20:44:23 +0000
@@ -33,51 +33,7 @@
 namespace serialization
 {
 
-
-/*******************************************************************************
-
-********************************************************************************/
-void serialize_long_long(Archiver& ar, long long& obj)
-{
-  assert(sizeof(long long) == 8);
-
-  if (ar.is_serializing_out())
-  {
-    int64_t int64v = obj;
-    ar.add_simple_temp_field(TYPE_INT64, &int64v);
-  }
-  else
-  {
-    int64_t int64v;
-    ar.read_next_simple_temp_field(TYPE_INT64, &int64v);
-
-    obj = static_cast<long long>(int64v);
-  }
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-void serialize_ulong_long(Archiver& ar, unsigned long long& obj)
-{
-  assert(sizeof(unsigned long long) == 8);
-
-  if (ar.is_serializing_out())
-  {
-    uint64_t uint64v = obj;
-    ar.add_simple_temp_field(TYPE_UINT64, &uint64v);
-  }
-  else
-  {
-    uint64_t uint64v;
-    ar.read_next_simple_temp_field(TYPE_UINT64, &uint64v);
-
-    obj = static_cast<unsigned long long>(uint64v);
-  }
-}
-
-
+#if 0
 /*******************************************************************************
 
 ********************************************************************************/
@@ -113,68 +69,6 @@
 /*******************************************************************************
 
 ********************************************************************************/
-void serialize_long(Archiver& ar, long& obj)
-{
-  if (ar.is_serializing_out())
-  {
-    int64_t int64v = obj;
-    ar.add_simple_temp_field(TYPE_INT64, &int64v);
-  }
-  else
-  {
-    int64_t int64v;
-    ar.read_next_simple_temp_field(TYPE_INT64, &int64v);
-
-    obj = static_cast<long>(int64v);
-  }
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-void serialize_ulong(Archiver& ar, ulong& obj)
-{
-  if (ar.is_serializing_out())
-  {
-    uint64_t uint64v = obj;
-    ar.add_simple_temp_field(TYPE_UINT64, &uint64v);
-  }
-  else
-  {
-    uint64_t uint64v;
-    ar.read_next_simple_temp_field(TYPE_UINT64, &uint64v);
-
-    obj = static_cast<ulong>(uint64v);
-  }
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-void serialize_csize(Archiver& ar, csize& obj)
-{
-  assert(sizeof(csize) <= 8);
-
-  if (ar.is_serializing_out())
-  {
-    uint64_t uint64v = obj;
-    ar.add_simple_temp_field(TYPE_UINT64, &uint64v);
-  }
-  else
-  {
-    uint64_t uint64v;
-    ar.read_next_simple_temp_field(TYPE_UINT64, &uint64v);
-
-    obj = static_cast<csize>(uint64v);
-  }
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
 void operator&(Archiver& ar, int32_t& obj)
 {
   if (ar.is_serializing_out())
@@ -207,22 +101,6 @@
 /*******************************************************************************
 
 ********************************************************************************/
-void serialize_enum(Archiver& ar, uint32_t& obj)
-{
-  if (ar.is_serializing_out())
-  {
-    ar.add_simple_temp_field(TYPE_ENUM, &obj);
-  }
-  else
-  {
-    ar.read_next_simple_temp_field(TYPE_ENUM, &obj);
-  }
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
 void operator&(Archiver& ar, int16_t& obj)
 {
   if (ar.is_serializing_out())
@@ -250,6 +128,213 @@
     ar.read_next_simple_temp_field(TYPE_UINT16, &obj);
   }
 }
+#endif
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void operator&(Archiver& ar, short& obj)
+{
+  assert(sizeof(short) == 2);
+
+  if (ar.is_serializing_out())
+  {
+    int16_t int16v = obj;
+    ar.add_simple_temp_field(TYPE_INT16, &int16v);
+  }
+  else
+  {
+    int16_t int16v;
+    ar.read_next_simple_temp_field(TYPE_INT16, &int16v);
+
+    obj = static_cast<short>(int16v);
+  }
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void operator&(Archiver& ar, unsigned short& obj)
+{
+  assert(sizeof(unsigned short) == 2);
+
+  if (ar.is_serializing_out())
+  {
+    uint16_t uint16v = obj;
+    ar.add_simple_temp_field(TYPE_UINT16, &uint16v);
+  }
+  else
+  {
+    uint16_t uint16v;
+    ar.read_next_simple_temp_field(TYPE_UINT16, &uint16v);
+
+    obj = static_cast<unsigned short>(uint16v);
+  }
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void operator&(Archiver& ar, int& obj)
+{
+  if (ar.is_serializing_out())
+  {
+    int64_t int64v = obj;
+    ar.add_simple_temp_field(TYPE_INT64, &int64v);
+  }
+  else
+  {
+    int64_t int64v;
+    ar.read_next_simple_temp_field(TYPE_INT64, &int64v);
+
+    obj = static_cast<int>(int64v);
+  }
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void operator&(Archiver& ar, unsigned int& obj)
+{
+  if (ar.is_serializing_out())
+  {
+    uint64_t uint64v = obj;
+    ar.add_simple_temp_field(TYPE_UINT64, &uint64v);
+  }
+  else
+  {
+    uint64_t uint64v;
+    ar.read_next_simple_temp_field(TYPE_UINT64, &uint64v);
+
+    obj = static_cast<unsigned int>(uint64v);
+  }
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void operator&(Archiver& ar, long& obj)
+{
+  if (ar.is_serializing_out())
+  {
+    int64_t int64v = obj;
+    ar.add_simple_temp_field(TYPE_INT64, &int64v);
+  }
+  else
+  {
+    int64_t int64v;
+    ar.read_next_simple_temp_field(TYPE_INT64, &int64v);
+
+    obj = static_cast<long>(int64v);
+  }
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void operator&(Archiver& ar, ulong& obj)
+{
+  if (ar.is_serializing_out())
+  {
+    uint64_t uint64v = obj;
+    ar.add_simple_temp_field(TYPE_UINT64, &uint64v);
+  }
+  else
+  {
+    uint64_t uint64v;
+    ar.read_next_simple_temp_field(TYPE_UINT64, &uint64v);
+
+    obj = static_cast<ulong>(uint64v);
+  }
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void operator&(Archiver& ar, long long& obj)
+{
+  assert(sizeof(long long) == 8);
+
+  if (ar.is_serializing_out())
+  {
+    int64_t int64v = obj;
+    ar.add_simple_temp_field(TYPE_INT64, &int64v);
+  }
+  else
+  {
+    int64_t int64v;
+    ar.read_next_simple_temp_field(TYPE_INT64, &int64v);
+
+    obj = static_cast<long long>(int64v);
+  }
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void operator&(Archiver& ar, unsigned long long& obj)
+{
+  assert(sizeof(unsigned long long) == 8);
+
+  if (ar.is_serializing_out())
+  {
+    uint64_t uint64v = obj;
+    ar.add_simple_temp_field(TYPE_UINT64, &uint64v);
+  }
+  else
+  {
+    uint64_t uint64v;
+    ar.read_next_simple_temp_field(TYPE_UINT64, &uint64v);
+
+    obj = static_cast<unsigned long long>(uint64v);
+  }
+}
+
+#if 0
+/*******************************************************************************
+
+********************************************************************************/
+void serialize_csize(Archiver& ar, csize& obj)
+{
+  assert(sizeof(csize) <= 8);
+
+  if (ar.is_serializing_out())
+  {
+    uint64_t uint64v = obj;
+    ar.add_simple_temp_field(TYPE_UINT64, &uint64v);
+  }
+  else
+  {
+    uint64_t uint64v;
+    ar.read_next_simple_temp_field(TYPE_UINT64, &uint64v);
+
+    obj = static_cast<csize>(uint64v);
+  }
+}
+#endif
+
+/*******************************************************************************
+
+********************************************************************************/
+void serialize_enum(Archiver& ar, uint32_t& obj)
+{
+  if (ar.is_serializing_out())
+  {
+    ar.add_simple_temp_field(TYPE_ENUM, &obj);
+  }
+  else
+  {
+    ar.read_next_simple_temp_field(TYPE_ENUM, &obj);
+  }
+}
 
 
 /*******************************************************************************

=== modified file 'src/zorbaserialization/serialize_basic_types.h'
--- src/zorbaserialization/serialize_basic_types.h	2012-06-22 15:19:14 +0000
+++ src/zorbaserialization/serialize_basic_types.h	2012-06-27 20:44:23 +0000
@@ -39,30 +39,24 @@
 class Archiver;
 
 
-void operator&(Archiver& ar, int64_t& obj);
-
-void operator&(Archiver& ar, uint64_t& obj);
-
-void serialize_long(Archiver& ar, long& obj);
-
-void serialize_long_long(Archiver& ar, long long& obj);
-
-void serialize_ulong_long(Archiver& ar, unsigned long long& obj);
-
-void serialize_ulong(Archiver& ar, ulong& obj);
-
-void serialize_csize(Archiver& ar, csize& obj);
-
-void operator&(Archiver& ar, int32_t& obj);
-
-void operator&(Archiver& ar, uint32_t& obj);
+void operator&(Archiver& ar, short& obj);
+
+void operator&(Archiver& ar, unsigned short& obj);
+
+void operator&(Archiver& ar, int& obj);
+
+void operator&(Archiver& ar, unsigned int& obj);
+
+void operator&(Archiver& ar, long& obj);
+
+void operator&(Archiver& ar, ulong& obj);
+
+void operator&(Archiver& ar, long long& obj);
+
+void operator&(Archiver& ar, unsigned long long& obj);
 
 void serialize_enum(Archiver& ar, uint32_t& obj);
 
-void operator&(Archiver& ar, int16_t& obj);
-
-void operator&(Archiver& ar, uint16_t& obj);
-
 void operator&(Archiver& ar, char& obj);
 
 void operator&(Archiver& ar, unsigned char& obj);

=== modified file 'src/zorbaserialization/serialize_template_types.h'
--- src/zorbaserialization/serialize_template_types.h	2012-06-26 01:32:29 +0000
+++ src/zorbaserialization/serialize_template_types.h	2012-06-27 20:44:23 +0000
@@ -304,7 +304,7 @@
   if (ar.is_serializing_out())
   {
     csize size = obj.size();
-    serialize_csize(ar, size);
+    ar & size;
 
     typename checked_vector<T>::iterator it = obj.begin();
     typename checked_vector<T>::iterator end = obj.end();
@@ -316,7 +316,7 @@
   else
   {
     csize size;
-    serialize_csize(ar, size);
+    ar & size;
 
     obj.resize(size);
 
@@ -340,11 +340,11 @@
   if (ar.is_serializing_out())
   {
     csize size = obj.size();
-    serialize_csize(ar, size);
+    ar & size;
 
     typename std::vector<T>::iterator it = obj.begin();
     typename std::vector<T>::iterator end = obj.end();
-    for(; it != end; ++it)
+    for (; it != end; ++it)
     {
       ar & (*it);
     }
@@ -352,13 +352,13 @@
   else
   {
     csize size;
-    serialize_csize(ar, size);
+    ar & size;
 
     obj.resize(size);
 
     typename std::vector<T>::iterator it = obj.begin();
     typename std::vector<T>::iterator end = obj.end();
-    for(; it != end; ++it)
+    for (; it != end; ++it)
     {
       ar & (*it);
     }
@@ -375,11 +375,11 @@
   if (ar.is_serializing_out())
   {
     csize size = obj.size();
-    serialize_csize(ar, size);
+    ar & size;
 
     typename std::vector<T*>::iterator it = obj.begin();
     typename std::vector<T*>::iterator end = obj.end();
-    for(; it != end; ++it)
+    for (; it != end; ++it)
     {
       ar & (*it);
     }
@@ -387,14 +387,14 @@
   else
   {
     csize size;
-    serialize_csize(ar, size);
+    ar & size;
 
     obj.resize(size);
 
     typename std::vector<T*>::iterator it = obj.begin();
     typename std::vector<T*>::iterator end = obj.end();
 
-    for(; it != end; ++it)
+    for (; it != end; ++it)
     {
       ar & (*it);
     }
@@ -425,11 +425,11 @@
     (void)is_ref;
 
     size = obj->size();
-    serialize_csize(ar, size);
+    ar & size;
 
     typename std::vector<T>::iterator it = obj->begin();
     typename std::vector<T>::iterator end = obj->end();
-    for(; it != end; ++it)
+    for (; it != end; ++it)
     {
       ar & (*it);
     }
@@ -458,13 +458,13 @@
 
     obj = new std::vector<T>;
 
-    serialize_csize(ar, size);
+    ar & size;
 
     obj->resize(size);
 
     typename std::vector<T>::iterator it = obj->begin();
     typename std::vector<T>::iterator end = obj->end();
-    for(; it != end; ++it)
+    for (; it != end; ++it)
     {
       ar & (*it);
     }
@@ -483,7 +483,7 @@
   if (ar.is_serializing_out())
   {
     csize size = obj.size();
-    serialize_csize(ar, size);
+    ar & size;
 
     typename std::list<T>::iterator it = obj.begin();
     typename std::list<T>::iterator end = obj.end();
@@ -495,7 +495,7 @@
   else
   {
     csize size;
-    serialize_csize(ar, size);
+    ar & size;
 
     obj.resize(size);
 
@@ -544,7 +544,7 @@
     (void)is_ref;
 
     size = obj->size();
-    serialize_csize(ar, size);
+    ar & size;
 
     typename std::map<T1, T2>::iterator it = obj->begin();
     typename std::map<T1, T2>::iterator end = obj->end();
@@ -580,7 +580,7 @@
 
     obj = new std::map<T1, T2>;
 
-    serialize_csize(ar, size);
+    ar & size;
 
     std::pair<T1, T2> p;
 
@@ -606,7 +606,7 @@
   if (ar.is_serializing_out())
   {
     csize s = obj.size();
-    serialize_csize(ar, s);
+    ar & s;
 
     typename std::map<T1, T2, Tcomp>::iterator it = obj.begin();
     typename std::map<T1, T2, Tcomp>::iterator end = obj.end();
@@ -621,7 +621,7 @@
   else
   {
     csize s;
-    serialize_csize(ar, s);
+    ar & s;
 
     std::pair<T1, T2> p;
 
@@ -639,45 +639,6 @@
 /*******************************************************************************
 
 ********************************************************************************/
-template<typename T2, class Tcomp>
-void operator&(Archiver& ar, std::map<csize, T2, Tcomp>& obj)
-{
-  if (ar.is_serializing_out())
-  {
-    csize s = obj.size();
-    serialize_csize(ar, s);
-
-    typename std::map<csize, T2, Tcomp>::iterator it = obj.begin();
-    typename std::map<csize, T2, Tcomp>::iterator end = obj.end();
-
-    for (; it != end; ++it)
-    {
-      csize key = (*it).first;
-      serialize_csize(ar, key);
-      ar & (*it).second;
-    }
-  }
-  else
-  {
-    csize s;
-    serialize_csize(ar, s);
-
-    std::pair<csize, T2> p;
-
-    for (csize i = 0; i < s; ++i)
-    {
-      serialize_csize(ar, p.first);
-      ar & p.second;
-
-      obj.insert(p);
-    }
-  }
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
 template<typename T, typename V, class Tcomp>
 void operator&(Archiver& ar, HashMap<T, V, Tcomp>& obj)
 {
@@ -693,7 +654,7 @@
     size = obj.size();
 
     ar & sync;
-    serialize_csize(ar, size);
+    ar & size;
 
     typename HashMap<T, V, Tcomp>::iterator it = obj.begin();
     typename HashMap<T, V, Tcomp>::iterator end = obj.end();
@@ -708,7 +669,7 @@
   else
   {
     ar & sync;
-    serialize_csize(ar, size);
+    ar & size;
 
     obj.theNumEntries = 0;
     obj.theInitialSize = obj.theHashTabSize;
@@ -767,10 +728,10 @@
 
     ar.set_is_temp_field(true);
 
-    serialize_csize(ar, capacity);
+    ar & capacity;
     ar & sync;
     ar & comp;
-    serialize_csize(ar, size);
+    ar & size;
 
     ar.set_is_temp_field(false);
 
@@ -808,10 +769,10 @@
 
     ar.set_is_temp_field(true);
 
-    serialize_csize(ar, capacity);
+    ar & capacity;
     ar & sync;
     ar & comp;
-    serialize_csize(ar, size);
+    ar & size;
 
     ar.set_is_temp_field(false);
 

=== modified file 'src/zorbaserialization/serialize_zorba_types.cpp'
--- src/zorbaserialization/serialize_zorba_types.cpp	2012-06-22 15:19:14 +0000
+++ src/zorbaserialization/serialize_zorba_types.cpp	2012-06-27 20:44:23 +0000
@@ -92,12 +92,12 @@
 
 void operator&(serialization::Archiver& ar, IntegerImpl<long long>& obj)
 {
-  serialize_long_long(ar, obj.get_value());
+  ar & obj.get_value();
 }
 
 void operator&(serialization::Archiver& ar, IntegerImpl<unsigned long long>& obj)
 {
-  serialize_ulong_long(ar, obj.get_value());
+  ar & obj.get_value();
 }
 
 #endif
@@ -119,13 +119,13 @@
 {
   SERIALIZE_ENUM(DateTime::FACET_TYPE, obj.facet);
 
-  serialize_long(ar, obj.data[0]);
-  serialize_long(ar, obj.data[1]);
-  serialize_long(ar, obj.data[2]);
-  serialize_long(ar, obj.data[3]);
-  serialize_long(ar, obj.data[4]);
-  serialize_long(ar, obj.data[5]);
-  serialize_long(ar, obj.data[6]);
+  ar & obj.data[0];
+  ar & obj.data[1];
+  ar & obj.data[2];
+  ar & obj.data[3];
+  ar & obj.data[4];
+  ar & obj.data[5];
+  ar & obj.data[6];
 
   ar & obj.the_time_zone;
 }
@@ -139,13 +139,13 @@
   SERIALIZE_ENUM(Duration::FACET_TYPE, obj.facet);
   ar & obj.is_negative;
 
-  serialize_long(ar, obj.data[0]);
-  serialize_long(ar, obj.data[1]);
-  serialize_long(ar, obj.data[2]);
-  serialize_long(ar, obj.data[3]);
-  serialize_long(ar, obj.data[4]);
-  serialize_long(ar, obj.data[5]);
-  serialize_long(ar, obj.data[6]);
+  ar & obj.data[0];
+  ar & obj.data[1];
+  ar & obj.data[2];
+  ar & obj.data[3];
+  ar & obj.data[4];
+  ar & obj.data[5];
+  ar & obj.data[6];
 }
 
 
@@ -190,18 +190,7 @@
 ********************************************************************************/
 void operator&(Archiver& ar, HashMapItemPointerCmp& obj)
 {
-  if (ar.is_serializing_out())
-  {
-    int32_t tz = obj.theTimeZone;
-    ar & tz;
-  }
-  else
-  {
-    int32_t tz = 0;
-    ar & tz;
-    obj.theTimeZone = tz;
-  }
-
+  ar & obj.theTimeZone;
   ar & obj.theCollator;
 }
 
@@ -1355,7 +1344,7 @@
     iterator_to_vector(iter, childs);
     std::vector<store::Item_t>::iterator  child_it;
     csize child_count = childs.size();
-    serialize_csize(ar, child_count);
+    ar & child_count;
 
     for(child_it = childs.begin(); child_it != childs.end(); ++child_it)
     {
@@ -1369,7 +1358,7 @@
   else
   {
     csize child_count;
-    serialize_csize(ar, child_count);
+    ar & child_count;
 
     for (csize i = 0; i < child_count; ++i)
     {