lestes: lestes::std::dumper Class Reference

typedef list< srp<object> > lestes::std::dumper::queue_type [private]

Definition at line 58 of file dumper.hh.

typedef set< srp<object> > lestes::std::dumper::set_type [private]

Definition at line 59 of file dumper.hh.

lestes::std::dumper::dumper	(	::std::ostream &	a_stream,
		bool	a_respect_barriers
	)			`[protected]`

Definition at line 146 of file dumper.cc.

Referenced by dump().

00147         : dumper_visitor(), stream(a_stream), respect_barriers(a_respect_barriers)
00148 {}

std::ostream & lestes::std::dumper::dump	(	::std::ostream &	output_to,
		ptr< object >	start_at,
		bool	respect_barriers = `true`
	)			`[static]`

Dumps every instance reachable from start_at to given ostream. Returns given ostream.

Definition at line 43 of file dumper.cc.

References dumper().

Referenced by lestes::lang::cplus::syn::do_it(), lestes::lang::cplus::sem::dumb(), lestes::lang::cplus::sem::dump(), lestes::lang::cplus::sem::dung(), main(), lestes::lang::cplus::sem::run(), lestes::lang::cplus::syn::dump_context_at_lassert::run(), and lestes::lang::cplus::syn::dump_at_lassert::run().

00045 {
00046         ptr<dumper> instance = new dumper( output_to, respect_barriers );
00047         instance->the_dump(start_at);
00048         return output_to;
00049 }

void lestes::std::dumper::visit_object ( ptr< object > o ) [virtual]

Implements lestes::std::dumper_visitor.

Definition at line 51 of file dumper.cc.

References lassert, and was_simple.

00052 {
00053         lassert(o);
00054         was_simple = false;
00055 }

void lestes::std::dumper::visit_nodump ( ) [virtual]

Implements lestes::std::dumper_visitor.

Definition at line 57 of file dumper.cc.

References stream, and was_simple.

00058 {
00059         stream << "<nondumpable />";
00060         was_simple = true;
00061 }

void lestes::std::dumper::visit_lint ( lint ) [virtual]

Implements lestes::std::dumper_visitor.

Definition at line 63 of file dumper.cc.

References stream, and was_simple.

00064 {
00065         stream << "<simple type=\"lint\" value=\"" << i << "\" />";
00066         was_simple = true;
00067 }

void lestes::std::dumper::visit_ulint ( ulint ) [virtual]

Implements lestes::std::dumper_visitor.

Definition at line 69 of file dumper.cc.

References stream, and was_simple.

00070 {
00071         stream << "<simple type=\"ulint\" value=\"" << i << "\" />";
00072         was_simple = true;
00073 }

void lestes::std::dumper::visit_bool ( bool ) [virtual]

Implements lestes::std::dumper_visitor.

Definition at line 75 of file dumper.cc.

References stream, and was_simple.

00076 {
00077         // ostream does not seem to support bool (or vice versa?)
00078         stream << "<simple type=\"bool\" value=\"" << (i ? "true" : "false") << "\" />";
00079         was_simple = true;
00080 }

void lestes::std::dumper::visit_lstring ( const lstring & ) [virtual]

Implements lestes::std::dumper_visitor.

Definition at line 82 of file dumper.cc.

References stream, and was_simple.

00083 {
00084         lstring tmp(i);
00085         lstring sought("<>&");
00086         lstring lt("&lt;");
00087         lstring gt("&gt;");
00088         lstring amp("&amp;");
00089         lstring::size_type mark = tmp.find_first_of(sought);
00090         if (mark != lstring::npos)
00091                 do {
00092                         switch (tmp[mark]) {
00093                         case '<':
00094                                 tmp.replace(mark, 1, lt);
00095                                 break;
00096                         case '>':
00097                                 tmp.replace(mark, 1, gt);
00098                                 break;
00099                         case '&':
00100                                 tmp.replace(mark, 1, amp);
00101                                 break;
00102                         }
00103                 } while ((mark = tmp.find_first_of(sought, mark+1)) != lstring::npos);
00104         stream << "<simple type=\"lstring\" value=\"" << tmp << "\" />";
00105         was_simple = true;
00106 }

