zorba-coders team mailing list archive
-
zorba-coders team
-
Mailing list archive
-
Message #05343
[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/94695
serializer restructuring
--
https://code.launchpad.net/~zorba-coders/zorba/serializer/+merge/94695
Your team Zorba Coders is subscribed to branch lp:zorba.
=== modified file 'src/zorbaserialization/archiver.cpp'
--- src/zorbaserialization/archiver.cpp 2012-02-02 09:56:52 +0000
+++ src/zorbaserialization/archiver.cpp 2012-02-26 21:58:26 +0000
@@ -35,93 +35,121 @@
{
-/////////////////////////////////////////
-//////////////////////////////////////////////////////
+/*******************************************************************************
-archive_field::archive_field(const char *type, bool is_simple, bool is_class,
- const void *value, const void *assoc_ptr,
- int version, enum ArchiveFieldTreat field_treat,
- archive_field *refered,
- int only_for_eval,
- ENUM_ALLOW_DELAY allow_delay,
- unsigned int level)
+********************************************************************************/
+archive_field::archive_field(
+ const char* type,
+ bool is_simple,
+ bool is_class,
+ const void* value,
+ const void* assoc_ptr,
+ int version,
+ enum ArchiveFieldKind kind,
+ archive_field* refered,
+ int only_for_eval,
+ ENUM_ALLOW_DELAY allow_delay,
+ unsigned int level)
{
- this->type = strdup(type);
- this->type_str_pos_in_pool = 0;//initialy is the number of references to this field
- this->is_simple = is_simple;
- this->is_class = is_class;
- if(value)
- {
- this->value = strdup((char*)value);
- }
+ theKind = kind;
+
+ theIsSimple = is_simple;
+ theIsClass = is_class;
+
+ theClassVersion = version;
+
+ theTypeName = strdup(type);
+ theTypeNamePosInPool = 0;//initialy is the number of references to this field
+
+ if (value)
+ theValue = strdup((char*)value);
else
- this->value = NULL;
+ theValue = NULL;
+
this->assoc_ptr = assoc_ptr;
- this->version = version;
- this->field_treat = field_treat;
- this->referencing = refered ? refered->id : 0;
-
- next = NULL;
- first_child = NULL;
- last_child = NULL;
- parent = NULL;
- this->refered = refered;
-
- this->only_for_eval = only_for_eval;
- this->allow_delay2 = allow_delay;
-
- this->level = level;
+
+ theReferredField = refered;
+
+ this->referencing = refered ? refered->theId : 0;
+
+ theLevel = level;
+
+ theNextSibling = NULL;
+ theFirstChild = NULL;
+ theLastChild = NULL;
+ theParent = NULL;
+
+ theOnlyForEval = only_for_eval;
+
+ theAllowDelay2 = allow_delay;
+
#ifdef ZORBA_PLAN_SERIALIZER_STATISTICS
- bytes_saved = 0;
- objects_saved = 0;
+ theBytesSaved = 0;
+ theObjectsSaved = 0;
#endif
}
+
+/*******************************************************************************
+
+********************************************************************************/
archive_field::~archive_field()
{
- free(type);
- if(value)
- free((void*)value);
- archive_field *temp1;
- archive_field *temp2;
- temp1 = first_child;
+ free(theTypeName);
+
+ if (theValue)
+ free((void*)theValue);
+
+ archive_field* temp1 = theFirstChild;
+ archive_field* temp2;
+
while(temp1)
{
- temp2 = temp1->next;
+ temp2 = temp1->theNextSibling;
delete temp1;
temp1 = temp2;
}
}
-/////////////////////////////////////////
-//////////////////////////////////////////////////////
-
+
+/*******************************************************************************
+
+********************************************************************************/
Archiver::Archiver(bool is_serializing_out, bool internal_archive)
- : serializing_out(is_serializing_out),
- serialize_base_class(false),
- all_reference_list(0),
- archive_version(g_zorba_classes_version),
- out_fields(0),
- current_compound_field(0),
- simple_hashout_fields(0),
- hash_out_fields(0),
- nr_ids(0),
- current_class_version(0),
- read_optional(false),
- is_temp_field(0),
- //is_temp_field_one_level(false),
- current_level(0),
- internal_archive(internal_archive),
- theUserCallback(0),
- //compiler_cb(0),
- dont_allow_delay_for_plan_sctx(false)
+ :
+ theSerializingOut(is_serializing_out),
+ serialize_base_class(false),
+ all_reference_list(0),
+ theArchiveVersion(g_zorba_classes_version),
+ theRootField(0),
+ current_compound_field(0),
+ simple_hashout_fields(0),
+ hash_out_fields(0),
+ nr_ids(0),
+ current_class_version(0),
+ read_optional(false),
+ theIsTempField(0),
+ theCurrentLevel(0),
+ internal_archive(internal_archive),
+ theUserCallback(0),
+ dont_allow_delay_for_plan_sctx(false)
{
-
- if(is_serializing_out)
+ if (theSerializingOut)
{
//create the top most field
- out_fields = new archive_field("", false, false, NULL, NULL, 0, ARCHIVE_FIELD_NORMAL, NULL, false, ALLOW_DELAY, 0);
- current_compound_field = out_fields;
+ theRootField = new archive_field("",
+ false,
+ false,
+ NULL,
+ NULL,
+ 0,
+ ARCHIVE_FIELD_NORMAL,
+ NULL,
+ false,
+ ALLOW_DELAY,
+ 0);
+
+ current_compound_field = theRootField;
}
if (!internal_archive)
@@ -130,7 +158,7 @@
nr_ids = har->get_nr_ids();
}
- if(is_serializing_out)
+ if (theSerializingOut)
{
simple_hashout_fields = new HashMap<SIMPLE_HASHOUT_FIELD, archive_field*,
SimpleHashoutFieldCompare>(1000, false);
@@ -138,168 +166,226 @@
}
- this->only_for_eval = 0;
- this->serialize_everything = false;
+ theOnlyForEval = 0;
+ theSerializeEverything = false;
loading_hardcoded_objects = false;
- allow_delay2 = ALLOW_DELAY;
+ theAllowDelay2 = ALLOW_DELAY;
}
+
+/*******************************************************************************
+
+********************************************************************************/
Archiver::~Archiver()
{
- delete out_fields;
- delete []all_reference_list;
+ delete theRootField;
+ delete [] all_reference_list;
delete simple_hashout_fields;
delete hash_out_fields;
- std::list<fwd_ref>::iterator it;
- for(it = fwd_reference_list.begin(); it != fwd_reference_list.end(); it++)
+ std::list<fwd_ref>::iterator it;
+ for (it = fwd_reference_list.begin(); it != fwd_reference_list.end(); it++)
{
- if((*it).class_name)
+ if ((*it).class_name)
free((*it).class_name);
}
std::vector<archive_field*>::const_iterator orphan_it;
- for(orphan_it = orphan_fields.begin(); orphan_it != orphan_fields.end(); orphan_it++)
+ for (orphan_it = orphan_fields.begin(); orphan_it != orphan_fields.end(); orphan_it++)
{
delete (*orphan_it);
}
}
-void Archiver::create_archive(const char *archive_name,
- const char *archive_info,
- int archive_version)
+/*******************************************************************************
+
+********************************************************************************/
+void Archiver::create_archive(
+ const char* archive_name,
+ const char* archive_info,
+ int archive_version)
{
- this->archive_name = strdup(archive_name);
- this->archive_info = strdup(archive_info);
- this->archive_version = archive_version;
+ theArchiveName = strdup(archive_name);
+ theArchiveInfo = strdup(archive_info);
+ theArchiveVersion = archive_version;
}
-//return true if field is not referencing
-bool Archiver::add_simple_field(const char *type,
- const char *value,
- const void *orig_ptr,
- enum ArchiveFieldTreat field_treat
- )
+
+/*******************************************************************************
+ return true if field is not referencing
+********************************************************************************/
+bool Archiver::add_simple_field(
+ const char* type,
+ const char* value,
+ const void* orig_ptr,
+ enum ArchiveFieldKind field_treat)
{
- current_level++;
- archive_field *new_field;
- archive_field *ref_field = NULL;
- bool exch_fields = false;
+ theCurrentLevel++;
+ archive_field* new_field;
+ archive_field* ref_field = NULL;
+ bool exch_fields = false;
//int id = 0;
if(!orig_ptr)
{
field_treat = ARCHIVE_FIELD_IS_NULL;
}
- else if((field_treat != ARCHIVE_FIELD_IS_BASECLASS) && orig_ptr &&
- !get_is_temp_field() && (!get_is_temp_field_one_level() || ((field_treat == ARCHIVE_FIELD_IS_PTR) && !get_is_temp_field_also_for_ptr())))
+ else if (field_treat != ARCHIVE_FIELD_IS_BASECLASS &&
+ orig_ptr &&
+ !get_is_temp_field() &&
+ (!get_is_temp_field_one_level() ||
+ (field_treat == ARCHIVE_FIELD_IS_PTR && !get_is_temp_field_also_for_ptr())))
+ {
ref_field = check_nonclass_pointer(type, orig_ptr);
- if(ref_field)
+ }
+
+ if (ref_field)
{
- assert((field_treat != ARCHIVE_FIELD_NORMAL) || (ref_field->field_treat != ARCHIVE_FIELD_NORMAL));
- if(get_is_temp_field_one_level() && (field_treat == ARCHIVE_FIELD_IS_PTR) && (allow_delay2 == ALLOW_DELAY))
- allow_delay2 = DONT_ALLOW_DELAY;
- if(field_treat == ARCHIVE_FIELD_NORMAL)
+ assert(field_treat != ARCHIVE_FIELD_NORMAL ||
+ ref_field->theKind != ARCHIVE_FIELD_NORMAL);
+
+ if (get_is_temp_field_one_level() &&
+ field_treat == ARCHIVE_FIELD_IS_PTR &&
+ theAllowDelay2 == ALLOW_DELAY)
+ theAllowDelay2 = DONT_ALLOW_DELAY;
+
+ if (field_treat == ARCHIVE_FIELD_NORMAL)
{
//special case
//move the prev field into this one
exch_fields = true;
}
+
field_treat = ARCHIVE_FIELD_IS_REFERENCING;
value = NULL;
orig_ptr = NULL;
}
-
- new_field = new archive_field(type, true, false, value, orig_ptr, 0, field_treat, ref_field, get_serialize_only_for_eval(), allow_delay2, current_level);
- allow_delay2 = ALLOW_DELAY;
- if(!ref_field && (field_treat != ARCHIVE_FIELD_IS_BASECLASS) && orig_ptr &&
- !get_is_temp_field() && (!get_is_temp_field_one_level() || ((field_treat == ARCHIVE_FIELD_IS_PTR) && !get_is_temp_field_also_for_ptr())))
+ new_field = new archive_field(type,
+ true,
+ false,
+ value,
+ orig_ptr,
+ 0,
+ field_treat,
+ ref_field,
+ get_serialize_only_for_eval(),
+ theAllowDelay2,
+ theCurrentLevel);
+
+ theAllowDelay2 = ALLOW_DELAY;
+
+ if (!ref_field &&
+ field_treat != ARCHIVE_FIELD_IS_BASECLASS &&
+ orig_ptr &&
+ !get_is_temp_field() &&
+ (!get_is_temp_field_one_level() ||
+ (field_treat == ARCHIVE_FIELD_IS_PTR && !get_is_temp_field_also_for_ptr())))
{
- SIMPLE_HASHOUT_FIELD f(type, orig_ptr);
+ SIMPLE_HASHOUT_FIELD f(type, orig_ptr);
simple_hashout_fields->insert(f, new_field);
}
- if(!exch_fields)
+
+ if (!exch_fields)
{
- new_field->parent = current_compound_field;
- new_field->id = ++nr_ids;
- new_field->order = new_field->id;
- if(current_compound_field->last_child)
- current_compound_field->last_child->next = new_field;
+ new_field->theParent = current_compound_field;
+ new_field->theId = ++nr_ids;
+ new_field->theOrder = new_field->theId;
+
+ if (current_compound_field->theLastChild)
+ current_compound_field->theLastChild->theNextSibling = new_field;
else
- current_compound_field->first_child = new_field;
- current_compound_field->last_child = new_field;
+ current_compound_field->theFirstChild = new_field;
+
+ current_compound_field->theLastChild = new_field;
}
else
{
exchange_fields(new_field, ref_field);
}
- current_level--;
+ theCurrentLevel--;
return ref_field != NULL;
}
-void Archiver::replace_field(archive_field *new_field, archive_field *ref_field)
+
+/*******************************************************************************
+
+********************************************************************************/
+void Archiver::replace_field(archive_field* new_field, archive_field* ref_field)
{
- archive_field *ref_field_parent = ref_field->parent;
- archive_field *ref_field_prev = ref_field_parent->first_child;
- if(ref_field_prev == ref_field)//is first child
+ archive_field* ref_field_parent = ref_field->theParent;
+ archive_field* ref_field_prev = ref_field_parent->theFirstChild;
+
+ if (ref_field_prev == ref_field)//is first child
{
- ref_field_parent->first_child = new_field;
- new_field->next = ref_field->next;
+ ref_field_parent->theFirstChild = new_field;
+ new_field->theNextSibling = ref_field->theNextSibling;
}
else
{
- while(ref_field_prev->next != ref_field)
- ref_field_prev = ref_field_prev->next;
- ref_field_prev->next = new_field;
- new_field->next = ref_field->next;
+ while (ref_field_prev->theNextSibling != ref_field)
+ ref_field_prev = ref_field_prev->theNextSibling;
+
+ ref_field_prev->theNextSibling = new_field;
+ new_field->theNextSibling = ref_field->theNextSibling;
}
- new_field->parent = ref_field_parent;
- if(ref_field_parent->last_child == ref_field)
- ref_field_parent->last_child = new_field;
- new_field->order = ref_field->order;
+
+ new_field->theParent = ref_field_parent;
+
+ if (ref_field_parent->theLastChild == ref_field)
+ ref_field_parent->theLastChild = new_field;
+
+ new_field->theOrder = ref_field->theOrder;
}
-void Archiver::exchange_fields(archive_field *new_field, archive_field *ref_field)
+
+/*******************************************************************************
+
+********************************************************************************/
+void Archiver::exchange_fields(archive_field* new_field, archive_field* ref_field)
{
- new_field->field_treat = ARCHIVE_FIELD_IS_REFERENCING;
- ref_field->field_treat = ARCHIVE_FIELD_NORMAL;
-// new_field->id = ref_field->id;
-// ref_field->id = ++nr_ids;
- new_field->id = ++nr_ids;
- new_field->referencing = ref_field->id;
+ new_field->theKind = ARCHIVE_FIELD_IS_REFERENCING;
+ ref_field->theKind = ARCHIVE_FIELD_NORMAL;
+// new_field->theId = ref_field->theId;
+// ref_field->theId = ++nr_ids;
+ new_field->theId = ++nr_ids;
+ new_field->referencing = ref_field->theId;
replace_field(new_field, ref_field);
- ref_field->parent = current_compound_field;
- if(current_compound_field->last_child)
- current_compound_field->last_child->next = ref_field;
+ ref_field->theParent = current_compound_field;
+ if(current_compound_field->theLastChild)
+ current_compound_field->theLastChild->theNextSibling = ref_field;
else
- current_compound_field->first_child = ref_field;
- ref_field->next = NULL;
- current_compound_field->last_child = ref_field;
- ref_field->order = nr_ids;
+ current_compound_field->theFirstChild = ref_field;
+ ref_field->theNextSibling = NULL;
+ current_compound_field->theLastChild = ref_field;
+ ref_field->theOrder = nr_ids;
- new_field->allow_delay2 = ref_field->allow_delay2;
+ new_field->theAllowDelay2 = ref_field->theAllowDelay2;
}
-bool Archiver::add_compound_field(const char *type,
- int version,
- bool is_class,
- const void *info,
- const void *ptr,//for classes, pointer to SerializeBaseClass
- enum ArchiveFieldTreat field_treat
- )
+
+/*******************************************************************************
+
+********************************************************************************/
+bool Archiver::add_compound_field(
+ const char* type,
+ int version,
+ bool is_class,
+ const void* info,
+ const void* ptr,//for classes, pointer to SerializeBaseClass
+ enum ArchiveFieldKind field_treat)
{
- current_level++;
- archive_field *new_field;
- archive_field *ref_field = NULL;
- bool exch_fields = false;
- //int id = 0;
+ theCurrentLevel++;
+ archive_field* new_field;
+ archive_field* ref_field = NULL;
+ bool exch_fields = false;
+
if(!ptr)
{
field_treat = ARCHIVE_FIELD_IS_NULL;
- current_level--;
+ theCurrentLevel--;
}
else if((field_treat != ARCHIVE_FIELD_IS_BASECLASS) && ptr &&
!get_is_temp_field() && (!get_is_temp_field_one_level() || ((field_treat == ARCHIVE_FIELD_IS_PTR) && !get_is_temp_field_also_for_ptr())))
@@ -311,9 +397,9 @@
}
if(ref_field)
{
- assert((field_treat != ARCHIVE_FIELD_NORMAL) || (ref_field->field_treat != ARCHIVE_FIELD_NORMAL));
- if(get_is_temp_field_one_level() && (field_treat == ARCHIVE_FIELD_IS_PTR) && (allow_delay2 == ALLOW_DELAY))
- allow_delay2 = DONT_ALLOW_DELAY;
+ assert((field_treat != ARCHIVE_FIELD_NORMAL) || (ref_field->theKind != ARCHIVE_FIELD_NORMAL));
+ if(get_is_temp_field_one_level() && (field_treat == ARCHIVE_FIELD_IS_PTR) && (theAllowDelay2 == ALLOW_DELAY))
+ theAllowDelay2 = DONT_ALLOW_DELAY;
if(field_treat == ARCHIVE_FIELD_NORMAL)
{
//special case
@@ -324,8 +410,8 @@
ptr = NULL;
}
- new_field = new archive_field(type, false, is_class, info, ptr, version, field_treat, ref_field, get_serialize_only_for_eval(), allow_delay2, current_level);
- allow_delay2 = ALLOW_DELAY;
+ new_field = new archive_field(type, false, is_class, info, ptr, version, field_treat, ref_field, get_serialize_only_for_eval(), theAllowDelay2, theCurrentLevel);
+ theAllowDelay2 = ALLOW_DELAY;
if(!ref_field && (field_treat != ARCHIVE_FIELD_IS_BASECLASS) && ptr &&
!get_is_temp_field() && (!get_is_temp_field_one_level() || ((field_treat == ARCHIVE_FIELD_IS_PTR) && !get_is_temp_field_also_for_ptr())))
{
@@ -341,14 +427,14 @@
}
if(!exch_fields)
{
- new_field->parent = current_compound_field;
- new_field->id = ++nr_ids;
- new_field->order = new_field->id;
- if(current_compound_field->last_child)
- current_compound_field->last_child->next = new_field;
+ new_field->theParent = current_compound_field;
+ new_field->theId = ++nr_ids;
+ new_field->theOrder = new_field->theId;
+ if(current_compound_field->theLastChild)
+ current_compound_field->theLastChild->theNextSibling = new_field;
else
- current_compound_field->first_child = new_field;
- current_compound_field->last_child = new_field;
+ current_compound_field->theFirstChild = new_field;
+ current_compound_field->theLastChild = new_field;
if(!ref_field && ptr)
current_compound_field = new_field;
}
@@ -357,23 +443,35 @@
exchange_fields(new_field, ref_field);
}
if(ref_field)
- current_level--;
+ theCurrentLevel--;
return ref_field != NULL;
}
+
+/*******************************************************************************
+
+********************************************************************************/
void Archiver::add_end_compound_field()
{
- current_compound_field = current_compound_field->parent;
- current_level--;
+ current_compound_field = current_compound_field->theParent;
+ theCurrentLevel--;
}
-void Archiver::set_class_type(const char *class_name)
+
+/*******************************************************************************
+
+********************************************************************************/
+void Archiver::set_class_type(const char* class_name)
{
- free(current_compound_field->type);
- current_compound_field->type = strdup(class_name);
+ free(current_compound_field->theTypeName);
+ current_compound_field->theTypeName = strdup(class_name);
}
-archive_field* Archiver::check_nonclass_pointer(const char *type, const void *ptr)
+
+/*******************************************************************************
+
+********************************************************************************/
+archive_field* Archiver::check_nonclass_pointer(const char* type, const void* ptr)
{
if(!ptr)
return NULL;
@@ -391,28 +489,12 @@
}
return duplicate_field;
}
-/*
-archive_field* Archiver::check_nonclass_pointer_internal(const void *ptr, archive_field *fields)
-{
- archive_field *child;
- child = fields->first_child;
- while(child)
- {
- if(child->is_simple || !child->is_class)
- if(child->assoc_ptr == ptr)
- return child;
- if(!child->is_simple)
- {
- archive_field* ref_field = check_nonclass_pointer_internal(ptr, child);
- if(ref_field)
- return ref_field;
- }
- child = child->next;
- }
- return 0;
-}
-*/
-archive_field* Archiver::check_class_pointer(const SerializeBaseClass *ptr)
+
+
+/*******************************************************************************
+
+********************************************************************************/
+archive_field* Archiver::check_class_pointer(const SerializeBaseClass* ptr)
{
if(!ptr)
return NULL;
@@ -427,174 +509,173 @@
}
return duplicate_field;
}
-/*
-archive_field* Archiver::check_class_pointer_internal(const SerializeBaseClass *ptr, archive_field *fields)
-{
-
- archive_field *child;
- child = fields->first_child;
- while(child)
- {
- if(child->is_class)
- if(child->assoc_class_ptr == ptr)
- return child;
- if(!child->is_simple)
- {
- archive_field* ref_field = check_class_pointer_internal(ptr, child);
- if(ref_field)
- return ref_field;
- }
- child = child->next;
- }
- return 0;
-}
-*/
-
-bool Archiver::read_next_field( char **type,
- std::string *value,
- int *id,
- int *version,
- bool *is_simple,
- bool *is_class,
- enum ArchiveFieldTreat *field_treat,
- int *referencing)
+
+
+/*******************************************************************************
+
+********************************************************************************/
+bool Archiver::read_next_field(
+ char** type,
+ std::string* value,
+ int* id,
+ int* version,
+ bool* is_simple,
+ bool* is_class,
+ enum ArchiveFieldKind* field_treat,
+ int* referencing)
{
bool retval = read_next_field_impl(type, value, id, version, is_simple, is_class, field_treat, referencing);
if(retval && !*is_simple && (*field_treat != ARCHIVE_FIELD_IS_REFERENCING))
- current_level++;
+ theCurrentLevel++;
return retval;
}
+
+/*******************************************************************************
+
+********************************************************************************/
void Archiver::read_end_current_level()
{
- current_level--;
+ theCurrentLevel--;
read_end_current_level_impl();
}
-void Archiver::check_simple_field(bool retval,
- const char *type,
- const char *required_type,
- bool is_simple,
- enum ArchiveFieldTreat field_treat,
- enum ArchiveFieldTreat required_field_treat,
- int id)
-{
- if(!retval)
- {
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0001_NONEXISTENT_INPUT_FIELD, ERROR_PARAMS( id )
- );
- }
-#ifndef NDEBUG
- if(!is_simple)
- {
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS( id )
- );
- }
-#endif
- if(field_treat == ARCHIVE_FIELD_IS_NULL)
- return;
-#ifndef NDEBUG
- if(strcmp(type, required_type))
- {
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS( id )
- );
- }
-#endif
- if((required_field_treat != (enum ArchiveFieldTreat)-1) && (field_treat != required_field_treat))
- {
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS( id )
- );
- }
-}
-
-void Archiver::check_nonclass_field(bool retval,
- const char *type,
- const char *required_type,
- bool is_simple,
- bool is_class,
- enum ArchiveFieldTreat field_treat,
- enum ArchiveFieldTreat required_field_treat,
- int id)
-{
- if(!retval)
- {
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0001_NONEXISTENT_INPUT_FIELD, ERROR_PARAMS( id )
- );
- }
-#ifndef NDEBUG
- if(is_simple || is_class)
- {
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS( id )
- );
- }
-#endif
- if(field_treat == ARCHIVE_FIELD_IS_NULL)
- return;
-#ifndef NDEBUG
- if(strcmp(type, required_type))
- {
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS( id )
- );
- }
-#endif
- if((required_field_treat != (enum ArchiveFieldTreat)-1) && (field_treat != required_field_treat))
- {
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS( id )
- );
- }
-}
-
-void Archiver::check_class_field(bool retval,
- const char *type,
- const char *required_type,
- bool is_simple,
- bool is_class,
- enum ArchiveFieldTreat field_treat,
- enum ArchiveFieldTreat required_field_treat,
- int id)
-{
- if(!retval)
- {
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0001_NONEXISTENT_INPUT_FIELD, ERROR_PARAMS( id )
- );
- }
-#ifndef NDEBUG
- if(is_simple || !is_class)
- {
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS( id )
- );
- }
-#endif
- if(field_treat == ARCHIVE_FIELD_IS_NULL)
- return;
-#ifndef NDEBUG
- if(strcmp(type, required_type))
- {
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS( id )
- );
- }
-#endif
- if((required_field_treat != (enum ArchiveFieldTreat)-1) && (field_treat != required_field_treat))
- {
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS( id )
- );
- }
-}
-
-void Archiver::register_reference(int id, enum ArchiveFieldTreat field_treat, const void *ptr)
+/*******************************************************************************
+
+********************************************************************************/
+void Archiver::check_simple_field(
+ bool retval,
+ const char* type,
+ const char* required_type,
+ bool is_simple,
+ enum ArchiveFieldKind field_treat,
+ enum ArchiveFieldKind required_field_treat,
+ int id)
+{
+ if (!retval)
+ {
+ throw ZORBA_EXCEPTION(zerr::ZCSE0001_NONEXISTENT_INPUT_FIELD, ERROR_PARAMS(id));
+ }
+
+#ifndef NDEBUG
+ if (!is_simple)
+ {
+ throw ZORBA_EXCEPTION(zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS(id));
+ }
+#endif
+
+ if(field_treat == ARCHIVE_FIELD_IS_NULL)
+ return;
+
+#ifndef NDEBUG
+ if (strcmp(type, required_type))
+ {
+ throw ZORBA_EXCEPTION(zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS(id));
+ }
+#endif
+
+ if ((required_field_treat != (enum ArchiveFieldKind)-1) &&
+ field_treat != required_field_treat)
+ {
+ throw ZORBA_EXCEPTION(zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS(id));
+ }
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void Archiver::check_nonclass_field(
+ bool retval,
+ const char* type,
+ const char* required_type,
+ bool is_simple,
+ bool is_class,
+ enum ArchiveFieldKind field_treat,
+ enum ArchiveFieldKind required_field_treat,
+ int id)
+{
+ if (!retval)
+ {
+ throw ZORBA_EXCEPTION(zerr::ZCSE0001_NONEXISTENT_INPUT_FIELD, ERROR_PARAMS(id));
+ }
+
+#ifndef NDEBUG
+ if (is_simple || is_class)
+ {
+ throw ZORBA_EXCEPTION(zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS(id));
+ }
+#endif
+
+ if (field_treat == ARCHIVE_FIELD_IS_NULL)
+ return;
+
+#ifndef NDEBUG
+ if (strcmp(type, required_type))
+ {
+ throw ZORBA_EXCEPTION(zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS(id));
+ }
+#endif
+
+ if ((required_field_treat != (enum ArchiveFieldKind)-1) &&
+ field_treat != required_field_treat)
+ {
+ throw ZORBA_EXCEPTION(zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS(id));
+ }
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void Archiver::check_class_field(
+ bool retval,
+ const char* type,
+ const char* required_type,
+ bool is_simple,
+ bool is_class,
+ enum ArchiveFieldKind field_treat,
+ enum ArchiveFieldKind required_field_treat,
+ int id)
+{
+ if (!retval)
+ {
+ throw ZORBA_EXCEPTION(zerr::ZCSE0001_NONEXISTENT_INPUT_FIELD, ERROR_PARAMS(id));
+ }
+
+#ifndef NDEBUG
+ if (is_simple || !is_class)
+ {
+ throw ZORBA_EXCEPTION(zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS(id));
+ }
+#endif
+
+ if (field_treat == ARCHIVE_FIELD_IS_NULL)
+ return;
+
+#ifndef NDEBUG
+ if (strcmp(type, required_type))
+ {
+ throw ZORBA_EXCEPTION(zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS(id));
+ }
+#endif
+
+ if ((required_field_treat != (enum ArchiveFieldKind)-1) &&
+ field_treat != required_field_treat)
+ {
+ throw ZORBA_EXCEPTION(zerr::ZCSE0002_INCOMPATIBLE_INPUT_FIELD, ERROR_PARAMS(id));
+ }
+}
+
+
+/*******************************************************************************
+
+********************************************************************************/
+void Archiver::register_reference(
+ int id,
+ enum ArchiveFieldKind field_treat,
+ const void* ptr)
{
if(get_is_temp_field())// && (field_treat != ARCHIVE_FIELD_IS_PTR))
return;
@@ -605,16 +686,26 @@
all_reference_list[id] = (void*)ptr;
}
+
+
+/*******************************************************************************
+
+********************************************************************************/
void Archiver::register_item(store::Item* i)
{
if(i)
registered_items.push_back(i);
}
-void Archiver::register_delay_reference(void **ptr,
- bool is_class,
- const char *class_name,
- int referencing)
+
+/*******************************************************************************
+
+********************************************************************************/
+void Archiver::register_delay_reference(
+ void** ptr,
+ bool is_class,
+ const char* class_name,
+ int referencing)
{
struct fwd_ref fid;
fid.referencing = referencing;
@@ -630,7 +721,14 @@
fwd_reference_list.push_back(fid);
}
-void Archiver::reconf_last_delayed_rcobject(void **last_obj, void **new_last_obj, bool to_add_ref)
+
+/*******************************************************************************
+
+********************************************************************************/
+void Archiver::reconf_last_delayed_rcobject(
+ void** last_obj,
+ void** new_last_obj,
+ bool to_add_ref)
{
if(fwd_reference_list.size() > 0)
{
@@ -644,45 +742,58 @@
}
}
-void Archiver::register_pointers_internal(archive_field *fields)
+
+/*******************************************************************************
+
+********************************************************************************/
+void Archiver::register_pointers_internal(archive_field* fields)
{
- archive_field *child;
- child = fields->first_child;
+ archive_field* child;
+ child = fields->theFirstChild;
while(child)
{
- register_reference(child->id, child->field_treat, child->assoc_ptr);
- if(!child->is_simple)
+ register_reference(child->theId, child->theKind, child->assoc_ptr);
+ if(!child->theIsSimple)
{
register_pointers_internal(child);
}
- child = child->next;
+ child = child->theNextSibling;
}
}
-void *Archiver::get_reference_value(int refid)
+
+/*******************************************************************************
+
+********************************************************************************/
+void* Archiver::get_reference_value(int refid)
{
if(internal_archive && !all_reference_list)
{
//construct all_reference_list
root_tag_is_read();
- register_pointers_internal(out_fields);
+ register_pointers_internal(theRootField);
}
- void *assoc_ptr = NULL;
+
+ void* assoc_ptr = NULL;
//if(!all_reference_list->get((uint32_t)refid, assoc_ptr))
- if(!(assoc_ptr=all_reference_list[refid]))
+ if(!(assoc_ptr = all_reference_list[refid]))
{
- Archiver *har = ::zorba::serialization::ClassSerializer::getInstance()->getArchiverForHardcodedObjects();
+ Archiver* har = ::zorba::serialization::ClassSerializer::getInstance()->getArchiverForHardcodedObjects();
if(har != this)
assoc_ptr = har->get_reference_value(refid);
}
return assoc_ptr;
}
+
+/*******************************************************************************
+
+********************************************************************************/
void Archiver::finalize_input_serialization()
{
- std::list<fwd_ref>::iterator it;
- void *ptr;
- for(it = fwd_reference_list.begin(); it != fwd_reference_list.end(); it++)
+ std::list<fwd_ref>::iterator it;
+ void* ptr;
+ for (it = fwd_reference_list.begin(); it != fwd_reference_list.end(); it++)
{
ptr = get_reference_value((*it).referencing);
if(!ptr)
@@ -755,58 +866,88 @@
}
}
+
+/*******************************************************************************
+
+********************************************************************************/
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(archive_version != g_zorba_classes_version)
+ if (theArchiveVersion != g_zorba_classes_version)
{
- throw ZORBA_EXCEPTION(
- zerr::ZCSE0012_INCOMPATIBLE_ARCHIVE_VERSION,
- ERROR_PARAMS( archive_version, g_zorba_classes_version )
- );
+ throw ZORBA_EXCEPTION(zerr::ZCSE0012_INCOMPATIBLE_ARCHIVE_VERSION,
+ ERROR_PARAMS(theArchiveVersion, g_zorba_classes_version));
}
- //all_reference_list = new hash32map<void*>(nr_ids*2, 0.6f);
+
all_reference_list = new void*[nr_ids+1];
memset(all_reference_list, 0, sizeof(void*)*(nr_ids+1));
}
+
+/*******************************************************************************
+
+********************************************************************************/
int Archiver::get_nr_ids()
{
return nr_ids;
}
+
+/*******************************************************************************
+
+********************************************************************************/
void Archiver::prepare_serialize_out()
{
- if(!is_serialize_everything())
+ if (!is_serialize_everything())
{
- check_compound_fields(out_fields);
+ check_compound_fields(theRootField);
}
- while(check_allowed_delays(out_fields))
- {}
+ while(check_allowed_delays(theRootField))
+ {
+ }
}
-archive_field* Archiver::replace_with_null(archive_field *current_field)
+
+/*******************************************************************************
+
+********************************************************************************/
+archive_field* Archiver::replace_with_null(archive_field* current_field)
{
- if(current_field->parent)
+ if (current_field->theParent)
{
- archive_field *null_field = new archive_field("NULL",
- current_field->is_simple,
- current_field->is_class, "", NULL, 0,
- ARCHIVE_FIELD_IS_NULL, NULL, false, ALLOW_DELAY, current_field->level);
- null_field->id = ++nr_ids;
+ archive_field* null_field = new archive_field("NULL",
+ current_field->theIsSimple,
+ current_field->theIsClass,
+ "",
+ NULL,
+ 0,
+ ARCHIVE_FIELD_IS_NULL,
+ NULL,
+ false,
+ ALLOW_DELAY,
+ current_field->theLevel);
+ null_field->theId = ++nr_ids;
replace_field(null_field, current_field);
- current_field->parent = NULL;
- current_field->next = NULL;
+ current_field->theParent = NULL;
+ current_field->theNextSibling = NULL;
return null_field;
}
@@ -814,59 +955,71 @@
return NULL;
}
-int Archiver::compute_field_depth(archive_field *field)
+
+/*******************************************************************************
+
+********************************************************************************/
+int Archiver::compute_field_depth(archive_field* field)
{
archive_field *temp;
int i=0;
- temp = field->parent;
+ temp = field->theParent;
while(temp)
{
- temp = temp->parent;
+ temp = temp->theParent;
i++;
}
return i;
}
-int Archiver::get_only_for_eval(archive_field *field)
+
+/*******************************************************************************
+
+********************************************************************************/
+int Archiver::get_only_for_eval(archive_field* field)
{
- if(field->only_for_eval)
- return field->only_for_eval;
+ if(field->theOnlyForEval)
+ return field->theOnlyForEval;
archive_field *child;
- for(child = field->first_child; child; child = child->next)
+ for(child = field->theFirstChild; child; child = child->theNextSibling)
{
- if(child->only_for_eval)
- return child->only_for_eval;
+ if(child->theOnlyForEval)
+ return child->theOnlyForEval;
}
return 0;
}
-archive_field* Archiver::find_top_most_eval_only_field(archive_field *parent_field)
+
+/*******************************************************************************
+
+********************************************************************************/
+archive_field* Archiver::find_top_most_eval_only_field(archive_field* parent_field)
{
int ref_depth = -1;
archive_field *refering_field = NULL;
archive_field *child;
- child = parent_field->first_child;
+ child = parent_field->theFirstChild;
while(child)
{
- if(child->only_for_eval)
+ if(child->theOnlyForEval)
{
}
- else if((child->field_treat == ARCHIVE_FIELD_IS_REFERENCING) &&
- get_only_for_eval(child->refered))
+ else if((child->theKind == ARCHIVE_FIELD_IS_REFERENCING) &&
+ get_only_for_eval(child->theReferredField))
{
- int new_depth = compute_field_depth(child->refered);
+ int new_depth = compute_field_depth(child->theReferredField);
if(!refering_field || (ref_depth > new_depth))
{
ref_depth = new_depth;
refering_field = child;
}
}
- else if(!child->is_simple && !child->refered)
+ else if(!child->theIsSimple && !child->theReferredField)
{
archive_field *new_refering = find_top_most_eval_only_field(child);
if(new_refering)
{
- int new_depth = compute_field_depth(new_refering->refered);
+ int new_depth = compute_field_depth(new_refering->theReferredField);
if(!refering_field || (ref_depth > new_depth))
{
ref_depth = new_depth;
@@ -874,49 +1027,57 @@
}
}
}
- child = child->next;
+ child = child->theNextSibling;
}
return refering_field;
}
-void Archiver::exchange_mature_fields(archive_field *field1, archive_field *field2)
+
+/*******************************************************************************
+
+********************************************************************************/
+void Archiver::exchange_mature_fields(archive_field* field1, archive_field* field2)
{
archive_field *field1_prev = get_prev(field1);
- archive_field *field1_next = field1->next;
- archive_field *field1_parent = field1->parent;
+ archive_field *field1_next = field1->theNextSibling;
+ archive_field *field1_parent = field1->theParent;
archive_field *field2_prev = get_prev(field2);
- archive_field *field2_parent = field2->parent;
- archive_field *field2_next = field2->next;
+ archive_field *field2_parent = field2->theParent;
+ archive_field *field2_next = field2->theNextSibling;
//move field2
if(field1_prev)
- field1_prev->next = field2;
+ field1_prev->theNextSibling = field2;
else
- field1_parent->first_child = field2;
- field2->next = field1_next;
+ field1_parent->theFirstChild = field2;
+ field2->theNextSibling = field1_next;
if(!field1_next)
- field1_parent->last_child = field2;
- field2->parent = field1_parent;
+ field1_parent->theLastChild = field2;
+ field2->theParent = field1_parent;
//move field1
if(field2_prev)
- field2_prev->next = field1;
+ field2_prev->theNextSibling = field1;
else
- field2_parent->first_child = field1;
- field1->next = field2_next;
+ field2_parent->theFirstChild = field1;
+ field1->theNextSibling = field2_next;
if(!field2_next)
- field2_parent->last_child = field1;
- field1->parent = field2_parent;
+ field2_parent->theLastChild = field1;
+ field1->theParent = field2_parent;
- ENUM_ALLOW_DELAY temp_delay = field1->allow_delay2;
- field1->allow_delay2 = field2->allow_delay2;
- field2->allow_delay2 = temp_delay;
+ ENUM_ALLOW_DELAY temp_delay = field1->theAllowDelay2;
+ field1->theAllowDelay2 = field2->theAllowDelay2;
+ field2->theAllowDelay2 = temp_delay;
unsigned int temp_order;
- temp_order = field1->order;
- field1->order = field2->order;
- field2->order = temp_order;
+ temp_order = field1->theOrder;
+ field1->theOrder = field2->theOrder;
+ field2->theOrder = temp_order;
}
-void Archiver::check_compound_fields(archive_field *parent_field)
+
+/*******************************************************************************
+
+********************************************************************************/
+void Archiver::check_compound_fields(archive_field* parent_field)
{
//resolve all references first
//iterate: find the reference to the top most eval_only field and resolve it
@@ -927,75 +1088,83 @@
if(!refering_field)
break;
- if((refering_field->refered->allow_delay2 != ALLOW_DELAY) ||
- (refering_field->refered->field_treat == ARCHIVE_FIELD_NORMAL) ||
- !refering_field->refered->only_for_eval)
+ if((refering_field->theReferredField->theAllowDelay2 != ALLOW_DELAY) ||
+ (refering_field->theReferredField->theKind == ARCHIVE_FIELD_NORMAL) ||
+ !refering_field->theReferredField->theOnlyForEval)
{
//must preserve this serialization
- archive_field *temp_field = refering_field->refered->parent;
+ archive_field *temp_field = refering_field->theReferredField->theParent;
while(temp_field)
{
- temp_field->only_for_eval = 0;
- temp_field = temp_field->parent;
+ temp_field->theOnlyForEval = 0;
+ temp_field = temp_field->theParent;
}
}
else
{
- exchange_mature_fields(refering_field, refering_field->refered);
- refering_field->only_for_eval = refering_field->refered->only_for_eval;
+ exchange_mature_fields(refering_field, refering_field->theReferredField);
+ refering_field->theOnlyForEval = refering_field->theReferredField->theOnlyForEval;
}
- clean_only_for_eval(refering_field->refered, get_only_for_eval(refering_field->refered));
+ clean_only_for_eval(refering_field->theReferredField, get_only_for_eval(refering_field->theReferredField));
}
while(check_only_for_eval_nondelay_referencing(parent_field))
{}
replace_only_for_eval_with_null(parent_field);
}
-bool Archiver::check_only_for_eval_nondelay_referencing(archive_field *parent_field)
+
+/*******************************************************************************
+
+********************************************************************************/
+bool Archiver::check_only_for_eval_nondelay_referencing(archive_field* parent_field)
{
- archive_field *current_field = parent_field->first_child;
+ archive_field *current_field = parent_field->theFirstChild;
while(current_field)
{
- if(current_field->only_for_eval && (current_field->field_treat != ARCHIVE_FIELD_NORMAL))
+ if(current_field->theOnlyForEval && (current_field->theKind != ARCHIVE_FIELD_NORMAL))
{
- if((current_field->field_treat == ARCHIVE_FIELD_IS_REFERENCING) &&
- (current_field->allow_delay2 != ALLOW_DELAY) &&
- (!current_field->refered->only_for_eval))
+ if((current_field->theKind == ARCHIVE_FIELD_IS_REFERENCING) &&
+ (current_field->theAllowDelay2 != ALLOW_DELAY) &&
+ (!current_field->theReferredField->theOnlyForEval))
{
//exchange fields
- // exchange_mature_fields(current_field, current_field->refered);
- // current_field->only_for_eval = false;
+ // exchange_mature_fields(current_field, current_field->theReferredField);
+ // current_field->theOnlyForEval = false;
//must preserve this serialization
- archive_field *temp_field = current_field->parent;
+ archive_field *temp_field = current_field->theParent;
while(temp_field)
{
- temp_field->only_for_eval = 0;
- temp_field = temp_field->parent;
+ temp_field->theOnlyForEval = 0;
+ temp_field = temp_field->theParent;
}
- clean_only_for_eval(current_field, current_field->only_for_eval);
+ clean_only_for_eval(current_field, current_field->theOnlyForEval);
return true;
}
}
- if(!current_field->is_simple)
+ if(!current_field->theIsSimple)
{
if(check_only_for_eval_nondelay_referencing(current_field))
return true;
}
- current_field = current_field->next;
+ current_field = current_field->theNextSibling;
}
return false;
}
-void Archiver::replace_only_for_eval_with_null(archive_field *parent_field)
+
+/*******************************************************************************
+
+********************************************************************************/
+void Archiver::replace_only_for_eval_with_null(archive_field* parent_field)
{
- archive_field *current_field = parent_field->first_child;
+ archive_field *current_field = parent_field->theFirstChild;
while(current_field)
{
- if(current_field->only_for_eval &&
- (current_field->field_treat != ARCHIVE_FIELD_NORMAL) &&
- (current_field->field_treat != ARCHIVE_FIELD_IS_BASECLASS))
+ if(current_field->theOnlyForEval &&
+ (current_field->theKind != ARCHIVE_FIELD_NORMAL) &&
+ (current_field->theKind != ARCHIVE_FIELD_IS_BASECLASS))
{
//don't save it, replace it with NULL if possible
archive_field *null_field = replace_with_null(current_field);
@@ -1004,50 +1173,57 @@
current_field = null_field;
}
- if(!current_field->is_simple)
+ if(!current_field->theIsSimple)
{
replace_only_for_eval_with_null(current_field);
}
- current_field = current_field->next;
+ current_field = current_field->theNextSibling;
}
}
-void Archiver::clean_only_for_eval(archive_field *field, int substract_value)
+
+/*******************************************************************************
+
+********************************************************************************/
+void Archiver::clean_only_for_eval(archive_field* field, int substract_value)
{
- if(field->only_for_eval >= substract_value)
- field->only_for_eval -= substract_value;
+ if(field->theOnlyForEval >= substract_value)
+ field->theOnlyForEval -= substract_value;
else
- field->only_for_eval = 0;
- if(!field->is_simple)
+ field->theOnlyForEval = 0;
+ if(!field->theIsSimple)
{
- archive_field *child = field->first_child;
+ archive_field *child = field->theFirstChild;
while(child)
{
clean_only_for_eval(child, substract_value);
- child = child->next;
+ child = child->theNextSibling;
}
}
}
-/*
+
+
+/*******************************************************************************
return 0 if not found
return -1 if field1 is before field2
return 1 if field1 is after field2
-*/
-int Archiver::check_order(archive_field *parent_field,
- archive_field *field1,
- archive_field *field2)
+********************************************************************************/
+int Archiver::check_order(
+ archive_field* parent_field,
+ archive_field* field1,
+ archive_field* field2)
{
- if(field1->order < field2->order)
+ if(field1->theOrder < field2->theOrder)
return -1;
- else if(field1->order == field2->order)
+ else if(field1->theOrder == field2->theOrder)
return 0;
else
return 1;
/*
archive_field *child;
int check_ret;
- child = parent_field->first_child;
+ child = parent_field->theFirstChild;
while(child)
{
if(child == field1)
@@ -1060,61 +1236,79 @@
if(check_ret)
return check_ret;
}
- child = child->next;
+ child = child->theNextSibling;
}
return 0;
*/
}
+
+/*******************************************************************************
+
+********************************************************************************/
archive_field* Archiver::get_prev(archive_field* field)
{
- archive_field *temp;
- temp = field->parent->first_child;
- if(temp == field)
+ archive_field* temp;
+ temp = field->theParent->theFirstChild;
+
+ if (temp == field)
return NULL;
- while(temp)
+
+ while (temp)
{
- if(temp->next == field)
+ if (temp->theNextSibling == field)
return temp;
- temp = temp->next;
+
+ temp = temp->theNextSibling;
}
+
assert(false);//unreachable
return NULL;
}
-bool Archiver::check_allowed_delays(archive_field *parent_field)
+
+/*******************************************************************************
+
+********************************************************************************/
+bool Archiver::check_allowed_delays(archive_field* parent_field)
{
//check all fields with dont_allow_delay and see if they are delayed
//exchange field with the reference then
- archive_field *child;
- child = parent_field->first_child;
- while(child)
+ archive_field* child;
+ child = parent_field->theFirstChild;
+
+ while (child)
{
- if((child->field_treat == ARCHIVE_FIELD_IS_REFERENCING) &&
- (((child->allow_delay2 == DONT_ALLOW_DELAY) && (check_order(out_fields, child, child->refered) < 1) && (child->allow_delay2 == DONT_ALLOW_DELAY)) ||
- (child->allow_delay2 == SERIALIZE_NOW)))
+ if (child->theKind == ARCHIVE_FIELD_IS_REFERENCING &&
+ ((child->theAllowDelay2 == DONT_ALLOW_DELAY &&
+ check_order(theRootField, child, child->theReferredField) < 1 &&
+ child->theAllowDelay2 == DONT_ALLOW_DELAY) ||
+ child->theAllowDelay2 == SERIALIZE_NOW))
{
- if(child->allow_delay2 == SERIALIZE_NOW)
+ if (child->theAllowDelay2 == SERIALIZE_NOW)
{
}
- if((child->refered->field_treat == ARCHIVE_FIELD_NORMAL) ||
- (child->refered->allow_delay2 == SERIALIZE_NOW))
+
+ if (child->theReferredField->theKind == ARCHIVE_FIELD_NORMAL ||
+ child->theReferredField->theAllowDelay2 == SERIALIZE_NOW)
{
//impossible to solve situation
//need to change the serialization order somewhere
throw ZORBA_EXCEPTION(zerr::ZCSE0014_INFINITE_CIRCULAR_DEPENDENCIES);
}
//exchange fields
- exchange_mature_fields(child, child->refered);
+ exchange_mature_fields(child, child->theReferredField);
- // child->refered->allow_delay2 = ALLOW_DELAY;
- child = child->refered;
+ // child->theReferredField->theAllowDelay2 = ALLOW_DELAY;
+ child = child->theReferredField;
return true;
}
- if(check_allowed_delays(child))
+
+ if (check_allowed_delays(child))
return true;
- child = child->next;
+
+ child = child->theNextSibling;
}
return false;
=== modified file 'src/zorbaserialization/archiver.h'
--- src/zorbaserialization/archiver.h 2012-02-02 09:56:52 +0000
+++ src/zorbaserialization/archiver.h 2012-02-26 21:58:26 +0000
@@ -18,13 +18,13 @@
#define ZORBA_BINARY_SERIALIZATION_ARCHIVER
#include "util/hashmap32.h"
-//#include "zorbautils/hashmap.h"
#include <stack>
#include "zorbaserialization/class_serializer.h"
#include "zorbaserialization/plan_settings.h"
-namespace zorba{
+namespace zorba
+{
namespace store
{
@@ -46,18 +46,44 @@
/*
Archiver is working with fields. One archive contains a sequence of fields.
They can be simple fields or combo fields.
+
Simple fields: have values of simple types.
Combo fields: contain a sequence of fields. Are like list, vector, class etc.
Each field has a unique id.
- Special field is a field that points to a previous field. This is to resolve serialization
- of pointers to the same object.
+ Special field is a field that points to a previous field. This is to resolve
+ serialization of pointers to the same object.
*/
class ClassSerializer;
-enum ArchiveFieldTreat
+
+/*******************************************************************************
+
+ ARCHIVE_FIELD_IS_REFERENCING :
+ ------------------------------
+ A field A that references another field B, where both A and B represent the
+ "same" object.
+
+ ARCHIVE_FIELD_IS_BASECLASS :
+ ----------------------------
+ A field representing a "partial" class object: If an obj O belong to a class C
+ and C is a subclass of a base class B, then a field of ARCHIVE_FIELD_IS_BASECLASS
+ kind is created to represent the serialization of the data members of B.
+
+ ARCHIVE_FIELD_IS_PTR :
+ ----------------------
+
+ ARCHIVE_FIELD_IS_NULL :
+ -----------------------
+ A field representing a NULL pointer.
+
+ ARCHIVE_FIELD_NORMAL :
+ ----------------------
+
+********************************************************************************/
+enum ArchiveFieldKind
{
ARCHIVE_FIELD_NORMAL,
ARCHIVE_FIELD_IS_PTR,
@@ -66,6 +92,21 @@
ARCHIVE_FIELD_IS_REFERENCING
};
+
+/*******************************************************************************
+
+********************************************************************************/
+enum ENUM_ALLOW_DELAY
+{
+ ALLOW_DELAY,
+ DONT_ALLOW_DELAY,
+ SERIALIZE_NOW
+};
+
+
+/*******************************************************************************
+
+********************************************************************************/
struct fwd_ref
{
int referencing;
@@ -76,66 +117,185 @@
bool to_add_ref;
};
-enum ENUM_ALLOW_DELAY
-{
- ALLOW_DELAY,
- DONT_ALLOW_DELAY,
- SERIALIZE_NOW
-};
-
+
+/*******************************************************************************
+ theId :
+ -------
+ The unique id of the field. Not initialized by constructor.
+
+ theIsSimple:
+ ------------
+ Whether this field represents a "simple" obj or a "compound" obj.
+
+ theIsClass:
+ -----------
+ Whether this field represents a class obj or not. Class objs are always
+ 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.
+
+ theTypeName:
+ ------------
+
+ theTypeNamePosInPool:
+ ---------------------
+
+ theValue:
+ ---------
+ For simple fields
+
+ theValuePosInPool:
+ ------------------
+ Not initialized by constructor.
+
+ thePtr :
+ --------
+ Pointer to the obj represented by this field. NULL if this field is referencing
+ another field that represents the same obj.
+
+ theReferredField:
+ -----------------
+
+ referencing:
+ ------------
+
+ theOrder:
+ ---------
+ Order in the tree. Not initialized by constructor.
+
+ theLevel:
+ ---------
+ The level of this field, i.e., the nuber of fields in the paths from this
+ field to the root. The root is at level 0.
+
+ theNextSibling:
+ ---------------
+
+ theFirstChild:
+ --------------
+
+ theLastChild:
+ -------------
+
+ theParent:
+ ----------
+
+ theOnlyForEval:
+ ---------------
+
+ theAllowDelay2:
+ ---------------
+
+ theBytesSaved:
+ --------------
+
+ theObjectsSaved:
+ ----------------
+
+ The following data members are serialized:
+
+ 1. theTypeName : only if theKind is PTR
+ 2. theValue : except if theKind is REFERENCING
+ 3. theReferedId : only if theKind is REFERENCING
+ 4. theKind
+ 5. theId
+********************************************************************************/
class archive_field
{
public:
- char *type;
- unsigned int type_str_pos_in_pool;
- bool is_simple;
- unsigned int version;//for classes
- enum ArchiveFieldTreat field_treat;
- unsigned int referencing;
- unsigned int id;
- unsigned int order;///order in the tree
- unsigned int level;
- bool is_class;
- const char *value;//for simple fields
- unsigned int value_str_pos_in_pool;
- union{
- const SerializeBaseClass *assoc_class_ptr;
- const void *assoc_ptr;
+ unsigned int theId;
+
+ bool theIsSimple;
+ bool theIsClass;
+ unsigned int theClassVersion;
+
+ enum ArchiveFieldKind theKind;
+
+ char * theTypeName;
+ unsigned int theTypeNamePosInPool;
+
+ const char * theValue;
+ unsigned int theValuePosInPool;
+
+ union
+ {
+ const SerializeBaseClass * assoc_class_ptr;
+ const void * assoc_ptr;
};
- class archive_field *next;
- class archive_field *first_child;
- class archive_field *last_child;
- class archive_field *parent;
- class archive_field *refered;
-
- int only_for_eval;
- ENUM_ALLOW_DELAY allow_delay2;
+ class archive_field * theReferredField;
+ unsigned int referencing;
+
+ unsigned int theOrder;
+
+ unsigned int theLevel;
+
+ class archive_field * theNextSibling;
+ class archive_field * theFirstChild;
+ class archive_field * theLastChild;
+ class archive_field * theParent;
+
+ int theOnlyForEval;
+
+ ENUM_ALLOW_DELAY theAllowDelay2;
+
#ifdef ZORBA_PLAN_SERIALIZER_STATISTICS
- unsigned int bytes_saved;
- unsigned int objects_saved;
+ unsigned int theBytesSaved;
+ unsigned int theObjectsSaved;
#endif
+
public:
- archive_field(const char *type, bool is_simple, bool is_class,
- const void *value, const void *assoc_ptr,
- int version, enum ArchiveFieldTreat field_treat,
- archive_field *refered,
- int only_for_eval,
- ENUM_ALLOW_DELAY allow_delay,
- unsigned int level);
+ archive_field(
+ const char* type,
+ bool is_simple,
+ bool is_class,
+ const void* value,
+ const void* assoc_ptr,
+ int version,
+ enum ArchiveFieldKind field_treat,
+ archive_field* refered,
+ int only_for_eval,
+ ENUM_ALLOW_DELAY allow_delay,
+ unsigned int level);
+
~archive_field();
};
-//base class
+
+/*******************************************************************************
+
+ theSerializingOut :
+ -------------------
+ Whether the archiver is used to serialize or deserialize a plan.
+
+ theRootField :
+ --------------
+ The root of the fields tree.
+
+ theCCB :
+ --------
+ to workaround user defined function compile-at-runtime.
+
+********************************************************************************/
class Archiver
{
friend class ClassSerializer;
+
struct SIMPLE_HASHOUT_FIELD
{
std::string type;
- const void * ptr;
+ const void * ptr;
+
SIMPLE_HASHOUT_FIELD() {}
- SIMPLE_HASHOUT_FIELD(const char *typestr, const void *ptrptr)
+
+ SIMPLE_HASHOUT_FIELD(const char* typestr, const void* ptrptr)
{
type = typestr;
if(type[type.length()-1] == '*')
@@ -144,6 +304,7 @@
}
};
+
class SimpleHashoutFieldCompare
{
public:
@@ -162,285 +323,364 @@
return false;
}
};
+
+ typedef HashMap<SIMPLE_HASHOUT_FIELD,
+ archive_field*,
+ SimpleHashoutFieldCompare> SimpleFieldMap;
+
protected:
- bool serializing_out;
- //ClassSerializer *ser;
-
- int serialize_base_class;
-
- //std::list<struct field_ptr_vs_id> all_reference_list;
- //hash32map<void*> *all_reference_list;//key is id, value is assoc_ptr
- void* *all_reference_list;
+ bool theSerializingOut;
+
+ int serialize_base_class;
+
+ void ** all_reference_list;
- std::list<struct fwd_ref> fwd_reference_list;
-
- std::string archive_name;
- std::string archive_info;
- unsigned long archive_version;
-
- class archive_field *out_fields;
- class archive_field *current_compound_field;
- HashMap<SIMPLE_HASHOUT_FIELD, archive_field*, SimpleHashoutFieldCompare> *simple_hashout_fields;//for simple types
- hash64map<archive_field*> *hash_out_fields;//key is ptr, value is archive_field*, for non-simple types
- std::vector<archive_field*> orphan_fields;
-
- int nr_ids;
- int current_class_version;
-
- bool read_optional;
- int is_temp_field;
- //bool is_temp_field_one_level;
- unsigned int current_level;
+ std::list<struct fwd_ref> fwd_reference_list;
+
+ std::string theArchiveName;
+ std::string theArchiveInfo;
+ unsigned long theArchiveVersion;
+
+ archive_field * theRootField;
+
+ archive_field * current_compound_field;
+
+ SimpleFieldMap * simple_hashout_fields;//for simple types
+
+ hash64map<archive_field*> * hash_out_fields;//key is ptr, value is archive_field*, for non-simple types
+ std::vector<archive_field*> orphan_fields;
+
+ int nr_ids;
+
+ int current_class_version;
+
+ bool read_optional;
+
+ int theIsTempField;
+
+ unsigned int theCurrentLevel;
+
std::stack< std::pair<unsigned int, bool> > limit_temp_level_stack;
- bool internal_archive;
- int only_for_eval;
- bool serialize_everything;
- bool loading_hardcoded_objects;
- ENUM_ALLOW_DELAY allow_delay2;
-
- std::vector<store::Item*> registered_items;
- SerializationCallback* theUserCallback;
+
+ bool internal_archive;
+
+ int theOnlyForEval;
+
+ bool theSerializeEverything;
+
+ bool loading_hardcoded_objects;
+
+ ENUM_ALLOW_DELAY theAllowDelay2;
+
+ std::vector<store::Item*> registered_items;
+
+ SerializationCallback * theUserCallback;
public:
- //CompilerCB *compiler_cb;///to workaround user defined function compile-at-runtime
- bool dont_allow_delay_for_plan_sctx;
+ bool dont_allow_delay_for_plan_sctx;
+
public:
Archiver(bool is_serializing_out, bool internal_archive=false);
+
virtual ~Archiver();
-public:
- SerializationCallback*
- getUserCallback() const { return theUserCallback; }
-
- void
- setUserCallback(SerializationCallback* aCallback) { theUserCallback = aCallback; }
-
-public:
- bool add_simple_field( const char *type,
- const char *value,
- const void *orig_ptr,
- enum ArchiveFieldTreat field_treat);
-
- bool add_compound_field( const char *type,
- int version,
- bool is_class,
- const void *info,
- const void *ptr,//for classes, pointer to SerializeBaseClass
- enum ArchiveFieldTreat field_treat
- );
+ SerializationCallback* getUserCallback() const { return theUserCallback; }
+
+ void setUserCallback(SerializationCallback* aCallback) { theUserCallback = aCallback; }
+
+ bool add_simple_field(
+ const char* type,
+ const char* value,
+ const void* orig_ptr,
+ enum ArchiveFieldKind field_treat);
+
+ bool add_compound_field(
+ const char* type,
+ int version,
+ bool is_class,
+ const void* info,
+ const void* ptr,//for classes, pointer to SerializeBaseClass
+ enum ArchiveFieldKind field_treat);
void add_end_compound_field();
- void set_class_type(const char *class_name);
+ void set_class_type(const char* class_name);
//return the id of previous object if it is the same
- archive_field* check_nonclass_pointer(const char *type, const void *ptr);
- archive_field* check_class_pointer(const SerializeBaseClass *ptr);
+ archive_field* check_nonclass_pointer(const char* type, const void* ptr);
+
+ archive_field* check_class_pointer(const SerializeBaseClass* ptr);
- bool read_next_field( char **type,
- std::string *value,
- int *id,
- int *version,
- bool *is_simple,
- bool *is_class,
- enum ArchiveFieldTreat *field_treat,
- int *referencing);
+ bool read_next_field(
+ char** type,
+ std::string* value,
+ int* id,
+ int* version,
+ bool* is_simple,
+ bool* is_class,
+ enum ArchiveFieldKind* field_treat,
+ int* referencing);
void read_end_current_level();
- virtual bool read_next_field_impl( char **type,
- std::string *value,
- int *id,
- int *version,
- bool *is_simple,
- bool *is_class,
- enum ArchiveFieldTreat *field_treat,
- int *referencing) = 0;
+ 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) = 0;
virtual void read_end_current_level_impl() = 0;
protected:
- virtual void create_archive(const char *archive_name,
- const char *archive_info,
- int archive_version);
+ virtual void create_archive(
+ const char* archive_name,
+ const char* archive_info,
+ int archive_version);
virtual void serialize_out() = 0;
- virtual void read_archive_description(std::string *archive_name,
- std::string *archive_info,
- int *archive_version,
- int *nr_ids)
+ virtual void read_archive_description(
+ std::string* archive_name,
+ std::string* archive_info,
+ int* archive_version,
+ int* nr_ids)
{
- *archive_name = this->archive_name;
- *archive_info = this->archive_info;
- *archive_version = this->archive_version;
+ *archive_name = theArchiveName;
+ *archive_info = theArchiveInfo;
+ *archive_version = theArchiveVersion;
*nr_ids = this->nr_ids;
}
protected:
- archive_field* check_nonclass_pointer_internal(const void *ptr, archive_field *fields);
- archive_field* check_class_pointer_internal(const SerializeBaseClass *ptr, archive_field *fields);
- void replace_field(archive_field *new_field, archive_field *ref_field);
- void exchange_fields(archive_field *new_field, archive_field *ref_field);
+ archive_field* check_nonclass_pointer_internal(
+ const void* ptr,
+ archive_field* fields);
+
+ archive_field* check_class_pointer_internal(
+ const SerializeBaseClass* ptr,
+ archive_field* fields);
+
+ void replace_field(archive_field* new_field, archive_field* ref_field);
+
+ void exchange_fields(archive_field* new_field, archive_field* ref_field);
void root_tag_is_read();
- void register_pointers_internal(archive_field *fields);
+
+ void register_pointers_internal(archive_field* fields);
+
void prepare_serialize_out();
- archive_field* replace_with_null(archive_field *current_field);
- int compute_field_depth(archive_field *field);
- int get_only_for_eval(archive_field *field);
- archive_field* find_top_most_eval_only_field(archive_field *parent_field);
- void check_compound_fields(archive_field *parent_field);
- bool check_only_for_eval_nondelay_referencing(archive_field *parent_field);
- void replace_only_for_eval_with_null(archive_field *parent_field);
- void clean_only_for_eval(archive_field *field, int substract_value);
- void exchange_mature_fields(archive_field *field1, archive_field *field2);
+
+ archive_field* replace_with_null(archive_field* current_field);
+
+ int compute_field_depth(archive_field* field);
+
+ int get_only_for_eval(archive_field* field);
+
+ archive_field* find_top_most_eval_only_field(archive_field* parent_field);
+
+ void check_compound_fields(archive_field* parent_field);
+
+ bool check_only_for_eval_nondelay_referencing(archive_field* parent_field);
+
+ void replace_only_for_eval_with_null(archive_field* parent_field);
+
+ void clean_only_for_eval(archive_field* field, int substract_value);
+
+ void exchange_mature_fields(archive_field* field1, archive_field* field2);
+
archive_field* get_prev(archive_field* field);
- int check_order(archive_field *parent_field,
- archive_field *field1,
- archive_field *field2);
- bool check_allowed_delays(archive_field *parent_field);
+
+ int check_order(
+ archive_field* parent_field,
+ archive_field* field1,
+ archive_field* field2);
+
+ bool check_allowed_delays(archive_field* parent_field);
public:
- void check_simple_field(bool retval,
- const char *type,
- const char *required_type,
- bool is_simple,
- enum ArchiveFieldTreat field_treat,
- enum ArchiveFieldTreat required_field_treat,
- int id);
- void check_nonclass_field(bool retval,
- const char *type,
- const char *required_type,
- bool is_simple,
- bool is_class,
- enum ArchiveFieldTreat field_treat,
- enum ArchiveFieldTreat required_field_treat,
- int id);
- void check_class_field(bool retval,
- const char *type,
- const char *required_type,
- bool is_simple,
- bool is_class,
- enum ArchiveFieldTreat field_treat,
- enum ArchiveFieldTreat required_field_treat,
- int id);
- void register_reference(int id, enum ArchiveFieldTreat field_treat, const void *ptr);
- void register_delay_reference(void **ptr, bool is_class, const char *class_name, int referencing);
- void reconf_last_delayed_rcobject(void **last_obj, void **new_last_obj, bool to_add_ref);
+ void check_simple_field(
+ bool retval,
+ const char* type,
+ const char* required_type,
+ bool is_simple,
+ enum ArchiveFieldKind field_treat,
+ enum ArchiveFieldKind required_field_treat,
+ int id);
+
+ void check_nonclass_field(
+ bool retval,
+ const char* type,
+ const char* required_type,
+ bool is_simple,
+ bool is_class,
+ enum ArchiveFieldKind field_treat,
+ enum ArchiveFieldKind required_field_treat,
+ int id);
+
+ void check_class_field(
+ bool retval,
+ const char* type,
+ const char* required_type,
+ bool is_simple,
+ bool is_class,
+ enum ArchiveFieldKind field_treat,
+ enum ArchiveFieldKind required_field_treat,
+ int id);
+
+ void register_reference(
+ int id,
+ enum ArchiveFieldKind field_treat,
+ const void* ptr);
+
+ void register_delay_reference(
+ void** ptr,
+ bool is_class,
+ const char* class_name,
+ int referencing);
+
+ void reconf_last_delayed_rcobject(
+ void** last_obj,
+ void** new_last_obj,
+ bool to_add_ref);
+
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)
+ void set_serialize_base_class(bool s)
{
if(s)
serialize_base_class++;
else
serialize_base_class--;
+
assert(serialize_base_class >= 0);
assert(serialize_base_class <= 1);
}
- bool is_serialize_base_class()
+
+ bool is_serialize_base_class()
{
return serialize_base_class > 0;
}
- bool is_serializing_out()//true out, false in
+
+ bool is_serializing_out()
{
- return serializing_out;
+ return theSerializingOut;
}
-// ClassSerializer* get_serializer()
-// {
-// return ser;
-// }
- void *get_reference_value(int refid);
+
+ void* get_reference_value(int refid);
+
void finalize_input_serialization();
void set_read_optional_field(bool activate_optional)
{
this->read_optional = activate_optional;
}
+
bool get_read_optional_field() { return this->read_optional; }
+
void set_is_temp_field(bool is_temp)
{
- if(is_temp)
- this->is_temp_field++;
+ if (is_temp)
+ theIsTempField++;
else
- this->is_temp_field--;
- assert(is_temp_field >= 0);
+ theIsTempField--;
+
+ assert(theIsTempField >= 0);
}
- bool get_is_temp_field() { return (this->is_temp_field > 0); }
+
+ bool get_is_temp_field() { return (theIsTempField > 0); }
+
void set_is_temp_field_one_level(bool is_temp, bool also_for_ptr = false)
{
- if(is_temp)
- limit_temp_level_stack.push(std::pair<int, bool>(current_level + 1, also_for_ptr));
+ if (is_temp)
+ limit_temp_level_stack.push(std::pair<int, bool>(theCurrentLevel + 1,
+ also_for_ptr));
else
limit_temp_level_stack.pop();
}
+
bool get_is_temp_field_one_level()
{
- //if(get_is_temp_field()) return true;
- if(limit_temp_level_stack.empty())
+ if (limit_temp_level_stack.empty())
+ {
return false;
- else if(limit_temp_level_stack.top().first == current_level)
+ }
+ else if (limit_temp_level_stack.top().first == theCurrentLevel)
+ {
return true;
+ }
else
{
- unsigned int lastlevel = limit_temp_level_stack.top().first;
- archive_field *temp_field = current_compound_field;
- while(temp_field && (temp_field->level >= lastlevel))
+ unsigned int lastlevel = limit_temp_level_stack.top().first;
+ archive_field* temp_field = current_compound_field;
+
+ while (temp_field && (temp_field->theLevel >= lastlevel))
{
- if((temp_field->field_treat == ARCHIVE_FIELD_IS_PTR) ||
- (temp_field->field_treat == ARCHIVE_FIELD_IS_REFERENCING))
+ if (temp_field->theKind == ARCHIVE_FIELD_IS_PTR ||
+ temp_field->theKind == ARCHIVE_FIELD_IS_REFERENCING)
return false;
- temp_field = temp_field->parent;
+
+ temp_field = temp_field->theParent;
}
- if(temp_field)
+
+ if (temp_field)
return true;
else
return false;
}
}
- bool get_is_temp_field_also_for_ptr() {return (limit_temp_level_stack.top().first == current_level) && limit_temp_level_stack.top().second;}
+
+ bool get_is_temp_field_also_for_ptr()
+ {
+ return (limit_temp_level_stack.top().first == theCurrentLevel &&
+ limit_temp_level_stack.top().second);
+ }
int get_nr_ids();
- bool is_serialize_everything() {return this->serialize_everything;}
- void set_serialize_everything() {this->serialize_everything = true;}
-
- int get_serialize_only_for_eval() {return only_for_eval;}
+ bool is_serialize_everything() { return theSerializeEverything; }
+
+ void set_serialize_everything() { theSerializeEverything = true; }
+
+ int get_serialize_only_for_eval() { return theOnlyForEval; }
+
void set_serialize_only_for_eval(bool evalonly)
{
- if(evalonly)
- only_for_eval++;
+ if (evalonly)
+ theOnlyForEval++;
else
- only_for_eval--;
- assert(only_for_eval >= 0);
+ theOnlyForEval--;
+
+ assert(theOnlyForEval >= 0);
}
+
void set_loading_hardcoded_objects(bool set_hardcoded)
{
this->loading_hardcoded_objects = set_hardcoded;
}
- bool is_loading_hardcoded_objects()
- {
- return loading_hardcoded_objects;
- }
+
+ bool is_loading_hardcoded_objects() { return loading_hardcoded_objects; }
+
void dont_allow_delay(ENUM_ALLOW_DELAY d = DONT_ALLOW_DELAY)
{
- this->allow_delay2 = d;
- }
- void reset_allow_delay()
- {
- this->allow_delay2 = ALLOW_DELAY;
- }
- ENUM_ALLOW_DELAY get_allow_delay() {return this->allow_delay2;}
+ theAllowDelay2 = d;
+ }
+
+ void reset_allow_delay() { theAllowDelay2 = ALLOW_DELAY; }
+
+ ENUM_ALLOW_DELAY get_allow_delay() { return theAllowDelay2; }
};
=== modified file 'src/zorbaserialization/bin_archiver.cpp'
--- src/zorbaserialization/bin_archiver.cpp 2011-06-14 17:26:33 +0000
+++ src/zorbaserialization/bin_archiver.cpp 2012-02-26 21:58:26 +0000
@@ -19,13 +19,16 @@
#include "diagnostics/xquery_diagnostics.h"
#include <fstream>
-namespace zorba{
- namespace serialization{
+namespace zorba
+{
+
+namespace serialization
+{
#define ZORBA_BIN_SERIALIZED_PLAN_STRING "ZORBA-XQUERY BINARY SERIALIZED PLAN"
#define BUFFER_SEGMENT_SIZE 2*1024*1024
-BinArchiver::BinArchiver(std::istream *is) : Archiver(false)
+BinArchiver::BinArchiver(std::istream* is) : Archiver(false)
{
//open archiver for input
this->is = is;
@@ -68,9 +71,9 @@
}
in_current = in_buffer;
- read_string(archive_name);
- read_string(archive_info);
- archive_version = read_int();
+ read_string(theArchiveName);
+ read_string(theArchiveInfo);
+ theArchiveVersion = read_int();
nr_ids = read_int();
unsigned int is_release = read_int();
#ifndef NDEBUG
@@ -88,10 +91,12 @@
read_string_pool();
root_tag_is_read();
-
}
-BinArchiver::BinArchiver(std::ostream *os) : Archiver(true)
+
+BinArchiver::BinArchiver(std::ostream* os)
+ :
+ Archiver(true)
{
//open archiver for output
this->is = NULL;
@@ -103,12 +108,14 @@
in_buffer = NULL;
}
+
BinArchiver::~BinArchiver()
{
if(in_buffer)
free(in_buffer);
}
+
#ifdef ZORBA_PLAN_SERIALIZER_STATISTICS
void add_indentation(std::ostream &os, unsigned int indent)
{
@@ -118,7 +125,8 @@
}
}
-void write_xml_name(std::ostream &os, const char *type)
+
+void write_xml_name(std::ostream& os, const char* type)
{
if(!type || !*type)
{
@@ -135,29 +143,33 @@
}
}
-void output_statistics_archive_field(std::ostream &os, unsigned int indent, archive_field *parent)
+
+void output_statistics_archive_field(
+ std::ostream& os,
+ unsigned int indent,
+ archive_field* parent)
{
add_indentation(os, indent);
os << "<";
- write_xml_name(os, parent->type);
+ write_xml_name(os, parent->theTypeName);
os << " n=\"" << parent->objects_saved << "\"";
- os << " s=\"" << parent->bytes_saved << "\"";
- if(parent->field_treat == ARCHIVE_FIELD_IS_REFERENCING)
+ os << " s=\"" << parent->thebytesSaved << "\"";
+ if(parent->theKind == ARCHIVE_FIELD_IS_REFERENCING)
os << " t=\"ref\"";
- else if(parent->field_treat == ARCHIVE_FIELD_IS_PTR)
+ else if(parent->theKind == ARCHIVE_FIELD_IS_PTR)
os << " t=\"ptr\"";
- if((!parent->is_simple) && (parent->field_treat != ARCHIVE_FIELD_IS_REFERENCING))
+ if((!parent->theIsSimple) && (parent->theKind != ARCHIVE_FIELD_IS_REFERENCING))
{
os << ">" << std::endl;
archive_field *current_field = parent->first_child;
while(current_field)
{
output_statistics_archive_field(os, indent+2, current_field);
- current_field = current_field->next;
+ current_field = current_field->theNextSibling;
}
add_indentation(os, indent);
os << "</";
- write_xml_name(os, parent->type);
+ write_xml_name(os, parent->theTypeName);
os << ">" << std::endl;
}
else
@@ -167,9 +179,10 @@
}
#endif
+
void BinArchiver::serialize_out()
{
- if(!os)
+ if (!os)
{
throw ZORBA_EXCEPTION(zerr::ZCSE0007_INPUT_ARCHIVE_USED_FOR_OUT_SERIALIZATION);
}
@@ -185,9 +198,9 @@
os->write(ZORBA_BIN_SERIALIZED_PLAN_STRING, sizeof(ZORBA_BIN_SERIALIZED_PLAN_STRING));
- os->write(archive_name.c_str(), (std::streamsize)archive_name.length()+1);
- os->write(archive_info.c_str(), (std::streamsize)archive_info.length()+1);
- write_int(archive_version);
+ os->write(theArchiveName.c_str(), (std::streamsize)theArchiveName.length()+1);
+ os->write(theArchiveInfo.c_str(), (std::streamsize)theArchiveInfo.length()+1);
+ write_int(theArchiveVersion);
write_int(nr_ids);
#ifndef NDEBUG
write_int(0);//for debug
@@ -196,13 +209,13 @@
#endif
//first gather all strings in a string pool
- collect_strings(out_fields);
+ collect_strings(theRootField);
//now serialize the string pool
serialize_out_string_pool();
//now serialize the fields
- serialize_compound_fields(out_fields);
- if(bitfill)
+ serialize_compound_fields(theRootField);
+ if (bitfill)
{
current_byte <<= (8-bitfill);
os->write((char*)¤t_byte, 1);
@@ -210,6 +223,7 @@
bytes_saved++;
#endif
}
+
#ifdef ZORBA_PLAN_SERIALIZER_STATISTICS
std::ofstream plan_xml("plan.xml");
plan_xml << "<plan objects_saved=\"" << objects_saved << "\""
@@ -229,6 +243,7 @@
#endif
}
+
int BinArchiver::add_to_string_pool(const char *str)
{
if(!str)
@@ -252,42 +267,46 @@
return str_pos;
}
-void BinArchiver::collect_strings(archive_field *parent_field)
+
+void BinArchiver::collect_strings(archive_field* parent_field)
{
- archive_field *current_field = parent_field->first_child;
- while(current_field)
+ archive_field* current_field = parent_field->theFirstChild;
+ while (current_field)
{
- if(current_field->field_treat != ARCHIVE_FIELD_IS_NULL)
+ if(current_field->theKind != ARCHIVE_FIELD_IS_NULL)
{
#ifdef NDEBUG
- if(current_field->is_class && (current_field->field_treat == ARCHIVE_FIELD_IS_PTR))
+ if(current_field->theIsClass && (current_field->theKind == ARCHIVE_FIELD_IS_PTR))
#endif
- current_field->type_str_pos_in_pool = add_to_string_pool(current_field->type);
- if(current_field->field_treat != ARCHIVE_FIELD_IS_REFERENCING)
+ current_field->theTypeNamePosInPool = add_to_string_pool(current_field->theTypeName);
+ if(current_field->theKind != ARCHIVE_FIELD_IS_REFERENCING)
{
- current_field->value_str_pos_in_pool = add_to_string_pool(current_field->value);
+ current_field->theValuePosInPool = add_to_string_pool(current_field->theValue);
}
}
- if(!current_field->is_simple)
+
+ if(!current_field->theIsSimple)
{
- if(current_field->field_treat != ARCHIVE_FIELD_IS_REFERENCING)
+ if(current_field->theKind != ARCHIVE_FIELD_IS_REFERENCING)
{
collect_strings(current_field);
}
}
- current_field = current_field->next;
+
+ current_field = current_field->theNextSibling;
}
}
-void BinArchiver::serialize_out_string_pool()
+
+void BinArchiver::serialize_out_string_pool()
{
//sort strings based on use count
unsigned int i,j;
- for(i=0;i<strings_pos.size();i++)
+ for (i = 0; i < strings_pos.size(); i++)
{
- for(j=i+1;j<strings_pos.size();j++)
+ for (j = i+1; j < strings_pos.size(); j++)
{
- if(strings.at(strings_pos[i]).count < strings.at(strings_pos[j]).count)
+ if (strings.at(strings_pos[i]).count < strings.at(strings_pos[j]).count)
{
unsigned int temp;
temp = strings_pos[i];
@@ -317,27 +336,29 @@
}
}
+
void BinArchiver::serialize_compound_fields(archive_field *parent_field)
{
#ifdef ZORBA_PLAN_SERIALIZER_STATISTICS
unsigned int bytes_saved1 = bytes_saved;
unsigned int objects_saved1 = objects_saved;
#endif
- archive_field *current_field = parent_field->first_child;
+ archive_field* current_field = parent_field->theFirstChild;
+
while(current_field)
{
#ifndef NDEBUG
unsigned char tempbyte;
tempbyte = 0;
- tempbyte |= current_field->is_simple ? 1 : 0;
- tempbyte |= current_field->is_class ? 1<<1 : 0;
- tempbyte |= (current_field->field_treat&0x0F)<<4;
+ tempbyte |= current_field->theIsSimple ? 1 : 0;
+ tempbyte |= current_field->theIsClass ? 1<<1 : 0;
+ tempbyte |= (current_field->theKind&0x0F)<<4;
write_bits(tempbyte, 8);
#else
- //write_bit(current_field->is_class ? 1 : 0);
- //write_bits(current_field->field_treat, 3);
+ //write_bit(current_field->theIsClass ? 1 : 0);
+ //write_bits(current_field->theKind, 3);
unsigned char small_treat = 0;
- switch(current_field->field_treat)
+ switch(current_field->theKind)
{
case ARCHIVE_FIELD_IS_NULL: small_treat = 1;break;
case ARCHIVE_FIELD_IS_REFERENCING: small_treat = 2;break;
@@ -345,41 +366,41 @@
}
write_bits(small_treat, 2);
#endif
- if(current_field->field_treat != ARCHIVE_FIELD_IS_NULL)
+ if(current_field->theKind != ARCHIVE_FIELD_IS_NULL)
{
#ifdef NDEBUG
- if(current_field->is_class && (current_field->field_treat == ARCHIVE_FIELD_IS_PTR))
+ if(current_field->theIsClass && (current_field->theKind == ARCHIVE_FIELD_IS_PTR))
#endif
{
- if(!current_field->type)
+ if(!current_field->theTypeName)
write_int_exp2(0);
else
- write_int_exp2(strings.at(current_field->type_str_pos_in_pool-1).final_pos);
+ write_int_exp2(strings.at(current_field->theTypeNamePosInPool-1).final_pos);
}
- write_int_exp(current_field->id - this->last_id);
- last_id = current_field->id;
- if(current_field->field_treat != ARCHIVE_FIELD_IS_REFERENCING)
+ write_int_exp(current_field->theId - this->last_id);
+ last_id = current_field->theId;
+ if(current_field->theKind != ARCHIVE_FIELD_IS_REFERENCING)
{
#ifndef NDEBUG
- write_int(current_field->version);
+ write_int(current_field->theClassVersion);
#endif
- if(!current_field->value_str_pos_in_pool)
- write_int_exp2(current_field->value_str_pos_in_pool);
+ if(!current_field->theValuePosInPool)
+ write_int_exp2(current_field->theValuePosInPool);
else
- write_int_exp2(strings.at(current_field->value_str_pos_in_pool-1).final_pos);
+ write_int_exp2(strings.at(current_field->theValuePosInPool-1).final_pos);
}
else
write_int(current_field->referencing);
}
#ifdef ZORBA_PLAN_SERIALIZER_STATISTICS
objects_saved++;
- if(current_field->field_treat == ARCHIVE_FIELD_IS_PTR)
+ if(current_field->theKind == ARCHIVE_FIELD_IS_PTR)
nr_ptrs++;
#endif
- if(!current_field->is_simple)
+ if(!current_field->theIsSimple)
{
- if(current_field->field_treat != ARCHIVE_FIELD_IS_REFERENCING)
+ if(current_field->theKind != ARCHIVE_FIELD_IS_REFERENCING)
{
serialize_compound_fields(current_field);
#ifndef NDEBUG
@@ -389,16 +410,17 @@
#endif
}
}
- current_field = current_field->next;
+ current_field = current_field->theNextSibling;
}
#ifdef ZORBA_PLAN_SERIALIZER_STATISTICS
//gather statistics for this node
- parent_field->bytes_saved = bytes_saved - bytes_saved1;
- parent_field->objects_saved = objects_saved - objects_saved1;
+ parent_field->thebytesSaved = bytes_saved - bytes_saved1;
+ parent_field->theObjectsSaved = objects_saved - objects_saved1;
#endif
}
+
void BinArchiver::write_string(const char *str)
{
os->write(str, (std::streamsize)strlen(str)+1);
@@ -407,6 +429,7 @@
#endif
}
+
void BinArchiver::write_bit(unsigned char bit)
{
current_byte <<= 1;
@@ -423,6 +446,7 @@
}
}
+
void BinArchiver::write_bits(unsigned int value, unsigned int bits)
{
while(bits)
@@ -432,6 +456,7 @@
}
}
+
void BinArchiver::write_int(unsigned int intval)
{
//write 7 bits per byte, only significant bits
@@ -448,9 +473,9 @@
tmp = (intval & 0x7F) | 0x80;
//os->write((char*)&tmp, 1);
write_bits(tmp, 8);
-
}
+
void BinArchiver::write_int_exp(unsigned int intval)
{
if(intval == 1)
@@ -479,6 +504,7 @@
}
}
+
void BinArchiver::write_int_exp2(unsigned int intval)
{
if(intval < (1<<4))
@@ -533,6 +559,7 @@
in_current++;
}
+
void BinArchiver::read_string(char* str)
{
//char c;
@@ -560,6 +587,7 @@
in_current++;
}
+
unsigned char BinArchiver::read_bit()
{
if(bitfill == 0)
@@ -574,6 +602,7 @@
return result;
}
+
unsigned int BinArchiver::read_bits(unsigned int bits)
{
unsigned int result = 0;
@@ -607,6 +636,7 @@
return result;
}
+
unsigned int BinArchiver::read_int()
{
unsigned int outval = 0;
@@ -623,6 +653,7 @@
return outval;
}
+
unsigned int BinArchiver::read_int_exp()
{
unsigned char bit;
@@ -641,6 +672,7 @@
return read_bits(32);
}
+
unsigned int BinArchiver::read_int_exp2()
{
unsigned char bit;
@@ -660,6 +692,7 @@
}
+
void BinArchiver::read_string_pool()
{
strings.clear();
@@ -681,13 +714,14 @@
bitfill = 8;
}
+
bool BinArchiver::read_next_field_impl( char **type,
std::string *value,
int *id,
int *version,
bool *is_simple,
bool *is_class,
- enum ArchiveFieldTreat *field_treat,
+ enum ArchiveFieldKind *field_treat,
int *referencing)
{
if(!is)
@@ -701,7 +735,7 @@
#ifndef NDEBUG
*is_simple = false;
*is_class = false;
- *field_treat = (enum ArchiveFieldTreat)-1;
+ *field_treat = (enum ArchiveFieldKind)-1;
#endif
*referencing = -1;
@@ -713,10 +747,10 @@
return false;
*is_simple = tempbyte & 0x01 ? true : false;
*is_class = tempbyte & 0x02 ? true : false;
- *field_treat = (enum ArchiveFieldTreat)((tempbyte>>4)&0x0F);
+ *field_treat = (enum ArchiveFieldKind)((tempbyte>>4)&0x0F);
#else
//*is_class = read_bit();
- //*field_treat = (enum ArchiveFieldTreat)read_bits(3);
+ //*field_treat = (enum ArchiveFieldKind)read_bits(3);
unsigned char small_treat = read_bits(2);
switch(small_treat)
{
@@ -760,8 +794,6 @@
}
-
-
void BinArchiver::read_end_current_level_impl()
{
#ifndef NDEBUG
=== modified file 'src/zorbaserialization/bin_archiver.h'
--- src/zorbaserialization/bin_archiver.h 2011-06-14 17:26:33 +0000
+++ src/zorbaserialization/bin_archiver.h 2012-02-26 21:58:26 +0000
@@ -29,83 +29,98 @@
class BinArchiver : public Archiver
{
- std::istream *is;
- std::ostream *os;
-
-// int read_tag_level;
-// char field_type[1000];
- bool has_attributes;
- bool is_compound_field_without_children;
-
- HashCharPtrObj<int> string_pool;
+ std::istream * is;
+
+ std::ostream * os;
+
+ bool has_attributes;
+ bool is_compound_field_without_children;
+
+ HashCharPtrObj<int> string_pool;
+
typedef struct
{
std::string str;
unsigned int count;
unsigned int final_pos;//1 based
- }STRING_POS;
+ } STRING_POS;
+
std::vector<STRING_POS> strings;
std::vector<unsigned int> strings_pos;
- unsigned int last_id;
- unsigned char current_byte;
- unsigned char bitfill;
+ unsigned int last_id;
+ unsigned char current_byte;
+ unsigned char bitfill;
- unsigned char *in_buffer;
- unsigned char *in_current;
- size_t size_read;
+ unsigned char * in_buffer;
+ unsigned char * in_current;
+ size_t size_read;
#ifdef ZORBA_PLAN_SERIALIZER_STATISTICS
- unsigned int bytes_saved;
- unsigned int objects_saved;
- unsigned int nr_ptrs;
- unsigned int strings_saved;
+ unsigned int bytes_saved;
+ unsigned int objects_saved;
+ unsigned int nr_ptrs;
+ unsigned int strings_saved;
#endif
public:
- BinArchiver(std::istream *is);
- BinArchiver(std::ostream *os);
+ BinArchiver(std::istream* is);
+
+ BinArchiver(std::ostream* os);
+
virtual ~BinArchiver();
- virtual bool read_next_field_impl( char **type,
- std::string *value,
- int *id,
- int *version,
- bool *is_simple,
- bool *is_class,
- enum ArchiveFieldTreat *field_treat,
- int *referencing);
+ 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 void read_end_current_level_impl();
-
-///////////////////////////////////
virtual void serialize_out();
-
protected:
//writing
- int add_to_string_pool(const char *str);
- void collect_strings(archive_field *parent_field);
+ int add_to_string_pool(const char* str);
+
+ void collect_strings(archive_field* parent_field);
+
void serialize_out_string_pool();
- void serialize_compound_fields(archive_field *parent_field);
- //void encode_string(const char *value);
- //const char *get_field_treat_string(enum ArchiveFieldTreat field_treat);
- void write_string(const char *str);
+
+ void serialize_compound_fields(archive_field* parent_field);
+
+ void write_string(const char* str);
+
void write_bit(unsigned char bit);
+
void write_bits(unsigned int value, unsigned int bits);
+
void write_int(unsigned int intval);
+
void write_int_exp(unsigned int intval);
+
void write_int_exp2(unsigned int intval);
//reading
- void read_string(std::string &str);
+ void read_string(std::string& str);
+
void read_string(char* str);
+
unsigned char read_bit();
- unsigned int read_bits(unsigned int bits);
- unsigned int read_int();
- unsigned int read_int_exp();
- unsigned int read_int_exp2();
+
+ unsigned int read_bits(unsigned int bits);
+
+ unsigned int read_int();
+
+ unsigned int read_int_exp();
+
+ unsigned int read_int_exp2();
+
void read_string_pool();
};
=== modified file 'src/zorbaserialization/class_serializer.cpp'
--- src/zorbaserialization/class_serializer.cpp 2011-10-03 09:18:49 +0000
+++ src/zorbaserialization/class_serializer.cpp 2012-02-26 21:58:26 +0000
@@ -189,7 +189,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -220,7 +220,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -250,7 +250,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -280,7 +280,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -310,7 +310,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -340,7 +340,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -370,7 +370,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -400,7 +400,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -430,7 +430,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -462,7 +462,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -494,7 +494,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -532,7 +532,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -569,7 +569,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -598,7 +598,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -638,7 +638,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -667,7 +667,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -698,13 +698,13 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_IS_PTR;
+ enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_IS_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())
return;
- ar.check_simple_field(retval, type, "std::string*", is_simple, field_treat, (ArchiveFieldTreat)-1, id);
+ ar.check_simple_field(retval, type, "std::string*", is_simple, field_treat, (ArchiveFieldKind)-1, id);
if(field_treat == ARCHIVE_FIELD_IS_NULL)
{
obj = NULL;
@@ -741,13 +741,13 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_IS_PTR;
+ enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_IS_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())
return;
- ar.check_simple_field(retval, type, "char*", is_simple, field_treat, (ArchiveFieldTreat)-1, id);
+ ar.check_simple_field(retval, type, "char*", is_simple, field_treat, (ArchiveFieldKind)-1, id);
if(field_treat == ARCHIVE_FIELD_IS_NULL)
{
obj = NULL;
@@ -787,7 +787,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
=== modified file 'src/zorbaserialization/mem_archiver.cpp'
--- src/zorbaserialization/mem_archiver.cpp 2011-06-14 17:26:33 +0000
+++ src/zorbaserialization/mem_archiver.cpp 2012-02-26 21:58:26 +0000
@@ -17,60 +17,68 @@
#include "zorbaserialization/mem_archiver.h"
-namespace zorba{
- namespace serialization{
+namespace zorba
+{
+
+namespace serialization
+{
void MemArchiver::reset_serialize_in()
{
- serializing_out = false;
- current_level = 0;
+ theSerializingOut = false;
+ theCurrentLevel = 0;
- current_field = out_fields->first_child;
+ current_field = theRootField->theFirstChild;
root_tag_is_read();
}
-bool MemArchiver::read_next_field_impl( char **type,
- std::string *value,
- int *id,
- int *version,
- bool *is_simple,
- bool *is_class,
- enum ArchiveFieldTreat *field_treat,
- int *referencing)
+
+bool MemArchiver::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)
{
- if((current_field == NULL) || is_after_last)
+ if (current_field == NULL || is_after_last)
return false;
- *type = current_field->type;
- *value = current_field->value;
- *id = current_field->id;
- *version = current_field->version;
- *is_simple = current_field->is_simple;
- *is_class = current_field->is_class;
- *field_treat = current_field->field_treat;
+
+ *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->first_child)
- current_field = current_field->first_child;
+ if(current_field->theFirstChild)
+ current_field = current_field->theFirstChild;
else if(!*is_simple && ((*field_treat == ARCHIVE_FIELD_IS_BASECLASS) || (*field_treat == ARCHIVE_FIELD_IS_PTR)))
{
//class without childs
- temp_field.parent = current_field;
+ temp_field.theParent = current_field;
current_field = &temp_field;//prepare for read_end_current_level()
}
- else if(current_field->next)
- current_field = current_field->next;
+ else if(current_field->theNextSibling)
+ current_field = current_field->theNextSibling;
else
is_after_last = true;
return true;
}
+
void MemArchiver::read_end_current_level_impl()
{
is_after_last = false;
- current_field = current_field->parent;
- if(current_field->next)
- current_field = current_field->next;
+ current_field = current_field->theParent;
+
+ if(current_field->theNextSibling)
+ current_field = current_field->theNextSibling;
else
is_after_last = true;
}
=== modified file 'src/zorbaserialization/mem_archiver.h'
--- src/zorbaserialization/mem_archiver.h 2011-06-14 17:26:33 +0000
+++ src/zorbaserialization/mem_archiver.h 2012-02-26 21:58:26 +0000
@@ -41,7 +41,7 @@
int *version,
bool *is_simple,
bool *is_class,
- enum ArchiveFieldTreat *field_treat,
+ enum ArchiveFieldKind *field_treat,
int *referencing);
virtual void read_end_current_level_impl();
=== modified file 'src/zorbaserialization/template_serializer.h'
--- src/zorbaserialization/template_serializer.h 2011-08-27 14:57:52 +0000
+++ src/zorbaserialization/template_serializer.h 2012-02-26 21:58:26 +0000
@@ -74,7 +74,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -143,7 +143,7 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -196,7 +196,7 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -260,13 +260,13 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_IS_PTR;
+ enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_IS_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())
return;
- ar.check_nonclass_field(retval, type, "std::vector<T>*", is_simple, is_class, field_treat, (ArchiveFieldTreat)-1, id);
+ ar.check_nonclass_field(retval, type, "std::vector<T>*", is_simple, is_class, field_treat, (ArchiveFieldKind)-1, id);
if(field_treat == ARCHIVE_FIELD_IS_NULL)
{
obj = NULL;
@@ -349,7 +349,7 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -393,7 +393,7 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -442,13 +442,13 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_IS_PTR;
+ enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_IS_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())
return;
- ar.check_nonclass_field(retval, type, "std::pair<T1, T2>", is_simple, is_class, field_treat, (ArchiveFieldTreat)-1, id);
+ ar.check_nonclass_field(retval, type, "std::pair<T1, T2>", is_simple, is_class, field_treat, (ArchiveFieldKind)-1, id);
if(field_treat == ARCHIVE_FIELD_IS_NULL)
{
obj = NULL;
@@ -533,13 +533,13 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_IS_PTR;
+ enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_IS_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())
return;
- ar.check_nonclass_field(retval, type, "std::map<T1, T2>", is_simple, is_class, field_treat, (ArchiveFieldTreat)-1, id);
+ ar.check_nonclass_field(retval, type, "std::map<T1, T2>", is_simple, is_class, field_treat, (ArchiveFieldKind)-1, id);
if(field_treat == ARCHIVE_FIELD_IS_NULL)
{
obj = NULL;
@@ -634,7 +634,7 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -688,7 +688,7 @@
int version;
bool is_simple = false;
bool is_class = true;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -795,13 +795,13 @@
int version;
bool is_simple = false;
bool is_class = true;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_IS_PTR;
+ enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_IS_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())
return;
- ar.check_class_field(retval, "", "", is_simple, is_class, field_treat, (ArchiveFieldTreat)-1, id);
+ ar.check_class_field(retval, "", "", is_simple, is_class, field_treat, (ArchiveFieldKind)-1, id);
if(field_treat == ARCHIVE_FIELD_IS_NULL)
{
assert(!ar.is_serialize_base_class());
=== modified file 'src/zorbaserialization/xml_archiver.cpp'
--- src/zorbaserialization/xml_archiver.cpp 2011-06-14 17:26:33 +0000
+++ src/zorbaserialization/xml_archiver.cpp 2012-02-26 21:58:26 +0000
@@ -18,10 +18,16 @@
#include "zorbaserialization/xml_archiver.h"
#include "diagnostics/xquery_diagnostics.h"
-namespace zorba{
- namespace serialization{
-
-XmlArchiver::XmlArchiver(std::istream *is) : Archiver(false)
+namespace zorba
+{
+
+namespace serialization
+{
+
+
+XmlArchiver::XmlArchiver(std::istream* is)
+ :
+ Archiver(false)
{
//open archiver for input
this->is = is;
@@ -60,6 +66,7 @@
read_tag_level++;
}
+
XmlArchiver::XmlArchiver(std::ostream *os) : Archiver(true)
{
//open archiver for output
@@ -71,6 +78,7 @@
indent_off = sizeof(indent_spaces)-1;
}
+
void XmlArchiver::serialize_out()
{
if(!os)
@@ -82,56 +90,56 @@
write_string("<?xml version=\"1.0\"?>\n");
write_string("<zorba_archive archive_name=\"");
- encode_string(archive_name.c_str());
+ encode_string(theArchiveName.c_str());
write_string("\" ");
write_string("archive_info=\"");
- encode_string(archive_info.c_str());
+ encode_string(theArchiveInfo.c_str());
write_string("\" ");
- *os << "archive_version=\"" << archive_version << "\" ";
+ *os << "archive_version=\"" << theArchiveVersion << "\" ";
*os << "nr_ids=\"" << nr_ids << "\" >" << std::endl;
- serialize_compound_fields(out_fields);
+ serialize_compound_fields(theRootField);
write_string("</zorba_archive>\n");
-
}
+
void XmlArchiver::serialize_compound_fields(archive_field *parent_field)
{
- archive_field *current_field = parent_field->first_child;
+ archive_field *current_field = parent_field->theFirstChild;
char strtemp[100];
while(current_field)
{
write_string(indent_off >= 0 ? indent_spaces+indent_off : indent_spaces);
write_string("<obj_field is_simple=\"");
- write_string(current_field->is_simple ? "true" : "false");
+ write_string(current_field->theIsSimple ? "true" : "false");
write_string("\" ");
write_string("type=\"");
- write_string(current_field->type);
+ write_string(current_field->theTypeName);
write_string("\" ");
write_string("version=\"");
- sprintf(strtemp, "%d", current_field->version);
+ sprintf(strtemp, "%d", current_field->theClassVersion);
write_string(strtemp);
write_string("\" ");
write_string("field_treat=\"");
- write_string(get_field_treat_string(current_field->field_treat));
+ write_string(get_field_treat_string(current_field->theKind));
write_string("\" ");
write_string("referencing=\"");
sprintf(strtemp, "%d", current_field->referencing);
write_string(strtemp);
write_string("\" ");
write_string("id=\"");
- sprintf(strtemp, "%d", current_field->id);
+ sprintf(strtemp, "%d", current_field->theId);
write_string(strtemp);
write_string("\" ");
write_string("is_class=\"");
- write_string(current_field->is_class ? "true" : "false");
+ write_string(current_field->theIsClass ? "true" : "false");
write_string("\" ");
write_string("value=\"");
- encode_string(current_field->value);
+ encode_string(current_field->theValue);
write_string("\" ");
- if(current_field->is_simple ||
- (current_field->field_treat == ARCHIVE_FIELD_IS_REFERENCING) ||
- (current_field->first_child == NULL))
+ if(current_field->theIsSimple ||
+ (current_field->theKind == ARCHIVE_FIELD_IS_REFERENCING) ||
+ (current_field->theFirstChild == NULL))
{
write_string("/>\n");
}
@@ -144,10 +152,11 @@
write_string(indent_off >= 0 ? indent_spaces+indent_off : indent_spaces);
write_string("</obj_field>\n");
}
- current_field = current_field->next;
+ current_field = current_field->theNextSibling;
}
}
+
void XmlArchiver::encode_string(const char *value)
{
if(!value)
@@ -164,12 +173,14 @@
}
}
+
void XmlArchiver::write_string(const char *str)
{
os->write(str, (std::streamsize)strlen(str));
}
-const char *XmlArchiver::get_field_treat_string(enum ArchiveFieldTreat field_treat)
+
+const char *XmlArchiver::get_field_treat_string(enum ArchiveFieldKind field_treat)
{
switch(field_treat)
{
@@ -185,14 +196,15 @@
////////////reading archive
-bool XmlArchiver::read_next_field_impl( char **type,
- std::string *value,
- int *id,
- int *version,
- bool *is_simple,
- bool *is_class,
- enum ArchiveFieldTreat *field_treat,
- int *referencing)
+bool XmlArchiver::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)
{
if(!is)
{
@@ -204,7 +216,7 @@
*version = -1;
*is_simple = false;
*is_class = false,
- *field_treat = (enum ArchiveFieldTreat)-1;
+ *field_treat = (enum ArchiveFieldKind)-1;
*referencing = -1;
if(is_compound_field_without_children)
@@ -253,14 +265,14 @@
while(read_attrib_name(attrib_name))
{
-// write_string("<obj_field is_simple=\"" << (current_field->is_simple ? "true" : "false") << "\" "
-// <<"type=\"" << current_field->type << "\" "
+// write_string("<obj_field is_simple=\"" << (current_field->theIsSimple ? "true" : "false") << "\" "
+// <<"type=\"" << current_field->theTypeName << "\" "
// <<"version=\"" << current_field->version << "\" "
-// <<"field_treat=\"" << get_field_treat_string(current_field->field_treat) << "\" "
+// <<"field_treat=\"" << get_field_treat_string(current_field->theKind) << "\" "
// <<"referencing=\"" << current_field->referencing << "\" "
// <<"id=\"" << current_field->id << "\" "
-// <<"is_class=\"" << current_field->is_class << "\" "
-// <<"value=\"" ;//<< current_field->value ? current_field->value : "" << "\" ";
+// <<"is_class=\"" << current_field->theIsClass << "\" "
+// <<"value=\"" ;//<< current_field->theValue ? current_field->theValue : "" << "\" ";
process_attr:
switch(attr_index)
{
@@ -378,7 +390,6 @@
}
-
bool XmlArchiver::read_root_tag(char c)
{
if(!match_string(c, "zorba_archive"))
@@ -400,16 +411,16 @@
{
if(!strcmp(attrib_name, "archive_name"))
{
- read_attrib_value(&archive_name);
+ read_attrib_value(&theArchiveName);
}
else if(!strcmp(attrib_name, "archive_info"))
{
- read_attrib_value(&archive_info);
+ read_attrib_value(&theArchiveInfo);
}
else if(!strcmp(attrib_name, "archive_version"))
{
read_attrib_value(attrib_value);
- archive_version = atoi(attrib_value);
+ theArchiveVersion = atoi(attrib_value);
}
else if(!strcmp(attrib_name, "nr_ids"))
{
@@ -421,6 +432,7 @@
return true;
}
+
void XmlArchiver::read_end_current_level_impl()
{
if(is_compound_field_without_children)
@@ -470,6 +482,7 @@
return;
}
+
bool XmlArchiver::match_string(char c, const char *match)
{
if(match[0] != c)
@@ -490,6 +503,7 @@
return true;
}
+
bool XmlArchiver::read_attrib_name(char *attrib_name)
{
char c;
@@ -540,6 +554,7 @@
return true;
}
+
void XmlArchiver::read_attrib_value(char *attrib_value)
{
char c = 0;
@@ -651,6 +666,7 @@
*attrib_value = 0;
}
+
void XmlArchiver::read_attrib_value(std::string *attrib_value)
{
char c = 0;
@@ -755,6 +771,7 @@
}
}
+
void XmlArchiver::skip_tag()
{
std::string temp_val;
@@ -778,6 +795,7 @@
}
}
+
void XmlArchiver::skip_comment_tag()
{
char c;
=== modified file 'src/zorbaserialization/xml_archiver.h'
--- src/zorbaserialization/xml_archiver.h 2011-06-14 17:26:33 +0000
+++ src/zorbaserialization/xml_archiver.h 2012-02-26 21:58:26 +0000
@@ -45,7 +45,7 @@
int *version,
bool *is_simple,
bool *is_class,
- enum ArchiveFieldTreat *field_treat,
+ enum ArchiveFieldKind *field_treat,
int *referencing);
virtual void read_end_current_level_impl();
@@ -59,7 +59,7 @@
//writing
void serialize_compound_fields(archive_field *parent_field);
void encode_string(const char *value);
- const char *get_field_treat_string(enum ArchiveFieldTreat field_treat);
+ const char *get_field_treat_string(enum ArchiveFieldKind field_treat);
void write_string(const char *str);
//reading
=== modified file 'src/zorbaserialization/zorba_class_serializer.cpp'
--- src/zorbaserialization/zorba_class_serializer.cpp 2012-02-22 04:03:16 +0000
+++ src/zorbaserialization/zorba_class_serializer.cpp 2012-02-26 21:58:26 +0000
@@ -130,7 +130,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_IS_PTR;
+ enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_IS_PTR;
int referencing;
bool retval;
retval = ar.read_next_field(&type, &value, &id, &version, &is_simple, &is_class, &field_treat, &referencing);
@@ -191,7 +191,7 @@
int version;
bool is_simple = true;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -317,7 +317,7 @@
int is_function = 0;
int id;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_IS_PTR;
+ enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_IS_PTR;
int referencing;
if(ar.is_serializing_out())
@@ -358,7 +358,7 @@
retval = ar.read_next_field(&type, &value, &id, &version, &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 ArchiveFieldTreat)-1, id);
+ ar.check_class_field(retval, type, "store::Item*", is_simple, is_class, field_treat, (enum ArchiveFieldKind)-1, id);
if(field_treat == ARCHIVE_FIELD_IS_NULL)
{
obj = NULL;
@@ -826,7 +826,7 @@
}
ar.set_is_temp_field(false);
int id;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_IS_PTR;
+ enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_IS_PTR;
int referencing;
bool is_ref;
if(ar.is_serializing_out())
@@ -861,7 +861,7 @@
ar.set_is_temp_field(true);
return;
}
- ar.check_class_field(retval, type, "store::Item*", is_simple, is_class, field_treat, (enum ArchiveFieldTreat)-1, id);
+ ar.check_class_field(retval, type, "store::Item*", is_simple, is_class, field_treat, (enum ArchiveFieldKind)-1, id);
//ar.register_reference(id, &obj);
if((field_treat != ARCHIVE_FIELD_IS_PTR) && (field_treat != ARCHIVE_FIELD_IS_REFERENCING))
{
@@ -1072,13 +1072,13 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_IS_PTR;
+ enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_IS_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())
return;
- ar.check_nonclass_field(retval, type, "Diagnostic*", is_simple, is_class, field_treat, (ArchiveFieldTreat)-1, id);
+ ar.check_nonclass_field(retval, type, "Diagnostic*", is_simple, is_class, field_treat, (ArchiveFieldKind)-1, id);
if(field_treat == ARCHIVE_FIELD_IS_NULL)
{
assert(!ar.is_serialize_base_class());
@@ -1178,13 +1178,13 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_IS_PTR;
+ enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_IS_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())
return;
- ar.check_nonclass_field(retval, type, "ZorbaException*", is_simple, is_class, field_treat, (ArchiveFieldTreat)-1, id);
+ ar.check_nonclass_field(retval, type, "ZorbaException*", is_simple, is_class, field_treat, (ArchiveFieldKind)-1, id);
if(field_treat == ARCHIVE_FIELD_IS_NULL)
{
assert(!ar.is_serialize_base_class());
@@ -1269,7 +1269,7 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -1310,7 +1310,7 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -1347,7 +1347,7 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -1390,7 +1390,7 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
=== modified file 'src/zorbaserialization/zorba_class_serializer.h'
--- src/zorbaserialization/zorba_class_serializer.h 2012-02-02 09:56:52 +0000
+++ src/zorbaserialization/zorba_class_serializer.h 2012-02-26 21:58:26 +0000
@@ -118,7 +118,7 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -180,7 +180,7 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -253,7 +253,7 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -328,7 +328,7 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
@@ -417,13 +417,13 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_IS_PTR;
+ enum ArchiveFieldKind field_treat = ARCHIVE_FIELD_IS_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())
return;
- ar.check_nonclass_field(retval, type, "rchandle<T>", is_simple, is_class, field_treat, (ArchiveFieldTreat)-1, id);
+ ar.check_nonclass_field(retval, type, "rchandle<T>", is_simple, is_class, field_treat, (ArchiveFieldKind)-1, id);
if(field_treat == ARCHIVE_FIELD_IS_NULL)
{
assert(!ar.is_serialize_base_class());
@@ -541,7 +541,7 @@
int version;
bool is_simple = false;
bool is_class = false;
- enum ArchiveFieldTreat field_treat = ARCHIVE_FIELD_NORMAL;
+ 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);
=== modified file 'test/rbkt/testdriver.cpp'
--- test/rbkt/testdriver.cpp 2012-02-13 21:49:40 +0000
+++ test/rbkt/testdriver.cpp 2012-02-26 21:58:26 +0000
@@ -26,7 +26,7 @@
#include <time.h>
#endif
-//#define ZORBA_TEST_PLAN_SERIALIZATION
+#define ZORBA_TEST_PLAN_SERIALIZATION
#include "testdriverconfig.h" // SRC and BIN dir definitions
#include "specification.h" // parsing spec files
Follow ups
-
[Merge] lp:~zorba-coders/zorba/serializer into lp:zorba
From: Zorba Build Bot, 2012-02-27
-
Re: [Merge] lp:~zorba-coders/zorba/serializer into lp:zorba
From: Zorba Build Bot, 2012-02-27
-
[Merge] lp:~zorba-coders/zorba/serializer into lp:zorba
From: Zorba Build Bot, 2012-02-27
-
[Merge] lp:~zorba-coders/zorba/serializer into lp:zorba
From: Zorba Build Bot, 2012-02-27
-
[Merge] lp:~zorba-coders/zorba/serializer into lp:zorba
From: Markos Zaharioudakis, 2012-02-27
-
[Merge] lp:~zorba-coders/zorba/serializer into lp:zorba
From: Zorba Build Bot, 2012-02-26
-
Re: [Merge] lp:~zorba-coders/zorba/serializer into lp:zorba
From: Zorba Build Bot, 2012-02-26
-
[Merge] lp:~zorba-coders/zorba/serializer into lp:zorba
From: Zorba Build Bot, 2012-02-26
-
[Merge] lp:~zorba-coders/zorba/serializer into lp:zorba
From: Zorba Build Bot, 2012-02-26
-
[Merge] lp:~zorba-coders/zorba/serializer into lp:zorba
From: Markos Zaharioudakis, 2012-02-26
