zorba-coders team mailing list archive
-
zorba-coders team
-
Mailing list archive
-
Message #07269
[Merge] lp:~zorba-coders/zorba/serializer into lp:zorba
Markos Zaharioudakis has proposed merging lp:~zorba-coders/zorba/serializer into lp:zorba.
Requested reviews:
Markos Zaharioudakis (markos-za)
For more details, see:
https://code.launchpad.net/~zorba-coders/zorba/serializer/+merge/101213
removed class-version infrastrure from plan serializer
--
https://code.launchpad.net/~zorba-coders/zorba/serializer/+merge/101213
Your team Zorba Coders is subscribed to branch lp:zorba.
=== modified file 'src/annotations/annotations.cpp'
--- src/annotations/annotations.cpp 2012-03-28 05:19:57 +0000
+++ src/annotations/annotations.cpp 2012-04-08 20:59:19 +0000
@@ -32,10 +32,8 @@
namespace zorba {
SERIALIZABLE_CLASS_VERSIONS(AnnotationInternal)
-END_SERIALIZABLE_CLASS_VERSIONS(AnnotationInternal)
SERIALIZABLE_CLASS_VERSIONS(AnnotationList)
-END_SERIALIZABLE_CLASS_VERSIONS(AnnotationList);
std::vector<store::Item_t>
=== modified file 'src/api/xqueryimpl.cpp'
--- src/api/xqueryimpl.cpp 2012-03-28 05:19:57 +0000
+++ src/api/xqueryimpl.cpp 2012-04-08 20:59:19 +0000
@@ -103,17 +103,17 @@
SERIALIZABLE_CLASS_VERSIONS(XQueryImpl::PlanProxy)
-END_SERIALIZABLE_CLASS_VERSIONS(XQueryImpl::PlanProxy)
SERIALIZABLE_CLASS_VERSIONS(XQueryImpl)
-END_SERIALIZABLE_CLASS_VERSIONS(XQueryImpl)
-XQueryImpl::XQueryImpl(::zorba::serialization::Archiver &ar)
- : ::zorba::serialization::SerializeBaseClass(),
- theCollMgr(0)
+XQueryImpl::XQueryImpl(::zorba::serialization::Archiver& ar)
+ :
+ ::zorba::serialization::SerializeBaseClass(),
+ theCollMgr(0)
{
}
+
/*******************************************************************************
********************************************************************************/
=== modified file 'src/compiler/api/compilercb.cpp'
--- src/compiler/api/compilercb.cpp 2012-03-28 05:19:57 +0000
+++ src/compiler/api/compilercb.cpp 2012-04-08 20:59:19 +0000
@@ -34,10 +34,8 @@
{
SERIALIZABLE_CLASS_VERSIONS(CompilerCB)
-END_SERIALIZABLE_CLASS_VERSIONS(CompilerCB)
SERIALIZABLE_CLASS_VERSIONS(CompilerCB::config)
-END_SERIALIZABLE_CLASS_VERSIONS(CompilerCB::config)
#define DEF_PRINT_EXPR_TREE( phase ) \
=== modified file 'src/compiler/expression/expr.cpp'
--- src/compiler/expression/expr.cpp 2012-03-28 05:19:57 +0000
+++ src/compiler/expression/expr.cpp 2012-04-08 20:59:19 +0000
@@ -50,93 +50,64 @@
{
SERIALIZABLE_CLASS_VERSIONS(expr)
-END_SERIALIZABLE_CLASS_VERSIONS(expr)
SERIALIZABLE_CLASS_VERSIONS(catch_clause)
-END_SERIALIZABLE_CLASS_VERSIONS(catch_clause)
SERIALIZABLE_CLASS_VERSIONS(trycatch_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(trycatch_expr)
SERIALIZABLE_CLASS_VERSIONS(function_trace_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(function_trace_expr)
SERIALIZABLE_CLASS_VERSIONS(eval_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(eval_expr)
#ifdef ZORBA_WITH_DEBUGGER
SERIALIZABLE_CLASS_VERSIONS(debugger_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(debugger_expr)
#endif
SERIALIZABLE_CLASS_VERSIONS(wrapper_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(wrapper_expr)
SERIALIZABLE_CLASS_VERSIONS(namespace_context_base_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(namespace_context_base_expr)
SERIALIZABLE_CLASS_VERSIONS(cast_or_castable_base_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(cast_or_castable_base_expr)
SERIALIZABLE_CLASS_VERSIONS(cast_base_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(cast_base_expr)
SERIALIZABLE_CLASS_VERSIONS(promote_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(promote_expr)
SERIALIZABLE_CLASS_VERSIONS(castable_base_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(castable_base_expr)
SERIALIZABLE_CLASS_VERSIONS(instanceof_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(instanceof_expr)
SERIALIZABLE_CLASS_VERSIONS(treat_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(treat_expr)
SERIALIZABLE_CLASS_VERSIONS(castable_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(castable_expr)
SERIALIZABLE_CLASS_VERSIONS(cast_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(cast_expr)
SERIALIZABLE_CLASS_VERSIONS(name_cast_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(name_cast_expr)
SERIALIZABLE_CLASS_VERSIONS(if_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(if_expr)
SERIALIZABLE_CLASS_VERSIONS(validate_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(validate_expr)
SERIALIZABLE_CLASS_VERSIONS(pragma)
-END_SERIALIZABLE_CLASS_VERSIONS(pragma)
SERIALIZABLE_CLASS_VERSIONS(extension_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(extension_expr)
SERIALIZABLE_CLASS_VERSIONS(const_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(const_expr)
SERIALIZABLE_CLASS_VERSIONS(order_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(order_expr)
SERIALIZABLE_CLASS_VERSIONS(elem_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(elem_expr)
SERIALIZABLE_CLASS_VERSIONS(doc_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(doc_expr)
SERIALIZABLE_CLASS_VERSIONS(attr_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(attr_expr)
SERIALIZABLE_CLASS_VERSIONS(text_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(text_expr)
SERIALIZABLE_CLASS_VERSIONS(pi_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(pi_expr)
SERIALIZABLE_CLASS_VERSIONS(OrderModifier)
-END_SERIALIZABLE_CLASS_VERSIONS(OrderModifier)
/*******************************************************************************
=== modified file 'src/compiler/expression/flwor_expr.cpp'
--- src/compiler/expression/flwor_expr.cpp 2012-03-28 05:19:57 +0000
+++ src/compiler/expression/flwor_expr.cpp 2012-04-08 20:59:19 +0000
@@ -38,43 +38,30 @@
{
SERIALIZABLE_CLASS_VERSIONS(flwor_clause)
-END_SERIALIZABLE_CLASS_VERSIONS(flwor_clause)
SERIALIZABLE_CLASS_VERSIONS(forletwin_clause)
-END_SERIALIZABLE_CLASS_VERSIONS(forletwin_clause)
SERIALIZABLE_CLASS_VERSIONS(for_clause)
-END_SERIALIZABLE_CLASS_VERSIONS(for_clause)
SERIALIZABLE_CLASS_VERSIONS(let_clause)
-END_SERIALIZABLE_CLASS_VERSIONS(let_clause)
SERIALIZABLE_CLASS_VERSIONS(window_clause)
-END_SERIALIZABLE_CLASS_VERSIONS(window_clause)
SERIALIZABLE_CLASS_VERSIONS(group_clause)
-END_SERIALIZABLE_CLASS_VERSIONS(group_clause)
SERIALIZABLE_CLASS_VERSIONS(orderby_clause)
-END_SERIALIZABLE_CLASS_VERSIONS(orderby_clause)
SERIALIZABLE_CLASS_VERSIONS(materialize_clause)
-END_SERIALIZABLE_CLASS_VERSIONS(materialize_clause)
SERIALIZABLE_CLASS_VERSIONS(count_clause)
-END_SERIALIZABLE_CLASS_VERSIONS(count_clause)
SERIALIZABLE_CLASS_VERSIONS(where_clause)
-END_SERIALIZABLE_CLASS_VERSIONS(where_clause)
SERIALIZABLE_CLASS_VERSIONS(flwor_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(flwor_expr)
SERIALIZABLE_CLASS_VERSIONS(flwor_wincond)
-END_SERIALIZABLE_CLASS_VERSIONS(flwor_wincond)
SERIALIZABLE_CLASS_VERSIONS(flwor_wincond::vars)
-END_SERIALIZABLE_CLASS_VERSIONS(flwor_wincond::vars)
DEF_EXPR_ACCEPT (flwor_expr)
=== modified file 'src/compiler/expression/fo_expr.cpp'
--- src/compiler/expression/fo_expr.cpp 2012-03-28 05:19:57 +0000
+++ src/compiler/expression/fo_expr.cpp 2012-04-08 20:59:19 +0000
@@ -34,7 +34,7 @@
{
SERIALIZABLE_CLASS_VERSIONS(fo_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(fo_expr)
+
void fo_expr::accept(expr_visitor& v)
{
@@ -130,11 +130,11 @@
}
-void fo_expr::serialize(::zorba::serialization::Archiver &ar)
+void fo_expr::serialize(::zorba::serialization::Archiver& ar)
{
serialize_baseclass(ar, (expr*)this);
ar & theArgs;
- SERIALIZE_FUNCTION((function*&)theFunction);
+ ar & ((function*&)theFunction);
}
=== modified file 'src/compiler/expression/ft_expr.cpp'
--- src/compiler/expression/ft_expr.cpp 2012-03-28 05:19:57 +0000
+++ src/compiler/expression/ft_expr.cpp 2012-04-08 20:59:19 +0000
@@ -25,7 +25,7 @@
namespace zorba {
SERIALIZABLE_CLASS_VERSIONS(ftcontains_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(ftcontains_expr)
+
#define EV_ACCEPT( EXPR, V ) \
if ( !(EXPR) ) ; else (EXPR)->accept( V )
=== modified file 'src/compiler/expression/ftnode.cpp'
--- src/compiler/expression/ftnode.cpp 2012-03-28 05:19:57 +0000
+++ src/compiler/expression/ftnode.cpp 2012-04-08 20:59:19 +0000
@@ -37,100 +37,69 @@
///////////////////////////////////////////////////////////////////////////////
SERIALIZABLE_CLASS_VERSIONS(ftand)
-END_SERIALIZABLE_CLASS_VERSIONS(ftand)
SERIALIZABLE_CLASS_VERSIONS(ftcontent_filter)
-END_SERIALIZABLE_CLASS_VERSIONS(ftcontent_filter)
SERIALIZABLE_CLASS_VERSIONS(ftcase_option)
-END_SERIALIZABLE_CLASS_VERSIONS(ftcase_option)
SERIALIZABLE_CLASS_VERSIONS(ftdiacritics_option)
-END_SERIALIZABLE_CLASS_VERSIONS(ftdiacritics_option)
SERIALIZABLE_CLASS_VERSIONS(ftdistance_filter)
-END_SERIALIZABLE_CLASS_VERSIONS(ftdistance_filter)
SERIALIZABLE_CLASS_VERSIONS(ftextension_option)
-END_SERIALIZABLE_CLASS_VERSIONS(ftextension_option)
SERIALIZABLE_CLASS_VERSIONS(ftextension_selection)
-END_SERIALIZABLE_CLASS_VERSIONS(ftextension_selection)
SERIALIZABLE_CLASS_VERSIONS(ftlanguage_option)
-END_SERIALIZABLE_CLASS_VERSIONS(ftlanguage_option)
SERIALIZABLE_CLASS_VERSIONS(ftmatch_option)
-END_SERIALIZABLE_CLASS_VERSIONS(ftmatch_option)
SERIALIZABLE_CLASS_VERSIONS(ftmatch_options)
-END_SERIALIZABLE_CLASS_VERSIONS(ftmatch_options)
SERIALIZABLE_CLASS_VERSIONS(ftmild_not)
-END_SERIALIZABLE_CLASS_VERSIONS(ftmild_not)
SERIALIZABLE_CLASS_VERSIONS(ftnode)
-END_SERIALIZABLE_CLASS_VERSIONS(ftnode)
SERIALIZABLE_CLASS_VERSIONS(ftnode_list)
-END_SERIALIZABLE_CLASS_VERSIONS(ftnode_list)
SERIALIZABLE_CLASS_VERSIONS(ftor)
-END_SERIALIZABLE_CLASS_VERSIONS(ftor)
SERIALIZABLE_CLASS_VERSIONS(ftorder_filter)
-END_SERIALIZABLE_CLASS_VERSIONS(ftorder_filter)
SERIALIZABLE_CLASS_VERSIONS(ftpos_filter)
-END_SERIALIZABLE_CLASS_VERSIONS(ftpos_filter)
SERIALIZABLE_CLASS_VERSIONS(ftprimary)
-END_SERIALIZABLE_CLASS_VERSIONS(ftprimary)
SERIALIZABLE_CLASS_VERSIONS(ftprimary_with_options)
-END_SERIALIZABLE_CLASS_VERSIONS(ftprimary_with_options)
SERIALIZABLE_CLASS_VERSIONS(ftrange)
-END_SERIALIZABLE_CLASS_VERSIONS(ftrange)
SERIALIZABLE_CLASS_VERSIONS(ftscope_filter)
-END_SERIALIZABLE_CLASS_VERSIONS(ftscope_filter)
SERIALIZABLE_CLASS_VERSIONS(ftselection)
-END_SERIALIZABLE_CLASS_VERSIONS(ftselection)
SERIALIZABLE_CLASS_VERSIONS(ftstem_option)
-END_SERIALIZABLE_CLASS_VERSIONS(ftstem_option)
SERIALIZABLE_CLASS_VERSIONS(ftstop_words)
-END_SERIALIZABLE_CLASS_VERSIONS(ftstop_words)
SERIALIZABLE_CLASS_VERSIONS(ftstop_word_option)
-END_SERIALIZABLE_CLASS_VERSIONS(ftstop_word_option)
SERIALIZABLE_CLASS_VERSIONS(ftthesaurus_id)
-END_SERIALIZABLE_CLASS_VERSIONS(ftthesaurus_id)
SERIALIZABLE_CLASS_VERSIONS(ftthesaurus_option)
-END_SERIALIZABLE_CLASS_VERSIONS(ftthesaurus_option)
SERIALIZABLE_CLASS_VERSIONS(ftunary_not)
-END_SERIALIZABLE_CLASS_VERSIONS(ftunary_not)
SERIALIZABLE_CLASS_VERSIONS(ftweight)
-END_SERIALIZABLE_CLASS_VERSIONS(ftweight)
SERIALIZABLE_CLASS_VERSIONS(ftwild_card_option)
-END_SERIALIZABLE_CLASS_VERSIONS(ftwild_card_option)
SERIALIZABLE_CLASS_VERSIONS(ftwindow_filter)
-END_SERIALIZABLE_CLASS_VERSIONS(ftwindow_filter)
SERIALIZABLE_CLASS_VERSIONS(ftwords)
-END_SERIALIZABLE_CLASS_VERSIONS(ftwords)
SERIALIZABLE_CLASS_VERSIONS(ftwords_times)
-END_SERIALIZABLE_CLASS_VERSIONS(ftwords_times)
+
////////// Visit macros ///////////////////////////////////////////////////////
=== modified file 'src/compiler/expression/function_item_expr.cpp'
--- src/compiler/expression/function_item_expr.cpp 2012-03-28 05:19:57 +0000
+++ src/compiler/expression/function_item_expr.cpp 2012-04-08 20:59:19 +0000
@@ -28,7 +28,7 @@
SERIALIZABLE_CLASS_VERSIONS(dynamic_function_invocation_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(dynamic_function_invocation_expr)
+
DEF_EXPR_ACCEPT (dynamic_function_invocation_expr)
@@ -79,7 +79,7 @@
********************************************************************************/
SERIALIZABLE_CLASS_VERSIONS(function_item_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(function_item_expr)
+
DEF_EXPR_ACCEPT (function_item_expr)
=== modified file 'src/compiler/expression/path_expr.cpp'
--- src/compiler/expression/path_expr.cpp 2012-03-28 05:19:57 +0000
+++ src/compiler/expression/path_expr.cpp 2012-04-08 20:59:19 +0000
@@ -34,13 +34,10 @@
{
SERIALIZABLE_CLASS_VERSIONS(relpath_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(relpath_expr)
SERIALIZABLE_CLASS_VERSIONS(axis_step_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(axis_step_expr)
SERIALIZABLE_CLASS_VERSIONS(match_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(match_expr)
DEF_EXPR_ACCEPT (relpath_expr)
=== modified file 'src/compiler/expression/script_exprs.cpp'
--- src/compiler/expression/script_exprs.cpp 2012-03-28 05:19:57 +0000
+++ src/compiler/expression/script_exprs.cpp 2012-04-08 20:59:19 +0000
@@ -30,28 +30,20 @@
{
SERIALIZABLE_CLASS_VERSIONS(block_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(block_expr)
SERIALIZABLE_CLASS_VERSIONS(apply_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(apply_expr)
SERIALIZABLE_CLASS_VERSIONS(var_decl_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(var_decl_expr)
SERIALIZABLE_CLASS_VERSIONS(var_set_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(var_set_expr)
SERIALIZABLE_CLASS_VERSIONS(exit_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(exit_expr)
SERIALIZABLE_CLASS_VERSIONS(exit_catcher_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(exit_catcher_expr)
SERIALIZABLE_CLASS_VERSIONS(flowctl_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(flowctl_expr)
SERIALIZABLE_CLASS_VERSIONS(while_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(while_expr)
DEF_EXPR_ACCEPT(block_expr)
DEF_EXPR_ACCEPT(apply_expr)
=== modified file 'src/compiler/expression/update_exprs.cpp'
--- src/compiler/expression/update_exprs.cpp 2012-03-28 05:19:57 +0000
+++ src/compiler/expression/update_exprs.cpp 2012-04-08 20:59:19 +0000
@@ -25,25 +25,18 @@
{
SERIALIZABLE_CLASS_VERSIONS(update_expr_base)
-END_SERIALIZABLE_CLASS_VERSIONS(update_expr_base)
SERIALIZABLE_CLASS_VERSIONS(insert_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(insert_expr)
SERIALIZABLE_CLASS_VERSIONS(delete_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(delete_expr)
SERIALIZABLE_CLASS_VERSIONS(replace_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(replace_expr)
SERIALIZABLE_CLASS_VERSIONS(rename_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(rename_expr)
SERIALIZABLE_CLASS_VERSIONS(copy_clause)
-END_SERIALIZABLE_CLASS_VERSIONS(copy_clause)
SERIALIZABLE_CLASS_VERSIONS(transform_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(transform_expr)
DEF_EXPR_ACCEPT (insert_expr)
=== modified file 'src/compiler/expression/var_expr.cpp'
--- src/compiler/expression/var_expr.cpp 2012-03-28 05:19:57 +0000
+++ src/compiler/expression/var_expr.cpp 2012-04-08 20:59:19 +0000
@@ -33,10 +33,8 @@
{
SERIALIZABLE_CLASS_VERSIONS(var_expr)
-END_SERIALIZABLE_CLASS_VERSIONS(var_expr)
SERIALIZABLE_CLASS_VERSIONS(GlobalBinding)
-END_SERIALIZABLE_CLASS_VERSIONS(GlobalBinding)
/*******************************************************************************
=== modified file 'src/compiler/parser/query_loc.cpp'
--- src/compiler/parser/query_loc.cpp 2012-03-28 05:19:57 +0000
+++ src/compiler/parser/query_loc.cpp 2012-04-08 20:59:19 +0000
@@ -27,7 +27,6 @@
{
SERIALIZABLE_CLASS_VERSIONS(QueryLoc)
-END_SERIALIZABLE_CLASS_VERSIONS(QueryLoc)
QueryLoc QueryLoc::null;
=== modified file 'src/compiler/xqddf/collection_decl.cpp'
--- src/compiler/xqddf/collection_decl.cpp 2012-03-28 05:19:57 +0000
+++ src/compiler/xqddf/collection_decl.cpp 2012-04-08 20:59:19 +0000
@@ -25,7 +25,6 @@
namespace zorba {
SERIALIZABLE_CLASS_VERSIONS(StaticallyKnownCollection)
-END_SERIALIZABLE_CLASS_VERSIONS(StaticallyKnownCollection)
/*******************************************************************************
=== modified file 'src/compiler/xqddf/value_ic.cpp'
--- src/compiler/xqddf/value_ic.cpp 2012-03-28 05:19:57 +0000
+++ src/compiler/xqddf/value_ic.cpp 2012-04-08 20:59:19 +0000
@@ -33,7 +33,6 @@
{
SERIALIZABLE_CLASS_VERSIONS(ValueIC)
-END_SERIALIZABLE_CLASS_VERSIONS(ValueIC)
/*******************************************************************************
=== modified file 'src/compiler/xqddf/value_index.cpp'
--- src/compiler/xqddf/value_index.cpp 2012-03-28 05:19:57 +0000
+++ src/compiler/xqddf/value_index.cpp 2012-04-08 20:59:19 +0000
@@ -43,7 +43,6 @@
{
SERIALIZABLE_CLASS_VERSIONS(IndexDecl)
-END_SERIALIZABLE_CLASS_VERSIONS(IndexDecl)
/*******************************************************************************
=== modified file 'src/context/decimal_format.cpp'
--- src/context/decimal_format.cpp 2012-03-28 05:19:57 +0000
+++ src/context/decimal_format.cpp 2012-04-08 20:59:19 +0000
@@ -24,7 +24,7 @@
namespace zorba {
SERIALIZABLE_CLASS_VERSIONS(DecimalFormat)
-END_SERIALIZABLE_CLASS_VERSIONS(DecimalFormat)
+
DecimalFormat::DecimalFormat(
bool isDefault,
=== modified file 'src/context/namespace_context.cpp'
--- src/context/namespace_context.cpp 2012-03-28 05:19:57 +0000
+++ src/context/namespace_context.cpp 2012-04-08 20:59:19 +0000
@@ -24,7 +24,6 @@
namespace zorba {
SERIALIZABLE_CLASS_VERSIONS(namespace_context)
-END_SERIALIZABLE_CLASS_VERSIONS(namespace_context)
=== modified file 'src/context/static_context.cpp'
--- src/context/static_context.cpp 2012-03-28 05:19:57 +0000
+++ src/context/static_context.cpp 2012-04-08 20:59:19 +0000
@@ -89,19 +89,14 @@
SERIALIZABLE_CLASS_VERSIONS(BaseUriInfo)
-END_SERIALIZABLE_CLASS_VERSIONS(BaseUriInfo)
SERIALIZABLE_CLASS_VERSIONS(FunctionInfo)
-END_SERIALIZABLE_CLASS_VERSIONS(FunctionInfo)
SERIALIZABLE_CLASS_VERSIONS(PrologOption)
-END_SERIALIZABLE_CLASS_VERSIONS(PrologOption)
SERIALIZABLE_CLASS_VERSIONS(static_context::ctx_module_t)
-END_SERIALIZABLE_CLASS_VERSIONS(static_context::ctx_module_t)
SERIALIZABLE_CLASS_VERSIONS(static_context)
-END_SERIALIZABLE_CLASS_VERSIONS(static_context)
/**************************************************************************//**
=== modified file 'src/debugger/debugger_commons.cpp'
--- src/debugger/debugger_commons.cpp 2012-03-28 05:19:57 +0000
+++ src/debugger/debugger_commons.cpp 2012-04-08 20:59:19 +0000
@@ -42,7 +42,6 @@
// ****************************************************************************
SERIALIZABLE_CLASS_VERSIONS(Breakable)
-END_SERIALIZABLE_CLASS_VERSIONS(Breakable)
void
Breakable::serialize(serialization::Archiver& ar)
@@ -54,7 +53,7 @@
// ****************************************************************************
SERIALIZABLE_CLASS_VERSIONS(QueryLocComparator)
-END_SERIALIZABLE_CLASS_VERSIONS(QueryLocComparator)
+
void
QueryLocComparator::serialize(serialization::Archiver& ar) {
@@ -113,7 +112,7 @@
// ****************************************************************************
SERIALIZABLE_CLASS_VERSIONS(DebuggerSingletonIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(DebuggerSingletonIterator)
+
DebuggerSingletonIterator::DebuggerSingletonIterator(
static_context* sctx, QueryLoc loc, DebuggerCommons* lCommons)
@@ -145,7 +144,7 @@
// ****************************************************************************
SERIALIZABLE_CLASS_VERSIONS(DebuggerCommons)
-END_SERIALIZABLE_CLASS_VERSIONS(DebuggerCommons)
+
DebuggerCommons::DebuggerCommons(static_context* sctx)
: theBreak(false),
=== modified file 'src/functions/external_function.cpp'
--- src/functions/external_function.cpp 2012-03-28 05:19:57 +0000
+++ src/functions/external_function.cpp 2012-04-08 20:59:19 +0000
@@ -27,7 +27,6 @@
{
SERIALIZABLE_CLASS_VERSIONS(external_function)
-END_SERIALIZABLE_CLASS_VERSIONS(external_function)
/*******************************************************************************
=== modified file 'src/functions/function.cpp'
--- src/functions/function.cpp 2012-03-28 05:19:57 +0000
+++ src/functions/function.cpp 2012-04-08 20:59:19 +0000
@@ -33,7 +33,6 @@
namespace zorba {
SERIALIZABLE_CLASS_VERSIONS(function)
-END_SERIALIZABLE_CLASS_VERSIONS(function)
/*******************************************************************************
=== modified file 'src/functions/signature.cpp'
--- src/functions/signature.cpp 2012-03-28 05:19:57 +0000
+++ src/functions/signature.cpp 2012-04-08 20:59:19 +0000
@@ -26,7 +26,6 @@
{
SERIALIZABLE_CLASS_VERSIONS(signature)
-END_SERIALIZABLE_CLASS_VERSIONS(signature)
signature::signature(
@@ -37,68 +36,68 @@
:
theQName(name),
theIsVariadic(variadic)
-{
- theTypes.push_back(returnType);
- theTypes.push_back(paramType1);
-}
-
-
-signature::signature(
- const store::Item_t& name,
- const xqtref_t& returnType)
- :
- theQName(name),
- theIsVariadic(false)
-{
- theTypes.push_back(returnType);
-}
-
-
-signature::signature(
- const store::Item_t& name,
- const xqtref_t& paramType1,
- const xqtref_t& returnType)
- :
- theQName(name),
- theIsVariadic(false)
-{
- theTypes.push_back(returnType);
- theTypes.push_back(paramType1);
-}
-
-
-signature::signature(
- const store::Item_t& name,
- const xqtref_t& paramType1,
- const xqtref_t& paramType2,
- const xqtref_t& returnType)
- :
- theQName(name),
- theIsVariadic(false)
-{
- theTypes.push_back(returnType);
- theTypes.push_back(paramType1);
- theTypes.push_back(paramType2);
-}
-
-
-signature::signature(
- const store::Item_t& name,
- const xqtref_t& paramType1,
- const xqtref_t& paramType2,
+{
+ theTypes.push_back(returnType);
+ theTypes.push_back(paramType1);
+}
+
+
+signature::signature(
+ const store::Item_t& name,
+ const xqtref_t& returnType)
+ :
+ theQName(name),
+ theIsVariadic(false)
+{
+ theTypes.push_back(returnType);
+}
+
+
+signature::signature(
+ const store::Item_t& name,
+ const xqtref_t& paramType1,
+ const xqtref_t& returnType)
+ :
+ theQName(name),
+ theIsVariadic(false)
+{
+ theTypes.push_back(returnType);
+ theTypes.push_back(paramType1);
+}
+
+
+signature::signature(
+ const store::Item_t& name,
+ const xqtref_t& paramType1,
+ const xqtref_t& paramType2,
+ const xqtref_t& returnType)
+ :
+ theQName(name),
+ theIsVariadic(false)
+{
+ theTypes.push_back(returnType);
+ theTypes.push_back(paramType1);
+ theTypes.push_back(paramType2);
+}
+
+
+signature::signature(
+ const store::Item_t& name,
+ const xqtref_t& paramType1,
+ const xqtref_t& paramType2,
const xqtref_t& paramType3,
- const xqtref_t& returnType)
- :
- theQName(name),
- theIsVariadic(false)
-{
- theTypes.push_back(returnType);
- theTypes.push_back(paramType1);
- theTypes.push_back(paramType2);
+ const xqtref_t& returnType)
+ :
+ theQName(name),
+ theIsVariadic(false)
+{
+ theTypes.push_back(returnType);
+ theTypes.push_back(paramType1);
+ theTypes.push_back(paramType2);
theTypes.push_back(paramType3);
}
-
-
+
+
signature::signature(
const store::Item_t& name,
const xqtref_t& paramType1,
=== modified file 'src/functions/udf.cpp'
--- src/functions/udf.cpp 2012-03-28 05:19:57 +0000
+++ src/functions/udf.cpp 2012-04-08 20:59:19 +0000
@@ -40,7 +40,6 @@
{
SERIALIZABLE_CLASS_VERSIONS(user_function)
-END_SERIALIZABLE_CLASS_VERSIONS(user_function)
/*******************************************************************************
=== modified file 'src/runtime/accessors/pregenerated/accessors.cpp'
--- src/runtime/accessors/pregenerated/accessors.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/accessors/pregenerated/accessors.cpp 2012-04-08 20:59:19 +0000
@@ -34,15 +34,9 @@
namespace zorba {
// <NodeNameIterator>
-const char* NodeNameIterator::class_name_str = "NodeNameIterator";
NodeNameIterator::class_factory<NodeNameIterator>
NodeNameIterator::g_class_factory;
-const serialization::ClassVersion
-NodeNameIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int NodeNameIterator::class_versions_count =
-sizeof(NodeNameIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void NodeNameIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -62,15 +56,9 @@
// <NilledIterator>
-const char* NilledIterator::class_name_str = "NilledIterator";
NilledIterator::class_factory<NilledIterator>
NilledIterator::g_class_factory;
-const serialization::ClassVersion
-NilledIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int NilledIterator::class_versions_count =
-sizeof(NilledIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void NilledIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -90,15 +78,9 @@
// <FnStringIterator>
-const char* FnStringIterator::class_name_str = "FnStringIterator";
FnStringIterator::class_factory<FnStringIterator>
FnStringIterator::g_class_factory;
-const serialization::ClassVersion
-FnStringIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnStringIterator::class_versions_count =
-sizeof(FnStringIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnStringIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -132,15 +114,9 @@
// <FnDataIterator>
-const char* FnDataIterator::class_name_str = "FnDataIterator";
FnDataIterator::class_factory<FnDataIterator>
FnDataIterator::g_class_factory;
-const serialization::ClassVersion
-FnDataIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnDataIterator::class_versions_count =
-sizeof(FnDataIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnDataIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -174,15 +150,9 @@
// <BaseUriIterator>
-const char* BaseUriIterator::class_name_str = "BaseUriIterator";
BaseUriIterator::class_factory<BaseUriIterator>
BaseUriIterator::g_class_factory;
-const serialization::ClassVersion
-BaseUriIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int BaseUriIterator::class_versions_count =
-sizeof(BaseUriIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void BaseUriIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -202,15 +172,9 @@
// <DocumentUriIterator>
-const char* DocumentUriIterator::class_name_str = "DocumentUriIterator";
DocumentUriIterator::class_factory<DocumentUriIterator>
DocumentUriIterator::g_class_factory;
-const serialization::ClassVersion
-DocumentUriIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int DocumentUriIterator::class_versions_count =
-sizeof(DocumentUriIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void DocumentUriIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -230,15 +194,9 @@
// <RootIterator>
-const char* RootIterator::class_name_str = "RootIterator";
RootIterator::class_factory<RootIterator>
RootIterator::g_class_factory;
-const serialization::ClassVersion
-RootIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int RootIterator::class_versions_count =
-sizeof(RootIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void RootIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/any_uri/pregenerated/any_uri.cpp'
--- src/runtime/any_uri/pregenerated/any_uri.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/any_uri/pregenerated/any_uri.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <ResolveUriIterator>
-const char* ResolveUriIterator::class_name_str = "ResolveUriIterator";
ResolveUriIterator::class_factory<ResolveUriIterator>
ResolveUriIterator::g_class_factory;
-const serialization::ClassVersion
-ResolveUriIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ResolveUriIterator::class_versions_count =
-sizeof(ResolveUriIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ResolveUriIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/base/binarybase.h'
--- src/runtime/base/binarybase.h 2012-03-28 05:19:57 +0000
+++ src/runtime/base/binarybase.h 2012-04-08 20:59:19 +0000
@@ -24,8 +24,7 @@
namespace zorba
{
-extern const ::zorba::serialization::ClassVersion g_BinaryBaseIterator_class_versions[];
-extern const int g_BinaryBaseIterator_class_versions_count;
+
/*******************************************************************************
Superclass for all iterators which have 2 child iterators and no additional
=== modified file 'src/runtime/base/narybase.h'
--- src/runtime/base/narybase.h 2012-03-28 05:19:57 +0000
+++ src/runtime/base/narybase.h 2012-04-08 20:59:19 +0000
@@ -28,9 +28,6 @@
class PlanIterVisitor;
-extern const ::zorba::serialization::ClassVersion g_NaryBaseIterator_class_versions[];
-extern const int g_NaryBaseIterator_class_versions_count;
-
/*******************************************************************************
Superclass for all iterators which have N child iterators and no additional
=== modified file 'src/runtime/base/noarybase.h'
--- src/runtime/base/noarybase.h 2012-03-28 05:19:57 +0000
+++ src/runtime/base/noarybase.h 2012-04-08 20:59:19 +0000
@@ -24,8 +24,6 @@
namespace zorba
{
-extern const ::zorba::serialization::ClassVersion g_NoaryBaseIterator_class_versions[];
-extern const int g_NoaryBaseIterator_class_versions_count;
/*******************************************************************************
=== modified file 'src/runtime/base/plan_iterator.cpp'
--- src/runtime/base/plan_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/base/plan_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -26,23 +26,7 @@
namespace zorba
{
-SERIALIZABLE_TEMPLATE_VERSIONS(Batcher)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(Batcher)
-
-SERIALIZABLE_TEMPLATE_VERSIONS(BinaryBaseIterator)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(BinaryBaseIterator)
-
-SERIALIZABLE_TEMPLATE_VERSIONS(NaryBaseIterator)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(NaryBaseIterator)
-
-SERIALIZABLE_TEMPLATE_VERSIONS(NoaryBaseIterator)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(NoaryBaseIterator)
-
-SERIALIZABLE_TEMPLATE_VERSIONS(UnaryBaseIterator)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(UnaryBaseIterator)
-
SERIALIZABLE_CLASS_VERSIONS(PlanIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(PlanIterator)
/*******************************************************************************
=== modified file 'src/runtime/base/plan_iterator.h'
--- src/runtime/base/plan_iterator.h 2012-03-28 05:19:57 +0000
+++ src/runtime/base/plan_iterator.h 2012-04-08 20:59:19 +0000
@@ -473,10 +473,6 @@
};
-extern const ::zorba::serialization::ClassVersion g_Batcher_class_versions[];
-extern const int g_Batcher_class_versions_count;
-
-
/*******************************************************************************
Class to implement batching
********************************************************************************/
=== modified file 'src/runtime/base/unarybase.h'
--- src/runtime/base/unarybase.h 2012-03-28 05:19:57 +0000
+++ src/runtime/base/unarybase.h 2012-04-08 20:59:19 +0000
@@ -25,9 +25,6 @@
namespace zorba
{
-extern const ::zorba::serialization::ClassVersion g_UnaryBaseIterator_class_versions[];
-extern const int g_UnaryBaseIterator_class_versions_count;
-
/*******************************************************************************
Superclass for all iterators which have one child iterator and no additional
=== modified file 'src/runtime/base64/pregenerated/base64.cpp'
--- src/runtime/base64/pregenerated/base64.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/base64/pregenerated/base64.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <Base64DecodeIterator>
-const char* Base64DecodeIterator::class_name_str = "Base64DecodeIterator";
Base64DecodeIterator::class_factory<Base64DecodeIterator>
Base64DecodeIterator::g_class_factory;
-const serialization::ClassVersion
-Base64DecodeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int Base64DecodeIterator::class_versions_count =
-sizeof(Base64DecodeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void Base64DecodeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -61,15 +55,9 @@
// <Base64EncodeIterator>
-const char* Base64EncodeIterator::class_name_str = "Base64EncodeIterator";
Base64EncodeIterator::class_factory<Base64EncodeIterator>
Base64EncodeIterator::g_class_factory;
-const serialization::ClassVersion
-Base64EncodeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int Base64EncodeIterator::class_versions_count =
-sizeof(Base64EncodeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void Base64EncodeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/booleans/BooleanImpl.cpp'
--- src/runtime/booleans/BooleanImpl.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/booleans/BooleanImpl.cpp 2012-04-08 20:59:19 +0000
@@ -44,19 +44,12 @@
namespace zorba {
SERIALIZABLE_CLASS_VERSIONS(FnBooleanIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(FnBooleanIterator)
SERIALIZABLE_CLASS_VERSIONS(OrIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(OrIterator)
SERIALIZABLE_CLASS_VERSIONS(AndIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(AndIterator)
SERIALIZABLE_CLASS_VERSIONS(CompareIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(CompareIterator)
-
-SERIALIZABLE_TEMPLATE_VERSIONS(TypedValueCompareIterator)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(TypedValueCompareIterator)
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(TypedValueCompareIterator, TypedValueCompareIterator<store::XS_DOUBLE>, 1)
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(TypedValueCompareIterator, TypedValueCompareIterator<store::XS_FLOAT>, 2)
@@ -65,7 +58,6 @@
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(TypedValueCompareIterator, TypedValueCompareIterator<store::XS_STRING>, 5)
SERIALIZABLE_CLASS_VERSIONS(AtomicValuesEquivalenceIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(AtomicValuesEquivalenceIterator)
/*******************************************************************************
=== modified file 'src/runtime/booleans/pregenerated/booleans.cpp'
--- src/runtime/booleans/pregenerated/booleans.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/booleans/pregenerated/booleans.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <IsSameNodeIterator>
-const char* IsSameNodeIterator::class_name_str = "IsSameNodeIterator";
IsSameNodeIterator::class_factory<IsSameNodeIterator>
IsSameNodeIterator::g_class_factory;
-const serialization::ClassVersion
-IsSameNodeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsSameNodeIterator::class_versions_count =
-sizeof(IsSameNodeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsSameNodeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -61,15 +55,9 @@
// <NodeBeforeIterator>
-const char* NodeBeforeIterator::class_name_str = "NodeBeforeIterator";
NodeBeforeIterator::class_factory<NodeBeforeIterator>
NodeBeforeIterator::g_class_factory;
-const serialization::ClassVersion
-NodeBeforeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int NodeBeforeIterator::class_versions_count =
-sizeof(NodeBeforeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void NodeBeforeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -89,15 +77,9 @@
// <NodeAfterIterator>
-const char* NodeAfterIterator::class_name_str = "NodeAfterIterator";
NodeAfterIterator::class_factory<NodeAfterIterator>
NodeAfterIterator::g_class_factory;
-const serialization::ClassVersion
-NodeAfterIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int NodeAfterIterator::class_versions_count =
-sizeof(NodeAfterIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void NodeAfterIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/collections/collections_base.cpp'
--- src/runtime/collections/collections_base.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/collections/collections_base.cpp 2012-04-08 20:59:19 +0000
@@ -22,9 +22,6 @@
namespace zorba {
-SERIALIZABLE_TEMPLATE_VERSIONS(ZorbaCollectionIteratorHelper)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(ZorbaCollectionIteratorHelper)
-
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS2(ZorbaCollectionIteratorHelper,
ZorbaCollectionIteratorHelper<ZorbaInsertNodesIterator, PlanIteratorState>, 1)
=== modified file 'src/runtime/collections/collections_impl.cpp'
--- src/runtime/collections/collections_impl.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/collections/collections_impl.cpp 2012-04-08 20:59:19 +0000
@@ -326,7 +326,6 @@
SERIALIZABLE_CLASS_VERSIONS(CountCollectionIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(CountCollectionIterator)
NARY_ACCEPT(CountCollectionIterator);
=== modified file 'src/runtime/collections/pregenerated/collections.cpp'
--- src/runtime/collections/pregenerated/collections.cpp 2012-03-28 23:58:23 +0000
+++ src/runtime/collections/pregenerated/collections.cpp 2012-04-08 20:59:19 +0000
@@ -34,15 +34,9 @@
namespace zorba {
// <FnCollectionIterator>
-const char* FnCollectionIterator::class_name_str = "FnCollectionIterator";
FnCollectionIterator::class_factory<FnCollectionIterator>
FnCollectionIterator::g_class_factory;
-const serialization::ClassVersion
-FnCollectionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnCollectionIterator::class_versions_count =
-sizeof(FnCollectionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnCollectionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -64,15 +58,9 @@
// <ZorbaCollectionIterator>
-const char* ZorbaCollectionIterator::class_name_str = "ZorbaCollectionIterator";
ZorbaCollectionIterator::class_factory<ZorbaCollectionIterator>
ZorbaCollectionIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaCollectionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaCollectionIterator::class_versions_count =
-sizeof(ZorbaCollectionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaCollectionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -94,15 +82,9 @@
// <ZorbaIndexOfIterator>
-const char* ZorbaIndexOfIterator::class_name_str = "ZorbaIndexOfIterator";
ZorbaIndexOfIterator::class_factory<ZorbaIndexOfIterator>
ZorbaIndexOfIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaIndexOfIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaIndexOfIterator::class_versions_count =
-sizeof(ZorbaIndexOfIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaIndexOfIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -122,15 +104,9 @@
// <ZorbaCreateCollectionIterator>
-const char* ZorbaCreateCollectionIterator::class_name_str = "ZorbaCreateCollectionIterator";
ZorbaCreateCollectionIterator::class_factory<ZorbaCreateCollectionIterator>
ZorbaCreateCollectionIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaCreateCollectionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaCreateCollectionIterator::class_versions_count =
-sizeof(ZorbaCreateCollectionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaCreateCollectionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -150,15 +126,9 @@
// <ZorbaDeleteCollectionIterator>
-const char* ZorbaDeleteCollectionIterator::class_name_str = "ZorbaDeleteCollectionIterator";
ZorbaDeleteCollectionIterator::class_factory<ZorbaDeleteCollectionIterator>
ZorbaDeleteCollectionIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaDeleteCollectionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaDeleteCollectionIterator::class_versions_count =
-sizeof(ZorbaDeleteCollectionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaDeleteCollectionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -178,15 +148,9 @@
// <ZorbaInsertNodesIterator>
-const char* ZorbaInsertNodesIterator::class_name_str = "ZorbaInsertNodesIterator";
ZorbaInsertNodesIterator::class_factory<ZorbaInsertNodesIterator>
ZorbaInsertNodesIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaInsertNodesIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaInsertNodesIterator::class_versions_count =
-sizeof(ZorbaInsertNodesIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaInsertNodesIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -206,15 +170,9 @@
// <ZorbaInsertNodesFirstIterator>
-const char* ZorbaInsertNodesFirstIterator::class_name_str = "ZorbaInsertNodesFirstIterator";
ZorbaInsertNodesFirstIterator::class_factory<ZorbaInsertNodesFirstIterator>
ZorbaInsertNodesFirstIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaInsertNodesFirstIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaInsertNodesFirstIterator::class_versions_count =
-sizeof(ZorbaInsertNodesFirstIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaInsertNodesFirstIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -234,15 +192,9 @@
// <ZorbaInsertNodesLastIterator>
-const char* ZorbaInsertNodesLastIterator::class_name_str = "ZorbaInsertNodesLastIterator";
ZorbaInsertNodesLastIterator::class_factory<ZorbaInsertNodesLastIterator>
ZorbaInsertNodesLastIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaInsertNodesLastIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaInsertNodesLastIterator::class_versions_count =
-sizeof(ZorbaInsertNodesLastIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaInsertNodesLastIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -262,15 +214,9 @@
// <ZorbaInsertNodesBeforeIterator>
-const char* ZorbaInsertNodesBeforeIterator::class_name_str = "ZorbaInsertNodesBeforeIterator";
ZorbaInsertNodesBeforeIterator::class_factory<ZorbaInsertNodesBeforeIterator>
ZorbaInsertNodesBeforeIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaInsertNodesBeforeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaInsertNodesBeforeIterator::class_versions_count =
-sizeof(ZorbaInsertNodesBeforeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaInsertNodesBeforeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -290,15 +236,9 @@
// <ZorbaInsertNodesAfterIterator>
-const char* ZorbaInsertNodesAfterIterator::class_name_str = "ZorbaInsertNodesAfterIterator";
ZorbaInsertNodesAfterIterator::class_factory<ZorbaInsertNodesAfterIterator>
ZorbaInsertNodesAfterIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaInsertNodesAfterIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaInsertNodesAfterIterator::class_versions_count =
-sizeof(ZorbaInsertNodesAfterIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaInsertNodesAfterIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -318,15 +258,9 @@
// <ZorbaApplyInsertNodesIterator>
-const char* ZorbaApplyInsertNodesIterator::class_name_str = "ZorbaApplyInsertNodesIterator";
ZorbaApplyInsertNodesIterator::class_factory<ZorbaApplyInsertNodesIterator>
ZorbaApplyInsertNodesIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaApplyInsertNodesIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaApplyInsertNodesIterator::class_versions_count =
-sizeof(ZorbaApplyInsertNodesIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaApplyInsertNodesIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -348,15 +282,9 @@
// <ZorbaApplyInsertNodesFirstIterator>
-const char* ZorbaApplyInsertNodesFirstIterator::class_name_str = "ZorbaApplyInsertNodesFirstIterator";
ZorbaApplyInsertNodesFirstIterator::class_factory<ZorbaApplyInsertNodesFirstIterator>
ZorbaApplyInsertNodesFirstIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaApplyInsertNodesFirstIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaApplyInsertNodesFirstIterator::class_versions_count =
-sizeof(ZorbaApplyInsertNodesFirstIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaApplyInsertNodesFirstIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -378,15 +306,9 @@
// <ZorbaApplyInsertNodesLastIterator>
-const char* ZorbaApplyInsertNodesLastIterator::class_name_str = "ZorbaApplyInsertNodesLastIterator";
ZorbaApplyInsertNodesLastIterator::class_factory<ZorbaApplyInsertNodesLastIterator>
ZorbaApplyInsertNodesLastIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaApplyInsertNodesLastIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaApplyInsertNodesLastIterator::class_versions_count =
-sizeof(ZorbaApplyInsertNodesLastIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaApplyInsertNodesLastIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -408,15 +330,9 @@
// <ZorbaApplyInsertNodesBeforeIterator>
-const char* ZorbaApplyInsertNodesBeforeIterator::class_name_str = "ZorbaApplyInsertNodesBeforeIterator";
ZorbaApplyInsertNodesBeforeIterator::class_factory<ZorbaApplyInsertNodesBeforeIterator>
ZorbaApplyInsertNodesBeforeIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaApplyInsertNodesBeforeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaApplyInsertNodesBeforeIterator::class_versions_count =
-sizeof(ZorbaApplyInsertNodesBeforeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaApplyInsertNodesBeforeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -438,15 +354,9 @@
// <ZorbaApplyInsertNodesAfterIterator>
-const char* ZorbaApplyInsertNodesAfterIterator::class_name_str = "ZorbaApplyInsertNodesAfterIterator";
ZorbaApplyInsertNodesAfterIterator::class_factory<ZorbaApplyInsertNodesAfterIterator>
ZorbaApplyInsertNodesAfterIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaApplyInsertNodesAfterIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaApplyInsertNodesAfterIterator::class_versions_count =
-sizeof(ZorbaApplyInsertNodesAfterIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaApplyInsertNodesAfterIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -468,15 +378,9 @@
// <ZorbaDeleteNodesIterator>
-const char* ZorbaDeleteNodesIterator::class_name_str = "ZorbaDeleteNodesIterator";
ZorbaDeleteNodesIterator::class_factory<ZorbaDeleteNodesIterator>
ZorbaDeleteNodesIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaDeleteNodesIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaDeleteNodesIterator::class_versions_count =
-sizeof(ZorbaDeleteNodesIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaDeleteNodesIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -496,15 +400,9 @@
// <ZorbaDeleteNodesFirstIterator>
-const char* ZorbaDeleteNodesFirstIterator::class_name_str = "ZorbaDeleteNodesFirstIterator";
ZorbaDeleteNodesFirstIterator::class_factory<ZorbaDeleteNodesFirstIterator>
ZorbaDeleteNodesFirstIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaDeleteNodesFirstIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaDeleteNodesFirstIterator::class_versions_count =
-sizeof(ZorbaDeleteNodesFirstIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaDeleteNodesFirstIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -524,15 +422,9 @@
// <ZorbaDeleteNodesLastIterator>
-const char* ZorbaDeleteNodesLastIterator::class_name_str = "ZorbaDeleteNodesLastIterator";
ZorbaDeleteNodesLastIterator::class_factory<ZorbaDeleteNodesLastIterator>
ZorbaDeleteNodesLastIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaDeleteNodesLastIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaDeleteNodesLastIterator::class_versions_count =
-sizeof(ZorbaDeleteNodesLastIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaDeleteNodesLastIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -552,15 +444,9 @@
// <ZorbaTruncateCollectionIterator>
-const char* ZorbaTruncateCollectionIterator::class_name_str = "ZorbaTruncateCollectionIterator";
ZorbaTruncateCollectionIterator::class_factory<ZorbaTruncateCollectionIterator>
ZorbaTruncateCollectionIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaTruncateCollectionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaTruncateCollectionIterator::class_versions_count =
-sizeof(ZorbaTruncateCollectionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaTruncateCollectionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -580,15 +466,9 @@
// <ZorbaCollectionNameIterator>
-const char* ZorbaCollectionNameIterator::class_name_str = "ZorbaCollectionNameIterator";
ZorbaCollectionNameIterator::class_factory<ZorbaCollectionNameIterator>
ZorbaCollectionNameIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaCollectionNameIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaCollectionNameIterator::class_versions_count =
-sizeof(ZorbaCollectionNameIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaCollectionNameIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -608,15 +488,9 @@
// <IsAvailableCollectionIterator>
-const char* IsAvailableCollectionIterator::class_name_str = "IsAvailableCollectionIterator";
IsAvailableCollectionIterator::class_factory<IsAvailableCollectionIterator>
IsAvailableCollectionIterator::g_class_factory;
-const serialization::ClassVersion
-IsAvailableCollectionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsAvailableCollectionIterator::class_versions_count =
-sizeof(IsAvailableCollectionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsAvailableCollectionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -636,15 +510,9 @@
// <AvailableCollectionsIterator>
-const char* AvailableCollectionsIterator::class_name_str = "AvailableCollectionsIterator";
AvailableCollectionsIterator::class_factory<AvailableCollectionsIterator>
AvailableCollectionsIterator::g_class_factory;
-const serialization::ClassVersion
-AvailableCollectionsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int AvailableCollectionsIterator::class_versions_count =
-sizeof(AvailableCollectionsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void AvailableCollectionsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -666,15 +534,9 @@
// <IsAvailableIndexIterator>
-const char* IsAvailableIndexIterator::class_name_str = "IsAvailableIndexIterator";
IsAvailableIndexIterator::class_factory<IsAvailableIndexIterator>
IsAvailableIndexIterator::g_class_factory;
-const serialization::ClassVersion
-IsAvailableIndexIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsAvailableIndexIterator::class_versions_count =
-sizeof(IsAvailableIndexIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsAvailableIndexIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -694,15 +556,9 @@
// <AvailableIndexesIterator>
-const char* AvailableIndexesIterator::class_name_str = "AvailableIndexesIterator";
AvailableIndexesIterator::class_factory<AvailableIndexesIterator>
AvailableIndexesIterator::g_class_factory;
-const serialization::ClassVersion
-AvailableIndexesIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int AvailableIndexesIterator::class_versions_count =
-sizeof(AvailableIndexesIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void AvailableIndexesIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -724,15 +580,9 @@
// <IsActivatedICIterator>
-const char* IsActivatedICIterator::class_name_str = "IsActivatedICIterator";
IsActivatedICIterator::class_factory<IsActivatedICIterator>
IsActivatedICIterator::g_class_factory;
-const serialization::ClassVersion
-IsActivatedICIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsActivatedICIterator::class_versions_count =
-sizeof(IsActivatedICIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsActivatedICIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -752,15 +602,9 @@
// <ActivatedICsIterator>
-const char* ActivatedICsIterator::class_name_str = "ActivatedICsIterator";
ActivatedICsIterator::class_factory<ActivatedICsIterator>
ActivatedICsIterator::g_class_factory;
-const serialization::ClassVersion
-ActivatedICsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ActivatedICsIterator::class_versions_count =
-sizeof(ActivatedICsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ActivatedICsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -782,15 +626,9 @@
// <IsDeclaredCollectionIterator>
-const char* IsDeclaredCollectionIterator::class_name_str = "IsDeclaredCollectionIterator";
IsDeclaredCollectionIterator::class_factory<IsDeclaredCollectionIterator>
IsDeclaredCollectionIterator::g_class_factory;
-const serialization::ClassVersion
-IsDeclaredCollectionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsDeclaredCollectionIterator::class_versions_count =
-sizeof(IsDeclaredCollectionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsDeclaredCollectionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -810,15 +648,9 @@
// <DeclaredCollectionsIterator>
-const char* DeclaredCollectionsIterator::class_name_str = "DeclaredCollectionsIterator";
DeclaredCollectionsIterator::class_factory<DeclaredCollectionsIterator>
DeclaredCollectionsIterator::g_class_factory;
-const serialization::ClassVersion
-DeclaredCollectionsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int DeclaredCollectionsIterator::class_versions_count =
-sizeof(DeclaredCollectionsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void DeclaredCollectionsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -840,15 +672,9 @@
// <IsDeclaredIndexIterator>
-const char* IsDeclaredIndexIterator::class_name_str = "IsDeclaredIndexIterator";
IsDeclaredIndexIterator::class_factory<IsDeclaredIndexIterator>
IsDeclaredIndexIterator::g_class_factory;
-const serialization::ClassVersion
-IsDeclaredIndexIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsDeclaredIndexIterator::class_versions_count =
-sizeof(IsDeclaredIndexIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsDeclaredIndexIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -868,15 +694,9 @@
// <DeclaredIndexesIterator>
-const char* DeclaredIndexesIterator::class_name_str = "DeclaredIndexesIterator";
DeclaredIndexesIterator::class_factory<DeclaredIndexesIterator>
DeclaredIndexesIterator::g_class_factory;
-const serialization::ClassVersion
-DeclaredIndexesIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int DeclaredIndexesIterator::class_versions_count =
-sizeof(DeclaredIndexesIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void DeclaredIndexesIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -903,15 +723,9 @@
// <IsDeclaredICIterator>
-const char* IsDeclaredICIterator::class_name_str = "IsDeclaredICIterator";
IsDeclaredICIterator::class_factory<IsDeclaredICIterator>
IsDeclaredICIterator::g_class_factory;
-const serialization::ClassVersion
-IsDeclaredICIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsDeclaredICIterator::class_versions_count =
-sizeof(IsDeclaredICIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsDeclaredICIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -931,15 +745,9 @@
// <DeclaredICsIterator>
-const char* DeclaredICsIterator::class_name_str = "DeclaredICsIterator";
DeclaredICsIterator::class_factory<DeclaredICsIterator>
DeclaredICsIterator::g_class_factory;
-const serialization::ClassVersion
-DeclaredICsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int DeclaredICsIterator::class_versions_count =
-sizeof(DeclaredICsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void DeclaredICsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/context/pregenerated/context.cpp'
--- src/runtime/context/pregenerated/context.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/context/pregenerated/context.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <CurrentDateTimeIterator>
-const char* CurrentDateTimeIterator::class_name_str = "CurrentDateTimeIterator";
CurrentDateTimeIterator::class_factory<CurrentDateTimeIterator>
CurrentDateTimeIterator::g_class_factory;
-const serialization::ClassVersion
-CurrentDateTimeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int CurrentDateTimeIterator::class_versions_count =
-sizeof(CurrentDateTimeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void CurrentDateTimeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -61,15 +55,9 @@
// <CurrentDateIterator>
-const char* CurrentDateIterator::class_name_str = "CurrentDateIterator";
CurrentDateIterator::class_factory<CurrentDateIterator>
CurrentDateIterator::g_class_factory;
-const serialization::ClassVersion
-CurrentDateIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int CurrentDateIterator::class_versions_count =
-sizeof(CurrentDateIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void CurrentDateIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -89,15 +77,9 @@
// <CurrentTimeIterator>
-const char* CurrentTimeIterator::class_name_str = "CurrentTimeIterator";
CurrentTimeIterator::class_factory<CurrentTimeIterator>
CurrentTimeIterator::g_class_factory;
-const serialization::ClassVersion
-CurrentTimeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int CurrentTimeIterator::class_versions_count =
-sizeof(CurrentTimeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void CurrentTimeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -117,15 +99,9 @@
// <ImplicitTimezoneIterator>
-const char* ImplicitTimezoneIterator::class_name_str = "ImplicitTimezoneIterator";
ImplicitTimezoneIterator::class_factory<ImplicitTimezoneIterator>
ImplicitTimezoneIterator::g_class_factory;
-const serialization::ClassVersion
-ImplicitTimezoneIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ImplicitTimezoneIterator::class_versions_count =
-sizeof(ImplicitTimezoneIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ImplicitTimezoneIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -145,15 +121,9 @@
// <DefaultCollationIterator>
-const char* DefaultCollationIterator::class_name_str = "DefaultCollationIterator";
DefaultCollationIterator::class_factory<DefaultCollationIterator>
DefaultCollationIterator::g_class_factory;
-const serialization::ClassVersion
-DefaultCollationIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int DefaultCollationIterator::class_versions_count =
-sizeof(DefaultCollationIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void DefaultCollationIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/core/apply_updates.cpp'
--- src/runtime/core/apply_updates.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/apply_updates.cpp 2012-04-08 20:59:19 +0000
@@ -42,7 +42,6 @@
{
SERIALIZABLE_CLASS_VERSIONS(ApplyIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(ApplyIterator)
/*******************************************************************************
=== modified file 'src/runtime/core/arithmetic_impl.cpp'
--- src/runtime/core/arithmetic_impl.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/arithmetic_impl.cpp 2012-04-08 20:59:19 +0000
@@ -43,8 +43,6 @@
namespace zorba {
-SERIALIZABLE_TEMPLATE_VERSIONS(GenericArithIterator)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(GenericArithIterator)
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(GenericArithIterator, GenericArithIterator<AddOperation>, 1)
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(GenericArithIterator, GenericArithIterator<SubtractOperation>, 2)
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(GenericArithIterator, GenericArithIterator<MultiplyOperation>, 3)
=== modified file 'src/runtime/core/constructors.cpp'
--- src/runtime/core/constructors.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/constructors.cpp 2012-04-08 20:59:19 +0000
@@ -49,28 +49,20 @@
{
SERIALIZABLE_CLASS_VERSIONS(DocumentIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(DocumentIterator)
SERIALIZABLE_CLASS_VERSIONS(ElementIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(ElementIterator)
SERIALIZABLE_CLASS_VERSIONS(AttributeIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(AttributeIterator)
SERIALIZABLE_CLASS_VERSIONS(NameCastIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(NameCastIterator)
SERIALIZABLE_CLASS_VERSIONS(CommentIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(CommentIterator)
SERIALIZABLE_CLASS_VERSIONS(PiIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(PiIterator)
SERIALIZABLE_CLASS_VERSIONS(TextIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(TextIterator)
SERIALIZABLE_CLASS_VERSIONS(EnclosedIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(EnclosedIterator)
/*******************************************************************************
=== modified file 'src/runtime/core/flwor_iterator.cpp'
--- src/runtime/core/flwor_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/flwor_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -51,19 +51,15 @@
{
SERIALIZABLE_CLASS_VERSIONS(OrderByClause)
-END_SERIALIZABLE_CLASS_VERSIONS(OrderByClause)
SERIALIZABLE_CLASS_VERSIONS(MaterializeClause)
-END_SERIALIZABLE_CLASS_VERSIONS(MaterializeClause)
SERIALIZABLE_CLASS_VERSIONS(GroupByClause)
-END_SERIALIZABLE_CLASS_VERSIONS(GroupByClause)
SERIALIZABLE_CLASS_VERSIONS(ForLetClause)
-END_SERIALIZABLE_CLASS_VERSIONS(ForLetClause)
SERIALIZABLE_CLASS_VERSIONS(FLWORIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(FLWORIterator)
+
/////////////////////////////////////////////////////////////////////////////////
// //
=== modified file 'src/runtime/core/fncall_iterator.cpp'
--- src/runtime/core/fncall_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/fncall_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -82,10 +82,8 @@
namespace zorba {
SERIALIZABLE_CLASS_VERSIONS(UDFunctionCallIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(UDFunctionCallIterator)
SERIALIZABLE_CLASS_VERSIONS(ExtFunctionCallIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(ExtFunctionCallIterator)
=== modified file 'src/runtime/core/gflwor/common.cpp'
--- src/runtime/core/gflwor/common.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/gflwor/common.cpp 2012-04-08 20:59:19 +0000
@@ -28,10 +28,8 @@
{
SERIALIZABLE_CLASS_VERSIONS(GroupingSpec)
-END_SERIALIZABLE_CLASS_VERSIONS(GroupingSpec)
SERIALIZABLE_CLASS_VERSIONS(NonGroupingSpec)
-END_SERIALIZABLE_CLASS_VERSIONS(NonGroupingSpec)
/////////////////////////////////////////////////////////////////////////////////
=== modified file 'src/runtime/core/gflwor/count_iterator.cpp'
--- src/runtime/core/gflwor/count_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/gflwor/count_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -31,7 +31,7 @@
namespace flwor
{
SERIALIZABLE_CLASS_VERSIONS(CountIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(CountIterator)
+
/////////////////////////////////////////////////////////////////////////////////
// //
=== modified file 'src/runtime/core/gflwor/for_iterator.cpp'
--- src/runtime/core/gflwor/for_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/gflwor/for_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -26,7 +26,7 @@
namespace flwor
{
SERIALIZABLE_CLASS_VERSIONS(ForIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(ForIterator)
+
/////////////////////////////////////////////////////////////////////////////////
// //
=== modified file 'src/runtime/core/gflwor/groupby_iterator.cpp'
--- src/runtime/core/gflwor/groupby_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/gflwor/groupby_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -39,7 +39,7 @@
{
SERIALIZABLE_CLASS_VERSIONS(GroupByIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(GroupByIterator)
+
/////////////////////////////////////////////////////////////////////////////////
// //
=== modified file 'src/runtime/core/gflwor/let_iterator.cpp'
--- src/runtime/core/gflwor/let_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/gflwor/let_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -27,7 +27,6 @@
namespace flwor
{
SERIALIZABLE_CLASS_VERSIONS(LetIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(LetIterator)
=== modified file 'src/runtime/core/gflwor/orderby_iterator.cpp'
--- src/runtime/core/gflwor/orderby_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/gflwor/orderby_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -46,10 +46,9 @@
{
SERIALIZABLE_CLASS_VERSIONS(OrderByIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(OrderByIterator)
SERIALIZABLE_CLASS_VERSIONS(OrderSpec)
-END_SERIALIZABLE_CLASS_VERSIONS(OrderSpec)
+
/////////////////////////////////////////////////////////////////////////////////
// //
=== modified file 'src/runtime/core/gflwor/outerfor_iterator.cpp'
--- src/runtime/core/gflwor/outerfor_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/gflwor/outerfor_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -33,7 +33,7 @@
namespace flwor
{
SERIALIZABLE_CLASS_VERSIONS(OuterForIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(OuterForIterator)
+
/////////////////////////////////////////////////////////////////////////////////
// //
=== modified file 'src/runtime/core/gflwor/tuplesource_iterator.cpp'
--- src/runtime/core/gflwor/tuplesource_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/gflwor/tuplesource_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -36,7 +36,6 @@
{
SERIALIZABLE_CLASS_VERSIONS(TupleSourceIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(TupleSourceIterator)
bool TupleSourceIterator::nextImpl(store::Item_t& aResult, PlanState& aPlanState) const
=== modified file 'src/runtime/core/gflwor/tuplestream_iterator.cpp'
--- src/runtime/core/gflwor/tuplestream_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/gflwor/tuplestream_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -33,7 +33,7 @@
namespace flwor
{
SERIALIZABLE_CLASS_VERSIONS(TupleStreamIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(TupleStreamIterator)
+
TupleStreamIterator::TupleStreamIterator(
static_context* sctx,
=== modified file 'src/runtime/core/gflwor/where_iterator.cpp'
--- src/runtime/core/gflwor/where_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/gflwor/where_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -28,7 +28,6 @@
{
SERIALIZABLE_CLASS_VERSIONS(WhereIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(WhereIterator)
/////////////////////////////////////////////////////////////////////////////////
=== modified file 'src/runtime/core/gflwor/window_iterator.cpp'
--- src/runtime/core/gflwor/window_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/gflwor/window_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -32,16 +32,12 @@
{
SERIALIZABLE_CLASS_VERSIONS(StartClause)
-END_SERIALIZABLE_CLASS_VERSIONS(StartClause)
SERIALIZABLE_CLASS_VERSIONS(EndClause)
-END_SERIALIZABLE_CLASS_VERSIONS(EndClause)
SERIALIZABLE_CLASS_VERSIONS(WindowIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(WindowIterator)
SERIALIZABLE_CLASS_VERSIONS(WindowVars)
-END_SERIALIZABLE_CLASS_VERSIONS(WindowVars)
/////////////////////////////////////////////////////////////////////////////////
=== modified file 'src/runtime/core/internal_operators.cpp'
--- src/runtime/core/internal_operators.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/internal_operators.cpp 2012-04-08 20:59:19 +0000
@@ -30,10 +30,9 @@
namespace zorba {
SERIALIZABLE_CLASS_VERSIONS(HoistIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(HoistIterator)
SERIALIZABLE_CLASS_VERSIONS(UnhoistIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(UnhoistIterator)
+
void HoistIteratorState::init(PlanState& planState)
{
=== modified file 'src/runtime/core/item_iterator.cpp'
--- src/runtime/core/item_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/item_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -24,17 +24,14 @@
#include "store/api/item.h"
-using namespace std;
+
namespace zorba
{
SERIALIZABLE_CLASS_VERSIONS(EmptyIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(EmptyIterator)
SERIALIZABLE_CLASS_VERSIONS(SingletonIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(SingletonIterator)
SERIALIZABLE_CLASS_VERSIONS(IfThenElseIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(IfThenElseIterator)
/*******************************************************************************
@@ -55,7 +52,7 @@
bool SingletonIterator::nextImpl(store::Item_t& result, PlanState& planState) const
{
PlanIteratorState* state;
- DEFAULT_STACK_INIT ( PlanIteratorState, state, planState );
+ DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
result = theValue;
STACK_PUSH ( result != NULL, state );
=== modified file 'src/runtime/core/nodeid_iterators.cpp'
--- src/runtime/core/nodeid_iterators.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/nodeid_iterators.cpp 2012-04-08 20:59:19 +0000
@@ -30,10 +30,9 @@
namespace zorba
{
SERIALIZABLE_CLASS_VERSIONS(NodeDistinctIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(NodeDistinctIterator)
SERIALIZABLE_CLASS_VERSIONS(NodeSortIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(NodeSortIterator)
+
/*******************************************************************************
=== modified file 'src/runtime/core/path_iterators.cpp'
--- src/runtime/core/path_iterators.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/path_iterators.cpp 2012-04-08 20:59:19 +0000
@@ -42,11 +42,7 @@
namespace zorba
{
- //SERIALIZABLE_CLASS_VERSIONS(AxisIteratorHelper)
- //END_SERIALIZABLE_CLASS_VERSIONS(AxisIteratorHelper)
-SERIALIZABLE_TEMPLATE_VERSIONS(AxisIterator)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(AxisIterator)
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS2(AxisIterator, AxisIterator<SelfAxisIterator, SelfAxisState>, 1)
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS2(AxisIterator, AxisIterator<AttributeAxisIterator, AttributeAxisState>, 2)
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS2(AxisIterator, AxisIterator<ParentAxisIterator, ParentAxisState>, 3)
@@ -65,52 +61,36 @@
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS2(AxisIterator, AxisIterator<FollowingAxisIterator,FollowingAxisState>, 16)
SERIALIZABLE_CLASS_VERSIONS(SelfAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(SelfAxisIterator)
SERIALIZABLE_CLASS_VERSIONS(AttributeAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(AttributeAxisIterator)
SERIALIZABLE_CLASS_VERSIONS(ParentAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(ParentAxisIterator)
SERIALIZABLE_CLASS_VERSIONS(AncestorAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(AncestorAxisIterator)
SERIALIZABLE_CLASS_VERSIONS(AncestorReverseAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(AncestorReverseAxisIterator)
SERIALIZABLE_CLASS_VERSIONS(AncestorSelfAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(AncestorSelfAxisIterator)
SERIALIZABLE_CLASS_VERSIONS(AncestorSelfReverseAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(AncestorSelfReverseAxisIterator)
SERIALIZABLE_CLASS_VERSIONS(RSiblingAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(RSiblingAxisIterator)
SERIALIZABLE_CLASS_VERSIONS(LSiblingAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(LSiblingAxisIterator)
SERIALIZABLE_CLASS_VERSIONS(LSiblingReverseAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(LSiblingReverseAxisIterator)
SERIALIZABLE_CLASS_VERSIONS(ChildAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(ChildAxisIterator)
SERIALIZABLE_CLASS_VERSIONS(DescendantAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(DescendantAxisIterator)
SERIALIZABLE_CLASS_VERSIONS(DescendantSelfAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(DescendantSelfAxisIterator)
SERIALIZABLE_CLASS_VERSIONS(PrecedingAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(PrecedingAxisIterator)
SERIALIZABLE_CLASS_VERSIONS(PrecedingReverseAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(PrecedingReverseAxisIterator)
SERIALIZABLE_CLASS_VERSIONS(FollowingAxisIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(FollowingAxisIterator)
UNARY_ACCEPT(SelfAxisIterator);
=== modified file 'src/runtime/core/sequencetypes.cpp'
--- src/runtime/core/sequencetypes.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/sequencetypes.cpp 2012-04-08 20:59:19 +0000
@@ -33,27 +33,21 @@
#include "store/api/item_factory.h"
-using namespace std;
-
namespace zorba
{
+
SERIALIZABLE_CLASS_VERSIONS(InstanceOfIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(InstanceOfIterator)
SERIALIZABLE_CLASS_VERSIONS(CastIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(CastIterator)
SERIALIZABLE_CLASS_VERSIONS(CastableIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(CastableIterator)
SERIALIZABLE_CLASS_VERSIONS(PromoteIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(PromoteIterator)
SERIALIZABLE_CLASS_VERSIONS(TreatIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(TreatIterator)
SERIALIZABLE_CLASS_VERSIONS(EitherNodesOrAtomicsIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(EitherNodesOrAtomicsIterator)
+
/*******************************************************************************
=== modified file 'src/runtime/core/trycatch.cpp'
--- src/runtime/core/trycatch.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/trycatch.cpp 2012-04-08 20:59:19 +0000
@@ -38,20 +38,22 @@
namespace zorba {
SERIALIZABLE_CLASS_VERSIONS(TryCatchIterator::CatchClause)
-END_SERIALIZABLE_CLASS_VERSIONS(TryCatchIterator::CatchClause)
SERIALIZABLE_CLASS_VERSIONS(TryCatchIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(TryCatchIterator)
TryCatchIteratorState::TryCatchIteratorState()
- : theTempIterator(NULL),
+ :
+ theTempIterator(NULL),
theCatchIterator(NULL)
-{}
+{
+}
+
TryCatchIteratorState::~TryCatchIteratorState()
{
- if (theTempIterator != NULL) {
+ if (theTempIterator != NULL)
+ {
theTempIterator->close();
theTempIterator = NULL;
}
@@ -61,16 +63,19 @@
for (; lIters != lItersEnd; ++lIters) {
(*lIters)->close();
}
-
}
+
void
-TryCatchIteratorState::init(PlanState& planState) {
+TryCatchIteratorState::init(PlanState& planState)
+{
PlanIteratorState::init(planState);
}
+
void
-TryCatchIteratorState::reset(PlanState& planState) {
+TryCatchIteratorState::reset(PlanState& planState)
+{
PlanIteratorState::reset(planState);
if ( theTargetSequence )
theTargetSequence->purge(); // release the target sequence
=== modified file 'src/runtime/core/var_iterators.cpp'
--- src/runtime/core/var_iterators.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/core/var_iterators.cpp 2012-04-08 20:59:19 +0000
@@ -41,22 +41,17 @@
{
SERIALIZABLE_CLASS_VERSIONS(CtxVarIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(CtxVarIterator)
SERIALIZABLE_CLASS_VERSIONS(CtxVarDeclareIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(CtxVarDeclareIterator)
SERIALIZABLE_CLASS_VERSIONS(CtxVarAssignIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(CtxVarAssignIterator)
SERIALIZABLE_CLASS_VERSIONS(CtxVarIsSetIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(CtxVarIsSetIterator)
SERIALIZABLE_CLASS_VERSIONS(ForVarIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(ForVarIterator)
SERIALIZABLE_CLASS_VERSIONS(LetVarIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(LetVarIterator)
+
/////////////////////////////////////////////////////////////////////////////////
// //
=== modified file 'src/runtime/debug/pregenerated/debug_iterator.cpp'
--- src/runtime/debug/pregenerated/debug_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/debug/pregenerated/debug_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -34,15 +34,9 @@
#ifdef ZORBA_WITH_DEBUGGER
// <DebugIterator>
-const char* DebugIterator::class_name_str = "DebugIterator";
DebugIterator::class_factory<DebugIterator>
DebugIterator::g_class_factory;
-const serialization::ClassVersion
-DebugIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int DebugIterator::class_versions_count =
-sizeof(DebugIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void DebugIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/durations_dates_times/DurationsDatesTimesImpl.cpp'
--- src/runtime/durations_dates_times/DurationsDatesTimesImpl.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/durations_dates_times/DurationsDatesTimesImpl.cpp 2012-04-08 20:59:19 +0000
@@ -42,17 +42,12 @@
namespace zorba
{
SERIALIZABLE_CLASS_VERSIONS(FnDateTimeConstructorIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(FnDateTimeConstructorIterator)
SERIALIZABLE_CLASS_VERSIONS(FnFormatDateTimeIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(FnFormatDateTimeIterator)
-
SERIALIZABLE_CLASS_VERSIONS(FnAdjustToTimeZoneIterator_1)
-END_SERIALIZABLE_CLASS_VERSIONS(FnAdjustToTimeZoneIterator_1)
SERIALIZABLE_CLASS_VERSIONS(FnAdjustToTimeZoneIterator_2)
-END_SERIALIZABLE_CLASS_VERSIONS(FnAdjustToTimeZoneIterator_2)
BINARY_ACCEPT(FnDateTimeConstructorIterator);
=== modified file 'src/runtime/durations_dates_times/pregenerated/durations_dates_times.cpp'
--- src/runtime/durations_dates_times/pregenerated/durations_dates_times.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/durations_dates_times/pregenerated/durations_dates_times.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <YearsFromDurationIterator>
-const char* YearsFromDurationIterator::class_name_str = "YearsFromDurationIterator";
YearsFromDurationIterator::class_factory<YearsFromDurationIterator>
YearsFromDurationIterator::g_class_factory;
-const serialization::ClassVersion
-YearsFromDurationIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int YearsFromDurationIterator::class_versions_count =
-sizeof(YearsFromDurationIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void YearsFromDurationIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -61,15 +55,9 @@
// <MonthsFromDurationIterator>
-const char* MonthsFromDurationIterator::class_name_str = "MonthsFromDurationIterator";
MonthsFromDurationIterator::class_factory<MonthsFromDurationIterator>
MonthsFromDurationIterator::g_class_factory;
-const serialization::ClassVersion
-MonthsFromDurationIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int MonthsFromDurationIterator::class_versions_count =
-sizeof(MonthsFromDurationIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void MonthsFromDurationIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -89,15 +77,9 @@
// <DaysFromDurationIterator>
-const char* DaysFromDurationIterator::class_name_str = "DaysFromDurationIterator";
DaysFromDurationIterator::class_factory<DaysFromDurationIterator>
DaysFromDurationIterator::g_class_factory;
-const serialization::ClassVersion
-DaysFromDurationIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int DaysFromDurationIterator::class_versions_count =
-sizeof(DaysFromDurationIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void DaysFromDurationIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -117,15 +99,9 @@
// <HoursFromDurationIterator>
-const char* HoursFromDurationIterator::class_name_str = "HoursFromDurationIterator";
HoursFromDurationIterator::class_factory<HoursFromDurationIterator>
HoursFromDurationIterator::g_class_factory;
-const serialization::ClassVersion
-HoursFromDurationIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int HoursFromDurationIterator::class_versions_count =
-sizeof(HoursFromDurationIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void HoursFromDurationIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -145,15 +121,9 @@
// <MinutesFromDurationIterator>
-const char* MinutesFromDurationIterator::class_name_str = "MinutesFromDurationIterator";
MinutesFromDurationIterator::class_factory<MinutesFromDurationIterator>
MinutesFromDurationIterator::g_class_factory;
-const serialization::ClassVersion
-MinutesFromDurationIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int MinutesFromDurationIterator::class_versions_count =
-sizeof(MinutesFromDurationIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void MinutesFromDurationIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -173,15 +143,9 @@
// <SecondsFromDurationIterator>
-const char* SecondsFromDurationIterator::class_name_str = "SecondsFromDurationIterator";
SecondsFromDurationIterator::class_factory<SecondsFromDurationIterator>
SecondsFromDurationIterator::g_class_factory;
-const serialization::ClassVersion
-SecondsFromDurationIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SecondsFromDurationIterator::class_versions_count =
-sizeof(SecondsFromDurationIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SecondsFromDurationIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -201,15 +165,9 @@
// <YearFromDatetimeIterator>
-const char* YearFromDatetimeIterator::class_name_str = "YearFromDatetimeIterator";
YearFromDatetimeIterator::class_factory<YearFromDatetimeIterator>
YearFromDatetimeIterator::g_class_factory;
-const serialization::ClassVersion
-YearFromDatetimeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int YearFromDatetimeIterator::class_versions_count =
-sizeof(YearFromDatetimeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void YearFromDatetimeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -229,15 +187,9 @@
// <MonthFromDatetimeIterator>
-const char* MonthFromDatetimeIterator::class_name_str = "MonthFromDatetimeIterator";
MonthFromDatetimeIterator::class_factory<MonthFromDatetimeIterator>
MonthFromDatetimeIterator::g_class_factory;
-const serialization::ClassVersion
-MonthFromDatetimeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int MonthFromDatetimeIterator::class_versions_count =
-sizeof(MonthFromDatetimeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void MonthFromDatetimeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -257,15 +209,9 @@
// <DayFromDatetimeIterator>
-const char* DayFromDatetimeIterator::class_name_str = "DayFromDatetimeIterator";
DayFromDatetimeIterator::class_factory<DayFromDatetimeIterator>
DayFromDatetimeIterator::g_class_factory;
-const serialization::ClassVersion
-DayFromDatetimeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int DayFromDatetimeIterator::class_versions_count =
-sizeof(DayFromDatetimeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void DayFromDatetimeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -285,15 +231,9 @@
// <HoursFromDatetimeIterator>
-const char* HoursFromDatetimeIterator::class_name_str = "HoursFromDatetimeIterator";
HoursFromDatetimeIterator::class_factory<HoursFromDatetimeIterator>
HoursFromDatetimeIterator::g_class_factory;
-const serialization::ClassVersion
-HoursFromDatetimeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int HoursFromDatetimeIterator::class_versions_count =
-sizeof(HoursFromDatetimeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void HoursFromDatetimeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -313,15 +253,9 @@
// <MinutesFromDatetimeIterator>
-const char* MinutesFromDatetimeIterator::class_name_str = "MinutesFromDatetimeIterator";
MinutesFromDatetimeIterator::class_factory<MinutesFromDatetimeIterator>
MinutesFromDatetimeIterator::g_class_factory;
-const serialization::ClassVersion
-MinutesFromDatetimeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int MinutesFromDatetimeIterator::class_versions_count =
-sizeof(MinutesFromDatetimeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void MinutesFromDatetimeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -341,15 +275,9 @@
// <SecondsFromDatetimeIterator>
-const char* SecondsFromDatetimeIterator::class_name_str = "SecondsFromDatetimeIterator";
SecondsFromDatetimeIterator::class_factory<SecondsFromDatetimeIterator>
SecondsFromDatetimeIterator::g_class_factory;
-const serialization::ClassVersion
-SecondsFromDatetimeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SecondsFromDatetimeIterator::class_versions_count =
-sizeof(SecondsFromDatetimeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SecondsFromDatetimeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -369,15 +297,9 @@
// <TimezoneFromDatetimeIterator>
-const char* TimezoneFromDatetimeIterator::class_name_str = "TimezoneFromDatetimeIterator";
TimezoneFromDatetimeIterator::class_factory<TimezoneFromDatetimeIterator>
TimezoneFromDatetimeIterator::g_class_factory;
-const serialization::ClassVersion
-TimezoneFromDatetimeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int TimezoneFromDatetimeIterator::class_versions_count =
-sizeof(TimezoneFromDatetimeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void TimezoneFromDatetimeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -397,15 +319,9 @@
// <YearFromDateIterator>
-const char* YearFromDateIterator::class_name_str = "YearFromDateIterator";
YearFromDateIterator::class_factory<YearFromDateIterator>
YearFromDateIterator::g_class_factory;
-const serialization::ClassVersion
-YearFromDateIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int YearFromDateIterator::class_versions_count =
-sizeof(YearFromDateIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void YearFromDateIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -425,15 +341,9 @@
// <MonthFromDateIterator>
-const char* MonthFromDateIterator::class_name_str = "MonthFromDateIterator";
MonthFromDateIterator::class_factory<MonthFromDateIterator>
MonthFromDateIterator::g_class_factory;
-const serialization::ClassVersion
-MonthFromDateIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int MonthFromDateIterator::class_versions_count =
-sizeof(MonthFromDateIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void MonthFromDateIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -453,15 +363,9 @@
// <DayFromDateIterator>
-const char* DayFromDateIterator::class_name_str = "DayFromDateIterator";
DayFromDateIterator::class_factory<DayFromDateIterator>
DayFromDateIterator::g_class_factory;
-const serialization::ClassVersion
-DayFromDateIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int DayFromDateIterator::class_versions_count =
-sizeof(DayFromDateIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void DayFromDateIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -481,15 +385,9 @@
// <TimezoneFromDateIterator>
-const char* TimezoneFromDateIterator::class_name_str = "TimezoneFromDateIterator";
TimezoneFromDateIterator::class_factory<TimezoneFromDateIterator>
TimezoneFromDateIterator::g_class_factory;
-const serialization::ClassVersion
-TimezoneFromDateIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int TimezoneFromDateIterator::class_versions_count =
-sizeof(TimezoneFromDateIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void TimezoneFromDateIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -509,15 +407,9 @@
// <HoursFromTimeIterator>
-const char* HoursFromTimeIterator::class_name_str = "HoursFromTimeIterator";
HoursFromTimeIterator::class_factory<HoursFromTimeIterator>
HoursFromTimeIterator::g_class_factory;
-const serialization::ClassVersion
-HoursFromTimeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int HoursFromTimeIterator::class_versions_count =
-sizeof(HoursFromTimeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void HoursFromTimeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -537,15 +429,9 @@
// <MinutesFromTimeIterator>
-const char* MinutesFromTimeIterator::class_name_str = "MinutesFromTimeIterator";
MinutesFromTimeIterator::class_factory<MinutesFromTimeIterator>
MinutesFromTimeIterator::g_class_factory;
-const serialization::ClassVersion
-MinutesFromTimeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int MinutesFromTimeIterator::class_versions_count =
-sizeof(MinutesFromTimeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void MinutesFromTimeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -565,15 +451,9 @@
// <SecondsFromTimeIterator>
-const char* SecondsFromTimeIterator::class_name_str = "SecondsFromTimeIterator";
SecondsFromTimeIterator::class_factory<SecondsFromTimeIterator>
SecondsFromTimeIterator::g_class_factory;
-const serialization::ClassVersion
-SecondsFromTimeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SecondsFromTimeIterator::class_versions_count =
-sizeof(SecondsFromTimeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SecondsFromTimeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -593,15 +473,9 @@
// <TimezoneFromTimeIterator>
-const char* TimezoneFromTimeIterator::class_name_str = "TimezoneFromTimeIterator";
TimezoneFromTimeIterator::class_factory<TimezoneFromTimeIterator>
TimezoneFromTimeIterator::g_class_factory;
-const serialization::ClassVersion
-TimezoneFromTimeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int TimezoneFromTimeIterator::class_versions_count =
-sizeof(TimezoneFromTimeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void TimezoneFromTimeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/errors_and_diagnostics/pregenerated/errors_and_diagnostics.cpp'
--- src/runtime/errors_and_diagnostics/pregenerated/errors_and_diagnostics.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/errors_and_diagnostics/pregenerated/errors_and_diagnostics.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <ErrorIterator>
-const char* ErrorIterator::class_name_str = "ErrorIterator";
ErrorIterator::class_factory<ErrorIterator>
ErrorIterator::g_class_factory;
-const serialization::ClassVersion
-ErrorIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ErrorIterator::class_versions_count =
-sizeof(ErrorIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ErrorIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -61,15 +55,9 @@
// <TraceIterator>
-const char* TraceIterator::class_name_str = "TraceIterator";
TraceIterator::class_factory<TraceIterator>
TraceIterator::g_class_factory;
-const serialization::ClassVersion
-TraceIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int TraceIterator::class_versions_count =
-sizeof(TraceIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void TraceIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/errors_and_diagnostics/pregenerated/other_diagnostics.cpp'
--- src/runtime/errors_and_diagnostics/pregenerated/other_diagnostics.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/errors_and_diagnostics/pregenerated/other_diagnostics.cpp 2012-04-08 20:59:19 +0000
@@ -34,15 +34,9 @@
namespace zorba {
// <ReadLineIterator>
-const char* ReadLineIterator::class_name_str = "ReadLineIterator";
ReadLineIterator::class_factory<ReadLineIterator>
ReadLineIterator::g_class_factory;
-const serialization::ClassVersion
-ReadLineIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ReadLineIterator::class_versions_count =
-sizeof(ReadLineIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ReadLineIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -62,15 +56,9 @@
// <PrintIterator>
-const char* PrintIterator::class_name_str = "PrintIterator";
PrintIterator::class_factory<PrintIterator>
PrintIterator::g_class_factory;
-const serialization::ClassVersion
-PrintIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int PrintIterator::class_versions_count =
-sizeof(PrintIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void PrintIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -90,15 +78,9 @@
// <FunctionTraceIterator>
-const char* FunctionTraceIterator::class_name_str = "FunctionTraceIterator";
FunctionTraceIterator::class_factory<FunctionTraceIterator>
FunctionTraceIterator::g_class_factory;
-const serialization::ClassVersion
-FunctionTraceIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FunctionTraceIterator::class_versions_count =
-sizeof(FunctionTraceIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FunctionTraceIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/eval/eval.cpp'
--- src/runtime/eval/eval.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/eval/eval.cpp 2012-04-08 20:59:19 +0000
@@ -45,7 +45,6 @@
SERIALIZABLE_CLASS_VERSIONS(EvalIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(EvalIterator)
/****************************************************************************//**
=== modified file 'src/runtime/fetch/pregenerated/fetch.cpp'
--- src/runtime/fetch/pregenerated/fetch.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/fetch/pregenerated/fetch.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <FetchContentIterator>
-const char* FetchContentIterator::class_name_str = "FetchContentIterator";
FetchContentIterator::class_factory<FetchContentIterator>
FetchContentIterator::g_class_factory;
-const serialization::ClassVersion
-FetchContentIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FetchContentIterator::class_versions_count =
-sizeof(FetchContentIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FetchContentIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -61,15 +55,9 @@
// <FetchContentTypeIterator>
-const char* FetchContentTypeIterator::class_name_str = "FetchContentTypeIterator";
FetchContentTypeIterator::class_factory<FetchContentTypeIterator>
FetchContentTypeIterator::g_class_factory;
-const serialization::ClassVersion
-FetchContentTypeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FetchContentTypeIterator::class_versions_count =
-sizeof(FetchContentTypeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FetchContentTypeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/fnput/pregenerated/fnput.cpp'
--- src/runtime/fnput/pregenerated/fnput.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/fnput/pregenerated/fnput.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <FnPutIterator>
-const char* FnPutIterator::class_name_str = "FnPutIterator";
FnPutIterator::class_factory<FnPutIterator>
FnPutIterator::g_class_factory;
-const serialization::ClassVersion
-FnPutIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnPutIterator::class_versions_count =
-sizeof(FnPutIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnPutIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/full_text/full_text.cpp'
--- src/runtime/full_text/full_text.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/full_text/full_text.cpp 2012-04-08 20:59:19 +0000
@@ -32,16 +32,9 @@
namespace zorba {
-const char* FTContainsIterator::class_name_str = "FTContainsIterator";
FTContainsIterator::class_factory<FTContainsIterator>
FTContainsIterator::g_class_factory;
-const serialization::ClassVersion
- FTContainsIterator::class_versions[] = { { 1, 0x000905, false } };
-
-const int FTContainsIterator::class_versions_count =
- sizeof( FTContainsIterator::class_versions ) /
- sizeof( struct serialization::ClassVersion );
void FTContainsIterator::accept( PlanIterVisitor &v ) const {
v.beginVisit( *this );
=== modified file 'src/runtime/function_item/dynamic_fncall_iterator.cpp'
--- src/runtime/function_item/dynamic_fncall_iterator.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/function_item/dynamic_fncall_iterator.cpp 2012-04-08 20:59:19 +0000
@@ -37,16 +37,9 @@
{
-const char* DynamicFnCallIterator::class_name_str = "DynamicFnCallIterator";
DynamicFnCallIterator::class_factory<DynamicFnCallIterator>
DynamicFnCallIterator::g_class_factory;
-const serialization::ClassVersion
-DynamicFnCallIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int DynamicFnCallIterator::class_versions_count =
-sizeof(DynamicFnCallIterator::class_versions)/sizeof(struct serialization::ClassVersion);
-
/*******************************************************************************
=== modified file 'src/runtime/function_item/function_item.cpp'
--- src/runtime/function_item/function_item.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/function_item/function_item.cpp 2012-04-08 20:59:19 +0000
@@ -31,10 +31,10 @@
{
SERIALIZABLE_CLASS_VERSIONS(FunctionItem)
-END_SERIALIZABLE_CLASS_VERSIONS(FunctionItem)
-
-
-FunctionItem::FunctionItem(::zorba::serialization::Archiver& ar) :
+
+
+FunctionItem::FunctionItem(::zorba::serialization::Archiver& ar)
+ :
store::Item(store::Item::FUNCTION)
{
}
=== modified file 'src/runtime/function_item/pregenerated/function_item_iter.cpp'
--- src/runtime/function_item/pregenerated/function_item_iter.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/function_item/pregenerated/function_item_iter.cpp 2012-04-08 20:59:19 +0000
@@ -36,15 +36,9 @@
namespace zorba {
// <FunctionNameIterator>
-const char* FunctionNameIterator::class_name_str = "FunctionNameIterator";
FunctionNameIterator::class_factory<FunctionNameIterator>
FunctionNameIterator::g_class_factory;
-const serialization::ClassVersion
-FunctionNameIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FunctionNameIterator::class_versions_count =
-sizeof(FunctionNameIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FunctionNameIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -64,15 +58,9 @@
// <FunctionArityIterator>
-const char* FunctionArityIterator::class_name_str = "FunctionArityIterator";
FunctionArityIterator::class_factory<FunctionArityIterator>
FunctionArityIterator::g_class_factory;
-const serialization::ClassVersion
-FunctionArityIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FunctionArityIterator::class_versions_count =
-sizeof(FunctionArityIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FunctionArityIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -92,15 +80,9 @@
// <PartialApplyIterator>
-const char* PartialApplyIterator::class_name_str = "PartialApplyIterator";
PartialApplyIterator::class_factory<PartialApplyIterator>
PartialApplyIterator::g_class_factory;
-const serialization::ClassVersion
-PartialApplyIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int PartialApplyIterator::class_versions_count =
-sizeof(PartialApplyIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void PartialApplyIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/indexing/index_ddl.cpp'
--- src/runtime/indexing/index_ddl.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/indexing/index_ddl.cpp 2012-04-08 20:59:19 +0000
@@ -47,34 +47,24 @@
SERIALIZABLE_CLASS_VERSIONS(CreateInternalIndexIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(CreateInternalIndexIterator)
SERIALIZABLE_CLASS_VERSIONS(CreateIndexIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(CreateIndexIterator)
SERIALIZABLE_CLASS_VERSIONS(DeleteIndexIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(DeleteIndexIterator)
SERIALIZABLE_CLASS_VERSIONS(RefreshIndexIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(RefreshIndexIterator)
SERIALIZABLE_CLASS_VERSIONS(ValueIndexEntryBuilderIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(ValueIndexEntryBuilderIterator)
SERIALIZABLE_CLASS_VERSIONS(GeneralIndexEntryBuilderIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(GeneralIndexEntryBuilderIterator)
SERIALIZABLE_CLASS_VERSIONS(ProbeIndexPointValueIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(ProbeIndexPointValueIterator)
SERIALIZABLE_CLASS_VERSIONS(ProbeIndexPointGeneralIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(ProbeIndexPointGeneralIterator)
SERIALIZABLE_CLASS_VERSIONS(ProbeIndexRangeValueIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(ProbeIndexRangeValueIterator)
SERIALIZABLE_CLASS_VERSIONS(ProbeIndexRangeGeneralIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(ProbeIndexRangeGeneralIterator)
/*******************************************************************************
=== modified file 'src/runtime/indexing/pregenerated/ic_ddl.cpp'
--- src/runtime/indexing/pregenerated/ic_ddl.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/indexing/pregenerated/ic_ddl.cpp 2012-04-08 20:59:19 +0000
@@ -34,15 +34,9 @@
namespace zorba {
// <ActivateICIterator>
-const char* ActivateICIterator::class_name_str = "ActivateICIterator";
ActivateICIterator::class_factory<ActivateICIterator>
ActivateICIterator::g_class_factory;
-const serialization::ClassVersion
-ActivateICIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ActivateICIterator::class_versions_count =
-sizeof(ActivateICIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ActivateICIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -58,15 +52,9 @@
// <DeactivateICIterator>
-const char* DeactivateICIterator::class_name_str = "DeactivateICIterator";
DeactivateICIterator::class_factory<DeactivateICIterator>
DeactivateICIterator::g_class_factory;
-const serialization::ClassVersion
-DeactivateICIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int DeactivateICIterator::class_versions_count =
-sizeof(DeactivateICIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void DeactivateICIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -82,15 +70,9 @@
// <CheckICIterator>
-const char* CheckICIterator::class_name_str = "CheckICIterator";
CheckICIterator::class_factory<CheckICIterator>
CheckICIterator::g_class_factory;
-const serialization::ClassVersion
-CheckICIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int CheckICIterator::class_versions_count =
-sizeof(CheckICIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void CheckICIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/introspection/pregenerated/sctx.cpp'
--- src/runtime/introspection/pregenerated/sctx.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/introspection/pregenerated/sctx.cpp 2012-04-08 20:59:19 +0000
@@ -35,15 +35,9 @@
namespace zorba {
// <StaticNamespacesIterator>
-const char* StaticNamespacesIterator::class_name_str = "StaticNamespacesIterator";
StaticNamespacesIterator::class_factory<StaticNamespacesIterator>
StaticNamespacesIterator::g_class_factory;
-const serialization::ClassVersion
-StaticNamespacesIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int StaticNamespacesIterator::class_versions_count =
-sizeof(StaticNamespacesIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void StaticNamespacesIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -69,15 +63,9 @@
// <DefaultFunctionNamespaceIterator>
-const char* DefaultFunctionNamespaceIterator::class_name_str = "DefaultFunctionNamespaceIterator";
DefaultFunctionNamespaceIterator::class_factory<DefaultFunctionNamespaceIterator>
DefaultFunctionNamespaceIterator::g_class_factory;
-const serialization::ClassVersion
-DefaultFunctionNamespaceIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int DefaultFunctionNamespaceIterator::class_versions_count =
-sizeof(DefaultFunctionNamespaceIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void DefaultFunctionNamespaceIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -97,15 +85,9 @@
// <SctxBaseUriIterator>
-const char* SctxBaseUriIterator::class_name_str = "SctxBaseUriIterator";
SctxBaseUriIterator::class_factory<SctxBaseUriIterator>
SctxBaseUriIterator::g_class_factory;
-const serialization::ClassVersion
-SctxBaseUriIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SctxBaseUriIterator::class_versions_count =
-sizeof(SctxBaseUriIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SctxBaseUriIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -125,15 +107,9 @@
// <SctxDefaultCollationIterator>
-const char* SctxDefaultCollationIterator::class_name_str = "SctxDefaultCollationIterator";
SctxDefaultCollationIterator::class_factory<SctxDefaultCollationIterator>
SctxDefaultCollationIterator::g_class_factory;
-const serialization::ClassVersion
-SctxDefaultCollationIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SctxDefaultCollationIterator::class_versions_count =
-sizeof(SctxDefaultCollationIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SctxDefaultCollationIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -153,15 +129,9 @@
// <StaticNamespaceBindingIterator>
-const char* StaticNamespaceBindingIterator::class_name_str = "StaticNamespaceBindingIterator";
StaticNamespaceBindingIterator::class_factory<StaticNamespaceBindingIterator>
StaticNamespaceBindingIterator::g_class_factory;
-const serialization::ClassVersion
-StaticNamespaceBindingIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int StaticNamespaceBindingIterator::class_versions_count =
-sizeof(StaticNamespaceBindingIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void StaticNamespaceBindingIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -181,15 +151,9 @@
// <InscopeVariablesIterator>
-const char* InscopeVariablesIterator::class_name_str = "InscopeVariablesIterator";
InscopeVariablesIterator::class_factory<InscopeVariablesIterator>
InscopeVariablesIterator::g_class_factory;
-const serialization::ClassVersion
-InscopeVariablesIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int InscopeVariablesIterator::class_versions_count =
-sizeof(InscopeVariablesIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void InscopeVariablesIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -215,15 +179,9 @@
// <DefaultCollectionTypeIterator>
-const char* DefaultCollectionTypeIterator::class_name_str = "DefaultCollectionTypeIterator";
DefaultCollectionTypeIterator::class_factory<DefaultCollectionTypeIterator>
DefaultCollectionTypeIterator::g_class_factory;
-const serialization::ClassVersion
-DefaultCollectionTypeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int DefaultCollectionTypeIterator::class_versions_count =
-sizeof(DefaultCollectionTypeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void DefaultCollectionTypeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -243,15 +201,9 @@
// <XPath10CompatModeIterator>
-const char* XPath10CompatModeIterator::class_name_str = "XPath10CompatModeIterator";
XPath10CompatModeIterator::class_factory<XPath10CompatModeIterator>
XPath10CompatModeIterator::g_class_factory;
-const serialization::ClassVersion
-XPath10CompatModeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int XPath10CompatModeIterator::class_versions_count =
-sizeof(XPath10CompatModeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void XPath10CompatModeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -271,15 +223,9 @@
// <StaticallyKnownDocumentsIterator>
-const char* StaticallyKnownDocumentsIterator::class_name_str = "StaticallyKnownDocumentsIterator";
StaticallyKnownDocumentsIterator::class_factory<StaticallyKnownDocumentsIterator>
StaticallyKnownDocumentsIterator::g_class_factory;
-const serialization::ClassVersion
-StaticallyKnownDocumentsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int StaticallyKnownDocumentsIterator::class_versions_count =
-sizeof(StaticallyKnownDocumentsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void StaticallyKnownDocumentsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -305,15 +251,9 @@
// <StaticallyKnownDocumentTypeIterator>
-const char* StaticallyKnownDocumentTypeIterator::class_name_str = "StaticallyKnownDocumentTypeIterator";
StaticallyKnownDocumentTypeIterator::class_factory<StaticallyKnownDocumentTypeIterator>
StaticallyKnownDocumentTypeIterator::g_class_factory;
-const serialization::ClassVersion
-StaticallyKnownDocumentTypeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int StaticallyKnownDocumentTypeIterator::class_versions_count =
-sizeof(StaticallyKnownDocumentTypeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void StaticallyKnownDocumentTypeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -333,15 +273,9 @@
// <StaticallyKnownCollationsIterator>
-const char* StaticallyKnownCollationsIterator::class_name_str = "StaticallyKnownCollationsIterator";
StaticallyKnownCollationsIterator::class_factory<StaticallyKnownCollationsIterator>
StaticallyKnownCollationsIterator::g_class_factory;
-const serialization::ClassVersion
-StaticallyKnownCollationsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int StaticallyKnownCollationsIterator::class_versions_count =
-sizeof(StaticallyKnownCollationsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void StaticallyKnownCollationsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -367,15 +301,9 @@
// <ConstructionModeIterator>
-const char* ConstructionModeIterator::class_name_str = "ConstructionModeIterator";
ConstructionModeIterator::class_factory<ConstructionModeIterator>
ConstructionModeIterator::g_class_factory;
-const serialization::ClassVersion
-ConstructionModeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ConstructionModeIterator::class_versions_count =
-sizeof(ConstructionModeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ConstructionModeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -395,15 +323,9 @@
// <OrderingModeIterator>
-const char* OrderingModeIterator::class_name_str = "OrderingModeIterator";
OrderingModeIterator::class_factory<OrderingModeIterator>
OrderingModeIterator::g_class_factory;
-const serialization::ClassVersion
-OrderingModeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int OrderingModeIterator::class_versions_count =
-sizeof(OrderingModeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void OrderingModeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -423,15 +345,9 @@
// <DefaultOrderIterator>
-const char* DefaultOrderIterator::class_name_str = "DefaultOrderIterator";
DefaultOrderIterator::class_factory<DefaultOrderIterator>
DefaultOrderIterator::g_class_factory;
-const serialization::ClassVersion
-DefaultOrderIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int DefaultOrderIterator::class_versions_count =
-sizeof(DefaultOrderIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void DefaultOrderIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -451,15 +367,9 @@
// <BoundarySpacePolicyIterator>
-const char* BoundarySpacePolicyIterator::class_name_str = "BoundarySpacePolicyIterator";
BoundarySpacePolicyIterator::class_factory<BoundarySpacePolicyIterator>
BoundarySpacePolicyIterator::g_class_factory;
-const serialization::ClassVersion
-BoundarySpacePolicyIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int BoundarySpacePolicyIterator::class_versions_count =
-sizeof(BoundarySpacePolicyIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void BoundarySpacePolicyIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -479,15 +389,9 @@
// <CopyNamespacesModeIterator>
-const char* CopyNamespacesModeIterator::class_name_str = "CopyNamespacesModeIterator";
CopyNamespacesModeIterator::class_factory<CopyNamespacesModeIterator>
CopyNamespacesModeIterator::g_class_factory;
-const serialization::ClassVersion
-CopyNamespacesModeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int CopyNamespacesModeIterator::class_versions_count =
-sizeof(CopyNamespacesModeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void CopyNamespacesModeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -507,15 +411,9 @@
// <FunctionNamesIterator>
-const char* FunctionNamesIterator::class_name_str = "FunctionNamesIterator";
FunctionNamesIterator::class_factory<FunctionNamesIterator>
FunctionNamesIterator::g_class_factory;
-const serialization::ClassVersion
-FunctionNamesIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FunctionNamesIterator::class_versions_count =
-sizeof(FunctionNamesIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FunctionNamesIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -541,15 +439,9 @@
// <FunctionArgumentsCountIterator>
-const char* FunctionArgumentsCountIterator::class_name_str = "FunctionArgumentsCountIterator";
FunctionArgumentsCountIterator::class_factory<FunctionArgumentsCountIterator>
FunctionArgumentsCountIterator::g_class_factory;
-const serialization::ClassVersion
-FunctionArgumentsCountIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FunctionArgumentsCountIterator::class_versions_count =
-sizeof(FunctionArgumentsCountIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FunctionArgumentsCountIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -575,15 +467,9 @@
// <InScopeSchemaTypesIterator>
-const char* InScopeSchemaTypesIterator::class_name_str = "InScopeSchemaTypesIterator";
InScopeSchemaTypesIterator::class_factory<InScopeSchemaTypesIterator>
InScopeSchemaTypesIterator::g_class_factory;
-const serialization::ClassVersion
-InScopeSchemaTypesIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int InScopeSchemaTypesIterator::class_versions_count =
-sizeof(InScopeSchemaTypesIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void InScopeSchemaTypesIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -609,15 +495,9 @@
// <InScopeElementDeclarationsIterator>
-const char* InScopeElementDeclarationsIterator::class_name_str = "InScopeElementDeclarationsIterator";
InScopeElementDeclarationsIterator::class_factory<InScopeElementDeclarationsIterator>
InScopeElementDeclarationsIterator::g_class_factory;
-const serialization::ClassVersion
-InScopeElementDeclarationsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int InScopeElementDeclarationsIterator::class_versions_count =
-sizeof(InScopeElementDeclarationsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void InScopeElementDeclarationsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -643,15 +523,9 @@
// <InScopeAttributeDeclarationsIterator>
-const char* InScopeAttributeDeclarationsIterator::class_name_str = "InScopeAttributeDeclarationsIterator";
InScopeAttributeDeclarationsIterator::class_factory<InScopeAttributeDeclarationsIterator>
InScopeAttributeDeclarationsIterator::g_class_factory;
-const serialization::ClassVersion
-InScopeAttributeDeclarationsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int InScopeAttributeDeclarationsIterator::class_versions_count =
-sizeof(InScopeAttributeDeclarationsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void InScopeAttributeDeclarationsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -677,15 +551,9 @@
// <InScopeElementGroupsIterator>
-const char* InScopeElementGroupsIterator::class_name_str = "InScopeElementGroupsIterator";
InScopeElementGroupsIterator::class_factory<InScopeElementGroupsIterator>
InScopeElementGroupsIterator::g_class_factory;
-const serialization::ClassVersion
-InScopeElementGroupsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int InScopeElementGroupsIterator::class_versions_count =
-sizeof(InScopeElementGroupsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void InScopeElementGroupsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -711,15 +579,9 @@
// <InScopeAttributeGroupsIterator>
-const char* InScopeAttributeGroupsIterator::class_name_str = "InScopeAttributeGroupsIterator";
InScopeAttributeGroupsIterator::class_factory<InScopeAttributeGroupsIterator>
InScopeAttributeGroupsIterator::g_class_factory;
-const serialization::ClassVersion
-InScopeAttributeGroupsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int InScopeAttributeGroupsIterator::class_versions_count =
-sizeof(InScopeAttributeGroupsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void InScopeAttributeGroupsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -745,15 +607,9 @@
// <OptionIterator>
-const char* OptionIterator::class_name_str = "OptionIterator";
OptionIterator::class_factory<OptionIterator>
OptionIterator::g_class_factory;
-const serialization::ClassVersion
-OptionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int OptionIterator::class_versions_count =
-sizeof(OptionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void OptionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -773,15 +629,9 @@
// <FunctionAnnotationsIterator>
-const char* FunctionAnnotationsIterator::class_name_str = "FunctionAnnotationsIterator";
FunctionAnnotationsIterator::class_factory<FunctionAnnotationsIterator>
FunctionAnnotationsIterator::g_class_factory;
-const serialization::ClassVersion
-FunctionAnnotationsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FunctionAnnotationsIterator::class_versions_count =
-sizeof(FunctionAnnotationsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FunctionAnnotationsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/json/pregenerated/json.cpp'
--- src/runtime/json/pregenerated/json.cpp 2011-12-09 00:25:03 +0000
+++ src/runtime/json/pregenerated/json.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <JSONParseInternal>
-const char* JSONParseInternal::class_name_str = "JSONParseInternal";
JSONParseInternal::class_factory<JSONParseInternal>
JSONParseInternal::g_class_factory;
-const serialization::ClassVersion
-JSONParseInternal::class_versions[] ={{ 1, 0x000905, false}};
-
-const int JSONParseInternal::class_versions_count =
-sizeof(JSONParseInternal::class_versions)/sizeof(struct serialization::ClassVersion);
void JSONParseInternal::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -61,15 +55,9 @@
// <JSONSerializeInternal>
-const char* JSONSerializeInternal::class_name_str = "JSONSerializeInternal";
JSONSerializeInternal::class_factory<JSONSerializeInternal>
JSONSerializeInternal::g_class_factory;
-const serialization::ClassVersion
-JSONSerializeInternal::class_versions[] ={{ 1, 0x000905, false}};
-
-const int JSONSerializeInternal::class_versions_count =
-sizeof(JSONSerializeInternal::class_versions)/sizeof(struct serialization::ClassVersion);
void JSONSerializeInternal::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/maths/pregenerated/maths.cpp'
--- src/runtime/maths/pregenerated/maths.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/maths/pregenerated/maths.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <SqrtIterator>
-const char* SqrtIterator::class_name_str = "SqrtIterator";
SqrtIterator::class_factory<SqrtIterator>
SqrtIterator::g_class_factory;
-const serialization::ClassVersion
-SqrtIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SqrtIterator::class_versions_count =
-sizeof(SqrtIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SqrtIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -57,15 +51,9 @@
// <ExpIterator>
-const char* ExpIterator::class_name_str = "ExpIterator";
ExpIterator::class_factory<ExpIterator>
ExpIterator::g_class_factory;
-const serialization::ClassVersion
-ExpIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ExpIterator::class_versions_count =
-sizeof(ExpIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ExpIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -81,15 +69,9 @@
// <Exp10Iterator>
-const char* Exp10Iterator::class_name_str = "Exp10Iterator";
Exp10Iterator::class_factory<Exp10Iterator>
Exp10Iterator::g_class_factory;
-const serialization::ClassVersion
-Exp10Iterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int Exp10Iterator::class_versions_count =
-sizeof(Exp10Iterator::class_versions)/sizeof(struct serialization::ClassVersion);
void Exp10Iterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -105,15 +87,9 @@
// <LogIterator>
-const char* LogIterator::class_name_str = "LogIterator";
LogIterator::class_factory<LogIterator>
LogIterator::g_class_factory;
-const serialization::ClassVersion
-LogIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int LogIterator::class_versions_count =
-sizeof(LogIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void LogIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -129,15 +105,9 @@
// <Log10Iterator>
-const char* Log10Iterator::class_name_str = "Log10Iterator";
Log10Iterator::class_factory<Log10Iterator>
Log10Iterator::g_class_factory;
-const serialization::ClassVersion
-Log10Iterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int Log10Iterator::class_versions_count =
-sizeof(Log10Iterator::class_versions)/sizeof(struct serialization::ClassVersion);
void Log10Iterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -153,15 +123,9 @@
// <SinIterator>
-const char* SinIterator::class_name_str = "SinIterator";
SinIterator::class_factory<SinIterator>
SinIterator::g_class_factory;
-const serialization::ClassVersion
-SinIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SinIterator::class_versions_count =
-sizeof(SinIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SinIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -177,15 +141,9 @@
// <CosIterator>
-const char* CosIterator::class_name_str = "CosIterator";
CosIterator::class_factory<CosIterator>
CosIterator::g_class_factory;
-const serialization::ClassVersion
-CosIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int CosIterator::class_versions_count =
-sizeof(CosIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void CosIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -201,15 +159,9 @@
// <TanIterator>
-const char* TanIterator::class_name_str = "TanIterator";
TanIterator::class_factory<TanIterator>
TanIterator::g_class_factory;
-const serialization::ClassVersion
-TanIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int TanIterator::class_versions_count =
-sizeof(TanIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void TanIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -225,15 +177,9 @@
// <ArcSinIterator>
-const char* ArcSinIterator::class_name_str = "ArcSinIterator";
ArcSinIterator::class_factory<ArcSinIterator>
ArcSinIterator::g_class_factory;
-const serialization::ClassVersion
-ArcSinIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ArcSinIterator::class_versions_count =
-sizeof(ArcSinIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ArcSinIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -249,15 +195,9 @@
// <ArcCosIterator>
-const char* ArcCosIterator::class_name_str = "ArcCosIterator";
ArcCosIterator::class_factory<ArcCosIterator>
ArcCosIterator::g_class_factory;
-const serialization::ClassVersion
-ArcCosIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ArcCosIterator::class_versions_count =
-sizeof(ArcCosIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ArcCosIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -273,15 +213,9 @@
// <ArcTanIterator>
-const char* ArcTanIterator::class_name_str = "ArcTanIterator";
ArcTanIterator::class_factory<ArcTanIterator>
ArcTanIterator::g_class_factory;
-const serialization::ClassVersion
-ArcTanIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ArcTanIterator::class_versions_count =
-sizeof(ArcTanIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ArcTanIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -297,15 +231,9 @@
// <Atan2Iterator>
-const char* Atan2Iterator::class_name_str = "Atan2Iterator";
Atan2Iterator::class_factory<Atan2Iterator>
Atan2Iterator::g_class_factory;
-const serialization::ClassVersion
-Atan2Iterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int Atan2Iterator::class_versions_count =
-sizeof(Atan2Iterator::class_versions)/sizeof(struct serialization::ClassVersion);
void Atan2Iterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -322,15 +250,9 @@
// <CoshIterator>
-const char* CoshIterator::class_name_str = "CoshIterator";
CoshIterator::class_factory<CoshIterator>
CoshIterator::g_class_factory;
-const serialization::ClassVersion
-CoshIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int CoshIterator::class_versions_count =
-sizeof(CoshIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void CoshIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -346,15 +268,9 @@
// <AcoshIterator>
-const char* AcoshIterator::class_name_str = "AcoshIterator";
AcoshIterator::class_factory<AcoshIterator>
AcoshIterator::g_class_factory;
-const serialization::ClassVersion
-AcoshIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int AcoshIterator::class_versions_count =
-sizeof(AcoshIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void AcoshIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -370,15 +286,9 @@
// <FmodIterator>
-const char* FmodIterator::class_name_str = "FmodIterator";
FmodIterator::class_factory<FmodIterator>
FmodIterator::g_class_factory;
-const serialization::ClassVersion
-FmodIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FmodIterator::class_versions_count =
-sizeof(FmodIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FmodIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -395,15 +305,9 @@
// <LdexpIterator>
-const char* LdexpIterator::class_name_str = "LdexpIterator";
LdexpIterator::class_factory<LdexpIterator>
LdexpIterator::g_class_factory;
-const serialization::ClassVersion
-LdexpIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int LdexpIterator::class_versions_count =
-sizeof(LdexpIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void LdexpIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -420,15 +324,9 @@
// <PowIterator>
-const char* PowIterator::class_name_str = "PowIterator";
PowIterator::class_factory<PowIterator>
PowIterator::g_class_factory;
-const serialization::ClassVersion
-PowIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int PowIterator::class_versions_count =
-sizeof(PowIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void PowIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -445,15 +343,9 @@
// <SinhIterator>
-const char* SinhIterator::class_name_str = "SinhIterator";
SinhIterator::class_factory<SinhIterator>
SinhIterator::g_class_factory;
-const serialization::ClassVersion
-SinhIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SinhIterator::class_versions_count =
-sizeof(SinhIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SinhIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -469,15 +361,9 @@
// <AsinhIterator>
-const char* AsinhIterator::class_name_str = "AsinhIterator";
AsinhIterator::class_factory<AsinhIterator>
AsinhIterator::g_class_factory;
-const serialization::ClassVersion
-AsinhIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int AsinhIterator::class_versions_count =
-sizeof(AsinhIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void AsinhIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -493,15 +379,9 @@
// <TanhIterator>
-const char* TanhIterator::class_name_str = "TanhIterator";
TanhIterator::class_factory<TanhIterator>
TanhIterator::g_class_factory;
-const serialization::ClassVersion
-TanhIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int TanhIterator::class_versions_count =
-sizeof(TanhIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void TanhIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -517,15 +397,9 @@
// <AtanhIterator>
-const char* AtanhIterator::class_name_str = "AtanhIterator";
AtanhIterator::class_factory<AtanhIterator>
AtanhIterator::g_class_factory;
-const serialization::ClassVersion
-AtanhIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int AtanhIterator::class_versions_count =
-sizeof(AtanhIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void AtanhIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -541,15 +415,9 @@
// <PiNumberIterator>
-const char* PiNumberIterator::class_name_str = "PiNumberIterator";
PiNumberIterator::class_factory<PiNumberIterator>
PiNumberIterator::g_class_factory;
-const serialization::ClassVersion
-PiNumberIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int PiNumberIterator::class_versions_count =
-sizeof(PiNumberIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void PiNumberIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -565,15 +433,9 @@
// <IsInfIterator>
-const char* IsInfIterator::class_name_str = "IsInfIterator";
IsInfIterator::class_factory<IsInfIterator>
IsInfIterator::g_class_factory;
-const serialization::ClassVersion
-IsInfIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsInfIterator::class_versions_count =
-sizeof(IsInfIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsInfIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -589,15 +451,9 @@
// <IsNaNIterator>
-const char* IsNaNIterator::class_name_str = "IsNaNIterator";
IsNaNIterator::class_factory<IsNaNIterator>
IsNaNIterator::g_class_factory;
-const serialization::ClassVersion
-IsNaNIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsNaNIterator::class_versions_count =
-sizeof(IsNaNIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsNaNIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -613,15 +469,9 @@
// <ModfIterator>
-const char* ModfIterator::class_name_str = "ModfIterator";
ModfIterator::class_factory<ModfIterator>
ModfIterator::g_class_factory;
-const serialization::ClassVersion
-ModfIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ModfIterator::class_versions_count =
-sizeof(ModfIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ModfIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -651,15 +501,9 @@
// <FrexpIterator>
-const char* FrexpIterator::class_name_str = "FrexpIterator";
FrexpIterator::class_factory<FrexpIterator>
FrexpIterator::g_class_factory;
-const serialization::ClassVersion
-FrexpIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FrexpIterator::class_versions_count =
-sizeof(FrexpIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FrexpIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/misc/materialize.cpp'
--- src/runtime/misc/materialize.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/misc/materialize.cpp 2012-04-08 20:59:19 +0000
@@ -30,8 +30,6 @@
SERIALIZABLE_CLASS_VERSIONS(MaterializeIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(MaterializeIterator)
-
MaterializeIteratorState::MaterializeIteratorState()
=== modified file 'src/runtime/nodes/pregenerated/node_position.cpp'
--- src/runtime/nodes/pregenerated/node_position.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/nodes/pregenerated/node_position.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <NodePositionIterator>
-const char* NodePositionIterator::class_name_str = "NodePositionIterator";
NodePositionIterator::class_factory<NodePositionIterator>
NodePositionIterator::g_class_factory;
-const serialization::ClassVersion
-NodePositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int NodePositionIterator::class_versions_count =
-sizeof(NodePositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void NodePositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -61,15 +55,9 @@
// <IsAncestorPositionIterator>
-const char* IsAncestorPositionIterator::class_name_str = "IsAncestorPositionIterator";
IsAncestorPositionIterator::class_factory<IsAncestorPositionIterator>
IsAncestorPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsAncestorPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsAncestorPositionIterator::class_versions_count =
-sizeof(IsAncestorPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsAncestorPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -89,15 +77,9 @@
// <IsFollowingSiblingPositionIterator>
-const char* IsFollowingSiblingPositionIterator::class_name_str = "IsFollowingSiblingPositionIterator";
IsFollowingSiblingPositionIterator::class_factory<IsFollowingSiblingPositionIterator>
IsFollowingSiblingPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsFollowingSiblingPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsFollowingSiblingPositionIterator::class_versions_count =
-sizeof(IsFollowingSiblingPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsFollowingSiblingPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -117,15 +99,9 @@
// <IsFollowingPositionIterator>
-const char* IsFollowingPositionIterator::class_name_str = "IsFollowingPositionIterator";
IsFollowingPositionIterator::class_factory<IsFollowingPositionIterator>
IsFollowingPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsFollowingPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsFollowingPositionIterator::class_versions_count =
-sizeof(IsFollowingPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsFollowingPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -145,15 +121,9 @@
// <IsInSubtreeOfPositionIterator>
-const char* IsInSubtreeOfPositionIterator::class_name_str = "IsInSubtreeOfPositionIterator";
IsInSubtreeOfPositionIterator::class_factory<IsInSubtreeOfPositionIterator>
IsInSubtreeOfPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsInSubtreeOfPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsInSubtreeOfPositionIterator::class_versions_count =
-sizeof(IsInSubtreeOfPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsInSubtreeOfPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -173,15 +143,9 @@
// <IsDescendantPositionIterator>
-const char* IsDescendantPositionIterator::class_name_str = "IsDescendantPositionIterator";
IsDescendantPositionIterator::class_factory<IsDescendantPositionIterator>
IsDescendantPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsDescendantPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsDescendantPositionIterator::class_versions_count =
-sizeof(IsDescendantPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsDescendantPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -201,15 +165,9 @@
// <IsPrecedingSiblingPositionIterator>
-const char* IsPrecedingSiblingPositionIterator::class_name_str = "IsPrecedingSiblingPositionIterator";
IsPrecedingSiblingPositionIterator::class_factory<IsPrecedingSiblingPositionIterator>
IsPrecedingSiblingPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsPrecedingSiblingPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsPrecedingSiblingPositionIterator::class_versions_count =
-sizeof(IsPrecedingSiblingPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsPrecedingSiblingPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -229,15 +187,9 @@
// <IsPrecedingPositionIterator>
-const char* IsPrecedingPositionIterator::class_name_str = "IsPrecedingPositionIterator";
IsPrecedingPositionIterator::class_factory<IsPrecedingPositionIterator>
IsPrecedingPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsPrecedingPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsPrecedingPositionIterator::class_versions_count =
-sizeof(IsPrecedingPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsPrecedingPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -257,15 +209,9 @@
// <IsChildPositionIterator>
-const char* IsChildPositionIterator::class_name_str = "IsChildPositionIterator";
IsChildPositionIterator::class_factory<IsChildPositionIterator>
IsChildPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsChildPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsChildPositionIterator::class_versions_count =
-sizeof(IsChildPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsChildPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -285,15 +231,9 @@
// <IsAttributeOfPositionIterator>
-const char* IsAttributeOfPositionIterator::class_name_str = "IsAttributeOfPositionIterator";
IsAttributeOfPositionIterator::class_factory<IsAttributeOfPositionIterator>
IsAttributeOfPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsAttributeOfPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsAttributeOfPositionIterator::class_versions_count =
-sizeof(IsAttributeOfPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsAttributeOfPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -313,15 +253,9 @@
// <IsParentPositionIterator>
-const char* IsParentPositionIterator::class_name_str = "IsParentPositionIterator";
IsParentPositionIterator::class_factory<IsParentPositionIterator>
IsParentPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsParentPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsParentPositionIterator::class_versions_count =
-sizeof(IsParentPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsParentPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -341,15 +275,9 @@
// <IsPrecedingInDocumentOrderPositionIterator>
-const char* IsPrecedingInDocumentOrderPositionIterator::class_name_str = "IsPrecedingInDocumentOrderPositionIterator";
IsPrecedingInDocumentOrderPositionIterator::class_factory<IsPrecedingInDocumentOrderPositionIterator>
IsPrecedingInDocumentOrderPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsPrecedingInDocumentOrderPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsPrecedingInDocumentOrderPositionIterator::class_versions_count =
-sizeof(IsPrecedingInDocumentOrderPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsPrecedingInDocumentOrderPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -369,15 +297,9 @@
// <IsFollowingInDocumentOrderPositionIterator>
-const char* IsFollowingInDocumentOrderPositionIterator::class_name_str = "IsFollowingInDocumentOrderPositionIterator";
IsFollowingInDocumentOrderPositionIterator::class_factory<IsFollowingInDocumentOrderPositionIterator>
IsFollowingInDocumentOrderPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsFollowingInDocumentOrderPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsFollowingInDocumentOrderPositionIterator::class_versions_count =
-sizeof(IsFollowingInDocumentOrderPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsFollowingInDocumentOrderPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -397,15 +319,9 @@
// <LevelPositionIterator>
-const char* LevelPositionIterator::class_name_str = "LevelPositionIterator";
LevelPositionIterator::class_factory<LevelPositionIterator>
LevelPositionIterator::g_class_factory;
-const serialization::ClassVersion
-LevelPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int LevelPositionIterator::class_versions_count =
-sizeof(LevelPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void LevelPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -425,15 +341,9 @@
// <IsAttributePositionIterator>
-const char* IsAttributePositionIterator::class_name_str = "IsAttributePositionIterator";
IsAttributePositionIterator::class_factory<IsAttributePositionIterator>
IsAttributePositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsAttributePositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsAttributePositionIterator::class_versions_count =
-sizeof(IsAttributePositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsAttributePositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -453,15 +363,9 @@
// <IsCommentPositionIterator>
-const char* IsCommentPositionIterator::class_name_str = "IsCommentPositionIterator";
IsCommentPositionIterator::class_factory<IsCommentPositionIterator>
IsCommentPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsCommentPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsCommentPositionIterator::class_versions_count =
-sizeof(IsCommentPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsCommentPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -481,15 +385,9 @@
// <IsDocumentPositionIterator>
-const char* IsDocumentPositionIterator::class_name_str = "IsDocumentPositionIterator";
IsDocumentPositionIterator::class_factory<IsDocumentPositionIterator>
IsDocumentPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsDocumentPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsDocumentPositionIterator::class_versions_count =
-sizeof(IsDocumentPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsDocumentPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -509,15 +407,9 @@
// <IsElementPositionIterator>
-const char* IsElementPositionIterator::class_name_str = "IsElementPositionIterator";
IsElementPositionIterator::class_factory<IsElementPositionIterator>
IsElementPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsElementPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsElementPositionIterator::class_versions_count =
-sizeof(IsElementPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsElementPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -537,15 +429,9 @@
// <IsProcessingInstructionPositionIterator>
-const char* IsProcessingInstructionPositionIterator::class_name_str = "IsProcessingInstructionPositionIterator";
IsProcessingInstructionPositionIterator::class_factory<IsProcessingInstructionPositionIterator>
IsProcessingInstructionPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsProcessingInstructionPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsProcessingInstructionPositionIterator::class_versions_count =
-sizeof(IsProcessingInstructionPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsProcessingInstructionPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -565,15 +451,9 @@
// <IsTextPositionIterator>
-const char* IsTextPositionIterator::class_name_str = "IsTextPositionIterator";
IsTextPositionIterator::class_factory<IsTextPositionIterator>
IsTextPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsTextPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsTextPositionIterator::class_versions_count =
-sizeof(IsTextPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsTextPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -593,15 +473,9 @@
// <IsSiblingPositionIterator>
-const char* IsSiblingPositionIterator::class_name_str = "IsSiblingPositionIterator";
IsSiblingPositionIterator::class_factory<IsSiblingPositionIterator>
IsSiblingPositionIterator::g_class_factory;
-const serialization::ClassVersion
-IsSiblingPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsSiblingPositionIterator::class_versions_count =
-sizeof(IsSiblingPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsSiblingPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -621,15 +495,9 @@
// <InSameTreePositionIterator>
-const char* InSameTreePositionIterator::class_name_str = "InSameTreePositionIterator";
InSameTreePositionIterator::class_factory<InSameTreePositionIterator>
InSameTreePositionIterator::g_class_factory;
-const serialization::ClassVersion
-InSameTreePositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int InSameTreePositionIterator::class_versions_count =
-sizeof(InSameTreePositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void InSameTreePositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -649,15 +517,9 @@
// <InCollectionPositionIterator>
-const char* InCollectionPositionIterator::class_name_str = "InCollectionPositionIterator";
InCollectionPositionIterator::class_factory<InCollectionPositionIterator>
InCollectionPositionIterator::g_class_factory;
-const serialization::ClassVersion
-InCollectionPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int InCollectionPositionIterator::class_versions_count =
-sizeof(InCollectionPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void InCollectionPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -677,15 +539,9 @@
// <InSameCollectionPositionIterator>
-const char* InSameCollectionPositionIterator::class_name_str = "InSameCollectionPositionIterator";
InSameCollectionPositionIterator::class_factory<InSameCollectionPositionIterator>
InSameCollectionPositionIterator::g_class_factory;
-const serialization::ClassVersion
-InSameCollectionPositionIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int InSameCollectionPositionIterator::class_versions_count =
-sizeof(InSameCollectionPositionIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void InSameCollectionPositionIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/nodes/pregenerated/nodes.cpp'
--- src/runtime/nodes/pregenerated/nodes.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/nodes/pregenerated/nodes.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <NodeReferenceIterator>
-const char* NodeReferenceIterator::class_name_str = "NodeReferenceIterator";
NodeReferenceIterator::class_factory<NodeReferenceIterator>
NodeReferenceIterator::g_class_factory;
-const serialization::ClassVersion
-NodeReferenceIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int NodeReferenceIterator::class_versions_count =
-sizeof(NodeReferenceIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void NodeReferenceIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -61,15 +55,9 @@
// <NodeByReferenceIterator>
-const char* NodeByReferenceIterator::class_name_str = "NodeByReferenceIterator";
NodeByReferenceIterator::class_factory<NodeByReferenceIterator>
NodeByReferenceIterator::g_class_factory;
-const serialization::ClassVersion
-NodeByReferenceIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int NodeByReferenceIterator::class_versions_count =
-sizeof(NodeByReferenceIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void NodeByReferenceIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -89,15 +77,9 @@
// <FnLocalNameIterator>
-const char* FnLocalNameIterator::class_name_str = "FnLocalNameIterator";
FnLocalNameIterator::class_factory<FnLocalNameIterator>
FnLocalNameIterator::g_class_factory;
-const serialization::ClassVersion
-FnLocalNameIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnLocalNameIterator::class_versions_count =
-sizeof(FnLocalNameIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnLocalNameIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -117,15 +99,9 @@
// <FnNamespaceUriIterator>
-const char* FnNamespaceUriIterator::class_name_str = "FnNamespaceUriIterator";
FnNamespaceUriIterator::class_factory<FnNamespaceUriIterator>
FnNamespaceUriIterator::g_class_factory;
-const serialization::ClassVersion
-FnNamespaceUriIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnNamespaceUriIterator::class_versions_count =
-sizeof(FnNamespaceUriIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnNamespaceUriIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -145,15 +121,9 @@
// <FnLangIterator>
-const char* FnLangIterator::class_name_str = "FnLangIterator";
FnLangIterator::class_factory<FnLangIterator>
FnLangIterator::g_class_factory;
-const serialization::ClassVersion
-FnLangIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnLangIterator::class_versions_count =
-sizeof(FnLangIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnLangIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -173,15 +143,9 @@
// <FnHasChildrenIterator>
-const char* FnHasChildrenIterator::class_name_str = "FnHasChildrenIterator";
FnHasChildrenIterator::class_factory<FnHasChildrenIterator>
FnHasChildrenIterator::g_class_factory;
-const serialization::ClassVersion
-FnHasChildrenIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnHasChildrenIterator::class_versions_count =
-sizeof(FnHasChildrenIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnHasChildrenIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -201,15 +165,9 @@
// <FnInnermostIterator>
-const char* FnInnermostIterator::class_name_str = "FnInnermostIterator";
FnInnermostIterator::class_factory<FnInnermostIterator>
FnInnermostIterator::g_class_factory;
-const serialization::ClassVersion
-FnInnermostIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnInnermostIterator::class_versions_count =
-sizeof(FnInnermostIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnInnermostIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -241,15 +199,9 @@
// <FnOutermostIterator>
-const char* FnOutermostIterator::class_name_str = "FnOutermostIterator";
FnOutermostIterator::class_factory<FnOutermostIterator>
FnOutermostIterator::g_class_factory;
-const serialization::ClassVersion
-FnOutermostIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnOutermostIterator::class_versions_count =
-sizeof(FnOutermostIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnOutermostIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -281,15 +233,9 @@
// <FnGenerateIdIterator>
-const char* FnGenerateIdIterator::class_name_str = "FnGenerateIdIterator";
FnGenerateIdIterator::class_factory<FnGenerateIdIterator>
FnGenerateIdIterator::g_class_factory;
-const serialization::ClassVersion
-FnGenerateIdIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnGenerateIdIterator::class_versions_count =
-sizeof(FnGenerateIdIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnGenerateIdIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -309,15 +255,9 @@
// <IsAncestorIterator>
-const char* IsAncestorIterator::class_name_str = "IsAncestorIterator";
IsAncestorIterator::class_factory<IsAncestorIterator>
IsAncestorIterator::g_class_factory;
-const serialization::ClassVersion
-IsAncestorIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsAncestorIterator::class_versions_count =
-sizeof(IsAncestorIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsAncestorIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -337,15 +277,9 @@
// <IsDescendantIterator>
-const char* IsDescendantIterator::class_name_str = "IsDescendantIterator";
IsDescendantIterator::class_factory<IsDescendantIterator>
IsDescendantIterator::g_class_factory;
-const serialization::ClassVersion
-IsDescendantIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsDescendantIterator::class_versions_count =
-sizeof(IsDescendantIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsDescendantIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -365,15 +299,9 @@
// <IsParentIterator>
-const char* IsParentIterator::class_name_str = "IsParentIterator";
IsParentIterator::class_factory<IsParentIterator>
IsParentIterator::g_class_factory;
-const serialization::ClassVersion
-IsParentIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsParentIterator::class_versions_count =
-sizeof(IsParentIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsParentIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -393,15 +321,9 @@
// <IsChildIterator>
-const char* IsChildIterator::class_name_str = "IsChildIterator";
IsChildIterator::class_factory<IsChildIterator>
IsChildIterator::g_class_factory;
-const serialization::ClassVersion
-IsChildIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsChildIterator::class_versions_count =
-sizeof(IsChildIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsChildIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -421,15 +343,9 @@
// <IsFollowingIterator>
-const char* IsFollowingIterator::class_name_str = "IsFollowingIterator";
IsFollowingIterator::class_factory<IsFollowingIterator>
IsFollowingIterator::g_class_factory;
-const serialization::ClassVersion
-IsFollowingIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsFollowingIterator::class_versions_count =
-sizeof(IsFollowingIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsFollowingIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -449,15 +365,9 @@
// <IsPrecedingIterator>
-const char* IsPrecedingIterator::class_name_str = "IsPrecedingIterator";
IsPrecedingIterator::class_factory<IsPrecedingIterator>
IsPrecedingIterator::g_class_factory;
-const serialization::ClassVersion
-IsPrecedingIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsPrecedingIterator::class_versions_count =
-sizeof(IsPrecedingIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsPrecedingIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -477,15 +387,9 @@
// <IsFollowingSiblingIterator>
-const char* IsFollowingSiblingIterator::class_name_str = "IsFollowingSiblingIterator";
IsFollowingSiblingIterator::class_factory<IsFollowingSiblingIterator>
IsFollowingSiblingIterator::g_class_factory;
-const serialization::ClassVersion
-IsFollowingSiblingIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsFollowingSiblingIterator::class_versions_count =
-sizeof(IsFollowingSiblingIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsFollowingSiblingIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -505,15 +409,9 @@
// <IsPrecedingSiblingIterator>
-const char* IsPrecedingSiblingIterator::class_name_str = "IsPrecedingSiblingIterator";
IsPrecedingSiblingIterator::class_factory<IsPrecedingSiblingIterator>
IsPrecedingSiblingIterator::g_class_factory;
-const serialization::ClassVersion
-IsPrecedingSiblingIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsPrecedingSiblingIterator::class_versions_count =
-sizeof(IsPrecedingSiblingIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsPrecedingSiblingIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -533,15 +431,9 @@
// <LevelIterator>
-const char* LevelIterator::class_name_str = "LevelIterator";
LevelIterator::class_factory<LevelIterator>
LevelIterator::g_class_factory;
-const serialization::ClassVersion
-LevelIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int LevelIterator::class_versions_count =
-sizeof(LevelIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void LevelIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -561,15 +453,9 @@
// <LeastCommonAncestor>
-const char* LeastCommonAncestor::class_name_str = "LeastCommonAncestor";
LeastCommonAncestor::class_factory<LeastCommonAncestor>
LeastCommonAncestor::g_class_factory;
-const serialization::ClassVersion
-LeastCommonAncestor::class_versions[] ={{ 1, 0x000905, false}};
-
-const int LeastCommonAncestor::class_versions_count =
-sizeof(LeastCommonAncestor::class_versions)/sizeof(struct serialization::ClassVersion);
void LeastCommonAncestor::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/numerics/NumericsImpl.cpp'
--- src/runtime/numerics/NumericsImpl.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/numerics/NumericsImpl.cpp 2012-04-08 20:59:19 +0000
@@ -43,8 +43,7 @@
namespace zorba
{
-SERIALIZABLE_TEMPLATE_VERSIONS(NumArithIterator)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(NumArithIterator)
+
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NumArithIterator, NumArithIterator<AddOperation>, 1)
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NumArithIterator, NumArithIterator<SubtractOperation>, 2)
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NumArithIterator, NumArithIterator<MultiplyOperation>, 3)
@@ -52,8 +51,6 @@
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NumArithIterator, NumArithIterator<IntegerDivideOperation>, 5)
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NumArithIterator, NumArithIterator<ModOperation>, 6)
-SERIALIZABLE_TEMPLATE_VERSIONS(SpecificNumArithIterator)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(SpecificNumArithIterator)
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS2(SpecificNumArithIterator, SpecificNumArithIterator<AddOperation, store::XS_DOUBLE>, 1);
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS2(SpecificNumArithIterator, SpecificNumArithIterator<AddOperation, store::XS_FLOAT>, 2);
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS2(SpecificNumArithIterator, SpecificNumArithIterator<AddOperation, store::XS_DECIMAL>, 3);
@@ -77,10 +74,9 @@
SERIALIZABLE_CLASS_VERSIONS(OpNumericUnaryIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(OpNumericUnaryIterator)
SERIALIZABLE_CLASS_VERSIONS(OpDoubleUnaryIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(OpDoubleUnaryIterator)
+
/*******************************************************************************
AddOperation (see runtime/core/arithmetic_impl.h/cpp)
=== modified file 'src/runtime/numerics/pregenerated/numerics.cpp'
--- src/runtime/numerics/pregenerated/numerics.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/numerics/pregenerated/numerics.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <AbsIterator>
-const char* AbsIterator::class_name_str = "AbsIterator";
AbsIterator::class_factory<AbsIterator>
AbsIterator::g_class_factory;
-const serialization::ClassVersion
-AbsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int AbsIterator::class_versions_count =
-sizeof(AbsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void AbsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -61,15 +55,9 @@
// <CeilingIterator>
-const char* CeilingIterator::class_name_str = "CeilingIterator";
CeilingIterator::class_factory<CeilingIterator>
CeilingIterator::g_class_factory;
-const serialization::ClassVersion
-CeilingIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int CeilingIterator::class_versions_count =
-sizeof(CeilingIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void CeilingIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -89,15 +77,9 @@
// <FloorIterator>
-const char* FloorIterator::class_name_str = "FloorIterator";
FloorIterator::class_factory<FloorIterator>
FloorIterator::g_class_factory;
-const serialization::ClassVersion
-FloorIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FloorIterator::class_versions_count =
-sizeof(FloorIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FloorIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -117,15 +99,9 @@
// <RoundIterator>
-const char* RoundIterator::class_name_str = "RoundIterator";
RoundIterator::class_factory<RoundIterator>
RoundIterator::g_class_factory;
-const serialization::ClassVersion
-RoundIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int RoundIterator::class_versions_count =
-sizeof(RoundIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void RoundIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -145,15 +121,9 @@
// <RoundHalfToEvenIterator>
-const char* RoundHalfToEvenIterator::class_name_str = "RoundHalfToEvenIterator";
RoundHalfToEvenIterator::class_factory<RoundHalfToEvenIterator>
RoundHalfToEvenIterator::g_class_factory;
-const serialization::ClassVersion
-RoundHalfToEvenIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int RoundHalfToEvenIterator::class_versions_count =
-sizeof(RoundHalfToEvenIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void RoundHalfToEvenIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -173,15 +143,9 @@
// <FormatNumberIterator>
-const char* FormatNumberIterator::class_name_str = "FormatNumberIterator";
FormatNumberIterator::class_factory<FormatNumberIterator>
FormatNumberIterator::g_class_factory;
-const serialization::ClassVersion
-FormatNumberIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FormatNumberIterator::class_versions_count =
-sizeof(FormatNumberIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FormatNumberIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -201,15 +165,9 @@
// <FormatIntegerIterator>
-const char* FormatIntegerIterator::class_name_str = "FormatIntegerIterator";
FormatIntegerIterator::class_factory<FormatIntegerIterator>
FormatIntegerIterator::g_class_factory;
-const serialization::ClassVersion
-FormatIntegerIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FormatIntegerIterator::class_versions_count =
-sizeof(FormatIntegerIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FormatIntegerIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/parsing_and_serializing/pregenerated/parse_fragment.cpp' (properties changed: -x to +x)
--- src/runtime/parsing_and_serializing/pregenerated/parse_fragment.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/parsing_and_serializing/pregenerated/parse_fragment.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <FnParseXmlFragmentIterator>
-const char* FnParseXmlFragmentIterator::class_name_str = "FnParseXmlFragmentIterator";
FnParseXmlFragmentIterator::class_factory<FnParseXmlFragmentIterator>
FnParseXmlFragmentIterator::g_class_factory;
-const serialization::ClassVersion
-FnParseXmlFragmentIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnParseXmlFragmentIterator::class_versions_count =
-sizeof(FnParseXmlFragmentIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnParseXmlFragmentIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/parsing_and_serializing/pregenerated/parsing_and_serializing.cpp'
--- src/runtime/parsing_and_serializing/pregenerated/parsing_and_serializing.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/parsing_and_serializing/pregenerated/parsing_and_serializing.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <FnParseXmlIterator>
-const char* FnParseXmlIterator::class_name_str = "FnParseXmlIterator";
FnParseXmlIterator::class_factory<FnParseXmlIterator>
FnParseXmlIterator::g_class_factory;
-const serialization::ClassVersion
-FnParseXmlIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnParseXmlIterator::class_versions_count =
-sizeof(FnParseXmlIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnParseXmlIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -61,15 +55,9 @@
// <FnSerializeIterator>
-const char* FnSerializeIterator::class_name_str = "FnSerializeIterator";
FnSerializeIterator::class_factory<FnSerializeIterator>
FnSerializeIterator::g_class_factory;
-const serialization::ClassVersion
-FnSerializeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnSerializeIterator::class_versions_count =
-sizeof(FnSerializeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnSerializeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/qnames/pregenerated/qnames.cpp'
--- src/runtime/qnames/pregenerated/qnames.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/qnames/pregenerated/qnames.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <ResolveQNameIterator>
-const char* ResolveQNameIterator::class_name_str = "ResolveQNameIterator";
ResolveQNameIterator::class_factory<ResolveQNameIterator>
ResolveQNameIterator::g_class_factory;
-const serialization::ClassVersion
-ResolveQNameIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ResolveQNameIterator::class_versions_count =
-sizeof(ResolveQNameIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ResolveQNameIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -58,15 +52,9 @@
// <QNameIterator>
-const char* QNameIterator::class_name_str = "QNameIterator";
QNameIterator::class_factory<QNameIterator>
QNameIterator::g_class_factory;
-const serialization::ClassVersion
-QNameIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int QNameIterator::class_versions_count =
-sizeof(QNameIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void QNameIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -83,15 +71,9 @@
// <QNameEqualIterator>
-const char* QNameEqualIterator::class_name_str = "QNameEqualIterator";
QNameEqualIterator::class_factory<QNameEqualIterator>
QNameEqualIterator::g_class_factory;
-const serialization::ClassVersion
-QNameEqualIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int QNameEqualIterator::class_versions_count =
-sizeof(QNameEqualIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void QNameEqualIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -108,15 +90,9 @@
// <PrefixFromQNameIterator>
-const char* PrefixFromQNameIterator::class_name_str = "PrefixFromQNameIterator";
PrefixFromQNameIterator::class_factory<PrefixFromQNameIterator>
PrefixFromQNameIterator::g_class_factory;
-const serialization::ClassVersion
-PrefixFromQNameIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int PrefixFromQNameIterator::class_versions_count =
-sizeof(PrefixFromQNameIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void PrefixFromQNameIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -132,15 +108,9 @@
// <LocalNameFromQNameIterator>
-const char* LocalNameFromQNameIterator::class_name_str = "LocalNameFromQNameIterator";
LocalNameFromQNameIterator::class_factory<LocalNameFromQNameIterator>
LocalNameFromQNameIterator::g_class_factory;
-const serialization::ClassVersion
-LocalNameFromQNameIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int LocalNameFromQNameIterator::class_versions_count =
-sizeof(LocalNameFromQNameIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void LocalNameFromQNameIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -156,15 +126,9 @@
// <NamespaceUriFromQNameIterator>
-const char* NamespaceUriFromQNameIterator::class_name_str = "NamespaceUriFromQNameIterator";
NamespaceUriFromQNameIterator::class_factory<NamespaceUriFromQNameIterator>
NamespaceUriFromQNameIterator::g_class_factory;
-const serialization::ClassVersion
-NamespaceUriFromQNameIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int NamespaceUriFromQNameIterator::class_versions_count =
-sizeof(NamespaceUriFromQNameIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void NamespaceUriFromQNameIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -180,15 +144,9 @@
// <NamespaceUriForPrefixIterator>
-const char* NamespaceUriForPrefixIterator::class_name_str = "NamespaceUriForPrefixIterator";
NamespaceUriForPrefixIterator::class_factory<NamespaceUriForPrefixIterator>
NamespaceUriForPrefixIterator::g_class_factory;
-const serialization::ClassVersion
-NamespaceUriForPrefixIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int NamespaceUriForPrefixIterator::class_versions_count =
-sizeof(NamespaceUriForPrefixIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void NamespaceUriForPrefixIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -208,15 +166,9 @@
// <InScopePrefixesIterator>
-const char* InScopePrefixesIterator::class_name_str = "InScopePrefixesIterator";
InScopePrefixesIterator::class_factory<InScopePrefixesIterator>
InScopePrefixesIterator::g_class_factory;
-const serialization::ClassVersion
-InScopePrefixesIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int InScopePrefixesIterator::class_versions_count =
-sizeof(InScopePrefixesIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void InScopePrefixesIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/random/pregenerated/random.cpp'
--- src/runtime/random/pregenerated/random.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/random/pregenerated/random.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <SeededRandomIterator>
-const char* SeededRandomIterator::class_name_str = "SeededRandomIterator";
SeededRandomIterator::class_factory<SeededRandomIterator>
SeededRandomIterator::g_class_factory;
-const serialization::ClassVersion
-SeededRandomIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SeededRandomIterator::class_versions_count =
-sizeof(SeededRandomIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SeededRandomIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -73,15 +67,9 @@
// <RandomIterator>
-const char* RandomIterator::class_name_str = "RandomIterator";
RandomIterator::class_factory<RandomIterator>
RandomIterator::g_class_factory;
-const serialization::ClassVersion
-RandomIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int RandomIterator::class_versions_count =
-sizeof(RandomIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void RandomIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -113,15 +101,9 @@
// <UuidIterator>
-const char* UuidIterator::class_name_str = "UuidIterator";
UuidIterator::class_factory<UuidIterator>
UuidIterator::g_class_factory;
-const serialization::ClassVersion
-UuidIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int UuidIterator::class_versions_count =
-sizeof(UuidIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void UuidIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/schema/pregenerated/schema.cpp'
--- src/runtime/schema/pregenerated/schema.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/schema/pregenerated/schema.cpp 2012-04-08 20:59:19 +0000
@@ -37,15 +37,9 @@
#ifndef ZORBA_NO_XMLSCHEMA
// <ValidateIterator>
-const char* ValidateIterator::class_name_str = "ValidateIterator";
ValidateIterator::class_factory<ValidateIterator>
ValidateIterator::g_class_factory;
-const serialization::ClassVersion
-ValidateIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ValidateIterator::class_versions_count =
-sizeof(ValidateIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ValidateIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -61,15 +55,9 @@
#endif
// <ZorbaValidateInPlaceIterator>
-const char* ZorbaValidateInPlaceIterator::class_name_str = "ZorbaValidateInPlaceIterator";
ZorbaValidateInPlaceIterator::class_factory<ZorbaValidateInPlaceIterator>
ZorbaValidateInPlaceIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaValidateInPlaceIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaValidateInPlaceIterator::class_versions_count =
-sizeof(ZorbaValidateInPlaceIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaValidateInPlaceIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -85,15 +73,9 @@
// <ZorbaSchemaTypeIterator>
-const char* ZorbaSchemaTypeIterator::class_name_str = "ZorbaSchemaTypeIterator";
ZorbaSchemaTypeIterator::class_factory<ZorbaSchemaTypeIterator>
ZorbaSchemaTypeIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaSchemaTypeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaSchemaTypeIterator::class_versions_count =
-sizeof(ZorbaSchemaTypeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaSchemaTypeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -113,15 +95,9 @@
// <ZorbaIsValidatedIterator>
-const char* ZorbaIsValidatedIterator::class_name_str = "ZorbaIsValidatedIterator";
ZorbaIsValidatedIterator::class_factory<ZorbaIsValidatedIterator>
ZorbaIsValidatedIterator::g_class_factory;
-const serialization::ClassVersion
-ZorbaIsValidatedIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ZorbaIsValidatedIterator::class_versions_count =
-sizeof(ZorbaIsValidatedIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ZorbaIsValidatedIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/scripting/scripting.cpp'
--- src/runtime/scripting/scripting.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/scripting/scripting.cpp 2012-04-08 20:59:19 +0000
@@ -30,19 +30,14 @@
{
SERIALIZABLE_CLASS_VERSIONS(FlowCtlIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(FlowCtlIterator)
SERIALIZABLE_CLASS_VERSIONS(SequentialIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(SequentialIterator)
SERIALIZABLE_CLASS_VERSIONS(LoopIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(LoopIterator)
SERIALIZABLE_CLASS_VERSIONS(ExitIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(ExitIterator)
SERIALIZABLE_CLASS_VERSIONS(ExitCatcherIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(ExitCatcherIterator)
=== modified file 'src/runtime/sequences/SequencesImpl.cpp'
--- src/runtime/sequences/SequencesImpl.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/sequences/SequencesImpl.cpp 2012-04-08 20:59:19 +0000
@@ -56,7 +56,6 @@
namespace zorba {
SERIALIZABLE_CLASS_VERSIONS(FnMinMaxIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(FnMinMaxIterator)
NARY_ACCEPT(FnMinMaxIterator);
=== modified file 'src/runtime/sequences/pregenerated/sequences.cpp'
--- src/runtime/sequences/pregenerated/sequences.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/sequences/pregenerated/sequences.cpp 2012-04-08 20:59:19 +0000
@@ -34,15 +34,9 @@
namespace zorba {
// <FnConcatIterator>
-const char* FnConcatIterator::class_name_str = "FnConcatIterator";
FnConcatIterator::class_factory<FnConcatIterator>
FnConcatIterator::g_class_factory;
-const serialization::ClassVersion
-FnConcatIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnConcatIterator::class_versions_count =
-sizeof(FnConcatIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnConcatIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -66,15 +60,9 @@
// <FnIndexOfIterator>
-const char* FnIndexOfIterator::class_name_str = "FnIndexOfIterator";
FnIndexOfIterator::class_factory<FnIndexOfIterator>
FnIndexOfIterator::g_class_factory;
-const serialization::ClassVersion
-FnIndexOfIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnIndexOfIterator::class_versions_count =
-sizeof(FnIndexOfIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnIndexOfIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -112,15 +100,9 @@
// <FnEmptyIterator>
-const char* FnEmptyIterator::class_name_str = "FnEmptyIterator";
FnEmptyIterator::class_factory<FnEmptyIterator>
FnEmptyIterator::g_class_factory;
-const serialization::ClassVersion
-FnEmptyIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnEmptyIterator::class_versions_count =
-sizeof(FnEmptyIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnEmptyIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -140,15 +122,9 @@
// <FnExistsIterator>
-const char* FnExistsIterator::class_name_str = "FnExistsIterator";
FnExistsIterator::class_factory<FnExistsIterator>
FnExistsIterator::g_class_factory;
-const serialization::ClassVersion
-FnExistsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnExistsIterator::class_versions_count =
-sizeof(FnExistsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnExistsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -168,15 +144,9 @@
// <FnDistinctValuesIterator>
-const char* FnDistinctValuesIterator::class_name_str = "FnDistinctValuesIterator";
FnDistinctValuesIterator::class_factory<FnDistinctValuesIterator>
FnDistinctValuesIterator::g_class_factory;
-const serialization::ClassVersion
-FnDistinctValuesIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnDistinctValuesIterator::class_versions_count =
-sizeof(FnDistinctValuesIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnDistinctValuesIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -205,15 +175,9 @@
// <FnInsertBeforeIterator>
-const char* FnInsertBeforeIterator::class_name_str = "FnInsertBeforeIterator";
FnInsertBeforeIterator::class_factory<FnInsertBeforeIterator>
FnInsertBeforeIterator::g_class_factory;
-const serialization::ClassVersion
-FnInsertBeforeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnInsertBeforeIterator::class_versions_count =
-sizeof(FnInsertBeforeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnInsertBeforeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -251,15 +215,9 @@
// <FnRemoveIterator>
-const char* FnRemoveIterator::class_name_str = "FnRemoveIterator";
FnRemoveIterator::class_factory<FnRemoveIterator>
FnRemoveIterator::g_class_factory;
-const serialization::ClassVersion
-FnRemoveIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnRemoveIterator::class_versions_count =
-sizeof(FnRemoveIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnRemoveIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -297,15 +255,9 @@
// <FnReverseIterator>
-const char* FnReverseIterator::class_name_str = "FnReverseIterator";
FnReverseIterator::class_factory<FnReverseIterator>
FnReverseIterator::g_class_factory;
-const serialization::ClassVersion
-FnReverseIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnReverseIterator::class_versions_count =
-sizeof(FnReverseIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnReverseIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -329,15 +281,9 @@
// <FnSubsequenceIterator>
-const char* FnSubsequenceIterator::class_name_str = "FnSubsequenceIterator";
FnSubsequenceIterator::class_factory<FnSubsequenceIterator>
FnSubsequenceIterator::g_class_factory;
-const serialization::ClassVersion
-FnSubsequenceIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnSubsequenceIterator::class_versions_count =
-sizeof(FnSubsequenceIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnSubsequenceIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -373,15 +319,9 @@
// <SubsequenceIntIterator>
-const char* SubsequenceIntIterator::class_name_str = "SubsequenceIntIterator";
SubsequenceIntIterator::class_factory<SubsequenceIntIterator>
SubsequenceIntIterator::g_class_factory;
-const serialization::ClassVersion
-SubsequenceIntIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SubsequenceIntIterator::class_versions_count =
-sizeof(SubsequenceIntIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SubsequenceIntIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -417,15 +357,9 @@
// <SequencePointAccessIterator>
-const char* SequencePointAccessIterator::class_name_str = "SequencePointAccessIterator";
SequencePointAccessIterator::class_factory<SequencePointAccessIterator>
SequencePointAccessIterator::g_class_factory;
-const serialization::ClassVersion
-SequencePointAccessIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SequencePointAccessIterator::class_versions_count =
-sizeof(SequencePointAccessIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SequencePointAccessIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -459,15 +393,9 @@
// <FnZeroOrOneIterator>
-const char* FnZeroOrOneIterator::class_name_str = "FnZeroOrOneIterator";
FnZeroOrOneIterator::class_factory<FnZeroOrOneIterator>
FnZeroOrOneIterator::g_class_factory;
-const serialization::ClassVersion
-FnZeroOrOneIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnZeroOrOneIterator::class_versions_count =
-sizeof(FnZeroOrOneIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnZeroOrOneIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -487,15 +415,9 @@
// <FnOneOrMoreIterator>
-const char* FnOneOrMoreIterator::class_name_str = "FnOneOrMoreIterator";
FnOneOrMoreIterator::class_factory<FnOneOrMoreIterator>
FnOneOrMoreIterator::g_class_factory;
-const serialization::ClassVersion
-FnOneOrMoreIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnOneOrMoreIterator::class_versions_count =
-sizeof(FnOneOrMoreIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnOneOrMoreIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -515,15 +437,9 @@
// <FnExactlyOneIterator>
-const char* FnExactlyOneIterator::class_name_str = "FnExactlyOneIterator";
FnExactlyOneIterator::class_factory<FnExactlyOneIterator>
FnExactlyOneIterator::g_class_factory;
-const serialization::ClassVersion
-FnExactlyOneIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnExactlyOneIterator::class_versions_count =
-sizeof(FnExactlyOneIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnExactlyOneIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -543,15 +459,9 @@
// <FnDeepEqualIterator>
-const char* FnDeepEqualIterator::class_name_str = "FnDeepEqualIterator";
FnDeepEqualIterator::class_factory<FnDeepEqualIterator>
FnDeepEqualIterator::g_class_factory;
-const serialization::ClassVersion
-FnDeepEqualIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnDeepEqualIterator::class_versions_count =
-sizeof(FnDeepEqualIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnDeepEqualIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -571,15 +481,9 @@
// <HashSemiJoinIterator>
-const char* HashSemiJoinIterator::class_name_str = "HashSemiJoinIterator";
HashSemiJoinIterator::class_factory<HashSemiJoinIterator>
HashSemiJoinIterator::g_class_factory;
-const serialization::ClassVersion
-HashSemiJoinIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int HashSemiJoinIterator::class_versions_count =
-sizeof(HashSemiJoinIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void HashSemiJoinIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -599,15 +503,9 @@
// <SortSemiJoinIterator>
-const char* SortSemiJoinIterator::class_name_str = "SortSemiJoinIterator";
SortSemiJoinIterator::class_factory<SortSemiJoinIterator>
SortSemiJoinIterator::g_class_factory;
-const serialization::ClassVersion
-SortSemiJoinIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SortSemiJoinIterator::class_versions_count =
-sizeof(SortSemiJoinIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SortSemiJoinIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -627,15 +525,9 @@
// <FnCountIterator>
-const char* FnCountIterator::class_name_str = "FnCountIterator";
FnCountIterator::class_factory<FnCountIterator>
FnCountIterator::g_class_factory;
-const serialization::ClassVersion
-FnCountIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnCountIterator::class_versions_count =
-sizeof(FnCountIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnCountIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -655,15 +547,9 @@
// <FnAvgIterator>
-const char* FnAvgIterator::class_name_str = "FnAvgIterator";
FnAvgIterator::class_factory<FnAvgIterator>
FnAvgIterator::g_class_factory;
-const serialization::ClassVersion
-FnAvgIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnAvgIterator::class_versions_count =
-sizeof(FnAvgIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnAvgIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -683,15 +569,9 @@
// <FnSumIterator>
-const char* FnSumIterator::class_name_str = "FnSumIterator";
FnSumIterator::class_factory<FnSumIterator>
FnSumIterator::g_class_factory;
-const serialization::ClassVersion
-FnSumIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnSumIterator::class_versions_count =
-sizeof(FnSumIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnSumIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -711,15 +591,9 @@
// <FnSumDoubleIterator>
-const char* FnSumDoubleIterator::class_name_str = "FnSumDoubleIterator";
FnSumDoubleIterator::class_factory<FnSumDoubleIterator>
FnSumDoubleIterator::g_class_factory;
-const serialization::ClassVersion
-FnSumDoubleIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnSumDoubleIterator::class_versions_count =
-sizeof(FnSumDoubleIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnSumDoubleIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -739,15 +613,9 @@
// <FnSumFloatIterator>
-const char* FnSumFloatIterator::class_name_str = "FnSumFloatIterator";
FnSumFloatIterator::class_factory<FnSumFloatIterator>
FnSumFloatIterator::g_class_factory;
-const serialization::ClassVersion
-FnSumFloatIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnSumFloatIterator::class_versions_count =
-sizeof(FnSumFloatIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnSumFloatIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -767,15 +635,9 @@
// <FnSumDecimalIterator>
-const char* FnSumDecimalIterator::class_name_str = "FnSumDecimalIterator";
FnSumDecimalIterator::class_factory<FnSumDecimalIterator>
FnSumDecimalIterator::g_class_factory;
-const serialization::ClassVersion
-FnSumDecimalIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnSumDecimalIterator::class_versions_count =
-sizeof(FnSumDecimalIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnSumDecimalIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -795,15 +657,9 @@
// <FnSumIntegerIterator>
-const char* FnSumIntegerIterator::class_name_str = "FnSumIntegerIterator";
FnSumIntegerIterator::class_factory<FnSumIntegerIterator>
FnSumIntegerIterator::g_class_factory;
-const serialization::ClassVersion
-FnSumIntegerIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnSumIntegerIterator::class_versions_count =
-sizeof(FnSumIntegerIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnSumIntegerIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -823,15 +679,9 @@
// <OpToIterator>
-const char* OpToIterator::class_name_str = "OpToIterator";
OpToIterator::class_factory<OpToIterator>
OpToIterator::g_class_factory;
-const serialization::ClassVersion
-OpToIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int OpToIterator::class_versions_count =
-sizeof(OpToIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void OpToIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -869,15 +719,9 @@
// <FnIdIterator>
-const char* FnIdIterator::class_name_str = "FnIdIterator";
FnIdIterator::class_factory<FnIdIterator>
FnIdIterator::g_class_factory;
-const serialization::ClassVersion
-FnIdIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnIdIterator::class_versions_count =
-sizeof(FnIdIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnIdIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -901,15 +745,9 @@
// <FnElementWithIdIterator>
-const char* FnElementWithIdIterator::class_name_str = "FnElementWithIdIterator";
FnElementWithIdIterator::class_factory<FnElementWithIdIterator>
FnElementWithIdIterator::g_class_factory;
-const serialization::ClassVersion
-FnElementWithIdIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnElementWithIdIterator::class_versions_count =
-sizeof(FnElementWithIdIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnElementWithIdIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -933,15 +771,9 @@
// <FnIdRefIterator>
-const char* FnIdRefIterator::class_name_str = "FnIdRefIterator";
FnIdRefIterator::class_factory<FnIdRefIterator>
FnIdRefIterator::g_class_factory;
-const serialization::ClassVersion
-FnIdRefIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnIdRefIterator::class_versions_count =
-sizeof(FnIdRefIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnIdRefIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -965,15 +797,9 @@
// <FnDocIterator>
-const char* FnDocIterator::class_name_str = "FnDocIterator";
FnDocIterator::class_factory<FnDocIterator>
FnDocIterator::g_class_factory;
-const serialization::ClassVersion
-FnDocIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnDocIterator::class_versions_count =
-sizeof(FnDocIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnDocIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -993,15 +819,9 @@
// <FnDocAvailableIterator>
-const char* FnDocAvailableIterator::class_name_str = "FnDocAvailableIterator";
FnDocAvailableIterator::class_factory<FnDocAvailableIterator>
FnDocAvailableIterator::g_class_factory;
-const serialization::ClassVersion
-FnDocAvailableIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnDocAvailableIterator::class_versions_count =
-sizeof(FnDocAvailableIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnDocAvailableIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/spec/iterator_cpp.xq'
--- src/runtime/spec/iterator_cpp.xq 2012-03-28 05:19:57 +0000
+++ src/runtime/spec/iterator_cpp.xq 2012-04-08 20:59:19 +0000
@@ -38,7 +38,6 @@
'// <',$iter/@name,'>',$gen:newline,
local:serializable-class-versions($iter/@name),
- local:end-serializable-class-versions($iter/@name),
(: generate the visitor if requested :)
if(fn:not($iter/@generateAccept) or $iter/@generateAccept eq "true")
@@ -196,21 +195,15 @@
)
};
+
declare function local:serializable-class-versions($name as xs:string) as xs:string
{
- string-join(('const char* ',$name,'::class_name_str = "',$name,'";',$gen:newline,
- $name,'::class_factory<',$name,'>',$gen:newline,$name,'::g_class_factory;',$gen:newline,$gen:newline,
- 'const serialization::ClassVersion ',$gen:newline,$name,'::class_versions[] =',
- '{{ 1, ',$gen:zorba_version,', ',string(not($gen:backward_compatible)),'}')
- ,'')
+ string-join(
+ ($name, '::class_factory<', $name, '>', $gen:newline, $name, '::g_class_factory;',
+ $gen:newline, $gen:newline)
+ ,'')
};
-declare function local:end-serializable-class-versions($name as xs:string) as xs:string
-{
- string-join(('};',$gen:newline,$gen:newline, 'const int ',$name,'::class_versions_count =',$gen:newline,
- 'sizeof(',$name,'::class_versions)/sizeof(struct serialization::ClassVersion);',$gen:newline)
- ,'')
-};
declare variable $files external;
=== modified file 'src/runtime/store/pregenerated/documents.cpp'
--- src/runtime/store/pregenerated/documents.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/store/pregenerated/documents.cpp 2012-04-08 20:59:19 +0000
@@ -34,15 +34,9 @@
namespace zorba {
// <PutDocumentIterator>
-const char* PutDocumentIterator::class_name_str = "PutDocumentIterator";
PutDocumentIterator::class_factory<PutDocumentIterator>
PutDocumentIterator::g_class_factory;
-const serialization::ClassVersion
-PutDocumentIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int PutDocumentIterator::class_versions_count =
-sizeof(PutDocumentIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void PutDocumentIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -62,15 +56,9 @@
// <RemoveDocumentIterator>
-const char* RemoveDocumentIterator::class_name_str = "RemoveDocumentIterator";
RemoveDocumentIterator::class_factory<RemoveDocumentIterator>
RemoveDocumentIterator::g_class_factory;
-const serialization::ClassVersion
-RemoveDocumentIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int RemoveDocumentIterator::class_versions_count =
-sizeof(RemoveDocumentIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void RemoveDocumentIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -90,15 +78,9 @@
// <RetrieveDocumentIterator>
-const char* RetrieveDocumentIterator::class_name_str = "RetrieveDocumentIterator";
RetrieveDocumentIterator::class_factory<RetrieveDocumentIterator>
RetrieveDocumentIterator::g_class_factory;
-const serialization::ClassVersion
-RetrieveDocumentIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int RetrieveDocumentIterator::class_versions_count =
-sizeof(RetrieveDocumentIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void RetrieveDocumentIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -118,15 +100,9 @@
// <AvailableDocumentsIterator>
-const char* AvailableDocumentsIterator::class_name_str = "AvailableDocumentsIterator";
AvailableDocumentsIterator::class_factory<AvailableDocumentsIterator>
AvailableDocumentsIterator::g_class_factory;
-const serialization::ClassVersion
-AvailableDocumentsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int AvailableDocumentsIterator::class_versions_count =
-sizeof(AvailableDocumentsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void AvailableDocumentsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -148,15 +124,9 @@
// <IsAvailableDocumentIterator>
-const char* IsAvailableDocumentIterator::class_name_str = "IsAvailableDocumentIterator";
IsAvailableDocumentIterator::class_factory<IsAvailableDocumentIterator>
IsAvailableDocumentIterator::g_class_factory;
-const serialization::ClassVersion
-IsAvailableDocumentIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IsAvailableDocumentIterator::class_versions_count =
-sizeof(IsAvailableDocumentIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IsAvailableDocumentIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/store/pregenerated/maps.cpp'
--- src/runtime/store/pregenerated/maps.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/store/pregenerated/maps.cpp 2012-04-08 20:59:19 +0000
@@ -35,15 +35,9 @@
namespace zorba {
// <MapCreateIterator>
-const char* MapCreateIterator::class_name_str = "MapCreateIterator";
MapCreateIterator::class_factory<MapCreateIterator>
MapCreateIterator::g_class_factory;
-const serialization::ClassVersion
-MapCreateIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int MapCreateIterator::class_versions_count =
-sizeof(MapCreateIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void MapCreateIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -63,15 +57,9 @@
// <MapDestroyIterator>
-const char* MapDestroyIterator::class_name_str = "MapDestroyIterator";
MapDestroyIterator::class_factory<MapDestroyIterator>
MapDestroyIterator::g_class_factory;
-const serialization::ClassVersion
-MapDestroyIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int MapDestroyIterator::class_versions_count =
-sizeof(MapDestroyIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void MapDestroyIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -91,15 +79,9 @@
// <MapGetIterator>
-const char* MapGetIterator::class_name_str = "MapGetIterator";
MapGetIterator::class_factory<MapGetIterator>
MapGetIterator::g_class_factory;
-const serialization::ClassVersion
-MapGetIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int MapGetIterator::class_versions_count =
-sizeof(MapGetIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void MapGetIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -131,15 +113,9 @@
// <MapInsertIterator>
-const char* MapInsertIterator::class_name_str = "MapInsertIterator";
MapInsertIterator::class_factory<MapInsertIterator>
MapInsertIterator::g_class_factory;
-const serialization::ClassVersion
-MapInsertIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int MapInsertIterator::class_versions_count =
-sizeof(MapInsertIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void MapInsertIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -159,15 +135,9 @@
// <MapRemoveIterator>
-const char* MapRemoveIterator::class_name_str = "MapRemoveIterator";
MapRemoveIterator::class_factory<MapRemoveIterator>
MapRemoveIterator::g_class_factory;
-const serialization::ClassVersion
-MapRemoveIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int MapRemoveIterator::class_versions_count =
-sizeof(MapRemoveIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void MapRemoveIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -187,15 +157,9 @@
// <MapKeysIterator>
-const char* MapKeysIterator::class_name_str = "MapKeysIterator";
MapKeysIterator::class_factory<MapKeysIterator>
MapKeysIterator::g_class_factory;
-const serialization::ClassVersion
-MapKeysIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int MapKeysIterator::class_versions_count =
-sizeof(MapKeysIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void MapKeysIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -227,15 +191,9 @@
// <MapSizeIterator>
-const char* MapSizeIterator::class_name_str = "MapSizeIterator";
MapSizeIterator::class_factory<MapSizeIterator>
MapSizeIterator::g_class_factory;
-const serialization::ClassVersion
-MapSizeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int MapSizeIterator::class_versions_count =
-sizeof(MapSizeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void MapSizeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -255,15 +213,9 @@
// <AvailableMapsIterator>
-const char* AvailableMapsIterator::class_name_str = "AvailableMapsIterator";
AvailableMapsIterator::class_factory<AvailableMapsIterator>
AvailableMapsIterator::g_class_factory;
-const serialization::ClassVersion
-AvailableMapsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int AvailableMapsIterator::class_versions_count =
-sizeof(AvailableMapsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void AvailableMapsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/strings/pregenerated/strings.cpp'
--- src/runtime/strings/pregenerated/strings.cpp 2012-03-28 23:58:23 +0000
+++ src/runtime/strings/pregenerated/strings.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <CodepointsToStringIterator>
-const char* CodepointsToStringIterator::class_name_str = "CodepointsToStringIterator";
CodepointsToStringIterator::class_factory<CodepointsToStringIterator>
CodepointsToStringIterator::g_class_factory;
-const serialization::ClassVersion
-CodepointsToStringIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int CodepointsToStringIterator::class_versions_count =
-sizeof(CodepointsToStringIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void CodepointsToStringIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -61,15 +55,9 @@
// <StringToCodepointsIterator>
-const char* StringToCodepointsIterator::class_name_str = "StringToCodepointsIterator";
StringToCodepointsIterator::class_factory<StringToCodepointsIterator>
StringToCodepointsIterator::g_class_factory;
-const serialization::ClassVersion
-StringToCodepointsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int StringToCodepointsIterator::class_versions_count =
-sizeof(StringToCodepointsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void StringToCodepointsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -93,15 +81,9 @@
// <CompareStrIterator>
-const char* CompareStrIterator::class_name_str = "CompareStrIterator";
CompareStrIterator::class_factory<CompareStrIterator>
CompareStrIterator::g_class_factory;
-const serialization::ClassVersion
-CompareStrIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int CompareStrIterator::class_versions_count =
-sizeof(CompareStrIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void CompareStrIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -121,15 +103,9 @@
// <CodepointEqualIterator>
-const char* CodepointEqualIterator::class_name_str = "CodepointEqualIterator";
CodepointEqualIterator::class_factory<CodepointEqualIterator>
CodepointEqualIterator::g_class_factory;
-const serialization::ClassVersion
-CodepointEqualIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int CodepointEqualIterator::class_versions_count =
-sizeof(CodepointEqualIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void CodepointEqualIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -149,15 +125,9 @@
// <ConcatStrIterator>
-const char* ConcatStrIterator::class_name_str = "ConcatStrIterator";
ConcatStrIterator::class_factory<ConcatStrIterator>
ConcatStrIterator::g_class_factory;
-const serialization::ClassVersion
-ConcatStrIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ConcatStrIterator::class_versions_count =
-sizeof(ConcatStrIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ConcatStrIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -177,15 +147,9 @@
// <StringJoinIterator>
-const char* StringJoinIterator::class_name_str = "StringJoinIterator";
StringJoinIterator::class_factory<StringJoinIterator>
StringJoinIterator::g_class_factory;
-const serialization::ClassVersion
-StringJoinIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int StringJoinIterator::class_versions_count =
-sizeof(StringJoinIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void StringJoinIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -205,15 +169,9 @@
// <SubstringIterator>
-const char* SubstringIterator::class_name_str = "SubstringIterator";
SubstringIterator::class_factory<SubstringIterator>
SubstringIterator::g_class_factory;
-const serialization::ClassVersion
-SubstringIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SubstringIterator::class_versions_count =
-sizeof(SubstringIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SubstringIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -233,15 +191,9 @@
// <SubstringIntOptIterator>
-const char* SubstringIntOptIterator::class_name_str = "SubstringIntOptIterator";
SubstringIntOptIterator::class_factory<SubstringIntOptIterator>
SubstringIntOptIterator::g_class_factory;
-const serialization::ClassVersion
-SubstringIntOptIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SubstringIntOptIterator::class_versions_count =
-sizeof(SubstringIntOptIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SubstringIntOptIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -261,15 +213,9 @@
// <StringLengthIterator>
-const char* StringLengthIterator::class_name_str = "StringLengthIterator";
StringLengthIterator::class_factory<StringLengthIterator>
StringLengthIterator::g_class_factory;
-const serialization::ClassVersion
-StringLengthIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int StringLengthIterator::class_versions_count =
-sizeof(StringLengthIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void StringLengthIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -289,15 +235,9 @@
// <NormalizeSpaceIterator>
-const char* NormalizeSpaceIterator::class_name_str = "NormalizeSpaceIterator";
NormalizeSpaceIterator::class_factory<NormalizeSpaceIterator>
NormalizeSpaceIterator::g_class_factory;
-const serialization::ClassVersion
-NormalizeSpaceIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int NormalizeSpaceIterator::class_versions_count =
-sizeof(NormalizeSpaceIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void NormalizeSpaceIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -317,15 +257,9 @@
// <NormalizeUnicodeIterator>
-const char* NormalizeUnicodeIterator::class_name_str = "NormalizeUnicodeIterator";
NormalizeUnicodeIterator::class_factory<NormalizeUnicodeIterator>
NormalizeUnicodeIterator::g_class_factory;
-const serialization::ClassVersion
-NormalizeUnicodeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int NormalizeUnicodeIterator::class_versions_count =
-sizeof(NormalizeUnicodeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void NormalizeUnicodeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -345,15 +279,9 @@
// <UpperCaseIterator>
-const char* UpperCaseIterator::class_name_str = "UpperCaseIterator";
UpperCaseIterator::class_factory<UpperCaseIterator>
UpperCaseIterator::g_class_factory;
-const serialization::ClassVersion
-UpperCaseIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int UpperCaseIterator::class_versions_count =
-sizeof(UpperCaseIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void UpperCaseIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -373,15 +301,9 @@
// <LowerCaseIterator>
-const char* LowerCaseIterator::class_name_str = "LowerCaseIterator";
LowerCaseIterator::class_factory<LowerCaseIterator>
LowerCaseIterator::g_class_factory;
-const serialization::ClassVersion
-LowerCaseIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int LowerCaseIterator::class_versions_count =
-sizeof(LowerCaseIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void LowerCaseIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -401,15 +323,9 @@
// <TranslateIterator>
-const char* TranslateIterator::class_name_str = "TranslateIterator";
TranslateIterator::class_factory<TranslateIterator>
TranslateIterator::g_class_factory;
-const serialization::ClassVersion
-TranslateIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int TranslateIterator::class_versions_count =
-sizeof(TranslateIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void TranslateIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -429,15 +345,9 @@
// <EncodeForUriIterator>
-const char* EncodeForUriIterator::class_name_str = "EncodeForUriIterator";
EncodeForUriIterator::class_factory<EncodeForUriIterator>
EncodeForUriIterator::g_class_factory;
-const serialization::ClassVersion
-EncodeForUriIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int EncodeForUriIterator::class_versions_count =
-sizeof(EncodeForUriIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void EncodeForUriIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -457,15 +367,9 @@
// <IriToUriIterator>
-const char* IriToUriIterator::class_name_str = "IriToUriIterator";
IriToUriIterator::class_factory<IriToUriIterator>
IriToUriIterator::g_class_factory;
-const serialization::ClassVersion
-IriToUriIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int IriToUriIterator::class_versions_count =
-sizeof(IriToUriIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void IriToUriIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -485,15 +389,9 @@
// <EscapeHtmlUriIterator>
-const char* EscapeHtmlUriIterator::class_name_str = "EscapeHtmlUriIterator";
EscapeHtmlUriIterator::class_factory<EscapeHtmlUriIterator>
EscapeHtmlUriIterator::g_class_factory;
-const serialization::ClassVersion
-EscapeHtmlUriIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int EscapeHtmlUriIterator::class_versions_count =
-sizeof(EscapeHtmlUriIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void EscapeHtmlUriIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -513,15 +411,9 @@
// <ContainsIterator>
-const char* ContainsIterator::class_name_str = "ContainsIterator";
ContainsIterator::class_factory<ContainsIterator>
ContainsIterator::g_class_factory;
-const serialization::ClassVersion
-ContainsIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int ContainsIterator::class_versions_count =
-sizeof(ContainsIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void ContainsIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -541,15 +433,9 @@
// <StartsWithIterator>
-const char* StartsWithIterator::class_name_str = "StartsWithIterator";
StartsWithIterator::class_factory<StartsWithIterator>
StartsWithIterator::g_class_factory;
-const serialization::ClassVersion
-StartsWithIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int StartsWithIterator::class_versions_count =
-sizeof(StartsWithIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void StartsWithIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -569,15 +455,9 @@
// <EndsWithIterator>
-const char* EndsWithIterator::class_name_str = "EndsWithIterator";
EndsWithIterator::class_factory<EndsWithIterator>
EndsWithIterator::g_class_factory;
-const serialization::ClassVersion
-EndsWithIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int EndsWithIterator::class_versions_count =
-sizeof(EndsWithIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void EndsWithIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -597,15 +477,9 @@
// <SubstringBeforeIterator>
-const char* SubstringBeforeIterator::class_name_str = "SubstringBeforeIterator";
SubstringBeforeIterator::class_factory<SubstringBeforeIterator>
SubstringBeforeIterator::g_class_factory;
-const serialization::ClassVersion
-SubstringBeforeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SubstringBeforeIterator::class_versions_count =
-sizeof(SubstringBeforeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SubstringBeforeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -625,15 +499,9 @@
// <SubstringAfterIterator>
-const char* SubstringAfterIterator::class_name_str = "SubstringAfterIterator";
SubstringAfterIterator::class_factory<SubstringAfterIterator>
SubstringAfterIterator::g_class_factory;
-const serialization::ClassVersion
-SubstringAfterIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int SubstringAfterIterator::class_versions_count =
-sizeof(SubstringAfterIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void SubstringAfterIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -653,15 +521,9 @@
// <FnMatchesIterator>
-const char* FnMatchesIterator::class_name_str = "FnMatchesIterator";
FnMatchesIterator::class_factory<FnMatchesIterator>
FnMatchesIterator::g_class_factory;
-const serialization::ClassVersion
-FnMatchesIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnMatchesIterator::class_versions_count =
-sizeof(FnMatchesIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnMatchesIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -681,15 +543,9 @@
// <FnReplaceIterator>
-const char* FnReplaceIterator::class_name_str = "FnReplaceIterator";
FnReplaceIterator::class_factory<FnReplaceIterator>
FnReplaceIterator::g_class_factory;
-const serialization::ClassVersion
-FnReplaceIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnReplaceIterator::class_versions_count =
-sizeof(FnReplaceIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnReplaceIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -709,15 +565,9 @@
// <FnTokenizeIterator>
-const char* FnTokenizeIterator::class_name_str = "FnTokenizeIterator";
FnTokenizeIterator::class_factory<FnTokenizeIterator>
FnTokenizeIterator::g_class_factory;
-const serialization::ClassVersion
-FnTokenizeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnTokenizeIterator::class_versions_count =
-sizeof(FnTokenizeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnTokenizeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -747,15 +597,9 @@
// <FnAnalyzeStringIterator>
-const char* FnAnalyzeStringIterator::class_name_str = "FnAnalyzeStringIterator";
FnAnalyzeStringIterator::class_factory<FnAnalyzeStringIterator>
FnAnalyzeStringIterator::g_class_factory;
-const serialization::ClassVersion
-FnAnalyzeStringIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int FnAnalyzeStringIterator::class_versions_count =
-sizeof(FnAnalyzeStringIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void FnAnalyzeStringIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -775,15 +619,9 @@
// <StringMaterializeIterator>
-const char* StringMaterializeIterator::class_name_str = "StringMaterializeIterator";
StringMaterializeIterator::class_factory<StringMaterializeIterator>
StringMaterializeIterator::g_class_factory;
-const serialization::ClassVersion
-StringMaterializeIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int StringMaterializeIterator::class_versions_count =
-sizeof(StringMaterializeIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void StringMaterializeIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -803,15 +641,9 @@
// <StringIsStreamableIterator>
-const char* StringIsStreamableIterator::class_name_str = "StringIsStreamableIterator";
StringIsStreamableIterator::class_factory<StringIsStreamableIterator>
StringIsStreamableIterator::g_class_factory;
-const serialization::ClassVersion
-StringIsStreamableIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int StringIsStreamableIterator::class_versions_count =
-sizeof(StringIsStreamableIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void StringIsStreamableIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -831,15 +663,9 @@
// <StringSplitIterator>
-const char* StringSplitIterator::class_name_str = "StringSplitIterator";
StringSplitIterator::class_factory<StringSplitIterator>
StringSplitIterator::g_class_factory;
-const serialization::ClassVersion
-StringSplitIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int StringSplitIterator::class_versions_count =
-sizeof(StringSplitIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void StringSplitIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/update/update.cpp'
--- src/runtime/update/update.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/update/update.cpp 2012-04-08 20:59:19 +0000
@@ -49,22 +49,16 @@
{
SERIALIZABLE_CLASS_VERSIONS(InsertIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(InsertIterator)
SERIALIZABLE_CLASS_VERSIONS(DeleteIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(DeleteIterator)
SERIALIZABLE_CLASS_VERSIONS(ReplaceIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(ReplaceIterator)
SERIALIZABLE_CLASS_VERSIONS(RenameIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(RenameIterator)
SERIALIZABLE_CLASS_VERSIONS(CopyClause)
-END_SERIALIZABLE_CLASS_VERSIONS(CopyClause)
SERIALIZABLE_CLASS_VERSIONS(TransformIterator)
-END_SERIALIZABLE_CLASS_VERSIONS(TransformIterator)
void areNodeModifiersViolated(
=== modified file 'src/runtime/uris/pregenerated/uris.cpp'
--- src/runtime/uris/pregenerated/uris.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/uris/pregenerated/uris.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <DecodeURIIterator>
-const char* DecodeURIIterator::class_name_str = "DecodeURIIterator";
DecodeURIIterator::class_factory<DecodeURIIterator>
DecodeURIIterator::g_class_factory;
-const serialization::ClassVersion
-DecodeURIIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int DecodeURIIterator::class_versions_count =
-sizeof(DecodeURIIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void DecodeURIIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/runtime/xqdoc/pregenerated/xqdoc.cpp'
--- src/runtime/xqdoc/pregenerated/xqdoc.cpp 2012-03-28 05:19:57 +0000
+++ src/runtime/xqdoc/pregenerated/xqdoc.cpp 2012-04-08 20:59:19 +0000
@@ -33,15 +33,9 @@
namespace zorba {
// <XQDocIterator>
-const char* XQDocIterator::class_name_str = "XQDocIterator";
XQDocIterator::class_factory<XQDocIterator>
XQDocIterator::g_class_factory;
-const serialization::ClassVersion
-XQDocIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int XQDocIterator::class_versions_count =
-sizeof(XQDocIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void XQDocIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
@@ -61,15 +55,9 @@
// <XQDocContentIterator>
-const char* XQDocContentIterator::class_name_str = "XQDocContentIterator";
XQDocContentIterator::class_factory<XQDocContentIterator>
XQDocContentIterator::g_class_factory;
-const serialization::ClassVersion
-XQDocContentIterator::class_versions[] ={{ 1, 0x000905, false}};
-
-const int XQDocContentIterator::class_versions_count =
-sizeof(XQDocContentIterator::class_versions)/sizeof(struct serialization::ClassVersion);
void XQDocContentIterator::accept(PlanIterVisitor& v) const {
v.beginVisit(*this);
=== modified file 'src/types/node_test.cpp'
--- src/types/node_test.cpp 2012-03-28 05:19:57 +0000
+++ src/types/node_test.cpp 2012-04-08 20:59:19 +0000
@@ -23,7 +23,6 @@
{
SERIALIZABLE_CLASS_VERSIONS(NodeNameTest)
-END_SERIALIZABLE_CLASS_VERSIONS(NodeNameTest)
=== modified file 'src/types/schema/schema.cpp'
--- src/types/schema/schema.cpp 2012-03-28 05:19:57 +0000
+++ src/types/schema/schema.cpp 2012-04-08 20:59:19 +0000
@@ -59,7 +59,6 @@
namespace zorba
{
SERIALIZABLE_CLASS_VERSIONS(Schema)
-END_SERIALIZABLE_CLASS_VERSIONS(Schema)
//#define DO_TRACE
//#define DO_PRINT_SCHEMA_INFO
=== modified file 'src/types/typeimpl.cpp'
--- src/types/typeimpl.cpp 2012-03-28 05:19:57 +0000
+++ src/types/typeimpl.cpp 2012-04-08 20:59:19 +0000
@@ -41,40 +41,28 @@
SERIALIZABLE_CLASS_VERSIONS(XQType)
-END_SERIALIZABLE_CLASS_VERSIONS(XQType)
SERIALIZABLE_CLASS_VERSIONS(AtomicXQType)
-END_SERIALIZABLE_CLASS_VERSIONS(AtomicXQType)
SERIALIZABLE_CLASS_VERSIONS(NodeXQType)
-END_SERIALIZABLE_CLASS_VERSIONS(NodeXQType)
SERIALIZABLE_CLASS_VERSIONS(FunctionXQType)
-END_SERIALIZABLE_CLASS_VERSIONS(FunctionXQType)
SERIALIZABLE_CLASS_VERSIONS(ItemXQType)
-END_SERIALIZABLE_CLASS_VERSIONS(ItemXQType)
SERIALIZABLE_CLASS_VERSIONS(AnyXQType)
-END_SERIALIZABLE_CLASS_VERSIONS(AnyXQType)
SERIALIZABLE_CLASS_VERSIONS(AnySimpleXQType)
-END_SERIALIZABLE_CLASS_VERSIONS(AnySimpleXQType)
SERIALIZABLE_CLASS_VERSIONS(AnyFunctionXQType)
-END_SERIALIZABLE_CLASS_VERSIONS(AnyFunctionXQType)
SERIALIZABLE_CLASS_VERSIONS(UntypedXQType)
-END_SERIALIZABLE_CLASS_VERSIONS(UntypedXQType)
SERIALIZABLE_CLASS_VERSIONS(EmptyXQType)
-END_SERIALIZABLE_CLASS_VERSIONS(EmptyXQType)
SERIALIZABLE_CLASS_VERSIONS(NoneXQType)
-END_SERIALIZABLE_CLASS_VERSIONS(NoneXQType)
SERIALIZABLE_CLASS_VERSIONS(UserDefinedXQType)
-END_SERIALIZABLE_CLASS_VERSIONS(UserDefinedXQType)
const char* XQType::KIND_STRINGS[XQType::MAX_TYPE_KIND] =
=== modified file 'src/types/typemanagerimpl.cpp'
--- src/types/typemanagerimpl.cpp 2012-03-28 05:19:57 +0000
+++ src/types/typemanagerimpl.cpp 2012-04-08 20:59:19 +0000
@@ -52,10 +52,8 @@
#endif
SERIALIZABLE_CLASS_VERSIONS(TypeManager)
-END_SERIALIZABLE_CLASS_VERSIONS(TypeManager)
SERIALIZABLE_CLASS_VERSIONS(TypeManagerImpl)
-END_SERIALIZABLE_CLASS_VERSIONS(TypeManagerImpl)
/***************************************************************************//**
=== modified file 'src/zorbaserialization/CMakeLists.txt'
--- src/zorbaserialization/CMakeLists.txt 2012-04-04 13:25:43 +0000
+++ src/zorbaserialization/CMakeLists.txt 2012-04-08 20:59:19 +0000
@@ -22,7 +22,6 @@
serialize_basic_types.cpp
base64impl.cpp
class_serializer.cpp
- zorba_classes_version.cpp
zorba_class_serializer.cpp
zorba_class_versions.cpp
)
=== modified file 'src/zorbaserialization/archiver.cpp'
--- src/zorbaserialization/archiver.cpp 2012-04-04 13:25:43 +0000
+++ src/zorbaserialization/archiver.cpp 2012-04-08 20:59:19 +0000
@@ -44,7 +44,6 @@
bool is_class,
const void* value,
const void* assoc_ptr,
- int version,
enum ArchiveFieldKind kind,
archive_field* refered,
int only_for_eval,
@@ -56,8 +55,6 @@
theIsSimple = is_simple;
theIsClass = is_class;
- theClassVersion = version;
-
theTypeName = strdup(type);
theTypeNamePosInPool = 0;//initialy is the number of references to this field
@@ -120,7 +117,7 @@
theSerializingOut(is_serializing_out),
serialize_base_class(false),
all_reference_list(0),
- theArchiveVersion(g_zorba_classes_version),
+ theArchiveVersion(ClassSerializer::g_zorba_classes_version),
theRootField(0),
current_compound_field(0),
theSimpleFieldsMap(0),
@@ -146,7 +143,6 @@
false, // is_class
NULL, // value
NULL, // assoc_ptr
- 0, // version
ARCHIVE_FIELD_NORMAL,
NULL, // referred
false, // only for eval
@@ -321,7 +317,6 @@
false, // is_class
value,
ptr,
- 0, // version
fieldKind,
ref_field,
get_serialize_only_for_eval(),
@@ -432,7 +427,6 @@
********************************************************************************/
bool Archiver::add_compound_field(
const char* type,
- int version,
bool is_class,
const void* info,
const void* ptr,//for classes, pointer to SerializeBaseClass
@@ -490,7 +484,6 @@
is_class,
info,
ptr,
- version,
fieldKind,
ref_field,
get_serialize_only_for_eval(),
@@ -593,15 +586,17 @@
char** type,
std::string* value,
int* id,
- int* version,
bool* is_simple,
bool* is_class,
enum ArchiveFieldKind* fieldKind,
int* referencing)
{
- bool retval = read_next_field_impl(type, value, id, version, is_simple, is_class, fieldKind, referencing);
- if(retval && !*is_simple && (*fieldKind != ARCHIVE_FIELD_REFERENCING))
+ bool retval = read_next_field_impl(type, value, id,
+ is_simple, is_class, fieldKind, referencing);
+
+ if (retval && !*is_simple && (*fieldKind != ARCHIVE_FIELD_REFERENCING))
theCurrentLevel++;
+
return retval;
}
@@ -945,30 +940,12 @@
/*******************************************************************************
********************************************************************************/
-int Archiver::get_class_version()
-{
- return current_class_version;
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
-void Archiver::set_class_version(int new_class_version)
-{
- current_class_version = new_class_version;
-}
-
-
-/*******************************************************************************
-
-********************************************************************************/
void Archiver::root_tag_is_read()
{
- if (theArchiveVersion != g_zorba_classes_version)
+ if (theArchiveVersion != ClassSerializer::g_zorba_classes_version)
{
throw ZORBA_EXCEPTION(zerr::ZCSE0012_INCOMPATIBLE_ARCHIVE_VERSION,
- ERROR_PARAMS(theArchiveVersion, g_zorba_classes_version));
+ ERROR_PARAMS(theArchiveVersion, ClassSerializer::g_zorba_classes_version));
}
all_reference_list = new void*[nr_ids+1];
@@ -1013,7 +990,6 @@
current_field->theIsClass,
"",
NULL,
- 0,
ARCHIVE_FIELD_NULL,
NULL,
false,
=== modified file 'src/zorbaserialization/archiver.h'
--- src/zorbaserialization/archiver.h 2012-04-04 13:25:43 +0000
+++ src/zorbaserialization/archiver.h 2012-04-08 20:59:19 +0000
@@ -135,10 +135,6 @@
considered as "compound", so if theIsClass is true, theIsSimple is false.
However, the reverse is not true: a non-class obj may be simple or compound.
- theClassVersion:
- ----------------
- If this field represents a class obj, the class version of that obj.
-
theKind:
--------
The kind of the field. See ArchiveFieldKind enum above.
@@ -216,7 +212,6 @@
bool theIsSimple;
bool theIsClass;
- unsigned int theClassVersion;
enum ArchiveFieldKind theKind;
@@ -260,7 +255,6 @@
bool is_class,
const void* value,
const void* assoc_ptr,
- int version,
enum ArchiveFieldKind kind,
archive_field* refered,
int only_for_eval,
@@ -411,7 +405,6 @@
bool add_compound_field(
const char* type,
- int version,
bool is_class,
const void* info,
const void* ptr,//for classes, pointer to SerializeBaseClass
@@ -425,7 +418,6 @@
char** type,
std::string* value,
int* id,
- int* version,
bool* is_simple,
bool* is_class,
enum ArchiveFieldKind* field_treat,
@@ -437,7 +429,6 @@
char** type,
std::string* value,
int* id,
- int* version,
bool* is_simple,
bool* is_class,
enum ArchiveFieldKind* field_treat,
@@ -550,10 +541,6 @@
void register_item(store::Item* i);
- int get_class_version();
-
- void set_class_version(int new_class_version);
-
//to help check class name at runtime
void set_serialize_base_class(bool s)
{
=== modified file 'src/zorbaserialization/bin_archiver.cpp'
--- src/zorbaserialization/bin_archiver.cpp 2012-04-04 13:25:43 +0000
+++ src/zorbaserialization/bin_archiver.cpp 2012-04-08 20:59:19 +0000
@@ -422,9 +422,6 @@
if(current_field->theKind != ARCHIVE_FIELD_REFERENCING)
{
-#ifndef NDEBUG
- write_int(current_field->theClassVersion);
-#endif
if(!current_field->theValuePosInPool)
write_int_exp2(current_field->theValuePosInPool);
else
@@ -602,22 +599,6 @@
********************************************************************************/
void BinArchiver::read_string(std::string &str)
{
- //char c;
- //while(1)
- //{
- // is->read(&c, 1);
- // if(is->gcount() < 1)
- // {
- // throw ZORBA_EXCEPTION(
- // zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS( id )
- // );
- // }
- //
- // if(c)
- // str += c;
- // else
- // break;
- //}
str = (char*)in_current;
while(*in_current) in_current++;
in_current++;
@@ -629,21 +610,6 @@
********************************************************************************/
void BinArchiver::read_string(char* str)
{
- //char c;
- //while(1)
- //{
- // is->read(&c, 1);
- // if(is->gcount() < 1)
- // {
- // throw ZORBA_EXCEPTION(
- // zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS( id )
- // );
- // }
- // *str = c;
- // if(!c)
- // break;
- // str++;
- //}
while(*in_current)
{
*str = *in_current;
@@ -807,7 +773,6 @@
char** type,
std::string* value,
int* id,
- int* version,
bool* is_simple,
bool* is_class,
enum ArchiveFieldKind* field_treat,
@@ -820,7 +785,6 @@
*type = NULL;
*id = -1;
- *version = -1;
#ifndef NDEBUG
*is_simple = false;
*is_class = false;
@@ -869,9 +833,6 @@
this->last_id = *id;
if(*field_treat != ARCHIVE_FIELD_REFERENCING)
{
-#ifndef NDEBUG
- *version = read_int();
-#endif
unsigned int value_pos;
value_pos = read_int_exp2();
if(value_pos)
=== modified file 'src/zorbaserialization/bin_archiver.h'
--- src/zorbaserialization/bin_archiver.h 2012-03-28 05:19:57 +0000
+++ src/zorbaserialization/bin_archiver.h 2012-04-08 20:59:19 +0000
@@ -74,7 +74,6 @@
char** type,
std::string* value,
int* id,
- int* version,
bool* is_simple,
bool* is_class,
enum ArchiveFieldKind* field_treat,
=== modified file 'src/zorbaserialization/class_serializer.cpp'
--- src/zorbaserialization/class_serializer.cpp 2012-04-04 13:25:43 +0000
+++ src/zorbaserialization/class_serializer.cpp 2012-04-08 20:59:19 +0000
@@ -36,15 +36,15 @@
class ClassFactoriesCompare
{
public:
- uint32_t hash(const char * s1) const
+ uint32_t hash(const char* s1) const
{
- uint32_t h = 0;
- h = hashfun::h32(s1, FNV_32_INIT);
+ uint32_t h = hashfun::h32(s1, FNV_32_INIT);
return h;
}
+
bool equal(const char * s1, const char * s2) const
{
- if((s1 == s2) || !strcmp(s1, s2))
+ if (s1 == s2 || !strcmp(s1, s2))
return true;
else
return false;
@@ -55,30 +55,36 @@
/*******************************************************************************
********************************************************************************/
-class ClassFactoriesMap : public zorba::HashMap<const char *, class_deserializer *, ClassFactoriesCompare>
+class ClassFactoriesMap : public zorba::HashMap<const char*,
+ class_deserializer*,
+ ClassFactoriesCompare>
{
public:
- ClassFactoriesMap(ulong sz = 1024) :
- zorba::HashMap<const char *, class_deserializer *, ClassFactoriesCompare>(sz, false) {}
+ ClassFactoriesMap(ulong sz = 1024)
+ :
+ zorba::HashMap<const char*, class_deserializer*, ClassFactoriesCompare>(sz, false)
+ {
+ }
};
-//////////////////////////////////////////////
-///////////////////////////////////////////Global serialization Operators
-
-/*******************************************************************************
-
-********************************************************************************/
-ClassSerializer::ClassSerializer() : class_names(1000), class_names_count(0)
+/*******************************************************************************
+
+********************************************************************************/
+const unsigned long ClassSerializer::g_zorba_classes_version = 25;
+
+
+/*******************************************************************************
+
+********************************************************************************/
+ClassSerializer::ClassSerializer()
+ :
+ class_names(1000),
+ class_names_count(0)
{
-/*
- class_name_pool_size = 10000;
- class_name_pool = (char*)malloc(class_name_pool_size);
- class_name_pool_filled = 0;
-*/
- class_factories = NULL;//new ClassFactoriesMap;
+ class_factories = NULL;
+
t0 = clock();
-// g_class_serializer_destroyer.activate();
harcoded_objects_archive = NULL;
harcoded_objects_archive = new MemArchiver(true, true);//simulate serialize out
@@ -90,9 +96,6 @@
********************************************************************************/
ClassSerializer::~ClassSerializer()
{
-/*
- free(class_name_pool);
-*/
delete class_factories;
delete harcoded_objects_archive;
}
@@ -112,35 +115,10 @@
********************************************************************************/
void ClassSerializer::register_class_factory(
- const char *class_name,
- class_deserializer *class_factory)
+ const char* class_name,
+ class_deserializer* class_factory)
{
-/*+
-#ifndef NDEBUG
- //check for class name duplicates
- if(get_class_factory(class_name))
- {
- assert(false);
- }
-#endif
-*/
-/* int name_size = strlen(class_name);
- if((name_size + class_name_pool_filled + 1) > class_name_pool_size)
- {
- class_name_pool_size += 10000;
- class_name_pool = (char*)realloc(class_name_pool, class_name_pool_size);
- }
-// std::cout << "register class factory " << class_name << std::endl;
- class_factories->resize(class_factories->size()+1);
- ClassSerializer::registered_factory &r = class_factories->back();
- //strcpy(r.class_name, class_name);
- strcpy(class_name_pool + class_name_pool_filled, class_name);
- r.cls_name_off = class_name_pool_filled;
- class_name_pool_filled += name_size + 1;
- r.class_factory = class_factory;
-*/
-
- if(class_factories)
+ if (class_factories)
{
class_factories->insert(class_name, class_factory);
}
@@ -148,7 +126,7 @@
{
class_names[class_names_count++] = std::pair<const char *, class_deserializer*>(class_name, class_factory);
}
-// printf("register class_factory %s\n", class_name);
+
t1 = clock();
}
@@ -156,28 +134,22 @@
/*******************************************************************************
********************************************************************************/
-class_deserializer *ClassSerializer::get_class_factory(const char *classname)
+class_deserializer* ClassSerializer::get_class_factory(const char* classname)
{
-/*
- std::list<struct registered_factory>::iterator it;
- for(it = class_factories->begin(); it != class_factories->end(); it++)
- {
- if(!strcmp(class_name_pool + (*it).cls_name_off, classname))
- return (*it).class_factory;
- }
- return NULL;
-*/
- if(class_factories == NULL)
+ if (class_factories == NULL)
{
class_factories = new ClassFactoriesMap;
+
int i;
- std::vector<std::pair<const char *, class_deserializer*> >::iterator cls_it = class_names.begin();
- for(i=0;i<class_names_count;i++, cls_it++)
+ std::vector<std::pair<const char*, class_deserializer*> >::iterator cls_it = class_names.begin();
+
+ for (i = 0; i < class_names_count; i++, cls_it++)
{
class_factories->insert((*cls_it).first, (*cls_it).second);
}
}
- class_deserializer *cls_factory = NULL;
+
+ class_deserializer* cls_factory = NULL;
class_factories->get(classname, cls_factory);
return cls_factory;
}
@@ -193,13 +165,13 @@
/*******************************************************************************
-
+ called at shutdown
********************************************************************************/
void ClassSerializer::destroyArchiverForHardcodedObjects()
{
delete harcoded_objects_archive;
harcoded_objects_archive = NULL;
- harcoded_objects_archive = new MemArchiver(true, true);//simulate serialize out
+ harcoded_objects_archive = new MemArchiver(true, true);
}
=== modified file 'src/zorbaserialization/class_serializer.h'
--- src/zorbaserialization/class_serializer.h 2012-04-04 13:25:43 +0000
+++ src/zorbaserialization/class_serializer.h 2012-04-08 20:59:19 +0000
@@ -45,25 +45,15 @@
class ClassFactoriesMap;
-#define BACKWARD_COMPATIBLE true
-#define ZORBA_VERSION_1_5_0 0x010500
-
-extern const unsigned long g_zorba_classes_version;
-
-
/*******************************************************************************
-
+ The classes and macros defined in this file provide a generic infrastructure
+ for making an arbitrary c++ class serializable. This infrastructure is provided
+ for convenience; not every c++ type has to adopt this inftrasture.
********************************************************************************/
-struct ClassVersion
-{
- int class_version;
- unsigned long zorba_version;
- bool is_backward_compatible;
-};
/*******************************************************************************
- Derive all classes that need to be serialized from this base class
+ A base class for other c++ classes that need to be serialized.
********************************************************************************/
class ZORBA_DLL_PUBLIC SerializeBaseClass
{
@@ -71,10 +61,6 @@
virtual ~SerializeBaseClass() {}
virtual void serialize_internal(Archiver& ar) = 0;
-
- virtual const ClassVersion& get_classversion(int v) const = 0;
-
- virtual int get_version_count() const = 0;
};
@@ -98,6 +84,31 @@
};
+/*******************************************************************************
+
+********************************************************************************/
+#define SERIALIZABLE_CLASS_FACTORY_DECL(class_name, creator) \
+template<class T_serialized_class> \
+class class_factory : public ::zorba::serialization::class_deserializer \
+{ \
+public: \
+ class_factory() \
+ { \
+ serialization::ClassSerializer::getInstance()-> \
+ register_class_factory(T_serialized_class::get_class_name_str_static(), this); \
+ } \
+ \
+ virtual serialization::SerializeBaseClass* create_new(serialization::Archiver& ar) \
+ { \
+ return creator; \
+ } \
+ \
+ virtual void cast_ptr(serialization::SerializeBaseClass* ptr, void** class_ptr)\
+ { \
+ *class_ptr = (void*)dynamic_cast<T_serialized_class*>(ptr); \
+ } \
+};
+
/*******************************************************************************
stateless class, multithreading safe
@@ -124,6 +135,9 @@
{
friend class Archiver;
+public:
+ static const unsigned long g_zorba_classes_version;
+
private:
std::vector<std::pair<const char*, class_deserializer*> > class_names;
int class_names_count;
@@ -143,13 +157,13 @@
~ClassSerializer();
- void register_class_factory(const char *, class_deserializer *);
+ void register_class_factory(const char* className, class_deserializer* d);
- class_deserializer* get_class_factory(const char *classname);
+ class_deserializer* get_class_factory(const char* classname);
Archiver* getArchiverForHardcodedObjects();
- void destroyArchiverForHardcodedObjects();//called at shutdown
+ void destroyArchiverForHardcodedObjects();
clock_t get_registration_time() { return t1-t0;}
};
@@ -158,98 +172,6 @@
/*******************************************************************************
********************************************************************************/
-#define SERIALIZABLE_CLASS(class_name) \
-SERIALIZABLE_CLASS_PREFIX(class_name) \
-SERIALIZABLE_CLASS_FACTORY_DECL(class_name, new class_name(ar)) \
-static const char * class_name_str; \
-static const int class_versions_count; \
-static const struct serialization::ClassVersion class_versions[]; \
-static class_factory<class_name> g_class_factory;
-
-
-#define SERIALIZABLE_ABSTRACT_CLASS(class_name) \
-SERIALIZABLE_CLASS_PREFIX(class_name) \
-SERIALIZABLE_CLASS_FACTORY_DECL(class_name, NULL) \
-static const char * class_name_str; \
-static const int class_versions_count; \
-static const struct serialization::ClassVersion class_versions[]; \
-static class_factory<class_name> g_class_factory;
-
-
-#define SERIALIZABLE_TEMPLATE_CLASS(class_name) \
-SERIALIZABLE_CLASS_PREFIX(class_name) \
-SERIALIZABLE_CLASS_FACTORY_DECL(class_name, new class_name(ar)) \
-static const char * class_name_str; \
-static const int class_versions_count; \
-static const struct serialization::ClassVersion * class_versions;
-
-
-#define SERIALIZABLE_TEMPLATE_ABSTRACT_CLASS(class_name) \
-SERIALIZABLE_CLASS_PREFIX(class_name) \
-SERIALIZABLE_CLASS_FACTORY_DECL(class_name, NULL) \
-static const char * class_name_str; \
-static const int class_versions_count; \
-static const struct serialization::ClassVersion * class_versions;
-
-
-/*******************************************************************************
-
-********************************************************************************/
-#define SERIALIZABLE_CLASS_PREFIX(class_name) \
-virtual void serialize_internal(::zorba::serialization::Archiver& ar) \
-{ \
- CHECK_CLASS_NAME(class_name); \
- \
- if (ar.is_serialize_base_class()) \
- ar.set_serialize_base_class(false); \
- class_name::serialize(ar); \
-} \
- \
-virtual const serialization::ClassVersion& get_classversion(int v) const \
-{ \
- return class_versions[v]; \
-} \
- \
-virtual int get_version_count() const \
-{ \
- return class_versions_count; \
-} \
- \
-virtual const char* get_class_name_str() const { return class_name_str; } \
- \
-static const char* get_class_name_str_static() { return class_name_str; }
-
-
-/*******************************************************************************
-
-********************************************************************************/
-#define SERIALIZABLE_CLASS_FACTORY_DECL(class_name, creator) \
-template<class T_serialized_class> \
-class class_factory : public ::zorba::serialization::class_deserializer \
-{ \
-public: \
- class_factory() \
- { \
- /*register this class into plan serializer*/ \
- serialization::ClassSerializer::getInstance()-> \
- register_class_factory(T_serialized_class::get_class_name_str_static(), this); \
- } \
- \
- virtual serialization::SerializeBaseClass* create_new(serialization::Archiver& ar) \
- { \
- return creator; \
- } \
- \
- virtual void cast_ptr(serialization::SerializeBaseClass* ptr, void** class_ptr)\
- { \
- *class_ptr = (void*)dynamic_cast<T_serialized_class*>(ptr); \
- } \
-};
-
-
-/*******************************************************************************
-
-********************************************************************************/
#define SERIALIZABLE_CLASS_NO_FACTORY(class_name) \
virtual void serialize_internal(::zorba::serialization::Archiver& ar) \
{ \
@@ -260,67 +182,88 @@
class_name::serialize(ar); \
} \
\
-virtual const serialization::ClassVersion& get_classversion(int v) const \
-{ \
- return g_##class_name##_class_versions[v]; \
-} \
- \
-virtual int get_version_count() const \
-{ \
- return g_##class_name##_class_versions_count; \
-} \
- \
-virtual const char* get_class_name_str() const {return #class_name;} \
- \
-static const char* get_class_name_str_static() {return #class_name;}
-
-
-
-/*******************************************************************************
- Init the serialization-related static members of a non-template serializable
- class.
-********************************************************************************/
-
-//
-// Static members of non-template classes
-//
-#define SERIALIZABLE_CLASS_VERSIONS(class_name) \
- \
-const char* class_name::class_name_str = #class_name; \
- \
-class_name::class_factory<class_name> class_name::g_class_factory; \
- \
-const serialization::ClassVersion class_name::class_versions[] = \
-{{ 1, ZORBA_VERSION_1_5_0, !BACKWARD_COMPATIBLE}
-
-
-#define CLASS_VERSION(class_version, zorba_version, compatibility, description) \
- ,{class_version, zorba_version, compatibility}
-
-
-#define END_SERIALIZABLE_CLASS_VERSIONS(class_name) \
- }; \
- const int class_name::class_versions_count = \
- sizeof(class_name::class_versions)/sizeof(struct serialization::ClassVersion);
-
-
-//
-// Define the "versions" and "versions count" static data members of the template class
-//
-#define SERIALIZABLE_TEMPLATE_VERSIONS(template_name) \
-extern const ::zorba::serialization::ClassVersion g_##template_name##_class_versions[] = \
-{{ 1, ZORBA_VERSION_1_5_0, !BACKWARD_COMPATIBLE}
-
-//add CLASS_VERSION here
-
-#define END_SERIALIZABLE_TEMPLATE_VERSIONS(template_name) \
-}; \
-extern const int g_##template_name##_class_versions_count = \
-sizeof(g_##template_name##_class_versions)/sizeof(struct ::zorba::serialization::ClassVersion);
-
-
-//
-// Define the versions dependency from template instance to template versions
+virtual const char* get_class_name_str() const { return #class_name; } \
+ \
+static const char* get_class_name_str_static() { return #class_name; }
+
+
+/*******************************************************************************
+
+********************************************************************************/
+#define SERIALIZABLE_CLASS(class_name) \
+SERIALIZABLE_CLASS_PREFIX(class_name) \
+SERIALIZABLE_CLASS_FACTORY_DECL(class_name, new class_name(ar)) \
+static class_factory<class_name> g_class_factory;
+
+
+#define SERIALIZABLE_ABSTRACT_CLASS(class_name) \
+SERIALIZABLE_CLASS_PREFIX(class_name) \
+SERIALIZABLE_CLASS_FACTORY_DECL(class_name, NULL) \
+static class_factory<class_name> g_class_factory;
+
+
+#define SERIALIZABLE_CLASS_PREFIX(class_name) \
+virtual void serialize_internal(::zorba::serialization::Archiver& ar) \
+{ \
+ CHECK_CLASS_NAME(class_name); \
+ \
+ if (ar.is_serialize_base_class()) \
+ ar.set_serialize_base_class(false); \
+ \
+ class_name::serialize(ar); \
+} \
+ \
+virtual const char* get_class_name_str() const { return #class_name; } \
+ \
+static const char* get_class_name_str_static() { return #class_name; }
+
+
+#define SERIALIZABLE_CLASS_VERSIONS(class_name) \
+class_name::class_factory<class_name> class_name::g_class_factory;
+
+
+/*******************************************************************************
+
+********************************************************************************/
+#define SERIALIZABLE_TEMPLATE_CLASS(class_name) \
+SERIALIZABLE_TEMPLATE_CLASS_PREFIX(class_name) \
+SERIALIZABLE_CLASS_FACTORY_DECL(class_name, new class_name(ar)) \
+static const char * class_name_str;
+
+
+#define SERIALIZABLE_TEMPLATE_ABSTRACT_CLASS(class_name) \
+SERIALIZABLE_TEMPLATE_CLASS_PREFIX(class_name) \
+SERIALIZABLE_CLASS_FACTORY_DECL(class_name, NULL) \
+static const char * class_name_str;
+
+
+#define SERIALIZABLE_TEMPLATE_CLASS_PREFIX(class_name) \
+virtual void serialize_internal(::zorba::serialization::Archiver& ar) \
+{ \
+ CHECK_CLASS_NAME(class_name); \
+ \
+ if (ar.is_serialize_base_class()) \
+ ar.set_serialize_base_class(false); \
+ \
+ class_name::serialize(ar); \
+} \
+ \
+virtual const char* get_class_name_str() const { return class_name_str; } \
+ \
+static const char* get_class_name_str_static() { return class_name_str; }
+
+
+/*******************************************************************************
+ Init the serialization-related static members of a serializable class.
+********************************************************************************/
+
+
+//
+// Static members of template classes with one template param.
+//
+// The "index" param of the macro is used as a unique id for each specific
+// instantiation of the template class.
+//
// Example:
//
// SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(
@@ -328,16 +271,10 @@
// serializable_ItemPointerHashMap<StaticallyKnownCollection_t>,
// 1)
//
-#define SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(template_name, instance_name, index) \
- \
-instance_name::class_factory<instance_name> g_class_factory_##template_name##_##index; \
- \
-template<> const ::zorba::serialization::ClassVersion* instance_name::class_versions = \
-g_##template_name##_class_versions; \
- \
-template<> const int instance_name::class_versions_count = \
-g_##template_name##_class_versions_count; \
- \
+#define SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(template_name, instance_name, index) \
+ \
+instance_name::class_factory<instance_name> g_class_factory_##template_name##_##index; \
+ \
template<> const char* instance_name::class_name_str = #instance_name;
//
@@ -345,6 +282,7 @@
// then we need this macro because we cannot pass Foo<T1, T2> as the instance_name
// param of the SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS macro. This is because
// the "," inside Foo<T1, T2> will make it appear as two params.
+//
// Example:
//
// SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS2(
@@ -354,27 +292,23 @@
// 1)
//
#define SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS2(template_name, instance_name, second_T, index) \
-instance_name,second_T::class_factory<instance_name,second_T> g_class_factory_##template_name##_##index; \
-\
-template<> const ::zorba::serialization::ClassVersion *instance_name, second_T::class_versions = g_##template_name##_class_versions; \
-\
-template<> const int instance_name,second_T::class_versions_count = \
-g_##template_name##_class_versions_count; \
-\
-template<> const char *instance_name,second_T::class_name_str = #instance_name "," #second_T;
+instance_name, second_T::class_factory<instance_name,second_T> \
+g_class_factory_##template_name##_##index; \
+ \
+template<> const char* instance_name, second_T::class_name_str = \
+#instance_name "," #second_T;
#define SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS3(template_name, instance_name, second_T, third_T, index) \
- instance_name,second_T,third_T::class_factory<instance_name,second_T,third_T> g_class_factory_##template_name##_##index;\
- template<> const ::zorba::serialization::ClassVersion *instance_name,second_T,third_T::class_versions = g_##template_name##_class_versions;\
- template<> const int instance_name,second_T,third_T::class_versions_count = g_##template_name##_class_versions_count;\
- template<> const char *instance_name,second_T,third_T::class_name_str = #instance_name "," #second_T "," #third_T;
-
-//no need to add CLASS_VERSION and END_SERIALIZABLE_CLASS_VERSIONS
+instance_name, second_T, third_T::class_factory<instance_name,second_T,third_T> \
+g_class_factory_##template_name##_##index; \
+ \
+template<> const char* instance_name, second_T, third_T::class_name_str = \
+#instance_name "," #second_T "," #third_T;
/*******************************************************************************
-
+ Constructors to be used during deserialization
********************************************************************************/
#define SERIALIZABLE_CLASS_CONSTRUCTOR(class_name) \
@@ -419,34 +353,47 @@
}
#define SERIALIZABLE_CLASS_CONSTRUCTOR3(class_name, base_class1, base_class2) \
-class_name(::zorba::serialization::Archiver& ar) \
- : \
- base_class1(ar), \
- base_class2(ar) \
-{ \
+class_name(::zorba::serialization::Archiver& ar) \
+ : \
+ base_class1(ar), \
+ base_class2(ar) \
+{ \
}
+//
+// Example:
+//
+// SERIALIZABLE_CLASS_CONSTRUCTOR2T(SequentialIterator,
+// NaryBaseIterator<SequentialIterator, PlanIteratorState>);
+//
#define SERIALIZABLE_CLASS_CONSTRUCTOR2T(class_name, base_class, templ2) \
-class_name(::zorba::serialization::Archiver& ar) \
- : \
- base_class , templ2(ar) \
-{ \
+class_name(::zorba::serialization::Archiver& ar) \
+ : \
+ base_class , templ2(ar) \
+{ \
}
+
+//
+// Example:
+//
+// SERIALIZABLE_CLASS_CONSTRUCTOR3T(SpecificNumArithIterator,
+// BinaryBaseIterator<SpecificNumArithIterator<Operation, Type>, PlanIteratorState>);
+//
#define SERIALIZABLE_CLASS_CONSTRUCTOR3T(class_name, base_class, templ2, templ3) \
-class_name(::zorba::serialization::Archiver& ar) \
- : \
- base_class , \
- templ2, \
- templ3(ar) \
-{ \
+class_name(::zorba::serialization::Archiver& ar) \
+ : \
+ base_class , templ2, templ3(ar) \
+{ \
}
+/*******************************************************************************
+********************************************************************************/
#ifndef NDEBUG
#define CHECK_CLASS_NAME(class_name)\
-if(ar.is_serializing_out() && !ar.is_serialize_base_class()) \
+if (ar.is_serializing_out() && !ar.is_serialize_base_class()) \
{ \
assert(strstr(typeid(*this).name(), #class_name)); \
}
@@ -455,9 +402,6 @@
#endif
-#define SERIALIZE_FUNCTION(f) ar & f;
-
-
} // namespace serialization
} // namespace zorba
=== modified file 'src/zorbaserialization/mem_archiver.cpp'
--- src/zorbaserialization/mem_archiver.cpp 2012-04-04 13:25:43 +0000
+++ src/zorbaserialization/mem_archiver.cpp 2012-04-08 20:59:19 +0000
@@ -37,7 +37,6 @@
char** type,
std::string* value,
int* id,
- int* version,
bool* is_simple,
bool* is_class,
enum ArchiveFieldKind* field_treat,
@@ -49,16 +48,18 @@
*type = current_field->theTypeName;
*value = current_field->theValue;
*id = current_field->theId;
- *version = current_field->theClassVersion;
*is_simple = current_field->theIsSimple;
*is_class = current_field->theIsClass;
*field_treat = current_field->theKind;
*referencing = current_field->referencing;
is_after_last = false;
- if(current_field->theFirstChild)
+
+ if (current_field->theFirstChild)
current_field = current_field->theFirstChild;
- else if(!*is_simple && ((*field_treat == ARCHIVE_FIELD_BASECLASS) || (*field_treat == ARCHIVE_FIELD_PTR)))
+ else if(!*is_simple &&
+ (*field_treat == ARCHIVE_FIELD_BASECLASS ||
+ *field_treat == ARCHIVE_FIELD_PTR))
{
//class without childs
temp_field.theParent = current_field;
=== modified file 'src/zorbaserialization/mem_archiver.h'
--- src/zorbaserialization/mem_archiver.h 2012-03-28 05:19:57 +0000
+++ src/zorbaserialization/mem_archiver.h 2012-04-08 20:59:19 +0000
@@ -19,49 +19,47 @@
#include "zorbaserialization/archiver.h"
#include "zorbatypes/rchandle.h"
-namespace zorba{
- namespace serialization{
+
+namespace zorba
+{
+namespace serialization
+{
+
class MemArchiver : public Archiver
{
- archive_field *current_field;
- bool is_after_last;
- archive_field temp_field;
+ archive_field * current_field;
+ bool is_after_last;
+ archive_field temp_field;
+
public:
- MemArchiver(bool is_serializing_out, bool internal_archive=false) :
- Archiver(is_serializing_out, internal_archive) , temp_field("", false, false, NULL, NULL, 0, ARCHIVE_FIELD_NORMAL, NULL, false, ALLOW_DELAY, 0)
+ MemArchiver(bool is_serializing_out, bool internal_archive=false)
+ :
+ Archiver(is_serializing_out, internal_archive) ,
+ temp_field("", false, false, NULL, NULL, ARCHIVE_FIELD_NORMAL, NULL, false, ALLOW_DELAY, 0)
{
current_field = NULL;
is_after_last = false;
}
- virtual bool read_next_field_impl( char **type,
- std::string *value,
- int *id,
- int *version,
- bool *is_simple,
- bool *is_class,
- enum ArchiveFieldKind *field_treat,
- int *referencing);
+ virtual bool read_next_field_impl(
+ char** type,
+ std::string* value,
+ int* id,
+ bool* is_simple,
+ bool* is_class,
+ enum ArchiveFieldKind* field_treat,
+ int* referencing);
virtual void read_end_current_level_impl();
-
-///////////////////////////////////
virtual void serialize_out() {}
-public:
void reset_serialize_in();
-
-};
-
-/*
-class RCClassSerializer : public SimpleRCObject, public ClassSerializer
-{
-};
-extern rchandle<RCClassSerializer> g_rc_class_serializer;
-*/
-
-}}
+};
+
+
+}
+}
#endif
/* vim:set et sw=2 ts=2: */
=== modified file 'src/zorbaserialization/serialize_basic_types.cpp'
--- src/zorbaserialization/serialize_basic_types.cpp 2012-04-04 09:57:46 +0000
+++ src/zorbaserialization/serialize_basic_types.cpp 2012-04-08 20:59:19 +0000
@@ -52,7 +52,6 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
@@ -62,7 +61,6 @@
retval = ar.read_next_field(&type,
&value,
&id,
- &version,
&is_simple,
&is_class,
&field_treat,
@@ -103,7 +101,6 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
@@ -113,7 +110,6 @@
retval = ar.read_next_field(&type,
&value,
&id,
- &version,
&is_simple,
&is_class,
&field_treat,
@@ -154,7 +150,6 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
@@ -164,7 +159,6 @@
retval = ar.read_next_field(&type,
&value,
&id,
- &version,
&is_simple,
&is_class,
&field_treat,
@@ -205,7 +199,6 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
@@ -215,7 +208,6 @@
retval = ar.read_next_field(&type,
&value,
&id,
- &version,
&is_simple,
&is_class,
&field_treat,
@@ -256,7 +248,6 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
@@ -266,7 +257,6 @@
retval = ar.read_next_field(&type,
&value,
&id,
- &version,
&is_simple,
&is_class,
&field_treat,
@@ -307,14 +297,13 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version,
+ retval = ar.read_next_field(&type, &value, &id,
&is_simple, &is_class, &field_treat, &referencing);
if (!retval && ar.get_read_optional_field())
@@ -347,14 +336,13 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version,
+ retval = ar.read_next_field(&type, &value, &id,
&is_simple, &is_class, &field_treat, &referencing);
if (!retval && ar.get_read_optional_field())
@@ -387,14 +375,13 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version,
+ retval = ar.read_next_field(&type, &value, &id,
&is_simple, &is_class, &field_treat, &referencing);
if (!retval && ar.get_read_optional_field())
@@ -427,14 +414,13 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version,
+ retval = ar.read_next_field(&type, &value, &id,
&is_simple, &is_class, &field_treat, &referencing);
if (!retval && ar.get_read_optional_field())
@@ -469,14 +455,13 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_PTR;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version,
+ retval = ar.read_next_field(&type, &value, &id,
&is_simple, &is_class, &field_treat, &referencing);
if (!retval && ar.get_read_optional_field())
@@ -527,14 +512,13 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version,
+ retval = ar.read_next_field(&type, &value, &id,
&is_simple, &is_class, &field_treat, &referencing);
if (!retval && ar.get_read_optional_field())
@@ -569,14 +553,13 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version,
+ retval = ar.read_next_field(&type, &value, &id,
&is_simple, &is_class, &field_treat, &referencing);
if (!retval && ar.get_read_optional_field())
@@ -618,14 +601,13 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version,
+ retval = ar.read_next_field(&type, &value, &id,
&is_simple, &is_class, &field_treat, &referencing);
if (!retval && ar.get_read_optional_field())
@@ -665,14 +647,13 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version,
+ retval = ar.read_next_field(&type, &value, &id,
&is_simple, &is_class, &field_treat, &referencing);
if (!retval && ar.get_read_optional_field())
@@ -703,14 +684,13 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version,
+ retval = ar.read_next_field(&type, &value, &id,
&is_simple, &is_class, &field_treat, &referencing);
if (!retval && ar.get_read_optional_field())
@@ -751,14 +731,13 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version,
+ retval = ar.read_next_field(&type, &value, &id,
&is_simple, &is_class, &field_treat, &referencing);
if (!retval && ar.get_read_optional_field())
@@ -789,14 +768,13 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_PTR;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version,
+ retval = ar.read_next_field(&type, &value, &id,
&is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
@@ -848,14 +826,13 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version,
+ retval = ar.read_next_field(&type, &value, &id,
&is_simple, &is_class, &field_treat, &referencing);
if (!retval && ar.get_read_optional_field())
=== modified file 'src/zorbaserialization/template_serializer.h'
--- src/zorbaserialization/template_serializer.h 2012-04-04 13:25:43 +0000
+++ src/zorbaserialization/template_serializer.h 2012-04-08 20:59:19 +0000
@@ -48,8 +48,11 @@
} while (0)
+/*******************************************************************************
+
+********************************************************************************/
template<class RepType>
-void operator&(Archiver &ar, zorba::rstring<RepType>& obj)
+void operator&(Archiver& ar, zorba::rstring<RepType>& obj)
{
bool is_normal_str = true;
if(ar.is_serializing_out())
@@ -72,13 +75,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_simple_field(retval, type, "rstring", is_simple, field_treat, ARCHIVE_FIELD_NORMAL, id);
@@ -114,8 +116,12 @@
}
}
+
+/*******************************************************************************
+
+********************************************************************************/
template<typename T>
-void operator&(Archiver &ar, std::list<T> &obj)
+void operator&(Archiver& ar, std::list<T>& obj)
{
if(ar.is_serializing_out())
{
@@ -126,7 +132,7 @@
sprintf_s(strtemp, sizeof(strtemp), "%d", (int)obj.size());
#endif
bool is_ref;
- is_ref = ar.add_compound_field("std::list<T>", 0, !FIELD_IS_CLASS, strtemp, &obj, ARCHIVE_FIELD_NORMAL);
+ is_ref = ar.add_compound_field("std::list<T>", !FIELD_IS_CLASS, strtemp, &obj, ARCHIVE_FIELD_NORMAL);
if(!is_ref)
{
typename std::list<T>::iterator it;
@@ -142,13 +148,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_nonclass_field(retval, type, "std::list<T>", is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
@@ -167,8 +172,12 @@
}
}
+
+/*******************************************************************************
+
+********************************************************************************/
template<typename T>
-void operator&(Archiver &ar, std::vector<T> &obj)
+void operator&(Archiver& ar, std::vector<T>& obj)
{
if(ar.is_serializing_out())
{
@@ -179,7 +188,7 @@
sprintf_s(strtemp, sizeof(strtemp), "%d", (int)obj.size());
#endif
bool is_ref;
- is_ref = ar.add_compound_field("std::vector<T>", 0, !FIELD_IS_CLASS, strtemp, &obj, ARCHIVE_FIELD_NORMAL);
+ is_ref = ar.add_compound_field("std::vector<T>", !FIELD_IS_CLASS, strtemp, &obj, ARCHIVE_FIELD_NORMAL);
if(!is_ref)
{
typename std::vector<T>::iterator it;
@@ -195,13 +204,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_nonclass_field(retval, type, "std::vector<T>", is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
@@ -220,15 +228,18 @@
}
}
+
+/*******************************************************************************
+
+********************************************************************************/
template<typename T>
-void operator&(Archiver &ar, std::vector<T> *&obj)
+void operator&(Archiver& ar, std::vector<T>*& obj)
{
if(ar.is_serializing_out())
{
if(obj == NULL)
{
ar.add_compound_field("NULL",
- 1 ,//class_version
!FIELD_IS_CLASS, "NULL",
NULL,//(SerializeBaseClass*)obj,
ARCHIVE_FIELD_NULL);
@@ -241,7 +252,7 @@
sprintf_s(strtemp, sizeof(strtemp), "%d", (int)obj->size());
#endif
bool is_ref;
- is_ref = ar.add_compound_field("std::vector<T>*", 0, !FIELD_IS_CLASS, strtemp, obj, ar.is_serialize_base_class() ? ARCHIVE_FIELD_BASECLASS : ARCHIVE_FIELD_PTR);
+ is_ref = ar.add_compound_field("std::vector<T>*", !FIELD_IS_CLASS, strtemp, obj, ar.is_serialize_base_class() ? ARCHIVE_FIELD_BASECLASS : ARCHIVE_FIELD_PTR);
if(ar.is_serialize_base_class())
ar.set_serialize_base_class(false);
if(!is_ref)
@@ -259,13 +270,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_PTR;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_nonclass_field(retval, type, "std::vector<T>*", is_simple, is_class, field_treat, (ArchiveFieldKind)-1, id);
@@ -320,8 +330,12 @@
}
}
+
+/*******************************************************************************
+
+********************************************************************************/
template<typename T>
-void operator&(Archiver &ar, std::vector<T*> &obj)
+void operator&(Archiver& ar, std::vector<T*>& obj)
{
if(ar.is_serializing_out())
{
@@ -332,7 +346,7 @@
sprintf_s(strtemp, sizeof(strtemp), "%d", (int)obj.size());
#endif
bool is_ref;
- is_ref = ar.add_compound_field("std::vector<T*>", 0, !FIELD_IS_CLASS, strtemp, &obj, ARCHIVE_FIELD_NORMAL);
+ is_ref = ar.add_compound_field("std::vector<T*>", !FIELD_IS_CLASS, strtemp, &obj, ARCHIVE_FIELD_NORMAL);
if(!is_ref)
{
typename std::vector<T*>::iterator it;
@@ -348,13 +362,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_nonclass_field(retval, type, "std::vector<T*>", is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
@@ -373,13 +386,17 @@
}
}
+
+/*******************************************************************************
+
+********************************************************************************/
template<typename T1, typename T2>
-void operator&(Archiver &ar, std::pair<T1, T2> &obj)
+void operator&(Archiver& ar, std::pair<T1, T2>& obj)
{
if(ar.is_serializing_out())
{
bool is_ref;
- is_ref = ar.add_compound_field("std::pair<T1, T2>", 0, !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
+ is_ref = ar.add_compound_field("std::pair<T1, T2>", !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
if(!is_ref)
{
ar & obj.first;
@@ -392,13 +409,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_nonclass_field(retval, type, "std::pair<T1, T2>", is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
@@ -411,22 +427,25 @@
}
}
+
+/*******************************************************************************
+
+********************************************************************************/
template<typename T1, typename T2>
-void operator&(Archiver &ar, std::pair<T1, T2> *&obj)
+void operator&(Archiver& ar, std::pair<T1, T2>*& obj)
{
if(ar.is_serializing_out())
{
if(obj == NULL)
{
ar.add_compound_field("NULL",
- 1 ,//class_version
!FIELD_IS_CLASS, "NULL",
NULL,//(SerializeBaseClass*)obj,
ARCHIVE_FIELD_NULL);
return;
}
bool is_ref;
- is_ref = ar.add_compound_field("std::pair<T1, T2>", 0, !FIELD_IS_CLASS, "", &obj, ar.is_serialize_base_class() ? ARCHIVE_FIELD_BASECLASS : ARCHIVE_FIELD_PTR);
+ is_ref = ar.add_compound_field("std::pair<T1, T2>", !FIELD_IS_CLASS, "", &obj, ar.is_serialize_base_class() ? ARCHIVE_FIELD_BASECLASS : ARCHIVE_FIELD_PTR);
if(ar.is_serialize_base_class())
ar.set_serialize_base_class(false);
if(!is_ref)
@@ -441,13 +460,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_PTR;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_nonclass_field(retval, type, "std::pair<T1, T2>", is_simple, is_class, field_treat, (ArchiveFieldKind)-1, id);
@@ -491,22 +509,25 @@
}
}
+
+/*******************************************************************************
+
+********************************************************************************/
template<typename T1, typename T2>
-void operator&(Archiver &ar, std::map<T1, T2> *&obj)
+void operator&(Archiver& ar, std::map<T1, T2>*& obj)
{
if(ar.is_serializing_out())
{
if(obj == NULL)
{
ar.add_compound_field("NULL",
- 1 ,//class_version
!FIELD_IS_CLASS, "NULL",
NULL,//(SerializeBaseClass*)obj,
ARCHIVE_FIELD_NULL);
return;
}
bool is_ref;
- is_ref = ar.add_compound_field("std::map<T1, T2>", 0, !FIELD_IS_CLASS, "", obj, ar.is_serialize_base_class() ? ARCHIVE_FIELD_BASECLASS : ARCHIVE_FIELD_PTR);
+ is_ref = ar.add_compound_field("std::map<T1, T2>", !FIELD_IS_CLASS, "", obj, ar.is_serialize_base_class() ? ARCHIVE_FIELD_BASECLASS : ARCHIVE_FIELD_PTR);
if(ar.is_serialize_base_class())
ar.set_serialize_base_class(false);
if(!is_ref)
@@ -532,13 +553,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_PTR;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_nonclass_field(retval, type, "std::map<T1, T2>", is_simple, is_class, field_treat, (ArchiveFieldKind)-1, id);
@@ -603,13 +623,17 @@
void operator&(Archiver &ar, short &obj);
+
+/*******************************************************************************
+
+********************************************************************************/
template<typename T1, typename T2, class Tcomp>
-void operator&(Archiver &ar, std::map<T1, T2, Tcomp> &obj)
+void operator&(Archiver& ar, std::map<T1, T2, Tcomp>& obj)
{
if(ar.is_serializing_out())
{
bool is_ref;
- is_ref = ar.add_compound_field("std::map<T1, T2>", 0, !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
+ is_ref = ar.add_compound_field("std::map<T1, T2>", !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
if(!is_ref)
{
ar.set_is_temp_field_one_level(true);
@@ -633,13 +657,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_nonclass_field(retval, type, "std::map<T1, T2>", is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
@@ -662,20 +685,22 @@
}
}
+/*******************************************************************************
+
+********************************************************************************/
template<class T>
-void operator&(Archiver &ar, T &obj)
+void operator&(Archiver& ar, T& obj)
{
- if(ar.is_serializing_out())
+ if (ar.is_serializing_out())
{
bool is_ref;
is_ref = ar.add_compound_field(obj.get_class_name_str(),//typeid(obj).name()+6,
- T::class_versions[T::class_versions_count-1].class_version,
- FIELD_IS_CLASS, "0",//strtemp,
- (SerializeBaseClass*)&obj,
- //ar.is_serialize_base_class() ? ARCHIVE_FIELD_BASECLASS : ARCHIVE_FIELD_NORMAL);
- ARCHIVE_FIELD_NORMAL);
- if(!is_ref)
+ FIELD_IS_CLASS,
+ "0",//strtemp,
+ (SerializeBaseClass*)&obj,
+ ARCHIVE_FIELD_NORMAL);
+ if (!is_ref)
{
obj.serialize_internal(ar);
ar.add_end_compound_field();
@@ -683,82 +708,40 @@
}
else
{
- int prev_class_version = ar.get_class_version();
- char *type;
+ char* type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = true;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_class_field(retval, type, obj.get_class_name_str(), is_simple, is_class, field_treat,
- //ar.is_serialize_base_class() ? ARCHIVE_FIELD_BASECLASS : ARCHIVE_FIELD_NORMAL,
ARCHIVE_FIELD_NORMAL,
id);
- ar.set_class_version(version);
ar.register_reference(id, field_treat, (SerializeBaseClass*)&obj);
-#ifndef NDEBUG
- //check the version
- int v;
- if(version > T::class_versions[T::class_versions_count-1].class_version)
- {
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0005_CLASS_VERSION_TOO_NEW,
- ERROR_PARAMS(
- obj.get_class_name_str(), version,
- T::class_versions[T::class_versions_count-1].class_version
- )
- );
- }
- for(v = T::class_versions_count-1; v >= 0; v--)
- {
- if(version == T::class_versions[v].class_version)
- break;//supported version
- else if((version < T::class_versions[v].class_version) && !T::class_versions[v].is_backward_compatible)
- {
- int oldv;
- for(oldv = v; oldv >= 0; oldv--)
- {
- if(version == T::class_versions[oldv].class_version)
- break;
- }
- if(oldv < 0)
- oldv = 0;
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0006_CLASS_VERSION_TOO_OLD,
- ERROR_PARAMS(
- obj.get_class_name_str(), version,
- T::class_versions[v].class_version,
- BUILD_STRING( std::hex << T::class_versions[oldv].zorba_version )
- )
- );
- }
-
- }
-#endif
obj.serialize_internal(ar);
ar.read_end_current_level();
-
- ar.set_class_version(prev_class_version);
}
}
+
+/*******************************************************************************
+
+********************************************************************************/
template<class T>
-void operator&(Archiver &ar, T *&obj)
+void operator&(Archiver& ar, T*& obj)
{
if(ar.is_serializing_out())
{
if(obj == NULL)
{
ar.add_compound_field("NULL",
- 1 ,//class_version
FIELD_IS_CLASS, "NULL",
NULL,//(SerializeBaseClass*)obj,
ARCHIVE_FIELD_NULL);
@@ -769,12 +752,10 @@
is_ref = ar.add_compound_field((ar.is_serialize_base_class() ?
obj->T::get_class_name_str() :
obj->get_class_name_str()),
- (ar.is_serialize_base_class() ?
- T::class_versions[T::class_versions_count-1].class_version :
- obj->get_classversion(obj->get_version_count()-1).class_version),
- FIELD_IS_CLASS, "0",//strtemp,
- (SerializeBaseClass*)obj,
- ar.is_serialize_base_class() ? ARCHIVE_FIELD_BASECLASS : ARCHIVE_FIELD_PTR);
+ FIELD_IS_CLASS,
+ "0",//strtemp,
+ (SerializeBaseClass*)obj,
+ ar.is_serialize_base_class() ? ARCHIVE_FIELD_BASECLASS : ARCHIVE_FIELD_PTR);
if(!is_ref)
{
if(!ar.is_serialize_base_class())
@@ -790,17 +771,15 @@
}
else
{
- int prev_class_version = ar.get_class_version();
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = true;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_PTR;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_class_field(retval, "", "", is_simple, is_class, field_treat, (ArchiveFieldKind)-1, id);
@@ -811,25 +790,18 @@
ar.read_end_current_level();
return;
}
- ar.set_class_version(version);
-
-
-
- if(ar.is_serialize_base_class())
+
+ if (ar.is_serialize_base_class())
{
#ifndef NDEBUG
if(strcmp(type, T::get_class_name_str_static()))
{
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS( id )
- );
+ throw ZORBA_EXCEPTION(zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS(id));
}
#endif
if(field_treat != ARCHIVE_FIELD_BASECLASS)
{
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS( id )
- );
+ throw ZORBA_EXCEPTION(zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS(id));
}
}
else
@@ -842,10 +814,10 @@
}
}
- SerializeBaseClass *new_obj = NULL;
+ SerializeBaseClass* new_obj = NULL;
if(field_treat == ARCHIVE_FIELD_PTR)
{
- class_deserializer *cls_factory;
+ class_deserializer* cls_factory;
cls_factory = ClassSerializer::getInstance()->get_class_factory(type);
if(cls_factory == NULL)
{
@@ -864,56 +836,12 @@
);
}
- //check the version
-#ifndef NDEBUG
- int v;
- if(version > obj->get_classversion(obj->get_version_count()-1).class_version)
- {
- delete new_obj;obj=NULL;
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0005_CLASS_VERSION_TOO_NEW,
- ERROR_PARAMS(
- obj->get_class_name_str(), version,
- obj->get_classversion(obj->get_version_count()-1).class_version
- )
- );
- }
- for(v = obj->get_version_count()-1; v >= 0; v--)
- {
- const ClassVersion &ver = obj->get_classversion(v);
- if(version == ver.class_version)
- break;//supported version
- else if((version < ver.class_version) && !ver.is_backward_compatible)
- {
- int oldv;
- for(oldv = v; oldv >= 0; oldv--)
- {
- if(version == obj->get_classversion(oldv).class_version)
- break;
- }
- if(oldv < 0)
- oldv = 0;
-
- delete new_obj;obj=NULL;
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0006_CLASS_VERSION_TOO_OLD,
- ERROR_PARAMS(
- obj->get_class_name_str(), version,
- ver.class_version,
- BUILD_STRING(
- std::hex << obj->get_classversion(oldv).zorba_version
- )
- )
- );
- }
-
- }
-#endif
-
ar.register_reference(id, field_treat, new_obj);
- try{
- new_obj->serialize_internal(ar);
- }catch(...)
+ try
+ {
+ new_obj->serialize_internal(ar);
+ }
+ catch(...)
{
delete new_obj;obj=NULL;
throw;
@@ -922,60 +850,19 @@
}
else if(field_treat == ARCHIVE_FIELD_BASECLASS)
{
- //check the version
-#ifndef NDEBUG
- int v;
- if(version > obj->T::get_classversion(obj->T::get_version_count()-1).class_version)
- {
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0005_CLASS_VERSION_TOO_NEW,
- ERROR_PARAMS(
- obj->T::get_class_name_str(), version,
- obj->T::get_classversion(obj->T::get_version_count()-1).class_version
- )
- );
- }
- for(v = obj->T::get_version_count()-1; v >= 0; v--)
- {
- if(version == obj->T::get_classversion(v).class_version)
- break;//supported version
- else if((version < obj->T::get_classversion(v).class_version) && !obj->T::get_classversion(v).is_backward_compatible)
- {
- int oldv;
- for(oldv = v; oldv >= 0; oldv--)
- {
- if(version == obj->T::get_classversion(oldv).class_version)
- break;
- }
- if(oldv < 0)
- oldv = 0;
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0006_CLASS_VERSION_TOO_OLD,
- ERROR_PARAMS(
- obj->T::get_class_name_str(), version,
- obj->T::get_classversion(v).class_version,
- BUILD_STRING(
- std::hex << obj->T::get_classversion(oldv).zorba_version
- )
- )
- );
- }
-
- }
-#endif
-
obj->T::serialize_internal(ar);
ar.read_end_current_level();
}
else if((new_obj = (SerializeBaseClass*)ar.get_reference_value(referencing)))// ARCHIVE_FIELD_REFERENCING
{
- try{
+ try
+ {
obj = dynamic_cast<T*>(new_obj);
- }catch(...)
+ }
+ catch(...)
{
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0004_UNRESOLVED_FIELD_REFERENCE, ERROR_PARAMS( id )
- );
+ throw ZORBA_EXCEPTION(zerr::ZCSE0004_UNRESOLVED_FIELD_REFERENCE,
+ ERROR_PARAMS(id));
}
if(!obj)
{
@@ -988,14 +875,15 @@
{
ar.register_delay_reference((void**)&obj, FIELD_IS_CLASS, obj->T::get_class_name_str(), referencing);
}
- ar.set_class_version(prev_class_version);
}
}
+/*******************************************************************************
+********************************************************************************/
template<class T>
-void serialize_baseclass(Archiver &ar, T *obj)
+void serialize_baseclass(Archiver& ar, T* obj)
{
ar.set_serialize_base_class(true);
@@ -1004,8 +892,12 @@
//ar.set_serialize_base_class(false);
}
+
+/*******************************************************************************
+
+********************************************************************************/
template<class T>
-void read_optional_field(Archiver &ar, T &obj)
+void read_optional_field(Archiver& ar, T& obj)
{
ar.set_read_optional_field(true);
ar & obj;
=== modified file 'src/zorbaserialization/xml_archiver.cpp'
--- src/zorbaserialization/xml_archiver.cpp 2012-04-04 13:25:43 +0000
+++ src/zorbaserialization/xml_archiver.cpp 2012-04-08 20:59:19 +0000
@@ -115,9 +115,7 @@
write_string("type=\"");
write_string(current_field->theTypeName);
write_string("\" ");
- write_string("version=\"");
- sprintf(strtemp, "%d", current_field->theClassVersion);
- write_string(strtemp);
+ write_string("version=\"1");
write_string("\" ");
write_string("field_treat=\"");
write_string(get_field_treat_string(current_field->theKind));
@@ -200,7 +198,6 @@
char **type,
std::string *value,
int *id,
- int *version,
bool *is_simple,
bool *is_class,
enum ArchiveFieldKind *field_treat,
@@ -213,7 +210,6 @@
*type = NULL;
*id = -1;
- *version = -1;
*is_simple = false;
*is_class = false,
*field_treat = (enum ArchiveFieldKind)-1;
@@ -303,7 +299,6 @@
if(!strcmp(attrib_name, "version"))
{
read_attrib_value(attrib_value);
- *version = atoi(attrib_value);
attr_index++;
break;
}
=== modified file 'src/zorbaserialization/xml_archiver.h'
--- src/zorbaserialization/xml_archiver.h 2012-03-28 05:19:57 +0000
+++ src/zorbaserialization/xml_archiver.h 2012-04-08 20:59:19 +0000
@@ -42,7 +42,6 @@
virtual bool read_next_field_impl( char **type,
std::string *value,
int *id,
- int *version,
bool *is_simple,
bool *is_class,
enum ArchiveFieldKind *field_treat,
=== modified file 'src/zorbaserialization/zorba_class_serializer.cpp'
--- src/zorbaserialization/zorba_class_serializer.cpp 2012-04-04 13:25:43 +0000
+++ src/zorbaserialization/zorba_class_serializer.cpp 2012-04-08 20:59:19 +0000
@@ -53,62 +53,82 @@
namespace serialization{
+/*******************************************************************************
+
+********************************************************************************/
class store_item_class_factory : public ::zorba::serialization::class_deserializer
{
public:
store_item_class_factory()
{
- /*register this class into plan serializer*/
- ::zorba::serialization::ClassSerializer::getInstance()->register_class_factory("store::Item*", this);
+ ::zorba::serialization::ClassSerializer::getInstance()->
+ register_class_factory("store::Item*", this);
}
- virtual ::zorba::serialization::SerializeBaseClass *create_new(::zorba::serialization::Archiver &ar)
+ virtual ::zorba::serialization::SerializeBaseClass* create_new(
+ ::zorba::serialization::Archiver& ar)
{
return NULL;
}
- virtual void cast_ptr(::zorba::serialization::SerializeBaseClass* ptr, void **class_ptr)
+ virtual void cast_ptr(::zorba::serialization::SerializeBaseClass* ptr, void** class_ptr)
{
*class_ptr = (void*)dynamic_cast<store::Item*>(ptr);
}
};
-store_item_class_factory g_store_item_class_factory;
-
+
+store_item_class_factory g_store_item_class_factory;
+
+
+/*******************************************************************************
+
+********************************************************************************/
class xqpcollator_class_factory : public ::zorba::serialization::class_deserializer
{
public:
xqpcollator_class_factory()
{
- /*register this class into plan serializer*/
- ::zorba::serialization::ClassSerializer::getInstance()->register_class_factory("XQPCollator*", this);
+ ::zorba::serialization::ClassSerializer::getInstance()->
+ register_class_factory("XQPCollator*", this);
}
- virtual ::zorba::serialization::SerializeBaseClass *create_new(::zorba::serialization::Archiver &ar)
+ virtual ::zorba::serialization::SerializeBaseClass* create_new(
+ ::zorba::serialization::Archiver& ar)
{
return NULL;
}
- virtual void cast_ptr(::zorba::serialization::SerializeBaseClass* ptr, void **class_ptr)
+ virtual void cast_ptr(::zorba::serialization::SerializeBaseClass* ptr, void** class_ptr)
{
*class_ptr = (void*)dynamic_cast<XQPCollator*>(ptr);
}
};
-xqpcollator_class_factory g_xqpcollator_class_factory;
-
-
-void operator&(Archiver &ar, const XQType *&obj)
+xqpcollator_class_factory g_xqpcollator_class_factory;
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void operator&(Archiver& ar, const XQType*& obj)
{
- XQType *obj2 = (XQType*)obj;
+ XQType* obj2 = (XQType*)obj;
+
ar.dont_allow_delay();
+
operator&(ar, obj2);
- if(!ar.is_serializing_out())
+
+ if (!ar.is_serializing_out())
obj = (const XQType*)obj2;
}
-void operator&(Archiver &ar, XQPCollator*& obj)
+
+/*******************************************************************************
+
+********************************************************************************/
+void operator&(Archiver& ar, XQPCollator*& obj)
{
if (ar.is_serializing_out())
{
@@ -128,21 +148,22 @@
char* type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_PTR;
int referencing;
- bool retval;
-
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
-
- if(!retval && ar.get_read_optional_field())
+
+ bool retval = ar.read_next_field(&type, &value, &id,
+ &is_simple, &is_class, &field_treat,
+ &referencing);
+
+ if (!retval && ar.get_read_optional_field())
return;
- ar.check_simple_field(retval, type, "XQPCollator*", is_simple, field_treat, ARCHIVE_FIELD_PTR, id);
+ ar.check_simple_field(retval, type, "XQPCollator*",
+ is_simple, field_treat, ARCHIVE_FIELD_PTR, id);
- if(field_treat == ARCHIVE_FIELD_NULL)
+ if (field_treat == ARCHIVE_FIELD_NULL)
{
obj = NULL;
return;
@@ -153,15 +174,17 @@
else
obj = CollationFactory::createCollator();
-
ar.register_reference(id, field_treat, &obj);
}
}
-void operator&(Archiver &ar, MAPM &obj)
+/*******************************************************************************
+
+********************************************************************************/
+void operator&(Archiver& ar, MAPM& obj)
{
- if(ar.is_serializing_out())
+ if (ar.is_serializing_out())
{
int nr_digits = obj.significant_digits();
char *lBuffer = (char*)malloc(nr_digits + 20);
@@ -193,13 +216,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = true;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_simple_field(retval, type, "MAPM", is_simple, field_treat, ARCHIVE_FIELD_NORMAL, id);
@@ -224,6 +246,9 @@
template void operator&(serialization::Archiver&, IntegerImpl<unsigned long long>&);
#endif /* ZORBA_WITH_BIG_INTEGER */
+/*******************************************************************************
+
+********************************************************************************/
void iterator_to_vector(store::Iterator_t iter, std::vector<store::Item_t> &items)
{
store::Item_t i;
@@ -237,6 +262,10 @@
void serialize_node_tree(Archiver &ar, store::Item *&obj, bool all_tree);
+
+/*******************************************************************************
+
+********************************************************************************/
void serialize_my_children(Archiver &ar, store::Iterator_t iter)
{
if(ar.is_serializing_out())
@@ -270,6 +299,10 @@
}
}
+
+/*******************************************************************************
+
+********************************************************************************/
void serialize_my_children2(Archiver &ar, store::Iterator_t iter)
{
serialize_my_children(ar, iter);
@@ -320,7 +353,10 @@
}
-void operator&(Archiver &ar, store::Item* &obj)
+/*******************************************************************************
+
+********************************************************************************/
+void operator&(Archiver& ar, store::Item*& obj)
{
bool is_ref = false;
int is_node = 0;
@@ -338,7 +374,6 @@
if (obj == NULL)
{
ar.add_compound_field("store::Item*",
- 1 ,//class_version
FIELD_IS_CLASS, "NULL",
NULL,//(SerializeBaseClass*)obj,
ARCHIVE_FIELD_NULL);
@@ -361,7 +396,6 @@
ar.set_is_temp_field(true);
is_ref = ar.add_compound_field("store::Item*",
- 0,
FIELD_IS_CLASS,
strtemp,
obj,
@@ -374,29 +408,34 @@
{
char* type;
std::string value;
- int version;
bool is_simple = false;
bool is_class = true;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
- if(!retval && ar.get_read_optional_field())
+
+ retval = ar.read_next_field(&type, &value, &id,
+ &is_simple, &is_class, &field_treat, &referencing);
+
+ if (!retval && ar.get_read_optional_field())
return;
- ar.check_class_field(retval, type, "store::Item*", is_simple, is_class, field_treat, (enum ArchiveFieldKind)-1, id);
- if(field_treat == ARCHIVE_FIELD_NULL)
+
+ ar.check_class_field(retval, type, "store::Item*",
+ is_simple, is_class, field_treat, (enum ArchiveFieldKind)-1, id);
+
+ if (field_treat == ARCHIVE_FIELD_NULL)
{
obj = NULL;
ar.read_end_current_level();
return;
}
- //ar.register_reference(id, &obj);
- if((field_treat != ARCHIVE_FIELD_PTR) && (field_treat != ARCHIVE_FIELD_REFERENCING))
+
+ if ((field_treat != ARCHIVE_FIELD_PTR) && (field_treat != ARCHIVE_FIELD_REFERENCING))
{
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS( id )
- );
+ throw ZORBA_EXCEPTION(zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS(id));
}
+
is_ref = (field_treat == ARCHIVE_FIELD_REFERENCING);
- if(!is_ref)
+
+ if (!is_ref)
{
sscanf(value.c_str(), "n%da%dp%de%df%d",
&is_node, &is_atomic, &is_pul, &is_error, &is_function);
@@ -414,13 +453,12 @@
zstring name_of_type;
bool is_qname;
- if(ar.is_serializing_out())
+ if (ar.is_serializing_out())
{
type = obj->getType();
name_of_type = type->getLocalName();
const zstring& ns =type->getNamespace();
- is_qname = (name_of_type == "QName" &&
- ns == "http://www.w3.org/2001/XMLSchema";);
+ is_qname = (name_of_type == "QName" && ns == "http://www.w3.org/2001/XMLSchema";);
}
ar & is_qname;
@@ -822,6 +860,10 @@
}
+
+/*******************************************************************************
+
+********************************************************************************/
void serialize_node_tree(Archiver &ar, store::Item *&obj, bool all_tree)
{
//only for node items
@@ -857,24 +899,22 @@
if(obj == NULL)
{
ar.add_compound_field("NULL",
- 1 ,//class_version
!FIELD_IS_CLASS, "NULL",
NULL,//(SerializeBaseClass*)obj,
ARCHIVE_FIELD_NULL);
ar.set_is_temp_field(true);
return;
}
- is_ref = ar.add_compound_field("store::Item*", 0, FIELD_IS_CLASS, "", obj, ARCHIVE_FIELD_PTR);
+ is_ref = ar.add_compound_field("store::Item*", FIELD_IS_CLASS, "", obj, ARCHIVE_FIELD_PTR);
}
else
{
char *type;
std::string value;
- int version;
bool is_simple = false;
bool is_class = true;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
if(field_treat == ARCHIVE_FIELD_NULL)
@@ -1033,6 +1073,9 @@
}
+/*******************************************************************************
+
+********************************************************************************/
void operator&(Archiver &ar, zorba::store::TempSeq *obj)
{
throw ZORBA_EXCEPTION(
@@ -1040,6 +1083,10 @@
);
}
+
+/*******************************************************************************
+
+********************************************************************************/
void operator&(Archiver &ar, const Diagnostic *&obj)
{
if(ar.is_serializing_out())
@@ -1047,7 +1094,6 @@
if(obj == NULL)
{
ar.add_compound_field("NULL",
- 1 ,//class_version
!FIELD_IS_CLASS, "NULL",
NULL,//(SerializeBaseClass*)obj,
ARCHIVE_FIELD_NULL);
@@ -1065,7 +1111,6 @@
xquery_err != NULL ? 1 : 0,
zorba_err != NULL ? 1 : 0);
is_ref = ar.add_compound_field("Diagnostic*",
- 1,
!FIELD_IS_CLASS, err_type,
obj,
ARCHIVE_FIELD_PTR);
@@ -1092,13 +1137,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_PTR;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_nonclass_field(retval, type, "Diagnostic*", is_simple, is_class, field_treat, (ArchiveFieldKind)-1, id);
@@ -1147,6 +1191,10 @@
}
+
+/*******************************************************************************
+
+********************************************************************************/
void operator&(Archiver &ar, ZorbaException *&obj)
{
if(ar.is_serializing_out())
@@ -1154,7 +1202,6 @@
if(obj == NULL)
{
ar.add_compound_field("NULL",
- 1 ,//class_version
!FIELD_IS_CLASS, "NULL",
NULL,//(SerializeBaseClass*)obj,
ARCHIVE_FIELD_NULL);
@@ -1169,7 +1216,6 @@
user_ex != NULL ? 1 : 0,
xquery_ex != NULL ? 1 : 0);
is_ref = ar.add_compound_field("ZorbaException*",
- 1,
!FIELD_IS_CLASS, ex_type,
obj,
ARCHIVE_FIELD_PTR);
@@ -1198,13 +1244,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_PTR;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_nonclass_field(retval, type, "ZorbaException*", is_simple, is_class, field_treat, (ArchiveFieldKind)-1, id);
@@ -1264,12 +1309,16 @@
}
+
+/*******************************************************************************
+
+********************************************************************************/
void operator&(Archiver &ar, zorba::internal::diagnostic::location &obj)
{
if(ar.is_serializing_out())
{
bool is_ref;
- is_ref = ar.add_compound_field("internal::diagnostic::location", 0, !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
+ is_ref = ar.add_compound_field("internal::diagnostic::location", !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
if(!is_ref)
{
ar & obj.file_;
@@ -1289,13 +1338,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_nonclass_field(retval, type, "internal::diagnostic::location", is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
@@ -1309,12 +1357,16 @@
}
}
+
+/*******************************************************************************
+
+********************************************************************************/
void operator&(Archiver &ar, zorba::Item &obj)
{
if(ar.is_serializing_out())
{
bool is_ref;
- is_ref = ar.add_compound_field("zorba::Item", 0, !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
+ is_ref = ar.add_compound_field("zorba::Item", !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
if(!is_ref)
{
ar & obj.m_item;
@@ -1330,13 +1382,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_nonclass_field(retval, type, "zorba::Item", is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
@@ -1346,12 +1397,16 @@
}
}
-void operator&(Archiver &ar, zorba::XQueryStackTrace &obj)
+
+/*******************************************************************************
+
+********************************************************************************/
+void operator&(Archiver& ar, zorba::XQueryStackTrace& obj)
{
if(ar.is_serializing_out())
{
bool is_ref;
- is_ref = ar.add_compound_field("XQueryStackTrace", 0, !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
+ is_ref = ar.add_compound_field("XQueryStackTrace", !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
if(!is_ref)
{
ar & obj.trace_;
@@ -1367,13 +1422,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_nonclass_field(retval, type, "XQueryStackTrace", is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
@@ -1383,12 +1437,16 @@
}
}
-void operator&(Archiver &ar, zorba::XQueryStackTrace::Entry &obj)
+
+/*******************************************************************************
+
+********************************************************************************/
+void operator&(Archiver& ar, zorba::XQueryStackTrace::Entry& obj)
{
if(ar.is_serializing_out())
{
bool is_ref;
- is_ref = ar.add_compound_field("XQueryStackTrace::Entry", 0, !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
+ is_ref = ar.add_compound_field("XQueryStackTrace::Entry", !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
if(!is_ref)
{
ar & obj.getFnNameRef();
@@ -1407,18 +1465,19 @@
}
else
{
- char *type;
+ char* type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
- if(!retval && ar.get_read_optional_field())
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
+
+ if (!retval && ar.get_read_optional_field())
return;
+
ar.check_nonclass_field(retval, type, "XQueryStackTrace::Entry", is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
ar & obj.getFnNameRef();
@@ -1433,7 +1492,6 @@
}
-
}
} // namespace zorba
/* vim:set et sw=2 ts=2: */
=== modified file 'src/zorbaserialization/zorba_class_serializer.h'
--- src/zorbaserialization/zorba_class_serializer.h 2012-03-28 05:19:57 +0000
+++ src/zorbaserialization/zorba_class_serializer.h 2012-04-08 20:59:19 +0000
@@ -101,19 +101,22 @@
ar & type_mgr; \
}
+
template<class T>
-void operator&(Archiver &ar, checked_vector<T> &obj)
+void operator&(Archiver& ar, checked_vector<T>& obj)
{
- if(ar.is_serializing_out())
+ if (ar.is_serializing_out())
{
char strtemp[20];
sprintf(strtemp, "%d", (int)obj.size());
+
bool is_ref;
- is_ref = ar.add_compound_field("checked_vector<T>", 0, !FIELD_IS_CLASS, strtemp, &obj, ARCHIVE_FIELD_NORMAL);
- if(!is_ref)
+ is_ref = ar.add_compound_field("checked_vector<T>", !FIELD_IS_CLASS, strtemp, &obj, ARCHIVE_FIELD_NORMAL);
+
+ if (!is_ref)
{
typename checked_vector<T>::iterator it;
- for(it=obj.begin(); it != obj.end(); it++)
+ for(it = obj.begin(); it != obj.end(); ++it)
{
ar & (*it);
}
@@ -122,43 +125,47 @@
}
else
{
- char *type;
+ char* type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
- if(!retval && ar.get_read_optional_field())
+
+ retval = ar.read_next_field(&type, &value, &id,
+ &is_simple, &is_class, &field_treat, &referencing);
+
+ if (!retval && ar.get_read_optional_field())
return;
- ar.check_nonclass_field(retval, type, "checked_vector<T>", is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
+
+ ar.check_nonclass_field(retval, type, "checked_vector<T>",
+ is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
+
ar.register_reference(id, field_treat, &obj);
int size;
sscanf(value.c_str(), "%d", &size);
obj.resize(size);
typename checked_vector<T>::iterator it;
- for(it=obj.begin(); it != obj.end(); it++)
+ for(it = obj.begin(); it != obj.end(); ++it)
{
ar & (*it);
}
ar.read_end_current_level();
-
}
}
template<class T>
-void operator&(Archiver &ar, store::ItemHandle<T>& obj)
+void operator&(Archiver& ar, store::ItemHandle<T>& obj)
{
- if(ar.is_serializing_out())
+ if (ar.is_serializing_out())
{
bool is_ref;
ENUM_ALLOW_DELAY allow_delay = ar.get_allow_delay();
- is_ref = ar.add_compound_field("ItemHandle<T>", 0, !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
+ is_ref = ar.add_compound_field("ItemHandle<T>", !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
if(!is_ref)
{
T *p = obj.getp();
@@ -187,13 +194,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_nonclass_field(retval, type, "ItemHandle<T>", is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
@@ -234,7 +240,7 @@
{
bool is_ref;
ENUM_ALLOW_DELAY allow_delay = ar.get_allow_delay();
- is_ref = ar.add_compound_field("rchandle<T>", 0, !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
+ is_ref = ar.add_compound_field("rchandle<T>", !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
assert(!is_ref);
ZORBA_ASSERT(!is_ref);
{
@@ -260,13 +266,12 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
+ retval = ar.read_next_field(&type, &value, &id, &is_simple, &is_class, &field_treat, &referencing);
if(!retval && ar.get_read_optional_field())
return;
ar.check_nonclass_field(retval, type, "rchandle<T>", is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
@@ -299,20 +304,29 @@
}
}
+
template<class T>
-void operator&(Archiver &ar, zorba::const_rchandle<T> &obj)
+void operator&(Archiver& ar, zorba::const_rchandle<T>& obj)
{
- if(ar.is_serializing_out())
+ if (ar.is_serializing_out())
{
bool is_ref;
ENUM_ALLOW_DELAY allow_delay = ar.get_allow_delay();
- is_ref = ar.add_compound_field("const_rchandle<T>", 0, !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
- if(!is_ref)
+
+ is_ref = ar.add_compound_field("const_rchandle<T>",
+ !FIELD_IS_CLASS,
+ "",
+ &obj,
+ ARCHIVE_FIELD_NORMAL);
+ if (!is_ref)
{
T *p = (T*)obj.getp();
+
if(allow_delay != ALLOW_DELAY)
ar.dont_allow_delay(allow_delay);
+
bool is_temp = false;
+
if(ar.get_is_temp_field_one_level())
{
is_temp = true;
@@ -335,29 +349,36 @@
char *type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
- if(!retval && ar.get_read_optional_field())
+
+ retval = ar.read_next_field(&type, &value, &id,
+ &is_simple, &is_class, &field_treat, &referencing);
+
+ if (!retval && ar.get_read_optional_field())
return;
- ar.check_nonclass_field(retval, type, "const_rchandle<T>", is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
- //ar.register_reference(id, field_treat, &obj);
+
+ ar.check_nonclass_field(retval, type, "const_rchandle<T>",
+ is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
bool is_temp = false;
- if(ar.get_is_temp_field_one_level())
+
+ if (ar.get_is_temp_field_one_level())
{
is_temp = true;
ar.set_is_temp_field_one_level(true, ar.get_is_temp_field_also_for_ptr());
}
+
T *p;
ar & p;
obj = p;
+
if(is_temp)
ar.set_is_temp_field_one_level(false);
+
if(p == NULL)
{
//workaround for the strict_aliasing warning in gcc
@@ -370,19 +391,22 @@
ar.reconf_last_delayed_rcobject(u_p.v, obj.getp_ref().v, true);
}
ar.read_end_current_level();
-
}
}
template<typename StringType>
-void operator&(Archiver &ar, zorba::internal::VariableQName<StringType> &obj)
+void operator&(Archiver& ar, zorba::internal::VariableQName<StringType>& obj)
{
- if(ar.is_serializing_out())
+ if (ar.is_serializing_out())
{
bool is_ref;
- is_ref = ar.add_compound_field("VariableQName<StringType>", 0, !FIELD_IS_CLASS, "", &obj, ARCHIVE_FIELD_NORMAL);
- if(!is_ref)
+ is_ref = ar.add_compound_field("VariableQName<StringType>",
+ !FIELD_IS_CLASS,
+ "",
+ &obj,
+ ARCHIVE_FIELD_NORMAL);
+ if (!is_ref)
{
ar & obj.ns_;
ar & obj.prefix_;
@@ -396,19 +420,23 @@
}
else
{
- char *type;
+ char* type;
std::string value;
int id;
- int version;
bool is_simple = false;
bool is_class = false;
enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_NORMAL;
int referencing;
bool retval;
- retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
- if(!retval && ar.get_read_optional_field())
+
+ retval = ar.read_next_field(&type, &value, &id,
+ &is_simple, &is_class, &field_treat, &referencing);
+
+ if (!retval && ar.get_read_optional_field())
return;
- ar.check_nonclass_field(retval, type, "VariableQName<StringType>", is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
+
+ ar.check_nonclass_field(retval, type, "VariableQName<StringType>",
+ is_simple, is_class, field_treat, ARCHIVE_FIELD_NORMAL, id);
ar & obj.ns_;
ar & obj.prefix_;
@@ -417,8 +445,9 @@
}
}
+
template<typename FloatType>
-void operator&(Archiver &ar, FloatImpl<FloatType> &obj)
+void operator&(Archiver& ar, FloatImpl<FloatType>& obj)
{
ar & obj.value_;
ar & obj.precision_;
=== modified file 'src/zorbaserialization/zorba_class_versions.cpp'
--- src/zorbaserialization/zorba_class_versions.cpp 2012-03-28 05:19:57 +0000
+++ src/zorbaserialization/zorba_class_versions.cpp 2012-04-08 20:59:19 +0000
@@ -47,24 +47,15 @@
namespace zorba{
SERIALIZABLE_CLASS_VERSIONS(RCObject)
-END_SERIALIZABLE_CLASS_VERSIONS(RCObject)
SERIALIZABLE_CLASS_VERSIONS(SimpleRCObject)
-END_SERIALIZABLE_CLASS_VERSIONS(SimpleRCObject)
SERIALIZABLE_CLASS_VERSIONS(store::Iterator)
-END_SERIALIZABLE_CLASS_VERSIONS(store::Iterator)
-
-SERIALIZABLE_TEMPLATE_VERSIONS(serializable_hashmap)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(serializable_hashmap)
// QQQ should be zstring?
typedef serializable_hashmap<std::string,xqtref_t> SER_HASHMAP_T;
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(serializable_hashmap, SER_HASHMAP_T, 3)
-SERIALIZABLE_TEMPLATE_VERSIONS(serializable_hashmap_entry)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(serializable_hashmap_entry)
-
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(serializable_hashmap_entry, SER_HASHMAP_T::entry, 3)
@@ -72,12 +63,6 @@
// HashMap serialization
//
-SERIALIZABLE_TEMPLATE_VERSIONS(serializable_HashEntry)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(serializable_HashEntry)
-
-SERIALIZABLE_TEMPLATE_VERSIONS(serializable_HashMap)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(serializable_HashMap)
-
// ItemPointerHashMapCmp
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS2(serializable_HashEntry, serializable_HashEntry<store::Item*, StaticallyKnownCollection_t>, 1)
@@ -108,10 +93,6 @@
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS3(serializable_HashMap, serializable_HashMap<store::Item*, PrologOption, ser_ItemPointerHashMapCmp>, 8)
SERIALIZABLE_CLASS_VERSIONS(ser_ItemPointerHashMapCmp)
-END_SERIALIZABLE_CLASS_VERSIONS(ser_ItemPointerHashMapCmp)
-
-SERIALIZABLE_TEMPLATE_VERSIONS(serializable_ItemPointerHashMap)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(serializable_ItemPointerHashMap)
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(serializable_ItemPointerHashMap, serializable_ItemPointerHashMap<StaticallyKnownCollection_t>, 1)
@@ -131,10 +112,6 @@
// HashMapZString
SERIALIZABLE_CLASS_VERSIONS(serializable_HashMapZStringCmp)
-END_SERIALIZABLE_CLASS_VERSIONS(serializable_HashMapZStringCmp)
-
-SERIALIZABLE_TEMPLATE_VERSIONS(serializable_HashMapZString)
-END_SERIALIZABLE_TEMPLATE_VERSIONS(serializable_HashMapZString)
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS2(serializable_HashEntry, serializable_HashEntry<zstring, static_context::ctx_module_t>, 11)
@@ -157,515 +134,5 @@
SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS3(serializable_HashMap, serializable_HashMap<zstring, xqtref_t, serializable_HashMapZStringCmp>,13)
-
-
-/*SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ElementIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FLWORIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<GroupByIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<IfThenElseIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<AttributeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<CompareIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnAdjustToTimeZoneIterator_2>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnBooleanIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<LogicIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<OpIsSameNodeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<OpNodeBeforeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<OpNodeAfterIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnRootIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnNodeNameIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnNilledIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnBaseUriIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnDocumentUriIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaCollectionExistsIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaNodeCountIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaNodeAtIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaIndexOfIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaExportXmlIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaListCollectionsIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaImportXmlIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaImportCatalogIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaImportFolderIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaCreateCollectionIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaDeleteCollectionIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaDeleteAllCollectionsIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaInsertNodeFirstIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaInsertNodeLastIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaInsertNodeBeforeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaInsertNodeAfterIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaInsertNodeAtIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaRemoveNodeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaRemoveNodeAtIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnCurrentDateTimeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnCurrentDateIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnCurrentTimeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnImplicitTimezoneIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnDefaultCollationIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaJSONSerializeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<GenericArithIterator<AddOperation>>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<GenericArithIterator<SubtractOperation>>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<GenericArithIterator<MultiplyOperation>>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<GenericArithIterator<DivideOperation>>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<GenericArithIterator<IntegerDivideOperation>>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<GenericArithIterator<ModOperation>>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<DocumentIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<DocumentContentIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<CommentIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<PiIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<TextIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<EnclosedIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<UDFunctionCallIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<StatelessExtFunctionCallIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<HoistIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<UnhoistIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<EmptyIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<SingletonIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<NodeDistinctIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<NodeSortIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<PathIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<SelfAxisIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<AttributeAxisIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ParentAxisIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<AncestorAxisIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<AncestorSelfAxisIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<RSiblingAxisIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<LSiblingAxisIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ChildAxisIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<DescendantAxisIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<DescendantSelfAxisIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<PrecedingAxisIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FollowingAxisIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<InstanceOfIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<CastIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<CastableIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<PromoteIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<TreatIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<EitherNodesOrAtomicsIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<TryCatchIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ForVarIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<LetVarIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<CountIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ForIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<LetIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<OuterForIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<TupleSourceIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<TupleStreamIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<WhereIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnDateTimeConstructorIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<OpDurationEqualIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnYearsFromDurationIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnMonthsFromDurationIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnDaysFromDurationIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnHoursFromDurationIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnMinutesFromDurationIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnSecondsFromDurationIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnYearFromDatetimeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnMonthFromDatetimeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnDayFromDatetimeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnHoursFromDatetimeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnMinutesFromDatetimeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnSecondsFromDatetimeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnTimezoneFromDatetimeIterato>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnYearFromDateIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnMonthFromDateIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnDayFromDateIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnTimezoneFromDateIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnHoursFromTimeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnMinutesFromTimeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnSecondsFromTimeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnTimezoneFromTimeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnFormatDateTimeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnAdjustToTimeZoneIterator_1>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnTraceIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<CtxVarAssignIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<CtxVarExistsIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<EvalIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<CreateValueIndex>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<DropValueIndex>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ValueIndexInsertSessionOpener>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ValueIndexInsertSessionCloser>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ValueIndexBuilder>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ValueIndexPointProbe>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnErrorIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnResolveUriIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<SequentialIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FlowCtlIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<LoopIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnReadStringIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnPrintIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<NodeReferenceIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<NodeByReferenceIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnLocalNameIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnNamespaceUriIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnLangIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnCollectionIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<OpNumericUnaryIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnAbsIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnCeilingIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnFloorIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnRoundIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnRoundHalfToEvenIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnSQRTIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnExpIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnLogIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnSinIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnCosIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnTanIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnArcSinIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnArcCosIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnArcTanIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ResolveQNameIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<QNameIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<QNameEqualIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<PrefixFromQNameIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<LocalNameFromQNameIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<NamespaceUriFromQNameIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<NamespaceUriForPrefixIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<InScopePrefixesIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaRestGetIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaRestPostIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaRestPutIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaRestDeleteIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaRestHeadIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnConcatIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnIndexOfIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnEmptyIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnExistsIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnDistinctValuesIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnInsertBeforeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnRemoveIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnReverseIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnSubsequenceIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnZeroOrOneIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnOneOrMoreIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnExactlyOneIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnDeepEqualIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<HashSemiJoinIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<SortSemiJoinIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnCountIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnAvgIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnMinMaxIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnSumIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<OpToIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnIdIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnElementWithIdIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnIdRefIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnDocIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnDocAvailableIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnParseIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<CodepointsToStringIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<StringToCodepointsIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<CompareStrIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<CodepointEqualIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ConcatStrIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<StringJoinIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<SubstringIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<StringLengthIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<NormalizeSpaceIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<NormalizeUnicodeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<UpperCaseIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<LowerCaseIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<TranslateIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<EncodeForUriIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<IriToUriIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<EscapeHtmlUriIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ContainsIterator)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<StartsWithIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<EndsWithIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<SubstringBeforeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<SubstringAfterIterator)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnMatchesIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnReplaceIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<FnTokenizeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<InsertIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<DeleteIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ReplaceIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<RenameIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaSchemaTypeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaBase64DecodeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaBase64EncodeIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaRandomIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ZorbaUUIDIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<ValidateIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(Batcher, Batcher<>)
-*/
-
-/*SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<AttributeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<CompareIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<FnAdjustToTimeZoneIterator_2, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<LogicIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<GenericArithIterator<AddOperation>, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<GenericArithIterator<SubtractOperation>, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<GenericArithIterator<MultiplyOperation>, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<GenericArithIterator<DivideOperation>, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<GenericArithIterator<IntegerDivideOperation>, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<GenericArithIterator<ModOperation>, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<PiIterator, PlanIteratorState >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<ForIterator, ForState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<LetIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<OuterForIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<TupleStreamIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<WhereIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<FnDateTimeConstructorIterator,PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<OpDurationEqualIterator,PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<ResolveQNameIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<QNameIterator,PlanIteratorState >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<QNameEqualIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<InsertIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<ReplaceIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<RenameIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(BinaryBaseIterator, BinaryBaseIterator<, >)
-*/
-
-/*SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<OpIsSameNodeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<OpNodeBeforeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<OpNodeAfterIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnRootIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnNodeNameIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnNilledIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnBaseUriIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnDocumentUriIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaCollectionExistsIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaNodeCountIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaNodeAtIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaIndexOfIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaExportXmlIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaListCollectionsIterator, ZorbaListCollectionsState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaImportXmlIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaImportCatalogIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaImportFolderIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaCreateCollectionIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaDeleteCollectionIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaDeleteAllCollectionsIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaInsertNodeFirstIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaInsertNodeLastIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaInsertNodeBeforeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaInsertNodeAfterIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaInsertNodeAtIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaRemoveNodeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaRemoveNodeAtIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnCurrentDateTimeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnCurrentDateIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnCurrentTimeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnImplicitTimezoneIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnDefaultCollationIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaJSONSerializeIterator, FnJSONSerializeIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<UDFunctionCallIterator, UDFunctionCallIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<StatelessExtFunctionCallIterator, StatelessExtFunctionCallIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<HoistIterator, HoistIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<UnhoistIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<TreatIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<EitherNodesOrAtomicsIterator, EitherNodesOrAtomicsIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnYearsFromDurationIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnMonthsFromDurationIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnDaysFromDurationIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnHoursFromDurationIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnMinutesFromDurationIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnSecondsFromDurationIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnYearFromDatetimeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnMonthFromDatetimeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnDayFromDatetimeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnHoursFromDatetimeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnMinutesFromDatetimeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnSecondsFromDatetimeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnTimezoneFromDatetimeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnYearFromDateIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnMonthFromDateIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnDayFromDateIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnTimezoneFromDateIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnHoursFromTimeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnMinutesFromTimeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnSecondsFromTimeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnTimezoneFromTimeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnFormatDateTimeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator,
-NaryBaseIterator<FnTraceIterator, FnTraceIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator,
-NaryBaseIterator<CtxVarAssignIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<CtxVarExistsIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<EvalIterator, EvalIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ValueIndexBuilder, ValueIndexBuilderState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ValueIndexPointProbe, ValueIndexPointProbeState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnErrorIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnResolveUriIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<SequentialIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FlowCtlIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<LoopIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnReadStringIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnPrintIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<NodeReferenceIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<NodeByReferenceIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnLocalNameIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnNamespaceUriIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnLangIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnCollectionIterator, FnCollectionIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnAbsIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnCeilingIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnFloorIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnRoundIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnRoundHalfToEvenIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnSQRTIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnExpIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnLogIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnSinIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnCosIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnTanIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnArcSinIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnArcCosIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnArcTanIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<NamespaceUriForPrefixIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaRestGetIterator, ZorbaRestGetIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaRestPostIterator, ZorbaRestGetIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaRestPutIterator, ZorbaRestGetIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaRestDeleteIterator, ZorbaRestGetIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaRestHeadIterator, ZorbaRestGetIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnConcatIterator, FnConcatIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnIndexOfIterator, FnIndexOfIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnEmptyIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnExistsIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnDistinctValuesIterator, FnDistinctValuesIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnInsertBeforeIterator, FnInsertBeforeIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnRemoveIterator, FnRemoveIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnReverseIterator, FnReverseIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnSubsequenceIterator, FnSubsequenceIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnZeroOrOneIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnOneOrMoreIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnExactlyOneIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnDeepEqualIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<HashSemiJoinIterator, HashSemiJoinIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<SortSemiJoinIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnCountIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnAvgIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnMinMaxIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnSumIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<OpToIterator, OpToIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnIdIterator, FnIdIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnIdIterator, FnElementWithIdIterator>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnIdRefIterator, FnIdRefIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnDocAvailableIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnParseIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<CodepointsToStringIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<StringToCodepointsIterator, StringToCodepointsState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<CompareStrIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<CodepointEqualIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ConcatStrIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<StringJoinIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<SubstringIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<StringLengthIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<NormalizeSpaceIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<NormalizeUnicodeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<UpperCaseIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<LowerCaseIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<TranslateIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<EncodeForUriIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<IriToUriIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<EscapeHtmlUriIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ContainsIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<StartsWithIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<EndsWithIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<SubstringBeforeIterator PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<SubstringAfterIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnMatchesIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnReplaceIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<FnTokenizeIterator, FnTokenizeIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaSchemaTypeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaBase64DecodeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaBase64EncodeIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaRandomIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<ZorbaUUIDIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NaryBaseIterator, NaryBaseIterator<, PlanIteratorState>)
-*/
-
-/*SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NoaryBaseIterator, NoaryBaseIterator<EmptyIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NoaryBaseIterator, NoaryBaseIterator<SingletonIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NoaryBaseIterator, NoaryBaseIterator<ForVarIterator, ForVarState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NoaryBaseIterator, NoaryBaseIterator<LetVarIterator, LetVarState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NoaryBaseIterator, NoaryBaseIterator<TupleSourceIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NoaryBaseIterator, NoaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NoaryBaseIterator, NoaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NoaryBaseIterator, NoaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NoaryBaseIterator, NoaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NoaryBaseIterator, NoaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NoaryBaseIterator, NoaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NoaryBaseIterator, NoaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(NoaryBaseIterator, NoaryBaseIterator<, >)
-*/
-
-/*SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<FnDataIterator, FnDataIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<FnBooleanIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<DocumentIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<DocumentContentIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<NameCastIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<CommentIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<TextIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<EnclosedIterator, EnclosedIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<NodeDistinctIterator, NodeDistinctState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<NodeSortIterator, NodeSortState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<PathIterator, PathIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<InstanceOfIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<CastIterator, CastIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<CastableIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<PromoteIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<TryCatchIterator, TryCatchIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<CountIterator, CountState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<FnAdjustToTimeZoneIterator_1,PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<CreateValueIndex, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<DropValueIndex, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<ValueIndexInsertSessionOpener, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<ValueIndexInsertSessionCloser, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<OpNumericUnaryIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<PrefixFromQNameIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<LocalNameFromQNameIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<NamespaceUriFromQNameIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<InScopePrefixesIterator,InScopePrefixesState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<FnDocIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<DeleteIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<ValidateIterator, PlanIteratorState>)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<, >)
-SERIALIZABLE_TEMPLATE_INSTANCE_VERSIONS(UnaryBaseIterator, UnaryBaseIterator<, >)
-*/
-
-
}
/* vim:set et sw=2 ts=2: */
=== modified file 'src/zorbaserialization/zorba_classes_version.cpp'
--- src/zorbaserialization/zorba_classes_version.cpp 2012-04-04 13:25:43 +0000
+++ src/zorbaserialization/zorba_classes_version.cpp 2012-04-08 20:59:19 +0000
@@ -22,6 +22,6 @@
namespace serialization
{
-const unsigned long g_zorba_classes_version = 21;
+
}}/* vim:set et sw=2 ts=2: */
=== modified file 'src/zorbatypes/binary.cpp'
--- src/zorbatypes/binary.cpp 2012-03-28 05:19:57 +0000
+++ src/zorbatypes/binary.cpp 2012-04-08 20:59:19 +0000
@@ -32,10 +32,8 @@
{
SERIALIZABLE_CLASS_VERSIONS(Base64)
-END_SERIALIZABLE_CLASS_VERSIONS(Base64)
SERIALIZABLE_CLASS_VERSIONS(Base16)
-END_SERIALIZABLE_CLASS_VERSIONS(Base16)
static const string base64_chars =
=== modified file 'src/zorbatypes/datetime/datetimetype.cpp'
--- src/zorbatypes/datetime/datetimetype.cpp 2012-03-28 05:19:57 +0000
+++ src/zorbatypes/datetime/datetimetype.cpp 2012-04-08 20:59:19 +0000
@@ -44,7 +44,6 @@
{
SERIALIZABLE_CLASS_VERSIONS(DateTime)
-END_SERIALIZABLE_CLASS_VERSIONS(DateTime)
static const char separators[] = { '-', '-', 'T', ':', ':', '.'};
=== modified file 'src/zorbatypes/datetime/duration.cpp'
--- src/zorbatypes/datetime/duration.cpp 2012-04-04 13:25:43 +0000
+++ src/zorbatypes/datetime/duration.cpp 2012-04-08 20:59:19 +0000
@@ -35,7 +35,6 @@
{
SERIALIZABLE_CLASS_VERSIONS(Duration)
-END_SERIALIZABLE_CLASS_VERSIONS(Duration)
const int Duration::FRAC_SECONDS_UPPER_LIMIT = 1000000;
=== modified file 'src/zorbatypes/datetime/timezone.cpp'
--- src/zorbatypes/datetime/timezone.cpp 2012-03-28 05:19:57 +0000
+++ src/zorbatypes/datetime/timezone.cpp 2012-04-08 20:59:19 +0000
@@ -28,7 +28,6 @@
namespace zorba
{
SERIALIZABLE_CLASS_VERSIONS(TimeZone)
-END_SERIALIZABLE_CLASS_VERSIONS(TimeZone)
TimeZone::TimeZone(short hours) : Duration(DAYTIMEDURATION_FACET)
=== modified file 'src/zorbatypes/decimal.cpp'
--- src/zorbatypes/decimal.cpp 2012-03-28 05:19:57 +0000
+++ src/zorbatypes/decimal.cpp 2012-04-08 20:59:19 +0000
@@ -41,7 +41,7 @@
namespace zorba {
SERIALIZABLE_CLASS_VERSIONS(Decimal)
-END_SERIALIZABLE_CLASS_VERSIONS(Decimal)
+
///////////////////////////////////////////////////////////////////////////////
Follow ups