void lestes::std::dumper::visit_ucn_string ( const ucn_string & ) [virtual]

Implements lestes::std::dumper_visitor.

Definition at line 108 of file dumper.cc.

References stream, and was_simple.

00109 {
00110         ucn_string tmp(i);
00111         ucn_string sought("\x3c\x3e\x26");
00112         ucn_string lt("\x26\x6c\x74\x3b");
00113         ucn_string gt("\x26\x67\x74\x3b");
00114         ucn_string amp("\x26\x61\x6d\x70\x3b");
00115         ucn_string::size_type mark = tmp.find_first_of(sought);
00116         if (mark != ucn_string::npos)
00117                 do {
00118                         switch (tmp[mark]) {
00119                         case 0x3c:
00120                                 tmp.replace(mark, 1, lt);
00121                                 break;
00122                         case 0x3e:
00123                                 tmp.replace(mark, 1, gt);
00124                                 break;
00125                         case 0x26:
00126                                 tmp.replace(mark, 1, amp);
00127                                 break;
00128                         }
00129                 } while ((mark = tmp.find_first_of(sought, mark+1)) != ucn_string::npos);
00130         stream << "<simple type=\"ucn_string\" value=\"" << tmp << "\" />";
00131         was_simple = true;
00132 }

void lestes::std::dumper::try_enqueue	(	ptr< object >	o,
		ptr< queue_type >	queue,
		ptr< set_type >	visited
	)			`[private]`

enqueues o into queue, iff o was not yet visited

Definition at line 134 of file dumper.cc.

Referenced by the_dump().

00135 {
00136         bool not_yet_visited = visited->insert(o).second;
00137         if (not_yet_visited)
00138                 queue->push_back(o);
00139 }

void lestes::std::dumper::gc_mark ( void ) [protected, virtual]

Marks the keystone.

Marks all directly reachable parts of the class. The method must be overriden for each inherited class. It should contain abc.gc_mark() for each field abc of the inherited class and call to gc_mark() of the direct ancestor of the class. Does nothing for keystone, only stops processing of ancestors.

Reimplemented from lestes::std::mem::keystone.

Definition at line 141 of file dumper.cc.

References lestes::std::mem::keystone::gc_mark().

00142 {
00143         dumper_visitor::gc_mark();
00144 }

void lestes::std::dumper::the_dump ( ptr< object > start_at ) [protected]

Does the actual dumping. Has got to be a non-static method, as we are a visitor :).

Definition at line 150 of file dumper.cc.

References lestes::std::set< Key, Compare >::create(), lestes::std::list< T >::create(), lassert, respect_barriers, stream, try_enqueue(), and was_simple.

