void Data::read(string xmlFile)
{
if(_xml.size() == 0)
{
_xml = xmlFile;
if(xmlFile[0] != '/')
{
char buf[1024];
getcwd(buf, 1024);
stringstream sst;
sst << buf << "/" << xmlFile;
_xml = sst.str();
}
}
cout << "reading xml file: " << _xml << endl;
YarsXSDSaxParser *parser = new YarsXSDSaxParser();
parser->read(xmlFile);
if(parser->errors() > 0)
{
FORF(vector<string>, i, parser, w_begin(), w_end()) cout << "WARNING: " << *i << endl;
FORF(vector<string>, i, parser, e_begin(), e_end()) cout << "ERROR: " << *i << endl;
FORF(vector<string>, i, parser, f_begin(), f_end()) cout << "FATAL: " << *i << endl;
delete parser;
exit(-1);
}
delete parser;
__writeCfg();
if(_initialisationCompleted == false)
{
if(_root->population() == NULL)
{
_root->initialiseFirstPopulationFromConfiguration();
}
_root->population()->addObserver(this);
_initialisationCompleted = true;
}
}
inline const basic_pointer_iserializer *
basic_iarchive_impl::load_pointer(
basic_iarchive &ar,
void * & t,
const basic_pointer_iserializer * bpis_ptr,
const basic_pointer_iserializer * (*finder)(
const boost::serialization::extended_type_info & type_
)
){
m_moveable_objects.is_pointer = true;
serialization::state_saver<bool> w(m_moveable_objects.is_pointer);
class_id_type cid;
load(ar, cid);
if(NULL_POINTER_TAG == cid){
t = NULL;
return bpis_ptr;
}
// if its a new class type - i.e. never been registered
if(class_id_type(cobject_info_set.size()) <= cid){
// if its either abstract
if(NULL == bpis_ptr
// or polymorphic
|| bpis_ptr->get_basic_serializer().is_polymorphic()){
// is must have been exported
char key[BOOST_SERIALIZATION_MAX_KEY_SIZE];
class_name_type class_name(key);
load(ar, class_name);
// if it has a class name
const serialization::extended_type_info *eti = NULL;
if(0 != key[0])
eti = serialization::extended_type_info::find(key);
if(NULL == eti)
boost::serialization::throw_exception(
archive_exception(archive_exception::unregistered_class)
);
bpis_ptr = (*finder)(*eti);
}
BOOST_ASSERT(NULL != bpis_ptr);
// class_id_type new_cid = register_type(bpis_ptr->get_basic_serializer());
BOOST_VERIFY(register_type(bpis_ptr->get_basic_serializer()) == cid);
int i = cid;
cobject_id_vector[i].bpis_ptr = bpis_ptr;
}
int i = cid;
cobject_id & co = cobject_id_vector[i];
bpis_ptr = co.bpis_ptr;
load_preamble(ar, co);
// extra line to evade borland issue
const bool tracking = co.tracking_level;
// if we're tracking and the pointer has already been read
if(tracking && ! track(ar, t))
// we're done
return bpis_ptr;
// save state
serialization::state_saver<object_id_type> w_start(m_moveable_objects.start);
// allocate space on the heap for the object - to be constructed later
t = bpis_ptr->heap_allocation();
BOOST_ASSERT(NULL != t);
if(! tracking){
bpis_ptr->load_object_ptr(ar, t, co.file_version);
}
else{
serialization::state_saver<void *> x(m_pending.object);
serialization::state_saver<const basic_iserializer *> y(m_pending.bis);
serialization::state_saver<version_type> z(m_pending.version);
m_pending.bis = & bpis_ptr->get_basic_serializer();
m_pending.version = co.file_version;
// predict next object id to be created
const unsigned int ui = object_id_vector.size();
serialization::state_saver<object_id_type> w_end(m_moveable_objects.end);
// add to list of serialized objects so that we can properly handle
// cyclic strucures
object_id_vector.push_back(aobject(t, cid));
// remember that that the address of these elements could change
// when we make another call so don't use the address
bpis_ptr->load_object_ptr(
ar,
t,
m_pending.version
);
object_id_vector[ui].loaded_as_pointer = true;
}
return bpis_ptr;
}