00151 {
00152         ptr<queue_type> queue = queue_type::create();
00153         ptr<set_type> visited = set_type::create();
00154 
00155         stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
00156                 "<dump xmlns=\"http://lestes.jikos.cz/schemas/dump\">" << endl;
00157         if (start_at) {
00158                 // if start_at is simple type, do not bother to run the algorithm :)
00159                 start_at->accept_dumper_visitor(this);
00160                 if (!was_simple) {
00161                         try_enqueue( start_at, queue, visited );
00162                 }
00163         } else {
00164                 stream << "<null />" << endl;
00165         }
00166         while ( !queue->empty() ) {
00167                 ptr<object> current = queue->front();
00168                 queue->pop_front();
00169                 // we do not enqueue null values
00170                 lassert(current);
00171 
00172                 bool at_barrier = current->dump_barrier_get();
00173 
00174                 ptr<reflection_list> refls = current->reflection_get();
00175                 lassert( refls );
00176 
00177                 stream << "<instance type=\"" << refls->back()->name_get() << "\""
00178                         " id=\"i_" << current->uid_get() << "\">" << endl;
00179                 ptr<field_list_list> fields = current->field_values_get();
00180                 field_list_list::iterator field_it = fields->begin();
00181                 for ( reflection_list::iterator refl_it = refls->begin();
00182                                 refl_it != refls->end(); ++refl_it ) {
00183 
00184                         ptr<class_reflection::field_metadata_list> metadata =
00185                                 (*refl_it)->field_metadata_get();
00186 
00187                         for (class_reflection::field_metadata_list::iterator
00188                                         meta_it = metadata->begin();
00189                                         meta_it != metadata->end();
00190                                         ++meta_it, ++field_it ) {
00191 
00192                                 // we must not run out of fields
00193                                 lassert( field_it != fields->end() );
00194 
00195                                 ulint item_no = 0;
00196                                 bool do_append_no = (*field_it)->size() > 1;
00197                                 for (value_list::iterator val_it = (*field_it)->begin();
00198                                                 val_it != (*field_it)->end();
00199                                                 ++val_it, ++item_no ) {
00200 
00201                                         stream << "<field name=\"" << (*meta_it)->first;
00202                                         if (do_append_no)
00203                                                 stream << item_no;
00204                                         stream << "\" type=\"" << (*meta_it)->second << "\""
00205                                                 " origin=\"" << (*refl_it)->name_get() << "\">";
00206                                         if (*val_it) {
00207                                                 (*val_it)->accept_dumper_visitor(this);
00208                                                 if (!was_simple) {
00209                                                         if (respect_barriers && at_barrier)
00210                                                                 stream << "<after-barrier />";
00211                                                         else {
00212                                                                 try_enqueue( *val_it, queue, visited );
00213                                                                 stream << "<pointer idref=\"i_" <<
00214                                                                         (*val_it)->uid_get() << "\" />";
00215                                                         }
00216                                                 }
00217                                         } else
00218                                                 stream << "<null />";
00219                                         stream << "</field>" << endl;
00220                                 }
00221                         }
00222                 }
00223 
00224                 // just an assert: there should not be any value lists left
00225                 lassert( field_it == fields->end() );
00226                 stream << "</instance>" << endl;
00227         };
00228         stream << "</dump>" << endl;
00229 }

bool lestes::std::dumper::was_simple [private]

return value from visit_XXX; null for simple_type visits

Definition at line 61 of file dumper.hh.

Referenced by the_dump(), visit_bool(), visit_lint(), visit_lstring(), visit_nodump(), visit_object(), visit_ucn_string(), and visit_ulint().

::std::ostream& lestes::std::dumper::stream [private]

Definition at line 62 of file dumper.hh.

Referenced by the_dump(), visit_bool(), visit_lint(), visit_lstring(), visit_nodump(), visit_ucn_string(), and visit_ulint().

const bool lestes::std::dumper::respect_barriers [private]

should the dumper respect barriers (see object::dump_barrier)

Definition at line 66 of file dumper.hh.

Referenced by the_dump().


Public Member Functions
virtual void	visit_object (ptr< object > o)
virtual void	visit_nodump ()
virtual void	visit_lint (lint)
virtual void	visit_ulint (ulint)
virtual void	visit_bool (bool)
virtual void	visit_lstring (const lstring &)
virtual void	visit_ucn_string (const ucn_string &)
Static Public Member Functions
::std::ostream &	dump (::std::ostream &output_to, ptr< object > start_at, bool respect_barriers=true)
	Dumps every instance reachable from start_at to given ostream. Returns given ostream.
Protected Member Functions
void	gc_mark ()
	Marks the keystone.
	dumper (::std::ostream &a_stream, bool a_respect_barriers)
void	the_dump (ptr< object > start_at)
	Does the actual dumping. Has got to be a non-static method, as we are a visitor :).
Private Types
typedef list< srp< object > >	queue_type
typedef set< srp< object > >	set_type
Private Member Functions
void	try_enqueue (ptr< object > o, ptr< queue_type > queue, ptr< set_type > visited)
	enqueues o into queue, iff o was not yet visited
Private Attributes
bool	was_simple
	return value from visit_XXX; null for simple_type visits
::std::ostream &	stream
const bool	respect_barriers
	should the dumper respect barriers (see object::dump_barrier)

lestes::std::dumper Class Reference

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation